private void CheckPeerConnection(ReceiverIdentifier nodeIdentifier, ClusterMemberMeta meta)
 {
     if (!meta.ConnectionEstablished)
     {
         using (var socket = socketFactory.CreateRouterSocket())
         {
             var uri = new Uri(meta.ScaleOutUri);
             try
             {
                 socket.SetMandatoryRouting();
                 socket.Connect(uri, waitUntilConnected: true);
                 var message = Message.Create(new PingMessage())
                               .As <Message>();
                 message.SetDomain(securityProvider.GetDomain(KinoMessages.Ping.Identity));
                 message.SetSocketIdentity(nodeIdentifier.Identity);
                 message.SignMessage(securityProvider);
                 socket.SendMessage(message);
                 socket.Disconnect(uri);
                 meta.LastKnownHeartBeat = DateTime.UtcNow;
             }
             catch (Exception err)
             {
                 routerLocalSocket.Send(Message.Create(new UnregisterUnreachableNodeMessage {
                     ReceiverNodeIdentity = nodeIdentifier.Identity
                 }));
                 logger.Warn($"Failed trying to check connectivity to node {nodeIdentifier}@{uri.ToSocketAddress()}. Peer deletion scheduled. {err}");
             }
         }
     }
 }
Exemple #2
0
        private void RoutePeerMessages(CancellationToken token, Barrier barrier)
        {
            try
            {
                using (var scaleOutFrontend = CreateScaleOutFrontendSocket())
                {
                    barrier.SignalAndWait(token);

                    while (!token.IsCancellationRequested)
                    {
                        Message message = null;
                        try
                        {
                            message = scaleOutFrontend.ReceiveMessage(token).As <Message>();
                            if (message != null)
                            {
                                message.VerifySignature(securityProvider);
                                var receiptConfirmationRequested = message.RemoveCallbackPoint(KinoMessages.ReceiptConfirmation);

                                if (receiptConfirmationRequested)
                                {
                                    receiptConfirmationQueue.Add(message, token);
                                }
                                localRouterSocket.Send(message);

                                ReceivedFromOtherNode(message);
                            }
                        }
                        //TODO: Check why sending exception message was only in case of SecurityException
                        //catch (SecurityException err)
                        //{
                        //    CallbackException(err, message);
                        //    logger.Error(err);
                        //}
                        catch (Exception err)
                        {
                            CallbackException(err, message);
                            logger.Error(err);
                        }
                    }
                }
            }
            catch (Exception err)
            {
                logger.Error(err);
            }
        }
Exemple #3
0
        private void RegisterMessageHub()
        {
            var registration = new InternalRouteRegistration
            {
                ReceiverIdentifier    = ReceiverIdentifier,
                KeepRegistrationLocal = keepRegistrationLocal,
                DestinationSocket     = receivingSocket
            };

            internalRegistrationsSender.Send(registration);
        }
Exemple #4
0
        private void SendActorRegistrationMessage(ActorRegistration registration)
        {
            var routeReg = new InternalRouteRegistration
            {
                ReceiverIdentifier = registration.ActorIdentifier,
                MessageContracts   = registration.MessageHandlers
                                     .Select(mh => new MessageContract
                {
                    Message = mh.Identifier,
                    KeepRegistrationLocal = mh.KeepRegistrationLocal
                })
                                     .ToArray(),
                DestinationSocket = receivingSocket
            };

            internalRegistrationsSender.Send(routeReg);
        }