private void StartWorkProc()
{
if (null != _worker)
{
_worker.Close();
_worker.Dispose();
}
_workProc = Task.Run(DoStart, _cancel.Token).ConfigureAwait(false);
}
private TimeoutException Timeout()
{
socket.Close();
keepAliveTimer?.Stop();
if (AutoRestartOnTimeout)
{
socket.Dispose();
CreateSocket();
}
return(new TimeoutException());
}
private void OnDestroy()
{
client.SendFrame("END");
client.Disconnect("tcp://localhost:5555");
client.Dispose();
NetMQConfig.Cleanup(); // this line is needed to prevent unity freeze after one use
}
private void StopQueryMQ()
{
try
{
if (null != _queryPoller)
{
if (null != _querySocket)
{
_queryPoller.Remove(_querySocket);
}
if (_queryPoller.IsRunning)
{
_queryPoller.Stop();
}
_queryPoller.Dispose();
_queryPoller = null;
}
if (null != _querySocket)
{
_querySocket.ReceiveReady -= _querySocket_ReceiveReady;
_querySocket.SendReady -= _querySocket_SendReady;
//_querySocket.Disconnect(_querySocket.Options.LastEndpoint);
_querySocket.Dispose();
_querySocket = null;
}
_queryMsgList.Clear();
}
catch (Exception ex)
{
}
}
public void Dispose()
{
if (_incoming == default || _incoming.IsDisposed)
{
return;
}
_incoming?.Dispose();
}
/// <summary>
///
/// </summary>
/// <param name="address"></param>
/// <param name="buf"></param>
/// <returns></returns>
public byte[] Send(string address, byte[] buf)
{
var client = new RequestSocket(">tcp://" + address); // connect
client.SendFrame(buf);
byte[] result = client.ReceiveFrameBytes();
client.Close();
client.Dispose();
return(result);
}
private static bool Send(string msg, out string response)
{
using (var client = new RequestSocket())
{
client.Connect(push_server);
client.TrySendFrame(new TimeSpan(0, 0, 3), Encoding.UTF8.GetBytes(msg));
bool result = client.TryReceiveFrameString(new TimeSpan(0, 0, 3), Encoding.UTF8, out response);
client.Close();
client.Dispose();
return(result);
}
}
private void StopStationNetMQ()
{
// HockSocketEvents(false);
try
{
if (null != _poller)
{
if (null != _subscriber)
{
_poller.Remove(_subscriber);
}
if (null != _requester)
{
_poller.Remove(_requester);
}
//_poller.Remove(_fileSubscriber);
if (_poller.IsRunning)
{
_poller.Stop();
}
_poller.Dispose();
_poller = null;
}
if (null != _subscriber)
{
_subscriber.Dispose();
_subscriber = null;
}
if (null != _requester)
{
_requester.Dispose();
_requester = null;
}
//_fileSubscriber.Dispose();
//_fileSubscriber = null;
}
catch (Exception err)
{
logger.ErrorFormat("Disconnect pub-sub error:{0}", err);
}
// this.OnDisconnected();
}
public void Disconnect()
{
// Close the Listen thread first so sockets will be free
connected = false;
listenThread.Join();
// Then request that the server remove and cleanup anything
// associated with this connection
Request(req_end);
// Finally dispose of any sockets
world.Dispose();
interaction.Dispose();
}
protected override void Run()
{
ForceDotNet.Force(); // this line is needed to prevent unity freeze after one use, not sure why yet
using (server = new ResponseSocket()) // check if its response or request ?
{
server.Bind("tcp://*:1234"); //SEND
using (client = new RequestSocket())
{
client.Connect("tcp://localhost:2222"); // RECIEVE
// for (int i = 0; i < 2 && Running; i++)
while (Running)
{
// TO BE ABLE TO SEND USING SERVER SOCKET:
string DummyServerReceive = server.ReceiveFrameString();
//Debug.Log("MY DUMMY SERVER REC: " + DummyServerReceive);
//SENDING TO SERVER : //SEND A VARIABLE BOOLEAN HERE
server.SendFrame(Mode + "," + Yindex + "," + Xindex + "," + Resign + "," + Pass + "," + HumanColor);
//Pass = "******";
//Resign = "-1";
//Debug.Log("SERVER IS DONE ");
// DUMMY SEND OF CLIENT TO RECEIVE
client.SendFrame("HELLOOOOOOO");
while (Running)
{
message = client.ReceiveFrameString(); // this returns true if it's successful
//Debug.Log("MESSAGE IS :" + this.message);
break;
}
}
client.Disconnect("tcp://localhost:2222");
client.Close();
client.Dispose();
}
server.Disconnect("tcp://*:1234");
server.Close();
server.Dispose();
}
NetMQConfig.Cleanup();
}
public Task RequestBatteryState()
{
var requestSocket = new RequestSocket();
requestSocket.Connect("tcp://127.0.0.1:3782");
var request = new PiTopMessage(PiTop4MessageId.REQ_GET_BATTERY_STATE);
requestSocket.SendFrame(request.ToString());
return Task.Run(() =>
{
var messageString = requestSocket.ReceiveFrameString();
requestSocket.Dispose();
var message = PiTopMessage.Parse(messageString);
MessageReceived?.Invoke(this, message);
});
}
public void Disconnect()
{
// First we set connected to false to prevent any new negotiations
// while we are trying to disconnect. Then we request to end the
// connection cleanly. This is a request to send the 'client end'
// event from the world server which also send it to ourselves to
// wakeup any errant listener threads
connected = false;
Request(req_end);
listenThread.Join();
// Finally dispose of any sockets
world.Dispose();
interaction.Dispose();
}
protected void Cleanup()
{
ClientFiber.Enqueue(() =>
{
Client.Dispose();
ClientContext.Dispose();
Thread.Sleep(10);
Service.Dispose();
ServerContext.Dispose();
});
Thread.Sleep(100);
Console.WriteLine("Dispose client fiber");
ClientFiber.Dispose();
Console.WriteLine("Dispose service");
ServerFiber.Dispose();
}
public static NetMQMessage SendRequest(NetMQMessage requestMessage)
{
using (var requestSocket = new RequestSocket(_facadeAddress))
{
requestSocket.SendMultipartMessage(requestMessage);
NetMQMessage responseMessage = null;
TimeSpan timeSpan = new TimeSpan(10, 0, 15);
requestSocket.TryReceiveMultipartMessage(timeSpan, ref responseMessage);
requestSocket.Disconnect(_facadeAddress);
requestSocket.Dispose();
return(responseMessage);
}
}
static void Main(string[] args)
{
using (NetMQContext context = NetMQContext.Create())
{
RequestSocket client = CreateServerSocket(context);
while (_retriesLeft > 0)
{
_sequence++;
Console.WriteLine("C: Sending ({0})", _sequence);
client.Send(Encoding.Unicode.GetBytes(_sequence.ToString()));
_expectReply = true;
while (_expectReply)
{
bool result = client.Poll(TimeSpan.FromMilliseconds(REQUEST_TIMEOUT));
if (!result)
{
_retriesLeft--;
if (_retriesLeft == 0)
{
Console.WriteLine("C: Server seems to be offline, abandoning");
break;
}
else
{
Console.WriteLine("C: No response from server, retrying...");
client.Disconnect(SERVER_ENDPOINT);
client.Close();
client.Dispose();
client = CreateServerSocket(context);
client.Send(Encoding.Unicode.GetBytes(_sequence.ToString()));
}
}
}
}
}
}
private bool Send(string cmd, ref string response)
{
try
{
using (var client = new RequestSocket())
{
client.Connect(server);
client.TrySendFrame(new TimeSpan(0, 0, 3), Encoding.UTF8.GetBytes(cmd));
bool result = client.TryReceiveFrameString(new TimeSpan(0, 0, 3), Encoding.UTF8, out response);
client.Close();
client.Dispose();
return(result);
}
}
catch (Exception ex)
{
NLog.Error("交易指令异常" + cmd, ex);
}
return(false);
}
public ReqSocket(string address, NetMQContext context)
{
_reqSocket = context.CreateRequestSocket();
_reqSocket.Options.ReceiveTimeout = TimeSpan.FromSeconds(10);
_reqSocket.Options.Linger = TimeSpan.Zero;
try
{
_reqSocket.Connect(address);
}
catch
{
try
{
_reqSocket.Dispose();
}
catch
{
}
throw;
}
}
public void Client(NodeDto connectingNode,
DhtProtocolCommandDto protocolCommandDto)
{
var cleanAddress = connectingNode.IpAddress.Replace("127.0.0.1", "localhost");
var address = $"tcp://{cleanAddress}:{connectingNode.Port}";
RequestSocket client = null;
// client = _clients.FirstOrDefault(socket => socket.Options.LastEndpoint.Equals(address));
// if (client == null)
// {
// client = new RequestSocket();
// _clients.Add(client);
// }
try
{
client = new RequestSocket();
client.Connect(address);
client.TrySendFrame(protocolCommandDto.ToString());
client.TryReceiveSignal(out bool signal);
}
catch (NetMQException e)
{
Log.Logger.Error(e, e.Message);
Log.Debug(e.ErrorCode.ToString());
Log.Debug(e.StackTrace);
Log.Debug(e.Message);
}
catch (Exception exception)
{
Log.Logger.Error(exception, exception.Message);
Log.Debug(exception.Message);
}
finally
{
// _clients.Remove(client);
client?.Disconnect(address);
client?.Dispose();
}
}
private void Listen()
{
log.Info("Session manager is starting.");
requestSocket = new RequestSocket();
switch (sessionType)
{
case eSessionType.Local:
requestSocket.Connect("inproc://opendiablo2-session");
break;
case eSessionType.Server:
case eSessionType.Remote:
default:
throw new OpenDiablo2Exception("This session type is currently unsupported.");
}
running = true;
resetEvent.WaitOne();
running = false;
requestSocket.Dispose();
log.Info("Session manager has stopped.");
}
private static List <HQItem> Query(string codes)
{
try
{
using (var client = new RequestSocket())
{
string cmd = string.Format("8001|{0}", codes);
string response;
client.Connect(query_server);
client.TrySendFrame(new TimeSpan(0, 0, 3), Encoding.UTF8.GetBytes(cmd));
bool result = client.TryReceiveFrameString(new TimeSpan(0, 0, 3), Encoding.UTF8, out response);
client.Close();
client.Dispose();
if (result && !string.IsNullOrWhiteSpace(response) && response.StartsWith("80001|"))
{
string[] datas = response.Substring(7).Replace("}", "").Split('{');
return(Deal(datas));
}
}
}
catch
{ }
return(new List <HQItem>());
}
/// <summary>清理资源</summary>
protected override void OnDispose()
{
_socket.Dispose();
}
public void Close()
{
poller.StopAsync();
socket.Dispose();
}
public void Dispose()
{
_requestSocket.Dispose();
}
private void OnDestroy()
{
_client.Dispose();
NetMQConfig.Cleanup(); // this line is needed to prevent unity freeze after one use, not sure why yet
}
protected void CloseSocket()
{
keepAliveTimer?.Stop();
socket?.Dispose();
socket = null;
}
//!
//! receiver function, receiving the initial scene from the katana server (executed in separate thread)
//!
public void sceneReceiver()
{
AsyncIO.ForceDotNet.Force();
using (var sceneReceiver = new RequestSocket())
{
print("Trying to receive scene.");
OnProgress(0.1f, "Init Scene Receiver..");
sceneReceiver.Connect("tcp://" + VPETSettings.Instance.serverIP + ":5565");
print("Server set up.");
byte[] byteStream;
// HEader
print("header");
sceneReceiver.SendFrame("header");
byteStream = sceneReceiver.ReceiveFrameBytes();
print("byteStreamHeader size: " + byteStream.Length);
if (doWriteScene)
{
writeBinary(byteStream, "header");
}
sceneLoader.SceneDataHandler.HeaderByteData = byteStream;
OnProgress(0.15f, "..Received Header..");
#if TRUNK
// Materials
print("materials");
sceneReceiver.SendFrame("materials");
byteStream = sceneReceiver.ReceiveFrameBytes();
print("byteStreamMatrilas size: " + byteStream.Length);
if (doWriteScene)
{
writeBinary(byteStream, "materials");
}
sceneLoader.SceneDataHandler.MaterialsByteData = byteStream;
OnProgress(0.20f, "..Received Materials..");
#endif
// Textures
if (VPETSettings.Instance.doLoadTextures)
{
print("textures");
sceneReceiver.SendFrame("textures");
byteStream = sceneReceiver.ReceiveFrameBytes();
print("byteStreamTextures size: " + byteStream.Length);
if (doWriteScene)
{
writeBinary(byteStream, "textures");
}
sceneLoader.SceneDataHandler.TexturesByteData = byteStream;
OnProgress(0.33f, "..Received Texture..");
}
// Objects
print("objects");
sceneReceiver.SendFrame("objects");
byteStream = sceneReceiver.ReceiveFrameBytes();
print("byteStreamObjects size: " + byteStream.Length);
if (doWriteScene)
{
writeBinary(byteStream, "objects");
}
sceneLoader.SceneDataHandler.ObjectsByteData = byteStream;
OnProgress(0.80f, "..Received Objects..");
// Nodes
print("nodes");
sceneReceiver.SendFrame("nodes");
byteStream = sceneReceiver.ReceiveFrameBytes();
print("byteStreamNodes size: " + byteStream.Length);
if (doWriteScene)
{
writeBinary(byteStream, "nodes");
}
sceneLoader.SceneDataHandler.NodesByteData = byteStream;
OnProgress(0.9f, "..Received Nodes..");
// Characters
print("characters");
sceneReceiver.SendFrame("characters");
byteStream = sceneReceiver.ReceiveFrameBytes();
print("byteStreamCharacters size: " + byteStream.Length);
if (doWriteScene)
{
writeBinary(byteStream, "characters");
}
sceneLoader.SceneDataHandler.CharactersByteData = byteStream;
OnProgress(0.9f, "..Received Characters..");
sceneReceiver.Disconnect("tcp://" + VPETSettings.Instance.serverIP + ":5565");
sceneReceiver.Close();
sceneReceiver.Dispose();
}
//NetMQConfig.Cleanup();
print("done receive scene");
m_sceneTransferDirty = true;
OnProgress(1.0f, "..Building Scene..");
}
public void Dispose()
{
_monitor?.Dispose();
_socket?.Dispose();
}
public void Dispose()
{
request.Dispose();
}
public void Stop()
{
_client.Close();
_client.Dispose();
}
public void Dispose()
{
_socket?.Dispose();
}
