khenaidoo | bf6e7bb | 2018-08-14 22:27:29 -0400 | [diff] [blame] | 1 | /* |
| 2 | * Copyright 2018-present Open Networking Foundation |
| 3 | |
| 4 | * Licensed under the Apache License, Version 2.0 (the "License"); |
| 5 | * you may not use this file except in compliance with the License. |
| 6 | * You may obtain a copy of the License at |
| 7 | |
| 8 | * http://www.apache.org/licenses/LICENSE-2.0 |
| 9 | |
| 10 | * Unless required by applicable law or agreed to in writing, software |
| 11 | * distributed under the License is distributed on an "AS IS" BASIS, |
| 12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| 13 | * See the License for the specific language governing permissions and |
| 14 | * limitations under the License. |
| 15 | */ |
Stephane Barbarie | 4a2564d | 2018-07-26 11:02:58 -0400 | [diff] [blame] | 16 | package model |
| 17 | |
Stephane Barbarie | e16186c | 2018-09-11 10:46:34 -0400 | [diff] [blame] | 18 | // TODO: proper error handling |
| 19 | // TODO: proper logging |
| 20 | |
Stephane Barbarie | 4a2564d | 2018-07-26 11:02:58 -0400 | [diff] [blame] | 21 | import ( |
| 22 | "fmt" |
| 23 | "github.com/golang/protobuf/proto" |
Stephane Barbarie | ec0919b | 2018-09-05 14:14:29 -0400 | [diff] [blame] | 24 | "github.com/opencord/voltha-go/common/log" |
Stephane Barbarie | 4a2564d | 2018-07-26 11:02:58 -0400 | [diff] [blame] | 25 | "reflect" |
| 26 | "strings" |
| 27 | ) |
| 28 | |
| 29 | const ( |
| 30 | NONE string = "none" |
| 31 | ) |
| 32 | |
Stephane Barbarie | 06c4a74 | 2018-10-01 11:09:32 -0400 | [diff] [blame] | 33 | type Node interface { |
| 34 | MakeLatest(branch *Branch, revision Revision, changeAnnouncement []ChangeTuple) |
| 35 | |
| 36 | // CRUD functions |
| 37 | Add(path string, data interface{}, txid string, makeBranch MakeBranchFunction) Revision |
| 38 | Get(path string, hash string, depth int, deep bool, txid string) interface{} |
| 39 | Update(path string, data interface{}, strict bool, txid string, makeBranch MakeBranchFunction) Revision |
| 40 | Remove(path string, txid string, makeBranch MakeBranchFunction) Revision |
| 41 | |
| 42 | MakeBranch(txid string) *Branch |
| 43 | DeleteBranch(txid string) |
| 44 | MergeBranch(txid string, dryRun bool) (Revision, error) |
| 45 | |
| 46 | MakeTxBranch() string |
| 47 | DeleteTxBranch(txid string) |
| 48 | FoldTxBranch(txid string) |
| 49 | |
| 50 | GetProxy(path string, exclusive bool) *Proxy |
Stephane Barbarie | 126101e | 2018-10-11 16:18:48 -0400 | [diff] [blame^] | 51 | |
| 52 | ExecuteCallbacks() |
| 53 | AddCallback(callback CallbackFunction, args ...interface{}) |
| 54 | AddNotificationCallback(callback CallbackFunction, args ...interface{}) |
Stephane Barbarie | 06c4a74 | 2018-10-01 11:09:32 -0400 | [diff] [blame] | 55 | } |
| 56 | |
| 57 | type node struct { |
Stephane Barbarie | 126101e | 2018-10-11 16:18:48 -0400 | [diff] [blame^] | 58 | Root *root |
Stephane Barbarie | 4a2564d | 2018-07-26 11:02:58 -0400 | [diff] [blame] | 59 | Type interface{} |
| 60 | Branches map[string]*Branch |
Stephane Barbarie | ec0919b | 2018-09-05 14:14:29 -0400 | [diff] [blame] | 61 | Tags map[string]Revision |
Stephane Barbarie | 4a2564d | 2018-07-26 11:02:58 -0400 | [diff] [blame] | 62 | Proxy *Proxy |
| 63 | EventBus *EventBus |
| 64 | AutoPrune bool |
| 65 | } |
| 66 | |
Stephane Barbarie | 694e2b9 | 2018-09-07 12:17:36 -0400 | [diff] [blame] | 67 | type ChangeTuple struct { |
Stephane Barbarie | 8c48b5c | 2018-10-02 09:45:17 -0400 | [diff] [blame] | 68 | Type CallbackType |
| 69 | PreviousData interface{} |
| 70 | LatestData interface{} |
Stephane Barbarie | 694e2b9 | 2018-09-07 12:17:36 -0400 | [diff] [blame] | 71 | } |
| 72 | |
Stephane Barbarie | 06c4a74 | 2018-10-01 11:09:32 -0400 | [diff] [blame] | 73 | func NewNode(root *root, initialData interface{}, autoPrune bool, txid string) *node { |
| 74 | n := &node{} |
Stephane Barbarie | 4a2564d | 2018-07-26 11:02:58 -0400 | [diff] [blame] | 75 | |
Stephane Barbarie | 126101e | 2018-10-11 16:18:48 -0400 | [diff] [blame^] | 76 | n.Root = root |
Stephane Barbarie | ec0919b | 2018-09-05 14:14:29 -0400 | [diff] [blame] | 77 | n.Branches = make(map[string]*Branch) |
| 78 | n.Tags = make(map[string]Revision) |
| 79 | n.Proxy = nil |
| 80 | n.EventBus = nil |
| 81 | n.AutoPrune = autoPrune |
Stephane Barbarie | 4a2564d | 2018-07-26 11:02:58 -0400 | [diff] [blame] | 82 | |
| 83 | if IsProtoMessage(initialData) { |
Stephane Barbarie | ec0919b | 2018-09-05 14:14:29 -0400 | [diff] [blame] | 84 | n.Type = reflect.ValueOf(initialData).Interface() |
Stephane Barbarie | 4a2564d | 2018-07-26 11:02:58 -0400 | [diff] [blame] | 85 | dataCopy := proto.Clone(initialData.(proto.Message)) |
Stephane Barbarie | ec0919b | 2018-09-05 14:14:29 -0400 | [diff] [blame] | 86 | n.initialize(dataCopy, txid) |
Stephane Barbarie | 4a2564d | 2018-07-26 11:02:58 -0400 | [diff] [blame] | 87 | } else if reflect.ValueOf(initialData).IsValid() { |
Stephane Barbarie | ec0919b | 2018-09-05 14:14:29 -0400 | [diff] [blame] | 88 | n.Type = reflect.ValueOf(initialData).Interface() |
Stephane Barbarie | 4a2564d | 2018-07-26 11:02:58 -0400 | [diff] [blame] | 89 | } else { |
| 90 | // not implemented error |
Stephane Barbarie | 8c48b5c | 2018-10-02 09:45:17 -0400 | [diff] [blame] | 91 | log.Errorf("cannot process initial data - %+v", initialData) |
Stephane Barbarie | 4a2564d | 2018-07-26 11:02:58 -0400 | [diff] [blame] | 92 | } |
| 93 | |
Stephane Barbarie | ec0919b | 2018-09-05 14:14:29 -0400 | [diff] [blame] | 94 | return n |
Stephane Barbarie | 4a2564d | 2018-07-26 11:02:58 -0400 | [diff] [blame] | 95 | } |
| 96 | |
Stephane Barbarie | 06c4a74 | 2018-10-01 11:09:32 -0400 | [diff] [blame] | 97 | func (n *node) MakeNode(data interface{}, txid string) *node { |
Stephane Barbarie | 126101e | 2018-10-11 16:18:48 -0400 | [diff] [blame^] | 98 | return NewNode(n.Root, data, true, txid) |
Stephane Barbarie | 4a2564d | 2018-07-26 11:02:58 -0400 | [diff] [blame] | 99 | } |
| 100 | |
Stephane Barbarie | 06c4a74 | 2018-10-01 11:09:32 -0400 | [diff] [blame] | 101 | func (n *node) MakeRevision(branch *Branch, data interface{}, children map[string][]Revision) Revision { |
Stephane Barbarie | 126101e | 2018-10-11 16:18:48 -0400 | [diff] [blame^] | 102 | if n.Root.RevisionClass.(reflect.Type) == reflect.TypeOf(PersistedRevision{}) { |
| 103 | return NewPersistedRevision(branch, data, children) |
| 104 | } |
| 105 | |
| 106 | return NewNonPersistedRevision(branch, data, children) |
Stephane Barbarie | 4a2564d | 2018-07-26 11:02:58 -0400 | [diff] [blame] | 107 | } |
| 108 | |
Stephane Barbarie | 06c4a74 | 2018-10-01 11:09:32 -0400 | [diff] [blame] | 109 | func (n *node) MakeLatest(branch *Branch, revision Revision, changeAnnouncement []ChangeTuple) { |
| 110 | n.makeLatest(branch, revision, changeAnnouncement) |
| 111 | } |
| 112 | func (n *node) makeLatest(branch *Branch, revision Revision, changeAnnouncement []ChangeTuple) { |
Stephane Barbarie | ec0919b | 2018-09-05 14:14:29 -0400 | [diff] [blame] | 113 | if _, ok := branch.Revisions[revision.GetHash()]; !ok { |
| 114 | branch.Revisions[revision.GetHash()] = revision |
Stephane Barbarie | 4a2564d | 2018-07-26 11:02:58 -0400 | [diff] [blame] | 115 | } |
| 116 | |
Stephane Barbarie | ec0919b | 2018-09-05 14:14:29 -0400 | [diff] [blame] | 117 | if branch.Latest == nil || revision.GetHash() != branch.Latest.GetHash() { |
Stephane Barbarie | 4a2564d | 2018-07-26 11:02:58 -0400 | [diff] [blame] | 118 | branch.Latest = revision |
| 119 | } |
| 120 | |
| 121 | if changeAnnouncement != nil && branch.Txid == "" { |
Stephane Barbarie | ec0919b | 2018-09-05 14:14:29 -0400 | [diff] [blame] | 122 | if n.Proxy != nil { |
Stephane Barbarie | 694e2b9 | 2018-09-07 12:17:36 -0400 | [diff] [blame] | 123 | for _, change := range changeAnnouncement { |
Stephane Barbarie | 126101e | 2018-10-11 16:18:48 -0400 | [diff] [blame^] | 124 | log.Debugf("invoking callback - changeType: %+v, previous:%+v, latest: %+v", |
| 125 | change.Type, |
| 126 | change.PreviousData, |
| 127 | change.LatestData) |
| 128 | n.Root.AddCallback( |
| 129 | n.Proxy.InvokeCallbacks, |
| 130 | change.Type, |
| 131 | true, |
| 132 | change.PreviousData, |
| 133 | change.LatestData) |
Stephane Barbarie | 4a2564d | 2018-07-26 11:02:58 -0400 | [diff] [blame] | 134 | } |
| 135 | } |
| 136 | |
Stephane Barbarie | 694e2b9 | 2018-09-07 12:17:36 -0400 | [diff] [blame] | 137 | for _, change := range changeAnnouncement { |
Stephane Barbarie | 126101e | 2018-10-11 16:18:48 -0400 | [diff] [blame^] | 138 | log.Debugf("sending notification - changeType: %+v, previous:%+v, latest: %+v", |
| 139 | change.Type, |
Stephane Barbarie | 8c48b5c | 2018-10-02 09:45:17 -0400 | [diff] [blame] | 140 | change.PreviousData, |
| 141 | change.LatestData) |
Stephane Barbarie | 126101e | 2018-10-11 16:18:48 -0400 | [diff] [blame^] | 142 | n.Root.AddNotificationCallback( |
| 143 | n.makeEventBus().Advertise, |
| 144 | change.Type, |
| 145 | revision.GetHash(), |
| 146 | change.PreviousData, |
| 147 | change.LatestData) |
Stephane Barbarie | 4a2564d | 2018-07-26 11:02:58 -0400 | [diff] [blame] | 148 | } |
| 149 | } |
| 150 | } |
| 151 | |
Stephane Barbarie | 06c4a74 | 2018-10-01 11:09:32 -0400 | [diff] [blame] | 152 | func (n *node) Latest(txid ...string) Revision { |
Stephane Barbarie | 88fbe7f | 2018-09-25 12:25:23 -0400 | [diff] [blame] | 153 | var branch *Branch |
| 154 | var exists bool |
| 155 | |
| 156 | if len(txid) > 0 && txid[0] != "" { |
| 157 | if branch, exists = n.Branches[txid[0]]; exists { |
| 158 | return branch.Latest |
| 159 | } |
| 160 | } else if branch, exists = n.Branches[NONE]; exists { |
Stephane Barbarie | 4a2564d | 2018-07-26 11:02:58 -0400 | [diff] [blame] | 161 | return branch.Latest |
| 162 | } |
| 163 | return nil |
| 164 | } |
| 165 | |
Stephane Barbarie | 06c4a74 | 2018-10-01 11:09:32 -0400 | [diff] [blame] | 166 | func (n *node) GetHash(hash string) Revision { |
Stephane Barbarie | ec0919b | 2018-09-05 14:14:29 -0400 | [diff] [blame] | 167 | return n.Branches[NONE].Revisions[hash] |
Stephane Barbarie | 4a2564d | 2018-07-26 11:02:58 -0400 | [diff] [blame] | 168 | } |
| 169 | |
Stephane Barbarie | 06c4a74 | 2018-10-01 11:09:32 -0400 | [diff] [blame] | 170 | func (n *node) initialize(data interface{}, txid string) { |
Stephane Barbarie | ec0919b | 2018-09-05 14:14:29 -0400 | [diff] [blame] | 171 | var children map[string][]Revision |
| 172 | children = make(map[string][]Revision) |
| 173 | for fieldName, field := range ChildrenFields(n.Type) { |
| 174 | _, fieldValue := GetAttributeValue(data, fieldName, 0) |
Stephane Barbarie | 4a2564d | 2018-07-26 11:02:58 -0400 | [diff] [blame] | 175 | |
| 176 | if fieldValue.IsValid() { |
| 177 | if field.IsContainer { |
| 178 | if field.Key != "" { |
| 179 | var keysSeen []string |
| 180 | |
| 181 | for i := 0; i < fieldValue.Len(); i++ { |
| 182 | v := fieldValue.Index(i) |
Stephane Barbarie | 88fbe7f | 2018-09-25 12:25:23 -0400 | [diff] [blame] | 183 | |
| 184 | rev := n.MakeNode(v.Interface(), txid).Latest(txid) |
| 185 | |
Stephane Barbarie | ec0919b | 2018-09-05 14:14:29 -0400 | [diff] [blame] | 186 | _, key := GetAttributeValue(v.Interface(), field.Key, 0) |
Stephane Barbarie | 4a2564d | 2018-07-26 11:02:58 -0400 | [diff] [blame] | 187 | for _, k := range keysSeen { |
| 188 | if k == key.String() { |
Stephane Barbarie | 8c48b5c | 2018-10-02 09:45:17 -0400 | [diff] [blame] | 189 | log.Errorf("duplicate key - %s", k) |
Stephane Barbarie | 4a2564d | 2018-07-26 11:02:58 -0400 | [diff] [blame] | 190 | } |
| 191 | } |
| 192 | children[fieldName] = append(children[fieldName], rev) |
| 193 | keysSeen = append(keysSeen, key.String()) |
| 194 | } |
| 195 | |
| 196 | } else { |
| 197 | for i := 0; i < fieldValue.Len(); i++ { |
| 198 | v := fieldValue.Index(i) |
Stephane Barbarie | ec0919b | 2018-09-05 14:14:29 -0400 | [diff] [blame] | 199 | children[fieldName] = append(children[fieldName], n.MakeNode(v.Interface(), txid).Latest()) |
Stephane Barbarie | 4a2564d | 2018-07-26 11:02:58 -0400 | [diff] [blame] | 200 | } |
| 201 | } |
| 202 | } else { |
Stephane Barbarie | ec0919b | 2018-09-05 14:14:29 -0400 | [diff] [blame] | 203 | children[fieldName] = append(children[fieldName], n.MakeNode(fieldValue.Interface(), txid).Latest()) |
Stephane Barbarie | 4a2564d | 2018-07-26 11:02:58 -0400 | [diff] [blame] | 204 | } |
| 205 | } else { |
Stephane Barbarie | 8c48b5c | 2018-10-02 09:45:17 -0400 | [diff] [blame] | 206 | log.Errorf("field is invalid - %+v", fieldValue) |
Stephane Barbarie | 4a2564d | 2018-07-26 11:02:58 -0400 | [diff] [blame] | 207 | } |
| 208 | } |
| 209 | // FIXME: ClearField??? No such method in go protos. Reset? |
| 210 | //data.ClearField(field_name) |
Stephane Barbarie | ec0919b | 2018-09-05 14:14:29 -0400 | [diff] [blame] | 211 | branch := NewBranch(n, "", nil, n.AutoPrune) |
| 212 | rev := n.MakeRevision(branch, data, children) |
Stephane Barbarie | 06c4a74 | 2018-10-01 11:09:32 -0400 | [diff] [blame] | 213 | n.makeLatest(branch, rev, nil) |
Stephane Barbarie | 4a2564d | 2018-07-26 11:02:58 -0400 | [diff] [blame] | 214 | |
Stephane Barbarie | ec0919b | 2018-09-05 14:14:29 -0400 | [diff] [blame] | 215 | if txid == "" { |
| 216 | n.Branches[NONE] = branch |
| 217 | } else { |
| 218 | n.Branches[txid] = branch |
| 219 | } |
Stephane Barbarie | 4a2564d | 2018-07-26 11:02:58 -0400 | [diff] [blame] | 220 | } |
| 221 | |
Stephane Barbarie | 06c4a74 | 2018-10-01 11:09:32 -0400 | [diff] [blame] | 222 | func (n *node) findRevByKey(revs []Revision, keyName string, value interface{}) (int, Revision) { |
| 223 | for i, rev := range revs { |
| 224 | dataValue := reflect.ValueOf(rev.GetData()) |
| 225 | dataStruct := GetAttributeStructure(rev.GetData(), keyName, 0) |
| 226 | |
| 227 | fieldValue := dataValue.Elem().FieldByName(dataStruct.Name) |
| 228 | |
Stephane Barbarie | 126101e | 2018-10-11 16:18:48 -0400 | [diff] [blame^] | 229 | //log.Debugf("fieldValue: %+v, type: %+v, value: %+v", fieldValue.Interface(), fieldValue.Type(), value) |
Stephane Barbarie | 06c4a74 | 2018-10-01 11:09:32 -0400 | [diff] [blame] | 230 | a := fmt.Sprintf("%s", fieldValue.Interface()) |
| 231 | b := fmt.Sprintf("%s", value) |
| 232 | if a == b { |
| 233 | return i, rev |
| 234 | } |
| 235 | } |
| 236 | |
Stephane Barbarie | 8c48b5c | 2018-10-02 09:45:17 -0400 | [diff] [blame] | 237 | log.Errorf("key %s=%s not found", keyName, value) |
Stephane Barbarie | 06c4a74 | 2018-10-01 11:09:32 -0400 | [diff] [blame] | 238 | |
| 239 | return -1, nil |
| 240 | } |
| 241 | |
Stephane Barbarie | 4a2564d | 2018-07-26 11:02:58 -0400 | [diff] [blame] | 242 | // |
| 243 | // Get operation |
| 244 | // |
Stephane Barbarie | 06c4a74 | 2018-10-01 11:09:32 -0400 | [diff] [blame] | 245 | func (n *node) Get(path string, hash string, depth int, deep bool, txid string) interface{} { |
Stephane Barbarie | 4a2564d | 2018-07-26 11:02:58 -0400 | [diff] [blame] | 246 | if deep { |
| 247 | depth = -1 |
| 248 | } |
| 249 | |
| 250 | for strings.HasPrefix(path, "/") { |
| 251 | path = path[1:] |
| 252 | } |
| 253 | |
| 254 | var branch *Branch |
Stephane Barbarie | ec0919b | 2018-09-05 14:14:29 -0400 | [diff] [blame] | 255 | var rev Revision |
Stephane Barbarie | 4a2564d | 2018-07-26 11:02:58 -0400 | [diff] [blame] | 256 | |
| 257 | // FIXME: should empty txid be cleaned up? |
Stephane Barbarie | ec0919b | 2018-09-05 14:14:29 -0400 | [diff] [blame] | 258 | if branch = n.Branches[txid]; txid == "" || branch == nil { |
| 259 | branch = n.Branches[NONE] |
Stephane Barbarie | 4a2564d | 2018-07-26 11:02:58 -0400 | [diff] [blame] | 260 | } |
| 261 | |
| 262 | if hash != "" { |
Stephane Barbarie | ec0919b | 2018-09-05 14:14:29 -0400 | [diff] [blame] | 263 | rev = branch.Revisions[hash] |
Stephane Barbarie | 4a2564d | 2018-07-26 11:02:58 -0400 | [diff] [blame] | 264 | } else { |
| 265 | rev = branch.Latest |
| 266 | } |
| 267 | |
Stephane Barbarie | 06c4a74 | 2018-10-01 11:09:32 -0400 | [diff] [blame] | 268 | return n.getPath(rev, path, depth) |
Stephane Barbarie | 4a2564d | 2018-07-26 11:02:58 -0400 | [diff] [blame] | 269 | } |
| 270 | |
Stephane Barbarie | 06c4a74 | 2018-10-01 11:09:32 -0400 | [diff] [blame] | 271 | func (n *node) getPath(rev Revision, path string, depth int) interface{} { |
Stephane Barbarie | 4a2564d | 2018-07-26 11:02:58 -0400 | [diff] [blame] | 272 | if path == "" { |
Stephane Barbarie | 06c4a74 | 2018-10-01 11:09:32 -0400 | [diff] [blame] | 273 | return n.getData(rev, depth) |
Stephane Barbarie | 4a2564d | 2018-07-26 11:02:58 -0400 | [diff] [blame] | 274 | } |
| 275 | |
| 276 | partition := strings.SplitN(path, "/", 2) |
| 277 | name := partition[0] |
Stephane Barbarie | 4a2564d | 2018-07-26 11:02:58 -0400 | [diff] [blame] | 278 | |
Stephane Barbarie | ec0919b | 2018-09-05 14:14:29 -0400 | [diff] [blame] | 279 | if len(partition) < 2 { |
| 280 | path = "" |
| 281 | } else { |
| 282 | path = partition[1] |
| 283 | } |
Stephane Barbarie | 4a2564d | 2018-07-26 11:02:58 -0400 | [diff] [blame] | 284 | |
Stephane Barbarie | ec0919b | 2018-09-05 14:14:29 -0400 | [diff] [blame] | 285 | names := ChildrenFields(n.Type) |
| 286 | field := names[name] |
| 287 | |
Stephane Barbarie | 06c4a74 | 2018-10-01 11:09:32 -0400 | [diff] [blame] | 288 | if field.IsContainer { |
Stephane Barbarie | 4a2564d | 2018-07-26 11:02:58 -0400 | [diff] [blame] | 289 | if field.Key != "" { |
Stephane Barbarie | ec0919b | 2018-09-05 14:14:29 -0400 | [diff] [blame] | 290 | children := rev.GetChildren()[name] |
Stephane Barbarie | 4a2564d | 2018-07-26 11:02:58 -0400 | [diff] [blame] | 291 | if path != "" { |
| 292 | partition = strings.SplitN(path, "/", 2) |
| 293 | key := partition[0] |
| 294 | path = "" |
Stephane Barbarie | 06c4a74 | 2018-10-01 11:09:32 -0400 | [diff] [blame] | 295 | keyValue := field.KeyFromStr(key) |
| 296 | if _, childRev := n.findRevByKey(children, field.Key, keyValue); childRev == nil { |
Stephane Barbarie | ec0919b | 2018-09-05 14:14:29 -0400 | [diff] [blame] | 297 | return nil |
| 298 | } else { |
| 299 | childNode := childRev.GetNode() |
Stephane Barbarie | 06c4a74 | 2018-10-01 11:09:32 -0400 | [diff] [blame] | 300 | return childNode.getPath(childRev, path, depth) |
Stephane Barbarie | ec0919b | 2018-09-05 14:14:29 -0400 | [diff] [blame] | 301 | } |
Stephane Barbarie | 4a2564d | 2018-07-26 11:02:58 -0400 | [diff] [blame] | 302 | } else { |
| 303 | var response []interface{} |
| 304 | for _, childRev := range children { |
Stephane Barbarie | ec0919b | 2018-09-05 14:14:29 -0400 | [diff] [blame] | 305 | childNode := childRev.GetNode() |
Stephane Barbarie | 06c4a74 | 2018-10-01 11:09:32 -0400 | [diff] [blame] | 306 | value := childNode.getData(childRev, depth) |
Stephane Barbarie | 4a2564d | 2018-07-26 11:02:58 -0400 | [diff] [blame] | 307 | response = append(response, value) |
| 308 | } |
| 309 | return response |
| 310 | } |
| 311 | } else { |
Stephane Barbarie | ec0919b | 2018-09-05 14:14:29 -0400 | [diff] [blame] | 312 | var response []interface{} |
| 313 | if path != "" { |
| 314 | // TODO: raise error |
| 315 | return response |
| 316 | } |
| 317 | for _, childRev := range rev.GetChildren()[name] { |
| 318 | childNode := childRev.GetNode() |
Stephane Barbarie | 06c4a74 | 2018-10-01 11:09:32 -0400 | [diff] [blame] | 319 | value := childNode.getData(childRev, depth) |
Stephane Barbarie | ec0919b | 2018-09-05 14:14:29 -0400 | [diff] [blame] | 320 | response = append(response, value) |
| 321 | } |
| 322 | return response |
Stephane Barbarie | 4a2564d | 2018-07-26 11:02:58 -0400 | [diff] [blame] | 323 | } |
Stephane Barbarie | ec0919b | 2018-09-05 14:14:29 -0400 | [diff] [blame] | 324 | } else { |
Stephane Barbarie | 06c4a74 | 2018-10-01 11:09:32 -0400 | [diff] [blame] | 325 | childRev := rev.GetChildren()[name][0] |
Stephane Barbarie | ec0919b | 2018-09-05 14:14:29 -0400 | [diff] [blame] | 326 | childNode := childRev.GetNode() |
Stephane Barbarie | 06c4a74 | 2018-10-01 11:09:32 -0400 | [diff] [blame] | 327 | return childNode.getPath(childRev, path, depth) |
Stephane Barbarie | 4a2564d | 2018-07-26 11:02:58 -0400 | [diff] [blame] | 328 | } |
| 329 | return nil |
| 330 | } |
| 331 | |
Stephane Barbarie | 06c4a74 | 2018-10-01 11:09:32 -0400 | [diff] [blame] | 332 | func (n *node) getData(rev Revision, depth int) interface{} { |
Stephane Barbarie | 4a2564d | 2018-07-26 11:02:58 -0400 | [diff] [blame] | 333 | msg := rev.Get(depth) |
| 334 | |
Stephane Barbarie | ec0919b | 2018-09-05 14:14:29 -0400 | [diff] [blame] | 335 | if n.Proxy != nil { |
Stephane Barbarie | 694e2b9 | 2018-09-07 12:17:36 -0400 | [diff] [blame] | 336 | log.Debug("invoking proxy GET Callbacks") |
Stephane Barbarie | 126101e | 2018-10-11 16:18:48 -0400 | [diff] [blame^] | 337 | msg = n.Proxy.InvokeCallbacks(GET, false, msg) |
Stephane Barbarie | 694e2b9 | 2018-09-07 12:17:36 -0400 | [diff] [blame] | 338 | |
Stephane Barbarie | 4a2564d | 2018-07-26 11:02:58 -0400 | [diff] [blame] | 339 | } |
| 340 | return msg |
| 341 | } |
| 342 | |
| 343 | // |
| 344 | // Update operation |
| 345 | // |
Stephane Barbarie | 06c4a74 | 2018-10-01 11:09:32 -0400 | [diff] [blame] | 346 | func (n *node) Update(path string, data interface{}, strict bool, txid string, makeBranch MakeBranchFunction) Revision { |
Stephane Barbarie | 4a2564d | 2018-07-26 11:02:58 -0400 | [diff] [blame] | 347 | // FIXME: is this required ... a bit overkill to take out a "/" |
| 348 | for strings.HasPrefix(path, "/") { |
| 349 | path = path[1:] |
| 350 | } |
| 351 | |
| 352 | var branch *Branch |
| 353 | var ok bool |
Stephane Barbarie | ec0919b | 2018-09-05 14:14:29 -0400 | [diff] [blame] | 354 | if txid == "" { |
| 355 | branch = n.Branches[NONE] |
| 356 | } else if branch, ok = n.Branches[txid]; !ok { |
Stephane Barbarie | 4a2564d | 2018-07-26 11:02:58 -0400 | [diff] [blame] | 357 | branch = makeBranch(n) |
| 358 | } |
| 359 | |
Stephane Barbarie | ec0919b | 2018-09-05 14:14:29 -0400 | [diff] [blame] | 360 | log.Debugf("Branch data : %+v, Passed data: %+v", branch.Latest.GetData(), data) |
| 361 | |
Stephane Barbarie | 4a2564d | 2018-07-26 11:02:58 -0400 | [diff] [blame] | 362 | if path == "" { |
| 363 | return n.doUpdate(branch, data, strict) |
| 364 | } |
Stephane Barbarie | 4a2564d | 2018-07-26 11:02:58 -0400 | [diff] [blame] | 365 | |
Stephane Barbarie | ec0919b | 2018-09-05 14:14:29 -0400 | [diff] [blame] | 366 | // TODO missing some code here... |
| 367 | rev := branch.Latest |
| 368 | |
| 369 | partition := strings.SplitN(path, "/", 2) |
| 370 | name := partition[0] |
| 371 | |
| 372 | if len(partition) < 2 { |
| 373 | path = "" |
| 374 | } else { |
| 375 | path = partition[1] |
Stephane Barbarie | 4a2564d | 2018-07-26 11:02:58 -0400 | [diff] [blame] | 376 | } |
| 377 | |
Stephane Barbarie | ec0919b | 2018-09-05 14:14:29 -0400 | [diff] [blame] | 378 | field := ChildrenFields(n.Type)[name] |
| 379 | var children []Revision |
| 380 | |
| 381 | if field.IsContainer { |
| 382 | if path == "" { |
Stephane Barbarie | 126101e | 2018-10-11 16:18:48 -0400 | [diff] [blame^] | 383 | log.Errorf("cannot update a list") |
Stephane Barbarie | ec0919b | 2018-09-05 14:14:29 -0400 | [diff] [blame] | 384 | } else if field.Key != "" { |
| 385 | partition := strings.SplitN(path, "/", 2) |
| 386 | key := partition[0] |
| 387 | if len(partition) < 2 { |
| 388 | path = "" |
| 389 | } else { |
| 390 | path = partition[1] |
| 391 | } |
Stephane Barbarie | 06c4a74 | 2018-10-01 11:09:32 -0400 | [diff] [blame] | 392 | keyValue := field.KeyFromStr(key) |
Stephane Barbarie | ec0919b | 2018-09-05 14:14:29 -0400 | [diff] [blame] | 393 | // TODO. Est-ce que le copy ne fonctionne pas? dois-je plutôt faire un clone de chaque item? |
| 394 | for _, v := range rev.GetChildren()[name] { |
| 395 | revCopy := reflect.ValueOf(v).Interface().(Revision) |
| 396 | children = append(children, revCopy) |
| 397 | } |
Stephane Barbarie | 06c4a74 | 2018-10-01 11:09:32 -0400 | [diff] [blame] | 398 | idx, childRev := n.findRevByKey(children, field.Key, keyValue) |
Stephane Barbarie | ec0919b | 2018-09-05 14:14:29 -0400 | [diff] [blame] | 399 | childNode := childRev.GetNode() |
Stephane Barbarie | 126101e | 2018-10-11 16:18:48 -0400 | [diff] [blame^] | 400 | childNode.Proxy = n.Proxy |
Stephane Barbarie | ec0919b | 2018-09-05 14:14:29 -0400 | [diff] [blame] | 401 | newChildRev := childNode.Update(path, data, strict, txid, makeBranch) |
Stephane Barbarie | 126101e | 2018-10-11 16:18:48 -0400 | [diff] [blame^] | 402 | |
Stephane Barbarie | ec0919b | 2018-09-05 14:14:29 -0400 | [diff] [blame] | 403 | if newChildRev.GetHash() == childRev.GetHash() { |
| 404 | if newChildRev != childRev { |
| 405 | log.Debug("clear-hash - %s %+v", newChildRev.GetHash(), newChildRev) |
| 406 | newChildRev.ClearHash() |
| 407 | } |
| 408 | return branch.Latest |
| 409 | } |
Stephane Barbarie | 06c4a74 | 2018-10-01 11:09:32 -0400 | [diff] [blame] | 410 | |
| 411 | _, newKey := GetAttributeValue(newChildRev.GetData(), field.Key, 0) |
| 412 | log.Debugf("newKey is %s", newKey.Interface()) |
| 413 | _newKeyType := fmt.Sprintf("%s", newKey) |
| 414 | _keyValueType := fmt.Sprintf("%s", keyValue) |
| 415 | if _newKeyType != _keyValueType { |
Stephane Barbarie | 126101e | 2018-10-11 16:18:48 -0400 | [diff] [blame^] | 416 | log.Errorf("cannot change key field") |
Stephane Barbarie | ec0919b | 2018-09-05 14:14:29 -0400 | [diff] [blame] | 417 | } |
| 418 | children[idx] = newChildRev |
| 419 | rev = rev.UpdateChildren(name, children, branch) |
Stephane Barbarie | 88fbe7f | 2018-09-25 12:25:23 -0400 | [diff] [blame] | 420 | branch.Latest.Drop(txid, false) |
Stephane Barbarie | 126101e | 2018-10-11 16:18:48 -0400 | [diff] [blame^] | 421 | n.MakeLatest(branch, rev, nil) |
Stephane Barbarie | ec0919b | 2018-09-05 14:14:29 -0400 | [diff] [blame] | 422 | return rev |
| 423 | } else { |
Stephane Barbarie | 126101e | 2018-10-11 16:18:48 -0400 | [diff] [blame^] | 424 | log.Errorf("cannot index into container with no keys") |
Stephane Barbarie | ec0919b | 2018-09-05 14:14:29 -0400 | [diff] [blame] | 425 | } |
| 426 | } else { |
| 427 | childRev := rev.GetChildren()[name][0] |
| 428 | childNode := childRev.GetNode() |
| 429 | newChildRev := childNode.Update(path, data, strict, txid, makeBranch) |
| 430 | rev = rev.UpdateChildren(name, []Revision{newChildRev}, branch) |
Stephane Barbarie | 88fbe7f | 2018-09-25 12:25:23 -0400 | [diff] [blame] | 431 | branch.Latest.Drop(txid, false) |
Stephane Barbarie | 126101e | 2018-10-11 16:18:48 -0400 | [diff] [blame^] | 432 | n.MakeLatest(branch, rev, nil) |
Stephane Barbarie | ec0919b | 2018-09-05 14:14:29 -0400 | [diff] [blame] | 433 | return rev |
| 434 | } |
| 435 | return nil |
| 436 | } |
| 437 | |
Stephane Barbarie | 06c4a74 | 2018-10-01 11:09:32 -0400 | [diff] [blame] | 438 | func (n *node) doUpdate(branch *Branch, data interface{}, strict bool) Revision { |
Stephane Barbarie | ec0919b | 2018-09-05 14:14:29 -0400 | [diff] [blame] | 439 | log.Debugf("Comparing types - expected: %+v, actual: %+v", reflect.ValueOf(n.Type).Type(), reflect.TypeOf(data)) |
| 440 | |
| 441 | if reflect.TypeOf(data) != reflect.ValueOf(n.Type).Type() { |
| 442 | // TODO raise error |
Stephane Barbarie | 8c48b5c | 2018-10-02 09:45:17 -0400 | [diff] [blame] | 443 | log.Errorf("data does not match type: %+v", n.Type) |
Stephane Barbarie | ec0919b | 2018-09-05 14:14:29 -0400 | [diff] [blame] | 444 | return nil |
| 445 | } |
| 446 | |
| 447 | // TODO: validate that this actually works |
| 448 | //if n.hasChildren(data) { |
| 449 | // return nil |
| 450 | //} |
Stephane Barbarie | 4a2564d | 2018-07-26 11:02:58 -0400 | [diff] [blame] | 451 | |
| 452 | if n.Proxy != nil { |
Stephane Barbarie | 694e2b9 | 2018-09-07 12:17:36 -0400 | [diff] [blame] | 453 | log.Debug("invoking proxy PRE_UPDATE Callbacks") |
Stephane Barbarie | 126101e | 2018-10-11 16:18:48 -0400 | [diff] [blame^] | 454 | n.Proxy.InvokeCallbacks(PRE_UPDATE, false, branch.Latest.GetData(), data) |
Stephane Barbarie | 4a2564d | 2018-07-26 11:02:58 -0400 | [diff] [blame] | 455 | } |
Stephane Barbarie | ec0919b | 2018-09-05 14:14:29 -0400 | [diff] [blame] | 456 | if !reflect.DeepEqual(branch.Latest.GetData(), data) { |
Stephane Barbarie | 4a2564d | 2018-07-26 11:02:58 -0400 | [diff] [blame] | 457 | if strict { |
Stephane Barbarie | ec0919b | 2018-09-05 14:14:29 -0400 | [diff] [blame] | 458 | // TODO: checkAccessViolations(data, Branch.GetLatest.data) |
Stephane Barbarie | 8c48b5c | 2018-10-02 09:45:17 -0400 | [diff] [blame] | 459 | log.Debugf("checking access violations") |
Stephane Barbarie | 4a2564d | 2018-07-26 11:02:58 -0400 | [diff] [blame] | 460 | } |
| 461 | rev := branch.Latest.UpdateData(data, branch) |
Stephane Barbarie | 8c48b5c | 2018-10-02 09:45:17 -0400 | [diff] [blame] | 462 | changes := []ChangeTuple{{POST_UPDATE, branch.Latest.GetData(), rev.GetData()}} |
Stephane Barbarie | 88fbe7f | 2018-09-25 12:25:23 -0400 | [diff] [blame] | 463 | branch.Latest.Drop(branch.Txid, true) |
Stephane Barbarie | 126101e | 2018-10-11 16:18:48 -0400 | [diff] [blame^] | 464 | n.MakeLatest(branch, rev, changes) |
Stephane Barbarie | 4a2564d | 2018-07-26 11:02:58 -0400 | [diff] [blame] | 465 | return rev |
| 466 | } else { |
| 467 | return branch.Latest |
| 468 | } |
| 469 | } |
| 470 | |
Stephane Barbarie | 4a2564d | 2018-07-26 11:02:58 -0400 | [diff] [blame] | 471 | // |
| 472 | // Add operation |
| 473 | // |
Stephane Barbarie | 06c4a74 | 2018-10-01 11:09:32 -0400 | [diff] [blame] | 474 | func (n *node) Add(path string, data interface{}, txid string, makeBranch MakeBranchFunction) Revision { |
Stephane Barbarie | 4a2564d | 2018-07-26 11:02:58 -0400 | [diff] [blame] | 475 | for strings.HasPrefix(path, "/") { |
| 476 | path = path[1:] |
| 477 | } |
| 478 | if path == "" { |
| 479 | // TODO raise error |
Stephane Barbarie | 126101e | 2018-10-11 16:18:48 -0400 | [diff] [blame^] | 480 | log.Errorf("cannot add for non-container mode") |
Stephane Barbarie | 4a2564d | 2018-07-26 11:02:58 -0400 | [diff] [blame] | 481 | } |
| 482 | |
| 483 | var branch *Branch |
| 484 | var ok bool |
Stephane Barbarie | ec0919b | 2018-09-05 14:14:29 -0400 | [diff] [blame] | 485 | if txid == "" { |
| 486 | branch = n.Branches[NONE] |
| 487 | } else if branch, ok = n.Branches[txid]; !ok { |
Stephane Barbarie | 4a2564d | 2018-07-26 11:02:58 -0400 | [diff] [blame] | 488 | branch = makeBranch(n) |
| 489 | } |
| 490 | |
| 491 | rev := branch.Latest |
| 492 | |
| 493 | partition := strings.SplitN(path, "/", 2) |
| 494 | name := partition[0] |
Stephane Barbarie | ec0919b | 2018-09-05 14:14:29 -0400 | [diff] [blame] | 495 | |
| 496 | if len(partition) < 2 { |
| 497 | path = "" |
| 498 | } else { |
| 499 | path = partition[1] |
| 500 | } |
Stephane Barbarie | 4a2564d | 2018-07-26 11:02:58 -0400 | [diff] [blame] | 501 | |
| 502 | field := ChildrenFields(n.Type)[name] |
Stephane Barbarie | ec0919b | 2018-09-05 14:14:29 -0400 | [diff] [blame] | 503 | var children []Revision |
Stephane Barbarie | 4a2564d | 2018-07-26 11:02:58 -0400 | [diff] [blame] | 504 | |
| 505 | if field.IsContainer { |
| 506 | if path == "" { |
| 507 | if field.Key != "" { |
| 508 | if n.Proxy != nil { |
Stephane Barbarie | 694e2b9 | 2018-09-07 12:17:36 -0400 | [diff] [blame] | 509 | log.Debug("invoking proxy PRE_ADD Callbacks") |
Stephane Barbarie | 126101e | 2018-10-11 16:18:48 -0400 | [diff] [blame^] | 510 | n.Proxy.InvokeCallbacks(PRE_ADD, false, data) |
Stephane Barbarie | 4a2564d | 2018-07-26 11:02:58 -0400 | [diff] [blame] | 511 | } |
| 512 | |
Stephane Barbarie | ec0919b | 2018-09-05 14:14:29 -0400 | [diff] [blame] | 513 | for _, v := range rev.GetChildren()[name] { |
| 514 | revCopy := reflect.ValueOf(v).Interface().(Revision) |
| 515 | children = append(children, revCopy) |
| 516 | } |
| 517 | _, key := GetAttributeValue(data, field.Key, 0) |
Stephane Barbarie | 126101e | 2018-10-11 16:18:48 -0400 | [diff] [blame^] | 518 | if _, exists := n.findRevByKey(children, field.Key, key.String()); exists != nil { |
Stephane Barbarie | 4a2564d | 2018-07-26 11:02:58 -0400 | [diff] [blame] | 519 | // TODO raise error |
Stephane Barbarie | 8c48b5c | 2018-10-02 09:45:17 -0400 | [diff] [blame] | 520 | log.Errorf("duplicate key found: %s", key.String()) |
Stephane Barbarie | 126101e | 2018-10-11 16:18:48 -0400 | [diff] [blame^] | 521 | } else { |
| 522 | childRev := n.MakeNode(data, txid).Latest(txid) |
| 523 | children = append(children, childRev) |
| 524 | rev := rev.UpdateChildren(name, children, branch) |
| 525 | changes := []ChangeTuple{{POST_ADD, nil, rev.GetData()}} |
| 526 | branch.Latest.Drop(txid, false) |
| 527 | n.MakeLatest(branch, rev, changes) |
| 528 | return rev |
Stephane Barbarie | 4a2564d | 2018-07-26 11:02:58 -0400 | [diff] [blame] | 529 | } |
| 530 | |
Stephane Barbarie | 4a2564d | 2018-07-26 11:02:58 -0400 | [diff] [blame] | 531 | } else { |
Stephane Barbarie | 126101e | 2018-10-11 16:18:48 -0400 | [diff] [blame^] | 532 | log.Errorf("cannot add to non-keyed container") |
Stephane Barbarie | 4a2564d | 2018-07-26 11:02:58 -0400 | [diff] [blame] | 533 | } |
| 534 | } else if field.Key != "" { |
| 535 | partition := strings.SplitN(path, "/", 2) |
| 536 | key := partition[0] |
Stephane Barbarie | ec0919b | 2018-09-05 14:14:29 -0400 | [diff] [blame] | 537 | if len(partition) < 2 { |
| 538 | path = "" |
| 539 | } else { |
| 540 | path = partition[1] |
| 541 | } |
Stephane Barbarie | 06c4a74 | 2018-10-01 11:09:32 -0400 | [diff] [blame] | 542 | keyValue := field.KeyFromStr(key) |
Stephane Barbarie | ec0919b | 2018-09-05 14:14:29 -0400 | [diff] [blame] | 543 | copy(children, rev.GetChildren()[name]) |
Stephane Barbarie | 06c4a74 | 2018-10-01 11:09:32 -0400 | [diff] [blame] | 544 | idx, childRev := n.findRevByKey(children, field.Key, keyValue) |
Stephane Barbarie | ec0919b | 2018-09-05 14:14:29 -0400 | [diff] [blame] | 545 | childNode := childRev.GetNode() |
Stephane Barbarie | 4a2564d | 2018-07-26 11:02:58 -0400 | [diff] [blame] | 546 | newChildRev := childNode.Add(path, data, txid, makeBranch) |
| 547 | children[idx] = newChildRev |
| 548 | rev := rev.UpdateChildren(name, children, branch) |
Stephane Barbarie | 88fbe7f | 2018-09-25 12:25:23 -0400 | [diff] [blame] | 549 | branch.Latest.Drop(txid, false) |
Stephane Barbarie | 126101e | 2018-10-11 16:18:48 -0400 | [diff] [blame^] | 550 | n.MakeLatest(branch, rev, nil) |
Stephane Barbarie | 4a2564d | 2018-07-26 11:02:58 -0400 | [diff] [blame] | 551 | return rev |
| 552 | } else { |
Stephane Barbarie | 126101e | 2018-10-11 16:18:48 -0400 | [diff] [blame^] | 553 | log.Errorf("cannot add to non-keyed container") |
Stephane Barbarie | 4a2564d | 2018-07-26 11:02:58 -0400 | [diff] [blame] | 554 | } |
| 555 | } else { |
Stephane Barbarie | 126101e | 2018-10-11 16:18:48 -0400 | [diff] [blame^] | 556 | log.Errorf("cannot add to non-container field") |
Stephane Barbarie | 4a2564d | 2018-07-26 11:02:58 -0400 | [diff] [blame] | 557 | } |
| 558 | return nil |
| 559 | } |
| 560 | |
| 561 | // |
| 562 | // Remove operation |
| 563 | // |
Stephane Barbarie | 06c4a74 | 2018-10-01 11:09:32 -0400 | [diff] [blame] | 564 | func (n *node) Remove(path string, txid string, makeBranch MakeBranchFunction) Revision { |
Stephane Barbarie | 4a2564d | 2018-07-26 11:02:58 -0400 | [diff] [blame] | 565 | for strings.HasPrefix(path, "/") { |
| 566 | path = path[1:] |
| 567 | } |
| 568 | if path == "" { |
| 569 | // TODO raise error |
Stephane Barbarie | 126101e | 2018-10-11 16:18:48 -0400 | [diff] [blame^] | 570 | log.Errorf("cannot remove for non-container mode") |
Stephane Barbarie | 4a2564d | 2018-07-26 11:02:58 -0400 | [diff] [blame] | 571 | } |
| 572 | var branch *Branch |
| 573 | var ok bool |
Stephane Barbarie | ec0919b | 2018-09-05 14:14:29 -0400 | [diff] [blame] | 574 | if txid == "" { |
| 575 | branch = n.Branches[NONE] |
| 576 | } else if branch, ok = n.Branches[txid]; !ok { |
Stephane Barbarie | 4a2564d | 2018-07-26 11:02:58 -0400 | [diff] [blame] | 577 | branch = makeBranch(n) |
| 578 | } |
| 579 | |
| 580 | rev := branch.Latest |
| 581 | |
| 582 | partition := strings.SplitN(path, "/", 2) |
| 583 | name := partition[0] |
Stephane Barbarie | ec0919b | 2018-09-05 14:14:29 -0400 | [diff] [blame] | 584 | if len(partition) < 2 { |
| 585 | path = "" |
| 586 | } else { |
| 587 | path = partition[1] |
| 588 | } |
Stephane Barbarie | 4a2564d | 2018-07-26 11:02:58 -0400 | [diff] [blame] | 589 | |
| 590 | field := ChildrenFields(n.Type)[name] |
Stephane Barbarie | ec0919b | 2018-09-05 14:14:29 -0400 | [diff] [blame] | 591 | var children []Revision |
Stephane Barbarie | 694e2b9 | 2018-09-07 12:17:36 -0400 | [diff] [blame] | 592 | postAnnouncement := []ChangeTuple{} |
Stephane Barbarie | 4a2564d | 2018-07-26 11:02:58 -0400 | [diff] [blame] | 593 | |
| 594 | if field.IsContainer { |
| 595 | if path == "" { |
Stephane Barbarie | 126101e | 2018-10-11 16:18:48 -0400 | [diff] [blame^] | 596 | log.Errorf("cannot remove without a key") |
Stephane Barbarie | 4a2564d | 2018-07-26 11:02:58 -0400 | [diff] [blame] | 597 | } else if field.Key != "" { |
| 598 | partition := strings.SplitN(path, "/", 2) |
| 599 | key := partition[0] |
Stephane Barbarie | ec0919b | 2018-09-05 14:14:29 -0400 | [diff] [blame] | 600 | if len(partition) < 2 { |
| 601 | path = "" |
| 602 | } else { |
| 603 | path = partition[1] |
| 604 | } |
Stephane Barbarie | 06c4a74 | 2018-10-01 11:09:32 -0400 | [diff] [blame] | 605 | keyValue := field.KeyFromStr(key) |
Stephane Barbarie | 4a2564d | 2018-07-26 11:02:58 -0400 | [diff] [blame] | 606 | if path != "" { |
Stephane Barbarie | ec0919b | 2018-09-05 14:14:29 -0400 | [diff] [blame] | 607 | for _, v := range rev.GetChildren()[name] { |
| 608 | newV := reflect.ValueOf(v).Interface().(Revision) |
| 609 | children = append(children, newV) |
| 610 | } |
Stephane Barbarie | 06c4a74 | 2018-10-01 11:09:32 -0400 | [diff] [blame] | 611 | idx, childRev := n.findRevByKey(children, field.Key, keyValue) |
Stephane Barbarie | ec0919b | 2018-09-05 14:14:29 -0400 | [diff] [blame] | 612 | childNode := childRev.GetNode() |
Stephane Barbarie | 4a2564d | 2018-07-26 11:02:58 -0400 | [diff] [blame] | 613 | newChildRev := childNode.Remove(path, txid, makeBranch) |
| 614 | children[idx] = newChildRev |
| 615 | rev := rev.UpdateChildren(name, children, branch) |
Stephane Barbarie | 88fbe7f | 2018-09-25 12:25:23 -0400 | [diff] [blame] | 616 | branch.Latest.Drop(txid, false) |
Stephane Barbarie | 126101e | 2018-10-11 16:18:48 -0400 | [diff] [blame^] | 617 | n.MakeLatest(branch, rev, nil) |
Stephane Barbarie | 4a2564d | 2018-07-26 11:02:58 -0400 | [diff] [blame] | 618 | return rev |
| 619 | } else { |
Stephane Barbarie | ec0919b | 2018-09-05 14:14:29 -0400 | [diff] [blame] | 620 | for _, v := range rev.GetChildren()[name] { |
| 621 | newV := reflect.ValueOf(v).Interface().(Revision) |
| 622 | children = append(children, newV) |
| 623 | } |
Stephane Barbarie | 06c4a74 | 2018-10-01 11:09:32 -0400 | [diff] [blame] | 624 | idx, childRev := n.findRevByKey(children, field.Key, keyValue) |
Stephane Barbarie | 4a2564d | 2018-07-26 11:02:58 -0400 | [diff] [blame] | 625 | if n.Proxy != nil { |
Stephane Barbarie | ec0919b | 2018-09-05 14:14:29 -0400 | [diff] [blame] | 626 | data := childRev.GetData() |
Stephane Barbarie | 126101e | 2018-10-11 16:18:48 -0400 | [diff] [blame^] | 627 | n.Proxy.InvokeCallbacks(PRE_REMOVE, false, data) |
Stephane Barbarie | 8c48b5c | 2018-10-02 09:45:17 -0400 | [diff] [blame] | 628 | postAnnouncement = append(postAnnouncement, ChangeTuple{POST_REMOVE, data, nil}) |
Stephane Barbarie | 4a2564d | 2018-07-26 11:02:58 -0400 | [diff] [blame] | 629 | } else { |
Stephane Barbarie | 8c48b5c | 2018-10-02 09:45:17 -0400 | [diff] [blame] | 630 | postAnnouncement = append(postAnnouncement, ChangeTuple{POST_REMOVE, childRev.GetData(), nil}) |
Stephane Barbarie | 4a2564d | 2018-07-26 11:02:58 -0400 | [diff] [blame] | 631 | } |
Stephane Barbarie | 88fbe7f | 2018-09-25 12:25:23 -0400 | [diff] [blame] | 632 | childRev.Drop(txid, true) |
Stephane Barbarie | 4a2564d | 2018-07-26 11:02:58 -0400 | [diff] [blame] | 633 | children = append(children[:idx], children[idx+1:]...) |
| 634 | rev := rev.UpdateChildren(name, children, branch) |
Stephane Barbarie | 88fbe7f | 2018-09-25 12:25:23 -0400 | [diff] [blame] | 635 | branch.Latest.Drop(txid, false) |
Stephane Barbarie | 126101e | 2018-10-11 16:18:48 -0400 | [diff] [blame^] | 636 | n.MakeLatest(branch, rev, postAnnouncement) |
Stephane Barbarie | 4a2564d | 2018-07-26 11:02:58 -0400 | [diff] [blame] | 637 | return rev |
| 638 | } |
| 639 | } else { |
Stephane Barbarie | 126101e | 2018-10-11 16:18:48 -0400 | [diff] [blame^] | 640 | log.Errorf("cannot add to non-keyed container") |
Stephane Barbarie | 4a2564d | 2018-07-26 11:02:58 -0400 | [diff] [blame] | 641 | } |
| 642 | } else { |
Stephane Barbarie | 126101e | 2018-10-11 16:18:48 -0400 | [diff] [blame^] | 643 | log.Errorf("cannot add to non-container field") |
Stephane Barbarie | 4a2564d | 2018-07-26 11:02:58 -0400 | [diff] [blame] | 644 | } |
| 645 | |
| 646 | return nil |
| 647 | } |
| 648 | |
Stephane Barbarie | ec0919b | 2018-09-05 14:14:29 -0400 | [diff] [blame] | 649 | // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Branching ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ |
| 650 | |
Stephane Barbarie | 06c4a74 | 2018-10-01 11:09:32 -0400 | [diff] [blame] | 651 | type MakeBranchFunction func(*node) *Branch |
Stephane Barbarie | ec0919b | 2018-09-05 14:14:29 -0400 | [diff] [blame] | 652 | |
Stephane Barbarie | 06c4a74 | 2018-10-01 11:09:32 -0400 | [diff] [blame] | 653 | func (n *node) MakeBranch(txid string) *Branch { |
Stephane Barbarie | ec0919b | 2018-09-05 14:14:29 -0400 | [diff] [blame] | 654 | branchPoint := n.Branches[NONE].Latest |
| 655 | branch := NewBranch(n, txid, branchPoint, true) |
| 656 | n.Branches[txid] = branch |
| 657 | return branch |
| 658 | } |
| 659 | |
Stephane Barbarie | 06c4a74 | 2018-10-01 11:09:32 -0400 | [diff] [blame] | 660 | func (n *node) DeleteBranch(txid string) { |
Stephane Barbarie | ec0919b | 2018-09-05 14:14:29 -0400 | [diff] [blame] | 661 | delete(n.Branches, txid) |
| 662 | } |
| 663 | |
Stephane Barbarie | 06c4a74 | 2018-10-01 11:09:32 -0400 | [diff] [blame] | 664 | func (n *node) mergeChild(txid string, dryRun bool) func(Revision) Revision { |
Stephane Barbarie | ec0919b | 2018-09-05 14:14:29 -0400 | [diff] [blame] | 665 | f := func(rev Revision) Revision { |
| 666 | childBranch := rev.GetBranch() |
| 667 | |
| 668 | if childBranch.Txid == txid { |
Stephane Barbarie | 06c4a74 | 2018-10-01 11:09:32 -0400 | [diff] [blame] | 669 | rev, _ = childBranch.Node.MergeBranch(txid, dryRun) |
Stephane Barbarie | ec0919b | 2018-09-05 14:14:29 -0400 | [diff] [blame] | 670 | } |
| 671 | |
| 672 | return rev |
| 673 | } |
| 674 | return f |
| 675 | } |
| 676 | |
Stephane Barbarie | 06c4a74 | 2018-10-01 11:09:32 -0400 | [diff] [blame] | 677 | func (n *node) MergeBranch(txid string, dryRun bool) (Revision, error) { |
Stephane Barbarie | ec0919b | 2018-09-05 14:14:29 -0400 | [diff] [blame] | 678 | srcBranch := n.Branches[txid] |
| 679 | dstBranch := n.Branches[NONE] |
| 680 | |
| 681 | forkRev := srcBranch.Origin |
| 682 | srcRev := srcBranch.Latest |
| 683 | dstRev := dstBranch.Latest |
| 684 | |
| 685 | rev, changes := Merge3Way(forkRev, srcRev, dstRev, n.mergeChild(txid, dryRun), dryRun) |
| 686 | |
| 687 | if !dryRun { |
Stephane Barbarie | 126101e | 2018-10-11 16:18:48 -0400 | [diff] [blame^] | 688 | n.MakeLatest(dstBranch, rev, changes) |
Stephane Barbarie | ec0919b | 2018-09-05 14:14:29 -0400 | [diff] [blame] | 689 | delete(n.Branches, txid) |
| 690 | } |
| 691 | |
Stephane Barbarie | e16186c | 2018-09-11 10:46:34 -0400 | [diff] [blame] | 692 | // TODO: return proper error when one occurs |
| 693 | return rev, nil |
Stephane Barbarie | ec0919b | 2018-09-05 14:14:29 -0400 | [diff] [blame] | 694 | } |
| 695 | |
| 696 | // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Diff utility ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ |
| 697 | |
Stephane Barbarie | 06c4a74 | 2018-10-01 11:09:32 -0400 | [diff] [blame] | 698 | //func (n *node) diff(hash1, hash2, txid string) { |
Stephane Barbarie | ec0919b | 2018-09-05 14:14:29 -0400 | [diff] [blame] | 699 | // branch := n.Branches[txid] |
| 700 | // rev1 := branch.get(hash1) |
| 701 | // rev2 := branch.get(hash2) |
| 702 | // |
| 703 | // if rev1.GetHash() == rev2.GetHash() { |
| 704 | // // empty patch |
| 705 | // } else { |
| 706 | // // translate data to json and generate patch |
| 707 | // patch, err := jsonpatch.MakePatch(rev1.GetData(), rev2.GetData()) |
| 708 | // patch. |
| 709 | // } |
| 710 | //} |
| 711 | |
| 712 | // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Tag utility ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ |
| 713 | |
| 714 | // TODO: is tag mgmt used in the python implementation? Need to validate |
| 715 | |
| 716 | // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Internals ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ |
| 717 | |
Stephane Barbarie | 06c4a74 | 2018-10-01 11:09:32 -0400 | [diff] [blame] | 718 | func (n *node) hasChildren(data interface{}) bool { |
Stephane Barbarie | ec0919b | 2018-09-05 14:14:29 -0400 | [diff] [blame] | 719 | for fieldName, field := range ChildrenFields(n.Type) { |
| 720 | _, fieldValue := GetAttributeValue(data, fieldName, 0) |
| 721 | |
| 722 | if (field.IsContainer && fieldValue.Len() > 0) || !fieldValue.IsNil() { |
| 723 | log.Error("cannot update external children") |
| 724 | return true |
| 725 | } |
| 726 | } |
| 727 | |
| 728 | return false |
| 729 | } |
| 730 | |
Stephane Barbarie | 06c4a74 | 2018-10-01 11:09:32 -0400 | [diff] [blame] | 731 | // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ node Proxy ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ |
Stephane Barbarie | ec0919b | 2018-09-05 14:14:29 -0400 | [diff] [blame] | 732 | |
Stephane Barbarie | 06c4a74 | 2018-10-01 11:09:32 -0400 | [diff] [blame] | 733 | func (n *node) GetProxy(path string, exclusive bool) *Proxy { |
Stephane Barbarie | 126101e | 2018-10-11 16:18:48 -0400 | [diff] [blame^] | 734 | //r := NewRoot(n.Type, n.KvStore) |
| 735 | //r.node = n |
| 736 | //r.KvStore = n.KvStore |
Stephane Barbarie | 06c4a74 | 2018-10-01 11:09:32 -0400 | [diff] [blame] | 737 | |
Stephane Barbarie | 126101e | 2018-10-11 16:18:48 -0400 | [diff] [blame^] | 738 | return n.getProxy(path, path, exclusive) |
Stephane Barbarie | ec0919b | 2018-09-05 14:14:29 -0400 | [diff] [blame] | 739 | } |
Stephane Barbarie | 126101e | 2018-10-11 16:18:48 -0400 | [diff] [blame^] | 740 | func (n *node) getProxy(path string, fullPath string, exclusive bool) *Proxy { |
Stephane Barbarie | ec0919b | 2018-09-05 14:14:29 -0400 | [diff] [blame] | 741 | for strings.HasPrefix(path, "/") { |
| 742 | path = path[1:] |
| 743 | } |
| 744 | if path == "" { |
Stephane Barbarie | 126101e | 2018-10-11 16:18:48 -0400 | [diff] [blame^] | 745 | return n.makeProxy(path, exclusive) |
Stephane Barbarie | ec0919b | 2018-09-05 14:14:29 -0400 | [diff] [blame] | 746 | } |
| 747 | |
| 748 | rev := n.Branches[NONE].Latest |
| 749 | partition := strings.SplitN(path, "/", 2) |
| 750 | name := partition[0] |
Stephane Barbarie | 126101e | 2018-10-11 16:18:48 -0400 | [diff] [blame^] | 751 | if len(partition) < 2 { |
| 752 | path = "" |
| 753 | } else { |
| 754 | path = partition[1] |
| 755 | } |
Stephane Barbarie | ec0919b | 2018-09-05 14:14:29 -0400 | [diff] [blame] | 756 | |
| 757 | field := ChildrenFields(n.Type)[name] |
Stephane Barbarie | 126101e | 2018-10-11 16:18:48 -0400 | [diff] [blame^] | 758 | if field != nil && field.IsContainer { |
Stephane Barbarie | ec0919b | 2018-09-05 14:14:29 -0400 | [diff] [blame] | 759 | if path == "" { |
| 760 | log.Error("cannot proxy a container field") |
Stephane Barbarie | 126101e | 2018-10-11 16:18:48 -0400 | [diff] [blame^] | 761 | } else if field.Key != "" { |
Stephane Barbarie | ec0919b | 2018-09-05 14:14:29 -0400 | [diff] [blame] | 762 | partition := strings.SplitN(path, "/", 2) |
| 763 | key := partition[0] |
Stephane Barbarie | 06c4a74 | 2018-10-01 11:09:32 -0400 | [diff] [blame] | 764 | if len(partition) < 2 { |
| 765 | path = "" |
| 766 | } else { |
| 767 | path = partition[1] |
| 768 | } |
| 769 | keyValue := field.KeyFromStr(key) |
Stephane Barbarie | 126101e | 2018-10-11 16:18:48 -0400 | [diff] [blame^] | 770 | var children []Revision |
| 771 | for _, v := range rev.GetChildren()[name] { |
| 772 | newV := reflect.ValueOf(v).Interface().(Revision) |
| 773 | children = append(children, newV) |
| 774 | } |
Stephane Barbarie | 06c4a74 | 2018-10-01 11:09:32 -0400 | [diff] [blame] | 775 | _, childRev := n.findRevByKey(children, field.Key, keyValue) |
Stephane Barbarie | ec0919b | 2018-09-05 14:14:29 -0400 | [diff] [blame] | 776 | childNode := childRev.GetNode() |
Stephane Barbarie | 06c4a74 | 2018-10-01 11:09:32 -0400 | [diff] [blame] | 777 | |
Stephane Barbarie | 126101e | 2018-10-11 16:18:48 -0400 | [diff] [blame^] | 778 | return childNode.getProxy(path, fullPath, exclusive) |
| 779 | } else { |
| 780 | log.Error("cannot index into container with no keys") |
Stephane Barbarie | ec0919b | 2018-09-05 14:14:29 -0400 | [diff] [blame] | 781 | } |
Stephane Barbarie | ec0919b | 2018-09-05 14:14:29 -0400 | [diff] [blame] | 782 | } else { |
| 783 | childRev := rev.GetChildren()[name][0] |
| 784 | childNode := childRev.GetNode() |
Stephane Barbarie | 126101e | 2018-10-11 16:18:48 -0400 | [diff] [blame^] | 785 | return childNode.getProxy(path, fullPath, exclusive) |
Stephane Barbarie | ec0919b | 2018-09-05 14:14:29 -0400 | [diff] [blame] | 786 | } |
| 787 | |
| 788 | return nil |
| 789 | } |
| 790 | |
Stephane Barbarie | 126101e | 2018-10-11 16:18:48 -0400 | [diff] [blame^] | 791 | func (n *node) makeProxy(fullPath string, exclusive bool) *Proxy { |
| 792 | r := &root{ |
| 793 | node: n, |
| 794 | Callbacks: n.Root.Callbacks, |
| 795 | NotificationCallbacks: n.Root.NotificationCallbacks, |
| 796 | DirtyNodes: n.Root.DirtyNodes, |
| 797 | KvStore: n.Root.KvStore, |
| 798 | Loading: n.Root.Loading, |
| 799 | RevisionClass: n.Root.RevisionClass, |
| 800 | } |
| 801 | |
Stephane Barbarie | ec0919b | 2018-09-05 14:14:29 -0400 | [diff] [blame] | 802 | if n.Proxy == nil { |
Stephane Barbarie | 126101e | 2018-10-11 16:18:48 -0400 | [diff] [blame^] | 803 | n.Proxy = NewProxy(r, fullPath, exclusive) |
Stephane Barbarie | ec0919b | 2018-09-05 14:14:29 -0400 | [diff] [blame] | 804 | } else { |
| 805 | if n.Proxy.Exclusive { |
| 806 | log.Error("node is already owned exclusively") |
| 807 | } |
| 808 | } |
| 809 | return n.Proxy |
| 810 | } |
| 811 | |
Stephane Barbarie | 06c4a74 | 2018-10-01 11:09:32 -0400 | [diff] [blame] | 812 | func (n *node) makeEventBus() *EventBus { |
Stephane Barbarie | ec0919b | 2018-09-05 14:14:29 -0400 | [diff] [blame] | 813 | if n.EventBus == nil { |
| 814 | n.EventBus = NewEventBus() |
| 815 | } |
| 816 | return n.EventBus |
| 817 | } |
| 818 | |
| 819 | // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Persistence Loading ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ |
| 820 | |
Stephane Barbarie | 126101e | 2018-10-11 16:18:48 -0400 | [diff] [blame^] | 821 | func (n *node) LoadLatest(hash string) { |
Stephane Barbarie | 4a2564d | 2018-07-26 11:02:58 -0400 | [diff] [blame] | 822 | branch := NewBranch(n, "", nil, n.AutoPrune) |
| 823 | pr := &PersistedRevision{} |
Stephane Barbarie | 126101e | 2018-10-11 16:18:48 -0400 | [diff] [blame^] | 824 | rev := pr.Load(branch, n.Root.KvStore, n.Type, hash) |
Stephane Barbarie | 06c4a74 | 2018-10-01 11:09:32 -0400 | [diff] [blame] | 825 | n.makeLatest(branch, rev, nil) |
Stephane Barbarie | 4a2564d | 2018-07-26 11:02:58 -0400 | [diff] [blame] | 826 | n.Branches[NONE] = branch |
| 827 | } |
Stephane Barbarie | 06c4a74 | 2018-10-01 11:09:32 -0400 | [diff] [blame] | 828 | |
Stephane Barbarie | 126101e | 2018-10-11 16:18:48 -0400 | [diff] [blame^] | 829 | func (n *node) ExecuteCallbacks() { |
| 830 | n.Root.ExecuteCallbacks() |
Stephane Barbarie | 06c4a74 | 2018-10-01 11:09:32 -0400 | [diff] [blame] | 831 | } |