static void RunClient(CancellationToken cancellationToken)
{
Task.Factory.StartNew(() =>
{
using (var client = new RequestSocket())
{
client.Connect("tcp://localhost:5555");
var i = 0;
while (true)
{
Console.WriteLine("Client: Sending Hello");
var request = new NetMQMessage();
request.Append($"Hello {i++}");
request.AppendEmptyFrame();
client.SendMultipartMessage(request);
var response = client.ReceiveMultipartMessage();
var message = response[0].ConvertToString();
Console.WriteLine($"Client: Received {message}");
if (cancellationToken.IsCancellationRequested)
{
return;
}
}
}
});
}
/// <summary>
/// the int returned is the callID
/// </summary>
/// <returns></returns>
public NetMQMessage CallMethod(NetMQMessage mqMessage)
{
lock (reqSocket)
{
var callID = GenerateCallID();
var messageToSend = new NetMQMessage();
messageToSend.Append(callID);
while (false == mqMessage.IsEmpty)
{
messageToSend.Append(mqMessage.Pop());
}
reqSocket.SendMultipartMessage(messageToSend);
var message = reqSocket.ReceiveMultipartMessage();
var callIdFrame = message.Pop();
int recivedCallId = callIdFrame.ConvertToInt32();
if (recivedCallId.Equals(callID))
{
//everything should be just fine
return(message);
}
callIdInUse.Remove(callID);
}
throw new MethodFailedException();
//return callID;
}
NetMQMessage sendRequest(RequestSocket socket, Dictionary <string, object> data)
{
NetMQMessage m = new NetMQMessage();
m.Append("notify." + data["subject"]);
using (var byteStream = new MemoryStream())
{
var ctx = new SerializationContext();
ctx.CompatibilityOptions.PackerCompatibilityOptions = MsgPack.PackerCompatibilityOptions.None;
var ser = MessagePackSerializer.Get <object>(ctx);
ser.Pack(byteStream, data);
m.Append(byteStream.ToArray());
}
socket.SendMultipartMessage(m);
timeout = new System.TimeSpan(0, 0, 0, 1);
NetMQMessage recievedMsg;
recievedMsg = socket.ReceiveMultipartMessage();
string msgType = recievedMsg[0].ConvertToString();
if (recievedMsg.FrameCount > 1)
{
MsgPack.UnpackingResult <MsgPack.MessagePackObject> message = MsgPack.Unpacking.UnpackObject(recievedMsg[1].ToByteArray());
MsgPack.MessagePackObject mmap = message.Value;
}
return(recievedMsg);
}
private Either <IError, CapabilityInfo> GetCapabilityFromServer(string name)
{
var message = RequestCreator.Create(_encryptor, MessageType.GetCapability,
JsonConvert.SerializeObject(new CapabilityInfo(name)));
_requestSocket.SendMultipartMessage(message);
var response = _requestSocket.ReceiveMultipartMessage();
var messageType = (MessageType)response.Pop().ConvertToInt32();
switch (messageType)
{
case MessageType.GrantCapability:
var infoJson = _encryptor.Decrypt(response.Pop().ToByteArray());
var info = JsonConvert.DeserializeObject <CapabilityInfo>(infoJson);
return(new Right <IError, CapabilityInfo>(info));
case MessageType.Error:
var errorContent = response.Pop().ToByteArray();
return(new Left <IError, CapabilityInfo>(ErrorMessageReceiver.GetError(errorContent)));
default:
return(new Left <IError, CapabilityInfo>(new UnexpectedMessageError()));
}
}
public static T RequestSendReceive <T>(this RequestSocket socket, IdKeyData ikd)
{
try
{
lock (socket)
{
socket.SendMoreFrame(ikd.Id).SendMoreFrame(ikd.Key).SendFrame(ikd.Data);
NetMQMessage msg = null;
#if DEBUG1
msg = socket.ReceiveMultipartMessage(); // debug模式打开，不会超时
#else
socket.TryReceiveMultipartMessage(TimeSpan.FromSeconds(10), ref msg);
#endif
if (msg != null)
{
var result = JsonUtil.Deserialize <T>(msg[0].Buffer);
return(result);
}
else
{
throw new Exception("中心服务器请求失败！");
}
}
}
catch (Exception ex)
{
socket = new RequestSocket();
socket.Connect(MQConfig.ResponseServer);
LogUtil.Warn("RequestSendReceive 异常：" + ex.StackTrace);
return(default(T));
}
}
private static bool GetAcknowledge(RequestSocket requestSocket)
{
var response = requestSocket.ReceiveMultipartMessage();
var messageType = (MessageType)response.Pop().ConvertToInt32();
return(messageType == MessageType.Acknowledge);
}
public NetMQMessage SendRequest(NetMQMessage message)
{
RequestSocket request = new RequestSocket();
request.Connect(RequestAddress);
request.SendMultipartMessage(message);
return(request.ReceiveMultipartMessage());
}
protected static ServermoduleID RegisterServermoduleByTargetType(TargetType target, ConnectionInfo connInfo)
{
if (null == connInfo)
{
throw new Exception("Does not allow null");
}
ServerMethod method = null;
if (TargetType.SlaveOwnerServermodule.Equals(target)) //TODO expand
{
method = new RegisterSlaveOwnerServermoduleMethod()
{
ConnectionInfo = connInfo
};
}
//socket only used for getting the servermodule ID
var setupSocket = new RequestSocket();
setupSocket.Connect("tcp://" + net_mq_util.NetMqUtil.SERVER_MODULE_IP + ":" + net_mq_util.NetMqUtil.SERVER_MODULE_PORT);
var localCallID = new Random().Next();
if (null == method)
{
throw new Exception();
}
var encodedMethod = net_mq_encoder.NetMqEncoder.GenerateServerModuleMethodMessage(new ServermoduleID()
{
ID = ProtocolConstants.SERVERMODULE_ID_NOT_YET_ASSIGNED
}, new CallID()
{
ID = localCallID
}, method);
setupSocket.SendMultipartMessage(encodedMethod);
var response = setupSocket.ReceiveMultipartMessage();
setupSocket.Close();
var decodedReponse = net_mq_decoder.NetMqDecoder.DecodeResponse <ServermoduleID>(response);
if (
ProtocolConstants.SERVERMODULE_ID_NOT_YET_ASSIGNED.Equals(decodedReponse.Item2.Item1.ID) &&
localCallID.Equals(decodedReponse.Item2.Item2.ID)
)
{
return(decodedReponse.Item1);
}
else
{
throw new MethodFailedException("The SlaveOwner Setup method failed");
}
}
public async Task <string> GetSmallPayloadAsync()
{
return(await Task.Run(() =>
{
_client.SendFrame(GetRequestTypeBytes(RequestType.GetSmallPayload));
var response = _client.ReceiveMultipartMessage();
if (response != null && response.FrameCount == 2)
{
var requestType = ReadRequestType(response[0]);
if (requestType == RequestType.GetSmallPayload)
{
return response[1].ConvertToString();
}
}
return string.Empty;
}));
}
NetMQMessage _sendRequestMessage(Dictionary <string, object> data)
{
NetMQMessage m = new NetMQMessage();
m.Append("notify." + data["subject"]);
using (var byteStream = new MemoryStream()) {
var ctx = new SerializationContext();
ctx.CompatibilityOptions.PackerCompatibilityOptions = MsgPack.PackerCompatibilityOptions.None;
var ser = MessagePackSerializer.Get <object>(ctx);
ser.Pack(byteStream, data);
m.Append(byteStream.ToArray());
}
_requestSocket.SendMultipartMessage(m);
NetMQMessage recievedMsg;
recievedMsg = _requestSocket.ReceiveMultipartMessage();
return(recievedMsg);
}
static void Main(string[] args)
{
try
{
//Thread thread = new Thread(new ThreadStart(start_zeromq_server));
//thread.Start();
start_zeromq_server();
Console.WriteLine($"Soma {sum(5, 10)}");
int i = 0;
while (i < 4)
{
using (var client = new RequestSocket("tcp://127.0.0.1:5555"))
{
Console.WriteLine("Client sending");
//client.SendMoreFrame("A").SendFrame("Hello");
byte[] msg = Encoding.ASCII.GetBytes("HEllo");
client.SendFrame(msg);
var resp = client.ReceiveMultipartMessage();
Console.WriteLine("Client received {0} frames", resp.FrameCount);
}
i++;
System.Threading.Thread.Sleep(1000);
}
using (var client = new RequestSocket("tcp://127.0.0.1:5555"))
{
Console.WriteLine("closing socket");
//client.SendMoreFrame("A").SendFrame("Hello");
byte[] msg = Encoding.ASCII.GetBytes("EXIT");
client.SendFrame(msg);
var resp = client.ReceiveMultipartMessage();
Console.WriteLine("Client received {0} frames", resp.FrameCount);
}
//thread.Join();
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
throw;
}
}
private static Maybe <string> RequestPublicKey(RequestSocket requestSocket)
{
var request = RequestCreator.Create(new NoEncryption(), MessageType.RequestPublicKey);
requestSocket.SendMultipartMessage(request);
var responseMessage = requestSocket.ReceiveMultipartMessage();
Maybe <string> response = null;
ResponseReader.Read <string>(new NoEncryption(), new NoEncryption(), responseMessage)
.Case((Response <string> publicKay) => response = new Maybe <string>(publicKay.Payload))
.Fold(_ => response = new Nothing <string>());
return(response);
}
private T SendMultipartMessageWithReply <T>(Message request)
where T : Message
{
_requestSocket.SendMultipartMessage(request.ToNetMQMessage());
var raw = _requestSocket.ReceiveMultipartMessage();
var reply = Message.Parse(raw);
if (!(reply is T))
{
throw new InvalidMessageException(
$"Unexpected reply message, {reply.GetType()}");
}
else
{
return((T)reply);
}
}
public void Run()
{
var rnd = new Random(m_id);
using (var worker = new RequestSocket())
{
worker.Connect(m_localBackendAddress);
Console.WriteLine("[WORKER {0}] Connected & READY", m_id);
// build READY message
var msg = new NetMQMessage();
var ready = NetMQFrame.Copy(new[] { Program.WorkerReady });
msg.Append(ready);
msg.Push(NetMQFrame.Empty);
msg.Push(new[] { m_id });
// and send to broker
worker.SendMultipartMessage(msg);
while (true)
{
// wait for a request - the REQ might be from a local client or a cloud request
var request = worker.ReceiveMultipartMessage();
if (request.FrameCount < 3)
{
Console.WriteLine("[WORKER {0}] ERR - received an empty message", m_id);
break; // something went wrong -> exit
}
Console.WriteLine("[WORKER {0}] received", m_id);
foreach (var frame in request)
{
Console.WriteLine("\t[{0}", frame.ConvertToString());
}
// simulate working for an arbitrary time < 2s
Thread.Sleep(rnd.Next(2000));
// simply send back what we received
worker.SendMultipartMessage(request);
}
}
}
private Maybe <Challenge> GetChallenge(RequestSocket requestSocket)
{
var challengeMessage = requestSocket.ReceiveMultipartMessage();
var messageType = (MessageType)challengeMessage.Pop().ConvertToInt32();
switch (messageType)
{
case MessageType.SendChallenge:
var encryptedChallenge = challengeMessage.Pop().ToByteArray();
return(new Maybe <Challenge>(
JsonConvert.DeserializeObject <Challenge>(_encryptor.Decrypt(encryptedChallenge))));
default:
return(new Nothing <Challenge>());
}
}
private static void Main()
{
using (var client = new RequestSocket(">tcp://127.0.0.1:5559"))
{
for (var i = 0; i < 10; i++)
{
var msg = new NetMQMessage();
msg.Append("Message_" + i);
client.SendMultipartMessage(msg);
Console.WriteLine("Sent Message {0}", msg.Last.ConvertToString());
var response = client.ReceiveMultipartMessage();
Console.WriteLine("Received Message {0}", response.Last.ConvertToString());
}
Console.ReadKey();
}
}
static void Main(string[] args)
{
Console.WriteLine("Tier 1");
var sendSocket = new RequestSocket();
sendSocket.Connect("tcp://127.0.0.1:" + net_mq_tier_two.Program.listeningPort);
sendSocket.SendMoreFrame("MethidID").SendFrame("Frame 2: ma last frame");
Console.WriteLine("finished sending");
var response = sendSocket.ReceiveMultipartMessage();
Console.WriteLine("Yaay I got a response: ");
Console.WriteLine(response.Pop().ConvertToString());
//Console.WriteLine(response.Pop().ConvertToString());
Console.ReadKey();
}
public void Run()
{
var rnd = new Random(m_id);
using (var worker = new RequestSocket())
{
worker.Connect(m_localBackendAddress);
Console.WriteLine("[WORKER {0}] Connected & READY", m_id);
// build READY message
var msg = new NetMQMessage();
var ready = NetMQFrame.Copy(new[] { Program.WorkerReady });
msg.Append(ready);
msg.Push(NetMQFrame.Empty);
msg.Push(new[] { m_id });
// and send to broker
worker.SendMultipartMessage(msg);
while (true)
{
// wait for a request - the REQ might be from a local client or a cloud request
var request = worker.ReceiveMultipartMessage();
if (request.FrameCount < 3)
{
Console.WriteLine("[WORKER {0}] ERR - received an empty message", m_id);
break; // something went wrong -> exit
}
Console.WriteLine("[WORKER {0}] received", m_id);
foreach (var frame in request)
Console.WriteLine("\t[{0}", frame.ConvertToString());
// simulate working for an arbitrary time < 2s
Thread.Sleep(rnd.Next(2000));
// simply send back what we received
worker.SendMultipartMessage(request);
}
}
}
/// <summary>
/// Invokes the capability and returns the return value
/// </summary>
/// <param name="argument">The invocation argument</param>
/// <returns>The return value</returns>
public Either <IError, TReturn> Invoke(TArgument argument)
{
_socket.SendMultipartMessage(CreateRequest(argument));
var response = _socket.ReceiveMultipartMessage();
var messageType = (MessageType)response.Pop().ConvertToInt32();
switch (messageType)
{
case MessageType.CapabilityInvocationResult:
return(new Right <IError, TReturn>(
JsonConvert.DeserializeObject <TReturn>(_encryptor.Decrypt(response.Pop().ToByteArray()))));
case MessageType.Error:
var error = JsonConvert.DeserializeObject <ErrorCode>(response.Pop().ConvertToString());
return(new Left <IError, TReturn>(ErrorUtilities.GetErrorByErrorCode(error)));
default:
throw new ArgumentOutOfRangeException();
}
}
public NetMQMessage recieveRequestMessage()
{
return(requestSocket.ReceiveMultipartMessage());
}
static void Main(string[] args)
{
Console.WriteLine("Tier 2");
var reciveSocket = new ResponseSocket();
//reciveSocket.Bind("tcp://0.0.0.0:" + listeningPort);
var newRouterSocket = new RouterSocket();
newRouterSocket.Bind("tcp://0.0.0.0:" + listeningPort);
Console.WriteLine("Ready to recive!");
var message = newRouterSocket.ReceiveMultipartMessage();
var sendSocket = new RequestSocket();
sendSocket.Connect("tcp://127.0.0.1:" + net_mq_tier_three.Program.listeningPort);
List <NetMQFrame> frames = new List <NetMQFrame>();
while (false == message.IsEmpty)
{
var frame = message.Pop();
frames.Add(frame);
}
if ("MethidID" == frames[2].ConvertToString())
{
if (true) // debug
{
foreach (var item in frames)
{
Console.WriteLine(item.ConvertToString());
}
}
var multiPartMessage = new NetMQMessage(frames);
sendSocket.SendMultipartMessage(multiPartMessage);
//now a response should be recived on the the same socket, and I need to figure out how to handle that.
var responseMessage = sendSocket.ReceiveMultipartMessage();
newRouterSocket.SendMultipartMessage(responseMessage);
}
else
{
//not a valid message
Console.WriteLine("Something bad happened in tier 2");
}
//lets pretend I have validated where to send this message
Console.ReadKey();
}
