implemented fifo

257844/src/main/java/cs451/parser/BarrierParser.java

@@ -0,0 +1,54 @@
+package cs451.parser;
+
+import java.net.InetAddress;
+import java.net.UnknownHostException;
+
+public class BarrierParser {
+
+    private static final String BARRIER_KEY = "--barrier";
+
+    private static final int BARRIER_ARGS_NUM = 2;
+    private static final String COLON_REGEX = ":";
+    private static final String IP_START_REGEX = "/";
+
+    private static String ip;
+    private static int port;
+
+    public boolean populate(String key, String value) {
+        if (!key.equals(BARRIER_KEY)) {
+            return false;
+        }
+
+        String[] barrier = value.split(COLON_REGEX);
+        if (barrier.length != BARRIER_ARGS_NUM) {
+            return false;
+        }
+
+        try {
+            String ipTest = InetAddress.getByName(barrier[0]).toString();
+            if (ipTest.startsWith(IP_START_REGEX)) {
+                ip = ipTest.substring(1);
+            } else {
+                ip = InetAddress.getByName(ipTest.split(IP_START_REGEX)[0]).getHostAddress();
+            }
+
+            port = Integer.parseInt(barrier[1]);
+            if (port <= 0) {
+                System.err.println("Barrier port must be a positive number!");
+                return false;
+            }
+        } catch (UnknownHostException e) {
+            e.printStackTrace();
+        }
+
+        return true;
+    }
+
+    public String getIp() {
+        return ip;
+    }
+
+    public int getPort() {
+        return port;
+    }
+}

257844/src/main/java/cs451/parser/ConfigParser.java

@@ -0,0 +1,44 @@
+package cs451.parser;
+
+import java.io.BufferedReader;
+import java.io.File;
+import java.io.FileReader;
+import java.io.IOException;
+
+public class ConfigParser {
+
+    private String path;
+
+    private int messages;
+
+
+    public boolean populate(String value) {
+        File file = new File(value);
+        path = file.getPath();
+
+        try (BufferedReader br = new BufferedReader(new FileReader(path))) {
+            int lineNum = 1;
+            for (String line; (line = br.readLine()) != null; lineNum++) {
+                switch(lineNum){
+                    case 1:
+                        messages = Integer.parseInt(line);
+                        break;
+                    default:
+                        break;
+                }
+            }
+        } catch (IOException e) {
+            System.err.println("Problem with the hosts file!");
+            return false;
+        }
+        return true;
+    }
+
+    public String getPath() {
+        return path;
+    }
+
+    public int getMessages() {
+        return messages;
+    }
+}

257844/src/main/java/cs451/parser/Constants.java

@@ -0,0 +1,30 @@
+package cs451.parser;
+
+public class Constants {
+
+    public static final int ARG_LIMIT_NO_CONFIG = 10;
+    public static final int ARG_LIMIT_CONFIG = 11;
+
+    // indexes for id
+    public static final int ID_KEY = 0;
+    public static final int ID_VALUE = 1;
+
+    // indexes for hosts
+    public static final int HOSTS_KEY = 2;
+    public static final int HOSTS_VALUE = 3;
+
+    // indexes for barrier
+    public static final int BARRIER_KEY = 4;
+    public static final int BARRIER_VALUE = 5;
+
+    // indexes for signal
+    public static final int SIGNAL_KEY = 6;
+    public static final int SIGNAL_VALUE = 7;
+
+    // indexes for output
+    public static final int OUTPUT_KEY = 8;
+    public static final int OUTPUT_VALUE = 9;
+
+    // indexes for config
+    public static final int CONFIG_VALUE = 10;
+}

257844/src/main/java/cs451/parser/Coordinator.java

