public void TC011_ReciveMessageIfWildcardSubscription()
{
string errorThrown = null;
string receivedMessage = "";
AutoResetEvent resetEvent = new AutoResetEvent(false);
using (IReactor natsClient = ReactorFactory.GetReactor(typeof(Reactor)))
{
natsClient.OnError += new EventHandler <ReactorErrorEventArgs>(delegate(object sender, ReactorErrorEventArgs args)
{
errorThrown = args.Message == null ? String.Empty : args.Message;
resetEvent.Set();
});
natsClient.Start(natsEndpoint);
// todo: vladi: if not testing agains an empty server, this subscription may fail
natsClient.Subscribe("*", delegate(string msg, string reply, string subject)
{
receivedMessage = msg;
resetEvent.Set();
});
natsClient.Publish("foo", null, "xxx");
resetEvent.WaitOne(5000);
natsClient.Close();
}
Assert.IsTrue(errorThrown == null, errorThrown);
Assert.AreEqual(receivedMessage, "xxx");
}
public void TC023_ReciveGiantMessageForSubscription()
{
bool errorThrown = false;
string receivedMessage = "";
AutoResetEvent resetEvent = new AutoResetEvent(false);
using (IReactor natsClient = ReactorFactory.GetReactor(typeof(Reactor)))
{
natsClient.OnError += new EventHandler <ReactorErrorEventArgs>(delegate(object sender, ReactorErrorEventArgs args)
{
errorThrown = true;
resetEvent.Set();
});
natsClient.Start(natsEndpoint);
natsClient.Subscribe("foo", delegate(string msg, string reply, string subject)
{
receivedMessage = msg;
resetEvent.Set();
});
ASCIIEncoding ascii = new ASCIIEncoding();
natsClient.Publish("foo", null, ascii.GetString(new byte[90000]));
resetEvent.WaitOne(10000);
natsClient.Close();
}
Assert.IsFalse(errorThrown);
Assert.AreEqual(receivedMessage.Length, 90000);
}
public void TC014_PublishCallback()
{
bool errorThrown = false;
bool done = false;
AutoResetEvent resetEvent = new AutoResetEvent(false);
using (IReactor natsClient = ReactorFactory.GetReactor(typeof(Reactor)))
{
natsClient.OnError += new EventHandler <ReactorErrorEventArgs>(delegate(object sender, ReactorErrorEventArgs args)
{
errorThrown = true;
resetEvent.Set();
});
natsClient.Start(natsEndpoint);
natsClient.Publish("foo", delegate()
{
done = true;
resetEvent.Set();
});
resetEvent.WaitOne(5000);
natsClient.Close();
}
Assert.IsFalse(errorThrown);
Assert.IsTrue(done);
}
public void TC010_ReciveEmptyMessage()
{
bool errorThrown = false;
string receivedMessage = "xxx";
AutoResetEvent resetEvent = new AutoResetEvent(false);
using (IReactor natsClient = ReactorFactory.GetReactor(typeof(Reactor)))
{
natsClient.OnError += new EventHandler <ReactorErrorEventArgs>(delegate(object sender, ReactorErrorEventArgs args)
{
errorThrown = true;
resetEvent.Set();
});
natsClient.Start(natsEndpoint);
natsClient.Subscribe("foo", delegate(string msg, string reply, string subject)
{
receivedMessage = msg;
resetEvent.Set();
});
natsClient.Publish("foo", null, "");
resetEvent.WaitOne(5000);
natsClient.Close();
}
Assert.IsFalse(errorThrown);
Assert.AreEqual(receivedMessage, "");
}
public void TC006_PublishNil()
{
bool errorThrown = false;
AutoResetEvent resetEvent = new AutoResetEvent(false);
using (IReactor natsClient = ReactorFactory.GetReactor(typeof(Reactor)))
{
natsClient.OnError += new EventHandler <ReactorErrorEventArgs>(delegate(object sender, ReactorErrorEventArgs args)
{
errorThrown = true;
resetEvent.Set();
});
natsClient.Start(natsEndpoint);
// todo: vladi: check to see if nil in Ruby evaluates to boolean true
natsClient.Publish(null);
natsClient.Publish(null, null, "hello");
resetEvent.WaitOne(5000);
natsClient.Close();
}
Assert.IsFalse(errorThrown);
}
public void TC005_PublishWithoudPayload()
{
bool errorThrown = false;
AutoResetEvent resetEvent = new AutoResetEvent(false);
using (IReactor natsClient = ReactorFactory.GetReactor(typeof(Reactor)))
{
natsClient.OnError += new EventHandler <ReactorErrorEventArgs>(delegate(object sender, ReactorErrorEventArgs args)
{
errorThrown = true;
resetEvent.Set();
});
natsClient.Start(natsEndpoint);
natsClient.Publish("foo");
natsClient.Publish("foo", null, "hello");
natsClient.Publish("foo", null, "hello", "reply");
resetEvent.WaitOne(5000);
natsClient.Close();
}
Assert.IsFalse(errorThrown);
}
public void Start()
{
if (!_server.IsActive)
{
_server.Start();
}
}
static void Main(string[] args)
{
Port = args.Length < 1 ? DEFAULT_PORT : Int32.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();
IReactor 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 TC001_StartStopClient()
{
using (IReactor natsClient = ReactorFactory.GetReactor(typeof(Reactor)))
{
natsClient.Start(natsEndpoint);
natsClient.Close();
}
}
public void TC015_MultipleResponseCallback()
{
bool errorThrown = false;
List <int> expected = new List <int>();
List <int> response = new List <int>();
AutoResetEvent resetEvent = new AutoResetEvent(false);
using (IReactor natsClient = ReactorFactory.GetReactor(typeof(Reactor)))
{
natsClient.OnError += new EventHandler <ReactorErrorEventArgs>(delegate(object sender, ReactorErrorEventArgs args)
{
errorThrown = true;
resetEvent.Set();
});
natsClient.Start(natsEndpoint);
SimpleCallback[] delegates = new SimpleCallback[] {
delegate() { response.Add(0); },
delegate() { response.Add(1); },
delegate() { response.Add(2); },
delegate() { response.Add(3); },
delegate() { response.Add(4); },
delegate() { response.Add(5); },
delegate() { response.Add(6); },
delegate() { response.Add(7); },
delegate() { response.Add(8); },
delegate() { response.Add(9); },
delegate() { response.Add(10); },
delegate() { response.Add(11); },
delegate() { response.Add(12); },
delegate() { response.Add(13); },
delegate() { response.Add(14); }
};
for (int i = 0; i < 15; i++)
{
expected.Add(i);
natsClient.Publish("foo", delegates[i]);
}
natsClient.Publish("foo", delegate()
{
resetEvent.Set();
});
resetEvent.WaitOne(5000);
natsClient.Close();
}
Assert.IsFalse(errorThrown);
for (int i = 0; i < 15; i++)
{
Assert.AreEqual(expected[i], response[i]);
}
}
public void TC002_CheckState()
{
using (IReactor natsClient = ReactorFactory.GetReactor(typeof(Reactor)))
{
natsClient.Start(natsEndpoint);
Assert.IsTrue(natsClient.Status == ConnectionStatus.Open);
natsClient.Close();
}
}
public void TC008_ReciveSidRequest()
{
using (IReactor natsClient = ReactorFactory.GetReactor(typeof(Reactor)))
{
natsClient.Start(natsEndpoint);
int mySid = natsClient.Request("foo");
natsClient.Close();
Assert.IsTrue(0 < mySid);
}
}
public void TC012_RecieveMessageOnUnsubscription()
{
bool errorThrown = false;
int receivedCount = 0;
object receivedCountLock = new object();
int sid = 0;
IReactor natsClient = ReactorFactory.GetReactor(typeof(Reactor));
natsClient.OnError += new EventHandler <ReactorErrorEventArgs>(delegate(object sender, ReactorErrorEventArgs args)
{
errorThrown = true;
});
natsClient.Start(natsEndpoint);
ManualResetEvent mre = new ManualResetEvent(false);
sid = natsClient.Subscribe("foo", delegate(string msg, string reply, string subject)
{
lock (receivedCountLock)
{
receivedCount++;
if (receivedCount == 2)
{
natsClient.Unsubscribe(sid);
mre.Set();
}
}
});
natsClient.Publish("foo", () =>
{
natsClient.Publish("foo", () =>
{
mre.WaitOne();
natsClient.Publish("foo", () => { }, "xxx");
}, "xxx");
}, "xxx");
Thread.Sleep(5000);
natsClient.Close();
Assert.IsFalse(errorThrown);
Assert.AreEqual(2, receivedCount);
}
public void TC021_PublishThreadSafe()
{
bool errorThrown = false;
object locker = new object();
int callbackNr = 0;
int sid = 0;
using (IReactor natsClient = ReactorFactory.GetReactor(typeof(Reactor)))
{
natsClient.OnError += new EventHandler <ReactorErrorEventArgs>(delegate(object sender, ReactorErrorEventArgs args)
{
errorThrown = true;
});
for (int i = 0; i < 40; i++)
{
string subject = Guid.NewGuid().ToString();
sid = natsClient.Subscribe(subject, delegate(string msg, string reply, string subj)
{
lock (locker)
{
callbackNr++;
}
});
Thread workerThread = new Thread(new ParameterizedThreadStart(delegate(object data)
{
natsClient.Publish((string)data);
}));
workerThread.Start(subject);
}
natsClient.Start(natsEndpoint);
while (callbackNr != 40 || errorThrown)
{
Thread.Sleep(1000);
}
natsClient.Close();
}
Assert.IsFalse(errorThrown);
}
/// <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 void TC018_UnsubscribeWithinBlocks()
{
bool errorThrown = false;
int receivedMessageCount = 0;
int sid = 0;
AutoResetEvent resetEvent = new AutoResetEvent(false);
object receivedMessageCountLock = new object();
using (IReactor natsClient = ReactorFactory.GetReactor(typeof(Reactor)))
{
natsClient.OnError += new EventHandler <ReactorErrorEventArgs>(delegate(object sender, ReactorErrorEventArgs args)
{
errorThrown = true;
resetEvent.Set();
});
natsClient.Start(natsEndpoint);
sid = natsClient.Subscribe("foo", delegate(string msg, string reply, string subject)
{
lock (receivedMessageCountLock)
{
receivedMessageCount++;
natsClient.Unsubscribe(sid);
}
});
natsClient.Publish("foo", delegate()
{
natsClient.Publish("foo", delegate()
{
resetEvent.Set();
}, "xxx");
}, "xxx");
resetEvent.WaitOne(5000);
natsClient.Close();
}
Assert.IsFalse(errorThrown);
Assert.AreEqual(1, receivedMessageCount);
}
/// <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 TC004_CheckServerError()
{
bool errorThrown = false;
AutoResetEvent resetEvent = new AutoResetEvent(false);
using (IReactor natsClient = ReactorFactory.GetReactor(typeof(Reactor)))
{
natsClient.Pedantic = true;
natsClient.OnError += new EventHandler <ReactorErrorEventArgs>(delegate(object sender, ReactorErrorEventArgs args)
{
errorThrown = true;
resetEvent.Set();
});
natsClient.Start(natsEndpoint);
natsClient.Unsubscribe(10000);
natsClient.Publish("done");
resetEvent.WaitOne(10000);
natsClient.Close();
}
Assert.IsTrue(errorThrown);
}
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();
}
public void TC017_RquestReplyMultipleConnections()
{
bool errorThrown = false;
string receivedMessage = "";
string receivedReply = "";
AutoResetEvent resetEvent = new AutoResetEvent(false);
using (IReactor natsClient = ReactorFactory.GetReactor(typeof(Reactor)))
{
natsClient.OnError += new EventHandler <ReactorErrorEventArgs>(delegate(object sender, ReactorErrorEventArgs args)
{
errorThrown = true;
resetEvent.Set();
});
natsClient.Start(natsEndpoint);
natsClient.Subscribe("need_help", delegate(string msg, string reply, string subject)
{
receivedMessage = msg;
natsClient.Publish(reply, null, "help");
});
// todo: vladi: this doesn't work if no message is sent.
natsClient.Request("need_help", null, delegate(string msg, string reply, string subject)
{
receivedReply = msg;
resetEvent.Set();
}, "yyy");
resetEvent.WaitOne(5000);
natsClient.Close();
}
Assert.IsFalse(errorThrown);
Assert.AreEqual(receivedMessage, "yyy");
Assert.AreEqual(receivedReply, "help");
}
public void TC019_ErrorHandlerNotPedantic()
{
bool errorThrown = false;
AutoResetEvent resetEvent = new AutoResetEvent(false);
using (IReactor natsClient = ReactorFactory.GetReactor(typeof(Reactor)))
{
natsClient.OnError += new EventHandler <ReactorErrorEventArgs>(delegate(object sender, ReactorErrorEventArgs args)
{
errorThrown = true;
resetEvent.Set();
});
natsClient.Start(natsEndpoint);
int sid = natsClient.Subscribe("foo");
natsClient.Unsubscribe(sid);
natsClient.Unsubscribe(sid);
resetEvent.WaitOne(5000);
natsClient.Close();
}
Assert.IsFalse(errorThrown);
}
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();
}
