lab5_v2 better solution

Author: NF-coder

programming/sem2/lab5_v2/src/main/java/server/ServerCycle.java

@@ -1,10 +1,22 @@
 package server;
 
 import server.core.Engine;
+import server.network.drivers.implementations.UDPDriver;
+import server.network.serializers.implementations.BinarySerializer;
+import server.storage.collection.drivers.implementations.DequeDriver;
+
+import java.util.concurrent.Executors;
 
 public class ServerCycle implements Runnable {
     public void run(){
-        Engine engine = new Engine();
+        Engine engine = new Engine(
+                new UDPDriver(4056),
+                Executors.newFixedThreadPool(1),
+                Executors.newFixedThreadPool(1),
+                Executors.newFixedThreadPool(3),
+                new BinarySerializer(),
+                new DequeDriver()
+        );
         while (true){
             engine.mainCycle();
         }

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

@@ -1,9 +1,12 @@
 package server.core;
 
+import java.net.SocketAddress;
 import java.util.HashMap;
+import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.ExecutorService;
 import java.util.function.Function;
 
+import server.network.container.NetworkContainer;
 import server.storage.collection.drivers.IStructDriver;
 import server.storage.commands.CommandsManager;
 
@@ -18,17 +21,17 @@ public CommandFactory(ExecutorService executor, IStructDriver structDriver) {
         this.executor = executor;
     }
 
-    public <T> void runCommand(
+    public CompletableFuture<NetworkContainer<HashMap<String,String>>> runCommand(
             String opName,
             HashMap<String, String> args,
-            Function<HashMap<String,String>, T> nextStage
+            SocketAddress socketAddress
     ) {
-        commandsManager.run(
+        return commandsManager.run(
                 opName,
                 args,
                 this.executor
         ).thenApply(
-                nextStage
+                res -> new NetworkContainer<>(socketAddress, res)
         );
     }
 }

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

@@ -1,62 +1,67 @@
 package server.core;
 
-import java.util.Queue;
-import java.util.concurrent.ConcurrentLinkedQueue;
-import java.util.concurrent.Executors;
+import java.util.concurrent.ExecutorService;
 
 import server.network.container.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 shared.objects.NetworkRequestDTO;
+import server.network.drivers.INetworkDriver;
+import server.network.managers.ReceiveManager;
+import server.network.managers.SendManager;
+import server.network.serializers.INetworkSerializers;
+import server.storage.collection.drivers.IStructDriver;
 import shared.objects.NetworkResponseDTO;
 
 public class Engine {
-    private final Queue<NetworkContainer<NetworkRequestDTO>> networkReceived = new ConcurrentLinkedQueue<>();
-    private final Queue<NetworkContainer<NetworkResponseDTO>> networkToSend = new ConcurrentLinkedQueue<>();
+    private final ReceiveManager receiveManager;
+    public final SendManager sendManager;
+    private final CommandFactory commandFactory;
 
-    private final CommandFactory commandFactory = new CommandFactory(
-            Executors.newFixedThreadPool(10),
-            new DequeDriver()
-    );
+    public Engine(
+            INetworkDriver networkDriver,
+            ExecutorService receiveExecutor,
+            ExecutorService sendExecutor,
+            ExecutorService commandExecutor,
+            INetworkSerializers networkSerializer,
+            IStructDriver structDriver
+    ) {
+        try {
+            networkDriver.init();
+        } catch (Exception e) {}
 
-    public Engine(){
-        Thread networkThread = new Thread(
-                new NetworkCycle(
-                    new UDPDriver(4056),
-                    new BinarySerializer(),
-                    this.networkReceived,
-                    this.networkToSend
-            )
+        this.receiveManager = new ReceiveManager(
+                networkDriver,
+                networkSerializer,
+                receiveExecutor
+        );
+        this.sendManager = new SendManager(
+                networkDriver,
+                networkSerializer,
+                sendExecutor
+        );
+        this.commandFactory = new CommandFactory(
+                commandExecutor,
+                structDriver
         );
-        networkThread.start();
     }
 
-    public void mainCycle(){
-        try{
-            if (!networkReceived.isEmpty()){
-                System.out.println("Received from get");
-                NetworkContainer<NetworkRequestDTO> networkRequestDTO = networkReceived.remove();
-                System.out.println(networkRequestDTO);
-
-                commandFactory.runCommand(
-                        networkRequestDTO.data().opName(),
-                        networkRequestDTO.data().args(),
-                        res->{
-                            System.out.println("fapl: " + res.toString());
-                            return networkToSend.add(
+    public void mainCycle() {
+        try {
+            receiveManager.call()
+                    .thenCompose(
+                            networkRequestDTO -> commandFactory.runCommand(
+                                    networkRequestDTO.data().opName(),
+                                    networkRequestDTO.data().args(),
+                                    networkRequestDTO.socketAddress()
+                            )
+                    )
+                    .thenCompose(
+                            result -> sendManager.call(
                                     new NetworkContainer<>(
-                                            networkRequestDTO.socketAddress(),
-                                            new NetworkResponseDTO(res)
+                                            result.socketAddress(),
+                                            new NetworkResponseDTO(result.data())
                                     )
-                            );
-                        }
-                );
-
-            }
-        }
-        catch (Exception e){
+                            )
+                    );
+        } catch (Exception e) {
             System.out.println("eng " + e.getMessage());
         }
     }

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

@@ -6,7 +6,9 @@
 import shared.objects.NetworkRequestDTO;
 
 import java.io.IOException;
+import java.util.HashMap;
 import java.util.Queue;
+import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
 
@@ -15,24 +17,34 @@ public class ReceiveManager {
     INetworkSerializers serializer;
     ExecutorService executor;
 
-    public ReceiveManager(INetworkDriver driver, INetworkSerializers serializer) {
+    public ReceiveManager(INetworkDriver driver, INetworkSerializers serializer, ExecutorService executor) {
         this.driver = driver;
         this.serializer = serializer;
-        this.executor = Executors.newFixedThreadPool(1);
+        this.executor = executor;
     }
 
-    public void call(Queue<NetworkContainer<NetworkRequestDTO>> inpQueue) throws IOException, ClassNotFoundException{
-        try {
-            NetworkContainer<byte[]> nc = this.driver.receive();
-            inpQueue.add(
-                    new NetworkContainer<>(
-                            nc.socketAddress(),
-                            this.serializer.deserialize(
-                                    nc.data()
-                            )
-                    )
-            );
-        }
-        catch (Exception e){}
+    public CompletableFuture<NetworkContainer<NetworkRequestDTO>> call() throws IOException, ClassNotFoundException{
+        return  CompletableFuture.supplyAsync(() -> {
+            try {
+                return this.driver.receive();
+            } catch (IOException e) {
+                throw new RuntimeException(e);
+            }
+        }).thenApply(
+                res -> {
+                    try {
+                        return new NetworkContainer<>(
+                                res.socketAddress(),
+                                this.serializer.deserialize(
+                                        res.data()
+                                )
+                        );
+                    } catch (IOException e) {
+                        throw new RuntimeException(e);
+                    } catch (ClassNotFoundException e) {
+                        throw new RuntimeException(e);
+                    }
+                }
+        );
     }
 }

programming/sem2/lab5_v2/src/main/java/server/network/managers/ReceiveManager.java

@@ -3,7 +3,6 @@
 import server.network.container.NetworkContainer;
 import server.network.drivers.INetworkDriver;
 import server.network.serializers.INetworkSerializers;
-import shared.objects.NetworkRequestDTO;
 import shared.objects.NetworkResponseDTO;
 
 import java.io.IOException;
@@ -17,17 +16,14 @@ public class SendManager {
     INetworkSerializers serializer;
     ExecutorService executor;
 
-    public SendManager(INetworkDriver driver, INetworkSerializers serializer) {
+    public SendManager(INetworkDriver driver, INetworkSerializers serializer, ExecutorService executor) {
         this.driver = driver;
         this.serializer = serializer;
-        this.executor = Executors.newFixedThreadPool(1);
+        this.executor = executor;
     }
 
-    public void call(Queue<NetworkContainer<NetworkResponseDTO>> outQueue) throws Exception{
-        NetworkContainer<NetworkResponseDTO> elem = outQueue.poll();
-        if(elem == null){return;}
-
-        CompletableFuture.supplyAsync(
+    public CompletableFuture<Void> call(NetworkContainer<NetworkResponseDTO> elem){
+        return CompletableFuture.supplyAsync(
                 () -> {
                     try {
                         return this.serializer.serialize(