@@ -0,0 +1,74 @@
+package cs451.parser;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.io.OutputStream;
+import java.io.DataOutputStream;
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
+import java.net.Socket;
+
+public class Coordinator {
+
+    private final int pid;
+
+    private final String barrierIp;
+    private final int barrierPort;
+
+    private final String signalIp;
+    private final int signalPort;
+
+    private final Socket signalSocket;
+
+    public Coordinator(int pid, String barrierIp, int barrierPort, String signalIp, int signalPort) {
+        this.pid = pid;
+        this.barrierIp = barrierIp;
+        this.barrierPort = barrierPort;
+        this.signalIp = signalIp;
+        this.signalPort = signalPort;
+
+        signalSocket = connectToHost(this.signalIp, this.signalPort);
+    }
+
+    public void waitOnBarrier() {
+        try {
+            Socket socket = connectToHost(barrierIp, barrierPort);
+            InputStream input = socket.getInputStream();
+            InputStreamReader reader = new InputStreamReader(input);
+            System.out.println("Accessing barrier...");
+
+            while (reader.read() != -1) {
+            }
+        } catch (IOException ex) {
+            System.out.println("I/O error: " + ex.getMessage());
+        }
+    }
+
+    public void finishedBroadcasting() {
+        try {
+            signalSocket.close();
+        } catch (IOException ex) {
+            System.out.println("I/O error: " + ex.getMessage());
+        }
+    }
+
+    private Socket connectToHost(String ip, int port) {
+        Socket socket = null;
+        try {
+            socket = new Socket(ip, port);
+            OutputStream output = socket.getOutputStream();
+            DataOutputStream writer = new DataOutputStream(output);
+
+            ByteBuffer bb = ByteBuffer.allocate(8);
+            bb.order(ByteOrder.BIG_ENDIAN);
+            bb.putLong(pid);
+
+            writer.write(bb.array(), 0, 8);
+        } catch (IOException ex) {
+            System.out.println("I/O error: " + ex.getMessage());
+        }
+
+        return socket;
+    }
+}

257844/src/main/java/cs451/parser/Host.java

@@ -0,0 +1,78 @@
+package cs451.parser;
+
+import java.net.InetAddress;
+import java.net.InetSocketAddress;
+import java.net.SocketAddress;
+import java.net.UnknownHostException;
+
+public class Host {
+
+    private static final String IP_START_REGEX = "/";
+
+    private int id = -1;
+    private String ip = null;
+    private int port = -1;
+    private SocketAddress addr = null;
+
+    public Host(InetSocketAddress addr, Integer id){
+        this.addr = addr;
+        this.ip = addr.getHostString();
+        this.port = addr.getPort();
+        this.id = id;
+    }
+
+    public Host(){}
+
+    public Host(Integer id){
+        this.id = id;
+    }
+
+    public boolean populate(String idString, String ipString, String portString) {
+        try {
+            id = Integer.parseInt(idString);
+
+            String ipTest = InetAddress.getByName(ipString).toString();
+            if (ipTest.startsWith(IP_START_REGEX)) {
+                ip = ipTest.substring(1);
+            } else {
+                ip = InetAddress.getByName(ipTest.split(IP_START_REGEX)[0]).getHostAddress();
+            }
+
+            port = Integer.parseInt(portString);
+            if (port <= 0) {
+                System.err.println("Port in the hosts file must be a positive number!");
+                return false;
+            }
+        } catch (NumberFormatException e) {
+            if (port == -1) {
+                System.err.println("Id in the hosts file must be a number!");
+            } else {
+                System.err.println("Port in the hosts file must be a number!");
+            }
+            return false;
+        } catch (UnknownHostException e) {
+            e.printStackTrace();
+        }
+
+        this.addr = new InetSocketAddress(ip, port);
+
+        return true;
+    }
+
+    public int getId() {
+        return id;
+    }
+
+    public String getIp() {
+        return ip;
+    }
+
+    public int getPort() {
+        return port;
+    }
+
+    public SocketAddress getAddr() {
+        return addr;
+    }
+
+}

257844/src/main/java/cs451/parser/HostsParser.java

