Mercurial > hg > Members > nobuyasu > jungle-network
changeset 31:190f6a3bdab2
rename some packages
line wrap: on
line diff
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/alice/jungle/core/NetworkDefaultJungle.java Mon Jul 01 20:34:03 2013 +0900 @@ -0,0 +1,62 @@ +package alice.jungle.core; + +import java.util.Iterator; +import java.util.concurrent.ConcurrentHashMap; + +import alice.jungle.transaction.NetworkDefaultJungleTree; + +import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.Jungle; +import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.JungleTree; +import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.persistent.ChangeList; +import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.persistent.Journal; +import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.persistent.NullJournal; +import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.ChangeSet; +import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.TreeEditor; +import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.operations.TreeOperation; +import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.transaction.DefaultChangeSet; +import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.transaction.DefaultTreeContext; +import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.transaction.DefaultTreeNode; +import jungle.test.codesegment.persistence.AliceJournal; +import fj.data.List; + +public class NetworkDefaultJungle implements Jungle { + private Journal journal; + private ConcurrentHashMap<String,JungleTree> trees; + private String uuid; + private TreeEditor editor; + + public NetworkDefaultJungle(Journal _journal,String _uuid,TreeEditor _editor) + { +// journal = new AliceJournal(); + journal = new NullJournal(); + trees = new ConcurrentHashMap<String,JungleTree>(); + uuid = _uuid; + editor = _editor; + } + + @Override + public JungleTree getTreeByName(String _name) + { + return trees.get(_name); + } + + @Override + public JungleTree createNewTree(String _name) + { + ChangeList list = new ChangeList(){ + @Override + public Iterator<TreeOperation> iterator() { + List<TreeOperation> nil = List.nil(); + return nil.iterator(); + } + }; + DefaultTreeNode root = new DefaultTreeNode(); + ChangeSet set = new DefaultChangeSet(root.getAsNode(),null,list,uuid,0); + DefaultTreeContext<DefaultTreeNode> tc = new DefaultTreeContext<DefaultTreeNode>(root,set); + JungleTree newTree = new NetworkDefaultJungleTree<DefaultTreeNode>(tc,uuid,journal.getWriter(),editor); + if(trees.putIfAbsent(_name,newTree) != null){ + return null; + } + return newTree; + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/alice/jungle/datasegment/store/operations/DefaultNodeOperationContainer.java Mon Jul 01 20:34:03 2013 +0900 @@ -0,0 +1,81 @@ +package alice.jungle.datasegment.store.operations; + +import java.io.IOException; +import java.nio.ByteBuffer; + +import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.Command; +import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.operations.AppendChildAtOperation; +import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.operations.DeleteAttributeOperation; +import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.operations.DeleteChildAtOperation; +import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.operations.NodeOperation; +import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.operations.PutAttributeOperation; + +import org.msgpack.MessagePack; +import org.msgpack.annotation.Message; +import org.msgpack.template.OrdinalEnumTemplate; +import org.msgpack.type.Value; + +@Message +public class DefaultNodeOperationContainer { + + public int pos; + public String key; + public Value value; + public Value commandValue; + + public static void main(String[] args) throws IOException { + String key = "hoge"; + ByteBuffer b = ByteBuffer.wrap("messagepack value".getBytes()); + PutAttributeOperation op = new PutAttributeOperation(key, b); + DefaultNodeOperationContainer container = new DefaultNodeOperationContainer(); + container.unconvert(op); + NodeOperation convertedOp = container.convert(); + System.out.println("pos : "+convertedOp.getPosition()); + System.out.println("Command : "+convertedOp.getCommand()); + System.out.println("key : "+convertedOp.getKey()); + System.out.println("value : "+new String(convertedOp.getValue().array())); + + } + + public DefaultNodeOperationContainer() { + + } + + public void unconvert(NodeOperation op) throws IOException { + MessagePack msgpack = new MessagePack(); + pos = op.getPosition(); + key = op.getKey(); + value = null; + if (op.getValue() != null) { + ByteBuffer b = op.getValue(); + byte[] bytes = b.array(); + Value v = msgpack.unconvert(bytes); + value = v; + } + Command c = op.getCommand(); + msgpack.register(Command.class, new OrdinalEnumTemplate(Command.class)); + Value cValue = msgpack.unconvert(c); + commandValue = cValue; + } + + public NodeOperation convert() throws IOException{ + MessagePack msgpack = new MessagePack(); + msgpack.register(Command.class, new OrdinalEnumTemplate(Command.class)); + Command c = msgpack.convert(commandValue, Command.class); + ByteBuffer b = null; + if (value != null) { + b = ByteBuffer.wrap(msgpack.convert(value, byte[].class)); + } + if (c == Command.PUT_ATTRIBUTE) { + return new PutAttributeOperation(key, b); + } else if (c == Command.APPEND_CHILD) { + return new AppendChildAtOperation(pos); + } else if (c == Command.DELETE_CHILD) { + return new DeleteChildAtOperation(pos); + } else if (c == Command.DELETE_ATTRIBUTE){ + return new DeleteAttributeOperation(key); + } + return null; + } + +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/alice/jungle/datasegment/store/operations/DefaultNodePathContainer.java Mon Jul 01 20:34:03 2013 +0900 @@ -0,0 +1,59 @@ +package alice.jungle.datasegment.store.operations; + +import java.io.IOException; +import java.util.LinkedList; +import java.util.List; + +import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.NodePath; +import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.DefaultNodePath; + +import org.msgpack.MessagePack; +import org.msgpack.annotation.Message; +import org.msgpack.template.IntegerTemplate; +import org.msgpack.template.ListTemplate; +import org.msgpack.type.Value; + +@Message +public class DefaultNodePathContainer { + + public Value pathValue; + + public static void main(String[] args) throws IOException { + DefaultNodePath p = new DefaultNodePath(); + p = p.add(1).add(2).add(3); + DefaultNodePathContainer pathContainer = new DefaultNodePathContainer(); + pathContainer.unconvert(p); + NodePath convertedPath = pathContainer.convert(); + for (int i : convertedPath) { + System.out.println(i); + } + } + + public DefaultNodePathContainer() { + + } + + public void unconvert(NodePath path) throws IOException { + MessagePack msgpack = new MessagePack(); + List<Integer> list = new LinkedList<Integer>(); + for(Integer i : path) { + list.add(i); + } + /* Remove first Element(-1). */ + list.remove(0); + msgpack.register(List.class, new ListTemplate(IntegerTemplate.getInstance())); + Value v = msgpack.unconvert(list); + pathValue = v; + } + + public DefaultNodePath convert() throws IOException { + MessagePack msgpack = new MessagePack(); + msgpack.register(List.class, new ListTemplate(IntegerTemplate.getInstance())); + List<Integer> convertedList = (List<Integer>)msgpack.convert(pathValue, List.class); + DefaultNodePath path = new DefaultNodePath(); + for (int i: convertedList) { + path = path.add(i); + } + return path; + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/alice/jungle/datasegment/store/operations/DefaultTreeOperationContainer.java Mon Jul 01 20:34:03 2013 +0900 @@ -0,0 +1,96 @@ +package alice.jungle.datasegment.store.operations; + +import java.io.IOException; +import java.nio.ByteBuffer; + +import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.Command; +import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.NodePath; +import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.DefaultNodePath; +import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.operations.DefaultTreeOperation; +import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.operations.NodeOperation; +import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.operations.PutAttributeOperation; +import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.operations.TreeOperation; + +import org.msgpack.MessagePack; +import org.msgpack.annotation.Message; +import org.msgpack.type.Value; + +@Message +public class DefaultTreeOperationContainer { + + Value pathValue; + Value opValue; + + public static void main(String[] args) throws IOException { + String key = "hoge"; + ByteBuffer b = ByteBuffer.wrap("messagepack value".getBytes()); + PutAttributeOperation op = new PutAttributeOperation(key, b); + + DefaultNodePath p = new DefaultNodePath(); + p = p.add(1).add(2).add(3); + DefaultTreeOperation treeOp = new DefaultTreeOperation(p, op); + + DefaultTreeOperationContainer treeOperationContainer = new DefaultTreeOperationContainer(); + treeOperationContainer.unconvert(treeOp); + + TreeOperation treeOperation = treeOperationContainer.convert(); + NodePath nodePath = treeOperation.getNodePath(); + NodeOperation nodeOp = treeOperation.getNodeOperation(); + Command c = nodeOp.getCommand(); + String str = ""; + switch (c) { + case PUT_ATTRIBUTE: + String k = nodeOp.getKey(); + ByteBuffer value = nodeOp.getValue(); + if (value.limit() < 100) { + str = String.format("key:%s,value:%s", k, + new String(value.array())); + } else { + str = String.format("key:%s,value:%d", k, value.limit()); + } + break; + case DELETE_ATTRIBUTE: + str = String.format("key:%s", nodeOp.getKey()); + break; + case APPEND_CHILD: + str = String.format("pos:%d", nodeOp.getPosition()); + break; + case DELETE_CHILD: + str = String.format("pos:%d", nodeOp.getPosition()); + break; + } + System.out.println(String.format("[%s:%s:%s]", c, nodePath, str)); + for (int i: nodePath ) { + System.out.println(i); + } + } + + public DefaultTreeOperationContainer() { + + } + + public void unconvert(DefaultTreeOperation _op) throws IOException { + NodeOperation nodeOp = _op.getNodeOperation(); + NodePath nodePath = _op.getNodePath(); + DefaultNodeOperationContainer opContainer = new DefaultNodeOperationContainer(); + opContainer.unconvert(nodeOp); + DefaultNodePathContainer pathContainer = new DefaultNodePathContainer(); + pathContainer.unconvert(nodePath); + unconvert(opContainer, pathContainer); + } + + public void unconvert(DefaultNodeOperationContainer _op, + DefaultNodePathContainer _path) throws IOException { + MessagePack msgpack = new MessagePack(); + pathValue = msgpack.unconvert(_path); + opValue = msgpack.unconvert(_op); + } + + public TreeOperation convert() throws IOException { + MessagePack msgpack = new MessagePack(); + DefaultNodePathContainer pathContainer = msgpack.convert(pathValue, DefaultNodePathContainer.class); + DefaultNodeOperationContainer opContainer = msgpack.convert(opValue, DefaultNodeOperationContainer.class); + return new DefaultTreeOperation(pathContainer.convert(), opContainer.convert()); + } + +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/alice/jungle/datasegment/store/operations/DefaultTreeOperationLogContainer.java Mon Jul 01 20:34:03 2013 +0900 @@ -0,0 +1,124 @@ +package alice.jungle.datasegment.store.operations; + +import java.io.IOException; +import java.nio.ByteBuffer; +import java.util.LinkedList; +import java.util.List; + +import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.Command; +import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.NodePath; +import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.DefaultNodePath; +import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.logger.DefaultTreeOperationLog; +import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.logger.TreeOperationLog; +import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.operations.DefaultTreeOperation; +import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.operations.NodeOperation; +import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.operations.PutAttributeOperation; +import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.operations.TreeOperation; + +import org.msgpack.MessagePack; +import org.msgpack.annotation.Message; +import org.msgpack.template.ListTemplate; +import org.msgpack.template.ValueTemplate; +import org.msgpack.type.Value; + +@Message +public class DefaultTreeOperationLogContainer { + + Value logValue; + + public static void main(String[] args) throws IOException { + String key = "hoge"; + ByteBuffer b = ByteBuffer.wrap("messagepack value".getBytes()); + PutAttributeOperation putOp = new PutAttributeOperation(key, b); + DefaultNodePath nodePath = new DefaultNodePath(); + nodePath = nodePath.add(1).add(2).add(3); + TreeOperation op = new DefaultTreeOperation(nodePath, putOp); + List<TreeOperation> list = new LinkedList<TreeOperation>(); + list.add(op); + list.add(op); + list.add(op); + DefaultTreeOperationLog log = new DefaultTreeOperationLog(list, list.size()); + + DefaultTreeOperationLogContainer logContainer = new DefaultTreeOperationLogContainer(); + logContainer.unconvert(log); + + MessagePack msgpack = new MessagePack(); + Value logContainerValue = msgpack.unconvert(logContainer); + DefaultTreeOperationLogContainer convertedLogContainer = msgpack.convert(logContainerValue, + DefaultTreeOperationLogContainer.class); + + TreeOperationLog convertedLog = convertedLogContainer.convert(); + for (TreeOperation treeOp : convertedLog) { + NodePath path = treeOp.getNodePath(); + NodeOperation nodeOp = treeOp.getNodeOperation(); + Command c = nodeOp.getCommand(); + String str = ""; + switch (c) { + case PUT_ATTRIBUTE: + String k = nodeOp.getKey(); + ByteBuffer value = nodeOp.getValue(); + if (value.limit() < 100) { + str = String.format("key:%s,value:%s", k, + new String(value.array())); + } else { + str = String.format("key:%s,value:%d", k, value.limit()); + } + break; + case DELETE_ATTRIBUTE: + str = String.format("key:%s", nodeOp.getKey()); + break; + case APPEND_CHILD: + str = String.format("pos:%d", nodeOp.getPosition()); + break; + case DELETE_CHILD: + str = String.format("pos:%d", nodeOp.getPosition()); + break; + } + System.out.println(String.format("[%s:%s:%s]", c, path, str)); + for (int i: path ) { + System.out.println(i); + } + + } + + + } + + public DefaultTreeOperationLogContainer() { + + } + + public void unconvert(TreeOperationLog _log) throws IOException { + MessagePack msgpack = new MessagePack(); + List<Value> list = new LinkedList<Value>(); + for(TreeOperation op : _log) { + NodeOperation nOp = op.getNodeOperation(); + NodePath nodePath = op.getNodePath(); + DefaultTreeOperation treeOp = new DefaultTreeOperation(nodePath, nOp); + DefaultTreeOperationContainer container = new DefaultTreeOperationContainer(); + container.unconvert(treeOp); + Value v = msgpack.unconvert(container); + list.add(v); + } + /* */ + msgpack.register(List.class, new ListTemplate(ValueTemplate.getInstance())); + Value listValue = msgpack.unconvert(list); + logValue = listValue; + } + + public DefaultTreeOperationLog convert() throws IOException { + MessagePack msgpack = new MessagePack(); + msgpack.register(List.class, new ListTemplate(ValueTemplate.getInstance())); + List<Value> listValue = msgpack.convert(logValue, List.class); + List<TreeOperation> logList = new LinkedList<TreeOperation>(); + for(Value v: listValue) { + DefaultTreeOperationContainer container = msgpack.convert(v, DefaultTreeOperationContainer.class); + logList.add(container.convert()); + } + DefaultTreeOperationLog log = new DefaultTreeOperationLog(logList, logList.size()); + return log; + } + + + +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/alice/jungle/operations/NetworkNodeOperation.java Mon Jul 01 20:34:03 2013 +0900 @@ -0,0 +1,47 @@ +package alice.jungle.operations; + +import java.nio.ByteBuffer; + +import org.msgpack.annotation.Message; + +import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.Command; +import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.operations.NodeOperation; +import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.trasnformer.EditableNode; +import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Either; +import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Error; + +@Message +public class NetworkNodeOperation implements NodeOperation { + + @Override + public Command getCommand() { + // TODO Auto-generated method stub + return null; + } + + @Override + public String getKey() { + // TODO Auto-generated method stub + return null; + } + + @Override + public int getPosition() { + // TODO Auto-generated method stub + return 0; + } + + @Override + public ByteBuffer getValue() { + // TODO Auto-generated method stub + return null; + } + + @Override + public <T extends EditableNode<T>> Either<Error, T> invoke(T arg0) { + // TODO Auto-generated method stub + return null; + } + + +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/alice/jungle/operations/NetworkNodePath.java Mon Jul 01 20:34:03 2013 +0900 @@ -0,0 +1,59 @@ +package alice.jungle.operations; + +import java.util.Iterator; +import java.util.LinkedList; + +import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.NodePath; +import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Pair; + +public class NetworkNodePath implements NodePath +{ + LinkedList<Integer> path; + + public NetworkNodePath() { + path = new LinkedList<Integer>(); + } + + private NetworkNodePath(LinkedList<Integer> _path) { + path = _path; + } + + @Override + public Iterator<Integer> iterator() { + return path.iterator(); + } + + @Override + public NetworkNodePath add(int _pos) { + LinkedList<Integer> newPath = copyPath(); + newPath.add(_pos); + return new NetworkNodePath(newPath); + } + + @Override + public Pair<Integer, NodePath> pop() { + LinkedList<Integer> cPath = copyPath(); + int e = cPath.getFirst(); + cPath.remove(); + return new Pair<Integer, NodePath>(e, new NetworkNodePath(cPath)); + } + + @Override + public int size() { + return path.size(); + } + + private LinkedList<Integer> copyPath() { + LinkedList<Integer> newPath = new LinkedList<Integer>(); + for (Integer i : path) { + newPath.add(i); + } + return newPath; + } + + @Override + public String toString() { + return path.toString(); + } + +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/alice/jungle/operations/NetworkTreeOperation.java Mon Jul 01 20:34:03 2013 +0900 @@ -0,0 +1,35 @@ +package alice.jungle.operations; + +import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.NodePath; +import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.operations.NodeOperation; +import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.operations.TreeOperation; + +import org.msgpack.annotation.Message; + +@Message +public class NetworkTreeOperation implements TreeOperation { + + public NodePath path; + public NodeOperation operation; + + public NetworkTreeOperation() { + path = null; + operation = null; + } + + public NetworkTreeOperation(NodePath _p, NodeOperation _op) { + path = _p; + operation = _op; + } + + @Override + public NodePath getNodePath() { + return path; + } + + @Override + public NodeOperation getNodeOperation() { + return operation; + } + +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/alice/jungle/operations/NetworkTreeOperationLog.java Mon Jul 01 20:34:03 2013 +0900 @@ -0,0 +1,72 @@ +package alice.jungle.operations; + +import java.util.Iterator; +import java.util.LinkedList; + +import org.msgpack.annotation.Message; + +import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.NodePath; +import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.logger.TreeOperationLog; +import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.operations.NodeOperation; +import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.operations.TreeOperation; + +@Message +public class NetworkTreeOperationLog implements TreeOperationLog +{ + public Iterable<TreeOperation> list; + public int size; + + public NetworkTreeOperationLog() { + list = new LinkedList<TreeOperation>(); + size = 0; + } + + public NetworkTreeOperationLog(Iterable<TreeOperation> _list, int _size) + { + list = _list; + size = _size; + } + + public Iterable<TreeOperation> getOperationLogList() { + return list; + } + + @Override + public Iterator<TreeOperation> iterator() { + return list.iterator(); + } + + @Override + public NetworkTreeOperationLog add(NodePath _p, NodeOperation _op) + { + TreeOperation op = new NetworkTreeOperation(_p, _op); + LinkedList<TreeOperation> newList = new LinkedList<TreeOperation>(); + for (Iterator<TreeOperation> iter = list.iterator(); iter.hasNext();) { + TreeOperation o = iter.next(); + newList.add(o); + } + newList.add(op); + return new NetworkTreeOperationLog(newList, size+1); + } + + @Override + public NetworkTreeOperationLog append(TreeOperationLog _log) + { + LinkedList<TreeOperation> newList = new LinkedList<TreeOperation>(); + for (Iterator<TreeOperation> iter = list.iterator(); iter.hasNext();) { + TreeOperation o = iter.next(); + newList.add(o); + } + for (TreeOperation o : _log) { + newList.add(o); + } + return new NetworkTreeOperationLog(newList, size+_log.length()); + } + + @Override + public int length() + { + return size; + } + +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/alice/jungle/transaction/NetworkDefaultJungleTree.java Mon Jul 01 20:34:03 2013 +0900 @@ -0,0 +1,44 @@ +package alice.jungle.transaction; + +import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.JungleTree; +import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.JungleTreeEditor; +import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.core.Node; +import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.persistent.ChangeListWriter; +import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.ChangeSet; +import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.TreeEditor; +import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.TreeNode; +import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.transaction.AtomicReservableReference; +import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.transaction.DefaultTransactionManager; +import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.transaction.TreeContext; + +public class NetworkDefaultJungleTree<T extends TreeNode<T>> implements JungleTree { + private final AtomicReservableReference<TreeContext<T>> repository; + private final String uuid; + private final ChangeListWriter writer; + private final TreeEditor editor; + + public NetworkDefaultJungleTree(TreeContext<T> _tc,String _uuid,ChangeListWriter _writer,TreeEditor _editor) + { + repository = new AtomicReservableReference<TreeContext<T>>(_tc); + uuid = _uuid; + writer = _writer; + editor = _editor; + } + + @Override + public JungleTreeEditor getTreeEditor() + { + TreeContext<T> tc = repository.get(); + DefaultTransactionManager<T> txManager = new DefaultTransactionManager<T>(writer,tc,repository,uuid); + T root = tc.getTreeNode(); + return new NetworkDefaultJungleTreeEditor<T>(root,txManager,editor); + } + + @Override + public Node getRootNode() + { + TreeContext<T> tc = repository.get(); + ChangeSet cs = tc.getChangeSet(); + return cs.getRoot(); + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/alice/jungle/transaction/NetworkDefaultJungleTreeEditor.java Mon Jul 01 20:34:03 2013 +0900 @@ -0,0 +1,151 @@ +package alice.jungle.transaction; + +import java.nio.ByteBuffer; + +import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.JungleTreeEditor; +import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.core.Node; +import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.NodePath; +import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.TreeEditor; +import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.TreeNode; +import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.logger.DefaultTreeOperationLog; +import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.logger.LoggingNodeHook; +import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.logger.OperationLog; +import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.logger.TreeOperationLog; +import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.operations.DefaultTreeOperation; +import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.operations.NodeOperation; +import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.operations.TreeOperation; +import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.trasnformer.AppendChildAt; +import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.trasnformer.DeleteAttribute; +import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.trasnformer.DeleteChildAt; +import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.trasnformer.NodeEditor; +import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.trasnformer.PutAttribute; +import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.transaction.DefaultJungleTreeEditor; +import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.transaction.TransactionManager; +import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.DefaultEither; +import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Either; +import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Error; +import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.IterableConverter; + +public class NetworkDefaultJungleTreeEditor<T extends TreeNode<T>> implements JungleTreeEditor { + + private final TransactionManager<T> txManager; + private final T root; + private final TreeEditor editor; + private final TreeOperationLog log; + + public NetworkDefaultJungleTreeEditor(T _root,TransactionManager<T> _txManager,TreeEditor _editor) + { + this(_root,_txManager,_editor,new DefaultTreeOperationLog()); + } + + public NetworkDefaultJungleTreeEditor(T _root,TransactionManager<T> _txManager,TreeEditor _editor,TreeOperationLog _log) + { + root = _root; + txManager = _txManager; + editor = _editor; + log = _log; + } + + private Either<Error,JungleTreeEditor> _edit(final NodePath _path,NodeEditor _e) + { + LoggingNodeHook hook = new LoggingNodeHook(_e); + Either<Error,T> either = editor.edit(root,_path,hook); + if(either.isA()){ + return DefaultEither.newA(either.a()); + } + + T newNode = either.b(); + OperationLog newLog = hook.getLog(); + + IterableConverter.Converter<TreeOperation,NodeOperation> converter = new IterableConverter.Converter<TreeOperation,NodeOperation>(){ + @Override + public TreeOperation conv(NodeOperation _b){ + return new DefaultTreeOperation(_path,_b); + } + }; + + Iterable<TreeOperation> iterable = new IterableConverter<TreeOperation,NodeOperation>(newLog,converter); + DefaultTreeOperationLog treeOperationLog = new DefaultTreeOperationLog(iterable,newLog.length()); + TreeOperationLog newTreeOpLog = log.append(treeOperationLog); + + JungleTreeEditor newEditor = new NetworkDefaultJungleTreeEditor<T>(newNode,txManager,editor,newTreeOpLog); + return DefaultEither.newB(newEditor); + } + + @Override + public Either<Error,JungleTreeEditor> addNewChildAt(NodePath _path, int _pos) + { + AppendChildAt appendChildAt = new AppendChildAt(_pos); + return _edit(_path,appendChildAt); + } + + @Override + public Either<Error,JungleTreeEditor> deleteChildAt(NodePath _path, int _pos) + { + DeleteChildAt deleteChildAt = new DeleteChildAt(_pos); + return _edit(_path,deleteChildAt); + } + + @Override + public Either<Error,JungleTreeEditor> putAttribute(NodePath _path,String _key,ByteBuffer _value) + { + PutAttribute putAttribute = new PutAttribute(_key,_value); + return _edit(_path,putAttribute); + } + + @Override + public Either<Error,JungleTreeEditor> deleteAttribute(NodePath _path, String _key) + { + DeleteAttribute deleteAttribute = new DeleteAttribute(_key); + return _edit(_path,deleteAttribute); + } + + @Override + public Either<Error,JungleTreeEditor> edit(NodePath _path,NodeEditor _editor) + { + return _edit(_path,_editor); + } + + @Override + public Either<Error,JungleTreeEditor> success() + { + Either<Error,TransactionManager<T>> either = txManager.commit(root,log); + if(either.isA()){ + return DefaultEither.newA(either.a()); + } + + TransactionManager<T> newTxManager = either.b(); + JungleTreeEditor newTreeEditor = new NetworkDefaultJungleTreeEditor<T>(root,newTxManager,editor); + + return DefaultEither.newB(newTreeEditor); + } + + @Override + public String getID() + { + return txManager.getUUID(); + } + + @Override + public String getRevision() + { + return Long.toString(txManager.getRevision()); + } + + @Override + public Node getRoot() + { + return null; + } + + public JungleTreeEditor setNewLogAndGetEditor(TreeOperationLog _log) { + JungleTreeEditor newEditor = new NetworkDefaultJungleTreeEditor<T>(root,txManager,editor, _log); + return newEditor; + } + + public TreeOperationLog getTreeOperationLog() { + return log; + } + + +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/alice/jungle/transaction/NetworkTransactionManager.java Mon Jul 01 20:34:03 2013 +0900 @@ -0,0 +1,87 @@ +package alice.jungle.transaction; + +import java.util.Iterator; + +import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.core.Node; +import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.persistent.ChangeList; +import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.persistent.ChangeListWriter; +import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.persistent.Result; +import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.ChangeSet; +import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.TreeNode; +import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.logger.TreeOperationLog; +import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.operations.TreeOperation; +import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.transaction.AtomicReservableReference; +import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.transaction.AtomicReservableReference.Reservation; +import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.transaction.DefaultChangeSet; +import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.transaction.DefaultTreeContext; +import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.transaction.TransactionManager; +import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.transaction.TreeContext; +import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.DefaultEither; +import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.DefaultError; +import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Either; +import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Error; + +public class NetworkTransactionManager<T extends TreeNode<T>> implements TransactionManager<T> +{ + + private final AtomicReservableReference<TreeContext<T>> repository; + private final TreeContext<T> tip; + private final ChangeListWriter writer; + private final String uuid; + private final String treeName; + + public NetworkTransactionManager(ChangeListWriter _writer,TreeContext<T> _tip, + AtomicReservableReference<TreeContext<T>> _repository,String _uuid, String _treeName) + { + repository = _repository; + tip = _tip; + writer = _writer; + uuid = _uuid; + treeName = _treeName; + } + + @Override + public Either<Error, TransactionManager<T>> commit(T _newRoot,final TreeOperationLog _log) { + ChangeSet cs = tip.getChangeSet(); + long currentRevision = cs.revision(); + long nextRevision = currentRevision + 1; + + ChangeList list = new ChangeList() { + @Override + public Iterator<TreeOperation> iterator(){ + return _log.iterator(); + } + }; + + Node root = _newRoot.getAsNode(); + DefaultChangeSet newCs = new DefaultChangeSet(root, cs, list, uuid, nextRevision); + DefaultTreeContext<T> newContext = new DefaultTreeContext<T>(_newRoot,newCs); + + @SuppressWarnings("rawtypes") + Reservation reservation = repository.makeReservation(tip, newContext); + if(reservation == null) { + return DefaultEither.newA((Error)new DefaultError()); + } + Result r = writer.write(list); + if(r == Result.SUCCESS){ + reservation.confirm(); + TransactionManager<T> txManager = new NetworkTransactionManager<T>(writer, newContext, repository, uuid, treeName); + return DefaultEither.newB(txManager); + } + + return DefaultEither.newA((Error)new DefaultError()); + } + + @Override + public long getRevision() + { + ChangeSet cs = tip.getChangeSet(); + return cs.revision(); + } + + @Override + public String getUUID() { + return uuid; + } + +}
--- a/src/jungle/test/codesegment/log/practice/StartCodeSegment.java Mon Jul 01 20:31:29 2013 +0900 +++ b/src/jungle/test/codesegment/log/practice/StartCodeSegment.java Mon Jul 01 20:34:03 2013 +0900 @@ -13,8 +13,8 @@ import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.operations.DeleteChildAtOperation; import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.operations.PutAttributeOperation; import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.operations.TreeOperation; -import jungle.test.datasegment.store.operations.DefaultTreeOperationLogContainer; import alice.codesegment.CodeSegment; +import alice.jungle.datasegment.store.operations.DefaultTreeOperationLogContainer; public class StartCodeSegment extends CodeSegment {
--- a/src/jungle/test/codesegment/log/practice/TestCodeSegment.java Mon Jul 01 20:31:29 2013 +0900 +++ b/src/jungle/test/codesegment/log/practice/TestCodeSegment.java Mon Jul 01 20:34:03 2013 +0900 @@ -19,12 +19,12 @@ import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.traverser.DefaultTraverser; import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Either; import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Error; -import jungle.test.core.NetworkDefaultJungle; -import jungle.test.datasegment.store.operations.DefaultTreeOperationLogContainer; -import jungle.test.transaction.NetworkDefaultJungleTreeEditor; import alice.codesegment.CodeSegment; import alice.datasegment.CommandType; import alice.datasegment.Receiver; +import alice.jungle.core.NetworkDefaultJungle; +import alice.jungle.datasegment.store.operations.DefaultTreeOperationLogContainer; +import alice.jungle.transaction.NetworkDefaultJungleTreeEditor; import alice.test.topology.aquarium.FishPoint; import org.msgpack.MessagePack;
--- a/src/jungle/test/codesegment/operation/JungleManager.java Mon Jul 01 20:31:29 2013 +0900 +++ b/src/jungle/test/codesegment/operation/JungleManager.java Mon Jul 01 20:34:03 2013 +0900 @@ -1,11 +1,11 @@ package jungle.test.codesegment.operation; +import alice.jungle.core.NetworkDefaultJungle; import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.DefaultJungle; import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.Jungle; import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.JungleTree; import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.DefaultTreeEditor; import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.traverser.DefaultTraverser; -import jungle.test.core.NetworkDefaultJungle; public class JungleManager { static Jungle jungle = new NetworkDefaultJungle(null,"hoge",new DefaultTreeEditor(new DefaultTraverser()));
--- a/src/jungle/test/codesegment/operation/StartJungleCodeSegment.java Mon Jul 01 20:31:29 2013 +0900 +++ b/src/jungle/test/codesegment/operation/StartJungleCodeSegment.java Mon Jul 01 20:34:03 2013 +0900 @@ -8,8 +8,8 @@ import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.DefaultNodePath; import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.operations.DefaultTreeOperation; import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.operations.PutAttributeOperation; -import jungle.test.datasegment.store.operations.DefaultTreeOperationContainer; import alice.codesegment.CodeSegment; +import alice.jungle.datasegment.store.operations.DefaultTreeOperationContainer; public class StartJungleCodeSegment {
--- a/src/jungle/test/codesegment/operation/TestPutAttributeCodeSegment.java Mon Jul 01 20:31:29 2013 +0900 +++ b/src/jungle/test/codesegment/operation/TestPutAttributeCodeSegment.java Mon Jul 01 20:34:03 2013 +0900 @@ -17,15 +17,15 @@ import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.operations.TreeOperation; import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Either; import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Error; -import jungle.test.datasegment.store.operations.DefaultTreeOperationContainer; -import jungle.test.datasegment.store.operations.DefaultTreeOperationLogContainer; -import jungle.test.transaction.NetworkDefaultJungleTreeEditor; import org.msgpack.type.Value; import alice.codesegment.CodeSegment; import alice.datasegment.CommandType; import alice.datasegment.Receiver; +import alice.jungle.datasegment.store.operations.DefaultTreeOperationContainer; +import alice.jungle.datasegment.store.operations.DefaultTreeOperationLogContainer; +import alice.jungle.transaction.NetworkDefaultJungleTreeEditor; public class TestPutAttributeCodeSegment extends CodeSegment {
--- a/src/jungle/test/codesegment/persistence/AliceJournal.java Mon Jul 01 20:31:29 2013 +0900 +++ b/src/jungle/test/codesegment/persistence/AliceJournal.java Mon Jul 01 20:34:03 2013 +0900 @@ -2,6 +2,9 @@ import java.nio.ByteBuffer; +import alice.jungle.datasegment.store.operations.DefaultNodeOperationContainer; +import alice.jungle.datasegment.store.operations.DefaultTreeOperationContainer; + import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.persistent.ChangeList; import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.persistent.ChangeListReader; import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.persistent.ChangeListWriter; @@ -11,8 +14,6 @@ import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.NodePath; import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.operations.NodeOperation; import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.operations.TreeOperation; -import jungle.test.datasegment.store.operations.DefaultNodeOperationContainer; -import jungle.test.datasegment.store.operations.DefaultTreeOperationContainer; public class AliceJournal implements Journal {
--- a/src/jungle/test/core/NetworkDefaultJungle.java Mon Jul 01 20:31:29 2013 +0900 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,61 +0,0 @@ -package jungle.test.core; - -import java.util.Iterator; -import java.util.concurrent.ConcurrentHashMap; - -import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.Jungle; -import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.JungleTree; -import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.persistent.ChangeList; -import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.persistent.Journal; -import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.persistent.NullJournal; -import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.ChangeSet; -import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.TreeEditor; -import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.operations.TreeOperation; -import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.transaction.DefaultChangeSet; -import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.transaction.DefaultTreeContext; -import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.transaction.DefaultTreeNode; -import jungle.test.codesegment.persistence.AliceJournal; -import jungle.test.transaction.NetworkDefaultJungleTree; -import fj.data.List; - -public class NetworkDefaultJungle implements Jungle { - private Journal journal; - private ConcurrentHashMap<String,JungleTree> trees; - private String uuid; - private TreeEditor editor; - - public NetworkDefaultJungle(Journal _journal,String _uuid,TreeEditor _editor) - { -// journal = new AliceJournal(); - journal = new NullJournal(); - trees = new ConcurrentHashMap<String,JungleTree>(); - uuid = _uuid; - editor = _editor; - } - - @Override - public JungleTree getTreeByName(String _name) - { - return trees.get(_name); - } - - @Override - public JungleTree createNewTree(String _name) - { - ChangeList list = new ChangeList(){ - @Override - public Iterator<TreeOperation> iterator() { - List<TreeOperation> nil = List.nil(); - return nil.iterator(); - } - }; - DefaultTreeNode root = new DefaultTreeNode(); - ChangeSet set = new DefaultChangeSet(root.getAsNode(),null,list,uuid,0); - DefaultTreeContext<DefaultTreeNode> tc = new DefaultTreeContext<DefaultTreeNode>(root,set); - JungleTree newTree = new NetworkDefaultJungleTree<DefaultTreeNode>(tc,uuid,journal.getWriter(),editor); - if(trees.putIfAbsent(_name,newTree) != null){ - return null; - } - return newTree; - } -}
--- a/src/jungle/test/core/practice/LogReadCodeSegment.java Mon Jul 01 20:31:29 2013 +0900 +++ b/src/jungle/test/core/practice/LogReadCodeSegment.java Mon Jul 01 20:34:03 2013 +0900 @@ -15,10 +15,10 @@ import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Either; import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Error; import jungle.test.codesegment.operation.JungleManager; -import jungle.test.datasegment.store.operations.DefaultTreeOperationLogContainer; import alice.codesegment.CodeSegment; import alice.datasegment.CommandType; import alice.datasegment.Receiver; +import alice.jungle.datasegment.store.operations.DefaultTreeOperationLogContainer; public class LogReadCodeSegment extends CodeSegment {
--- a/src/jungle/test/core/practice/LogSendTest.java Mon Jul 01 20:31:29 2013 +0900 +++ b/src/jungle/test/core/practice/LogSendTest.java Mon Jul 01 20:34:03 2013 +0900 @@ -3,6 +3,9 @@ import java.io.IOException; import java.nio.ByteBuffer; +import alice.jungle.datasegment.store.operations.DefaultTreeOperationLogContainer; +import alice.jungle.transaction.NetworkDefaultJungleTreeEditor; + import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.JungleTree; import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.JungleTreeEditor; import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.DefaultNodePath; @@ -10,8 +13,6 @@ import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Either; import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Error; import jungle.test.codesegment.operation.JungleManager; -import jungle.test.datasegment.store.operations.DefaultTreeOperationLogContainer; -import jungle.test.transaction.NetworkDefaultJungleTreeEditor; public class LogSendTest {
--- a/src/jungle/test/datasegment/store/operations/DefaultNodeOperationContainer.java Mon Jul 01 20:31:29 2013 +0900 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,81 +0,0 @@ -package jungle.test.datasegment.store.operations; - -import java.io.IOException; -import java.nio.ByteBuffer; - -import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.Command; -import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.operations.AppendChildAtOperation; -import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.operations.DeleteAttributeOperation; -import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.operations.DeleteChildAtOperation; -import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.operations.NodeOperation; -import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.operations.PutAttributeOperation; - -import org.msgpack.MessagePack; -import org.msgpack.annotation.Message; -import org.msgpack.template.OrdinalEnumTemplate; -import org.msgpack.type.Value; - -@Message -public class DefaultNodeOperationContainer { - - public int pos; - public String key; - public Value value; - public Value commandValue; - - public static void main(String[] args) throws IOException { - String key = "hoge"; - ByteBuffer b = ByteBuffer.wrap("messagepack value".getBytes()); - PutAttributeOperation op = new PutAttributeOperation(key, b); - DefaultNodeOperationContainer container = new DefaultNodeOperationContainer(); - container.unconvert(op); - NodeOperation convertedOp = container.convert(); - System.out.println("pos : "+convertedOp.getPosition()); - System.out.println("Command : "+convertedOp.getCommand()); - System.out.println("key : "+convertedOp.getKey()); - System.out.println("value : "+new String(convertedOp.getValue().array())); - - } - - public DefaultNodeOperationContainer() { - - } - - public void unconvert(NodeOperation op) throws IOException { - MessagePack msgpack = new MessagePack(); - pos = op.getPosition(); - key = op.getKey(); - value = null; - if (op.getValue() != null) { - ByteBuffer b = op.getValue(); - byte[] bytes = b.array(); - Value v = msgpack.unconvert(bytes); - value = v; - } - Command c = op.getCommand(); - msgpack.register(Command.class, new OrdinalEnumTemplate(Command.class)); - Value cValue = msgpack.unconvert(c); - commandValue = cValue; - } - - public NodeOperation convert() throws IOException{ - MessagePack msgpack = new MessagePack(); - msgpack.register(Command.class, new OrdinalEnumTemplate(Command.class)); - Command c = msgpack.convert(commandValue, Command.class); - ByteBuffer b = null; - if (value != null) { - b = ByteBuffer.wrap(msgpack.convert(value, byte[].class)); - } - if (c == Command.PUT_ATTRIBUTE) { - return new PutAttributeOperation(key, b); - } else if (c == Command.APPEND_CHILD) { - return new AppendChildAtOperation(pos); - } else if (c == Command.DELETE_CHILD) { - return new DeleteChildAtOperation(pos); - } else if (c == Command.DELETE_ATTRIBUTE){ - return new DeleteAttributeOperation(key); - } - return null; - } - -}
--- a/src/jungle/test/datasegment/store/operations/DefaultNodePathContainer.java Mon Jul 01 20:31:29 2013 +0900 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,59 +0,0 @@ -package jungle.test.datasegment.store.operations; - -import java.io.IOException; -import java.util.LinkedList; -import java.util.List; - -import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.NodePath; -import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.DefaultNodePath; - -import org.msgpack.MessagePack; -import org.msgpack.annotation.Message; -import org.msgpack.template.IntegerTemplate; -import org.msgpack.template.ListTemplate; -import org.msgpack.type.Value; - -@Message -public class DefaultNodePathContainer { - - public Value pathValue; - - public static void main(String[] args) throws IOException { - DefaultNodePath p = new DefaultNodePath(); - p = p.add(1).add(2).add(3); - DefaultNodePathContainer pathContainer = new DefaultNodePathContainer(); - pathContainer.unconvert(p); - NodePath convertedPath = pathContainer.convert(); - for (int i : convertedPath) { - System.out.println(i); - } - } - - public DefaultNodePathContainer() { - - } - - public void unconvert(NodePath path) throws IOException { - MessagePack msgpack = new MessagePack(); - List<Integer> list = new LinkedList<Integer>(); - for(Integer i : path) { - list.add(i); - } - /* Remove first Element(-1). */ - list.remove(0); - msgpack.register(List.class, new ListTemplate(IntegerTemplate.getInstance())); - Value v = msgpack.unconvert(list); - pathValue = v; - } - - public DefaultNodePath convert() throws IOException { - MessagePack msgpack = new MessagePack(); - msgpack.register(List.class, new ListTemplate(IntegerTemplate.getInstance())); - List<Integer> convertedList = (List<Integer>)msgpack.convert(pathValue, List.class); - DefaultNodePath path = new DefaultNodePath(); - for (int i: convertedList) { - path = path.add(i); - } - return path; - } -}
--- a/src/jungle/test/datasegment/store/operations/DefaultTreeOperationContainer.java Mon Jul 01 20:31:29 2013 +0900 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,96 +0,0 @@ -package jungle.test.datasegment.store.operations; - -import java.io.IOException; -import java.nio.ByteBuffer; - -import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.Command; -import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.NodePath; -import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.DefaultNodePath; -import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.operations.DefaultTreeOperation; -import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.operations.NodeOperation; -import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.operations.PutAttributeOperation; -import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.operations.TreeOperation; - -import org.msgpack.MessagePack; -import org.msgpack.annotation.Message; -import org.msgpack.type.Value; - -@Message -public class DefaultTreeOperationContainer { - - Value pathValue; - Value opValue; - - public static void main(String[] args) throws IOException { - String key = "hoge"; - ByteBuffer b = ByteBuffer.wrap("messagepack value".getBytes()); - PutAttributeOperation op = new PutAttributeOperation(key, b); - - DefaultNodePath p = new DefaultNodePath(); - p = p.add(1).add(2).add(3); - DefaultTreeOperation treeOp = new DefaultTreeOperation(p, op); - - DefaultTreeOperationContainer treeOperationContainer = new DefaultTreeOperationContainer(); - treeOperationContainer.unconvert(treeOp); - - TreeOperation treeOperation = treeOperationContainer.convert(); - NodePath nodePath = treeOperation.getNodePath(); - NodeOperation nodeOp = treeOperation.getNodeOperation(); - Command c = nodeOp.getCommand(); - String str = ""; - switch (c) { - case PUT_ATTRIBUTE: - String k = nodeOp.getKey(); - ByteBuffer value = nodeOp.getValue(); - if (value.limit() < 100) { - str = String.format("key:%s,value:%s", k, - new String(value.array())); - } else { - str = String.format("key:%s,value:%d", k, value.limit()); - } - break; - case DELETE_ATTRIBUTE: - str = String.format("key:%s", nodeOp.getKey()); - break; - case APPEND_CHILD: - str = String.format("pos:%d", nodeOp.getPosition()); - break; - case DELETE_CHILD: - str = String.format("pos:%d", nodeOp.getPosition()); - break; - } - System.out.println(String.format("[%s:%s:%s]", c, nodePath, str)); - for (int i: nodePath ) { - System.out.println(i); - } - } - - public DefaultTreeOperationContainer() { - - } - - public void unconvert(DefaultTreeOperation _op) throws IOException { - NodeOperation nodeOp = _op.getNodeOperation(); - NodePath nodePath = _op.getNodePath(); - DefaultNodeOperationContainer opContainer = new DefaultNodeOperationContainer(); - opContainer.unconvert(nodeOp); - DefaultNodePathContainer pathContainer = new DefaultNodePathContainer(); - pathContainer.unconvert(nodePath); - unconvert(opContainer, pathContainer); - } - - public void unconvert(DefaultNodeOperationContainer _op, - DefaultNodePathContainer _path) throws IOException { - MessagePack msgpack = new MessagePack(); - pathValue = msgpack.unconvert(_path); - opValue = msgpack.unconvert(_op); - } - - public TreeOperation convert() throws IOException { - MessagePack msgpack = new MessagePack(); - DefaultNodePathContainer pathContainer = msgpack.convert(pathValue, DefaultNodePathContainer.class); - DefaultNodeOperationContainer opContainer = msgpack.convert(opValue, DefaultNodeOperationContainer.class); - return new DefaultTreeOperation(pathContainer.convert(), opContainer.convert()); - } - -}
--- a/src/jungle/test/datasegment/store/operations/DefaultTreeOperationLogContainer.java Mon Jul 01 20:31:29 2013 +0900 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,124 +0,0 @@ -package jungle.test.datasegment.store.operations; - -import java.io.IOException; -import java.nio.ByteBuffer; -import java.util.LinkedList; -import java.util.List; - -import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.Command; -import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.NodePath; -import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.DefaultNodePath; -import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.logger.DefaultTreeOperationLog; -import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.logger.TreeOperationLog; -import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.operations.DefaultTreeOperation; -import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.operations.NodeOperation; -import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.operations.PutAttributeOperation; -import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.operations.TreeOperation; - -import org.msgpack.MessagePack; -import org.msgpack.annotation.Message; -import org.msgpack.template.ListTemplate; -import org.msgpack.template.ValueTemplate; -import org.msgpack.type.Value; - -@Message -public class DefaultTreeOperationLogContainer { - - Value logValue; - - public static void main(String[] args) throws IOException { - String key = "hoge"; - ByteBuffer b = ByteBuffer.wrap("messagepack value".getBytes()); - PutAttributeOperation putOp = new PutAttributeOperation(key, b); - DefaultNodePath nodePath = new DefaultNodePath(); - nodePath = nodePath.add(1).add(2).add(3); - TreeOperation op = new DefaultTreeOperation(nodePath, putOp); - List<TreeOperation> list = new LinkedList<TreeOperation>(); - list.add(op); - list.add(op); - list.add(op); - DefaultTreeOperationLog log = new DefaultTreeOperationLog(list, list.size()); - - DefaultTreeOperationLogContainer logContainer = new DefaultTreeOperationLogContainer(); - logContainer.unconvert(log); - - MessagePack msgpack = new MessagePack(); - Value logContainerValue = msgpack.unconvert(logContainer); - DefaultTreeOperationLogContainer convertedLogContainer = msgpack.convert(logContainerValue, - DefaultTreeOperationLogContainer.class); - - TreeOperationLog convertedLog = convertedLogContainer.convert(); - for (TreeOperation treeOp : convertedLog) { - NodePath path = treeOp.getNodePath(); - NodeOperation nodeOp = treeOp.getNodeOperation(); - Command c = nodeOp.getCommand(); - String str = ""; - switch (c) { - case PUT_ATTRIBUTE: - String k = nodeOp.getKey(); - ByteBuffer value = nodeOp.getValue(); - if (value.limit() < 100) { - str = String.format("key:%s,value:%s", k, - new String(value.array())); - } else { - str = String.format("key:%s,value:%d", k, value.limit()); - } - break; - case DELETE_ATTRIBUTE: - str = String.format("key:%s", nodeOp.getKey()); - break; - case APPEND_CHILD: - str = String.format("pos:%d", nodeOp.getPosition()); - break; - case DELETE_CHILD: - str = String.format("pos:%d", nodeOp.getPosition()); - break; - } - System.out.println(String.format("[%s:%s:%s]", c, path, str)); - for (int i: path ) { - System.out.println(i); - } - - } - - - } - - public DefaultTreeOperationLogContainer() { - - } - - public void unconvert(TreeOperationLog _log) throws IOException { - MessagePack msgpack = new MessagePack(); - List<Value> list = new LinkedList<Value>(); - for(TreeOperation op : _log) { - NodeOperation nOp = op.getNodeOperation(); - NodePath nodePath = op.getNodePath(); - DefaultTreeOperation treeOp = new DefaultTreeOperation(nodePath, nOp); - DefaultTreeOperationContainer container = new DefaultTreeOperationContainer(); - container.unconvert(treeOp); - Value v = msgpack.unconvert(container); - list.add(v); - } - /* */ - msgpack.register(List.class, new ListTemplate(ValueTemplate.getInstance())); - Value listValue = msgpack.unconvert(list); - logValue = listValue; - } - - public DefaultTreeOperationLog convert() throws IOException { - MessagePack msgpack = new MessagePack(); - msgpack.register(List.class, new ListTemplate(ValueTemplate.getInstance())); - List<Value> listValue = msgpack.convert(logValue, List.class); - List<TreeOperation> logList = new LinkedList<TreeOperation>(); - for(Value v: listValue) { - DefaultTreeOperationContainer container = msgpack.convert(v, DefaultTreeOperationContainer.class); - logList.add(container.convert()); - } - DefaultTreeOperationLog log = new DefaultTreeOperationLog(logList, logList.size()); - return log; - } - - - -}
--- a/src/jungle/test/operations/NetworkNodeOperation.java Mon Jul 01 20:31:29 2013 +0900 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,47 +0,0 @@ -package jungle.test.operations; - -import java.nio.ByteBuffer; - -import org.msgpack.annotation.Message; - -import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.Command; -import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.operations.NodeOperation; -import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.trasnformer.EditableNode; -import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Either; -import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Error; - -@Message -public class NetworkNodeOperation implements NodeOperation { - - @Override - public Command getCommand() { - // TODO Auto-generated method stub - return null; - } - - @Override - public String getKey() { - // TODO Auto-generated method stub - return null; - } - - @Override - public int getPosition() { - // TODO Auto-generated method stub - return 0; - } - - @Override - public ByteBuffer getValue() { - // TODO Auto-generated method stub - return null; - } - - @Override - public <T extends EditableNode<T>> Either<Error, T> invoke(T arg0) { - // TODO Auto-generated method stub - return null; - } - - -}
--- a/src/jungle/test/operations/NetworkNodePath.java Mon Jul 01 20:31:29 2013 +0900 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,59 +0,0 @@ -package jungle.test.operations; - -import java.util.Iterator; -import java.util.LinkedList; - -import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.NodePath; -import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Pair; - -public class NetworkNodePath implements NodePath -{ - LinkedList<Integer> path; - - public NetworkNodePath() { - path = new LinkedList<Integer>(); - } - - private NetworkNodePath(LinkedList<Integer> _path) { - path = _path; - } - - @Override - public Iterator<Integer> iterator() { - return path.iterator(); - } - - @Override - public NetworkNodePath add(int _pos) { - LinkedList<Integer> newPath = copyPath(); - newPath.add(_pos); - return new NetworkNodePath(newPath); - } - - @Override - public Pair<Integer, NodePath> pop() { - LinkedList<Integer> cPath = copyPath(); - int e = cPath.getFirst(); - cPath.remove(); - return new Pair<Integer, NodePath>(e, new NetworkNodePath(cPath)); - } - - @Override - public int size() { - return path.size(); - } - - private LinkedList<Integer> copyPath() { - LinkedList<Integer> newPath = new LinkedList<Integer>(); - for (Integer i : path) { - newPath.add(i); - } - return newPath; - } - - @Override - public String toString() { - return path.toString(); - } - -}
--- a/src/jungle/test/operations/NetworkTreeOperation.java Mon Jul 01 20:31:29 2013 +0900 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,35 +0,0 @@ -package jungle.test.operations; - -import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.NodePath; -import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.operations.NodeOperation; -import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.operations.TreeOperation; - -import org.msgpack.annotation.Message; - -@Message -public class NetworkTreeOperation implements TreeOperation { - - public NodePath path; - public NodeOperation operation; - - public NetworkTreeOperation() { - path = null; - operation = null; - } - - public NetworkTreeOperation(NodePath _p, NodeOperation _op) { - path = _p; - operation = _op; - } - - @Override - public NodePath getNodePath() { - return path; - } - - @Override - public NodeOperation getNodeOperation() { - return operation; - } - -}
--- a/src/jungle/test/operations/NetworkTreeOperationLog.java Mon Jul 01 20:31:29 2013 +0900 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,72 +0,0 @@ -package jungle.test.operations; - -import java.util.Iterator; -import java.util.LinkedList; - -import org.msgpack.annotation.Message; - -import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.NodePath; -import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.logger.TreeOperationLog; -import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.operations.NodeOperation; -import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.operations.TreeOperation; - -@Message -public class NetworkTreeOperationLog implements TreeOperationLog -{ - public Iterable<TreeOperation> list; - public int size; - - public NetworkTreeOperationLog() { - list = new LinkedList<TreeOperation>(); - size = 0; - } - - public NetworkTreeOperationLog(Iterable<TreeOperation> _list, int _size) - { - list = _list; - size = _size; - } - - public Iterable<TreeOperation> getOperationLogList() { - return list; - } - - @Override - public Iterator<TreeOperation> iterator() { - return list.iterator(); - } - - @Override - public NetworkTreeOperationLog add(NodePath _p, NodeOperation _op) - { - TreeOperation op = new NetworkTreeOperation(_p, _op); - LinkedList<TreeOperation> newList = new LinkedList<TreeOperation>(); - for (Iterator<TreeOperation> iter = list.iterator(); iter.hasNext();) { - TreeOperation o = iter.next(); - newList.add(o); - } - newList.add(op); - return new NetworkTreeOperationLog(newList, size+1); - } - - @Override - public NetworkTreeOperationLog append(TreeOperationLog _log) - { - LinkedList<TreeOperation> newList = new LinkedList<TreeOperation>(); - for (Iterator<TreeOperation> iter = list.iterator(); iter.hasNext();) { - TreeOperation o = iter.next(); - newList.add(o); - } - for (TreeOperation o : _log) { - newList.add(o); - } - return new NetworkTreeOperationLog(newList, size+_log.length()); - } - - @Override - public int length() - { - return size; - } - -}
--- a/src/jungle/test/operations/messagepack/PackOperationLog.java Mon Jul 01 20:31:29 2013 +0900 +++ b/src/jungle/test/operations/messagepack/PackOperationLog.java Mon Jul 01 20:34:03 2013 +0900 @@ -8,13 +8,14 @@ import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.NodePath; import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.operations.NodeOperation; import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.operations.TreeOperation; -import jungle.test.operations.NetworkNodeOperation; -import jungle.test.operations.NetworkNodePath; -import jungle.test.operations.NetworkTreeOperationLog; import org.msgpack.MessagePack; import org.msgpack.type.Value; +import alice.jungle.operations.NetworkNodeOperation; +import alice.jungle.operations.NetworkNodePath; +import alice.jungle.operations.NetworkTreeOperationLog; + public class PackOperationLog { public static void main(String[] args) throws IOException {
--- a/src/jungle/test/transaction/NetworkDefaultJungleTree.java Mon Jul 01 20:31:29 2013 +0900 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,44 +0,0 @@ -package jungle.test.transaction; - -import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.JungleTree; -import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.JungleTreeEditor; -import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.core.Node; -import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.persistent.ChangeListWriter; -import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.ChangeSet; -import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.TreeEditor; -import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.TreeNode; -import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.transaction.AtomicReservableReference; -import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.transaction.DefaultTransactionManager; -import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.transaction.TreeContext; - -public class NetworkDefaultJungleTree<T extends TreeNode<T>> implements JungleTree { - private final AtomicReservableReference<TreeContext<T>> repository; - private final String uuid; - private final ChangeListWriter writer; - private final TreeEditor editor; - - public NetworkDefaultJungleTree(TreeContext<T> _tc,String _uuid,ChangeListWriter _writer,TreeEditor _editor) - { - repository = new AtomicReservableReference<TreeContext<T>>(_tc); - uuid = _uuid; - writer = _writer; - editor = _editor; - } - - @Override - public JungleTreeEditor getTreeEditor() - { - TreeContext<T> tc = repository.get(); - DefaultTransactionManager<T> txManager = new DefaultTransactionManager<T>(writer,tc,repository,uuid); - T root = tc.getTreeNode(); - return new NetworkDefaultJungleTreeEditor<T>(root,txManager,editor); - } - - @Override - public Node getRootNode() - { - TreeContext<T> tc = repository.get(); - ChangeSet cs = tc.getChangeSet(); - return cs.getRoot(); - } -}
--- a/src/jungle/test/transaction/NetworkDefaultJungleTreeEditor.java Mon Jul 01 20:31:29 2013 +0900 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,151 +0,0 @@ -package jungle.test.transaction; - -import java.nio.ByteBuffer; - -import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.JungleTreeEditor; -import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.core.Node; -import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.NodePath; -import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.TreeEditor; -import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.TreeNode; -import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.logger.DefaultTreeOperationLog; -import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.logger.LoggingNodeHook; -import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.logger.OperationLog; -import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.logger.TreeOperationLog; -import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.operations.DefaultTreeOperation; -import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.operations.NodeOperation; -import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.operations.TreeOperation; -import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.trasnformer.AppendChildAt; -import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.trasnformer.DeleteAttribute; -import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.trasnformer.DeleteChildAt; -import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.trasnformer.NodeEditor; -import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.trasnformer.PutAttribute; -import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.transaction.DefaultJungleTreeEditor; -import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.transaction.TransactionManager; -import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.DefaultEither; -import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Either; -import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Error; -import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.IterableConverter; - -public class NetworkDefaultJungleTreeEditor<T extends TreeNode<T>> implements JungleTreeEditor { - - private final TransactionManager<T> txManager; - private final T root; - private final TreeEditor editor; - private final TreeOperationLog log; - - public NetworkDefaultJungleTreeEditor(T _root,TransactionManager<T> _txManager,TreeEditor _editor) - { - this(_root,_txManager,_editor,new DefaultTreeOperationLog()); - } - - public NetworkDefaultJungleTreeEditor(T _root,TransactionManager<T> _txManager,TreeEditor _editor,TreeOperationLog _log) - { - root = _root; - txManager = _txManager; - editor = _editor; - log = _log; - } - - private Either<Error,JungleTreeEditor> _edit(final NodePath _path,NodeEditor _e) - { - LoggingNodeHook hook = new LoggingNodeHook(_e); - Either<Error,T> either = editor.edit(root,_path,hook); - if(either.isA()){ - return DefaultEither.newA(either.a()); - } - - T newNode = either.b(); - OperationLog newLog = hook.getLog(); - - IterableConverter.Converter<TreeOperation,NodeOperation> converter = new IterableConverter.Converter<TreeOperation,NodeOperation>(){ - @Override - public TreeOperation conv(NodeOperation _b){ - return new DefaultTreeOperation(_path,_b); - } - }; - - Iterable<TreeOperation> iterable = new IterableConverter<TreeOperation,NodeOperation>(newLog,converter); - DefaultTreeOperationLog treeOperationLog = new DefaultTreeOperationLog(iterable,newLog.length()); - TreeOperationLog newTreeOpLog = log.append(treeOperationLog); - - JungleTreeEditor newEditor = new NetworkDefaultJungleTreeEditor<T>(newNode,txManager,editor,newTreeOpLog); - return DefaultEither.newB(newEditor); - } - - @Override - public Either<Error,JungleTreeEditor> addNewChildAt(NodePath _path, int _pos) - { - AppendChildAt appendChildAt = new AppendChildAt(_pos); - return _edit(_path,appendChildAt); - } - - @Override - public Either<Error,JungleTreeEditor> deleteChildAt(NodePath _path, int _pos) - { - DeleteChildAt deleteChildAt = new DeleteChildAt(_pos); - return _edit(_path,deleteChildAt); - } - - @Override - public Either<Error,JungleTreeEditor> putAttribute(NodePath _path,String _key,ByteBuffer _value) - { - PutAttribute putAttribute = new PutAttribute(_key,_value); - return _edit(_path,putAttribute); - } - - @Override - public Either<Error,JungleTreeEditor> deleteAttribute(NodePath _path, String _key) - { - DeleteAttribute deleteAttribute = new DeleteAttribute(_key); - return _edit(_path,deleteAttribute); - } - - @Override - public Either<Error,JungleTreeEditor> edit(NodePath _path,NodeEditor _editor) - { - return _edit(_path,_editor); - } - - @Override - public Either<Error,JungleTreeEditor> success() - { - Either<Error,TransactionManager<T>> either = txManager.commit(root,log); - if(either.isA()){ - return DefaultEither.newA(either.a()); - } - - TransactionManager<T> newTxManager = either.b(); - JungleTreeEditor newTreeEditor = new NetworkDefaultJungleTreeEditor<T>(root,newTxManager,editor); - - return DefaultEither.newB(newTreeEditor); - } - - @Override - public String getID() - { - return txManager.getUUID(); - } - - @Override - public String getRevision() - { - return Long.toString(txManager.getRevision()); - } - - @Override - public Node getRoot() - { - return null; - } - - public JungleTreeEditor setNewLogAndGetEditor(TreeOperationLog _log) { - JungleTreeEditor newEditor = new NetworkDefaultJungleTreeEditor<T>(root,txManager,editor, _log); - return newEditor; - } - - public TreeOperationLog getTreeOperationLog() { - return log; - } - - -}
--- a/src/jungle/test/transaction/NetworkTransactionManager.java Mon Jul 01 20:31:29 2013 +0900 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,87 +0,0 @@ -package jungle.test.transaction; - -import java.util.Iterator; - -import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.core.Node; -import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.persistent.ChangeList; -import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.persistent.ChangeListWriter; -import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.persistent.Result; -import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.ChangeSet; -import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.TreeNode; -import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.logger.TreeOperationLog; -import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.operations.TreeOperation; -import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.transaction.AtomicReservableReference; -import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.transaction.AtomicReservableReference.Reservation; -import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.transaction.DefaultChangeSet; -import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.transaction.DefaultTreeContext; -import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.transaction.TransactionManager; -import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.transaction.TreeContext; -import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.DefaultEither; -import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.DefaultError; -import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Either; -import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Error; - -public class NetworkTransactionManager<T extends TreeNode<T>> implements TransactionManager<T> -{ - - private final AtomicReservableReference<TreeContext<T>> repository; - private final TreeContext<T> tip; - private final ChangeListWriter writer; - private final String uuid; - private final String treeName; - - public NetworkTransactionManager(ChangeListWriter _writer,TreeContext<T> _tip, - AtomicReservableReference<TreeContext<T>> _repository,String _uuid, String _treeName) - { - repository = _repository; - tip = _tip; - writer = _writer; - uuid = _uuid; - treeName = _treeName; - } - - @Override - public Either<Error, TransactionManager<T>> commit(T _newRoot,final TreeOperationLog _log) { - ChangeSet cs = tip.getChangeSet(); - long currentRevision = cs.revision(); - long nextRevision = currentRevision + 1; - - ChangeList list = new ChangeList() { - @Override - public Iterator<TreeOperation> iterator(){ - return _log.iterator(); - } - }; - - Node root = _newRoot.getAsNode(); - DefaultChangeSet newCs = new DefaultChangeSet(root, cs, list, uuid, nextRevision); - DefaultTreeContext<T> newContext = new DefaultTreeContext<T>(_newRoot,newCs); - - @SuppressWarnings("rawtypes") - Reservation reservation = repository.makeReservation(tip, newContext); - if(reservation == null) { - return DefaultEither.newA((Error)new DefaultError()); - } - Result r = writer.write(list); - if(r == Result.SUCCESS){ - reservation.confirm(); - TransactionManager<T> txManager = new NetworkTransactionManager<T>(writer, newContext, repository, uuid, treeName); - return DefaultEither.newB(txManager); - } - - return DefaultEither.newA((Error)new DefaultError()); - } - - @Override - public long getRevision() - { - ChangeSet cs = tip.getChangeSet(); - return cs.revision(); - } - - @Override - public String getUUID() { - return uuid; - } - -}