added abstract command executor; dynamic load and execution of executors

client/src/main/java/com/uqac/rthoni/com/java_rmi/client/ClientApplication.java → client/src/main/java/com/uqac/rthoni/java_rmi/client/ClientApplication.java

-package com.uqac.rthoni.com.java_rmi.client;
+package com.uqac.rthoni.java_rmi.client;
 
 import com.uqac.rthoni.java_rmi.common.Command;
 
  */
 public class ClientApplication {
 
-    public static Vector<Command> readInputFile(String file)
+    public Vector<Command> readInputFile(String file)
     {
         FileInputStream fileInputStream = null;
         try {
         return lines;
     }
 
-    public static void run(String host, int port, String inputFile, String outputFile)
+    public void run(String host, int port, String inputFile, String outputFile)
     {
         System.out.format("Reading input file %s...\n", inputFile);
         Vector<Command> commands = readInputFile(inputFile);
         }
     }
 
-    private static void runCommand(Command command, String host, int port, OutputStream outputStream)
+    private void runCommand(Command command, String host, int port, OutputStream outputStream)
     {
         System.out.format("Running command %s...\n", command.getCommandName());
         System.out.format("Connecting to %s:%d...\n", host, port);

common/src/main/java/com/uqac/rthoni/java_rmi/common/ReflectionUtil.java

+package com.uqac.rthoni.java_rmi.common;
+
+import java.io.File;
+import java.io.IOException;
+import java.io.UnsupportedEncodingException;
+import java.net.JarURLConnection;
+import java.net.URL;
+import java.net.URLDecoder;
+import java.util.*;
+import java.util.jar.JarEntry;
+import java.util.jar.JarFile;
+import java.util.stream.Collectors;
+
+/**
+ * Created by robin on 9/16/16.
+ */
+public class ReflectionUtil {
+
+    public static Vector<Class> getClassesForPackage(String pckgname)
+            throws ClassNotFoundException {
+
+        Vector<Class> classes = new Vector<>();
+        ArrayList<File> directories = new ArrayList<>();
+        try {
+            ClassLoader cld = Thread.currentThread().getContextClassLoader();
+
+            Enumeration<URL> resources = cld.getResources(pckgname.replace('.', '/'));
+            while (resources.hasMoreElements()) {
+                URL res = resources.nextElement();
+                if (res.getProtocol().equalsIgnoreCase("jar")){
+                    JarURLConnection conn = (JarURLConnection) res.openConnection();
+                    JarFile jar = conn.getJarFile();
+                    for (JarEntry e: Collections.list(jar.entries())){
+
+                        if(e.getName().startsWith(pckgname.replace('.', '/'))
+                                && e.getName().endsWith(".class") && !e.getName().contains("$")){
+                            String className = e.getName().replace("/",".").substring(0,e.getName().length() - 6);
+                            classes.add(Class.forName(className));
+                        }
+                    }
+                }else
+                    directories.add(new File(URLDecoder.decode(res.getPath(), "UTF-8")));
+            }
+        } catch (Exception e) {
+            throw new ClassNotFoundException(String.format("Failed to get jar info: %s", e.getMessage()));
+        }
+
+        // For every directory identified capture all the .class files
+        for (File directory : directories) {
+            if (directory.exists()) {
+                // Get the list of the files contained in the package
+                String[] files = directory.list();
+                for (String file : files) {
+                    // we are only interested in .class files
+                    if (file.endsWith(".class")) {
+                        // removes the .class extension
+                        classes.add(Class.forName(pckgname + '.' + file.substring(0, file.length() - 6)));
+                    }
+                }
+            } else {
+                throw new ClassNotFoundException(String.format("Failed to get class file for %s", directory.getName()));
+            }
+        }
+        return classes;
+    }
+
+    public static Vector<Class> getClassesOfSuperClass(String thePackage, Class superClass)
+            throws ClassNotFoundException {
+        Vector<Class> classList = new Vector<>();
+        classList.addAll(getClassesForPackage(thePackage).stream()
+                .filter(discovered -> Collections.singletonList(discovered.getSuperclass())
+                        .contains(superClass)).collect(Collectors.toList()));
+
+        return classList;
+    }
+}

server/src/main/java/com/uqac/rthoni/com/java_rmi/server/ServerApplication.java → server/src/main/java/com/uqac/rthoni/java_rmi/server/ServerApplication.java

-package com.uqac.rthoni.com.java_rmi.server;
+package com.uqac.rthoni.java_rmi.server;
 
+import com.uqac.rthoni.java_rmi.server.executors.AbstractCommandExecutor;
 import com.uqac.rthoni.java_rmi.common.Command;
 
 import java.io.BufferedReader;
 import java.net.InetAddress;
 import java.net.ServerSocket;
 import java.net.Socket;
+import java.util.Vector;
 
 /**
  * Created by robin on 9/15/16.
  */
 public class ServerApplication {
 
+    private Vector<AbstractCommandExecutor> _executors = null;
+
     public static String ipToString(InetAddress ip) {
         String ipString = ip.toString();
         if (!ipString.isEmpty() && ipString.startsWith("/")) {
         }
     }
 
-    public static void run(int port, String sourceDir, String classDir, String logFile)
+    public void run(int port, String sourceDir, String classDir, String logFile)
     {
+        try {
+            loadExecutors();
+        } catch (ClassNotFoundException e) {
+            System.err.format("Failed to load executors: %s\n", e.getMessage());
+            System.exit(1);
+        }
+
         String host = "0.0.0.0";
         InetAddress ip = null;
         try {
         }
         if (ip == null) {
             System.err.format("Failed to resolve '%s'\n", host);
-            System.exit(1);
+            System.exit(2);
         }
         String ipString = ipToString(ip);
 
             runServer(serverSocket);
         } catch (IOException e) {
             System.err.format("Failed to listen on %s:%d: %s\n", ipString, port, e.getMessage());
-            System.exit(2);
+            System.exit(3);
         }
     }
 
-    public static void runServer(ServerSocket serverSocket)
+    private void loadExecutors() throws ClassNotFoundException
     {
-        boolean stop = false;
-        while (!stop) {
+        _executors = new Vector<>();
+        Vector<Class> classes = AbstractCommandExecutor.getAllExecutors();
+        for (Class c : classes) {
+            try {
+                AbstractCommandExecutor executor = (AbstractCommandExecutor)c.newInstance();
+                _executors.add(executor);
+            } catch (Exception e) {
+                System.err.format("Failed to load executor '%s': %s\n", c.getName(), e.getMessage());
+            }
+        }
+    }
+
+    private void runServer(ServerSocket serverSocket)
+    {
+        while (true) {
             Socket client = null;
             try {
                 client = serverSocket.accept();
         }
     }
 
-    private static void handleClient(Socket client)
+    private void handleClient(Socket client)
     {
         String str;
         try {
         }
         else {
             System.out.format("Received command: %s\n", command.getCommandName());
+
+            handleCommand(command, client);
+        }
+    }
+
+    private AbstractCommandExecutor getExecutor(Command command)
+    {
+        for (AbstractCommandExecutor executor : _executors) {
+            if (executor.getCommandName().equals(command.getCommandName())) {
+                return executor;
+            }
+        }
+        return null;
+    }
+
+    private void handleCommand(Command command, Socket client)
+    {
+        String data;
+        AbstractCommandExecutor executor = getExecutor(command);
+        if (executor == null) {
+            data = String.format("Unknown command '%s'", command.getCommandName());
+            System.err.println(data);
+        }
+        else {
             try {
-                client.getOutputStream().write("test\n".getBytes());
-            } catch (IOException e) {
-                e.printStackTrace();
+                data = executor.run(command);
+            } catch (Exception e) {
+                data = String.format("Error when handling command: %s", e.getMessage());
+                System.err.println(data);
             }
         }
+
+        try {
+            client.getOutputStream().write(String.format("%s\n", data).getBytes());
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
     }
 }

server/src/main/java/com/uqac/rthoni/java_rmi/server/executors/AbstractCommandExecutor.java

+package com.uqac.rthoni.java_rmi.server.executors;
+
+import com.uqac.rthoni.java_rmi.common.Command;
+import com.uqac.rthoni.java_rmi.common.ReflectionUtil;
+
+import java.util.Vector;
+
+/**
+ * Created by robin on 9/16/16.
+ */
+public abstract class AbstractCommandExecutor {
+
+    public static Vector<Class> getAllExecutors() throws ClassNotFoundException
+    {
+        return ReflectionUtil.getClassesOfSuperClass(AbstractCommandExecutor.class.getPackage().getName(), AbstractCommandExecutor.class);
+    }
+
+    public abstract String getCommandName();
+
+    public abstract String run(Command command) throws Exception;
+}

server/src/main/java/com/uqac/rthoni/java_rmi/server/executors/TestExecutor.java

+package com.uqac.rthoni.java_rmi.server.executors;
+
+import com.uqac.rthoni.java_rmi.common.Command;
+
+/**
+ * Created by robin on 9/16/16.
+ */
+public class TestExecutor extends AbstractCommandExecutor {
+    @Override
+    public String getCommandName() {
+        return "test";
+    }
+
+    @Override
+    public String run(Command command) throws Exception {
+        return "Test. succeeded";
+    }
+}

src/main/java/com/uqac/rthoni/java_rmi/Main.java

 package com.uqac.rthoni.java_rmi;
 
-import com.uqac.rthoni.com.java_rmi.client.ClientApplication;
-import com.uqac.rthoni.com.java_rmi.server.ServerApplication;
+import com.uqac.rthoni.java_rmi.client.ClientApplication;
+import com.uqac.rthoni.java_rmi.server.ServerApplication;
 
 import java.io.PrintStream;
 
             String classDir = args[3];
             String logFile = args[4];
 
-            ServerApplication.run(port, sourceDir, classDir, logFile);
+            ServerApplication app = new ServerApplication();
+            app.run(port, sourceDir, classDir, logFile);
         }
         else if (mode.equals("client")) {
             String host = args[1];
             String inputFile = args[3];
             String outputFile = args[4];
 
-            ClientApplication.run(host, port, inputFile, outputFile);
+            ClientApplication app = new ClientApplication();
+            app.run(host, port, inputFile, outputFile);
         }
         else {
             usage(name, true);