frontend

6 files changed, 831 insertions, 0 deletions

diff --git a/src/main/java/derms/frontend/DERMSInterface.java b/src/main/java/derms/frontend/DERMSInterface.java
new file mode 100644
index 0000000..9c7eb04
--- /dev/null
+++ b/src/main/java/derms/frontend/DERMSInterface.java
@@ -0,0 +1,19 @@
+package derms.frontend;
+
+import javax.jws.WebService;
+import javax.jws.soap.SOAPBinding;
+import javax.jws.soap.SOAPBinding.Style;
+
+@WebService
+@SOAPBinding(style = Style.RPC)
+public interface DERMSInterface {
+    String addResource(String resourceID, String resourceName, int duration);
+    String removeResource(String resourceID, int duration);
+    String listResourceAvailability(String resourceName);
+
+    // Coordinator methods
+    String requestResource(String coordinatorID, String resourceID, int duration);
+    String findResource(String coordinatorID, String resourceName);
+    String returnResource(String coordinatorID, String resourceID);
+    String swapResource(String coordinatorID, String oldResourceID, String oldResourceType, String newResourceID, String newResourceType);
+}
diff --git a/src/main/java/derms/frontend/DERMSServerImpl.java b/src/main/java/derms/frontend/DERMSServerImpl.java
new file mode 100644
index 0000000..c65fea9
--- /dev/null
+++ b/src/main/java/derms/frontend/DERMSServerImpl.java
@@ -0,0 +1,347 @@
+// DERMSImpl.java
+package derms.frontend;
+
+//import logger.Logger;
+//import model.Resource;
+import java.util.*;
+import java.util.stream.Collectors;
+import java.util.Optional;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.TimeUnit;
+
+import javax.jws.WebMethod;
+import javax.jws.WebService;
+import javax.jws.soap.SOAPBinding;
+import javax.jws.soap.SOAPBinding.Style;
+
+//import constants.Constants;
+//import constants.PortConstants;
+//import validation.ValidationService;
+//import interfaces.DERMSInterface;
+
+@WebService(endpointInterface = "frontend.DERMSInterface")
+@SOAPBinding(style = Style.RPC)
+public class DERMSServerImpl implements DERMSInterface {
+	
+    private static long DYNAMIC_TIMEOUT = 10000;
+    private static int Rm1BugCount = 0;
+    private static int Rm2BugCount = 0;
+    private static int Rm3BugCount = 0;
+    private static int Rm4BugCount = 0;
+    private static int Rm1NoResponseCount = 0;
+    private static int Rm2NoResponseCount = 0;
+    private static int Rm3NoResponseCount = 0;
+    private static int Rm4NoResponseCount = 0;
+    private long responseTime = DYNAMIC_TIMEOUT;
+    private long startTime;
+    private CountDownLatch latch;
+    private final FEInterface inter;
+    private final List<RmResponse> responses = new ArrayList<>();
+    
+    public DERMSServerImpl(FEInterface inter) {
+        super();
+        this.inter = inter;
+    }
+    
+	@WebMethod
+    public synchronized String addResource(String resourceID, String resourceName, int duration) {
+        MyRequest myRequest = new MyRequest("addResource", "");
+        myRequest.setResourceID(resourceID);
+        myRequest.setResourceType(resourceName);
+        myRequest.setDuration(duration);
+        myRequest.setSequenceNumber(sendUdpUnicastToSequencer(myRequest));
+        System.out.println("FE Implementation:addEvent>>>" + myRequest.toString());
+        return validateResponses(myRequest);
+    }
+
+	@WebMethod
+    public synchronized String removeResource(String resourceID, int duration) {
+        MyRequest myRequest = new MyRequest("removeResource", "");
+        myRequest.setResourceID(resourceID);
+        myRequest.setDuration(duration);
+        myRequest.setSequenceNumber(sendUdpUnicastToSequencer(myRequest));
+        System.out.println("FE Implementation:removeEvent>>>" + myRequest.toString());
+        return validateResponses(myRequest);
+    }
+
+	@WebMethod
+    public synchronized String listResourceAvailability(String resourceName) {
+        MyRequest myRequest = new MyRequest("listEventAvailability", "");
+        myRequest.setResourceType(resourceName);
+        myRequest.setSequenceNumber(sendUdpUnicastToSequencer(myRequest));
+        System.out.println("FE Implementation:listEventAvailability>>>" + myRequest.toString());
+        return validateResponses(myRequest);
+    }
+
+	@WebMethod
+    public synchronized String requestResource(String coordinatorID, String resourceID, int duration) {
+        MyRequest myRequest = new MyRequest("requestResource", coordinatorID);
+        myRequest.setResourceID(resourceID);
+        myRequest.setDuration(duration);
+        myRequest.setSequenceNumber(sendUdpUnicastToSequencer(myRequest));
+        System.out.println("FE Implementation:bookEvent>>>" + myRequest.toString());
+        return validateResponses(myRequest);
+    }
+	
+	@WebMethod
+    public synchronized String findResource(String coordinatorID, String resourceName) {
+        MyRequest myRequest = new MyRequest("findResource", coordinatorID);
+        myRequest.setResourceType(resourceName);
+        myRequest.setSequenceNumber(sendUdpUnicastToSequencer(myRequest));
+        System.out.println("FE Implementation:bookEvent>>>" + myRequest.toString());
+        return validateResponses(myRequest);
+    }
+	
+	@WebMethod
+    public synchronized String returnResource(String coordinatorID, String resourceID) {
+        MyRequest myRequest = new MyRequest("findResource", coordinatorID);
+        myRequest.setResourceID(resourceID);
+        myRequest.setSequenceNumber(sendUdpUnicastToSequencer(myRequest));
+        System.out.println("FE Implementation:bookEvent>>>" + myRequest.toString());
+        return validateResponses(myRequest);
+    }
+
+	@WebMethod
+    public synchronized String swapResource(String coordinatorID, String oldResourceID, String oldResourceType, String newResourceID, String newResourceType) {
+        MyRequest myRequest = new MyRequest("swapResource", coordinatorID);
+        myRequest.setResourceID(newResourceID);
+        myRequest.setResourceType(newResourceType);
+        myRequest.setOldResourceID(oldResourceID);
+        myRequest.setOldResourceType(oldResourceType);
+        myRequest.setSequenceNumber(sendUdpUnicastToSequencer(myRequest));
+        System.out.println("FE Implementation:swapEvent>>>" + myRequest.toString());
+        return validateResponses(myRequest);
+    }
+	
+    public void waitForResponse() {
+        try {
+            System.out.println("FE Implementation:waitForResponse>>>ResponsesRemain" + latch.getCount());
+            boolean timeoutReached = latch.await(DYNAMIC_TIMEOUT, TimeUnit.MILLISECONDS);
+            if (timeoutReached) {
+                setDynamicTimout();
+            }
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+//            inter.sendRequestToSequencer(myRequest);
+        }
+//         check result and react correspondingly
+    }
+	
+   private String validateResponses(MyRequest myRequest) {
+        String resp;
+        switch ((int) latch.getCount()) {
+            case 0:
+            case 1:
+            case 2:
+            case 3:
+                resp = findMajorityResponse(myRequest);
+                break;
+            case 4:
+                resp = "Fail: No response from any server";
+                System.out.println(resp);
+                if (myRequest.haveRetries()) {
+                    myRequest.countRetry();
+                    resp = retryRequest(myRequest);
+                }
+                rmDown(1);
+                rmDown(2);
+                rmDown(3);
+                rmDown(4);
+                break;
+            default:
+                resp = "Fail: " + myRequest.noRequestSendError();
+                break;
+        }
+        System.out.println("FE Implementation:validateResponses>>>Responses remain:" + latch.getCount() + " >>>Response to be sent to client " + resp);
+        return resp;
+    }
+   
+   private String findMajorityResponse(MyRequest myRequest) {
+       RmResponse res1 = null;
+       RmResponse res2 = null;
+       RmResponse res3 = null;
+       RmResponse res4 = null;
+       for (RmResponse response :responses) {
+           if (response.getSequenceID() == myRequest.getSequenceNumber()) {
+               switch (response.getRmNumber()) {
+                   case 1:
+                       res1 = response;
+                       break;
+                   case 2:
+                       res2 = response;
+                       break;
+                   case 3:
+                       res3 = response;
+                       break;
+                   case 4:
+                       res4 = response;
+                       break;
+               }
+           }
+       }
+       System.out.println("FE Implementation:findMajorityResponse>>>RM1" + ((res1 != null) ? res1.getResponse() : "null"));
+       System.out.println("FE Implementation:findMajorityResponse>>>RM2" + ((res2 != null) ? res2.getResponse() : "null"));
+       System.out.println("FE Implementation:findMajorityResponse>>>RM3" + ((res3 != null) ? res3.getResponse() : "null"));
+       System.out.println("FE Implementation:findMajorityResponse>>>RM4" + ((res4 != null) ? res4.getResponse() : "null"));
+
+    // Handling null responses and marking RMs down
+       if (res1 == null) rmDown(1);
+       if (res2 == null) rmDown(2);
+       if (res3 == null) rmDown(3);
+       if (res4 == null) rmDown(4);
+
+       // Majority voting logic
+       List<RmResponse> validResponses = Arrays.asList(res1, res2, res3, res4).stream()
+                                              .filter(Objects::nonNull)
+                                              .collect(Collectors.toList());
+
+       Map<String, Long> responseCounts = validResponses.stream()
+               .collect(Collectors.groupingBy(RmResponse::getResponse, Collectors.counting()));
+
+       // Find the response with the highest count
+       Optional<Map.Entry<String, Long>> majorityEntry = responseCounts.entrySet().stream()
+               .filter(entry -> entry.getValue() >= 3) // At least 3 matching responses for majority
+               .findFirst();
+
+       if (majorityEntry.isPresent()) {
+           String majorityResponse = majorityEntry.get().getKey();
+           System.out.println("Majority response found: " + majorityResponse);
+           return majorityResponse;
+       }
+
+       // Handle bugs or discrepancies
+       responseCounts.forEach((response, count) -> {
+           if (count == 1) {
+               validResponses.stream()
+                       .filter(r -> r.getResponse().equals(response))
+                       .forEach(r -> rmBugFound(r.getRmNumber()));
+           }
+       });
+
+       return "Fail: majority response not found";
+   }
+   
+   private void rmBugFound(int rmNumber) {
+       switch (rmNumber) {
+           case 1:
+               Rm1BugCount++;
+               if (Rm1BugCount == 3) {
+                   Rm1BugCount = 0;
+                   inter.informRmHasBug(rmNumber);
+               }
+               break;
+           case 2:
+               Rm2BugCount++;
+               if (Rm2BugCount == 3) {
+                   Rm2BugCount = 0;
+                   inter.informRmHasBug(rmNumber);
+               }
+               break;
+
+           case 3:
+               Rm3BugCount++;
+               if (Rm3BugCount == 3) {
+                   Rm3BugCount = 0;
+                   inter.informRmHasBug(rmNumber);
+               }
+               break;
+           case 4:
+               Rm4BugCount++;
+               if (Rm4BugCount == 3) {
+                   Rm4BugCount = 0;
+                   inter.informRmHasBug(rmNumber);
+               }
+               break;
+       }
+       System.out.println("FE Implementation:rmBugFound>>>RM1 - bugs:" + Rm1BugCount);
+       System.out.println("FE Implementation:rmBugFound>>>RM2 - bugs:" + Rm2BugCount);
+       System.out.println("FE Implementation:rmBugFound>>>RM3 - bugs:" + Rm3BugCount);
+       System.out.println("FE Implementation:rmBugFound>>>RM4 - bugs:" + Rm4BugCount);
+   }
+   
+   private void rmDown(int rmNumber) {
+       DYNAMIC_TIMEOUT = 10000;
+       switch (rmNumber) {
+           case 1:
+               Rm1NoResponseCount++;
+               if (Rm1NoResponseCount == 3) {
+                   Rm1NoResponseCount = 0;
+                   inter.informRmIsDown(rmNumber);
+               }
+               break;
+           case 2:
+               Rm2NoResponseCount++;
+               if (Rm2NoResponseCount == 3) {
+                   Rm2NoResponseCount = 0;
+                   inter.informRmIsDown(rmNumber);
+               }
+               break;
+
+           case 3:
+               Rm3NoResponseCount++;
+               if (Rm3NoResponseCount == 3) {
+                   Rm3NoResponseCount = 0;
+                   inter.informRmIsDown(rmNumber);
+               }
+               break;
+           case 4:
+               Rm4NoResponseCount++;
+               if (Rm4NoResponseCount == 3) {
+                   Rm4NoResponseCount = 0;
+                   inter.informRmIsDown(rmNumber);
+               }
+               break;
+       }
+       System.out.println("FE Implementation:rmDown>>>RM1 - noResponse:" + Rm1NoResponseCount);
+       System.out.println("FE Implementation:rmDown>>>RM2 - noResponse:" + Rm2NoResponseCount);
+       System.out.println("FE Implementation:rmDown>>>RM3 - noResponse:" + Rm3NoResponseCount);
+       System.out.println("FE Implementation:rmDown>>>RM4 - noResponse:" + Rm3NoResponseCount);
+   }
+   
+   private void setDynamicTimout() {
+       if (responseTime < 4000) {
+           DYNAMIC_TIMEOUT = (DYNAMIC_TIMEOUT + (responseTime * 3)) / 2;
+//           System.out.println("FE Implementation:setDynamicTimout>>>" + responseTime * 2);
+       } else {
+           DYNAMIC_TIMEOUT = 10000;
+       }
+       System.out.println("FE Implementation:setDynamicTimout>>>" + DYNAMIC_TIMEOUT);
+   }
+
+   private void notifyOKCommandReceived() {
+       latch.countDown();
+       System.out.println("FE Implementation:notifyOKCommandReceived>>>Response Received: Remaining responses" + latch.getCount());
+   }
+
+   public void addReceivedResponse(RmResponse res) {
+       long endTime = System.nanoTime();
+       responseTime = (endTime - startTime) / 1000000;
+       System.out.println("Current Response time is: " + responseTime);
+       responses.add(res);
+       notifyOKCommandReceived();
+   }
+
+   private int sendUdpUnicastToSequencer(MyRequest myRequest) {
+       startTime = System.nanoTime();
+       int sequenceNumber = inter.sendRequestToSequencer(myRequest);
+       myRequest.setSequenceNumber(sequenceNumber);
+       latch = new CountDownLatch(4);
+       waitForResponse();
+       return sequenceNumber;
+   }
+
+   private String retryRequest(MyRequest myRequest) {
+       System.out.println("FE Implementation:retryRequest>>>" + myRequest.toString());
+       startTime = System.nanoTime();
+       inter.retryRequest(myRequest);
+       latch = new CountDownLatch(4);
+       waitForResponse();
+       return validateResponses(myRequest);
+   }
+
+	
+}
+
diff --git a/src/main/java/derms/frontend/FE.java b/src/main/java/derms/frontend/FE.java
new file mode 100644
index 0000000..e49dd61
--- /dev/null
+++ b/src/main/java/derms/frontend/FE.java
@@ -0,0 +1,176 @@
+package derms.frontend;
+
+import java.io.IOException;
+import java.net.DatagramPacket;
+import java.net.DatagramSocket;
+import java.net.InetAddress;
+import java.net.SocketException;
+
+import javax.xml.ws.Endpoint;
+
+//import constants.Constants;
+
+public class FE {
+    private static final int sequencerPort = 1333;
+    private static final String sequencerIP = "192.168.2.17";
+//        private static final String sequencerIP = "localhost";
+    private static final String RM_Multicast_group_address = "230.1.1.10";
+    private static final int FE_SQ_PORT = 1414;
+    private static final int FE_PORT = 1999;
+    private static final int RM_Multicast_Port = 1234;
+    public static String FE_Address = "http://localhost:8067/service/FE";
+    private static final String FE_IP_Address = "";
+    
+    
+//    public static String FE_IP_Address = "localhost";
+
+    public static void main(String[] args) {
+        try {
+            FEInterface inter = new FEInterface() {
+                @Override
+                public void informRmHasBug(int RmNumber) {
+//                    String errorMessage = new MyRequest(RmNumber, "1").toString();
+                    MyRequest errorMessage = new MyRequest(RmNumber, "1");
+                    System.out.println("Rm:" + RmNumber + "has bug");
+//                    sendMulticastFaultMessageToRms(errorMessage);
+                    sendUnicastToSequencer(errorMessage);
+                }
+
+                @Override
+                public void informRmIsDown(int RmNumber) {
+//                    String errorMessage = new MyRequest(RmNumber, "2").toString();
+                    MyRequest errorMessage = new MyRequest(RmNumber, "2");
+                    System.out.println("Rm:" + RmNumber + "is down");
+//                    sendMulticastFaultMessageToRms(errorMessage);
+                    sendUnicastToSequencer(errorMessage);
+                }
+
+                @Override
+                public int sendRequestToSequencer(MyRequest myRequest) {
+                    return sendUnicastToSequencer(myRequest);
+                }
+
+                @Override
+                public void retryRequest(MyRequest myRequest) {
+                    System.out.println("No response from all Rms, Retrying request...");
+                    sendUnicastToSequencer(myRequest);
+                }
+            };
+            DERMSServerImpl servant = new DERMSServerImpl(inter);
+            Endpoint endpoint = Endpoint.publish(FE_Address, servant);
+            Runnable task = () -> {
+                listenForUDPResponses(servant);
+            };
+            Thread thread = new Thread(task);
+            thread.start();
+
+        } catch (Exception e) {
+//            System.err.println("Exception: " + e);
+            e.printStackTrace(System.out);
+//            Logger.serverLog(serverID, "Exception: " + e);
+        }
+
+//        System.out.println("FrontEnd Server Shutting down");
+//        Logger.serverLog(serverID, " Server Shutting down");
+
+    }
+
+    private static int sendUnicastToSequencer(MyRequest requestFromClient) {
+        DatagramSocket aSocket = null;
+        String dataFromClient = requestFromClient.toString();
+        System.out.println("FE:sendUnicastToSequencer>>>" + dataFromClient);
+        int sequenceID = 0;
+        try {
+            aSocket = new DatagramSocket(FE_SQ_PORT);
+            byte[] message = dataFromClient.getBytes();
+            InetAddress aHost = InetAddress.getByName(sequencerIP);
+            DatagramPacket requestToSequencer = new DatagramPacket(message, dataFromClient.length(), aHost, sequencerPort);
+
+            aSocket.send(requestToSequencer);
+
+            aSocket.setSoTimeout(1000);
+            // Set up an UPD packet for recieving
+            byte[] buffer = new byte[1000];
+            DatagramPacket response = new DatagramPacket(buffer, buffer.length);
+            // Try to receive the response from the ping
+            aSocket.receive(response);
+            String sentence = new String(response.getData(), 0,
+                    response.getLength());
+            System.out.println("FE:sendUnicastToSequencer/ResponseFromSequencer>>>" + sentence);
+            sequenceID = Integer.parseInt(sentence.trim());
+            System.out.println("FE:sendUnicastToSequencer/ResponseFromSequencer>>>SequenceID:" + sequenceID);
+        } catch (SocketException e) {
+            System.out.println("Failed: " + requestFromClient.noRequestSendError());
+            System.out.println("Socket: " + e.getMessage());
+        } catch (IOException e) {
+            System.out.println("Failed: " + requestFromClient.noRequestSendError());
+            e.printStackTrace();
+            System.out.println("IO: " + e.getMessage());
+        } finally {
+            if (aSocket != null)
+                aSocket.close();
+        }
+        return sequenceID;
+    }
+
+    public static void sendMulticastFaultMessageToRms(String errorMessage) {
+        DatagramSocket aSocket = null;
+        try {
+            aSocket = new DatagramSocket();
+            byte[] messages = errorMessage.getBytes();
+            InetAddress aHost = InetAddress.getByName(RM_Multicast_group_address);
+
+            DatagramPacket request = new DatagramPacket(messages, messages.length, aHost, RM_Multicast_Port);
+            System.out.println("FE:sendMulticastFaultMessageToRms>>>" + errorMessage);
+            aSocket.send(request);
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+
+    }
+
+    private static void listenForUDPResponses(DERMSServerImpl servant) {
+        DatagramSocket aSocket = null;
+        try {
+
+//            aSocket = new MulticastSocket(1413);
+//            InetAddress[] allAddresses = Inet4Address.getAllByName("SepJ-ROG");
+            InetAddress desiredAddress = InetAddress.getByName(FE_IP_Address);
+//            //In order to find the desired Ip to be routed by other modules (WiFi adapter)
+//            for (InetAddress address :
+//                    allAddresses) {
+//                if (address.getHostAddress().startsWith("192.168.2")) {
+//                    desiredAddress = address;
+//                }
+//            }
+//            aSocket.joinGroup(InetAddress.getByName("230.1.1.5"));
+            aSocket = new DatagramSocket(FE_PORT, desiredAddress);
+            byte[] buffer = new byte[1000];
+            System.out.println("FE Server Started on " + desiredAddress + ":" + FE_PORT + "............");
+
+            while (true) {
+                DatagramPacket response = new DatagramPacket(buffer, buffer.length);
+                aSocket.receive(response);
+                String sentence = new String(response.getData(), 0,
+                        response.getLength()).trim();
+                System.out.println("FE:Response received from Rm>>>" + sentence);
+                RmResponse rmResponse = new RmResponse(sentence);
+//                String[] parts = sentence.split(";");
+
+                System.out.println("Adding response to FrontEndImplementation:");
+                servant.addReceivedResponse(rmResponse);
+//                DatagramPacket reply = new DatagramPacket(response.getData(), response.getLength(), response.getAddress(),
+//                        response.getPort());
+//                aSocket.send(reply);
+            }
+
+        } catch (SocketException e) {
+            System.out.println("Socket: " + e.getMessage());
+        } catch (IOException e) {
+            System.out.println("IO: " + e.getMessage());
+        } finally {
+//            if (aSocket != null)
+//                aSocket.close();
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/main/java/derms/frontend/FEInterface.java b/src/main/java/derms/frontend/FEInterface.java
new file mode 100644
index 0000000..5a4e6f1
--- /dev/null
+++ b/src/main/java/derms/frontend/FEInterface.java
@@ -0,0 +1,11 @@
+package derms.frontend;
+
+public interface FEInterface {
+    void informRmHasBug(int RmNumber);
+
+    void informRmIsDown(int RmNumber);
+
+    int sendRequestToSequencer(MyRequest myRequest);
+
+    void retryRequest(MyRequest myRequest);
+}
\ No newline at end of file
diff --git a/src/main/java/derms/frontend/MyRequest.java b/src/main/java/derms/frontend/MyRequest.java
new file mode 100644
index 0000000..b0f2758
--- /dev/null
+++ b/src/main/java/derms/frontend/MyRequest.java
@@ -0,0 +1,131 @@
+package derms.frontend;
+
+public class MyRequest {
+	   private String function = "";
+	    private String clientID = "";
+	    private String resourceType = "";
+	    private String OldResourceType = "";
+	    private String resourceID = "";
+	    private String OldResourceID = "";
+	    private String FeIpAddress = "FE.FE_IP_Address";
+	    private int duration = 0;
+	    private int sequenceNumber = 0;
+	    private String MessageType = "00";
+	    private int retryCount = 1;
+
+	    public MyRequest(String function, String clientID) {
+	        setFunction(function);
+	        setClientID(clientID);
+	    }
+
+	    public MyRequest(int rmNumber, String bugType) {
+	        setMessageType(bugType + rmNumber);
+	    }
+
+	    public String getFunction() {
+	        return function;
+	    }
+
+	    public void setFunction(String function) {
+	        this.function = function;
+	    }
+
+	    public String getClientID() {
+	        return clientID;
+	    }
+
+	    public void setClientID(String clientID) {
+	        this.clientID = clientID;
+	    }
+
+	    public String getResourceType() {
+	        return resourceType;
+	    }
+
+	    public void setResourceType(String resourceType) {
+	        this.resourceType = resourceType;
+	    }
+
+	    public String getOldResourceType() {
+	        return OldResourceType;
+	    }
+
+	    public void setOldResourceType(String OldResourceType) {
+	        this.OldResourceType = OldResourceType;
+	    }
+
+	    public String getResourceID() {
+	        return resourceID;
+	    }
+
+	    public void setResourceID(String resourceID) {
+	        this.resourceID = resourceID;
+	    }
+
+	    public String getOldResourceID() {
+	        return OldResourceID;
+	    }
+
+	    public void setOldResourceID(String OldResourceID) {
+	        this.OldResourceID = OldResourceID;
+	    }
+
+	    public int getDuration() {
+	        return duration;
+	    }
+
+	    public void setDuration(int duration) {
+	        this.duration = duration;
+	    }
+
+	    public String noRequestSendError() {
+	        return "request: " + getFunction() + " from " + getClientID() + " not sent";
+	    }
+
+	    public int getSequenceNumber() {
+	        return sequenceNumber;
+	    }
+
+	    public void setSequenceNumber(int sequenceNumber) {
+	        this.sequenceNumber = sequenceNumber;
+	    }
+
+	    public String getFeIpAddress() {
+	        return FeIpAddress;
+	    }
+
+	    public void setFeIpAddress(String feIpAddress) {
+	        FeIpAddress = feIpAddress;
+	    }
+
+	    public String getMessageType() {
+	        return MessageType;
+	    }
+
+	    public void setMessageType(String messageType) {
+	        MessageType = messageType;
+	    }
+
+	    public boolean haveRetries() {
+	        return retryCount > 0;
+	    }
+
+	    public void countRetry() {
+	        retryCount--;
+	    }
+
+	    //Message Format: Sequence_id;FrontIpAddress;Message_Type;function(addResource,...);userID; newEventID;newEventType; oldEventID; oldEventType;bookingCapacity
+	    @Override
+	    public String toString() {
+	        return getSequenceNumber() + ";" +
+	                getFeIpAddress().toUpperCase() + ";" +
+	                getMessageType().toUpperCase() + ";" +
+	                getFunction().toUpperCase() + ";" +
+	                getClientID().toUpperCase() + ";" +
+	                getResourceID().toUpperCase() + ";" +
+	                getResourceType().toUpperCase() + ";" +
+	                getOldResourceID().toUpperCase() + ";" +
+	                getOldResourceType().toUpperCase() + ";" +
+	                getDuration();
+	    }
+}
diff --git a/src/main/java/derms/frontend/RmResponse.java b/src/main/java/derms/frontend/RmResponse.java
new file mode 100644
index 0000000..f693375
--- /dev/null
+++ b/src/main/java/derms/frontend/RmResponse.java
@@ -0,0 +1,147 @@
+package derms.frontend;
+
+public class RmResponse {
+    private int sequenceID = 0;
+    private String response = "";
+    private int rmNumber = 0;
+    private String function = "";
+    private String userID = "";
+    private String newResourceID = "";
+    private String newResourceType = "";
+    private String oldResourceID = "";
+    private String oldResourceType = "";
+    private int duration = 0;
+    private String udpMessage = "";
+    private boolean isSuccess = false;
+
+    public RmResponse(String udpMessage) {
+        setUdpMessage(udpMessage.trim());
+        String[] messageParts = getUdpMessage().split(";");
+        setSequenceID(Integer.parseInt(messageParts[0]));
+        setResponse(messageParts[1].trim());
+        setRmNumber(messageParts[2]);
+        setFunction(messageParts[3]);
+        setUserID(messageParts[4]);
+        setNewResourceID(messageParts[5]);
+        setNewResourceType(messageParts[6]);
+        setOldResourceID(messageParts[7]);
+        setOldResourceType(messageParts[8]);
+        setDuration(Integer.parseInt(messageParts[9]));
+    }
+
+    public int getSequenceID() {
+        return sequenceID;
+    }
+
+    public void setSequenceID(int sequenceID) {
+        this.sequenceID = sequenceID;
+    }
+
+    public String getResponse() {
+        return response;
+    }
+
+    public void setResponse(String response) {
+        isSuccess = response.contains("Success:");
+        this.response = response;
+    }
+
+    public int getRmNumber() {
+        return rmNumber;
+    }
+
+    public void setRmNumber(String rmNumber) {
+        if (rmNumber.equalsIgnoreCase("RM1")) {
+            this.rmNumber = 1;
+        } else if (rmNumber.equalsIgnoreCase("RM2")) {
+            this.rmNumber = 2;
+        } else if (rmNumber.equalsIgnoreCase("RM3")) {
+            this.rmNumber = 3;
+        } else {
+            this.rmNumber = 0;
+        }
+    }
+
+    public String getFunction() {
+        return function;
+    }
+
+    public void setFunction(String function) {
+        this.function = function;
+    }
+
+    public String getUserID() {
+        return userID;
+    }
+
+    public void setUserID(String userID) {
+        this.userID = userID;
+    }
+
+    public String getNewResourceID() {
+        return newResourceID;
+    }
+
+    public void setNewResourceID(String newEventID) {
+        this.newResourceID = newEventID;
+    }
+
+    public String getNewResourceType() {
+        return newResourceType;
+    }
+
+    public void setNewResourceType(String newEventType) {
+        this.newResourceType = newEventType;
+    }
+
+    public String getOldResourceID() {
+        return oldResourceID;
+    }
+
+    public void setOldResourceID(String oldEventID) {
+        this.oldResourceID = oldEventID;
+    }
+
+    public String getOldResourceType() {
+        return oldResourceType;
+    }
+
+    public void setOldResourceType(String oldEventType) {
+        this.oldResourceType = oldEventType;
+    }
+
+    public int getDuration() {
+        return duration;
+    }
+
+    public void setDuration(int bookingCapacity) {
+        this.duration = bookingCapacity;
+    }
+
+    public String getUdpMessage() {
+        return udpMessage;
+    }
+
+    public void setUdpMessage(String udpMessage) {
+        this.udpMessage = udpMessage;
+    }
+
+    public boolean isSuccess() {
+        return isSuccess;
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (obj != null) {
+            if (obj instanceof RmResponse) {
+                RmResponse obj1 = (RmResponse) obj;
+                return obj1.getFunction().equalsIgnoreCase(this.getFunction())
+                        && obj1.getSequenceID() == this.getSequenceID()
+                        && obj1.getUserID().equalsIgnoreCase(this.getUserID())
+                        && obj1.isSuccess() == this.isSuccess();
+//                        && obj1.getResponse().equalsIgnoreCase(this.getResponse());
+            }
+        }
+        return false;
+    }
+}