Fix socket permission denied error

plugins/command-manager/src/main/java/com/wazuh/commandmanager/CommandManagerPlugin.java

@@ -65,9 +65,7 @@ public Collection<Object> createComponents(
             Supplier<RepositoriesService> repositoriesServiceSupplier
     ) {
         this.commandIndex = new CommandIndex(client, clusterService, threadPool);
-        //ConfigReader configReader = new ConfigReader("127.0.0.1", 8080, "/", "admin", "admin");
         ConfigReader configReader = new ConfigReader("httpbin.org", 80, "/post", "admin", "admin");
-        //ConfigReader configReader = new ConfigReader();
         JobScheduler jobScheduler = new JobScheduler(threadPool, configReader);
         return Collections.emptyList();
     }

plugins/command-manager/src/main/java/com/wazuh/commandmanager/http/client/AsyncRequestRepository.java

@@ -34,15 +34,11 @@
 import org.apache.hc.core5.http.ContentType;
 import org.apache.hc.core5.http.HttpHost;
 import org.apache.hc.core5.http.message.StatusLine;
-import org.apache.hc.core5.io.CloseMode;
 import org.apache.hc.core5.reactor.IOReactorConfig;
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
 
 import java.io.IOException;
-import java.security.AccessController;
-import java.security.PrivilegedAction;
-import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.Future;
 import java.util.concurrent.TimeUnit;
 
@@ -51,15 +47,17 @@ public class AsyncRequestRepository {
     private static final Logger logger = LogManager.getLogger(AsyncRequestRepository.class);
     private final HttpHost target;
     private final String requestUri;
-    private final CloseableHttpAsyncClient client;
 
     public AsyncRequestRepository(ConfigReader configReader) throws Exception {
         this.target = new HttpHost(configReader.getHostName(), configReader.getPort());
         this.requestUri = configReader.getPath();
-        this.client = prepareAsyncRequest();
     }
 
     public CloseableHttpAsyncClient prepareAsyncRequest() throws IOException {
+        return null;
+    }
+
+    public Future<SimpleHttpResponse> performAsyncRequest() throws Exception {
         logger.info("Preparing Async Request");
         IOReactorConfig ioReactorConfig = IOReactorConfig.custom()
             .setSoTimeout(5, TimeUnit.SECONDS)
@@ -69,10 +67,6 @@ public CloseableHttpAsyncClient prepareAsyncRequest() throws IOException {
             .setIOReactorConfig(ioReactorConfig)
             .build();
         client.start();
-        return client;
-    }
-
-    public CompletableFuture<SimpleBody> performAsyncRequest() throws Exception {
 
         final SimpleHttpRequest request = SimpleRequestBuilder.post()
             .setHttpHost(target)
@@ -82,36 +76,29 @@ public CompletableFuture<SimpleBody> performAsyncRequest() throws Exception {
 
         logger.info("Executing {} request", request);
 
-        CompletableFuture<SimpleBody> completableFuture = new CompletableFuture<>();
-        AccessController.doPrivileged(
-            (PrivilegedAction<Future<SimpleHttpResponse>>) () -> this.client.execute(
-                SimpleRequestProducer.create(request),
-                SimpleResponseConsumer.create(),
-                new FutureCallback<>() {
-                    @Override
-                    public void completed(final SimpleHttpResponse response) {
-                        logger.info("{}->{}", request, new StatusLine(response));
-                        completableFuture.complete(response.getBody());
-                    }
+        return client.execute(
+            SimpleRequestProducer.create(request),
+            SimpleResponseConsumer.create(),
+            new FutureCallback<>() {
+                @Override
+                public void completed(final SimpleHttpResponse response) {
+                    logger.info("{}->{}", request, new StatusLine(response));
+                }
 
-                    @Override
-                    public void failed(final Exception ex) {
-                        logger.error("Could not process {} request: {}", request, ex.getMessage());
-                    }
+                @Override
+                public void failed(final Exception ex) {
+                    logger.error("Could not process {} request: {}", request, ex.getMessage());
+                }
 
-                    @Override
-                    public void cancelled() {
-                        logger.error("{} cancelled", request);
-                    }
+                @Override
+                public void cancelled() {
+                    logger.error("{} cancelled", request);
                 }
-            )
+            }
         );
-        //future.get();
-        return completableFuture;
     }
 
     public void close() {
         logger.info("HTTP requester shutting down");
-        this.client.close(CloseMode.GRACEFUL);
     }
-}
+}

plugins/command-manager/src/main/java/com/wazuh/commandmanager/scheduler/JobScheduler.java

@@ -2,12 +2,16 @@
 
 import com.wazuh.commandmanager.config.reader.ConfigReader;
 import com.wazuh.commandmanager.http.client.AsyncRequestRepository;
+import org.apache.hc.client5.http.async.methods.SimpleHttpResponse;
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
 import org.opensearch.threadpool.ThreadPool;
 
 
+import java.security.AccessController;
+import java.security.PrivilegedAction;
 import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Future;
 
 public class JobScheduler {
 
@@ -21,23 +25,23 @@ public JobScheduler(ThreadPool threadPool, ConfigReader configReader) {
 
     private void start(ThreadPool threadPool) {
         ExecutorService executorService = threadPool.executor(ThreadPool.Names.GENERIC);
+        Future<SimpleHttpResponse> future = AccessController.doPrivileged(
+            (PrivilegedAction<Future<SimpleHttpResponse>>) () -> {
+                try {
+                    return new AsyncRequestRepository(configReader).performAsyncRequest();
+                } catch (Exception e) {
+                    throw new RuntimeException(e);
+                }
+            }
+        );
         executorService.submit(
             () -> {
                 while(!Thread.currentThread().isInterrupted()) {
                     try {
                         Thread.sleep(5000);
-                        logger.info("Running task");
-                        AsyncRequestRepository asyncRequestRepository = new AsyncRequestRepository(this.configReader);
-                        asyncRequestRepository.performAsyncRequest()
-                            .thenAccept(
-                                logger::info
-                            )
-                            .exceptionally(
-                                e -> {
-                                    logger.error("Exception found {}", e.getMessage());
-                                    return null;
-                                }
-                            );
+                        logger.info("Running HTTP Request");
+                        logger.info(future.get().getBodyText());
+
                     } catch (InterruptedException e) {
                         Thread.currentThread().interrupt();
                         logger.info("Exiting scheduler");