Mercurial > hg > Members > shoshi > jungle > bbs
annotate src/main/java/jp/ac/u_ryukyu/ie/cr/bbs/network/NetworkJungleBulletinBoard.java @ 21:ee82133f619f default tip
import LogUpdateCodeSegment
| author | suruga |
|---|---|
| date | Mon, 28 Aug 2017 19:50:18 +0900 |
| parents | 7164db5bc76f |
| children |
| rev | line source |
|---|---|
| 2 | 1 package jp.ac.u_ryukyu.ie.cr.bbs.network; |
| 2 | |
| 3 | |
| 3 | 4 import jp.ac.u_ryukyu.ie.cr.bbs.local.BoardMessage; |
| 5 import jp.ac.u_ryukyu.ie.cr.bbs.local.GetAttributeImp; | |
| 6 import jp.ac.u_ryukyu.ie.cr.bbs.local.IterableConverter; | |
| 2 | 7 import jp.ac.u_ryukyu.ie.cr.jungle.Jungle; |
| 8 import jp.ac.u_ryukyu.ie.cr.jungle.core.Children; | |
| 9 import jp.ac.u_ryukyu.ie.cr.jungle.persistent.ChangeList; | |
| 10 import jp.ac.u_ryukyu.ie.cr.jungle.persistent.ChangeListReader; | |
| 8 | 11 import jp.ac.u_ryukyu.ie.cr.jungle.store.logger.DefaultOperationLog; |
| 12 import jp.ac.u_ryukyu.ie.cr.jungle.store.logger.LoggingNode; | |
| 13 import jp.ac.u_ryukyu.ie.cr.jungle.store.logger.OperationLog; | |
| 14 import jp.ac.u_ryukyu.ie.cr.jungle.store.nodepath.DefaultNodePath; | |
| 2 | 15 import jp.ac.u_ryukyu.ie.cr.jungle.store.trasnformer.NodeEditor; |
| 8 | 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; | |
| 2 | 19 import jp.ac.u_ryukyu.ie.cr.jungle.traverser.DefaultEvaluator; |
| 20 import jp.ac.u_ryukyu.ie.cr.jungle.traverser.DefaultTraverser; | |
| 21 import jp.ac.u_ryukyu.ie.cr.jungle.traverser.Traversal; | |
| 8 | 22 import jp.ac.u_ryukyu.ie.cr.jungle.tree.JungleTree; |
| 2 | 23 import jp.ac.u_ryukyu.ie.cr.jungle.util.DefaultEither; |
| 24 import jp.ac.u_ryukyu.ie.cr.jungle.util.Either; | |
| 8 | 25 import jp.ac.u_ryukyu.ie.cr.jungle.util.jungleError.Error; |
|
20
7164db5bc76f
fix BulltinBoardJungleamanager singleton
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents:
10
diff
changeset
|
26 import jp.ac.u_ryukyu.ie.cr.jungleNetwork.codesegment.JungleDistributedUpdator; |
| 2 | 27 import jp.ac.u_ryukyu.ie.cr.jungleNetwork.core.NetworkDefaultJungle; |
| 28 import jp.ac.u_ryukyu.ie.cr.jungleNetwork.persistent.AliceJournal; | |
| 29 import jp.ac.u_ryukyu.ie.cr.jungleNetwork.persistent.NetworkJournal; | |
| 30 import jp.ac.u_ryukyu.ie.cr.jungleNetwork.persistent.PersistentJournal; | |
| 31 import jp.ac.u_ryukyu.ie.cr.jungleNetwork.transaction.JungleUpdater; | |
| 32 | |
| 33 import java.io.File; | |
| 34 import java.io.IOException; | |
| 35 import java.nio.ByteBuffer; | |
| 36 import java.util.concurrent.atomic.AtomicInteger; | |
| 10 | 37 import static org.junit.Assert.*; |
| 2 | 38 |
| 39 public class NetworkJungleBulletinBoard implements NetworkBulletinBoard { | |
| 40 protected final Jungle jungle; | |
| 41 private final NetworkJournal journal; | |
| 42 private final String LOG_DIR; | |
|
20
7164db5bc76f
fix BulltinBoardJungleamanager singleton
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents:
10
diff
changeset
|
43 private final BulletinBoardJungleManager bm; |
| 2 | 44 private Boolean persistentFlag; |
| 45 private AtomicInteger requestCounter; | |
| 46 private long renewTime; | |
| 47 | |
| 48 private NetworkJungleBulletinBoard(String _uuid, NetworkJournal _journal) { | |
| 49 journal = _journal; | |
| 8 | 50 jungle = new NetworkDefaultJungle(journal, _uuid); |
|
20
7164db5bc76f
fix BulltinBoardJungleamanager singleton
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents:
10
diff
changeset
|
51 bm = new BulletinBoardJungleManager(jungle); |
| 2 | 52 persistentFlag = false; |
|
20
7164db5bc76f
fix BulltinBoardJungleamanager singleton
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents:
10
diff
changeset
|
53 requestCounter = bm.getRequestCounter(); |
| 2 | 54 LOG_DIR = "./log"; |
| 55 renewTime = 0; | |
| 56 } | |
| 57 | |
| 58 public NetworkJungleBulletinBoard(String _uuid) { | |
| 59 this(_uuid, new AliceJournal()); | |
| 60 jungle.createNewTree("boards"); | |
| 61 } | |
| 62 | |
| 63 public static NetworkBulletinBoard NewPersistentJungle(String _uuid) { | |
| 64 NetworkJungleBulletinBoard board = new NetworkJungleBulletinBoard(_uuid, new PersistentJournal()); | |
| 65 board.persistentFlag = true; | |
| 66 return board; | |
| 67 } | |
| 68 | |
| 21 | 69 public JungleDistributedUpdator getUpdator() { return bm; } |
|
20
7164db5bc76f
fix BulltinBoardJungleamanager singleton
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents:
10
diff
changeset
|
70 |
| 2 | 71 public void init() { |
| 72 if (!persistentFlag) { | |
| 73 return; | |
| 74 } | |
| 75 checkAndCreateLogDirectory(); | |
| 76 try { | |
| 77 commitLogRecover(); | |
| 78 } catch (IOException e) { | |
| 79 e.printStackTrace(); | |
| 80 } | |
| 81 } | |
| 82 | |
| 83 public void checkAndCreateLogDirectory() { | |
| 84 File logFile = new File(LOG_DIR); | |
| 85 if (!logFile.exists()) { | |
| 86 logFile.mkdir(); | |
| 87 return; | |
| 88 } | |
| 89 if (logFile.isFile()) { | |
| 90 logFile.delete(); | |
| 91 logFile.mkdir(); | |
| 92 } | |
| 93 } | |
| 94 | |
| 95 public void commitLogRecover() throws IOException { | |
| 96 File[] logFiles = new File(LOG_DIR).listFiles(); | |
| 97 for (File logFile : logFiles) { | |
| 98 commitLogRecover(logFile); | |
| 99 logFile.delete(); | |
| 100 } | |
| 101 if (jungle.getTreeByName("boards") == null) { | |
| 102 jungle.createNewTree("boards"); | |
| 103 } | |
| 104 } | |
| 105 | |
| 106 private void commitLogRecover(File logFile) throws IOException { | |
| 107 journal.setInputFile(logFile); | |
| 108 ChangeListReader reader = journal.getReader(); | |
| 109 if (reader == null) | |
| 110 return; | |
| 111 for (ChangeList chList : reader) { | |
| 112 String treeName = chList.getTreeName(); | |
| 113 JungleTree tree = jungle.getTreeByName(treeName); | |
| 114 if (tree == null) { | |
| 115 tree = jungle.createNewTree(treeName); | |
| 116 } | |
| 8 | 117 JungleTreeEditor editor = tree.getLocalJungleTreeEditor(); |
| 2 | 118 Either<Error, JungleTreeEditor> either = JungleUpdater.edit(editor, chList); |
| 119 editor = either.b(); | |
| 120 if (either.isA()) { | |
| 121 throw new IOException("Failed commit log recovery"); | |
| 122 } | |
| 123 editor.success(); | |
| 124 } | |
| 125 } | |
| 126 | |
| 127 public Iterable<String> getBoards() { | |
| 128 JungleTree tree = jungle.getTreeByName("boards"); | |
| 129 TreeNode node = tree.getRootNode(); | |
| 130 Children chs = node.getChildren(); | |
| 131 | |
| 132 IterableConverter.Converter<String, TreeNode> converter = new IterableConverter.Converter<String, TreeNode>() { | |
| 133 public String conv(TreeNode _b) { | |
| 134 ByteBuffer e = _b.getAttributes().get("name"); | |
| 135 System.out.println(new String(e.array())); | |
| 136 return new String(e.array()); | |
| 137 } | |
| 138 }; | |
| 139 | |
| 140 return new IterableConverter<String, TreeNode>(chs, converter); | |
| 141 } | |
| 142 | |
| 143 public long getRenewTime(String _boardName) { | |
| 144 return renewTime; | |
| 145 } | |
| 146 | |
| 147 public void createBoards(final String _name, final String _author, final String _initMessage, final String _editKey) { | |
| 148 requestCounter.incrementAndGet(); | |
| 149 if (null == jungle.createNewTree(_name)) { | |
| 150 throw new IllegalStateException(); | |
| 151 } | |
| 152 | |
| 153 JungleTree tree = jungle.getTreeByName("boards"); | |
| 8 | 154 JungleTreeEditor editor = tree.getJungleTreeEditor(); |
| 2 | 155 DefaultNodePath root = new DefaultNodePath(); |
| 156 Either<Error, JungleTreeEditor> either = editor.addNewChildAt(root, 0); | |
| 157 if (either.isA()) { | |
| 158 throw new IllegalStateException(); | |
| 159 } | |
| 160 editor = either.b(); | |
| 161 | |
| 162 either = editor.putAttribute(root.add(0), "name", ByteBuffer.wrap(_name.getBytes())); | |
| 163 if (either.isA()) { | |
| 164 throw new IllegalStateException(); | |
| 165 } | |
| 166 editor = either.b(); | |
| 167 final long timestamp = System.currentTimeMillis(); | |
| 168 ByteBuffer tBuffer = ByteBuffer.allocate(16); | |
| 169 tBuffer.putLong(timestamp); | |
| 170 either = editor.putAttribute(root.add(0), "timestamp", tBuffer); | |
| 171 if (either.isA()) { | |
| 172 throw new IllegalStateException(); | |
| 173 } | |
| 174 either = either.b().success(); | |
| 175 if (either.isA()) { | |
| 176 throw new IllegalStateException(); | |
| 177 } | |
| 178 | |
| 179 tree = jungle.getTreeByName(_name); | |
| 8 | 180 editor = tree.getJungleTreeEditor(); |
| 2 | 181 either = editor.addNewChildAt(root, 0); |
| 182 if (either.isA()) { | |
| 183 throw new IllegalStateException(); | |
| 184 } | |
| 185 editor = either.b(); | |
| 186 | |
| 9 | 187 jungleTransaction(editor, root,0, timestamp, logNode -> { |
| 188 logNode = logNode.getAttributes().put("author", ByteBuffer.wrap(_author.getBytes())).b(); | |
| 189 logNode = logNode.getAttributes().put("mes", ByteBuffer.wrap(_initMessage.getBytes())).b(); | |
| 190 logNode = logNode.getAttributes().put("key", ByteBuffer.wrap(_editKey.getBytes())).b(); | |
| 191 return logNode; | |
| 192 }); | |
| 193 } | |
| 194 | |
| 195 private Either<Error, JungleTreeEditor> jungleTransaction(JungleTreeEditor editor, DefaultNodePath path, int size, final long timestamp, JungleTransaction getLoggingNode) { | |
| 196 Either<Error, JungleTreeEditor> either; | |
| 2 | 197 NodeEditor e = new NodeEditor() { |
| 198 | |
| 199 public Either<Error, LoggingNode> edit(TreeNode node) { | |
| 8 | 200 LoggingNode logNode = wrap(node,null, new DefaultOperationLog()); |
| 9 | 201 ByteBuffer tBuffer2 = ByteBuffer.allocate(16); |
| 202 logNode = getLoggingNode.transaction(logNode); | |
| 2 | 203 tBuffer2.putLong(timestamp); |
| 204 logNode = logNode.getAttributes().put("timestamp", tBuffer2).b(); | |
| 205 return DefaultEither.newB(logNode); | |
| 206 } | |
| 207 @Override | |
| 8 | 208 public LoggingNode wrap(TreeNode treeNode, TreeNode treeNode1, OperationLog operationLog) { |
| 209 return new LoggingNode(treeNode, operationLog); | |
| 2 | 210 } |
| 211 }; | |
| 212 | |
| 9 | 213 either = editor.edit(path.add(size), e); |
| 2 | 214 if (either.isA()) { |
| 215 throw new IllegalStateException(); | |
| 216 } | |
| 217 either.b().success(); | |
| 9 | 218 return either; |
| 2 | 219 } |
| 220 | |
| 221 public void createFolder(final String _board, final String _author, final String _message, final String _editKey, | |
| 222 String _path) { | |
| 223 JungleTree tree = jungle.getTreeByName(_board); | |
| 224 if (tree == null) { | |
| 225 throw new IllegalStateException(); | |
| 226 } | |
| 227 | |
| 228 DefaultNodePath path = new DefaultNodePath(); | |
| 229 String[] nums = _path.split(","); | |
| 230 for (String num : nums) { | |
| 231 if (!num.equals("-1")) | |
| 232 path = path.add(Integer.parseInt(num)); | |
| 233 } | |
| 234 | |
| 235 requestCounter.incrementAndGet(); | |
| 236 Either<Error, JungleTreeEditor> either; | |
| 237 final long timestamp = System.currentTimeMillis(); | |
| 238 final ByteBuffer tBuffer = ByteBuffer.allocate(16); | |
| 239 tBuffer.putLong(timestamp); | |
| 240 | |
| 241 do { | |
| 242 TreeNode node = tree.getRootNode(); | |
| 243 DefaultTraverser traverser = new DefaultTraverser(); | |
| 244 DefaultEvaluator evaluator = new DefaultEvaluator(path); | |
| 245 Either<Error, Traversal> ret = traverser.traverse(node, evaluator); | |
| 246 if (ret.isA()) { | |
| 10 | 247 assertEquals(1,0); |
| 2 | 248 } |
| 249 | |
| 250 Traversal traversal = ret.b(); | |
| 251 TreeNode target = traversal.destination(); | |
| 252 int size = target.getChildren().size(); | |
| 8 | 253 JungleTreeEditor editor = tree.getJungleTreeEditor(); |
| 2 | 254 either = editor.addNewChildAt(path, size); |
| 255 if (either.isA()) { | |
| 256 throw new IllegalStateException(); | |
| 257 } | |
| 258 editor = either.b(); | |
| 259 | |
| 9 | 260 either = jungleTransaction(editor, path,size, timestamp, logNode -> { |
| 261 logNode = logNode.getAttributes().put("mes", ByteBuffer.wrap(_message.getBytes())).b(); | |
| 262 logNode = logNode.getAttributes().put("timestamp", tBuffer).b(); | |
| 263 return logNode; | |
| 264 }); | |
| 2 | 265 } while (either.isA()); |
| 266 | |
| 267 } | |
| 268 | |
| 269 public void createBoardMessage(final String _board, final String _author, final String _message, final String _editKey) { | |
| 270 requestCounter.incrementAndGet(); | |
| 271 JungleTree tree = jungle.getTreeByName(_board); | |
| 272 if (tree == null) { | |
| 273 throw new IllegalStateException(); | |
| 274 } | |
| 275 | |
| 276 Either<Error, JungleTreeEditor> either; | |
| 277 final long timestamp = System.currentTimeMillis(); | |
| 278 final ByteBuffer tBuffer = ByteBuffer.allocate(16); | |
| 279 tBuffer.putLong(timestamp); | |
| 280 do { | |
| 281 | |
| 282 TreeNode node = tree.getRootNode(); | |
| 283 int size = node.getChildren().size(); | |
| 284 DefaultNodePath path = new DefaultNodePath(); | |
| 285 | |
| 8 | 286 JungleTreeEditor editor = tree.getJungleTreeEditor(); |
| 2 | 287 either = editor.addNewChildAt(path, size); |
| 288 if (either.isA()) { | |
| 289 throw new IllegalStateException(); | |
| 290 } | |
| 291 editor = either.b(); | |
| 292 | |
| 293 NodeEditor e = new NodeEditor() { | |
| 294 public Either<Error, LoggingNode> edit(TreeNode node) { | |
| 8 | 295 LoggingNode logNode = wrap(node, null, new DefaultOperationLog()); |
| 2 | 296 logNode = logNode.getAttributes().put("author", ByteBuffer.wrap(_author.getBytes())).b(); |
| 297 logNode = logNode.getAttributes().put("mes", ByteBuffer.wrap(_message.getBytes())).b(); | |
| 298 logNode = logNode.getAttributes().put("key", ByteBuffer.wrap(_editKey.getBytes())).b(); | |
| 299 logNode = logNode.getAttributes().put("timestamp", tBuffer).b(); | |
| 300 return DefaultEither.newB(logNode); | |
| 301 } | |
| 302 | |
| 303 @Override | |
| 8 | 304 public LoggingNode wrap(TreeNode node,TreeNode node1, OperationLog op) { |
| 2 | 305 return new LoggingNode(node, op); |
| 306 } | |
| 307 }; | |
| 308 path = path.add(size); | |
| 309 either = editor.edit(path, e); | |
| 310 if (either.isA()) { | |
| 311 throw new IllegalStateException(); | |
| 312 } | |
| 313 editor = either.b(); | |
| 314 either = editor.success(); | |
| 315 } while (either.isA()); | |
| 316 | |
| 317 } | |
| 318 | |
| 319 public void editMessage(String _board, String _path, final String _author, final String _message, | |
| 320 final String _editKey) { | |
| 321 requestCounter.incrementAndGet(); | |
| 322 final long timestamp = System.currentTimeMillis(); | |
| 323 final ByteBuffer tBuffer = ByteBuffer.allocate(16); | |
| 324 tBuffer.putLong(timestamp); | |
| 325 JungleTree tree = jungle.getTreeByName(_board); | |
| 326 Either<Error, JungleTreeEditor> either = null; | |
| 327 DefaultNodePath path = new DefaultNodePath(); | |
| 328 String[] nums = _path.split(","); | |
| 329 for (String num : nums) { | |
| 330 if (!num.equals("-1")) | |
| 331 path = path.add(Integer.parseInt(num)); | |
| 332 } | |
| 333 do { | |
| 334 | |
| 8 | 335 JungleTreeEditor editor = tree.getJungleTreeEditor(); |
| 2 | 336 NodeEditor e = new NodeEditor() { |
| 337 public Either<Error, LoggingNode> edit(TreeNode node) { | |
| 8 | 338 LoggingNode logNode = wrap(node,null,new DefaultOperationLog()); |
| 2 | 339 System.out.println(new String(node.getAttributes().get("mes").array())); |
| 340 logNode = logNode.getAttributes().put("author", ByteBuffer.wrap(_author.getBytes())).b(); | |
| 341 logNode = logNode.getAttributes().put("mes", ByteBuffer.wrap(_message.getBytes())).b(); | |
| 342 logNode = logNode.getAttributes().put("key", ByteBuffer.wrap(_editKey.getBytes())).b(); | |
| 343 logNode = logNode.getAttributes().put("timestamp", tBuffer).b(); | |
| 344 System.out.println(new String(node.getAttributes().get("mes").array())); | |
| 345 return DefaultEither.newB(logNode); | |
| 346 } | |
| 347 | |
| 348 @Override | |
| 8 | 349 public LoggingNode wrap(TreeNode node,TreeNode node1, OperationLog op) { |
| 2 | 350 return new LoggingNode(node, op); |
| 351 } | |
| 352 }; | |
| 353 either = editor.edit(path, e); | |
| 354 if (either.isA()) { | |
| 355 throw new IllegalStateException(); | |
| 356 } | |
| 357 editor = either.b(); | |
| 358 either = editor.success(); | |
| 359 } while (either.isA()); | |
| 360 renewTime = timestamp; | |
| 361 } | |
| 362 | |
| 363 public void createAttribute(String _board, String _path, final String _author, final String _message, | |
| 364 final String _editKey) { | |
| 365 requestCounter.incrementAndGet(); | |
| 366 final long timestamp = System.currentTimeMillis(); | |
| 367 final ByteBuffer tBuffer = ByteBuffer.allocate(16); | |
| 368 tBuffer.putLong(timestamp); | |
| 369 JungleTree tree = jungle.getTreeByName(_board); | |
| 370 Either<Error, JungleTreeEditor> either = null; | |
| 371 DefaultNodePath path = new DefaultNodePath(); | |
| 372 String[] nums = _path.split(","); | |
| 373 for (String num : nums) { | |
| 374 if (!num.equals("-1")) | |
| 375 path = path.add(Integer.parseInt(num)); | |
| 376 } | |
| 377 | |
| 378 do { | |
| 8 | 379 JungleTreeEditor editor = tree.getJungleTreeEditor(); |
| 2 | 380 NodeEditor e = new NodeEditor() { |
| 381 String str; | |
| 382 | |
| 383 public Either<Error, LoggingNode> edit(TreeNode node) { | |
| 8 | 384 LoggingNode logNode = wrap(node, null,new DefaultOperationLog()); |
| 2 | 385 str = "0"; |
| 386 int count = 0; | |
| 387 for (; logNode.getAttributes().get("mes" + String.valueOf(count)) != null; count++) { | |
| 388 } | |
| 389 str = String.valueOf(count); | |
| 390 logNode = logNode.getAttributes().put("mes" + str, ByteBuffer.wrap(_message.getBytes())).b(); | |
| 391 logNode = logNode.getAttributes().put("timestamp" + str, tBuffer).b(); | |
| 392 return DefaultEither.newB(logNode); | |
| 393 } | |
| 394 | |
| 395 @Override | |
| 8 | 396 public LoggingNode wrap(TreeNode node, TreeNode node1,OperationLog op) { |
| 2 | 397 return new LoggingNode(node, op); |
| 398 } | |
| 399 }; | |
| 400 either = editor.edit(path, e); | |
| 401 if (either.isA()) { | |
| 402 throw new IllegalStateException(); | |
| 403 } | |
| 404 editor = either.b(); | |
| 405 either = editor.success(); | |
| 406 } while (either.isA()); | |
| 407 } | |
| 408 | |
| 409 public void editAttribute(String _bname, String _path, final String id, final String _message) { | |
| 410 requestCounter.incrementAndGet(); | |
| 411 final long timestamp = System.currentTimeMillis(); | |
| 412 final ByteBuffer tBuffer = ByteBuffer.allocate(16); | |
| 413 tBuffer.putLong(timestamp); | |
| 414 JungleTree tree = jungle.getTreeByName(_bname); | |
| 415 Either<Error, JungleTreeEditor> either = null; | |
| 416 DefaultNodePath path = new DefaultNodePath(); | |
| 417 String[] nums = _path.split(","); | |
| 418 for (String num : nums) { | |
| 419 if (!num.equals("-1")) | |
| 420 path = path.add(Integer.parseInt(num)); | |
| 421 } | |
| 422 | |
| 423 do { | |
| 8 | 424 JungleTreeEditor editor = tree.getJungleTreeEditor(); |
| 2 | 425 NodeEditor e = new NodeEditor() { |
| 426 public Either<Error, LoggingNode> edit(TreeNode node) { | |
| 8 | 427 LoggingNode logNode = wrap(node, null,new DefaultOperationLog()); |
| 2 | 428 logNode = logNode.getAttributes().put("mes" + id, ByteBuffer.wrap(_message.getBytes())).b(); |
| 429 logNode = logNode.getAttributes().put("timestamp" + id, tBuffer).b(); | |
| 430 return DefaultEither.newB(logNode); | |
| 431 } | |
| 432 | |
| 433 @Override | |
| 8 | 434 public LoggingNode wrap(TreeNode node,TreeNode node1, OperationLog op) { |
| 2 | 435 return new LoggingNode(node, op); |
| 436 } | |
| 437 }; | |
| 438 either = editor.edit(path, e); | |
| 439 if (either.isA()) { | |
| 440 throw new IllegalStateException(); | |
| 441 } | |
| 442 editor = either.b(); | |
| 443 either = editor.success(); | |
| 444 } while (either.isA()); | |
| 445 } | |
| 446 | |
| 447 public void deleteNode(String _board, String _path, String _id) { | |
| 448 requestCounter.incrementAndGet(); | |
| 449 int id = Integer.parseInt(_id); | |
| 450 final long timestamp = System.currentTimeMillis(); | |
| 451 final ByteBuffer tBuffer = ByteBuffer.allocate(16); | |
| 452 tBuffer.putLong(timestamp); | |
| 453 JungleTree tree = jungle.getTreeByName(_board); | |
| 454 Either<Error, JungleTreeEditor> either = null; | |
| 455 DefaultNodePath path = new DefaultNodePath(); | |
| 456 String[] nums = _path.split(","); | |
| 457 for (String num : nums) { | |
| 458 if (!num.equals("-1")) | |
| 459 path = path.add(Integer.parseInt(num)); | |
| 460 } | |
| 461 | |
| 462 do { | |
| 8 | 463 JungleTreeEditor editor = tree.getJungleTreeEditor(); |
| 2 | 464 |
| 465 either = editor.deleteChildAt(path, id); | |
| 466 if (either.isA()) { | |
| 467 throw new IllegalStateException(); | |
| 468 } | |
| 469 editor = either.b(); | |
| 470 either = editor.success(); | |
| 471 } while (either.isA()); | |
| 472 | |
| 473 } | |
| 474 | |
| 475 public void deleteAttribute(String _board, String _path, final String id) { | |
| 476 requestCounter.incrementAndGet(); | |
| 477 final long timestamp = System.currentTimeMillis(); | |
| 478 final ByteBuffer tBuffer = ByteBuffer.allocate(16); | |
| 479 tBuffer.putLong(timestamp); | |
| 480 JungleTree tree = jungle.getTreeByName(_board); | |
| 481 Either<Error, JungleTreeEditor> either = null; | |
| 482 DefaultNodePath path = new DefaultNodePath(); | |
| 483 String[] nums = _path.split(","); | |
| 484 for (String num : nums) { | |
| 485 if (!num.equals("-1")) | |
| 486 path = path.add(Integer.parseInt(num)); | |
| 487 } | |
| 488 | |
| 489 do { | |
| 8 | 490 JungleTreeEditor editor = tree.getJungleTreeEditor(); |
| 2 | 491 NodeEditor e = new NodeEditor() { |
| 492 public Either<Error, LoggingNode> edit(TreeNode node) { | |
| 8 | 493 LoggingNode logNode = wrap(node,null, new DefaultOperationLog()); |
| 2 | 494 logNode = logNode.getAttributes().delete("mes" + id).b(); |
| 495 logNode = logNode.getAttributes().delete("timestamp" + id).b(); | |
| 496 int count = Integer.parseInt(id); | |
| 497 for (; logNode.getAttributes().get("mes" + String.valueOf(count + 1)) != null; ) { | |
| 498 logNode = logNode.getAttributes() | |
| 499 .put("mes" + count, node.getAttributes().get("mes" + String.valueOf(count + 1))).b(); | |
| 500 logNode = logNode.getAttributes().put("timestamp" + count, tBuffer).b(); | |
| 501 count++; | |
| 502 } | |
| 503 if (count != Integer.parseInt(id)) { | |
| 504 logNode = logNode.getAttributes().delete("timestamp" + count).b(); | |
| 505 logNode = logNode.getAttributes().delete("mes" + count).b(); | |
| 506 } | |
| 507 | |
| 508 return DefaultEither.newB(logNode); | |
| 509 } | |
| 510 | |
| 511 @Override | |
| 8 | 512 public LoggingNode wrap(TreeNode node, TreeNode node1,OperationLog op) { |
| 2 | 513 return new LoggingNode(node, op); |
| 514 } | |
| 515 }; | |
| 516 either = editor.edit(path, e); | |
| 517 if (either.isA()) { | |
| 518 throw new IllegalStateException(); | |
| 519 } | |
| 520 editor = either.b(); | |
| 521 either = editor.success(); | |
| 522 } while (either.isA()); | |
| 523 } | |
| 524 | |
| 525 public void editMatrixMessage(String _board, String _uuid, final String _author, final String _message, | |
| 526 final String _editKey) { | |
| 527 requestCounter.incrementAndGet(); | |
| 528 final long timestamp = System.currentTimeMillis(); | |
| 529 final ByteBuffer tBuffer = ByteBuffer.allocate(16); | |
| 530 tBuffer.putLong(timestamp); | |
| 531 JungleTree tree = jungle.getTreeByName(_board); | |
| 532 Either<Error, JungleTreeEditor> either = null; | |
| 533 do { | |
| 534 DefaultNodePath path = new DefaultNodePath(); | |
| 535 path = path.add(Integer.parseInt(_uuid)); | |
| 536 | |
| 8 | 537 JungleTreeEditor editor = tree.getJungleTreeEditor(); |
| 2 | 538 NodeEditor e = new NodeEditor() { |
| 539 public Either<Error, LoggingNode> edit(TreeNode node) { | |
| 8 | 540 LoggingNode logNode = wrap(node, null,new DefaultOperationLog()); |
| 2 | 541 logNode = logNode.getAttributes().put("author", ByteBuffer.wrap(_author.getBytes())).b(); |
| 542 logNode = logNode.getAttributes().put("mes", ByteBuffer.wrap(_message.getBytes())).b(); | |
| 543 logNode = logNode.getAttributes().put("key", ByteBuffer.wrap(_editKey.getBytes())).b(); | |
| 544 logNode = logNode.getAttributes().put("timestamp", tBuffer).b(); | |
| 545 return DefaultEither.newB(logNode); | |
| 546 } | |
| 547 | |
| 548 @Override | |
| 8 | 549 public LoggingNode wrap(TreeNode node, TreeNode node1,OperationLog op) { |
| 2 | 550 return new LoggingNode(node, op); |
| 551 } | |
| 552 }; | |
| 553 either = editor.edit(path, e); | |
| 554 if (either.isA()) { | |
| 555 throw new IllegalStateException(); | |
| 556 } | |
| 557 editor = either.b(); | |
| 558 either = editor.success(); | |
| 559 } while (either.isA()); | |
| 560 renewTime = timestamp; | |
| 561 } | |
| 562 | |
| 563 public Iterable<BoardMessage> getFolder(String _boardName, String _nodeNum) { | |
| 564 DefaultNodePath path = new DefaultNodePath(); | |
| 565 System.out.println(_nodeNum.substring(0, 1)); | |
| 566 String[] nums = _nodeNum.split(","); | |
| 567 for (String num : nums) { | |
| 568 if (!num.equals("-1")) | |
| 569 path = path.add(Integer.parseInt(num)); | |
| 570 } | |
| 571 JungleTree tree = jungle.getTreeByName(_boardName); | |
| 572 TreeNode node = tree.getRootNode(); | |
| 573 requestCounter.incrementAndGet(); | |
| 574 | |
| 575 DefaultTraverser traverser = new DefaultTraverser(); | |
| 576 DefaultEvaluator evaluator = new DefaultEvaluator(path); | |
| 577 Either<Error, Traversal> ret = traverser.traverse(node, evaluator); | |
| 578 if (ret.isA()) { | |
| 10 | 579 assertEquals(1,0); |
| 2 | 580 } |
| 581 | |
| 582 Traversal traversal = ret.b(); | |
| 583 TreeNode target = traversal.destination(); | |
| 584 Children chs = target.getChildren(); | |
| 585 | |
| 586 final AtomicInteger counter = new AtomicInteger(0); | |
| 587 IterableConverter.Converter<BoardMessage, TreeNode> converter = new IterableConverter.Converter<BoardMessage, TreeNode>() { | |
| 588 public BoardMessage conv(TreeNode _b) { | |
| 589 String uuid = Integer.toString(counter.get()); | |
| 590 String message = new String(_b.getAttributes().get("mes").array()); | |
| 591 counter.incrementAndGet(); | |
| 592 return new BoardMessageImpl(null, message, uuid); | |
| 593 } | |
| 594 }; | |
| 595 return new IterableConverter<BoardMessage, TreeNode>(chs, converter); | |
| 596 } | |
| 597 | |
| 598 public boolean compare(TreeNode compareNode, String compareAttribute) { | |
| 599 String labName = compareNode.getAttributes().getString("mes"); | |
| 600 if (labName.equals(compareAttribute)) | |
| 601 return true; | |
| 602 | |
| 603 for (int loopCount = 0; compareNode.getAttributes().getString("mes" + loopCount) != null; loopCount++) { | |
| 604 labName = compareNode.getAttributes().getString("mes" + loopCount); | |
| 605 if (labName.equals(compareAttribute)) | |
| 606 return true; | |
| 607 } | |
| 608 | |
| 609 return false; | |
| 610 } | |
| 611 | |
| 612 public int getRequestNum() { | |
| 613 return requestCounter.get(); | |
| 614 } | |
| 615 | |
| 616 private static class BoardMessageImpl implements BoardMessage { | |
| 617 private final String author; | |
| 618 private final String message; | |
| 619 private final String uuid; | |
| 620 | |
| 621 public BoardMessageImpl(String _author, String _message, String _uuid) { | |
| 622 author = _author; | |
| 623 message = _message; | |
| 624 uuid = _uuid; | |
| 625 } | |
| 626 | |
| 627 public String getAuthor() { | |
| 628 return author; | |
| 629 } | |
| 630 | |
| 631 public String getMessage() { | |
| 632 return message; | |
| 633 } | |
| 634 | |
| 635 public String getUUID() { | |
| 636 return uuid; | |
| 637 } | |
| 638 | |
| 639 } | |
| 640 | |
| 641 public String sanitize(String str) { | |
| 642 if (str == null) { | |
| 643 return str; | |
| 644 } | |
| 645 str = str.replaceAll("&", "&"); | |
| 646 str = str.replaceAll("<", "<"); | |
| 647 str = str.replaceAll(">", ">"); | |
| 648 str = str.replaceAll("\"", """); | |
| 649 str = str.replaceAll("'", "'"); | |
| 650 return str; | |
| 651 } | |
| 652 | |
| 4 | 653 public GetAttributeImp getAttribute(String _bname, String nodePath,String revisionStr) { |
| 654 Long revision = Long.parseLong(revisionStr); | |
| 655 DefaultNodePath path = createNodePath(nodePath); | |
| 2 | 656 JungleTree tree = jungle.getTreeByName(_bname); |
| 4 | 657 JungleTree oldTree = tree.getOldTree(revision).b(); |
| 658 Either<Error, TreeNode> either = tree.getNodeOfPath(path); | |
| 659 if (either.isA()) | |
| 660 return new GetAttributeImp(new DefaultTreeNode()); | |
| 661 TreeNode node = either.b(); | |
| 662 return new GetAttributeImp(node); | |
| 663 } | |
| 2 | 664 |
| 4 | 665 private DefaultNodePath createNodePath(String nodePath) { |
| 666 DefaultNodePath path = new DefaultNodePath(); | |
| 667 try { | |
| 668 for (int count = 0; nodePath.substring(count, count + 1) != null; count++) { | |
| 669 if (!nodePath.substring(count, count + 1).equals("/")) | |
| 670 path = path.add(Integer.parseInt(nodePath.substring(count, count + 1))); | |
| 671 } | |
| 672 } catch (Exception _e) { | |
| 2 | 673 } |
| 4 | 674 return path; |
| 675 } | |
| 2 | 676 |
| 677 } |