public ServiceItem(RPCServer server, Type serviceType, object serviceInstance)
{
_server = server;
ServiceInstance = serviceInstance;
ServiceType = serviceType;
Descriptor = ServiceDescriptor.GetDescriptor(ServiceType, server._counterCategory, server._counterLevel, server._counterKind);
}
static void Main(string[] args)
{
int port = 11111;
int count = 1;
RPCServer rPCServer = new RPCServer(port);
rPCServer.RegisterService <IHello, Hello>();
rPCServer.Start();
Stopwatch watch = new Stopwatch();
var client = RPCClientFactory.GetClient <IHello>("127.0.0.1", port);
client.SayHello("Hello");
watch.Start();
LoopHelper.Loop(count, () =>
{
var res = client.SayHello("Hello");
//Console.WriteLine($"{DateTime.Now.ToString("HH:mm:ss:fff")}客户端:{res}");
});
watch.Stop();
Console.WriteLine($"耗时:{(double)watch.ElapsedMilliseconds/count}ms");
Console.ReadLine();
}
public void ValidHelloMessage()
{
var responseStream = new MemoryStream();
var stream = new TestStream(new MemoryStream(helloMessage), responseStream);
// Create mock byte server and client
var mockByteServer = new Mock <IServer <byte, byte> > ();
var byteServer = mockByteServer.Object;
var byteClient = new TestClient(stream);
var server = new RPCServer(byteServer);
server.OnClientRequestingConnection += (sender, e) => e.Request.Allow();
server.Start();
// Fire a client connection event
var eventArgs = new ClientRequestingConnectionEventArgs <byte, byte> (byteClient);
mockByteServer.Raise(m => m.OnClientRequestingConnection += null, eventArgs);
Assert.IsTrue(eventArgs.Request.ShouldAllow);
Assert.IsFalse(eventArgs.Request.ShouldDeny);
server.Update();
Assert.AreEqual(1, server.Clients.Count());
Assert.AreEqual("Jebediah Kerman!!!", server.Clients.First().Name);
byte[] bytes = responseStream.ToArray();
byte[] responseBytes = byteClient.Guid.ToByteArray();
Assert.IsTrue(responseBytes.SequenceEqual(bytes));
}
public ServiceItem(RPCServer server, Type serviceType, object serviceInstance)
{
_server = server;
ServiceInstance = serviceInstance;
ServiceType = serviceType;
Descriptor = ServiceDescriptor.GetDescriptor(ServiceType);
}
static void Main(string[] args)
{
Action <Exception> handleException = ex =>
{
Console.WriteLine(ex.Message);
};
int port = 9999;
int count = 1000000;
RPCServer rPCServer = new RPCServer(port);
rPCServer.RegisterService <IHello, Hello>();
rPCServer.Start();
IHello client = null;
Stopwatch watch = new Stopwatch();
watch.Start();
LoopHelper.Loop(count, () =>
{
client = RPCClientFactory.GetClient <IHello>("127.0.0.1", port);
});
watch.Stop();
//var res = client.SayHello("Hello");
//Console.WriteLine($"客户端:{res}");
Console.WriteLine($"耗时:{watch.ElapsedMilliseconds}ms");
Console.ReadLine();
Console.WriteLine("完成");
Console.ReadLine();
}
public void NoHelloMessage()
{
var responseStream = new MemoryStream();
var stream = new TestStream(new MemoryStream(), responseStream);
// Create mock byte server and client
var mockByteServer = new Mock <IServer <byte, byte> > ();
var byteServer = mockByteServer.Object;
var mockByteClient = new Mock <IClient <byte, byte> > ();
mockByteClient.Setup(x => x.Stream).Returns(stream);
var byteClient = mockByteClient.Object;
var server = new RPCServer(byteServer);
server.OnClientRequestingConnection += (sender, e) => e.Request.Allow();
server.Start();
// Fire a client connection event
var eventArgs = new ClientRequestingConnectionEventArgs <byte, byte> (byteClient);
mockByteServer.Raise(m => m.OnClientRequestingConnection += null, eventArgs);
Assert.IsFalse(eventArgs.Request.ShouldAllow);
Assert.IsTrue(eventArgs.Request.ShouldDeny);
Assert.AreEqual(0, responseStream.Length);
}
static void Main(string[] args)
{
#if !DEBUG
AppDomain.CurrentDomain.UnhandledException += UnhandledExceptionHandler; // Catch any unhandled exceptions.
#endif
Thread.CurrentThread.CurrentCulture = CultureInfo.InvariantCulture; // Use invariant culture - we have to set it explicitly for every thread we create to prevent any file-reading problems (mostly because of number formats).
Console.ForegroundColor = ConsoleColor.Yellow;
ConsoleWindow.PrintBanner();
ConsoleWindow.PrintLicense();
Console.ResetColor();
InitLogging();
Log.Information("Coinium {0} warming-up..", Assembly.GetAssembly(typeof(Program)).GetName().Version);
Log.Information(string.Format("Running over {0} {1}.", PlatformManager.Framework, PlatformManager.FrameworkVersion));
var server = new RPCServer();
server.Listen("0.0.0.0", 3333);
//var client = new WalletClient("http://127.0.0.1:9335", "devel", "develpass");
//client.GetInfo();
Console.ReadLine();
}
public void WrongConnectionType()
{
var connectionMessage = TestingTools.CreateConnectionRequest(Type.Stream);
var responseStream = new MemoryStream();
var stream = new TestStream(new MemoryStream(connectionMessage), responseStream);
// Create mock byte server and client
var mockByteServer = new Mock <IServer <byte, byte> > ();
var byteServer = mockByteServer.Object;
var mockByteClient = new Mock <IClient <byte, byte> > ();
mockByteClient.Setup(x => x.Stream).Returns(stream);
var byteClient = mockByteClient.Object;
var server = new RPCServer(byteServer);
server.OnClientRequestingConnection += (sender, e) => e.Request.Allow();
server.Start();
// Fire a client connection event
var eventArgs = new ClientRequestingConnectionEventArgs <byte, byte> (byteClient);
mockByteServer.Raise(m => m.OnClientRequestingConnection += null, eventArgs);
Assert.IsFalse(eventArgs.Request.ShouldAllow);
Assert.IsTrue(eventArgs.Request.ShouldDeny);
TestingTools.CheckConnectionResponse(responseStream.ToArray(), 120, Status.WrongType,
"Connection request was for the stream server, but this is the rpc server. " +
"Did you connect to the wrong port number?", 0);
}
static void Main(string[] args)
{
RPCServer rpcServer = new RPCServer();
Console.WriteLine("server started");
Console.ReadLine();
}
public void ValidConnectionMessage()
{
var responseStream = new MemoryStream();
var stream = new TestStream(new MemoryStream(TestingTools.CreateConnectionRequest(Type.Rpc)), responseStream);
// Create mock byte server and client
var mockByteServer = new Mock <IServer <byte, byte> > ();
var byteServer = mockByteServer.Object;
var byteClient = new TestClient(stream);
var server = new RPCServer(byteServer);
server.OnClientRequestingConnection += (sender, e) => e.Request.Allow();
server.Start();
// Fire a client connection event
var eventArgs = new ClientRequestingConnectionEventArgs <byte, byte> (byteClient);
mockByteServer.Raise(m => m.OnClientRequestingConnection += null, eventArgs);
Assert.IsTrue(eventArgs.Request.ShouldAllow);
Assert.IsFalse(eventArgs.Request.ShouldDeny);
server.Update();
Assert.AreEqual(1, server.Clients.Count());
Assert.AreEqual("Jebediah Kerman!!!", server.Clients.First().Name);
TestingTools.CheckConnectionResponse(responseStream.ToArray(), 19, Status.Ok, string.Empty, 16);
}
public void ShortConnectionMessageHeader()
{
var connectionMessage = new byte[5];
Array.Copy(TestingTools.CreateConnectionRequest(Type.Rpc), connectionMessage, connectionMessage.Length);
var responseStream = new MemoryStream();
var stream = new TestStream(new MemoryStream(connectionMessage), responseStream);
// Create mock byte server and client
var mockByteServer = new Mock <IServer <byte, byte> > ();
var byteServer = mockByteServer.Object;
var mockByteClient = new Mock <IClient <byte, byte> > ();
mockByteClient.Setup(x => x.Stream).Returns(stream);
var byteClient = mockByteClient.Object;
var server = new RPCServer(byteServer);
server.OnClientRequestingConnection += (sender, e) => e.Request.Allow();
server.Start();
// Fire a client connection event
var eventArgs = new ClientRequestingConnectionEventArgs <byte, byte> (byteClient);
mockByteServer.Raise(m => m.OnClientRequestingConnection += null, eventArgs);
Assert.IsFalse(eventArgs.Request.ShouldAllow);
Assert.IsFalse(eventArgs.Request.ShouldDeny);
Assert.AreEqual(responseStream.ToArray().Length, 0);
}
public void InvalidHelloMessageName()
{
helloMessage [15] = 0x00;
var responseStream = new MemoryStream ();
var stream = new TestStream (new MemoryStream (helloMessage), responseStream);
// Create mock byte server and client
var mockByteServer = new Mock<IServer<byte,byte>> ();
var byteServer = mockByteServer.Object;
var mockByteClient = new Mock<IClient<byte,byte>> ();
mockByteClient.Setup (x => x.Stream).Returns (stream);
var byteClient = mockByteClient.Object;
var server = new RPCServer (byteServer);
server.OnClientRequestingConnection += (sender, e) => e.Request.Allow ();
server.Start ();
// Fire a client connection event
var eventArgs = new ClientRequestingConnectionArgs<byte,byte> (byteClient);
mockByteServer.Raise (m => m.OnClientRequestingConnection += null, eventArgs);
Assert.IsFalse (eventArgs.Request.ShouldAllow);
Assert.IsTrue (eventArgs.Request.ShouldDeny);
Assert.AreEqual (0, responseStream.Length);
}
static void Main(string[] args)
{
RPCServer.Open("TestRPCConcurrent", new Handler());
Console.WriteLine("已启动TestRPCConcurrent的服务，按任意键退出");
Console.ReadLine();
RPCServer.Close("TestRPCConcurrent");
}
static void Main(string[] args)
{
RPCServer.Open("getName2", new Handler());
Console.WriteLine("已启动getName2的服务，按任意键退出");
Console.ReadLine();
RPCServer.Close("getName2");
}
static void Main(string[] args)
{
RPCServer rPCServer = new RPCServer(39999);
rPCServer.RegisterService <IHello, Hello>();
rPCServer.Start();
Console.ReadLine();
}
private static void CleanupRPCServers()
{
var services = ServiceAttribute.GetServics();
foreach (var service in services)
{
RPCServer.Close(service);
}
}
static void Main(string[] args)
{
RPCServer server = new RPCServer("127.0.0.1", 3000, 4000, 1024 * 64);
server.RegServiceModule(new TalkService());
server.MsgOut += Server_MsgOut;
server.Start();
Console.ReadLine();
}
static void Main(string[] args)
{
RPCServer server = new RPCServer();
server.RegServiceModule(new ServerClass());
server.ReadOutTime = 2000; //设置超时时间
server.Start();
Console.ReadLine();
}
private static void InitRPCServers()
{
var services = ServiceAttribute.GetServics();
foreach (var service in services)
{
RPCServer.Open(service, MQServiceHandler.Instance);
}
}
static void Main(string[] args)
{
Console.WriteLine("我是服务端:");
RPCServer rPCServer = new RPCServer(9999);
rPCServer.RegisterService<IHello, Hello>();
rPCServer.Start();
Console.ReadLine();
}
static void Main(string[] args)
{
RPCServer rPCServer = new RPCServer(CommonHelper.DotNettyPort);
rPCServer.RegisterService <IHello, Hello>();
rPCServer.Start();
Console.WriteLine($"RpcServer started on {CommonHelper.DotNettyPort}");
Console.ReadLine();
}
internal KRPCServer(IPAddress address, ushort rpcPort, ushort streamPort,
bool oneRPCPerUpdate = false, uint maxTimePerUpdate = 5000, bool adaptiveRateControl = true, bool blockingRecv = true, uint recvTimeout = 1000)
{
rpcTcpServer = new TCPServer ("RPCServer", address, rpcPort);
streamTcpServer = new TCPServer ("StreamServer", address, streamPort);
rpcServer = new RPCServer (rpcTcpServer);
streamServer = new StreamServer (streamTcpServer);
clientScheduler = new RoundRobinScheduler<IClient<Request,Response>> ();
continuations = new List<RequestContinuation> ();
streamRequests = new Dictionary<IClient<byte,StreamMessage>,IList<StreamRequest>> ();
OneRPCPerUpdate = oneRPCPerUpdate;
MaxTimePerUpdate = maxTimePerUpdate;
AdaptiveRateControl = adaptiveRateControl;
BlockingRecv = blockingRecv;
RecvTimeout = recvTimeout;
// Tie events to underlying server
rpcServer.OnStarted += (s, e) => {
if (OnStarted != null)
OnStarted (this, EventArgs.Empty);
};
rpcServer.OnStopped += (s, e) => {
if (OnStopped != null)
OnStopped (this, EventArgs.Empty);
};
rpcServer.OnClientRequestingConnection += (s, e) => {
if (OnClientRequestingConnection != null)
OnClientRequestingConnection (s, e);
};
rpcServer.OnClientConnected += (s, e) => {
if (OnClientConnected != null)
OnClientConnected (s, e);
};
rpcServer.OnClientDisconnected += (s, e) => {
if (OnClientDisconnected != null)
OnClientDisconnected (s, e);
};
// Add/remove clients from the scheduler
rpcServer.OnClientConnected += (s, e) => clientScheduler.Add (e.Client);
rpcServer.OnClientDisconnected += (s, e) => clientScheduler.Remove (e.Client);
// Add/remove clients from the list of stream requests
streamServer.OnClientConnected += (s, e) => streamRequests [e.Client] = new List<StreamRequest> ();
streamServer.OnClientDisconnected += (s, e) => streamRequests.Remove (e.Client);
// Validate stream client identifiers
streamServer.OnClientRequestingConnection += (s, e) => {
if (rpcServer.Clients.Where (c => c.Guid == e.Client.Guid).Any ())
e.Request.Allow ();
else
e.Request.Deny ();
};
}
static void Main(string[] args)
{
RPCServer rPCServer = new RPCServer(9999);
rPCServer.RegisterService <IHello, Hello>();
rPCServer.RegisterService <IOrderService, OrderService>();
rPCServer.Start();
Console.WriteLine(".netCore ecf DotNettyRPC start!");
Console.ReadLine();
}
static void Main(string[] args)
{
LogAction.LogOut += LogAction_LogOut;
RPCServer server = new RPCServer("any", 3000, 4000, 1024 * 64, 1024 * 1024);
server.RegServiceModule(new TalkService());
server.IsUseTask = false; //如果不搞 C1-->S--->C1 并且是同步访问的 就不要设置为TRUE
server.IsCallReturn = false; //服务器不允许调用客户端同步等待函数
server.Start();
Console.ReadLine();
}
static void Main(string[] args)
{
LogAction.LogOut += LogAction_LogOut;
RPCServer server = new RPCServer("127.0.0.1", 3000, 4000, 1024 * 64, 1024 * 1024);
server.RegServiceModule(new TalkService());
server.IsUseTask = true; //如果不搞 client call-->Server call(not return)--->client， 并且是同步访问的 就不要设置为TRUE 否则会浪费CPU
server.IsCallReturn = true; //服务器是否允许调用客户端同步等待函数
server.Start();
Console.ReadLine();
}
public WinServ()
{
InitializeComponent();
LogAction.LogOut += LogAction_LogOut;
Server = new RPCServer();
Server.IsCanConn += Server_IsCanConn;
Service.UpdateUserList += Service_UpdateUserList;
Server.RegServiceModule(Service);
}
static void DotNettyRPCTest()
{
RPCServer rpcServer = new RPCServer(9999);
rpcServer.RegisterService <IOrderService, OrderService>();
rpcServer.Start();
IOrderService client = RPCClientFactory.GetClient <IOrderService>("127.0.0.1", 9999);
var res = client.CalculateFinalOrderSum(9, 3);
Console.ReadLine();
}
public void ExceptionMehodCalled_ReturnsException()
{
using (var server = new RPCServer <string, string>(_factory, _converter, "integrationBroker", "rpcTestQueue"))
{
server.Start(Exception);
using (var client = new RPCClient <string, string>(_factory, _converter, "integrationBroker", "rpcTestQueue"))
{
Assert.Throws <Exception>(() => client.Call("test"));
}
}
}
static void Main(string[] args)
{
try
{
RPCServer rpcServer = new RPCServer("127.0.0.1", 2016);
rpcServer.StartServer();
}
catch (Exception ex)
{
Console.WriteLine(" $$ " + " Unexpected error occured " + ex.Message.ToString());
}
}
private NexusAPI SetupNexusApi()
{
var apiCache = Settings.Node.ApiCache;
var apiLog = Settings.Node.ApiLog;
var apiProxyURL = Settings.Node.ApiProxyUrl;
var readOnlyMode = Settings.Node.Readonly;
var hasRPC = Settings.Node.HasRpc;
var hasREST = Settings.Node.HasRest;
NexusAPI nexusApi = new NexusAPI(_nexus, apiCache, apiLog ? Logger : null);
if (apiProxyURL != null)
{
nexusApi.ProxyURL = apiProxyURL;
// TEMP Normal node needs a proxy url set to relay transactions to the BPs
nexusApi.Node = _node;
Logger.Message($"API will be acting as proxy for {apiProxyURL}");
}
else
{
nexusApi.Node = _node;
}
if (readOnlyMode)
{
Logger.Warning($"Node will be running in read-only mode.");
}
else
{
nexusApi.Mempool = _mempool;
}
// RPC setup
if (hasRPC)
{
var rpcPort = Settings.Node.RpcPort;
Logger.Message($"RPC server listening on port {rpcPort}...");
var rpcServer = new RPCServer(nexusApi, "/rpc", rpcPort, (level, text) => WebLogMapper("rpc", level, text));
rpcServer.StartInThread(ThreadPriority.AboveNormal);
}
// REST setup
if (hasREST)
{
var restPort = Settings.Node.RestPort;
Logger.Message($"REST server listening on port {restPort}...");
var restServer = new RESTServer(nexusApi, "/api", restPort, (level, text) => WebLogMapper("rest", level, text));
restServer.StartInThread(ThreadPriority.AboveNormal);
}
return(nexusApi);
}
internal static void Cleanup()
{
var tips = RemotableAttribute.GetTips();
foreach (var tip in tips)
{
var methodName = RemoteServiceName.GetObject(tip.RemoteType);
RPCServer.Close(methodName);
}
//取消订阅
CancelEvents();
}
public void PingMehodCalled_RturnsArgument()
{
using (var server = new RPCServer <string, string>(_factory, _converter, "integrationBroker", "rpcTestQueue"))
{
server.Start(Ping);
using (var client = new RPCClient <string, string>(_factory, _converter, "integrationBroker", "rpcTestQueue"))
{
var result = client.Call("test");
Assert.AreEqual("test", result);
}
}
}
internal KRPCServer(IPAddress address, ushort rpcPort, ushort streamPort)
{
rpcTcpServer = new TCPServer ("RPCServer", address, rpcPort);
streamTcpServer = new TCPServer ("StreamServer", address, streamPort);
rpcServer = new RPCServer (rpcTcpServer);
streamServer = new StreamServer (streamTcpServer);
clientScheduler = new RoundRobinScheduler<IClient<Request,Response>> ();
continuations = new List<RequestContinuation> ();
streamRequests = new Dictionary<IClient<byte,StreamMessage>,IList<StreamRequest>> ();
// Tie events to underlying server
rpcServer.OnStarted += (s, e) => {
if (OnStarted != null)
OnStarted (this, EventArgs.Empty);
};
rpcServer.OnStopped += (s, e) => {
if (OnStopped != null)
OnStopped (this, EventArgs.Empty);
};
rpcServer.OnClientRequestingConnection += (s, e) => {
if (OnClientRequestingConnection != null)
OnClientRequestingConnection (s, e);
};
rpcServer.OnClientConnected += (s, e) => {
if (OnClientConnected != null)
OnClientConnected (s, e);
};
rpcServer.OnClientDisconnected += (s, e) => {
if (OnClientDisconnected != null)
OnClientDisconnected (s, e);
};
// Add/remove clients from the scheduler
rpcServer.OnClientConnected += (s, e) => clientScheduler.Add (e.Client);
rpcServer.OnClientDisconnected += (s, e) => clientScheduler.Remove (e.Client);
// Add/remove clients from the list of stream requests
streamServer.OnClientConnected += (s, e) => streamRequests [e.Client] = new List<StreamRequest> ();
streamServer.OnClientDisconnected += (s, e) => streamRequests.Remove (e.Client);
// Validate stream client identifiers
streamServer.OnClientRequestingConnection += (s, e) => {
if (rpcServer.Clients.Where (c => c.Guid == e.Client.Guid).Any ())
e.Request.Allow ();
else
e.Request.Deny ();
};
}
public void ShortHelloMessageIdentifier()
{
var shortHelloMessage = new byte[8 + 31];
byte[] header = { 0x48, 0x45, 0x4C, 0x4C, 0x4F, 0xBA, 0xDA, 0x55 };
Array.Copy (header, shortHelloMessage, header.Length);
string identifier = "Jebediah Kerman!!!";
var encoder = new UTF8Encoding (false, true);
byte[] identifierBytes = encoder.GetBytes (identifier);
Array.Copy (identifierBytes, 0, shortHelloMessage, header.Length, identifierBytes.Length);
var stream = new TestStream (new MemoryStream (shortHelloMessage));
// Create mock byte server and client
var mockByteServer = new Mock<IServer<byte,byte>> ();
var byteServer = mockByteServer.Object;
var mockByteClient = new Mock<IClient<byte,byte>> ();
mockByteClient.Setup (x => x.Stream).Returns (stream);
var byteClient = mockByteClient.Object;
var server = new RPCServer (byteServer);
server.OnClientRequestingConnection += (sender, e) => e.Request.Allow ();
server.Start ();
// Fire a client connection event
var eventArgs = new ClientRequestingConnectionArgs<byte,byte> (byteClient);
mockByteServer.Raise (m => m.OnClientRequestingConnection += null, eventArgs);
Assert.IsFalse (eventArgs.Request.ShouldAllow);
Assert.IsTrue (eventArgs.Request.ShouldDeny);
}
public void ValidHelloMessage()
{
var stream = new TestStream (new MemoryStream (helloMessage));
// Create mock byte server and client
var mockByteServer = new Mock<IServer<byte,byte>> ();
var byteServer = mockByteServer.Object;
var byteClient = new TestClient (stream);
var server = new RPCServer (byteServer);
server.OnClientRequestingConnection += (sender, e) => e.Request.Allow ();
server.Start ();
// Fire a client connection event
var eventArgs = new ClientRequestingConnectionArgs<byte,byte> (byteClient);
mockByteServer.Raise (m => m.OnClientRequestingConnection += null, eventArgs);
Assert.IsTrue (eventArgs.Request.ShouldAllow);
Assert.IsFalse (eventArgs.Request.ShouldDeny);
server.Update ();
Assert.AreEqual (1, server.Clients.Count ());
Assert.AreEqual ("Jebediah Kerman!!!", server.Clients.First ().Name);
}
public void ShortHelloMessageHeader()
{
var message = new byte[] { 0x48, 0x45, 0x4C };
var stream = new TestStream (new MemoryStream (message));
// Create mock byte server and client
var mockByteServer = new Mock<IServer<byte,byte>> ();
var byteServer = mockByteServer.Object;
var mockByteClient = new Mock<IClient<byte,byte>> ();
mockByteClient.Setup (x => x.Stream).Returns (stream);
var byteClient = mockByteClient.Object;
var server = new RPCServer (byteServer);
server.OnClientRequestingConnection += (sender, e) => e.Request.Allow ();
server.Start ();
// Fire a client connection event
var eventArgs = new ClientRequestingConnectionArgs<byte,byte> (byteClient);
mockByteServer.Raise (m => m.OnClientRequestingConnection += null, eventArgs);
Assert.IsFalse (eventArgs.Request.ShouldAllow);
Assert.IsTrue (eventArgs.Request.ShouldDeny);
}
public void ValidHelloMessageWithNoName()
{
for (int i = 12; i < helloMessage.Length; i++) {
helloMessage [i] = 0x00;
}
var responseStream = new MemoryStream ();
var stream = new TestStream (new MemoryStream (helloMessage), responseStream);
// Create mock byte server and client
var mockByteServer = new Mock<IServer<byte,byte>> ();
var byteServer = mockByteServer.Object;
var byteClient = new TestClient (stream);
var server = new RPCServer (byteServer);
server.OnClientRequestingConnection += (sender, e) => e.Request.Allow ();
server.Start ();
// Fire a client connection event
var eventArgs = new ClientRequestingConnectionArgs<byte,byte> (byteClient);
mockByteServer.Raise (m => m.OnClientRequestingConnection += null, eventArgs);
Assert.IsTrue (eventArgs.Request.ShouldAllow);
Assert.IsFalse (eventArgs.Request.ShouldDeny);
server.Update ();
Assert.AreEqual (1, server.Clients.Count ());
Assert.AreEqual ("", server.Clients.First ().Name);
byte[] bytes = responseStream.ToArray ();
byte[] responseBytes = byteClient.Guid.ToByteArray ();
Assert.IsTrue (responseBytes.SequenceEqual (bytes));
}
