Task <bool> ProcessMessage(ISignalingMessage message)
        {
            try
            {
                switch (message)
                {
                case SNPLinkConnectionRequest_req req:
                {
                    _logService.LogInfo($"Getting {req}");
                    var port = NetworkNodeConfig.Neighbors.First(n => n.Name == req.To).Port;

                    var msg = new SNPNegotiation_req
                    {
                        From              = req.From,
                        FromPort          = port,
                        ToPort            = req.ToPort,
                        To                = req.To,
                        Port              = port,
                        Slots             = req.Slots,
                        Guid              = req.Guid,
                        RequestFromDomain = req.RequestFromDomain,
                        Rerouting         = req.Rerouting,
                        Action            = req.Action,
                        Releasing         = req.Releasing
                    };

                    if (msg.Releasing)
                    {
                        var snpLinkConnectionRequest_rsp = new SNPLinkConnectionRequest_rsp
                        {
                            From              = req.From,
                            FromPort          = port,
                            To                = req.To,
                            ToPort            = req.ToPort,
                            Slots             = req.Slots,
                            Guid              = req.Guid,
                            RequestFromDomain = req.RequestFromDomain,
                            Result            = RequestResult.Confirmed,
                            Rerouting         = req.Rerouting,
                            Releasing         = req.Releasing
                        };

                        if (msg.RequestFromDomain)
                        {
                            _lrmService.SendMessageToDomainCCRC(snpLinkConnectionRequest_rsp);
                        }
                        else
                        {
                            _lrmService.SendMessageToCCRC(snpLinkConnectionRequest_rsp);
                        }

                        return(Task.FromResult(true));
                    }

                    _logService.LogInfo($"Sending {msg}");
                    _cableCloudConnectionService.SendSNPNegotiation(msg);
                    break;
                }

                case SNPNegotiation_req negreq:
                {
                    _logService.LogInfo($"Getting {negreq}");

                    var port = NetworkNodeConfig.Neighbors.First(n => n.Name == negreq.From).Port;

                    var areFree = _routingService.CheckFreeSlots(negreq.Slots);

                    var msg = new SNPNegotiation_rsp
                    {
                        From              = negreq.From,
                        FromPort          = negreq.FromPort,
                        To                = negreq.To,
                        ToPort            = port,
                        Port              = port,
                        Slots             = negreq.Slots,
                        Result            = areFree ? RequestResult.Confirmed : RequestResult.Rejected,
                        Guid              = negreq.Guid,
                        RequestFromDomain = negreq.RequestFromDomain,
                        Rerouting         = negreq.Rerouting,
                        Releasing         = negreq.Releasing
                    };

                    _logService.LogInfo($"Sending {msg}");

                    _cableCloudConnectionService.SendSNPNegotiation(msg);
                    break;
                }

                case SNPNegotiation_rsp negrsp:
                {
                    _logService.LogInfo($"Getting {negrsp}");

                    var port = NetworkNodeConfig.Neighbors.First(n => n.Name == negrsp.To).Port;

                    var snpLinkConnectionRequest_rsp = new SNPLinkConnectionRequest_rsp
                    {
                        From              = negrsp.From,
                        FromPort          = port,
                        To                = negrsp.To,
                        ToPort            = negrsp.ToPort,
                        Slots             = negrsp.Slots,
                        Guid              = negrsp.Guid,
                        RequestFromDomain = negrsp.RequestFromDomain,
                        Result            = negrsp.Result == RequestResult.Confirmed
                                    ? RequestResult.Confirmed
                                    : RequestResult.Rejected,
                        Rerouting = negrsp.Rerouting,
                        Releasing = negrsp.Releasing
                    };


                    _logService.LogInfo($"Sending {snpLinkConnectionRequest_rsp}");

                    if (negrsp.RequestFromDomain)
                    {
                        _lrmService.SendMessageToDomainCCRC(snpLinkConnectionRequest_rsp);
                    }
                    else
                    {
                        _lrmService.SendMessageToCCRC(snpLinkConnectionRequest_rsp);
                    }

                    break;
                }

                case CableAction cableAction:
                {
                    _logService.LogInfo("Sending LocalTopology to CC and RC");
                    _lrmService.SendMessageToCCRC(cableAction);
                    break;
                }
                }
            } catch (Exception ex)
            {
                _logService.LogError(ex.StackTrace);
            }

            return(Task.FromResult(true));
        }