Feat server

EasyLib/Api/JobManagerClient.cs

@@ -0,0 +1,5 @@
+namespace EasyLib.Api;
+
+public class JobManagerClient
+{
+}

EasyLib/Api/JobManagerServer.cs

@@ -0,0 +1,126 @@
+using System.Net;
+using System.Net.Sockets;
+using EasyLib.Enums;
+using EasyLib.Files;
+using EasyLib.JobManager;
+using EasyLib.Json;
+
+namespace EasyLib.Api;
+
+public class JobManagerServer
+{
+    private readonly LocalJobManager _localJobManager;
+    private readonly TcpListener _serverSocket = null!;
+    private readonly List<Worker> _workers = new List<Worker>();
+    public readonly object ServerLockObject = new object();
+
+    public JobManagerServer(LocalJobManager localJobManager)
+    {
+        _localJobManager = localJobManager;
+        var serverPort = ConfigManager.Instance.ServerPort;
+        if (serverPort != null)
+        {
+            _serverSocket = new TcpListener(IPAddress.Any, serverPort.Value);
+            _serverSocket.Start();
+            new Thread(_waitForConnection).Start();
+        }
+    }
+
+    public CancellationTokenSource CancellationTokenSource { get; } = new CancellationTokenSource();
+
+    private void _waitForConnection()
+    {
+        try
+        {
+            while (true)
+            {
+                TcpClient socket = _serverSocket.AcceptTcpClient();
+
+                Worker worker = new Worker(socket, this);
+                AddWorker(worker);
+                worker.SendAllJobs(_localJobManager.GetJobs());
+                if (CancellationTokenSource.IsCancellationRequested)
+                    break;
+            }
+        }
+        catch (SocketException e)
+        {
+            CleanInstance();
+        }
+    }
+
+    private void AddWorker(Worker worker)
+    {
+        lock (ServerLockObject)
+        {
+            _workers.Add(worker);
+            worker.Start();
+        }
+    }
+
+    public void RemoveWorker(Worker worker)
+    {
+        lock (ServerLockObject)
+        {
+            _workers.Remove(worker);
+            worker.Close();
+        }
+    }
+
+    public void Broadcast(ApiAction action, JsonJob jsonJob)
+    {
+        lock (ServerLockObject)
+        {
+            foreach (Worker worker in _workers)
+            {
+                worker.Send(new JsonApiRequest() { Action = action, Job = jsonJob });
+            }
+        }
+    }
+
+    public void ExecuteJobCommand(ApiAction action, Job.Job job)
+    {
+        var localJob = _localJobManager.GetJobsFromIds(new[] { (int)job.Id });
+        if (localJob.Count != 1)
+            return;
+        switch (action)
+        {
+            case ApiAction.Start:
+                _localJobManager.ExecuteJob(localJob[0]);
+                break;
+            case ApiAction.Cancel:
+                _localJobManager.CancelJob(localJob[0]);
+                break;
+            case ApiAction.Pause:
+                _localJobManager.PauseJob(localJob[0]);
+                break;
+            case ApiAction.Edit:
+                _localJobManager.EditJob(localJob[0], job.Name, job.SourceFolder, job.DestinationFolder, job.Type);
+                break;
+            case ApiAction.Delete:
+                _localJobManager.DeleteJob(localJob[0]);
+                break;
+            case ApiAction.Resume:
+                _localJobManager.ResumeJob(localJob[0]);
+                break;
+            case ApiAction.Create:
+                _localJobManager.CreateJob(job.Name, job.SourceFolder, job.DestinationFolder, job.Type);
+                break;
+        }
+    }
+
+    public void CleanInstance()
+    {
+        var numWorkers = _workers.Count;
+        for (var i = 0; i < numWorkers; i++)
+        {
+            lock (ServerLockObject)
+            {
+                _workers[i].Close();
+            }
+        }
+
+        _workers.Clear();
+        _serverSocket.Stop();
+    }
+}

EasyLib/Api/JobManagerServerWorker.cs

@@ -0,0 +1,74 @@
+using System.Net.Sockets;
+using System.Text;
+using EasyLib.Enums;
+using EasyLib.Job;
+using EasyLib.Json;
+
+namespace EasyLib.Api;
+
+public class Worker
+{
+    private readonly JobManagerServer _server;
+    private readonly TcpClient _socket;
+    private readonly Stream _stream;
+
+    public Worker(TcpClient socket, JobManagerServer server)
+    {
+        this._socket = socket;
+        this._stream = socket.GetStream();
+        this._server = server;
+    }
+
+    public void Start()
+    {
+        new Thread(Run).Start();
+    }
+
+    public void Send(JsonApiRequest request)
+    {
+        string json = Newtonsoft.Json.JsonConvert.SerializeObject(request);
+        byte[] buffer = Encoding.UTF8.GetBytes(json);
+        _stream.Write(buffer, 0, buffer.Length);
+    }
+
+    private void Run()
+    {
+        try
+        {
+            byte[] buffer = new byte[2018];
+            while (true)
+            {
+                int receivedBytes = _stream.Read(buffer, 0, buffer.Length);
+                if (receivedBytes < 1)
+                    break;
+                JsonApiRequest request =
+                    Newtonsoft.Json.JsonConvert.DeserializeObject<JsonApiRequest>(
+                        Encoding.UTF8.GetString(buffer, 0, receivedBytes));
+                _server.ExecuteJobCommand(request.Action, new LocalJob(request.Job));
+                if (_server.CancellationTokenSource.IsCancellationRequested)
+                    break;
+            }
+        }
+        catch (Exception e)
+        {
+            Close();
+            lock (_server.ServerLockObject)
+            {
+                _server.RemoveWorker(this);
+            }
+        }
+    }
+
+    public void SendAllJobs(List<Job.Job> jobs)
+    {
+        foreach (Job.Job job in jobs)
+        {
+            Send(new JsonApiRequest() { Action = ApiAction.Create, Job = job.ToJsonJob() });
+        }
+    }
+
+    public void Close()
+    {
+        _stream.Close();
+    }
+}

