/// <summary>
/// 断掉连接，重新连接
/// </summary>
void ReconnectIfDis()
{
///
/// 超时处理
///
isConnected = false;
if (reqSock != null)
{
reqSock.Disconnect(ConnectingAddress);
reqSock.Close();
}
ConsoleEx.DebugLog("HeartBeat socket is Connecting...", ConsoleEx.RED);
var context = Core.ZeroMQ;
reqSock = context.CreateRequestSocket();
reqSock.Options.SendHighWatermark = EngCfg.HighWatermark;
reqSock.Options.ReceiveHighWatermark = EngCfg.HighWatermark;
//生成通讯地址和协议方式
ConnectingAddress = ConnectAddr(typeof(HeartBeatClient));
reqSock.Connect(ConnectingAddress);
isConnected = true;
RepeatTimer.Change(IntervalPeriod, Timeout.Infinite);
}
/// <summary>
/// 断掉连接，重新连接
/// </summary>
public void ReceiveTimeout()
{
ConsoleEx.DebugLog("Req Sock is timeout.", ConsoleEx.RED);
///
/// 超时处理
///
connected = false;
if (reqSock != null)
{
reqSock.Disconnect(ConnectingAddress);
reqSock.Close();
}
establish(Reconnected);
}
public int setAddr(string ip)
{
if (ip.Length == 0)
{
return(-1);
}
if (addr.Length != 0)
{
client.Disconnect(addr);
}
addr = "tcp://" + ip + ":" + port.ToString();
Console.WriteLine("Connect to " + addr);
client.Connect(addr);
return(0);
}
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
}
public Result GetRepositories(string query)
{
var watch = Stopwatch.StartNew();
_answer = null;
_repositories = null;
using (var client = new RequestSocket())
{
client.Connect(EndpointProvider.Address);
byte[] load = Encoding.UTF8.GetBytes(query);
client.SendFrame(load);
client.ReceiveReady += ClientOnReceiveReady;
client.Poll(TimeSpan.FromMilliseconds(3000));
client.ReceiveReady -= ClientOnReceiveReady;
client.Disconnect(EndpointProvider.Address);
}
watch.Stop();
return(new Result()
{
Answer = _answer ?? GetErrorMessage(),
DurationMilliseconds = watch.ElapsedMilliseconds,
Repositories = _repositories ?? new Repository[0]
});
}
public void Connect(string hostName, int port)
{
try
{
_address = $"tcp://{hostName}:{port}";
_incoming.Connect(_address);
_out?.WriteInfoLine($"{_id}: Socket connected to {_address}");
if (!_protocol.Handshake(_incoming))
{
throw new InvalidOperationException($"{_id}: Handshake failed");
}
}
catch (Exception e)
{
_out?.WriteErrorLine($"{_id}: {e}");
_incoming.Disconnect(_address);
Dispose();
}
}
public Status setAddr(string ip)
{
if (ip.Length == 0)
{
return(Status.Error);
}
if (addr.Length != 0)
{
client.Disconnect(addr);
}
addr = "tcp://" + ip + ":" + PORT.ToString();
Console.WriteLine("Connect to " + addr);
try
{
client.Connect(addr);
}
catch (Exception e)
{
Console.WriteLine("Network Error.Please check your IP address and network connection!");
return(Status.Error);
}
return(Status.Success);
}
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 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);
}
}
public TResponse RemoteProcedureCall <TParam, TResponse>(MethodBase method, TParam parameter)
{
using var socket = new RequestSocket();
socket.Connect(this.connectPath);
if (parameter != null)
{
socket
.SendMoreFrame(this.apiVersion)
.SendMoreFrame(this.systemToken)
.SendMoreFrame(method.Name)
.SendMoreFrame(parameter.GetType().FullName)
.SendFrame(JsonSerializer.Serialize(parameter));
}
else
{
socket
.SendMoreFrame(this.apiVersion)
.SendMoreFrame(this.systemToken)
.SendMoreFrame(method.Name)
.SendMoreFrameEmpty()
.SendFrameEmpty();
}
var frames = new List <string>();
if (socket.TryReceiveMultipartStrings(new TimeSpan(0, 0, 3), Encoding.UTF8, ref frames))
{
if (frames[0] != RpcStatus.OK)
{
throw new Exception($"RPC call failed: {frames[0]}");
}
if (typeof(TResponse) != TypeResolver.GetType(frames[1]))
{
throw new Exception($"RPC call failed: type mismatch");
}
socket.Disconnect(this.connectPath);
return(JsonSerializer.Deserialize <TResponse>(frames[2]));
}
else
{
throw new TimeoutException();
}
}
public bool IsListening()
{
var isListening = false;
var endPoint = Binding + "://" + _ipAddress + ":" + _tcpPort.ToString();
using (var requester = new RequestSocket(endPoint))
{
if (requester.TrySendFrame(TimeSpan.FromSeconds(2), _outgoingByte) &&
requester.TryReceiveFrameBytes(TimeSpan.FromSeconds(2), out _incomingByte))
{
isListening = true;
}
requester.Disconnect(endPoint);
}
return(isListening);
}
private static bool TryRequest(string endpoint, string requestString)
{
Console.WriteLine("Trying echo service at {0}", endpoint);
using (var client = new RequestSocket())
{
client.Options.Linger = TimeSpan.Zero;
client.Connect(endpoint);
client.SendFrame(requestString);
client.ReceiveReady += ClientOnReceiveReady;
bool pollResult = client.Poll(TimeSpan.FromMilliseconds(RequestTimeout));
client.ReceiveReady -= ClientOnReceiveReady;
client.Disconnect(endpoint);
return(pollResult);
}
}
private static bool TryRequest(string endpoint, string requestString)
{
Console.WriteLine("Trying echo service at {0}", endpoint);
using (var client = new RequestSocket())
{
client.Options.Linger = TimeSpan.Zero;
client.Connect(endpoint);
client.SendFrame(requestString);
client.ReceiveReady += ClientOnReceiveReady;
bool pollResult = client.Poll(TimeSpan.FromMilliseconds(RequestTimeout));
client.ReceiveReady -= ClientOnReceiveReady;
client.Disconnect(endpoint);
return pollResult;
}
}
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()));
}
}
}
}
}
}
/// <summary>
/// 关闭套接字
/// </summary>
private void CloseSocket()
{
lock (this)
{
if (_socket == null)
{
return;
}
try
{
_socket.Disconnect(Config.InnerAddress);
}
catch (Exception)
{
//LogRecorder.Exception(e);//一般是无法连接服务器而出错
}
_socket.Close();
_socket = null;
}
}
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();
}
}
public MessageFrame <THeader, TPayload> SendRequest(MessageFrame <THeader, TPayload> requestMessage)
{
var endPoint = Binding + "://" + _ipAddress + ":" + _tcpPort.ToString();
using (var requester = new RequestSocket(endPoint))
{
// Connect
requester.Connect(endPoint);
// Send
requester.SendFrame(ObjectToByteArray(requestMessage), false);
// Receive
//TODO: Implement time-out
byte[] response = requester.ReceiveFrameBytes();
requestMessage = Deserialize <MessageFrame <THeader, TPayload> >(response);
requester.Disconnect(endPoint);
}
return(requestMessage);
}
private static void Disconnect()
{
loggerServer.Disconnect(Address);
loggerServer = null;
Conneceted = false;
}
//!
//! 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..");
}
private static void TerminateClient(RequestSocket client)
{
client.Disconnect(ServerEndpoint);
client.Close();
}
private static void TerminateClient(RequestSocket client)
{
client.Disconnect(SERVER_ENDPOINT);
client.Close();
}
//!
//! 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");
}
int dataIdx = 0;
VPETSettings.Instance.lightIntensityFactor = BitConverter.ToSingle(byteStream, dataIdx);
print("VPETSettings.Instance.lightIntensityFactor " + VPETSettings.Instance.lightIntensityFactor);
dataIdx += sizeof(float);
VPETSettings.Instance.textureBinaryType = BitConverter.ToInt32(byteStream, dataIdx);
OnProgress(0.15f, "..Received Header..");
//VpetHeader vpetHeader = SceneDataHandler.ByteArrayToStructure<VpetHeader>(byteStream, ref dataIdx);
//VPETSettings.Instance.lightIntensityFactor = vpetHeader.lightIntensityFactor;
//VPETSettings.Instance.textureBinaryType = vpetHeader.textureBinaryType;
// Textures
if (VPETSettings.Instance.doLoadTextures)
{
print("textures");
sceneReceiver.SendFrame("textures");
byteStream = sceneReceiver.ReceiveFrameBytes();
print("byteStreamTextures size: " + byteStream.Length);
if (doWriteScene)
{
writeBinary(byteStream, "textu");
}
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, "objec");
}
sceneLoader.SceneDataHandler.ObjectsByteData = byteStream;
OnProgress(0.80f, "..Received Objects..");
// Nodes
print("nodes");
sceneReceiver.SendFrame("nodes");
byteStream = sceneReceiver.ReceiveFrameBytes();
print("byteStreamNodess size: " + byteStream.Length);
if (doWriteScene)
{
writeBinary(byteStream, "nodes");
}
sceneLoader.SceneDataHandler.NodesByteData = byteStream;
OnProgress(0.9f, "..Received Nodes..");
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..");
}
private static void TerminateClient(RequestSocket client)
{
client.Disconnect(ServerEndpoint);
client.Close();
}
private static void TerminateClient(RequestSocket client)
{
client.Disconnect(SERVER_ENDPOINT);
client.Close();
}
public void close()
{
client.Disconnect(ServerEndpoint);
client.Close();
Debug.Log($"C: Frame disconnected...{ServerEndpoint}");
}
public override bool Disconnect()
{
Client.Disconnect(ConnectionC);
//Server.Disconnect(ConnectionS);
return(true);
}