@@ -0,0 +1,87 @@
+package cs451.parser;
+
+import java.io.BufferedReader;
+import java.io.FileReader;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Comparator;
+import java.util.List;
+
+public class HostsParser {
+
+    private static final String HOSTS_KEY = "--hosts";
+    private static final String SPACES_REGEX = "\\s+";
+
+    private String filename;
+    private final List<Host> hosts = new ArrayList<>();
+
+    public boolean populate(String key, String filename) {
+        if (!key.equals(HOSTS_KEY)) {
+            return false;
+        }
+
+        this.filename = filename;
+        try (BufferedReader br = new BufferedReader(new FileReader(filename))) {
+            int lineNum = 1;
+            for (String line; (line = br.readLine()) != null; lineNum++) {
+                if (line.isBlank()) {
+                    continue;
+                }
+
+                String[] splits = line.split(SPACES_REGEX);
+                if (splits.length != 3) {
+                    System.err.println("Problem with the line " + lineNum + " in the hosts file!");
+                    return false;
+                }
+
+                Host newHost = new Host();
+                if (!newHost.populate(splits[0], splits[1], splits[2])) {
+                    return false;
+                }
+
+                hosts.add(newHost);
+            }
+        } catch (IOException e) {
+            System.err.println("Problem with the hosts file!");
+            return false;
+        }
+
+        if (!checkIdRange()) {
+            System.err.println("Hosts ids are not within the range!");
+            return false;
+        }
+
+        // sort by id
+        hosts.sort(new HostsComparator());
+        return true;
+    }
+
+    private boolean checkIdRange() {
+        int num = hosts.size();
+        for (Host host : hosts) {
+            if (host.getId() < 1 || host.getId() > num) {
+                System.err.println("Id of a host is not in the right range!");
+                return false;
+            }
+        }
+
+        return true;
+    }
+
+    public boolean inRange(int id) {
+        return id <= hosts.size();
+    }
+
+    public List<Host> getHosts() {
+        return hosts;
+    }
+
+    static class HostsComparator implements Comparator<Host> {
+
+        public int compare(Host a, Host b) {
+            return a.getId() - b.getId();
+        }
+
+    }
+
+}

257844/src/main/java/cs451/parser/IdParser.java

@@ -0,0 +1,31 @@
+package cs451.parser;
+
+public class IdParser {
+
+    private static final String ID_KEY = "--id";
+
+    private int id;
+
+    public boolean populate(String key, String value) {
+        if (!key.equals(ID_KEY)) {
+            return false;
+        }
+
+        try {
+            id = Integer.parseInt(value);
+            if (id <= 0) {
+                System.err.println("Id must be a positive number!");
+            }
+        } catch (NumberFormatException e) {
+            System.err.println("Id must be a number!");
+            return false;
+        }
+
+        return true;
+    }
+
+    public int getId() {
+        return id;
+    }
+
+}

257844/src/main/java/cs451/parser/OutputParser.java

@@ -0,0 +1,25 @@
+package cs451.parser;
+
+import java.io.File;
+
+public class OutputParser {
+
+    private static final String OUTPUT_KEY = "--output";
+
+    private String path;
+
+    public boolean populate(String key, String value) {
+        if (!key.equals(OUTPUT_KEY)) {
+            return false;
+        }
+
+        File file = new File(value);
+        path = file.getPath();
+        return true;
+    }
+
+    public String getPath() {
+        return path;
+    }
+
+}

257844/src/main/java/cs451/parser/Parser.java

