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 _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 Cacher()
{
NN.SetSockOpt(sub.SocketID, SocketOption.RCVTIMEO, 100);
sub.Subscribe("");
}
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();
}
}
public void RecieveDataAsClient()
{
try
{
Task.Factory.StartNew(() =>
{
while (!_ctsCancellationTokenSource.IsCancellationRequested)
{
byte[] _IncomingData = _subscribeSocket.ReceiveImmediate();
if (_IncomingData == null)
{
continue;
}
byte[] buffer = _IncomingData.Skip(10).Take(_IncomingData.Length - 2).ToArray();
//if ((MessageType)BitConverter.ToInt16(_IncomingData, 0) != MessageType.HEARTBEAT)
//{
// cout = cout + 1;
// eDataUpdate.Invoke(cout.ToString());
//}
switch ((MessageType)BitConverter.ToInt16(_IncomingData, 0))
{
case MessageType.ORDER:
{
//NNFPktCracker(buffer);
short TransactionCode = 0;
var MsgHeader = (Message_Header)DataPacket.RawDeserialize(buffer.Skip(0).Take(40).ToArray(), typeof(Message_Header));
TransactionCode = IPAddress.HostToNetworkOrder(MsgHeader.TransactionCode);
checkCase(TransactionCode, buffer);
break;
}
case MessageType.ORDERRej:
{
ORDERRej(buffer);
break;
}
case MessageType.LOGIN:
{
NNFInOut.Instance.SIGN_ON_REQUEST_OUT(buffer);
long client_Autoid = Global.Instance.ClientId - 100;
_subscribeSocket.Subscribe(
BitConverter.GetBytes((short)MessageType.ORDERRej).Concat(BitConverter.GetBytes(Global.Instance.ClientId)).ToArray());
_subscribeSocket.Subscribe(
BitConverter.GetBytes((short)MessageType.MESSAGE).Concat(BitConverter.GetBytes(Global.Instance.ClientId)).ToArray());
_subscribeSocket.Subscribe(
BitConverter.GetBytes((short)MessageType.HEARTBEAT).Concat(BitConverter.GetBytes(0)).ToArray());
_subscribeSocket.Subscribe(
BitConverter.GetBytes((short)MessageType.ORDER).Concat(BitConverter.GetBytes(Global.Instance.ClientId)).ToArray());
_subscribeSocket.Subscribe(
BitConverter.GetBytes((short)MessageType.ORDER).Concat(BitConverter.GetBytes(client_Autoid)).ToArray());
_subscribeSocket.Subscribe(
BitConverter.GetBytes((short)MessageType.ORDERRej).Concat(BitConverter.GetBytes(client_Autoid)).ToArray());
_subscribeSocket.Subscribe(
BitConverter.GetBytes((short)MessageType.MESSAGE).Concat(BitConverter.GetBytes(client_Autoid)).ToArray());
Global.LastTime = System.DateTime.Now;
break;
}
case MessageType.MESSAGE:
{
MESSAGE(buffer);
break;
}
case MessageType.HEARTBEAT:
{
HeartBeat(buffer);
Global.LastTime = System.DateTime.Now;
break;
}
default:
MessageBox.Show("Some invalid packet recieved from Server Message Code " + "Error ");
break;
}
_ctsCancellationTokenSource.Token.ThrowIfCancellationRequested();
}
}, _ctsCancellationTokenSource.Token);
}
catch (OperationCanceledException e)
{
Console.WriteLine("Cancellation invoked");
}
catch (AggregateException e)
{
if (e.InnerException is OperationCanceledException)
{
if (_requestSocket != null)
{
_requestSocket.Dispose();
}
if (_subscribeSocket != null)
{
_subscribeSocket.Dispose();
}
}
else
{
Console.WriteLine("Some unexpected exception ");
}
}
catch (Exception Ex)
{
Console.WriteLine("Exception Raised from Index " + " " + Ex.Message);
}
}
