379 lines
10 KiB
Go
379 lines
10 KiB
Go
package plaintextdocument
|
|
|
|
import (
|
|
"fmt"
|
|
"github.com/anytypeio/go-anytype-infrastructure-experiments/account"
|
|
"github.com/anytypeio/go-anytype-infrastructure-experiments/acltree"
|
|
"github.com/anytypeio/go-anytype-infrastructure-experiments/thread"
|
|
)
|
|
|
|
type PlainTextDocument struct {
|
|
heads []string
|
|
aclTree acltree.ACLTree
|
|
state *DocumentState
|
|
}
|
|
|
|
func (p *PlainTextDocument) Update(tree acltree.ACLTree) {
|
|
var err error
|
|
defer func() {
|
|
if err != nil {
|
|
fmt.Println("rebuild has returned error:", err)
|
|
}
|
|
}()
|
|
|
|
prevHeads := p.heads
|
|
p.heads = tree.Heads()
|
|
startId := prevHeads[0]
|
|
tree.IterateFrom(startId, func(change *acltree.Change) (isContinue bool) {
|
|
if change.Id == startId {
|
|
return true
|
|
}
|
|
if change.DecryptedDocumentChange != nil {
|
|
p.state, err = p.state.ApplyChange(change.DecryptedDocumentChange, change.Id)
|
|
if err != nil {
|
|
return false
|
|
}
|
|
}
|
|
return true
|
|
})
|
|
}
|
|
|
|
func (p *PlainTextDocument) Rebuild(tree acltree.ACLTree) {
|
|
p.heads = tree.Heads()
|
|
var startId string
|
|
var err error
|
|
defer func() {
|
|
if err != nil {
|
|
fmt.Println("rebuild has returned error:", err)
|
|
}
|
|
}()
|
|
|
|
rootChange := tree.Root()
|
|
|
|
if rootChange.DecryptedDocumentChange == nil {
|
|
err = fmt.Errorf("root doesn't have decrypted change")
|
|
return
|
|
}
|
|
|
|
state, err := BuildDocumentStateFromChange(rootChange.DecryptedDocumentChange, rootChange.Id)
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
startId = rootChange.Id
|
|
tree.Iterate(func(change *acltree.Change) (isContinue bool) {
|
|
if startId == change.Id {
|
|
return true
|
|
}
|
|
if change.DecryptedDocumentChange != nil {
|
|
state, err = state.ApplyChange(change.DecryptedDocumentChange, change.Id)
|
|
if err != nil {
|
|
return false
|
|
}
|
|
}
|
|
return true
|
|
})
|
|
if err != nil {
|
|
return
|
|
}
|
|
p.state = state
|
|
}
|
|
|
|
func NewPlainTextDocument(t thread.Thread, acc *account.AccountData) (*PlainTextDocument, error) {
|
|
tree, e
|
|
}
|
|
|
|
//
|
|
//type AccountData struct {
|
|
// Identity string
|
|
// SignKey threadmodels.SigningPrivKey
|
|
// EncKey threadmodels.EncryptionPrivKey
|
|
//}
|
|
//
|
|
//type Document struct {
|
|
// // TODO: ensure that every operation on Document is synchronized
|
|
// thread threadmodels.Thread
|
|
// stateProvider InitialStateProvider
|
|
// accountData *AccountData
|
|
// decoder threadmodels.SigningPubKeyDecoder
|
|
//
|
|
// treeBuilder *acltree.treeBuilder
|
|
// aclTreeBuilder *acltree.aclTreeBuilder
|
|
// aclStateBuilder *acltree.aclStateBuilder
|
|
// snapshotValidator *acltree.snapshotValidator
|
|
// docStateBuilder *acltree.documentStateBuilder
|
|
//
|
|
// docContext *acltree.documentContext
|
|
//}
|
|
//
|
|
//type UpdateResult int
|
|
//
|
|
//const (
|
|
// UpdateResultNoAction UpdateResult = iota
|
|
// UpdateResultAppend
|
|
// UpdateResultRebuild
|
|
//)
|
|
//
|
|
//type CreateChangePayload struct {
|
|
// ChangesData proto.Marshaler
|
|
// ACLData *pb.ACLChangeACLData
|
|
// Id string // TODO: this is just for testing, because id should be created automatically from content
|
|
//}
|
|
//
|
|
//func NewDocument(
|
|
// thread threadmodels.Thread,
|
|
// stateProvider InitialStateProvider,
|
|
// accountData *AccountData) *Document {
|
|
//
|
|
// decoder := threadmodels.NewEd25519Decoder()
|
|
// return &Document{
|
|
// thread: thread,
|
|
// stateProvider: stateProvider,
|
|
// accountData: accountData,
|
|
// decoder: decoder,
|
|
// aclTreeBuilder: acltree.newACLTreeBuilder(thread, decoder),
|
|
// treeBuilder: acltree.newTreeBuilder(thread, decoder),
|
|
// snapshotValidator: acltree.newSnapshotValidator(decoder, accountData),
|
|
// aclStateBuilder: acltree.newACLStateBuilder(decoder, accountData),
|
|
// docStateBuilder: acltree.newDocumentStateBuilder(stateProvider),
|
|
// docContext: &acltree.documentContext{},
|
|
// }
|
|
//}
|
|
//
|
|
////sync layer -> Object cache -> document -> Update (..raw changes)
|
|
////client layer -> Object cache -> document -> CreateChange(...)
|
|
////
|
|
//
|
|
//// smartblock -> CreateChange(payload)
|
|
//// SmartTree iterate etc
|
|
//func (d *Document) CreateChange(payload *CreateChangePayload) error {
|
|
// // TODO: add snapshot creation logic
|
|
// marshalled, err := payload.ChangesData.Marshal()
|
|
// if err != nil {
|
|
// return err
|
|
// }
|
|
//
|
|
// encrypted, err := d.docContext.aclState.userReadKeys[d.docContext.aclState.currentReadKeyHash].
|
|
// Encrypt(marshalled)
|
|
// if err != nil {
|
|
// return err
|
|
// }
|
|
//
|
|
// aclChange := &pb.ACLChange{
|
|
// TreeHeadIds: d.docContext.fullTree.Heads(),
|
|
// AclHeadIds: d.getACLHeads(),
|
|
// SnapshotBaseId: d.docContext.fullTree.RootId(),
|
|
// AclData: payload.ACLData,
|
|
// ChangesData: encrypted,
|
|
// CurrentReadKeyHash: d.docContext.aclState.currentReadKeyHash,
|
|
// Timestamp: 0,
|
|
// Identity: d.accountData.Identity,
|
|
// }
|
|
//
|
|
// // TODO: add CID creation logic based on content
|
|
// ch := acltree.NewChange(payload.Id, aclChange)
|
|
// ch.DecryptedDocumentChange = marshalled
|
|
//
|
|
// fullMarshalledChange, err := proto.Marshal(aclChange)
|
|
// if err != nil {
|
|
// return err
|
|
// }
|
|
// signature, err := d.accountData.SignKey.Sign(fullMarshalledChange)
|
|
// if err != nil {
|
|
// return err
|
|
// }
|
|
//
|
|
// if aclChange.AclData != nil {
|
|
// // we can apply change right away without going through builder, because
|
|
// err = d.docContext.aclState.ApplyChange(payload.Id, aclChange)
|
|
// if err != nil {
|
|
// return err
|
|
// }
|
|
// }
|
|
// d.docContext.fullTree.AddFast(ch)
|
|
//
|
|
// err = d.thread.AddChange(&thread.RawChange{
|
|
// Payload: marshalled,
|
|
// Signature: signature,
|
|
// Id: payload.Id,
|
|
// })
|
|
// if err != nil {
|
|
// return err
|
|
// }
|
|
//
|
|
// d.thread.SetHeads([]string{ch.Id})
|
|
// d.thread.SetMaybeHeads([]string{ch.Id})
|
|
//
|
|
// return nil
|
|
//}
|
|
//
|
|
//func (d *Document) Update(changes ...*thread.RawChange) (DocumentState, UpdateResult, error) {
|
|
// var treeChanges []*acltree.Change
|
|
//
|
|
// var foundACLChange bool
|
|
// for _, ch := range changes {
|
|
// aclChange, err := d.treeBuilder.makeVerifiedACLChange(ch)
|
|
// if err != nil {
|
|
// return nil, UpdateResultNoAction, fmt.Errorf("change with id %s is incorrect: %w", ch.Id, err)
|
|
// }
|
|
//
|
|
// treeChange := d.treeBuilder.changeCreator(ch.Id, aclChange)
|
|
// treeChanges = append(treeChanges, treeChange)
|
|
//
|
|
// // this already sets PossibleHeads to include new changes
|
|
// // TODO: change this behaviour as non-obvious, because it is not evident from the interface
|
|
// err = d.thread.AddChange(ch)
|
|
// if err != nil {
|
|
// return nil, UpdateResultNoAction, fmt.Errorf("change with id %s cannot be added: %w", ch.Id, err)
|
|
// }
|
|
// if treeChange.IsACLChange() {
|
|
// foundACLChange = true
|
|
// }
|
|
// }
|
|
//
|
|
// if foundACLChange {
|
|
// res, err := d.Build()
|
|
// return res, UpdateResultRebuild, err
|
|
// }
|
|
//
|
|
// prevHeads := d.docContext.fullTree.Heads()
|
|
// mode := d.docContext.fullTree.Add(treeChanges...)
|
|
// switch mode {
|
|
// case acltree.Nothing:
|
|
// return d.docContext.docState, UpdateResultNoAction, nil
|
|
// case acltree.Rebuild:
|
|
// res, err := d.Build()
|
|
// return res, UpdateResultRebuild, err
|
|
// default:
|
|
// break
|
|
// }
|
|
//
|
|
// // TODO: we should still check if the user making those changes are able to write using "aclState"
|
|
// // decrypting everything, because we have no new keys
|
|
// for _, ch := range treeChanges {
|
|
// if ch.Content.GetChangesData() != nil {
|
|
// key, exists := d.docContext.aclState.userReadKeys[ch.Content.CurrentReadKeyHash]
|
|
// if !exists {
|
|
// err := fmt.Errorf("failed to find key with hash: %d", ch.Content.CurrentReadKeyHash)
|
|
// return nil, UpdateResultNoAction, err
|
|
// }
|
|
//
|
|
// err := ch.DecryptContents(key)
|
|
// if err != nil {
|
|
// err = fmt.Errorf("failed to decrypt contents for hash: %d", ch.Content.CurrentReadKeyHash)
|
|
// return nil, UpdateResultNoAction, err
|
|
// }
|
|
// }
|
|
// }
|
|
//
|
|
// // because for every new change we know it was after any of the previous heads
|
|
// // each of previous heads must have same "Next" nodes
|
|
// // so it doesn't matter which one we choose
|
|
// // so we choose first one
|
|
// newState, err := d.docStateBuilder.appendFrom(prevHeads[0], d.docContext.docState)
|
|
// if err != nil {
|
|
// res, _ := d.Build()
|
|
// return res, UpdateResultRebuild, fmt.Errorf("could not add changes to state, rebuilded")
|
|
// }
|
|
//
|
|
// // setting all heads
|
|
// d.thread.SetHeads(d.docContext.fullTree.Heads())
|
|
// // this should be the entrypoint when we build the document
|
|
// d.thread.SetMaybeHeads(d.docContext.fullTree.Heads())
|
|
//
|
|
// return newState, UpdateResultAppend, nil
|
|
//}
|
|
//
|
|
//func (d *Document) Build() (DocumentState, error) {
|
|
// return d.build(false)
|
|
//}
|
|
//
|
|
//// TODO: this should not be the responsibility of Document, move it somewhere else after testing
|
|
//func (d *Document) getACLHeads() []string {
|
|
// var aclTreeHeads []string
|
|
// for _, head := range d.docContext.fullTree.Heads() {
|
|
// if slice.FindPos(aclTreeHeads, head) != -1 { // do not scan known heads
|
|
// continue
|
|
// }
|
|
// precedingHeads := d.getPrecedingACLHeads(head)
|
|
//
|
|
// for _, aclHead := range precedingHeads {
|
|
// if slice.FindPos(aclTreeHeads, aclHead) != -1 {
|
|
// continue
|
|
// }
|
|
// aclTreeHeads = append(aclTreeHeads, aclHead)
|
|
// }
|
|
// }
|
|
// return aclTreeHeads
|
|
//}
|
|
//
|
|
//func (d *Document) getPrecedingACLHeads(head string) []string {
|
|
// headChange := d.docContext.fullTree.attached[head]
|
|
//
|
|
// if headChange.Content.GetAclData() != nil {
|
|
// return []string{head}
|
|
// } else {
|
|
// return headChange.Content.AclHeadIds
|
|
// }
|
|
//}
|
|
//
|
|
//func (d *Document) build(fromStart bool) (DocumentState, error) {
|
|
// d.treeBuilder.init()
|
|
// d.aclTreeBuilder.init()
|
|
//
|
|
// var err error
|
|
// d.docContext.fullTree, err = d.treeBuilder.build(fromStart)
|
|
// if err != nil {
|
|
// return nil, err
|
|
// }
|
|
//
|
|
// // TODO: remove this from context as this is used only to validate snapshot
|
|
// d.docContext.aclTree, err = d.aclTreeBuilder.build()
|
|
// if err != nil {
|
|
// return nil, err
|
|
// }
|
|
//
|
|
// if !fromStart {
|
|
// err = d.snapshotValidator.init(d.docContext.aclTree)
|
|
// if err != nil {
|
|
// return nil, err
|
|
// }
|
|
//
|
|
// valid, err := d.snapshotValidator.validateSnapshot(d.docContext.fullTree.root)
|
|
// if err != nil {
|
|
// return nil, err
|
|
// }
|
|
// if !valid {
|
|
// return d.build(true)
|
|
// }
|
|
// }
|
|
// err = d.aclStateBuilder.init(d.docContext.fullTree)
|
|
// if err != nil {
|
|
// return nil, err
|
|
// }
|
|
//
|
|
// d.docContext.aclState, err = d.aclStateBuilder.build()
|
|
// if err != nil {
|
|
// return nil, err
|
|
// }
|
|
//
|
|
// // tree should be exposed
|
|
//
|
|
// d.docStateBuilder.init(d.docContext.aclState, d.docContext.fullTree)
|
|
// d.docContext.docState, err = d.docStateBuilder.build()
|
|
// if err != nil {
|
|
// return nil, err
|
|
// }
|
|
//
|
|
// // setting all heads
|
|
// d.thread.SetHeads(d.docContext.fullTree.Heads())
|
|
// // this should be the entrypoint when we build the document
|
|
// d.thread.SetMaybeHeads(d.docContext.fullTree.Heads())
|
|
//
|
|
// return d.docContext.docState, nil
|
|
//}
|
|
//
|
|
//func (d *Document) State() DocumentState {
|
|
// return nil
|
|
//}
|