Beispiel #1
0
        private async Task <AssociationHandle> StartClient(Address remoteAddress)
        {
            if (InternalTransport != TransportMode.Tcp)
            {
                throw new NotSupportedException("Currently Akka.Streams server supports only TCP transport mode.");
            }

            var addressFamily = Settings.DnsUseIpv6 ? AddressFamily.InterNetworkV6 : AddressFamily.InterNetwork;


            var socketAddress = RemotingAddressHelpers.AddressToSocketAddress(remoteAddress);

            socketAddress = await MapEndpointAsync(socketAddress).ConfigureAwait(false);

            // TODO: socket options
            var clientSource = System.TcpStream().OutgoingConnection(socketAddress, connectionTimeout: Settings.ConnectTimeout)
                               .AddAttributes(ActorAttributes.CreateDispatcher(System.Settings.Config.GetString("akka.remote.use-dispatcher")));

            var joined = clientSource.JoinMaterialized(
                StreamTransportFlows.OutboundConnectionHandler(this, remoteAddress, socketAddress), (connectTask, associate) => (connectTask, associate))
                         .Join(Flow.Create <Google.Protobuf.ByteString>().Where(_ => true))
                         .Run(StreamMaterializer);

            await joined.connectTask.ConfigureAwait(false);

            return(await joined.associate.ConfigureAwait(false));
        }
            public override void PreStart()
            {
                // keep going even if the upstream is finished
                // so we can process the queued elements
                SetKeepGoing(true);

                // Request the first element
                Pull(_sink.In);

                var localAddress = RemotingAddressHelpers.MapSocketToAddress((IPEndPoint)_sink._localAddress,
                                                                             _sink._transport.SchemeIdentifier, _sink._transport.System.Name,
                                                                             _sink._transport.Settings.Hostname);

                if (localAddress != null)
                {
                    var cb = GetAsyncCallback <IHandleEventListener>(SetListener);

                    var handle = CreateAssociationHandle(_sink._transport, _sink._sourceRef, localAddress,
                                                         _sink._remoteAddress);
                    handle.ReadHandlerSource.Task.ContinueWith(tr =>
                    {
                        cb(tr.Result); // safely marshall back into the stage
                    }, TaskContinuationOptions.ExecuteSynchronously | TaskContinuationOptions.NotOnCanceled | TaskContinuationOptions.NotOnFaulted);
                }
                else
                {
                    _sink._transport.System.Stop(_sink._sourceRef);
                    FailStage(new InvalidAssociationException($"Unable to parse [{_sink._localAddress}] into Akka.NET address."));
                }
            }