@@ -0,0 +1,111 @@
+package cs451.parser;
+
+import java.util.List;
+
+public class Parser {
+
+    private final String[] args;
+    private long pid;
+    private IdParser idParser;
+    private HostsParser hostsParser;
+    private BarrierParser barrierParser;
+    private SignalParser signalParser;
+    private OutputParser outputParser;
+    private ConfigParser configParser;
+
+    public Parser(String[] args) {
+        this.args = args;
+    }
+
+    public void parse() {
+        pid = ProcessHandle.current().pid();
+
+        idParser = new IdParser();
+        hostsParser = new HostsParser();
+        barrierParser = new BarrierParser();
+        signalParser = new SignalParser();
+        outputParser = new OutputParser();
+        configParser = null;
+
+        int argsNum = args.length;
+        if (argsNum != Constants.ARG_LIMIT_NO_CONFIG && argsNum != Constants.ARG_LIMIT_CONFIG) {
+            help();
+        }
+
+        if (!idParser.populate(args[Constants.ID_KEY], args[Constants.ID_VALUE])) {
+            help();
+        }
+
+        if (!hostsParser.populate(args[Constants.HOSTS_KEY], args[Constants.HOSTS_VALUE])) {
+            help();
+        }
+
+        if (!hostsParser.inRange(idParser.getId())) {
+            help();
+        }
+
+        if (!barrierParser.populate(args[Constants.BARRIER_KEY], args[Constants.BARRIER_VALUE])) {
+            help();
+        }
+
+        if (!signalParser.populate(args[Constants.SIGNAL_KEY], args[Constants.SIGNAL_VALUE])) {
+            help();
+        }
+
+        if (!outputParser.populate(args[Constants.OUTPUT_KEY], args[Constants.OUTPUT_VALUE])) {
+            help();
+        }
+
+        if (argsNum == Constants.ARG_LIMIT_CONFIG) {
+            configParser = new ConfigParser();
+            if (!configParser.populate(args[Constants.CONFIG_VALUE])) {
+            }
+        }
+    }
+
+    private void help() {
+        System.err.println("Usage: ./run.sh --id ID --hosts HOSTS --barrier NAME:PORT --signal NAME:PORT --output OUTPUT [config]");
+        System.exit(1);
+    }
+
+    public int myId() {
+        return idParser.getId();
+    }
+
+    public List<Host> hosts() {
+        return hostsParser.getHosts();
+    }
+
+    public String barrierIp() {
+        return barrierParser.getIp();
+    }
+
+    public int barrierPort() {
+        return barrierParser.getPort();
+    }
+
+    public String signalIp() {
+        return signalParser.getIp();
+    }
+
+    public int signalPort() {
+        return signalParser.getPort();
+    }
+
+    public String output() {
+        return outputParser.getPath();
+    }
+
+    public boolean hasConfig() {
+        return configParser != null;
+    }
+
+    public String config() {
+        return configParser.getPath();
+    }
+
+    public int messageCount(){
+        return configParser.getMessages();
+    }
+
+}

257844/src/main/java/cs451/parser/SignalParser.java

@@ -0,0 +1,54 @@
+package cs451.parser;
+
+import java.net.InetAddress;
+import java.net.UnknownHostException;
+
+public class SignalParser {
+
+    private static final String SIGNAL_KEY = "--signal";
+
+    private static final int SIGNAL_ARGS_NUM = 2;
+    private static final String COLON_REGEX = ":";
+    private static final String IP_START_REGEX = "/";
+
+    private static String ip;
+    private static int port;
+
+    public boolean populate(String key, String value) {
+        if (!key.equals(SIGNAL_KEY)) {
+            return false;
+        }
+
+        String[] signal = value.split(COLON_REGEX);
+        if (signal.length != SIGNAL_ARGS_NUM) {
+            return false;
+        }
+
+        try {
+            String ipTest = InetAddress.getByName(signal[0]).toString();
+            if (ipTest.startsWith(IP_START_REGEX)) {
+                ip = ipTest.substring(1);
+            } else {
+                ip = InetAddress.getByName(ipTest.split(IP_START_REGEX)[0]).getHostAddress();
+            }
+
+            port = Integer.parseInt(signal[1]);
+            if (port <= 0) {
+                System.err.println("Signal port must be a positive number!");
+                return false;
+            }
+        } catch (UnknownHostException e) {
+            e.printStackTrace();
+        }
+
+        return true;
+    }
+
+    public String getIp() {
+        return ip;
+    }
+
+    public int getPort() {
+        return port;
+    }
+}