public void CreateContext()
{
NetMQConfig.ContextCreate();
var isTerminated = VerifyTermination();
Assert.AreEqual(false, isTerminated);
}
protected override void Run()
{
ForceDotNet.Force(); // this line is needed to prevent unity freeze after one use, not sure why yet
using (RequestSocket client = new RequestSocket())
{
//client.Connect("tcp://localhost:5555");
client.Connect("tcp://192.168.1.191:5566");
while (Running)
{
//Debug.Log("Sending Hello");
client.SendFrame("Hello");
string message = null;
bool gotMessage = false;
while (Running)
{
gotMessage = client.TryReceiveFrameString(out message); // this returns true if it's successful
if (gotMessage)
{
break;
}
}
if (gotMessage)
{
//Debug.Log("Received " + message);
callback(message);
}
}
}
NetMQConfig.Cleanup(); // this line is needed to prevent unity freeze after one use, not sure why yet
}
private void ListenerWork()
{
AsyncIO.ForceDotNet.Force();
using (var reqSocket = new RequestSocket())
{
string message = "";
if (_brushStrokeIndex == "")
{
message = _message + "," + _picture;
}
else
{
message = _message + "," + _picture + "," + _brushStrokeIndex + ',' + _brushValues;
}
//reqSocket.Connect("tcp://192.168.0.6:12345");
reqSocket.Connect("tcp://localhost:12345");
reqSocket.SendFrame(message);
string frameString = "";
while (frameString == null || frameString.Equals(""))
{
if (!reqSocket.TryReceiveFrameString(out frameString))
{
}
_messageQueue.Enqueue(frameString);
_messageDelegate(frameString);
}
reqSocket.Close();
}
NetMQConfig.Cleanup();
}
private void StatefullListenerEnqueueLoop()
{
OrLog(LogLevel.Verbose, "StatefullListenerEnqueueLoop start tcp://" + Room.ListenAddrV4 + ":" + Room.StatefullSubPort);
AsyncIO.ForceDotNet.Force();
using (var subSocket = new SubscriberSocket())
{
subSocket.Options.ReceiveHighWatermark = 1000;//default 1000
subSocket.Connect("tcp://" + Room.ListenAddrV4 + ":" + Room.StatefullSubPort);
subSocket.Subscribe("");
while (!statefullListenerEnqueueCancelled)
{
try
{
byte[] frameString;
if (!subSocket.TryReceiveFrameBytes(out frameString))
{
continue;
}
statefullQueue.Enqueue(frameString);
Thread.Yield();
}
catch (TerminatingException te)
{
OrLogWarn(LogLevel.Verbose, "Terminating Exception: " + te.Message);
break;
}
}
subSocket.Close();
}
NetMQConfig.Cleanup();
OrLog(LogLevel.Verbose, "StatefullListenerEnqueueLoop end");
}
private void ListenerWork()
{
AsyncIO.ForceDotNet.Force();
using (var server = new RouterSocket()) {
server.Bind("tcp://*:5555");
while (!_listenerCancelled)
{
//server.SkipFrame(); // to skip identity
string identity;
if (!server.TryReceiveFrameString(out identity))
{
continue;
}
//UnityEngine.Debug.LogFormat ("identity {0}", identity);
string message;
if (!server.TryReceiveFrameString(out message))
{
continue;
}
//UnityEngine.Debug.LogFormat ("message {0}", message);
//server.SendMoreFrame(identity).SendFrame("message");
Request request = new Request(server, identity, message);
_requestQueue.Enqueue(request);
}
}
NetMQConfig.Cleanup();
}
protected override void Run()
{
ForceDotNet.Force(); // this line is needed to prevent unity freeze after one use, not sure why yet
using (RequestSocket client = new RequestSocket())
{
client.Connect("tcp://localhost:5555");
while (Running)
{
Debug.Log("Request");
if (isReady)
{
client.SendFrame(makeAngleJSON());
string message = null;
bool gotMessage = false;
while (Running)
{
gotMessage = client.TryReceiveFrameString(out message); // this returns true if it's successful
if (gotMessage)
{
break;
}
}
if (gotMessage)
{
Debug.Log("Received " + message);
isReady = false;
}
}
}
}
NetMQConfig.Cleanup(); // this line is needed to prevent unity freeze after one use, not sure why yet
}
public void RequestMessage()
{
var messageReceived = false;
var message = "";
AsyncIO.ForceDotNet.Force();
var timeout = new TimeSpan(0, 0, 2);
using (var socket = new RequestSocket())
{
socket.Connect($"tcp://{_host}:{_port}");
if (socket.TrySendFrame("Hello"))
{
messageReceived = socket.TryReceiveFrameString(timeout, out message);
}
}
NetMQConfig.Cleanup();
if (!messageReceived)
{
message = "Could not receive message from server!";
}
_messageCallback(message);
}
public void sendRequest(byte[] imageAI)
{
ForceDotNet.Force();
using (RequestSocket client = new RequestSocket())
{
client.Connect("tcp://localhost:5555");
Debug.Log("Sending Picture");
client.SendFrame(imageAI);
string message = null;
bool gotMessage = false;
while (true)
{
gotMessage = client.TryReceiveFrameString(out message);
if (gotMessage)
{
break;
}
if (Input.GetKeyDown(KeyCode.Escape))
{
break;
}
}
if (gotMessage)
{
Debug.Log("Received " + message);
}
}
NetMQConfig.Cleanup();
}
public void Run()
{
try
{
while (true)
{
using (SubscriberSocket sock = new SubscriberSocket())
{
sock.Connect("tcp://eddn-relay.elite-markets.net:9500");
sock.SubscribeToAnyTopic();
Msg msg = new Msg();
msg.InitEmpty();
while (sock.TryReceive(ref msg, TimeSpan.FromMinutes(10)))
{
Process(msg);
msg.Close();
msg.InitEmpty();
}
}
}
}
finally
{
NetMQConfig.Cleanup();
}
}
public void Shutdown()
{
if (_socket != null)
{
try
{
_socket.Close();
}
catch (Exception)
{
}
try
{
_socket.Dispose();
}
catch (Exception)
{
}
}
_socket = null;
_finished = true;
_worker.Join();
NetMQConfig.Cleanup(true);
}
// Start is called before the first frame update
public void Start()
{
SetDefaultListenerPosition();
string[] args = System.Environment.GetCommandLineArgs();
for (int i = 0; i < args.Length; i++)
{
Debug.Log("ARG " + i + ": " + args[i]);
if (args[i].Contains("ignitebot"))
{
isIgniteBotEmbedded = true;
break;
}
}
playerObject = GameObject.Find("Player Listener");
if (isIgniteBotEmbedded)
{
AsyncIO.ForceDotNet.Force();
NetMQConfig.Cleanup();
poller = new NetMQPoller();
subSocket = new SubscriberSocket();
subSocket.ReceiveReady += OnReceiveReady;
subSocket.Options.ReceiveHighWatermark = 10;
subSocket.Connect(addr);
subSocket.Subscribe("RawFrame");
subSocket.Subscribe("CloseApp");
subSocket.Subscribe("MatchEvent");
poller.Add(subSocket);
poller.RunAsync();
}
}
private void nameGetterWork()
{
AsyncIO.ForceDotNet.Force();
using (var subSocket = new SubscriberSocket())
{
subSocket.Options.ReceiveHighWatermark = 1;
subSocket.Connect(_serverIP);
subSocket.Subscribe("");
while (!_nameGetterCancelled)
{
if (!subSocket.TryReceiveFrameString(out _newJsonString))
{
continue;
}
if (!_newJsonString.Equals(_jsonString))
{
_jsonString = _newJsonString;
_messageDelegate(_jsonString);
}
}
subSocket.Close();
}
NetMQConfig.Cleanup();
}
private void StatelessListenerLoop()
{
OrLog(LogLevel.Verbose, "StatelessListenerLoop start tcp://" + Room.ListenAddrV4 + ":" + Room.StatelessDealPort);
AsyncIO.ForceDotNet.Force();
using (var dealerSocket = new DealerSocket())
{
dealerSocket.Options.ReceiveHighWatermark = 1;
dealerSocket.Connect("tcp://" + Room.ListenAddrV4 + ":" + Room.StatelessDealPort);
while (!statelessListenerCancelled)
{
if (!IsMessageQueueRunning)
{
continue;
}
byte[] message;
if (statelessQueue.TryDequeue(out message))
{
dealerSocket.SendFrame(message, false);
}
Thread.Yield();
}
dealerSocket.Close();
}
NetMQConfig.Cleanup();
OrLog(LogLevel.Verbose, "StatelessListenerLoop end");
}
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);
}
}
}
/**
* Performs actual task of connecting to server and attempting to retreive JSON information about connections
*/
private void nameGetterWork()
{
AsyncIO.ForceDotNet.Force();
//Subscriber socket, connect to server and listen
using (var subSocket = new SubscriberSocket())
{
subSocket.Options.ReceiveHighWatermark = 1;
subSocket.Connect(_serverIP);
subSocket.Subscribe("");
//While still running
while (!_nameGetterCancelled)
{
//Attempt to grab a string from server
if (!subSocket.TryReceiveFrameString(out _newJsonString))
{
continue;
}
//If the string is not equal to the previous string, we have an update
if (!_newJsonString.Equals(_jsonString))
{
//Assign the new string as our current string, then forward our message to the messageDelegate function
Debug.Log("New JSON is " + _newJsonString);
_jsonString = _newJsonString;
_messageDelegate(_jsonString);
}
}
//Close socket
subSocket.Close();
}
//Cleanup
NetMQConfig.Cleanup();
}
protected override void Run()
{
ForceDotNet.Force(); // this line is needed to prevent unity freeze after one use, not sure why yet
Debug.Log("Subscriber started");
using (var subSocket = new SubscriberSocket())
{
//subSocket.Options.ReceiveHighWatermark = 1000;
subSocket.Connect("tcp://127.0.0.1:5555");
subSocket.Subscribe("22");
Console.WriteLine("Subscriber socket connecting...");
while (Running)
{
string messageTopicReceived = subSocket.ReceiveFrameString();
string messageReceived = subSocket.ReceiveFrameString();
//Debug.Log(messageReceived);
carFrontX = Convert.ToSingle(messageReceived.Split(' ')[1]) / 100;
carFrontZ = Convert.ToSingle(messageReceived.Split(' ')[2]) / 100;
carBackX = Convert.ToSingle(messageReceived.Split(' ')[3]) / 100;
carBackZ = Convert.ToSingle(messageReceived.Split(' ')[4]) / 100;
//Debug.Log(carFrontX.ToString() + ":" + carFrontZ.ToString() + " " +carBackX.ToString() + ":" + carBackZ.ToString());
}
}
NetMQConfig.Cleanup(); // this line is needed to prevent unity freeze after one use, not sure why yet
}
protected override void Run()
{
ForceDotNet.Force(); // this line is needed to prevent unity freeze after one use, not sure why yet
using (RequestSocket client = new RequestSocket())
{
client.Connect("tcp://localhost:5555");
while (Running)
{
if (waitingForRequest != null)
{
string message;
bool gotMessage = client.TryReceiveFrameString(out message);
if (gotMessage)
{
waitingForRequest.image.RecieveResults(waitingForRequest.request, message);
waitingForRequest = null;
}
}
else if (requests.Count > 0)
{
var request = requests.Dequeue();
client.SendFrame(request.request.HamiltonianString());
waitingForRequest = request;
}
}
}
NetMQConfig.Cleanup(); // this line is needed to prevent unity freeze after one use, not sure why yet
}
void NetMQClient()
{
AsyncIO.ForceDotNet.Force();
requestSocket = new RequestSocket();
requestSocket.Connect("tcp://127.0.0.1:5555");
while (!requestsCancelled)
{
}
requestSocket.Close();
NetMQConfig.Cleanup();
//using (var reqSocket = new RequestSocket())
//{
// reqSocket.Connect("tcp://127.0.0.1:5555");
// while (!requestsCancelled)
// {
// if (frame != null)
// {
// reqSocket.SendMoreFrame("F");
// string frameBase64 = System.Convert.ToBase64String(frame);
// reqSocket.SendFrame(frameBase64);
// var msg = reqSocket.ReceiveFrameString();
// print("From Server: " + msg);
// }
// }
// reqSocket.Close();
//}
//NetMQConfig.Cleanup();
}
public void TearDown()
{
_client?.Dispose();
_hdServer?.Dispose();
_rtServer?.Dispose();
NetMQConfig.Cleanup();
}
public async Task RestartAsync()
{
ITransport transport = CreateTransport();
try
{
await InitializeAsync(transport);
Assert.True(transport.Running);
await transport.StopAsync(TimeSpan.Zero);
Assert.False(transport.Running);
if (transport is NetMQTransport)
{
NetMQConfig.Cleanup(false);
}
await InitializeAsync(transport);
Assert.True(transport.Running);
}
finally
{
transport.Dispose();
}
}
//application close behaviour
private void Window_Closed(object sender, EventArgs e)
{
NetMQConfig.Cleanup();
Settings.Default.Save();
Application.Current.Shutdown();
Process.GetCurrentProcess().Kill(); //needs kill if user uses location service
}
// Client thread which does not block Update()
void NetMQClient()
{
AsyncIO.ForceDotNet.Force();
NetMQConfig.ManualTerminationTakeOver();
NetMQConfig.ContextCreate(true);
//string msg;
var timeout = new System.TimeSpan(0, 0, 1); //1sec
Debug.Log("Connect to the server.");
pairSocket = new NetMQ.Sockets.PairSocket();
pairSocket.Options.ReceiveHighWatermark = 0;
//pairSocket.Connect("tcp://192.168.1.122:55555");
pairSocket.Connect("tcp://192.168.1.111:55555");
is_connected = true;
while (is_connected && stop_thread_ == false)
{
is_connected = pairSocket.TryReceiveFrameString(timeout, out msg);
pairSocket.TrySendFrame(timeout, final);
}
pairSocket.Close();
Debug.Log("ContextTerminate.");
NetMQConfig.ContextTerminate();
NetMQConfig.Cleanup();
}
protected override void OnDestroy()
{
NetMQConfig.Cleanup(false);
base.OnDestroy();
_store.Dispose();
}
void SocketThreadLoop()
{
while (true)
{
threadRunning = true;
senderCancelled = false;
AsyncIO.ForceDotNet.Force();
using (var sock = new PairSocket())
{
sock.Connect("tcp://" + ip + ":" + port);
while (!senderCancelled)
{
if (!framePending)
{
continue;
}
sock.SendFrame(msgBuffer);
framesSent++;
framePending = false;
}
sock.Close();
}
NetMQConfig.Cleanup();
threadRunning = false;
}
}
/// <summary>
///
/// </summary>
public void CleanUp()
{
try {
lock (this._stop_lock) {
this._stop_thread = true;
}
if (this._use_inter_process_communication)
{
this._socket.Disconnect("ipc:///tmp/neodroid/messages");
}
else
{
this._socket.Disconnect("tcp://" + this._ip_address + ":" + this._port);
}
try {
this._socket.Dispose();
this._socket.Close();
} finally {
NetMQConfig.Cleanup(false);
}
this._wait_for_client_thread?.Join();
this._polling_thread?.Join();
} catch {
Console.WriteLine("Exception thrown while killing threads");
}
}
private void OnApplicationQuit()
{
Debug.Log("ZMQ Quit: Cleanup socket");
_pubSocket.Unbind("tcp://127.0.0.1:12345");
_pubSocket.Dispose();
NetMQConfig.Cleanup(false);
}
private void ListenerWork()
{
////Console.Write("Starting listener thread");
//System.Diagnostics.Debug.Write("STARTING LISTENER THREAD");
AsyncIO.ForceDotNet.Force();
using (var subSocket = new SubscriberSocket())
{
//System.Diagnostics.Debug.Write("conn");
subSocket.Options.ReceiveHighWatermark = 1000;
subSocket.Connect("tcp://127.0.0.1:1339");
subSocket.Subscribe("");
while (!_listenerCancelled)
{
//string frameString;
List <string> strs = new List <string>();
//if (!subSocket.TryReceive(out frameString)) continue;
byte[] arr;
if (!subSocket.TryReceiveFrameBytes(out arr))
{
continue;
}
//Console.Write("REC");
Face fc = Face.Parser.ParseFrom(arr);
_messageQueue.Enqueue(fc.ToString());
}
subSocket.Close();
}
NetMQConfig.Cleanup();
}
protected /*override*/ void Run2()
{
ForceDotNet.Force();
using (RequestSocket client = new RequestSocket())
{
client.Connect("tcp://localhost:5555");
while (running)
{
//Debug.Log("Sending Hello");
//client.SendFrame("subject: " + subject.x + "; " + subject.y);
client.SendFrame(JsonUtility.ToJson(subject));
Debug.Log("Sent " + JsonUtility.ToJson(subject));
string message = null;
bool gotMessage = false;
while (running)
{
gotMessage = client.TryReceiveFrameString(out message);
if (gotMessage)
{
break;
}
}
if (gotMessage)
{
Debug.Log("Received " + message);
UnityMainThreadDispatcher.Instance().Enqueue(HandleMessage(message));
}
}
}
NetMQConfig.Cleanup();
}
public override void Run()
{
ForceDotNet.Force(); // this line is needed to prevent unity freeze after one use
using (RequestSocket client = new RequestSocket())
{
client.Connect("tcp://localhost:5555");
string signal = "None";
bool gotMessage = false;
//Debug.Log("----Sending Signal----");
client.SendFrame(message);
while (Running)
{
gotMessage = client.TryReceiveFrameString(out signal); // this returns true if it's successful
if (gotMessage)
{
break;
}
}
if (gotMessage)
{
//Debug.Log("----Recived Signal: " + signal);
EmotionInput.activeEmotion = signal;
Running = false;
}
}
NetMQConfig.Cleanup(); // this line is needed to prevent unity freeze after one use
}
private static void Main()
{
Console.WriteLine("Creating socket..");
using (var pushSocket = new PushSocket(">tcp://localhost:5556")
{
/* So apparently this is needed to prevent the socket from being immediately disposed
* after the last instruction of the using block.
* With this setting, the socket shall be disposed only after the message has been sent.
* This is equivalent to say "wait forever", but someone may arguably want to set a finite
* amount of time when in production.
*/
Options = { Linger = TimeSpan.FromSeconds(-1) }
})
{
Console.WriteLine("Creating message..");
var message = new Message
{
Text = "test message",
TimeStamp = DateTime.Now,
Type = "test",
ValueCode = 0
};
Console.WriteLine("Serializing message..");
using (var memoryStream = new MemoryStream())
{
var binaryFormatter = new BinaryFormatter();
binaryFormatter.Serialize(memoryStream, message);
var serializedMessage = memoryStream.ToArray();
Console.WriteLine("Sending message..");
pushSocket.SendFrame(serializedMessage);
}
}
Console.WriteLine("Performing cleanup..");
NetMQConfig.Cleanup();
}
