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();
}
