finished implementing a command line user interface

Author: thsc42

src/net/sharksystem/asap/MultiASAPEngineFS_Impl.java

@@ -33,8 +33,8 @@ public static MultiASAPEngineFS createMultiEngine(CharSequence folder, ASAPChunk
      * root directory. setting list can be created by iterating those storages.
      * @param rootFolderName
      */
-    MultiASAPEngineFS_Impl(CharSequence owner, CharSequence rootFolderName, long maxExecutionTime,
-                                  ASAPChunkReceivedListener listener) throws ASAPException, IOException {
+    private MultiASAPEngineFS_Impl(CharSequence owner, CharSequence rootFolderName, long maxExecutionTime,
+                                   ASAPChunkReceivedListener listener) throws ASAPException, IOException {
         this.owner = owner;
         this.maxExecutionTime = maxExecutionTime;
         this.rootFolderName = rootFolderName;

src/net/sharksystem/cmdline/CmdLineUI.java

@@ -1,25 +1,27 @@
 package net.sharksystem.cmdline;
 
+import net.sharksystem.asap.*;
+
 import java.io.*;
 import java.util.HashMap;
 import java.util.Map;
 import java.util.StringTokenizer;
 
 /**
- * commands
- * - open
- * - connect
- * - list
- * - kill
- *
  * @author thsc
  */
 public class CmdLineUI {
+    // commands
     public static final String CONNECT = "connect";
     public static final String OPEN = "open";
     public static final String EXIT = "exit";
     public static final String LIST = "list";
     public static final String KILL = "kill";
+    public static final String SETWAITING = "setwaiting";
+    public static final String CREATE_ASAP_ENGINE = "newengine";
+    public static final String CREATE_ASAP_STORAGE = "newstorage";
+    public static final String CREATE_ASAP_MESSAGE = "newmessage";
+    public static final String RESET_ASAP_STORAGES = "resetstorage";
 
     private final PrintStream consoleOutput;
     private final BufferedReader userInput;
@@ -31,7 +33,7 @@ public static void main(String[] args) {
         CmdLineUI userCmd = new CmdLineUI(os, System.in);
 
         userCmd.printUsage();
-        userCmd.runGame();
+        userCmd.runCommandLoop();
     }
 
     public CmdLineUI(PrintStream os, InputStream is) {
@@ -58,6 +60,21 @@ public void printUsage() {
         b.append(KILL);
         b.append(".. kill an open connection");
         b.append("\n");
+        b.append(SETWAITING);
+        b.append(".. set waiting period");
+        b.append("\n");
+        b.append(CREATE_ASAP_ENGINE);
+        b.append(".. create new asap engine");
+        b.append("\n");
+        b.append(CREATE_ASAP_STORAGE);
+        b.append(".. create new asap storage");
+        b.append("\n");
+        b.append(CREATE_ASAP_MESSAGE);
+        b.append(".. add message to storage");
+        b.append("\n");
+        b.append(RESET_ASAP_STORAGES);
+        b.append(".. removes all asap storages");
+        b.append("\n");
         b.append(EXIT);
         b.append(".. exit");
 
@@ -73,30 +90,55 @@ public void printUsage(String cmdString, String comment) {
         switch(cmdString) {
             case CONNECT:
                 out.println(CONNECT + " IP/DNS-Name_remoteHost remotePort");
-                out.println("example: " + CONNECT + "  localhost 7070");
-                out.println("tries to connect to localhost:7070");
+                out.println("example: " + CONNECT + " localhost 7070 Bob");
+                out.println("tries to connect to localhost:7070 and let engine Bob handle connection when established");
                 break;
             case OPEN:
-                out.println(OPEN + " localPort");
-                out.println("example: " + OPEN + " 7070");
-                out.println("opens a server socket #7070");
+                out.println(OPEN + " localPort engineName");
+                out.println("example: " + OPEN + " 7070 Alice");
+                out.println("opens a server socket #7070 and let engine Alice handle connection when established");
                 break;
             case LIST:
                 out.println("lists all open connections / client and server");
                 break;
             case KILL:
                 out.println(KILL + " channel name");
-                out.println("example: " + KILL + "localhost:7070");
+                out.println("example: " + KILL + " localhost:7070");
                 out.println("kills channel named localhost:7070");
                 out.println("channel names are produced by using list");
                 out.println(KILL + "all .. kills all open connections");
                 break;
+            case SETWAITING:
+                out.println(SETWAITING + " number of millis to wait between two connection attempts");
+                out.println("example: " + KILL + " 1000");
+                out.println("set waiting period to one second");
+                break;
+            case CREATE_ASAP_ENGINE:
+                out.println(CREATE_ASAP_ENGINE + " name");
+                out.println("example: " + CREATE_ASAP_ENGINE + " Alice");
+                out.println("create engine called Alice - data kept under a folder called tests/Alice");
+                break;
+            case CREATE_ASAP_STORAGE:
+                out.println(CREATE_ASAP_STORAGE + " owner appName");
+                out.println("example: " + CREATE_ASAP_STORAGE + " Alice chat");
+                break;
+            case CREATE_ASAP_MESSAGE:
+                out.println(CREATE_ASAP_MESSAGE + " owner appName uri message");
+                out.println("example: " + CREATE_ASAP_MESSAGE + " Alice chat sn2://abChat HiBob");
+                out.println("note: message can only be ONE string. That would not work:");
+                out.println("does not work: " + CREATE_ASAP_MESSAGE + " Alice chat sn2://abChat Hi Bob");
+                out.println("five parameters instead of four.");
+                break;
+            case RESET_ASAP_STORAGES:
+                out.println(RESET_ASAP_STORAGES);
+                out.println("removes all storages");
+                break;
         }
 
         out.println("unknown command: " + cmdString);
     }
 
-    public void runGame() {
+    public void runCommandLoop() {
 
         boolean again = true;
         while(again) {
@@ -132,6 +174,16 @@ public void runGame() {
                         this.doList(); break;
                     case KILL:
                         this.doKill(parameterString); break;
+                    case SETWAITING:
+                        this.doSetWaiting(parameterString); break;
+                    case CREATE_ASAP_ENGINE:
+                        this.doCreateASAPMultiEngine(parameterString); break;
+                    case CREATE_ASAP_STORAGE:
+                        this.doCreateASAPStorage(parameterString); break;
+                    case CREATE_ASAP_MESSAGE:
+                        this.doCreateASAPMessage(parameterString); break;
+                    case RESET_ASAP_STORAGES:
+                        ASAPEngineFS.removeFolder("tests"); break;
                     case "q": // convenience
                     case EXIT:
                         this.doKill("all");
@@ -149,12 +201,23 @@ public void runGame() {
         }
     }
 
-    private Map<String, TCPChannel> openConnections = new HashMap<>();
+    private Map<String, TCPChannel> channels = new HashMap<>();
+    private long waitPeriod = 1000*30; // 30 seconds
 
-    private void startChannel(String name, TCPChannel channel) {
-        channel.setWaitPeriod(1000*30); // 30 seconds
+    private void setWaitPeriod(long period) {
+        this.waitPeriod = period;
+    }
+
+    private void startChannel(String name, TCPChannel channel, String engineName) throws ASAPException {
+        channel.setWaitPeriod(this.waitPeriod);
+        MultiASAPEngineFS multiASAPEngineFS = this.engines.get(engineName);
+        if(multiASAPEngineFS == null) {
+            throw new ASAPException("engine does not exist: " + engineName);
+        }
+
+        channel.setListener(new TCPChannelCreatedHandler(multiASAPEngineFS));
         channel.start();
-        this.openConnections.put(name, channel);
+        this.channels.put(name, channel);
     }
 
     private void doConnect(String parameterString) {
@@ -163,14 +226,17 @@ private void doConnect(String parameterString) {
         try {
             String remoteHost = st.nextToken();
             String remotePortString = st.nextToken();
+            String engineName = st.nextToken();
             int remotePort = Integer.parseInt(remotePortString);
 
             String name =  remoteHost + ":" + remotePortString;
 
-            this.startChannel(name,  new TCPChannel(remotePort, false, name));
+            this.startChannel(name,  new TCPChannel(remotePort, false, name), engineName);
         }
         catch(RuntimeException re) {
             this.printUsage(CONNECT, re.getLocalizedMessage());
+        } catch (ASAPException e) {
+            this.printUsage(CONNECT, e.getLocalizedMessage());
         }
     }
 
@@ -179,21 +245,29 @@ private void doOpen(String parameterString) {
 
         try {
             String portString = st.nextToken();
+            String engineName = st.nextToken();
 
             int port = Integer.parseInt(portString);
             String name =  "server:" + port;
 
-            this.startChannel(name,  new TCPChannel(port, true, name));
+            this.startChannel(name,  new TCPChannel(port, true, name), engineName);
         }
         catch(RuntimeException re) {
             this.printUsage(OPEN, re.getLocalizedMessage());
+        } catch (ASAPException e) {
+            this.printUsage(OPEN, e.getLocalizedMessage());
         }
     }
 
     private void doList() {
-        for(String connectionName : this.openConnections.keySet()) {
+        System.out.println("connections:");
+        for(String connectionName : this.channels.keySet()) {
             System.out.println(connectionName);
         }
+        System.out.println("engines:");
+        for(String engineName : this.engines.keySet()) {
+            System.out.println(engineName);
+        }
     }
 
     private void doKill(String parameterString) {
@@ -203,14 +277,14 @@ private void doKill(String parameterString) {
             String channelName = st.nextToken();
             if(channelName.equalsIgnoreCase("all")) {
                 System.out.println("kill all open channels..");
-                for(TCPChannel channel : this.openConnections.values()) {
+                for(TCPChannel channel : this.channels.values()) {
                     channel.kill();
                 }
-                this.openConnections = new HashMap<>();
+                this.channels = new HashMap<>();
                 System.out.println(".. done");
             } else {
 
-                TCPChannel channel = this.openConnections.remove(channelName);
+                TCPChannel channel = this.channels.remove(channelName);
                 if (channel == null) {
                     System.err.println("channel does not exist: " + channelName);
                     return;
@@ -225,5 +299,88 @@ private void doKill(String parameterString) {
             this.printUsage(KILL, e.getLocalizedMessage());
         }
     }
+
+    private void doSetWaiting(String parameterString) {
+        StringTokenizer st = new StringTokenizer(parameterString);
+
+        try {
+            String waitingPeriodString = st.nextToken();
+            long period = Long.parseLong(waitingPeriodString);
+            this.setWaitPeriod(period);
+        }
+        catch(RuntimeException e) {
+            this.printUsage(SETWAITING, e.getLocalizedMessage());
+        }
+    }
+
+    public static final String TESTS_ROOT_FOLDER = "tests";
+    private Map<String, MultiASAPEngineFS> engines = new HashMap();
+    private void doCreateASAPMultiEngine(String parameterString) {
+        StringTokenizer st = new StringTokenizer(parameterString);
+
+        try {
+            String engineName = st.nextToken();
+            this.engines.put(
+                    engineName,
+                    MultiASAPEngineFS_Impl.createMultiEngine(engineName,
+                            TESTS_ROOT_FOLDER + "/" + engineName,
+                            this.waitPeriod, null));
+        }
+        catch(RuntimeException e) {
+            this.printUsage(CREATE_ASAP_ENGINE, e.getLocalizedMessage());
+        } catch (IOException | ASAPException e) {
+            this.printUsage(CREATE_ASAP_ENGINE, e.getLocalizedMessage());
+        }
+    }
+
+    private String getStorageKey(String owner, String appName) {
+        return owner + ":" + appName;
+    }
+
+    private Map<String, ASAPStorage> storages = new HashMap();
+    private void doCreateASAPStorage(String parameterString) {
+        StringTokenizer st = new StringTokenizer(parameterString);
+
+        try {
+            String owner = st.nextToken();
+            String appName = st.nextToken();
+            String appFolderName = TESTS_ROOT_FOLDER + "/" + owner + "/" + appName;
+            String format = "sn2://" + appName;
+
+            ASAPStorage storage =
+                    ASAPEngineFS.getASAPStorage(owner, appFolderName, format);
+
+            this.storages.put(this.getStorageKey(owner, appName), storage);
+        }
+        catch(RuntimeException e) {
+            this.printUsage(CREATE_ASAP_STORAGE, e.getLocalizedMessage());
+        } catch (IOException | ASAPException e) {
+            this.printUsage(CREATE_ASAP_STORAGE, e.getLocalizedMessage());
+        }
+    }
+
+    private void doCreateASAPMessage(String parameterString) {
+        StringTokenizer st = new StringTokenizer(parameterString);
+
+        try {
+            String owner = st.nextToken();
+            String appName = st.nextToken();
+            String uri = st.nextToken();
+            String message = st.nextToken();
+
+            // first - get storage
+            ASAPStorage asapStorage = this.storages.get(this.getStorageKey(owner, appName));
+            if(asapStorage == null) {
+                System.err.println("storage does not exist: " + this.getStorageKey(owner, appName));
+                return;
+            }
+            asapStorage.add(uri, message);
+        }
+        catch(RuntimeException e) {
+            this.printUsage(CREATE_ASAP_MESSAGE, e.getLocalizedMessage());
+        } catch (IOException e) {
+            this.printUsage(CREATE_ASAP_MESSAGE, e.getLocalizedMessage());
+        }
+    }
 }
 

src/net/sharksystem/cmdline/TCPChannel.java

@@ -14,6 +14,7 @@ public class TCPChannel extends Thread {
     private final int port;
     private final boolean asServer;
     private final String name;
+    private TCPChannelCreatedListener listener = null;
     private Socket socket = null;
 
     private boolean fatalError = false;
@@ -24,10 +25,19 @@ public class TCPChannel extends Thread {
     private TCPClient tcpClient = null;
     private long waitInMillis = WAIT_LOOP_IN_MILLIS;
 
-    public TCPChannel(int port, boolean asServer, String name) {
+    public TCPChannel(int port, boolean asServer, String name, TCPChannelCreatedListener listener) {
         this.port = port;
         this.asServer = asServer;
         this.name = name;
+        this.listener = listener;
+    }
+
+    public TCPChannel(int port, boolean asServer, String name) {
+        this(port, asServer, name, null);
+    }
+
+    public void setListener(TCPChannelCreatedListener listener) {
+        this.listener = listener;
     }
 
     public void setWaitPeriod(long waitInMillis) {
@@ -65,10 +75,15 @@ public void run() {
         }
         } catch (IOException ex) {
             //<<<<<<<<<<<<<<<<<<debug
-            String s = "couldn't esatblish connection";
+            String s = "couldn't establish connection";
             System.out.println(s);
             this.fatalError = true;
         }
+        finally {
+            if(this.listener != null) {
+                this.listener.channelCreated(this);
+            }
+        }
     }
 
     public void close() throws IOException {