EasyLib/Enums/ApiAction.cs

@@ -0,0 +1,15 @@
+namespace EasyLib.Enums;
+
+public enum ApiAction
+{
+    Start,
+    Pause,
+    Resume,
+    Cancel,
+    Delete,
+    Edit,
+    Error,
+    State,
+    Progress,
+    Create,
+}

EasyLib/Events/ProcessStartEvent.cs

@@ -96,16 +96,17 @@ private void _checkProcesses(string processName)
     {
         while (true)
         {
-            if (Process.GetProcessesByName(processName).Length > Interlocked.Read(ref _numberOfRunningProcesses))
+            var processesLength = Process.GetProcessesByName(processName).Length;
+            if (processesLength > Interlocked.Read(ref _numberOfRunningProcesses))
             {
                 ProcessStarted();
             }
-            else if (Process.GetProcessesByName(processName).Length < Interlocked.Read(ref _numberOfRunningProcesses))
+            else if (processesLength < Interlocked.Read(ref _numberOfRunningProcesses))
             {
                 ProcessStopped();
             }
 
-            Thread.Sleep(100);
+            Thread.Sleep(500);
             if (_cancellationTokenSource.IsCancellationRequested) return;
         }
     }

EasyLib/Files/References/ConfigManagerReference.cs

@@ -44,8 +44,8 @@
     public string? EasyCryptoPath { get; set; }
     public string? CompanySoftwareProcessPath { get; set; }
     public ulong MaxFileSize { get; set; } = 1000000;
-    public int ServerPort { get; set; } = 4242;
-    public string ServerIp { get; set; } = "";
+    public int? ServerPort { get; set; } = null;
+    public string? ServerIp { get; set; } = null;
 
     private static string GenerateRandomKey()
     {
@@ -89,7 +89,7 @@
         CompanySoftwareProcessPath = jsonConfig.CompanySoftwareProcessPath;
         Language = CultureInfo.GetCultureInfo(jsonConfig.Language);
         MaxFileSize = jsonConfig.MaxFileSize;
         PriorityFileExtensions = jsonConfig.PriorityFileExtensions;
 
         // If the key was null, write the new key
         if (xorKey == null)

EasyLib/JobManager/JobManager.cs

@@ -184,6 +184,11 @@ public virtual bool ExecuteJobs(IEnumerable<Job.Job> jobs)
             .Aggregate(true, (current, result) => current && result);
     }
 
+    public virtual void ExecuteJob(Job.Job job)
+    {
+        job.Run();
+    }
+
     /// <summary>
     /// Create a new job
     /// </summary>

EasyLib/JobManager/LocalJobManager.cs

@@ -1,3 +1,4 @@
+using EasyLib.Api;
 using EasyLib.Enums;
 using EasyLib.Events;
 using EasyLib.Files;
@@ -15,6 +16,8 @@
     /// </summary>
     private readonly bool _ramOnly;
 
+    private readonly JobManagerServer? _server;
+
     /// <summary>
     /// Event for when jobs need to wait for the company software to close
     /// </summary>
@@ -28,7 +31,11 @@
             FetchJobs();
         }
 
         _pauseJobEvent = new ProcessStartEvent(ConfigManager.Instance.CompanySoftwareProcessPath, this);
+        if (ConfigManager.Instance.ServerPort != null)
+        {
+            _server = new JobManagerServer(this);
+        }
     }
 
     public override void OnJobProgress(Job.Job job)
@@ -42,6 +49,11 @@
         {
             StateManager.Instance.WriteJobs(Jobs);
         }
+
+        if (_server != null)
+        {
+            _server.Broadcast(ApiAction.Progress, job.ToJsonJob());
+        }
     }
 
     public override void OnJobStateChange(JobState state, Job.Job job)
@@ -57,6 +69,11 @@
     public override void CleanStop()
     {
         _pauseJobEvent.Stop();
+        if (_server != null)
+        {
+            _server.CancellationTokenSource.Cancel();
+            _server.CleanInstance();
+        }
     }
 
     public override List<Job.Job> GetJobs()
@@ -234,6 +251,6 @@
     public override void ReloadConfig()
     {
         _pauseJobEvent.Stop();
         _pauseJobEvent = new ProcessStartEvent(ConfigManager.Instance.CompanySoftwareProcessPath, this);
     }
 }

EasyLib/Json/JsonApiRequest.cs

@@ -0,0 +1,9 @@
+using EasyLib.Enums;
+
+namespace EasyLib.Json;
+
+public struct JsonApiRequest
+{
+    public ApiAction Action { get; set; }
+    public JsonJob Job { get; set; }
+}