many changes in preparation of automerge

Author: markusressel

internal/backend/automergesyncmanager.go

@@ -1,33 +1,30 @@
 package backend
 
 import (
-	"crypto/md5"
 	"errors"
 	"fmt"
 	automerge "github.com/automerge/automerge-go"
 	"github.com/gorilla/websocket"
-	"golang.org/x/text/encoding/unicode"
 	"log"
-	"strings"
 	mutexSync "sync"
 )
 
 type (
-	SyncStateRequest struct {
-		Type       string               `json:"type" xml:"type" form:"type" query:"type"`
-		RequestId  string               `json:"requestId" xml:"requestId" form:"requestId" query:"requestId"`
-		DocumentId string               `json:"documentId" xml:"documentId" form:"documentId" query:"documentId"`
-		SyncState  *automerge.SyncState `json:"syncState" xml:"syncState" form:"syncState" query:"syncState"`
+	SyncRequest struct {
+		Type       string                 `json:"type" xml:"type" form:"type" query:"type"`
+		RequestId  string                 `json:"requestId" xml:"requestId" form:"requestId" query:"requestId"`
+		DocumentId string                 `json:"documentId" xml:"documentId" form:"documentId" query:"documentId"`
+		SyncState  *automerge.SyncMessage `json:"syncState" xml:"syncState" form:"syncState" query:"syncState"`
 	}
 )
 
-// AutomergeSyncManager manages processing of EditRequests from clients
+// AutomergeSyncManager manages processing of SyncRequests from clients
 type AutomergeSyncManager struct {
 	treeManager                *TreeManager
 	websocketConnectionManager *WebsocketConnectionManager
 
-	// ServerShadows client connection -> server shadow
-	ServerShadows map[*websocket.Conn]string
+	// automergeDocuments client connection -> automerge.Doc
+	automergeDocuments map[*websocket.Conn]string
 
 	// lock for synchronizing the tree to the disk
 	lock mutexSync.RWMutex
@@ -36,12 +33,12 @@ type AutomergeSyncManager struct {
 func NewAutomergeSyncManager(
 	treeManager *TreeManager,
 ) *AutomergeSyncManager {
-	AutomergeSyncManager := &AutomergeSyncManager{
-		treeManager:   treeManager,
-		ServerShadows: make(map[*websocket.Conn]string),
+	s := &AutomergeSyncManager{
+		treeManager:        treeManager,
+		automergeDocuments: make(map[*websocket.Conn]string),
 	}
 
-	return AutomergeSyncManager
+	return s
 }
 
 func (sm *AutomergeSyncManager) IsItemBeingEditedRecursive(s *Section) (err error) {
@@ -63,53 +60,68 @@ func (sm *AutomergeSyncManager) IsItemBeingEditedRecursive(s *Section) (err erro
 
 // sets the initial server shadow for a new client connection
 func (sm *AutomergeSyncManager) initClient(conn *websocket.Conn, shadowContent string) {
-	sm.ServerShadows[conn] = shadowContent
+	sm.automergeDocuments[conn] = shadowContent
 }
 
 // removes the shadow for the given client
 func (sm *AutomergeSyncManager) removeClient(conn *websocket.Conn) {
-	delete(sm.ServerShadows, conn)
+	delete(sm.automergeDocuments, conn)
 }
 
-func (sm *AutomergeSyncManager) getDocument(documentId string) (err error) {
+func (sm *AutomergeSyncManager) getDocument(documentId string) (doc *automerge.Doc, err error) {
 	//doc, err := automerge.Load()
-	doc := automerge.New()
-	doc.
-		//NewText(documentId)
+	doc = automerge.New()
+	// doc.NewText(documentId)
 
-		text := doc.Path("collection").Text()
+	d := sm.treeManager.GetDocument(documentId)
+
+	text := doc.Path("content").Text()
+	err = text.Set(d.Content)
+	if err != nil {
+		return nil, err
+	}
+
+	return doc, err
 }
 
 // handles incoming edit requests from the client
-func (sm *AutomergeSyncManager) handleEditRequest(client *websocket.Conn, editRequest SyncStateRequest) (err error) {
-	documentId := editRequest.DocumentId
+func (sm *AutomergeSyncManager) handleSyncRequest(client *websocket.Conn, syncRequest SyncRequest) (err error) {
+	documentId := syncRequest.DocumentId
 
 	// get/create automerge document based on the document id
-	automergeDocument := getDocument(documentId)
-	// sm.ServerShadows[client]
+	automergeDocument, err := sm.getDocument(documentId)
+	if err != nil {
+		log.Printf("%v: error getting document: %v", client.RemoteAddr(), err)
+		return err
+	}
+	text := automergeDocument.Path("content").Text()
+	syncState := automerge.NewSyncState(automergeDocument)
+	// sm.automergeDocuments[client]
 
-	// apply patches to the automerge document
-	automergeDocument.ApplyChanges(editRequest.Patches)
+	_, err = syncState.ReceiveMessage(syncRequest.SyncState.Bytes())
+	if err != nil {
+		log.Printf("%v: error receiving sync state: %v", client.RemoteAddr(), err)
+		return err
+	}
 
-	// patch the server shadow
-	sm.ServerShadows[client], err = ApplyPatch(sm.ServerShadows[client], editRequest.Patches)
+	// apply patches to the automerge document
+	for _, change := range syncRequest.SyncState.Changes() {
+		err := automergeDocument.Apply(change)
+		if err != nil {
+			return err
+		}
+	}
 
 	// then patch the server document version
 	d := sm.treeManager.GetDocument(documentId)
-	patchedText, err := ApplyPatch(d.Content, editRequest.Patches)
-	if err != nil {
-		// if fuzzy patch fails, drop client changes
-		log.Printf("%v: fuzzy patch failed: %v", client.RemoteAddr(), err)
-		// reset err variable as we can recover from this error
-		err = nil
-	} else {
-		if d.Content != patchedText {
-			defer sm.saveCurrentDocumentContent(documentId)
-		}
-		d.Content = patchedText
+	patchedText := text.String()
+	if d.Content != patchedText {
+		// TODO: maybe we need to save the automerge documents here too?
+		defer sm.saveCurrentDocumentContent(documentId)
 	}
+	d.Content = patchedText
 
-	err = sm.sendEditRequestResponse(client, documentId)
+	err = sm.sendSyncRequestResponse(client, documentId)
 	if err != nil {
 		log.Printf("%v: error sending response: %v", client.RemoteAddr(), err)
 		return err
@@ -124,10 +136,9 @@ func (sm *AutomergeSyncManager) sendInitialTextResponse(client *websocket.Conn,
 	sm.initClient(client, document.Content)
 
 	automergeDocument := automerge.New()
+	syncState := automerge.NewSyncState(automergeDocument)
 
-	automergeText := automerge.NewText(document.Content)
-
-	documentContentText, err := automerge.As[*automerge.Text](automergeDocument.Root())
+	documentContentText, err := automerge.As[*automerge.Text](automergeDocument.RootMap().Get("content"))
 	if err != nil {
 		return err
 	}
@@ -138,21 +149,23 @@ func (sm *AutomergeSyncManager) sendInitialTextResponse(client *websocket.Conn,
 
 	commitMessage := "Initial commit"
 	commit, err := automergeDocument.Commit(commitMessage)
+	log.Printf("Commit: %v", commit)
 	if err != nil {
 		return err
 	}
-	serializedDocument := automergeDocument.Save()
 
-	syncState := automerge.NewSyncState(automergeDocument)
-	shadowChecksum := sm.calculateChecksum(document.Content)
+	syncStateMessage, valid := syncState.GenerateMessage()
+	if valid == false {
+		log.Printf("Error generating sync state message: %v", err)
+		return err
+	}
 
 	// Write current document state to the client
-	err = client.WriteJSON(SyncStateRequest{
-		Type:           TypeInitialContent,
-		DocumentId:     document.ID,
-		RequestId:      "",
-		SyncState:      syncState,
-		ShadowChecksum: shadowChecksum,
+	err = client.WriteJSON(SyncRequest{
+		Type:       TypeInitialContent,
+		DocumentId: document.ID,
+		RequestId:  "",
+		SyncState:  syncStateMessage,
 	})
 	if err != nil {
 		log.Printf("%v: error writing initial content response: %v", client.RemoteAddr(), err)
@@ -163,53 +176,32 @@ func (sm *AutomergeSyncManager) sendInitialTextResponse(client *websocket.Conn,
 }
 
 // responds to a client with the changes from the server site document version
-func (sm *AutomergeSyncManager) sendEditRequestResponse(client *websocket.Conn, documentId string) (err error) {
-	d := sm.treeManager.GetDocument(documentId)
-
-	shadow := sm.ServerShadows[client]
-	shadowChecksum := sm.calculateChecksum(shadow)
+func (sm *AutomergeSyncManager) sendSyncRequestResponse(client *websocket.Conn, documentId string) (err error) {
+	// d := sm.treeManager.GetDocument(documentId)
 
-	patches, err := CreatePatch(shadow, d.Content)
+	automergeDocument, err := sm.getDocument(documentId)
 	if err != nil {
-		log.Printf("Error creating patch: %v", err)
+		log.Printf("%v: error getting document: %v", client.RemoteAddr(), err)
 		return err
 	}
-	sm.ServerShadows[client] = d.Content
 
-	// we can skip this if there are no changes that need to be passed to the client
-	if len(patches) <= 0 {
-		return
+	syncState := automerge.NewSyncState(automergeDocument)
+	syncStateMessage, valid := syncState.GenerateMessage()
+	if valid == false {
+		log.Printf("Error generating sync state message: %v", err)
+		return err
 	}
 
-	return sm.websocketConnectionManager.sendToClient(client,
-		EditRequest{
-			Type:           TypeEditRequest,
-			RequestId:      "",
-			DocumentId:     documentId,
-			Patches:        patches,
-			ShadowChecksum: shadowChecksum,
+	return sm.websocketConnectionManager.syncStateToClient(
+		client,
+		SyncRequest{
+			Type:       TypeSyncRequest,
+			RequestId:  "",
+			DocumentId: documentId,
+			SyncState:  syncStateMessage,
 		})
 }
 
-// calculateChecksum calculates a checksum for a given text using the MD5 hashing algorithm.
-//
-// important notes for the implementation of this method:
-//   - the text that is hashed must be encoded using UTF-16LE without BOM
-//     this will ensure the bytes are the same on all clients
-//   - the checksum string must include leading zeros
-//   - all characters are lowercase
-func (sm *AutomergeSyncManager) calculateChecksum(text string) string {
-	encoder := unicode.UTF16(unicode.LittleEndian, unicode.IgnoreBOM).NewEncoder()
-	utf16, err := encoder.String(text)
-	if err != nil {
-		log.Printf("Error encoding String to UTF-16: %v", err)
-	}
-
-	hash := md5.Sum([]byte(utf16))
-	checksum := fmt.Sprintf("%02x", hash[:])
-	return strings.ToLower(checksum)
-}
-
 func (sm *AutomergeSyncManager) saveCurrentDocumentContent(documentId string) {
 	sm.lock.RLock()
 	defer sm.lock.RUnlock()
@@ -237,9 +229,9 @@ func (sm *AutomergeSyncManager) SetWebsocketConnectionManager(manager *Websocket
 		fmt.Println("New client connected", client)
 		return sm.sendInitialTextResponse(client, document)
 	})
-	sm.websocketConnectionManager.SetOnIncomingMessageListener(func(client *websocket.Conn, request EditRequest) error {
-		fmt.Println("Incoming message from client", client)
-		return sm.handleEditRequest(client, request)
+	sm.websocketConnectionManager.SetOnSyncRequestMessageListener(func(client *websocket.Conn, request SyncRequest) error {
+		fmt.Println("Incoming sync message from client", client)
+		return sm.handleSyncRequest(client, request)
 	})
 	sm.websocketConnectionManager.SetOnClientDisconnectedListener(func(client *websocket.Conn, documentId string, remainingConnections uint) {
 		fmt.Println("Client disconnected", client)

internal/backend/syncmanager.go

@@ -216,7 +216,7 @@ func (sm *SyncManager) SetWebsocketConnectionManager(manager *WebsocketConnectio
 		fmt.Println("New client connected", client)
 		return sm.sendInitialTextResponse(client, document)
 	})
-	sm.websocketConnectionManager.SetOnIncomingMessageListener(func(client *websocket.Conn, request EditRequest) error {
+	sm.websocketConnectionManager.SetOnIncomingEditRequestMessageListener(func(client *websocket.Conn, request EditRequest) error {
 		fmt.Println("Incoming message from client", client)
 		return sm.handleEditRequest(client, request)
 	})