public LzoNanoData(string DataAddress)
{
DATAAddress = DataAddress;
subscriber = new SubscribeSocket();
subscriber.Options.ReconnectInterval = new TimeSpan(0, 0, 1);
subscriber.Connect(DataAddress);
Console.WriteLine("NANOMQ UDP_Reciever Start DataAddress: " + DataAddress);
}
public Subscriber(string[] connections, string subscription = "")
{
_socket = new SubscribeSocket();
foreach (string connection in connections)
{
_socket.Connect(connection);
}
_socket.Subscribe(subscription);
Thread.Sleep(100); // time to connect
_db = new DBManager();
}
public static void Execute(string[] args)
{
string[] values = args;
if (values.Length != 3)
{
throw new ArgumentException("Invalid number parameters.");
}
switch (values[1].Trim().ToLower())
{
case "publisher":
using (var s = new PublishSocket())
{
s.Bind(values[2]);
int i = 0;
while (true)
{
byte[] b = Encoding.ASCII.GetBytes("Publish Counter is " + ++i);
s.Send(b);
Console.Write(".");
Thread.Sleep(2000);
}
}
break;
case "subscriber":
using (var s = new SubscribeSocket())
{
//Needs to match the first portion of the message being received.
s.Subscribe("Publish Counter");
s.Connect(values[2]);
while (true)
{
byte[] b = s.Receive();
if (b != null)
{
Console.WriteLine("Received: " + Encoding.ASCII.GetString(b));
}
else
{
Console.WriteLine("x");
}
}
}
break;
}
}
public void Connect(Config config, string addr)
{
req.Connect(String.Format("ws://{0}:{1}", addr, config.CacherCmdPort));
sub.Connect(String.Format("ws://{0}:{1}", addr, config.CacherDatPort));
this.config = config;
Params.Clear();
req.Send(PackOne(0, 0));
// this is blocking, we won't return until server has responded
var data = req.Receive();
UnpackToMap(data, config.Params, ref Params);
// use key 0 to signal everything has changed
// Alternatively, a event could be emitted for each key but the
// consideration is it could overload whatever handler for being
// called too many times. It is conceivable the handle simply will
// update for all params each time a event is received.
Changed(this, 0);
}
public void _socketfun()
{
_requestSocket = new RequestSocket();
_requestSocket.Connect("tcp://" + Global.Instance.NNFConIp + ":" + Global.Instance.NNFConPUBPort);
_subscribeSocket = new SubscribeSocket();
_subscribeSocket.Connect("tcp://" + Global.Instance.NNFConIp + ":" + Global.Instance.NNFConSUBPort);
long client_Autoid = Global.Instance.ClientId - 100;
_subscribeSocket.Subscribe(BitConverter.GetBytes((short)MessageType.LOGIN).Concat(BitConverter.GetBytes(Global.Instance.ClientId)).ToArray());
dllevent += new dll(checkCase);
_CTS = new CancellationTokenSource();
}
public void Connect(EventHandler handler)
{
// Request our id from the server.
interaction.Connect(url + ":8889");
Request(req_register);
// Connection must be made before requesting access or otherwise
// we may miss some key events that have already been sent by the
// time we connected.
Console.WriteLine("Accessing...");
world.Subscribe(id);
world.Connect(url + ":8888");
// `Connected` doesn't mean we are actually fully listening. Start
// the listen thread and then wait 500ms before requesting access
this.connected = true;
this.listenThread = new Thread(() => ListenProc(handler));
this.listenThread.Start();
Thread.Sleep(500);
// Request access from the world server.
Request(req_access);
Console.WriteLine("Connected with id " + id);
}
public static void Execute()
{
Console.WriteLine("Executing pubsub test ");
int receiveCount = 0;
var clientThread = new Thread(
() =>
{
var subscriber = new SubscribeSocket();
subscriber.Connect(InprocAddress);
subscriber.Subscribe("TestMessage");
byte[] streamOutput = new byte[BufferSize];
while (true)
{
var sw = Stopwatch.StartNew();
for (int i = 0; i < Iter; i++)
{
int read = 0;
streamOutput = subscriber.Receive();
read = streamOutput.Length;
//using (var stream = subscriber.ReceiveStream())
// while (stream.Length != stream.Position)
// {
// read += stream.Read(streamOutput, 0, streamOutput.Length);
// var message = Encoding.ASCII.GetString(streamOutput, 0, read);
// Trace.Assert(message.StartsWith("TestMessage"));
//
// break;
// }
++receiveCount;
}
sw.Stop();
var secondsPerSend = sw.Elapsed.TotalSeconds / (double)Iter;
Console.WriteLine("Time {0} us, {1} per second, {2} mb/s ",
(int)(secondsPerSend * 1000d * 1000d),
(int)(1d / secondsPerSend),
(int)(DataSize * 2d / (1024d * 1024d * secondsPerSend)));
}
});
clientThread.Start();
{
var publisher = new PublishSocket();
publisher.Bind(InprocAddress);
Thread.Sleep(100);
var sw = Stopwatch.StartNew();
int sendCount = 0;
var text = "TestMessage" + new string('q', 10);
var data = Encoding.ASCII.GetBytes(text);
while (sw.Elapsed.TotalSeconds < 10)
{
publisher.Send(data);
++sendCount;
}
Thread.Sleep(100);
clientThread.Abort();
Console.WriteLine("Send count {0} receive count {1}", sendCount, receiveCount);
publisher.Dispose();
}
}
