public Server(string address, int port, IClientListener <Request, Response> listener, ISerializeProcessor sp, bool isIPAddressAny) { this._address = address; this._port = port; this._lisenter = listener; this.SP = sp; this.isAnyIPAddress = isIPAddressAny || string.IsNullOrEmpty(_address); var excutor = new TryCatchExecutor((e) => { //Console.Write(e); }); var bootStrapper = new ServerBootstrap() .Executor(excutor) .SetTransport(System.Net.TransportType.Tcp) .Build(); _server = bootStrapper.NewReactor( NodeBuilder.BuildNode() .Host(isIPAddressAny? IPAddress.Any:IPAddress.Parse(_address)) .WithPort(port) ); _server.OnConnection += _server_OnConnection;; _server.OnDisconnection += TempServer_OnDisconnection; }
private static void Main(string[] args) { Port = args.Length < 1 ? DEFAULT_PORT : int.Parse(args[0]); var ip = IPAddress.Any; Console.WriteLine("Starting echo server..."); Console.WriteLine("Will begin listening for requests on {0}:{1}", ip, Port); var bootstrapper = new ServerBootstrap() .WorkerThreads(2) .SetTransport(TransportType.Udp) .Build(); var reactor = bootstrapper.NewReactor(NodeBuilder.BuildNode().Host(ip).WithPort(Port)); reactor.OnConnection += (node, connection) => { ServerPrint(node, string.Format("Accepting connection from... {0}:{1}", node.Host, node.Port)); connection.BeginReceive(Receive); }; reactor.OnDisconnection += (reason, address) => ServerPrint(address.RemoteHost, string.Format("Closed connection to... {0}:{1} [Reason:{2}]", address.RemoteHost.Host, address.RemoteHost.Port, reason.Type)); reactor.Start(); Console.ReadKey(); }
public void Should_find_two_equivalent_nodes_as_equal() { var node1 = NodeBuilder.BuildNode().Host(IPAddress.Loopback).WithPort(1337); var node2 = NodeBuilder.FromEndpoint(new IPEndPoint(IPAddress.Loopback, 1337)); Assert.IsTrue(node1.Equals(node2)); }
public override Task <Tuple <Address, TaskCompletionSource <IAssociationEventListener> > > Listen() { var listenAddress = NodeBuilder.BuildNode().Host(Settings.Hostname).WithPort(Settings.Port); var publicAddress = NodeBuilder.BuildNode().Host(Settings.PublicHostname).WithPort(Settings.Port); var newServerChannel = NewServer(listenAddress); newServerChannel.Open(); publicAddress.Port = newServerChannel.Local.Port; //use the port assigned by the transport //Block reads until a handler actor is registered //TODO ConnectionGroup.TryAdd(newServerChannel); ServerChannel = newServerChannel; var addr = NodeToAddress(publicAddress, SchemeIdentifier, System.Name, Settings.PublicHostname); if (addr == null) { throw new HeliosNodeException("Unknown local address type {0}", newServerChannel.Local); } LocalAddress = addr; AssociationListenerPromise.Task.ContinueWith(result => ServerChannel.BeginReceive(), TaskContinuationOptions.AttachedToParent & TaskContinuationOptions.ExecuteSynchronously); return(Task.Run(() => Tuple.Create(addr, AssociationListenerPromise))); }
public bool AttemptConnect(string host, string portStr) { try { var port = int.Parse(portStr); RemoteHost = NodeBuilder.BuildNode().Host(host).WithPort(port).WithTransportType(TransportType.Tcp); Connection = new ClientBootstrap() .SetTransport(TransportType.Tcp) .RemoteAddress(RemoteHost) .OnConnect(ConnectionEstablishedCallback) .OnReceive(ReceivedDataCallback) .OnDisconnect(ConnectionTerminatedCallback) .Build().NewConnection(NodeBuilder.BuildNode().Host(IPAddress.Any).WithPort(10001), RemoteHost); Connection.Open(); return(true); } catch (Exception ex) { AppendStatusText(ex.Message); AppendStatusText(ex.StackTrace); AppendStatusText(ex.Source); return(false); } }
private static void Main(string[] args) { var host = IPAddress.Any; var port = 9991; Console.Title = "Server"; Console.WriteLine("Starting server on {0}:{1}", host, port); var executor = new TryCatchExecutor(exception => Console.WriteLine("Unhandled exception: {0}", exception)); var bootstrapper = new ServerBootstrap() .WorkerThreads(2) .Executor(executor) .SetTransport(TransportType.Tcp) .Build(); var server = bootstrapper.NewReactor(NodeBuilder.BuildNode().Host(host).WithPort(port)); server.OnConnection += (address, connection) => { Console.WriteLine("Connected: {0}", address); connection.BeginReceive(Receive); }; server.OnDisconnection += (reason, address) => Console.WriteLine("Disconnected: {0}; Reason: {1}", address.RemoteHost, reason.Type); server.Start(); Console.WriteLine("Running, press any key to exit"); Console.ReadKey(); Console.WriteLine("Shutting down..."); server.Stop(); Console.WriteLine("Terminated"); }
public static INode AddressToNode(Address address) { if (address == null || string.IsNullOrEmpty(address.Host) || !address.Port.HasValue) { throw new ArgumentException("Must have valid host and port information", "address"); } return(NodeBuilder.BuildNode().Host(address.Host).WithPort(address.Port.Value)); }
public void Should_find_two_equivalent_INodes_in_dictionary_without_reference_equality() { var node1 = NodeBuilder.BuildNode().Host(IPAddress.Loopback).WithPort(1337); var node2 = NodeBuilder.FromEndpoint(new IPEndPoint(IPAddress.Loopback, 1337)); var nodeDict = new Dictionary <INode, string>(); nodeDict.Add(node1, "test!"); Assert.AreEqual("test!", nodeDict[node2]); }
public void UdpProxyServer_should_bind_to_ephemeral_port() { var server = new ServerBootstrap().SetTransport(TransportType.Udp) .Build() .NewReactor(NodeBuilder.BuildNode().Host(IPAddress.Any).WithPort(0)); server.Start(); Assert.NotEqual(0, server.LocalEndpoint.Port); server.Stop(); }
public void Should_resolve_remote_hostname_to_IP() { //arrange var testNode = NodeBuilder.BuildNode().Host("yahoo.com").WithPort(80).WithTransportType(TransportType.Tcp); //act //assert Assert.IsNotNull(testNode.Host); }
public void Should_throw_exception_when_connecting_to_unreachable_node() { //arrange var node = NodeBuilder.BuildNode().Host(IPAddress.Loopback).WithPort(11111); var connection = node.GetConnection(); //act connection.Open(); //assert }
public void TcpProxyServer_connection_adapter_should_bind_to_ephemeral_port() { var server = new ServerBootstrap().SetTransport(TransportType.Tcp) .Build() .NewReactor(NodeBuilder.BuildNode().Host(IPAddress.Any).WithPort(0)) .ConnectionAdapter; server.Open(); Assert.NotEqual(0, server.Local.Port); server.Close(); }
public void Should_resolve_localhost_hostname_to_IP() { //arrange var testNode = NodeBuilder.BuildNode().Host("localhost").WithPort(1337).WithTransportType(TransportType.Udp); var expectNode = NodeBuilder.BuildNode().Host(IPAddress.Loopback).WithPort(1337).WithTransportType(TransportType.Udp); //act //assert Assert.AreEqual(expectNode, testNode); }
public SocketClient() { InitializeComponent(); Connection = new ClientBootstrap() .SetTransport(TransportType.Udp) .RemoteAddress(Node.Loopback()) .OnConnect(ConnectionEstablishedCallback) .OnReceive(ReceivedDataCallback) .OnDisconnect(ConnectionTerminatedCallback) .Build().NewConnection(NodeBuilder.BuildNode().Host(IPAddress.Any).WithPort(10001), RemoteHost); Connection.OnError += ConnectionOnOnError; Connection.Open(); }
public void Helios20_Server_and_Helios14_Client_Should_ReadWrite() { IConnection client = null; IChannel server = null; try { server = _serverBootstrap.BindAsync(new IPEndPoint(IPAddress.Loopback, 0)).Result; var serverAddress = (IPEndPoint)server.LocalAddress; client = _clientBootstrap.NewConnection( NodeBuilder.BuildNode().Host(IPAddress.Loopback).WithPort(serverAddress.Port)); var actualReadCount = 0; client.Receive += (data, channel) => { _received.Add(Unpooled.WrappedBuffer(data.Buffer)); if (++actualReadCount == ReadCount) { _resetEvent.Set(); } }; client.OnConnection += (address, channel) => { channel.BeginReceive(); }; client.Open(); var writes = Enumerable.Range(0, ReadCount) .Select(x => ThreadLocalRandom.Current.Next()) .OrderBy(y => y) .ToList(); foreach (var write in writes) { client.Send(Unpooled.Buffer(4).WriteInt(write).Array, 0, 4, null); } _resetEvent.Wait(); var decodedReceive = _received.Select(y => y.ReadInt()).OrderBy(x => x).ToList(); Assert.True(decodedReceive.SequenceEqual(writes)); } finally { client?.Close(); server?.CloseAsync().Wait(); _serverGroup.ShutdownGracefullyAsync().Wait(); } }
public void Should_convert_valid_ipv6_tcp_INode_to_NodeUri() { //arrange var testNode = NodeBuilder.BuildNode().Host(IPAddress.IPv6Loopback).WithPort(1337).WithTransportType(TransportType.Tcp); //act var nodeUri = new NodeUri(testNode); //assert Assert.Equal(testNode.Port, nodeUri.Port); Assert.Equal(string.Format("[{0}]", testNode.Host), nodeUri.Host); Assert.Equal("tcp", nodeUri.Scheme); Assert.True(nodeUri.IsLoopback); }
public void UdpConnection_should_bind_to_outbound_ephemeral_port() { var serverAddress = NodeBuilder.BuildNode().Host(IPAddress.Loopback).WithPort(13171); var server = new ServerBootstrap().SetTransport(TransportType.Udp).Build().NewReactor(serverAddress); var connection = new ClientBootstrap().SetTransport(TransportType.Udp) .Build() .NewConnection(Node.Loopback(), serverAddress); server.Start(); connection.Open(); Assert.NotEqual(0, connection.Local.Port); connection.Close(); server.Stop(); }
public void Should_convert_valid_UDP_INode_to_NodeUri() { //arrange var testNode = NodeBuilder.BuildNode().Host(IPAddress.Loopback).WithPort(1337).WithTransportType(TransportType.Udp); //act var nodeUri = new NodeUri(testNode); //assert Assert.Equal(testNode.Port, nodeUri.Port); Assert.Equal(testNode.Host.ToString(), nodeUri.Host); Assert.Equal("udp", nodeUri.Scheme); Assert.True(nodeUri.IsLoopback); }
public override void ConnectToServer() { RemoteHost = NodeBuilder.BuildNode() .Host(this.Config.Address) .WithPort(this.Config.Port) .WithTransportType(System.Net.TransportType.Tcp); Connection = new ClientBootstrap() .SetTransport(System.Net.TransportType.Tcp) .RemoteAddress(RemoteHost) .OnConnect(ConnectionEstablishedCallback) .OnDisconnect(ConnectionTerminatedCallback) .Build() .NewConnection(RemoteHost); Connection.Open(); }
public bool AttemptConnect(string host, string portStr) { try { var port = Int32.Parse(portStr); RemoteHost = NodeBuilder.BuildNode().Host(host).WithPort(port).WithTransportType(TransportType.Udp); return(true); } catch (Exception ex) { AppendStatusText(ex.Message); AppendStatusText(ex.StackTrace); AppendStatusText(ex.Source); return(false); } }
private bool AttemptConnect(string connectString) { try { if (_connectionDictionary.ContainsKey(connectString) && _nodeDictionary.ContainsKey(connectString)) { // 이미 만들어진 엔트리가 있는 경우 return(true); } var rxConnectString = rx.Match(connectString); if (rxConnectString.Success) { IPAddress host = IPAddress.Parse(rxConnectString.Groups[1].Value); int port = int.Parse(rxConnectString.Groups[2].Value); INode remoteHost = NodeBuilder.BuildNode() .Host(host) .WithPort(port) .WithTransportType(TransportType.Udp); _nodeDictionary[connectString] = remoteHost; IConnection connection = _connectionFactory.NewConnection( NodeBuilder.BuildNode() .Host(IPAddress.Any) .WithPort(10001), remoteHost); connection.Open(); _connectionDictionary[connectString] = connection; } else { // connectString 이 잘못된 경우이니 로그를 남기든지 한다. return(false); } return(true); } catch (Exception ex) { //AppendStatusText(ex.Message); //AppendStatusText(ex.StackTrace); //AppendStatusText(ex.Source); return(false); } }
/// <summary> /// 启动一个通信 /// </summary> /// <param name="nodeConfig"></param> public virtual bool StartReactor(NodeConfig nodeConfig) { try { var bootstrapper = new ServerBootstrap() .WorkerThreads(2) .Build(); reactor = bootstrapper.NewReactor(NodeBuilder.BuildNode().Host(nodeConfig)); reactor.ConnectionAdapter = new ProtocolUT("12", (ReactorBase)reactor); reactor.Start(); connectionAdapter = reactor.ConnectionAdapter; return(true); } catch (Exception ex) { Console.WriteLine(ex.ToString()); } return(false); }
public ConnectionWorker(String server, Int32 port) { Server = server; Port = port; // Create the client RemoteHost = NodeBuilder.BuildNode().Host(Server).WithPort(port).WithTransportType(TransportType.Tcp); Client = (TcpConnection) new ClientBootstrap() .SetTransport(TransportType.Tcp) .RemoteAddress(RemoteHost) .OnConnect(ConnectionEstablishedCallback) .OnReceive(ReceivedDataCallback) .OnDisconnect(ConnectionTerminatedCallback) .Build() .NewConnection(NodeBuilder.BuildNode().Host(IPAddress.Any).WithPort(port), RemoteHost); Client.NoDelay = true; Client.ReceiveBufferSize = 8192; Client.Open(); }
/// <summary>开始客户端 /// /// </summary> public static void StartClient() { var host = IPAddress.Loopback; const int port = 9991; var connectionFactory = new ClientBootstrap().SetTransport(TransportType.Tcp).Build(); //New一个Client _client = connectionFactory.NewConnection(Node.Empty(), NodeBuilder.BuildNode().Host(host).WithPort(port)); _client.OnConnection += (address, connection) => { connection.BeginReceive(Received); }; _client.OnDisconnection += (address, reason) => { }; //建立连接 _client.Open(); //加入服务端组 Join(); //等待输入 //WaitInput(); }
/// <summary> /// 启动一个通信 /// </summary> /// <param name="nodeConfig"></param> public bool StartReactor(NodeConfig nodeConfig) { try { var bootstrapper = new ServerBootstrap() .WorkerThreads(2) //.SetConfig(new DefaultConnectionConfig().SetOption(OptionKeyEnums.ParseTimeOut.ToString(), 5)) .Build(); reactor = bootstrapper.NewReactor(NodeBuilder.BuildNode().Host(nodeConfig)); reactor.ConnectionAdapter = new ProtocolUT("SerialProtocol", (ReactorBase)reactor); reactor.Start(); connectionAdapter = reactor.ConnectionAdapter; return(true); } catch (Exception ex) { Console.WriteLine(ex.ToString()); } return(false); }
public void Should_throw_exception_when_connecting_to_unreachable_node() { //arrange var node = NodeBuilder.BuildNode().Host(IPAddress.Loopback).WithPort(11111); var connection = node.GetConnection(); var boolDisconnected = false; var resetEvent = new AutoResetEvent(false); connection.OnDisconnection += delegate(HeliosConnectionException reason, IConnection channel) { boolDisconnected = true; resetEvent.Set(); }; //act connection.Open(); resetEvent.WaitOne(); //assert Assert.True(boolDisconnected); }
private void btnStartServer_Click(object sender, EventArgs e) { var host = IPAddress.Any; var port = 9991; lblTxt.Text = string.Format("开启服务 {0}:{1}", host, port); var serverFactory = new ServerBootstrap() .SetTransport(TransportType.Tcp) .Build(); server = serverFactory.NewReactor(NodeBuilder.BuildNode().Host(host).WithPort(port)); server.OnConnection += (address, connection) => { connection.BeginReceive(Receive); }; server.OnDisconnection += (reason, address) => { }; //MessageBox.Show(string.Format("断开连接: {0}; 原因: {1}", address.RemoteHost, reason.Type)); server.Start(); }
public void Should_not_throw_exception_when_connecting_via_ipv6() { // arrange var node = NodeBuilder.BuildNode().Host(IPAddress.IPv6Loopback).WithPort(11111); var connection = node.GetConnection(); var boolDisconnected = false; var resetEvent = new AutoResetEvent(false); connection.OnDisconnection += delegate { boolDisconnected = true; resetEvent.Set(); }; // act connection.Open(); resetEvent.WaitOne(); // assert Assert.True(boolDisconnected); }
public void Helios20_Client_and_Helios14_Server_Should_ReadWrite() { IReactor server = null; IChannel client = null; try { server = _serverBootstrap.NewReactor(NodeBuilder.BuildNode().Host(IPAddress.Loopback).WithPort(0)); server.OnReceive += (data, channel) => { // echo the response back channel.Send(data); }; server.OnConnection += (address, channel) => { channel.BeginReceive(); }; server.Start(); client = _clientBootstrap.ConnectAsync(server.LocalEndpoint).Result; Task.Delay(TimeSpan.FromMilliseconds(500)).Wait(); // because Helios 1.4 is stupid var writes = Enumerable.Range(0, ReadCount) .Select(x => ThreadLocalRandom.Current.Next()) .OrderBy(y => y) .ToList(); foreach (var write in writes) { client.WriteAndFlushAsync(Unpooled.Buffer(4).WriteInt(write)); } _resetEvent.Wait(); var decodedReceive = _received.Select(y => y.ReadInt()).OrderBy(x => x).ToList(); Assert.True(decodedReceive.SequenceEqual(writes)); } finally { client?.CloseAsync().Wait(); server?.Stop(); _clientGroup.ShutdownGracefullyAsync().Wait(); } }
private void Run() { var bootstrapper = new ServerBootstrap() .WorkerThreads(4) .SetTransport(TransportType.Udp) .Build(); _reactor = bootstrapper.NewReactor( NodeBuilder.BuildNode() .Host(HostIp) .WithPort(HostPort)); _reactor.OnConnection += (node, connection) => { //ServerPrint(node, // string.Format("Accepting connection from... {0}:{1}", node.Host, node.Port)); connection.BeginReceive(UdpPackerReceiveCallback); }; //reactor.OnDisconnection += (reason, address) => ServerPrint(address.RemoteHost, // string.Format("Closed connection to... {0}:{1} [Reason:{2}]", address.RemoteHost.Host, address.RemoteHost.Port, reason.Type)); _reactor.Start(); }
private void BuildNode(WorkflowDefinitionBuilder workflowBuilder, NodeBuilder nodeBuilder, NodeModel node) { nodeBuilder.BuildNode(); }