public Listener()
{
working = true;
listener = new Thread(new ThreadStart(() =>
{
server = new ResponseSocket();
server.Bind("tcp://*:5554");
string message;
while (working)
{
if (server.TryReceiveFrameString(System.TimeSpan.FromSeconds(2), out message))
{
Console.WriteLine("receive message: {0}", message);
var message_obj = json_converter.JsonConverter.deserialaze(message);
ProcessMessage(message_obj as iMessage);
}
else
{
Console.WriteLine("No message recieve");
}
}
}));
listener.IsBackground = true;
}
public string Try_Recv_String()
{
string a;
bool result = socket.TryReceiveFrameString(out a);
return(result? a: "");
}
void Respond()
{
AsyncIO.ForceDotNet.Force();
var socket = new ResponseSocket("tcp://*:5558");
try{
while (responderIsStarted)
{
string inMsg;
if (!socket.TryReceiveFrameString(out inMsg))
{
continue;
}
Debug.Log("Received: " + inMsg);
if (inMsg == "on")
{
lightIsOn = true;
socket.SendFrame("Light is on");
}
else if (inMsg == "off")
{
lightIsOn = false;
socket.SendFrame("Light is off");
}
}
}finally{
if (socket != null)
{
socket.Close();
((IDisposable)socket).Dispose();
NetMQConfig.Cleanup(true);
}
}
}
private void ListenerWork()
{
UnityEngine.Debug.Log("ListenerWork ");
AsyncIO.ForceDotNet.Force();
using (var server = new ResponseSocket())
{
server.Bind("tcp://*:12346");
while (!_listenerCancelled)
{
UnityEngine.Debug.Log("!ListenerCancelled");
Connected = _contactWatch.ElapsedMilliseconds < ContactThreshold;
string message;
if (!server.TryReceiveFrameString(out message))
{
continue;
}
_contactWatch.Restart();
var response = _messageDelegate(message);
server.SendFrame(response);
//Thread.Sleep(thread_sleep_time);
}
}
NetMQConfig.Cleanup();
}
private void ListenerWork()
{
AsyncIO.ForceDotNet.Force();
using (var server = new ResponseSocket())
{
server.Bind("tcp://*:12345");
while (!_listenerCancelled)
{
Connected = _contactWatch.ElapsedMilliseconds < ContactThreshold;
string message = "blah";
bool success = false;
if (sending)
{
success = OutgoingSocketExtensions.TrySendFrame(server, message);
}
else
{
success = server.TryReceiveFrameString(out message);
}
if (success)
{
sending = !sending;
_contactWatch.Restart();
}
}
}
NetMQConfig.Cleanup();
}
private void ResponseEntry()
{
using (ResponseSocket serverSocket = new ResponseSocket())
{
string endpoint = "tcp://*:" + ModResponse.port;
try
{
serverSocket.Bind(endpoint);
}
catch (Exception err)
{
Logging.logger.Error(ModName + " bind response socket failed " + endpoint + " " + err.Message);
throw (err);
}
ResponseRM.ressock = serverSocket;
string received = string.Empty;
bool result;
string resdata = string.Empty;
ResponseRM.Working = true;
while (ResponseRM.Running)
{
//string received = serverSocket.ReceiveFrameString();
received = string.Empty;
result = serverSocket.TryReceiveFrameString(out received);
if (result == true)
{
try
{
resdata = this.ResponseEntry(received);
serverSocket.SendFrame(resdata);
}
catch (Exception err)
{
Logging.logger.Error(err.Message);
resdata = Entry4ExceptionMsg(err.Message);
serverSocket.SendFrame(resdata);
throw (err);
}
}
DelayTime();
}
ResponseRM.Working = false;
serverSocket.Close();
}
}
/// SERVER
static void Main(string[] args)
{
string message;
bool status;
using (var responseSocket = new ResponseSocket("@tcp://*:5252"))
//using (var requestSocket = new RequestSocket(">tcp://localhost:5252"))
{
//Console.WriteLine("requestSocket : Sending 'Hello'");
//requestSocket.SendFrame("Hello");
//Start and wait for messages
//Console.WriteLine("Start and wait for messages");
//Console.ReadLine();
while (true)
{
status = responseSocket.TryReceiveFrameString(out message);
if (status)
{
Console.WriteLine("responseSocket : Server Received '{0}'", message);
status = responseSocket.TrySendFrame("World");
if (status)
{
continue;
}
else
{
//May happen that another frame arrives, before sending, may never happen this scenario.
responseSocket.TrySkipFrame();
}
}
}
//Console.WriteLine("responseSocket : Server Received '{0}'", message);
//Console.WriteLine("responseSocket Sending 'World'");
//responseSocket.SendFrame("World");
//Console.WriteLine("Received executed, Sent reponse");
//Console.ReadLine();
////message = requestSocket.ReceiveFrameString();
//Console.WriteLine("requestSocket : Received '{0}'", message);
//Console.WriteLine("All Done..");
//Console.ReadLine();
}
}
/// <summary>
/// Request Hello message to server and receive message back. Do it 10 times.
/// Stop requesting when Running=false.
/// </summary>
protected override void Run()
{
ForceDotNet.Force(); // this line is needed to prevent unity freeze after one use, not sure why yet
using (ResponseSocket server = new ResponseSocket())
{
server.Bind("tcp://*:5555");
//missatge buit per defecte buit, ocupat i resultat 0
FeedbackInfo fbInfo = new FeedbackInfo();
string str = JsonUtility.ToJson(fbInfo);
msg_back = str;
string message = null;
bool gotMessage = false;
// mentre estem escoltant
while (Running)
{
gotMessage = server.TryReceiveFrameString(out message); // this returns true if it's successful
if (gotMessage)
{
//si estem processant un missatge no desem com a pendent
if (processingMessage == true)
{
Debug.Log("msg_back " + msg_back);
server.SendFrame(msg_back);
//si estem lliures el desem
}
else
{
pending_message = message;
Debug.Log("msg_back " + msg_back);
server.SendFrame(msg_back);
}
}
}
}
NetMQConfig.Cleanup(); // this line is needed to prevent unity freeze after one use, not sure why yet
}
// Client thread which does not block Update()
void NetMQServer()
{
AsyncIO.ForceDotNet.Force();
NetMQConfig.ManualTerminationTakeOver();
NetMQConfig.ContextCreate(true);
string msg;
var timeout = new System.TimeSpan(0, 0, 1); //1sec
Log("Connect.");
var socket = new ResponseSocket("@tcp://localhost:5557");
while (true)
{
lock (thisLock_) {
if (stop_thread_)
{
break;
}
}
// Log("Get request.");
try {
if (socket.TryReceiveFrameString(timeout, out msg))
{
Log("recived: " + msg);
socket.SendFrame("world");
}
else
{
Log("Timed out, sleep");
Thread.Sleep(1000);
}
} catch (System.Exception ex) {
Log(ex.Message);
throw ex;
}
}
socket.Close();
Log("ContextTerminate.");
NetMQConfig.ContextTerminate();
}
private void ListenerWork()
{
AsyncIO.ForceDotNet.Force();
using (var server = new ResponseSocket()) {
server.Bind("tcp://*:12346");
while (!_listenerCancelled)
{
Connected = _contactWatch.ElapsedMilliseconds < ContactThreshold;
string message;
if (!server.TryReceiveFrameString(out message))
{
continue;
}
_contactWatch.Start();
OnReceiveMessage_Thread(message);
server.SendFrame("ok");
}
}
NetMQConfig.Cleanup();
}
private void ListenerWork()
{
AsyncIO.ForceDotNet.Force();
using (var server = new ResponseSocket())
{
server.Bind("tcp://*:12346");
while (!listenerCancelled)
{
string message;
if (!server.TryReceiveFrameString(out message))
{
continue;
}
contactWatch.Restart();
var response = messageDelegate(message);
server.SendFrame(response);
}
}
NetMQConfig.Cleanup();
}
public void Start()
{
sub.ActiveMonitor = true;
//Thread montitorThread = new Thread(sub.MontitorLister);
while (socket == null || sub.IsListenerPresent())
{
if (socket == null)
{
socket = new ResponseSocket();
socket.Bind(Address);
//montitorThread.Start();
}
if (socket.TryReceiveFrameString(TimeSpan.FromSeconds(20), out string msg))
{
if (!ProcessMessage(msg))
{
break;
}
}
}
sub.ActiveMonitor = false;
socket.Unbind(Address);
socket.Dispose();
}
private void dataServer()
{
AsyncIO.ForceDotNet.Force();
using (var dataSender = new ResponseSocket())
{
dataSender.Bind("tcp://" + VPETSettings.Instance.serverIP + ":5565");
Debug.Log("Enter while.. ");
while (isRunning)
{
string message = "";
dataSender.TryReceiveFrameString(out message);
//print ("Got request message: " + message);
// re-run scene iteration if true
if (doGatherOnRequest)
{
gatherSceneData();
}
switch (message)
{
case "header":
print("Send Header.. ");
dataSender.SendFrame(headerByteData);
print(string.Format(".. Nodes ({0} bytes) sent ", headerByteData.Length));
break;
case "nodes":
print("Send Nodes.. ");
dataSender.SendFrame(nodesByteData);
print(string.Format(".. Nodes ({0} bytes) sent ", nodesByteData.Length));
break;
case "objects":
print("Send Objects.. ");
dataSender.SendFrame(objectsByteData);
print(string.Format(".. Objects ({0} bytes) sent ", objectsByteData.Length));
break;
case "characters":
print("Send Characters.. ");
dataSender.SendFrame(charactersByteData);
print(string.Format(".. Characters ({0} bytes) sent ", charactersByteData.Length));
break;
case "textures":
print("Send Textures.. ");
dataSender.SendFrame(texturesByteData);
print(string.Format(".. Textures ({0} bytes) sent ", texturesByteData.Length));
break;
#if TRUNK
case "materials":
print("Send Materials.. ");
dataSender.SendFrame(materialsByteData);
print(string.Format(".. Materials ({0} bytes) sent ", materialsByteData.Length));
break;
#endif
default:
break;
}
}
// TODO: check first if closed
try
{
dataSender.Disconnect("tcp://" + VPETSettings.Instance.serverIP + ":5565");
dataSender.Dispose();
dataSender.Close();
}
finally
{
NetMQConfig.Cleanup(false);
}
}
}