< Summary - Combined Code Coverage

Information
Class: NLightning.Daemon.Ipc.Handlers.OpenChannelIpcHandler
Assembly: NLightning.Daemon
File(s): /home/runner/work/NLightning/NLightning/src/NLightning.Daemon/Ipc/Handlers/OpenChannelIpcHandler.cs
Tag: 57_24045730253
Line coverage
0%
Covered lines: 0
Uncovered lines: 48
Coverable lines: 48
Total lines: 99
Line coverage: 0%
Branch coverage
0%
Covered branches: 0
Total branches: 2
Branch coverage: 0%
Method coverage

Feature is only available for sponsors

Upgrade to PRO version

Metrics

MethodBranch coverage Crap Score Cyclomatic complexity Line coverage
get_Command()100%210%
.ctor(...)100%210%
HandleAsync()0%620%

File(s)

/home/runner/work/NLightning/NLightning/src/NLightning.Daemon/Ipc/Handlers/OpenChannelIpcHandler.cs

#LineLine coverage
 1using MessagePack;
 2using Microsoft.Extensions.DependencyInjection;
 3using Microsoft.Extensions.Logging;
 4
 5namespace NLightning.Daemon.Ipc.Handlers;
 6
 7using Daemon.Handlers;
 8using Daemon.Interfaces;
 9using Domain.Client.Constants;
 10using Domain.Client.Enums;
 11using Domain.Client.Exceptions;
 12using Domain.Client.Requests;
 13using Domain.Client.Responses;
 14using Domain.Exceptions;
 15using Interfaces;
 16using Services.Ipc.Factories;
 17using Transport.Ipc;
 18using Transport.Ipc.Requests;
 19using Transport.Ipc.Responses;
 20
 21internal sealed class OpenChannelIpcHandler : IIpcCommandHandler
 22{
 23    private readonly ILogger<OpenChannelIpcHandler> _logger;
 24    private readonly IServiceProvider _serviceProvider;
 25
 026    public ClientCommand Command => ClientCommand.OpenChannel;
 27
 028    public OpenChannelIpcHandler(ILogger<OpenChannelIpcHandler> logger, IServiceProvider serviceProvider)
 29    {
 030        _logger = logger;
 031        _serviceProvider = serviceProvider;
 032    }
 33
 34    public async Task<IpcEnvelope> HandleAsync(IpcEnvelope envelope, CancellationToken ct)
 35    {
 36        try
 37        {
 38            // Deserialize the request
 039            var request =
 040                MessagePackSerializer.Deserialize<OpenChannelIpcRequest>(envelope.Payload, cancellationToken: ct);
 41
 42            // Get the client handler
 043            using var scope = _serviceProvider.CreateScope();
 044            var openChannelClientHandler =
 045                scope.ServiceProvider.GetService(
 046                        typeof(IClientCommandHandler<OpenChannelClientRequest, OpenChannelClientResponse>)) as
 047                    OpenChannelClientHandler ??
 048                throw new InvalidOperationException($"Unable to get service {nameof(OpenChannelClientHandler)}");
 49
 050            var clientResponse = await openChannelClientHandler.HandleAsync(request.ToClientRequest(), ct);
 51
 052            var payload = MessagePackSerializer.Serialize(OpenChannelIpcResponse.FromClientResponse(clientResponse),
 053                                                          cancellationToken: ct);
 054            return new IpcEnvelope
 055            {
 056                Version = envelope.Version,
 057                Command = envelope.Command,
 058                CorrelationId = envelope.CorrelationId,
 059                Kind = IpcEnvelopeKind.Response,
 060                Payload = payload
 061            };
 62        }
 063        catch (ClientException ce)
 64        {
 065            _logger.LogError(ce, "Error while handling OpenChannel");
 066            return IpcErrorFactory.CreateErrorEnvelope(envelope, ce.Message, ce.Message);
 67        }
 068        catch (FormatException fe)
 69        {
 070            _logger.LogWarning(fe, "Invalid peer address format");
 071            return IpcErrorFactory.CreateErrorEnvelope(envelope, ErrorCodes.InvalidAddress,
 072                                                       $"Invalid address format: {fe.Message}");
 73        }
 074        catch (InvalidOperationException oe)
 75        {
 076            _logger.LogError(oe, "The operation could not be completed");
 077            return IpcErrorFactory.CreateErrorEnvelope(envelope, ErrorCodes.InvalidOperation,
 078                                                       $"The operation could not be completed: {oe.Message}");
 79        }
 080        catch (ConnectionException ce)
 81        {
 082            _logger.LogError(ce, "Failed to connect to peer");
 083            return IpcErrorFactory.CreateErrorEnvelope(envelope, ErrorCodes.ConnectionError,
 084                                                       $"Connection failed: {ce.Message}");
 85        }
 086        catch (ChannelErrorException cee)
 87        {
 088            _logger.LogError(cee, "Error opening Channel");
 089            return IpcErrorFactory.CreateErrorEnvelope(envelope, ErrorCodes.ConnectionError,
 090                                                       $"Channel Error: {cee.Message}");
 91        }
 092        catch (Exception e)
 93        {
 094            _logger.LogError(e, "Error connecting to peer");
 095            return IpcErrorFactory.CreateErrorEnvelope(envelope, ErrorCodes.ServerError,
 096                                                       $"Error connecting to peer: {e.Message}");
 97        }
 098    }
 99}