v2 baseline

Author: NF-coder

programming/sem2/lab5_v2/src/main/java/client/core/ClientCycle.java

@@ -9,7 +9,7 @@
 
 public class ClientCycle implements Runnable{
     public void run(){
-        UDPDriver driver = new UDPDriver(4056);
+        UDPDriver driver = new UDPDriver(4059,4056);
         NetworkManager networkManager = new NetworkManager(driver);
 
         HashMap<String,String> hamp = new HashMap<>();

programming/sem2/lab5_v2/src/main/java/client/core/Engine.java

@@ -7,7 +7,7 @@
 import client.network.drivers.UDPDriver;
 
 public final class Engine {
-    UDPDriver driver = new UDPDriver(4056);
+    UDPDriver driver = new UDPDriver(4059, 4056);
     NetworkManager networkManager = new NetworkManager(driver);
 
     private static final BasicCommand[] commands = {new Help(), new Add(), new Info(),

programming/sem2/lab5_v2/src/main/java/client/network/NetworkManager.java

@@ -13,7 +13,7 @@ public NetworkManager(INetworkDriver driver) {
             this.driver.init();
         }
         catch (Exception e){
-
+            System.out.println(e.getMessage());
         }
     }
 

programming/sem2/lab5_v2/src/main/java/client/network/drivers/UDPDriver.java

@@ -1,33 +1,40 @@
 package client.network.drivers;
 
 import java.io.IOException;
+import java.lang.annotation.Target;
 import java.net.InetSocketAddress;
 import java.net.SocketAddress;
 import java.net.SocketException;
 import java.nio.ByteBuffer;
 import java.nio.channels.DatagramChannel;
 
 public class UDPDriver implements INetworkDriver {
+    int myPort;
+    int targetPort;
+
     DatagramChannel channel;
-    int port;
-    SocketAddress addr;
+    SocketAddress myAddr;
+    SocketAddress targetAddr;
     private final int PACKET_SIZE = 1024;
     private final int DATA_SIZE = PACKET_SIZE - 1;
 
-    public UDPDriver(int port) {
-        this.port = port;
+    public UDPDriver(int myPort, int targetPort) {
+        this.myPort = myPort;
+        this.targetPort = targetPort;
     }
 
     public void init() throws SocketException, IOException{
-        addr = new InetSocketAddress(port);
+        myAddr = new InetSocketAddress(myPort);
+        targetAddr = new InetSocketAddress(targetPort);
+
         channel = DatagramChannel.open();
-        channel.bind(addr);
-        channel.configureBlocking(false);
+        channel.bind(myAddr);
+        channel.configureBlocking(true);
     }
 
     public void send(byte[] data) throws IOException {
         ByteBuffer buf = ByteBuffer.wrap(data);
-        channel.send(buf, addr);
+        channel.send(buf, targetAddr);
     }
 
     public byte[] receive() throws IOException{
@@ -36,7 +43,7 @@ public byte[] receive() throws IOException{
         System.out.println("receiving...");
         System.out.println(buf);
 
-        addr = channel.receive(buf);
+        SocketAddress addr = channel.receive(buf);
 
         System.out.println("received: " + addr);
 

programming/sem2/lab5_v2/src/main/java/server/core/Engine.java

@@ -1,23 +1,24 @@
 package server.core;
 
-import server.network.NetworkCycle;
-import server.network.serializers.implementations.BinarySerializer;
-import shared.objects.NetworkRequestDTO;
-import server.network.drivers.implementations.UDPDriver;
-import shared.objects.NetworkResponseDTO;
-import server.storage.collection.drivers.implementations.DequeDriver;
-import server.storage.commands.CommandsManager;
-
-import java.util.ArrayDeque;
 import java.util.HashMap;
 import java.util.Queue;
 import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.ConcurrentLinkedQueue;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
 
+import server.network.NetworkContainer;
+import server.network.NetworkCycle;
+import server.network.drivers.implementations.UDPDriver;
+import server.network.serializers.implementations.BinarySerializer;
+import server.storage.collection.drivers.implementations.DequeDriver;
+import server.storage.commands.CommandsManager;
+import shared.objects.NetworkRequestDTO;
+import shared.objects.NetworkResponseDTO;
+
 public class Engine {
-    private final Queue<NetworkRequestDTO> networkReceived = new ArrayDeque<>();
-    private final Queue<NetworkResponseDTO> networkToSend = new ArrayDeque<>();
+    private final Queue<NetworkContainer<NetworkRequestDTO>> networkReceived = new ConcurrentLinkedQueue<>();
+    private final Queue<NetworkContainer<NetworkResponseDTO>> networkToSend = new ConcurrentLinkedQueue<>();
 
     private final ExecutorService executor = Executors.newFixedThreadPool(10);
     private final CommandsManager cm = new CommandsManager(
@@ -38,22 +39,26 @@ public Engine(){
 
     public void mainCycle(){
         try{
-            Thread.sleep(1);
+            //Thread.sleep(1);
+            //System.out.println(networkReceived.size());
             if (!networkReceived.isEmpty()){
                 System.out.println("Received from get");
-                NetworkRequestDTO networkRequestDTO = networkReceived.remove();
+                NetworkContainer<NetworkRequestDTO> networkRequestDTO = networkReceived.remove();
                 System.out.println(networkRequestDTO);
 
                 CompletableFuture<HashMap<String,String>> future = cm.run(
-                        networkRequestDTO.opName(),
-                        networkRequestDTO.args(),
+                        networkRequestDTO.data().opName(),
+                        networkRequestDTO.data().args(),
                         this.executor
                 );
                 future.thenApply(
                         res->{
                             System.out.println("fapl: " + res.toString());
                             return networkToSend.add(
-                                    new NetworkResponseDTO(res)
+                                    new NetworkContainer<>(
+                                            networkRequestDTO.socketAddress(),
+                                            new NetworkResponseDTO(res)
+                                    )
                             );
                         }
                 );

programming/sem2/lab5_v2/src/main/java/server/network/NetworkContainer.java

@@ -0,0 +1,5 @@
+package server.network;
+
+import java.net.SocketAddress;
+
+public record NetworkContainer<T> (SocketAddress socketAddress, T data) {}

programming/sem2/lab5_v2/src/main/java/server/network/NetworkCycle.java

@@ -9,14 +9,14 @@
 
 public class NetworkCycle implements Runnable{
     private final NetworkManager nm;
-    public final Queue<NetworkRequestDTO> inpQueue;
-    public final Queue<NetworkResponseDTO> outQueue;
+    public final Queue<NetworkContainer<NetworkRequestDTO>> inpQueue;
+    public final Queue<NetworkContainer<NetworkResponseDTO>> outQueue;
 
     public NetworkCycle(
             INetworkDriver nd,
             INetworkSerializers serializer,
-            Queue<NetworkRequestDTO> inpQueue,
-            Queue<NetworkResponseDTO> outQueue
+            Queue<NetworkContainer<NetworkRequestDTO>> inpQueue,
+            Queue<NetworkContainer<NetworkResponseDTO>> outQueue
     ){
         this.nm = new NetworkManager(
                 nd,

programming/sem2/lab5_v2/src/main/java/server/network/NetworkManager.java

@@ -25,23 +25,31 @@ public NetworkManager(INetworkDriver driver, INetworkSerializers serializer) {
         }
     }
 
-    public void send(Queue<NetworkResponseDTO> outQueue) throws IOException{
-        NetworkResponseDTO r1 = outQueue.poll();
+    public void send(Queue<NetworkContainer<NetworkResponseDTO>> outQueue) throws IOException{
+        NetworkContainer<NetworkResponseDTO> r1 = outQueue.poll();
         if(r1 == null){return;}
         System.out.println(r1);
+
         this.driver.send(
-                this.serializer.serialize(
-                        outQueue.poll()
+                new NetworkContainer<> (
+                        r1.socketAddress(),
+                        this.serializer.serialize(
+                                r1.data()
+                        )
                 )
         );
         System.out.println(r1);
     }
-    public void receive(Queue<NetworkRequestDTO> inpQueue) throws IOException, ClassNotFoundException{
+    public void receive(Queue<NetworkContainer<NetworkRequestDTO>> inpQueue) throws IOException, ClassNotFoundException{
         try {
+            NetworkContainer<byte[]> nc = this.driver.receive();
             inpQueue.add(
-                    this.serializer.deserialize(
-                        this.driver.receive()
-                )
+                    new NetworkContainer<>(
+                            nc.socketAddress(),
+                            this.serializer.deserialize(
+                                    nc.data()
+                            )
+                    )
             );
         }
         catch (Exception e){}

programming/sem2/lab5_v2/src/main/java/server/network/drivers/INetworkDriver.java

@@ -1,10 +1,12 @@
 package server.network.drivers;
 
+import server.network.NetworkContainer;
+
 import java.io.IOException;
 import java.net.SocketException;
 
 public interface INetworkDriver {
     public void init() throws SocketException, IOException;
-    public void send(byte[] data) throws IOException;
-    public byte[] receive() throws IOException;
+    public void send(NetworkContainer<byte[]> data) throws IOException;
+    public NetworkContainer<byte[]> receive() throws IOException;
 }

programming/sem2/lab5_v2/src/main/java/server/network/drivers/implementations/UDPDriver.java

@@ -1,6 +1,7 @@
 package server.network.drivers.implementations;
 
 import server.network.drivers.INetworkDriver;
+import server.network.NetworkContainer;
 
 import java.io.IOException;
 import java.net.InetSocketAddress;
@@ -27,16 +28,19 @@ public void init() throws SocketException, IOException{
         channel.configureBlocking(false);
     }
 
-    public void send(byte[] data) throws IOException {
-        ByteBuffer buf = ByteBuffer.wrap(data);
-        channel.send(buf, addr);
+    public void send(NetworkContainer<byte[]> data) throws IOException {
+        ByteBuffer buf = ByteBuffer.wrap(data.data());
+        channel.send(buf, data.socketAddress());
     }
 
-    public byte[] receive() throws IOException{
+    public NetworkContainer<byte[]> receive() throws IOException{
         ByteBuffer buf = ByteBuffer.allocate(DATA_SIZE);
         addr = channel.receive(buf);
         if (addr != null) {
-            return buf.array();
+            return new NetworkContainer<>(
+                    addr,
+                    buf.array()
+            );
         }
         return null;
     }