public TcpIncomingConnection(TcpExt tcp, 
                                     SocketChannel channel, 
                                     IChannelRegistry registry, 
                                     IActorRef bindHandler,
                                     IEnumerable<Inet.SocketOption> options, 
                                     bool readThrottling)
            : base(tcp, channel, readThrottling)
        {
            _bindHandler = bindHandler;
            _options = options;

            Context.Watch(bindHandler); // sign death pact

            registry.Register(channel, SocketAsyncOperation.None, Self);
        }
        public TcpIncomingConnection(TcpExt tcp,
                                     SocketChannel channel,
                                     IChannelRegistry registry,
                                     IActorRef bindHandler,
                                     IEnumerable <Inet.SocketOption> options,
                                     bool readThrottling)
            : base(tcp, channel, readThrottling)
        {
            _bindHandler = bindHandler;
            _options     = options;

            Context.Watch(bindHandler); // sign death pact

            registry.Register(channel, SocketAsyncOperation.None, Self);
        }
        public TcpOutgoingConnection(TcpExt tcp, IChannelRegistry channelRegistry, IActorRef commander, Tcp.Connect connect)
            : base(tcp, SocketChannel.Open().ConfigureBlocking(false), connect.PullMode)
        {
            _channelRegistry = channelRegistry;
            _commander = commander;
            _connect = connect;

            Context.Watch(commander);    // sign death pact

            connect.Options.ForEach(_ => _.BeforeConnect(Channel.Socket));
            if (connect.LocalAddress != null)
                Channel.Socket.Bind(connect.LocalAddress);
            channelRegistry.Register(Channel, SocketAsyncOperation.None, Self);
            if (connect.Timeout.HasValue)
                Context.SetReceiveTimeout(connect.Timeout.Value);  //Initiate connection timeout if supplied
        }
Exemple #4
0
 private void DoConnect(EndPoint address)
 {
     ReportConnectFailure(() =>
     {
         _channel = DatagramChannel.Open();
         _channel.ConfigureBlocking(false);
         var socket = _channel.Socket;
         _connect.Options.ForEach(x => x.BeforeDatagramBind(socket));
         if (_connect.LocalAddress != null)
         {
             socket.Bind(_connect.LocalAddress);
         }
         _channel.Connect(_connect.RemoteAddress);
         _channelRegistry.Register(_channel, SocketAsyncOperation.Receive, Self);
     });
     _log.Debug("Successfully connected to [{0}]", _connect.RemoteAddress);
 }
Exemple #5
0
        /// <summary>
        /// TBD
        /// </summary>
        /// <param name="udp">TBD</param>
        /// <param name="channelRegistry">TBD</param>
        /// <param name="commander">TBD</param>
        /// <param name="options">TBD</param>
        public UdpSender(UdpExt udp, IChannelRegistry channelRegistry, IActorRef commander, IEnumerable <Inet.SocketOption> options)
        {
            _udp       = udp;
            _commander = commander;
            _options   = options;

            _channel = new Func <DatagramChannel>(() =>
            {
                var datagramChannel = DatagramChannel.Open();
                datagramChannel.ConfigureBlocking(false);
                var socket = datagramChannel.Socket;
                _options.ForEach(x => x.BeforeDatagramBind(socket));

                return(datagramChannel);
            })();

            channelRegistry.Register(_channel, SocketAsyncOperation.None, Self);
        }
        public TcpOutgoingConnection(TcpExt tcp, IChannelRegistry channelRegistry, IActorRef commander, Tcp.Connect connect)
            : base(tcp, SocketChannel.Open().ConfigureBlocking(false), connect.PullMode)
        {
            _channelRegistry = channelRegistry;
            _commander       = commander;
            _connect         = connect;

            Context.Watch(commander);    // sign death pact

            connect.Options.ForEach(_ => _.BeforeConnect(Channel.Socket));
            if (connect.LocalAddress != null)
            {
                Channel.Socket.Bind(connect.LocalAddress);
            }
            channelRegistry.Register(Channel, SocketAsyncOperation.None, Self);
            if (connect.Timeout.HasValue)
            {
                Context.SetReceiveTimeout(connect.Timeout.Value);  //Initiate connection timeout if supplied
            }
        }
        public UdpListener(UdpExt udp, IChannelRegistry channelRegistry, IActorRef bindCommander, Udp.Bind bind)
        {
            _udp             = udp;
            _channelRegistry = channelRegistry;
            _bindCommander   = bindCommander;
            _bind            = bind;

            _selector = Context.Parent;

            Context.Watch(bind.Handler);        // sign death pact

            _channel = (bind.Options.OfType <Inet.DatagramChannelCreator>()
                        .FirstOrDefault() ?? new Inet.DatagramChannelCreator()).Create();
            _channel.ConfigureBlocking(false);

            var localAddress = new Func <object>(() =>
            {
                try
                {
                    var socket = Channel.Socket;
                    bind.Options.ForEach(x => x.BeforeDatagramBind(socket));
                    socket.Bind(bind.LocalAddress);
                    var ret = socket.LocalEndPoint;
                    if (ret == null)
                    {
                        throw new ArgumentException(string.Format("bound to unknown SocketAddress [{0}]", socket.LocalEndPoint));
                    }
                    channelRegistry.Register(Channel, SocketAsyncOperation.Receive, Self);
                    _log.Debug("Successfully bound to [{0}]", ret);
                    bind.Options.OfType <Inet.SocketOptionV2>().ForEach(x => x.AfterBind(socket));
                    return(ret);
                }
                catch (Exception e)
                {
                    bindCommander.Tell(new Udp.CommandFailed(bind));
                    _log.Error(e, "Failed to bind UDP channel to endpoint [{0}]", bind.LocalAddress);
                    Context.Stop(Self);
                    return(null);
                }
            })();
        }
 private Receive Connecting(ChannelRegistration registration, int remainingFinishConnectRetries)
 {
     return(message =>
     {
         if (message is SelectionHandler.ChannelConnectable)
         {
             ReportConnectFailure(() =>
             {
                 if (Channel.FinishConnect())
                 {
                     if (_connect.Timeout.HasValue)
                     {
                         Context.SetReceiveTimeout(null);
                     }
                     Log.Debug("Connection established to [{0}]", _connect.RemoteAddress);
                     CompleteConnect(registration, _commander, _connect.Options);
                 }
                 else
                 {
                     if (remainingFinishConnectRetries > 0)
                     {
                         var self = Self;
                         Context.System.Scheduler.Advanced.ScheduleOnce(1, () => _channelRegistry.Register(Channel, SocketAsyncOperation.Connect, self));
                         Context.Become(Connecting(registration, remainingFinishConnectRetries - 1));
                     }
                     else
                     {
                         Log.Debug("Could not establish connection because finishConnect never returned true (consider increasing akka.io.tcp.finish-connect-retries)");
                         Stop();
                     }
                 }
             });
             return true;
         }
         if (message is ReceiveTimeout)
         {
             if (_connect.Timeout.HasValue)
             {
                 Context.SetReceiveTimeout(null);                             // Clear the timeout
             }
             Log.Debug("Connect timeout expired, could not establish connection to [{0}]", _connect.RemoteAddress);
             Stop();
             return true;
         }
         return false;
     });
 }