public void HandleApplicationMessage(RawMessage message, IApplicationOutboundStream responder)
 {
     if (!actor.IsStopped)
     {
         Action <IClusterApplication> consumer = __ => __.HandleApplicationMessage(message, responder);
         if (mailbox.IsPreallocated)
         {
             mailbox.Send(actor, consumer, null, HandleApplicationMessageRepresentation1);
         }
         else
         {
             mailbox.Send(new LocalMessage <IClusterApplication>(actor, consumer,
                                                                 HandleApplicationMessageRepresentation1));
         }
     }
     else
     {
         actor.DeadLetters.FailedDelivery(new DeadLetter(actor,
                                                         HandleApplicationMessageRepresentation1));
     }
 }
        public void Open(Stage stage, Wire.Node.Node node, IInboundStreamInterest interest, IConfiguration configuration)
        {
            _operationalInboundStream =
                InboundStreamFactory.Instance(
                    stage,
                    interest,
                    node.OperationalAddress.Port,
                    AddressType.Op,
                    OpName,
                    Properties.Instance.OperationalBufferSize(),
                    Properties.Instance.OperationalInboundProbeInterval());

            _operationalOutboundStream =
                OperationalOutboundStreamFactory.Instance(
                    stage,
                    node,
                    new ManagedOutboundSocketChannelProvider(node, AddressType.Op, configuration),
                    new ByteBufferPool(
                        Properties.Instance.OperationalOutgoingPooledBuffers(),
                        Properties.Instance.OperationalBufferSize()));

            _applicationInboundStream =
                InboundStreamFactory.Instance(
                    stage,
                    interest,
                    node.ApplicationAddress.Port,
                    AddressType.App,
                    AppName,
                    Properties.Instance.ApplicationBufferSize(),
                    Properties.Instance.ApplicationInboundProbeInterval());

            _applicationOutboundStream =
                ApplicationOutboundStreamFactory.Instance(
                    stage,
                    new ManagedOutboundSocketChannelProvider(node, AddressType.App, configuration),
                    new ByteBufferPool(
                        Properties.Instance.ApplicationOutgoingPooledBuffers(),
                        Properties.Instance.ApplicationBufferSize()));
        }
 public void HandleApplicationMessage(RawMessage message, IApplicationOutboundStream responder) =>
 HandleApplicationMessageCheck.IncrementAndGet();
 public void HandleApplicationMessage(RawMessage message, IApplicationOutboundStream responder)
 {
 }
 public void InformResponder(IApplicationOutboundStream responder) => InformResponderCheck.IncrementAndGet();
 public override void HandleApplicationMessage(RawMessage message, IApplicationOutboundStream responder) =>
 Logger.Debug($"APP: Received application message: {message.AsTextMessage()}");