Mercurial > hg > Members > shoshi > jungle > bbs

comparison src/main/java/jp/ac/u_ryukyu/ie/cr/bbs/network/NetworkJungleBulletinBoard.java @ 8:4a66328f0141

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
fix Loggingnode
author suruga
date Wed, 19 Jul 2017 16:16:17 +0900
parents 5acde010c6db
children d9a9154a075e
comparison
equal deleted inserted replaced
7:6c584862fe93 8:4a66328f0141
3 3
4 import jp.ac.u_ryukyu.ie.cr.bbs.local.BoardMessage; 4 import jp.ac.u_ryukyu.ie.cr.bbs.local.BoardMessage;
5 import jp.ac.u_ryukyu.ie.cr.bbs.local.GetAttributeImp; 5 import jp.ac.u_ryukyu.ie.cr.bbs.local.GetAttributeImp;
6 import jp.ac.u_ryukyu.ie.cr.bbs.local.IterableConverter; 6 import jp.ac.u_ryukyu.ie.cr.bbs.local.IterableConverter;
7 import jp.ac.u_ryukyu.ie.cr.jungle.Jungle; 7 import jp.ac.u_ryukyu.ie.cr.jungle.Jungle;
8 import jp.ac.u_ryukyu.ie.cr.jungle.JungleTree;
9 import jp.ac.u_ryukyu.ie.cr.jungle.JungleTreeEditor;
10 import jp.ac.u_ryukyu.ie.cr.jungle.core.Children; 8 import jp.ac.u_ryukyu.ie.cr.jungle.core.Children;
11 import jp.ac.u_ryukyu.ie.cr.jungle.persistent.ChangeList; 9 import jp.ac.u_ryukyu.ie.cr.jungle.persistent.ChangeList;
12 import jp.ac.u_ryukyu.ie.cr.jungle.persistent.ChangeListReader; 10 import jp.ac.u_ryukyu.ie.cr.jungle.persistent.ChangeListReader;
13 import jp.ac.u_ryukyu.ie.cr.jungle.store.impl.DefaultNodePath; 11 import jp.ac.u_ryukyu.ie.cr.jungle.store.logger.DefaultOperationLog;
14 import jp.ac.u_ryukyu.ie.cr.jungle.store.impl.DefaultTreeEditor; 12 import jp.ac.u_ryukyu.ie.cr.jungle.store.logger.LoggingNode;
15 import jp.ac.u_ryukyu.ie.cr.jungle.store.impl.TreeNode; 13 import jp.ac.u_ryukyu.ie.cr.jungle.store.logger.OperationLog;
16 import jp.ac.u_ryukyu.ie.cr.jungle.store.impl.logger.DefaultOperationLog; 14 import jp.ac.u_ryukyu.ie.cr.jungle.store.nodepath.DefaultNodePath;
17 import jp.ac.u_ryukyu.ie.cr.jungle.store.impl.logger.LoggingNode;
18 import jp.ac.u_ryukyu.ie.cr.jungle.store.impl.logger.OperationLog;
19 import jp.ac.u_ryukyu.ie.cr.jungle.store.trasnformer.NodeEditor; 15 import jp.ac.u_ryukyu.ie.cr.jungle.store.trasnformer.NodeEditor;
20 import jp.ac.u_ryukyu.ie.cr.jungle.transaction.DefaultTreeNode; 16 import jp.ac.u_ryukyu.ie.cr.jungle.transaction.editor.jungleTreeEditor.JungleTreeEditor;
17 import jp.ac.u_ryukyu.ie.cr.jungle.transaction.node.Default.DefaultTreeNode;
18 import jp.ac.u_ryukyu.ie.cr.jungle.transaction.node.TreeNode;
21 import jp.ac.u_ryukyu.ie.cr.jungle.traverser.DefaultEvaluator; 19 import jp.ac.u_ryukyu.ie.cr.jungle.traverser.DefaultEvaluator;
22 import jp.ac.u_ryukyu.ie.cr.jungle.traverser.DefaultTraverser; 20 import jp.ac.u_ryukyu.ie.cr.jungle.traverser.DefaultTraverser;
23 import jp.ac.u_ryukyu.ie.cr.jungle.traverser.Traversal; 21 import jp.ac.u_ryukyu.ie.cr.jungle.traverser.Traversal;
22 import jp.ac.u_ryukyu.ie.cr.jungle.tree.JungleTree;
24 import jp.ac.u_ryukyu.ie.cr.jungle.util.DefaultEither; 23 import jp.ac.u_ryukyu.ie.cr.jungle.util.DefaultEither;
25 import jp.ac.u_ryukyu.ie.cr.jungle.util.Either; 24 import jp.ac.u_ryukyu.ie.cr.jungle.util.Either;
26 import jp.ac.u_ryukyu.ie.cr.jungle.util.Error; 25 import jp.ac.u_ryukyu.ie.cr.jungle.util.jungleError.Error;
27 import jp.ac.u_ryukyu.ie.cr.jungleNetwork.core.NetworkDefaultJungle; 26 import jp.ac.u_ryukyu.ie.cr.jungleNetwork.core.NetworkDefaultJungle;
28 import jp.ac.u_ryukyu.ie.cr.jungleNetwork.persistent.AliceJournal; 27 import jp.ac.u_ryukyu.ie.cr.jungleNetwork.persistent.AliceJournal;
29 import jp.ac.u_ryukyu.ie.cr.jungleNetwork.persistent.NetworkJournal; 28 import jp.ac.u_ryukyu.ie.cr.jungleNetwork.persistent.NetworkJournal;
30 import jp.ac.u_ryukyu.ie.cr.jungleNetwork.persistent.PersistentJournal; 29 import jp.ac.u_ryukyu.ie.cr.jungleNetwork.persistent.PersistentJournal;
31 import jp.ac.u_ryukyu.ie.cr.jungleNetwork.transaction.JungleUpdater; 30 import jp.ac.u_ryukyu.ie.cr.jungleNetwork.transaction.JungleUpdater;
44 private AtomicInteger requestCounter; 43 private AtomicInteger requestCounter;
45 private long renewTime; 44 private long renewTime;
46 45
47 private NetworkJungleBulletinBoard(String _uuid, NetworkJournal _journal) { 46 private NetworkJungleBulletinBoard(String _uuid, NetworkJournal _journal) {
48 journal = _journal; 47 journal = _journal;
49 jungle = new NetworkDefaultJungle(journal, _uuid, new DefaultTreeEditor(new DefaultTraverser())); 48 jungle = new NetworkDefaultJungle(journal, _uuid);
50 BulletinBoardJungleManager.setJungle(jungle); 49 BulletinBoardJungleManager.setJungle(jungle);
51 persistentFlag = false; 50 persistentFlag = false;
52 requestCounter = BulletinBoardJungleManager.getRequestCounter(); 51 requestCounter = BulletinBoardJungleManager.getRequestCounter();
53 LOG_DIR = "./log"; 52 LOG_DIR = "./log";
54 renewTime = 0; 53 renewTime = 0;
109 String treeName = chList.getTreeName(); 108 String treeName = chList.getTreeName();
110 JungleTree tree = jungle.getTreeByName(treeName); 109 JungleTree tree = jungle.getTreeByName(treeName);
111 if (tree == null) { 110 if (tree == null) {
112 tree = jungle.createNewTree(treeName); 111 tree = jungle.createNewTree(treeName);
113 } 112 }
114 JungleTreeEditor editor = tree.getLocalTreeEditor(); 113 JungleTreeEditor editor = tree.getLocalJungleTreeEditor();
115 Either<Error, JungleTreeEditor> either = JungleUpdater.edit(editor, chList); 114 Either<Error, JungleTreeEditor> either = JungleUpdater.edit(editor, chList);
116 editor = either.b(); 115 editor = either.b();
117 if (either.isA()) { 116 if (either.isA()) {
118 throw new IOException("Failed commit log recovery"); 117 throw new IOException("Failed commit log recovery");
119 } 118 }
146 if (null == jungle.createNewTree(_name)) { 145 if (null == jungle.createNewTree(_name)) {
147 throw new IllegalStateException(); 146 throw new IllegalStateException();
148 } 147 }
149 148
150 JungleTree tree = jungle.getTreeByName("boards"); 149 JungleTree tree = jungle.getTreeByName("boards");
151 JungleTreeEditor editor = tree.getTreeEditor(); 150 JungleTreeEditor editor = tree.getJungleTreeEditor();
152 DefaultNodePath root = new DefaultNodePath(); 151 DefaultNodePath root = new DefaultNodePath();
153 Either<Error, JungleTreeEditor> either = editor.addNewChildAt(root, 0); 152 Either<Error, JungleTreeEditor> either = editor.addNewChildAt(root, 0);
154 if (either.isA()) { 153 if (either.isA()) {
155 throw new IllegalStateException(); 154 throw new IllegalStateException();
156 } 155 }
172 if (either.isA()) { 171 if (either.isA()) {
173 throw new IllegalStateException(); 172 throw new IllegalStateException();
174 } 173 }
175 174
176 tree = jungle.getTreeByName(_name); 175 tree = jungle.getTreeByName(_name);
177 editor = tree.getTreeEditor(); 176 editor = tree.getJungleTreeEditor();
178 either = editor.addNewChildAt(root, 0); 177 either = editor.addNewChildAt(root, 0);
179 if (either.isA()) { 178 if (either.isA()) {
180 throw new IllegalStateException(); 179 throw new IllegalStateException();
181 } 180 }
182 editor = either.b(); 181 editor = either.b();
183 182
184 NodeEditor e = new NodeEditor() { 183 NodeEditor e = new NodeEditor() {
185 ByteBuffer tBuffer2 = ByteBuffer.allocate(16); 184 ByteBuffer tBuffer2 = ByteBuffer.allocate(16);
186 185
187 public Either<Error, LoggingNode> edit(TreeNode node) { 186 public Either<Error, LoggingNode> edit(TreeNode node) {
188 LoggingNode logNode = wrap(node, new DefaultOperationLog()); 187 LoggingNode logNode = wrap(node,null, new DefaultOperationLog());
189 logNode = logNode.getAttributes().put("author", ByteBuffer.wrap(_author.getBytes())).b(); 188 logNode = logNode.getAttributes().put("author", ByteBuffer.wrap(_author.getBytes())).b();
190 logNode = logNode.getAttributes().put("mes", ByteBuffer.wrap(_initMessage.getBytes())).b(); 189 logNode = logNode.getAttributes().put("mes", ByteBuffer.wrap(_initMessage.getBytes())).b();
191 logNode = logNode.getAttributes().put("key", ByteBuffer.wrap(_editKey.getBytes())).b(); 190 logNode = logNode.getAttributes().put("key", ByteBuffer.wrap(_editKey.getBytes())).b();
192 tBuffer2.putLong(timestamp); 191 tBuffer2.putLong(timestamp);
193 logNode = logNode.getAttributes().put("timestamp", tBuffer2).b(); 192 logNode = logNode.getAttributes().put("timestamp", tBuffer2).b();
194 return DefaultEither.newB(logNode); 193 return DefaultEither.newB(logNode);
195 } 194 }
196 195
197 @Override 196 @Override
198 public LoggingNode wrap(TreeNode node, OperationLog op) { 197 public LoggingNode wrap(TreeNode treeNode, TreeNode treeNode1, OperationLog operationLog) {
199 return new LoggingNode(node, op); 198 return new LoggingNode(treeNode, operationLog);
200 } 199 }
201 }; 200 };
202 201
203 either = editor.edit(root.add(0), e); 202 either = editor.edit(root.add(0), e);
204 if (either.isA()) { 203 if (either.isA()) {
238 } 237 }
239 238
240 Traversal traversal = ret.b(); 239 Traversal traversal = ret.b();
241 TreeNode target = traversal.destination(); 240 TreeNode target = traversal.destination();
242 int size = target.getChildren().size(); 241 int size = target.getChildren().size();
243 JungleTreeEditor editor = tree.getTreeEditor(); 242 JungleTreeEditor editor = tree.getJungleTreeEditor();
244 either = editor.addNewChildAt(path, size); 243 either = editor.addNewChildAt(path, size);
245 if (either.isA()) { 244 if (either.isA()) {
246 throw new IllegalStateException(); 245 throw new IllegalStateException();
247 } 246 }
248 editor = either.b(); 247 editor = either.b();
249 248
250 NodeEditor e = new NodeEditor() { 249 NodeEditor e = new NodeEditor() {
251 250
252 public Either<Error, LoggingNode> edit(TreeNode node) { 251 public Either<Error, LoggingNode> edit(TreeNode node) {
253 LoggingNode logNode = wrap(node, new DefaultOperationLog()); 252 LoggingNode logNode = wrap(node,null, new DefaultOperationLog());
254 logNode = logNode.getAttributes().put("mes", ByteBuffer.wrap(_message.getBytes())).b(); 253 logNode = logNode.getAttributes().put("mes", ByteBuffer.wrap(_message.getBytes())).b();
255 logNode = logNode.getAttributes().put("timestamp", tBuffer).b(); 254 logNode = logNode.getAttributes().put("timestamp", tBuffer).b();
256 return DefaultEither.newB(logNode); 255 return DefaultEither.newB(logNode);
257 } 256 }
258 257
259 @Override 258 @Override
260 public LoggingNode wrap(TreeNode node, OperationLog op) { 259 public LoggingNode wrap(TreeNode node, TreeNode node1, OperationLog op) {
261 return new LoggingNode(node, op); 260 return new LoggingNode(node, op);
262 } 261 }
263 262
264 }; 263 };
265 path = path.add(size); 264 path = path.add(size);
288 287
289 TreeNode node = tree.getRootNode(); 288 TreeNode node = tree.getRootNode();
290 int size = node.getChildren().size(); 289 int size = node.getChildren().size();
291 DefaultNodePath path = new DefaultNodePath(); 290 DefaultNodePath path = new DefaultNodePath();
292 291
293 JungleTreeEditor editor = tree.getTreeEditor(); 292 JungleTreeEditor editor = tree.getJungleTreeEditor();
294 either = editor.addNewChildAt(path, size); 293 either = editor.addNewChildAt(path, size);
295 if (either.isA()) { 294 if (either.isA()) {
296 throw new IllegalStateException(); 295 throw new IllegalStateException();
297 } 296 }
298 editor = either.b(); 297 editor = either.b();
299 298
300 NodeEditor e = new NodeEditor() { 299 NodeEditor e = new NodeEditor() {
301 public Either<Error, LoggingNode> edit(TreeNode node) { 300 public Either<Error, LoggingNode> edit(TreeNode node) {
302 LoggingNode logNode = wrap(node, new DefaultOperationLog()); 301 LoggingNode logNode = wrap(node, null, new DefaultOperationLog());
303 logNode = logNode.getAttributes().put("author", ByteBuffer.wrap(_author.getBytes())).b(); 302 logNode = logNode.getAttributes().put("author", ByteBuffer.wrap(_author.getBytes())).b();
304 logNode = logNode.getAttributes().put("mes", ByteBuffer.wrap(_message.getBytes())).b(); 303 logNode = logNode.getAttributes().put("mes", ByteBuffer.wrap(_message.getBytes())).b();
305 logNode = logNode.getAttributes().put("key", ByteBuffer.wrap(_editKey.getBytes())).b(); 304 logNode = logNode.getAttributes().put("key", ByteBuffer.wrap(_editKey.getBytes())).b();
306 logNode = logNode.getAttributes().put("timestamp", tBuffer).b(); 305 logNode = logNode.getAttributes().put("timestamp", tBuffer).b();
307 return DefaultEither.newB(logNode); 306 return DefaultEither.newB(logNode);
308 } 307 }
309 308
310 @Override 309 @Override
311 public LoggingNode wrap(TreeNode node, OperationLog op) { 310 public LoggingNode wrap(TreeNode node,TreeNode node1, OperationLog op) {
312 return new LoggingNode(node, op); 311 return new LoggingNode(node, op);
313 } 312 }
314 }; 313 };
315 path = path.add(size); 314 path = path.add(size);
316 either = editor.edit(path, e); 315 either = editor.edit(path, e);
337 if (!num.equals("-1")) 336 if (!num.equals("-1"))
338 path = path.add(Integer.parseInt(num)); 337 path = path.add(Integer.parseInt(num));
339 } 338 }
340 do { 339 do {
341 340
342 JungleTreeEditor editor = tree.getTreeEditor(); 341 JungleTreeEditor editor = tree.getJungleTreeEditor();
343 NodeEditor e = new NodeEditor() { 342 NodeEditor e = new NodeEditor() {
344 public Either<Error, LoggingNode> edit(TreeNode node) { 343 public Either<Error, LoggingNode> edit(TreeNode node) {
345 LoggingNode logNode = wrap(node, new DefaultOperationLog()); 344 LoggingNode logNode = wrap(node,null,new DefaultOperationLog());
346 System.out.println(new String(node.getAttributes().get("mes").array())); 345 System.out.println(new String(node.getAttributes().get("mes").array()));
347 logNode = logNode.getAttributes().put("author", ByteBuffer.wrap(_author.getBytes())).b(); 346 logNode = logNode.getAttributes().put("author", ByteBuffer.wrap(_author.getBytes())).b();
348 logNode = logNode.getAttributes().put("mes", ByteBuffer.wrap(_message.getBytes())).b(); 347 logNode = logNode.getAttributes().put("mes", ByteBuffer.wrap(_message.getBytes())).b();
349 logNode = logNode.getAttributes().put("key", ByteBuffer.wrap(_editKey.getBytes())).b(); 348 logNode = logNode.getAttributes().put("key", ByteBuffer.wrap(_editKey.getBytes())).b();
350 logNode = logNode.getAttributes().put("timestamp", tBuffer).b(); 349 logNode = logNode.getAttributes().put("timestamp", tBuffer).b();
351 System.out.println(new String(node.getAttributes().get("mes").array())); 350 System.out.println(new String(node.getAttributes().get("mes").array()));
352 return DefaultEither.newB(logNode); 351 return DefaultEither.newB(logNode);
353 } 352 }
354 353
355 @Override 354 @Override
356 public LoggingNode wrap(TreeNode node, OperationLog op) { 355 public LoggingNode wrap(TreeNode node,TreeNode node1, OperationLog op) {
357 return new LoggingNode(node, op); 356 return new LoggingNode(node, op);
358 } 357 }
359 }; 358 };
360 either = editor.edit(path, e); 359 either = editor.edit(path, e);
361 if (either.isA()) { 360 if (either.isA()) {
381 if (!num.equals("-1")) 380 if (!num.equals("-1"))
382 path = path.add(Integer.parseInt(num)); 381 path = path.add(Integer.parseInt(num));
383 } 382 }
384 383
385 do { 384 do {
386 JungleTreeEditor editor = tree.getTreeEditor(); 385 JungleTreeEditor editor = tree.getJungleTreeEditor();
387 NodeEditor e = new NodeEditor() { 386 NodeEditor e = new NodeEditor() {
388 String str; 387 String str;
389 388
390 public Either<Error, LoggingNode> edit(TreeNode node) { 389 public Either<Error, LoggingNode> edit(TreeNode node) {
391 LoggingNode logNode = wrap(node, new DefaultOperationLog()); 390 LoggingNode logNode = wrap(node, null,new DefaultOperationLog());
392 str = "0"; 391 str = "0";
393 int count = 0; 392 int count = 0;
394 for (; logNode.getAttributes().get("mes" + String.valueOf(count)) != null; count++) { 393 for (; logNode.getAttributes().get("mes" + String.valueOf(count)) != null; count++) {
395 } 394 }
396 str = String.valueOf(count); 395 str = String.valueOf(count);
398 logNode = logNode.getAttributes().put("timestamp" + str, tBuffer).b(); 397 logNode = logNode.getAttributes().put("timestamp" + str, tBuffer).b();
399 return DefaultEither.newB(logNode); 398 return DefaultEither.newB(logNode);
400 } 399 }
401 400
402 @Override 401 @Override
403 public LoggingNode wrap(TreeNode node, OperationLog op) { 402 public LoggingNode wrap(TreeNode node, TreeNode node1,OperationLog op) {
404 return new LoggingNode(node, op); 403 return new LoggingNode(node, op);
405 } 404 }
406 }; 405 };
407 either = editor.edit(path, e); 406 either = editor.edit(path, e);
408 if (either.isA()) { 407 if (either.isA()) {
426 if (!num.equals("-1")) 425 if (!num.equals("-1"))
427 path = path.add(Integer.parseInt(num)); 426 path = path.add(Integer.parseInt(num));
428 } 427 }
429 428
430 do { 429 do {
431 JungleTreeEditor editor = tree.getTreeEditor(); 430 JungleTreeEditor editor = tree.getJungleTreeEditor();
432 NodeEditor e = new NodeEditor() { 431 NodeEditor e = new NodeEditor() {
433 public Either<Error, LoggingNode> edit(TreeNode node) { 432 public Either<Error, LoggingNode> edit(TreeNode node) {
434 LoggingNode logNode = wrap(node, new DefaultOperationLog()); 433 LoggingNode logNode = wrap(node, null,new DefaultOperationLog());
435 logNode = logNode.getAttributes().put("mes" + id, ByteBuffer.wrap(_message.getBytes())).b(); 434 logNode = logNode.getAttributes().put("mes" + id, ByteBuffer.wrap(_message.getBytes())).b();
436 logNode = logNode.getAttributes().put("timestamp" + id, tBuffer).b(); 435 logNode = logNode.getAttributes().put("timestamp" + id, tBuffer).b();
437 return DefaultEither.newB(logNode); 436 return DefaultEither.newB(logNode);
438 } 437 }
439 438
440 @Override 439 @Override
441 public LoggingNode wrap(TreeNode node, OperationLog op) { 440 public LoggingNode wrap(TreeNode node,TreeNode node1, OperationLog op) {
442 return new LoggingNode(node, op); 441 return new LoggingNode(node, op);
443 } 442 }
444 }; 443 };
445 either = editor.edit(path, e); 444 either = editor.edit(path, e);
446 if (either.isA()) { 445 if (either.isA()) {
465 if (!num.equals("-1")) 464 if (!num.equals("-1"))
466 path = path.add(Integer.parseInt(num)); 465 path = path.add(Integer.parseInt(num));
467 } 466 }
468 467
469 do { 468 do {
470 JungleTreeEditor editor = tree.getTreeEditor(); 469 JungleTreeEditor editor = tree.getJungleTreeEditor();
471 470
472 either = editor.deleteChildAt(path, id); 471 either = editor.deleteChildAt(path, id);
473 if (either.isA()) { 472 if (either.isA()) {
474 throw new IllegalStateException(); 473 throw new IllegalStateException();
475 } 474 }
492 if (!num.equals("-1")) 491 if (!num.equals("-1"))
493 path = path.add(Integer.parseInt(num)); 492 path = path.add(Integer.parseInt(num));
494 } 493 }
495 494
496 do { 495 do {
497 JungleTreeEditor editor = tree.getTreeEditor(); 496 JungleTreeEditor editor = tree.getJungleTreeEditor();
498 NodeEditor e = new NodeEditor() { 497 NodeEditor e = new NodeEditor() {
499 public Either<Error, LoggingNode> edit(TreeNode node) { 498 public Either<Error, LoggingNode> edit(TreeNode node) {
500 LoggingNode logNode = wrap(node, new DefaultOperationLog()); 499 LoggingNode logNode = wrap(node,null, new DefaultOperationLog());
501 logNode = logNode.getAttributes().delete("mes" + id).b(); 500 logNode = logNode.getAttributes().delete("mes" + id).b();
502 logNode = logNode.getAttributes().delete("timestamp" + id).b(); 501 logNode = logNode.getAttributes().delete("timestamp" + id).b();
503 int count = Integer.parseInt(id); 502 int count = Integer.parseInt(id);
504 for (; logNode.getAttributes().get("mes" + String.valueOf(count + 1)) != null; ) { 503 for (; logNode.getAttributes().get("mes" + String.valueOf(count + 1)) != null; ) {
505 logNode = logNode.getAttributes() 504 logNode = logNode.getAttributes()
514 513
515 return DefaultEither.newB(logNode); 514 return DefaultEither.newB(logNode);
516 } 515 }
517 516
518 @Override 517 @Override
519 public LoggingNode wrap(TreeNode node, OperationLog op) { 518 public LoggingNode wrap(TreeNode node, TreeNode node1,OperationLog op) {
520 return new LoggingNode(node, op); 519 return new LoggingNode(node, op);
521 } 520 }
522 }; 521 };
523 either = editor.edit(path, e); 522 either = editor.edit(path, e);
524 if (either.isA()) { 523 if (either.isA()) {
539 Either<Error, JungleTreeEditor> either = null; 538 Either<Error, JungleTreeEditor> either = null;
540 do { 539 do {
541 DefaultNodePath path = new DefaultNodePath(); 540 DefaultNodePath path = new DefaultNodePath();
542 path = path.add(Integer.parseInt(_uuid)); 541 path = path.add(Integer.parseInt(_uuid));
543 542
544 JungleTreeEditor editor = tree.getTreeEditor(); 543 JungleTreeEditor editor = tree.getJungleTreeEditor();
545 NodeEditor e = new NodeEditor() { 544 NodeEditor e = new NodeEditor() {
546 public Either<Error, LoggingNode> edit(TreeNode node) { 545 public Either<Error, LoggingNode> edit(TreeNode node) {
547 LoggingNode logNode = wrap(node, new DefaultOperationLog()); 546 LoggingNode logNode = wrap(node, null,new DefaultOperationLog());
548 logNode = logNode.getAttributes().put("author", ByteBuffer.wrap(_author.getBytes())).b(); 547 logNode = logNode.getAttributes().put("author", ByteBuffer.wrap(_author.getBytes())).b();
549 logNode = logNode.getAttributes().put("mes", ByteBuffer.wrap(_message.getBytes())).b(); 548 logNode = logNode.getAttributes().put("mes", ByteBuffer.wrap(_message.getBytes())).b();
550 logNode = logNode.getAttributes().put("key", ByteBuffer.wrap(_editKey.getBytes())).b(); 549 logNode = logNode.getAttributes().put("key", ByteBuffer.wrap(_editKey.getBytes())).b();
551 logNode = logNode.getAttributes().put("timestamp", tBuffer).b(); 550 logNode = logNode.getAttributes().put("timestamp", tBuffer).b();
552 return DefaultEither.newB(logNode); 551 return DefaultEither.newB(logNode);
553 } 552 }
554 553
555 @Override 554 @Override
556 public LoggingNode wrap(TreeNode node, OperationLog op) { 555 public LoggingNode wrap(TreeNode node, TreeNode node1,OperationLog op) {
557 return new LoggingNode(node, op); 556 return new LoggingNode(node, op);
558 } 557 }
559 }; 558 };
560 either = editor.edit(path, e); 559 either = editor.edit(path, e);
561 if (either.isA()) { 560 if (either.isA()) {