SleepMachineHandler

src/api/NetworkResurrector.Api.Application/CommandHandlers/RestartMachineHandler.cs

@@ -7,7 +7,6 @@ using NetworkResurrector.Api.Domain.Constants;
 using NetworkResurrector.Api.Domain.Repositories;
 using NetworkResurrector.Api.PublishedLanguage.Commands;
 using NetworkResurrector.Api.PublishedLanguage.Events;
-using NetworkResurrector.Server.Wrapper.Services;
 using System;
 using System.Threading;
 using System.Threading.Tasks;
@@ -17,15 +16,13 @@ namespace NetworkResurrector.Api.Application.CommandHandlers
     public class RestartMachineHandler : IRequestHandler<RestartMachine, MachineRestarted>
     {
         private readonly ILogger<RestartMachineHandler> _logger;
-        private readonly IResurrectorService _resurrectorService;
         private readonly INetworkRepository _repository;
         private readonly IResurrectorAgentService _resurrectorAgentService;
         private readonly IConfiguration _configuration;
 
-        public RestartMachineHandler(ILogger<RestartMachineHandler> logger, IResurrectorService resurrectorService, INetworkRepository repository, IResurrectorAgentService resurrectorAgentService, IConfiguration configuration)
+        public RestartMachineHandler(ILogger<RestartMachineHandler> logger, INetworkRepository repository, IResurrectorAgentService resurrectorAgentService, IConfiguration configuration)
         {
             _logger=logger;
-            _resurrectorService=resurrectorService;
             _repository=repository;
             _resurrectorAgentService=resurrectorAgentService;
             _configuration=configuration;
@@ -50,9 +47,9 @@ namespace NetworkResurrector.Api.Application.CommandHandlers
 
                     var owner = new ActionOwner(_configuration.GetValue<string>("Service:Code"));
                     var options = new ActionOptions(command.Delay ?? 0, command.Force);
-                    var RestartResultByAgent = await _resurrectorAgentService.Restart(ipAddressOrMachineName, machine.Agent.AgentPort, owner, options);
+                    var restartResultByAgent = await _resurrectorAgentService.Restart(ipAddressOrMachineName, machine.Agent.AgentPort, owner, options);
-                    var status = RestartResultByAgent.Success ? $"Machine '{ipAddressOrMachineName}' successfully restarted." : $"Machine '{ipAddressOrMachineName}' could not be restarted.";
+                    var status = restartResultByAgent.Success ? $"Machine '{ipAddressOrMachineName}' successfully restarted." : $"Machine '{ipAddressOrMachineName}' could not be restarted.";
-                    result = new MachineRestarted(RestartResultByAgent.Success, status);
+                    result = new MachineRestarted(restartResultByAgent.Success, status);
                     break;
 
                 default:

src/api/NetworkResurrector.Api.Application/CommandHandlers/SleepMachineHandler.cs

@@ -0,0 +1,64 @@
+using MediatR;
+using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.Logging;
+using NetworkResurrector.Agent.PublishedLanguage.Dto;
+using NetworkResurrector.Agent.Wrapper.Services;
+using NetworkResurrector.Api.Domain.Constants;
+using NetworkResurrector.Api.Domain.Repositories;
+using NetworkResurrector.Api.PublishedLanguage.Commands;
+using NetworkResurrector.Api.PublishedLanguage.Events;
+using System;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace NetworkResurrector.Api.Application.CommandHandlers
+{
+    public class SleepMachineHandler : IRequestHandler<SleepMachine, MachineSlept>
+    {
+        private readonly ILogger<SleepMachineHandler> _logger;
+        private readonly INetworkRepository _repository;
+        private readonly IResurrectorAgentService _resurrectorAgentService;
+        private readonly IConfiguration _configuration;
+
+        public SleepMachineHandler(ILogger<SleepMachineHandler> logger, INetworkRepository repository, IResurrectorAgentService resurrectorAgentService, IConfiguration configuration)
+        {
+            _logger=logger;
+            _repository=repository;
+            _resurrectorAgentService=resurrectorAgentService;
+            _configuration=configuration;
+        }
+
+        public async Task<MachineSlept> Handle(SleepMachine command, CancellationToken cancellationToken)
+        {
+            _logger.LogDebug($"Start sleeping machine {command.MachineId}");
+            var machine = await _repository.GetMachine(command.MachineId);
+            var powerConfiguration = await _repository.GetPowerActionConfiguration(command.MachineId, PowerActions.SLEEP);
+
+            //log activity
+
+            var ipAddressOrMachineName = machine.IPv4Address ?? machine.MachineName;
+            MachineSlept result;
+
+            switch (powerConfiguration.Performer.PerformerCode)
+            {
+                case PowerActionPerformers.NETWORK_RESURRECTOR_AGENT:
+                    if (machine.Agent == null)
+                        throw new Exception($"Cannot use network resurrector agent as sleep performer for machine '{ipAddressOrMachineName}' because it is not configured.");
+
+                    var owner = new ActionOwner(_configuration.GetValue<string>("Service:Code"));
+                    var options = new ActionOptions(command.Delay ?? 0, command.Force);
+                    var sleepResultByAgent = await _resurrectorAgentService.Sleep(ipAddressOrMachineName, machine.Agent.AgentPort, owner, options);
+                    var status = sleepResultByAgent.Success ? $"Machine '{ipAddressOrMachineName}' successfully slept." : $"Machine '{ipAddressOrMachineName}' could not be slept.";
+                    result = new MachineSlept(sleepResultByAgent.Success, status);
+                    break;
+
+                default:
+                    throw new Exception($"Power action performer {powerConfiguration.Performer.PerformerCode} is not implemented.");
+            }
+
+            _logger.LogDebug($"Machine {command.MachineId} sleeping finished. Success: {result.Success}; Status: {result.Status}");
+
+            return result;
+        }
+    }
+}

src/api/NetworkResurrector.Api.PublishedLanguage/Commands/SleepMachine.cs

@@ -0,0 +1,12 @@
+using NDB.Application.DataContracts;
+using NetworkResurrector.Api.PublishedLanguage.Events;
+
+namespace NetworkResurrector.Api.PublishedLanguage.Commands
+{
+    public class SleepMachine : Command<MachineSlept>
+    {
+        public int MachineId { get; set; }
+        public int? Delay { get; set; }
+        public bool Force { get; set; }
+    }
+}

src/api/NetworkResurrector.Api.PublishedLanguage/Events/MachineSlept.cs

@@ -0,0 +1,4 @@
+namespace NetworkResurrector.Api.PublishedLanguage.Events
+{
+    public record MachineSlept(bool Success, string Status);
+}

src/api/NetworkResurrector.Api/Controllers/ResurrectorController.cs

@@ -45,5 +45,12 @@ namespace NetworkResurrector.Api.Controllers
             var result = await _mediator.Send(restartMachine);
             return Ok(result);
         }
+
+        [HttpPost("sleep")]
+        public async Task<IActionResult> SleepMachine([FromBody] SleepMachine sleepMachine)
+        {
+            var result = await _mediator.Send(sleepMachine);
+            return Ok(result);
+        }
     }
 }