/// <summary>
/// 发送返回值
/// </summary>
/// <param name="socket"></param>
/// <param name="item"></param>
/// <param name="state"></param>
/// <returns></returns>
private bool SendResult(ref ZSocket socket, ApiCallItem item, ZeroOperatorStateType state)
{
if (!CanLoop)
{
ZeroTrace.WriteError("SendResult", "is closed", StationName);
return(false);
}
if (item.Result == null)
{
return(SendResult(ref socket, new ZMessage
{
new ZFrame(item.Caller),
new ZFrame(new byte[]
{
2, (byte)state, ZeroFrameType.Requester, ZeroFrameType.GlobalId
}),
new ZFrame(item.Requester.ToZeroBytes()),
new ZFrame((item.GlobalId).ToZeroBytes())
}));
}
return(SendResult(ref socket, new ZMessage
{
new ZFrame(item.Caller),
new ZFrame(new byte[]
{
3, (byte)state, ZeroFrameType.JsonValue, ZeroFrameType.Requester, ZeroFrameType.GlobalId
}),
new ZFrame((item.Result).ToZeroBytes()),
new ZFrame(item.Requester.ToZeroBytes()),
new ZFrame((item.GlobalId).ToZeroBytes())
}));
}
private void ApiCallNoMonitor(ref ZSocket socket, ApiCallItem item)
{
ZeroOperatorStateType state = RestoryContext(item);
if (state == ZeroOperatorStateType.Ok)
{
Prepare(item);
state = ExecCommand(item);
if (state != ZeroOperatorStateType.Ok)
{
Interlocked.Increment(ref ErrorCount);
}
else
{
Interlocked.Increment(ref SuccessCount);
}
}
else
{
Interlocked.Increment(ref ErrorCount);
}
if (!SendResult(ref socket, item, state))
{
Interlocked.Increment(ref SendError);
}
End(item);
}
static void TestFrameInner(string title, ZeroOperatorStateType state, byte[][] frames)
{
using (var socket = ZSocket.CreateClientSocket(address, ZSocketType.DEALER))
{
socket.SetOption(ZSocketOption.RCVTIMEO, 30000);
if (!socket.SendTo(frames))
{
Console.Error.Write(" : Send Error");
return;
}
var result = socket.Receive();
if (!result.InteractiveSuccess)
{
Console.Error.WriteLine(" : Receive Error");
}
if (result.State == state)
{
Console.ForegroundColor = ConsoleColor.Blue;
Console.Write($"(success) : {state}");
}
else
{
Console.Error.Write($"(bad) : {result.State}");
}
}
}
static void TestFrame(string title, ZeroOperatorStateType state, params byte[][] frames)
{
Console.Error.Write(title);
Console.ForegroundColor = ConsoleColor.Red;
TestFrameInner(title, state, frames);
Console.Error.WriteLine();
Console.Error.WriteLine("**----**");
Console.ResetColor();
}
private async Task <ZeroOperatorStateType> ApiCallByMonitor()
{
using (MonitorScope.CreateScope($"{Station.ServiceName}/{Item.ApiName}"))
{
LogRecorder.MonitorTrace(() => $"GlobalId:{Item.GlobalId}");
LogRecorder.MonitorTrace(() => JsonConvert.SerializeObject(Item, Formatting.Indented));
ZeroOperatorStateType state = RestoryContext();
if (state != ZeroOperatorStateType.Ok)
{
LogRecorder.MonitorTrace("Restory context failed");
Interlocked.Increment(ref Station.ErrorCount);
return(state);
}
using (MonitorScope.CreateScope("Do"))
{
state = CommandPrepare(true, out var action);
if (state == ZeroOperatorStateType.Ok)
{
object res;
if (CancellationToken.IsCancellationRequested)
{
res = ZeroOperatorStateType.Unavailable;
}
else
{
res = CommandExec(true, action);
}
state = await CheckCommandResult(res);
}
}
if (state != ZeroOperatorStateType.Ok)
{
Interlocked.Increment(ref Station.ErrorCount);
}
else
{
Interlocked.Increment(ref Station.SuccessCount);
}
LogRecorder.MonitorTrace(Item.Result);
return(state);
}
}
private async Task <ZeroOperatorStateType> ApiCallNoMonitor()
{
ZeroOperatorStateType state = RestoryContext();
if (state != ZeroOperatorStateType.Ok)
{
Interlocked.Increment(ref Station.ErrorCount);
return(state);
}
Prepare();
state = CommandPrepare(false, out var action);
if (state == ZeroOperatorStateType.Ok)
{
object res;
if (CancellationToken.IsCancellationRequested)
{
res = ZeroOperatorStateType.Unavailable;
}
else
{
GlobalContext.Current.DependencyObjects.Annex(action);
GlobalContext.Current.DependencyObjects.Annex(this);
res = CommandExec(false, action);
}
state = await CheckCommandResult(res);
}
if (state != ZeroOperatorStateType.Ok)
{
Interlocked.Increment(ref Station.ErrorCount);
}
else
{
Interlocked.Increment(ref Station.SuccessCount);
}
return(state);
}
private void ApiCallByMonitor(ref ZSocket socket, ApiCallItem item)
{
using (MonitorScope.CreateScope(item.ApiName))
{
LogRecorder.MonitorTrace($"Caller:{item.Caller}");
LogRecorder.MonitorTrace($"GlobalId:{item.GlobalId}");
LogRecorder.MonitorTrace(JsonConvert.SerializeObject(item));
ZeroOperatorStateType state = RestoryContext(item);
if (state == ZeroOperatorStateType.Ok)
{
Prepare(item);
using (MonitorScope.CreateScope("Do"))
{
state = ExecCommand(item);
}
if (state != ZeroOperatorStateType.Ok)
{
Interlocked.Increment(ref ErrorCount);
}
else
{
Interlocked.Increment(ref SuccessCount);
}
}
else
{
Interlocked.Increment(ref ErrorCount);
}
LogRecorder.MonitorTrace(item.Result);
if (!SendResult(ref socket, item, state))
{
ZeroTrace.WriteError(item.ApiName, "SendResult");
Interlocked.Increment(ref SendError);
}
End(item);
}
}
/// <summary>
/// 远程调用
/// </summary>
/// <returns></returns>
private void Call()
{
if (!ZeroApplication.ZerCenterIsRun)
{
State = ZeroOperatorStateType.LocalNoReady;
return;
}
var socket = ZeroConnectionPool.GetSocket(Station, ApiContext.RequestContext.RequestId);
if (socket.Socket == null)
{
//ApiContext.Current.LastError = ErrorCode.NoReady;
_json = ApiResult.NoReadyJson;
State = ZeroOperatorStateType.LocalNoReady;
return;
}
using (socket)
{
ReadNetWork(socket);
}
}
/// <summary>
/// 状态转换
/// </summary>
/// <param name="state"></param>
/// <param name="remote">是否远程状态</param>
/// <returns></returns>
public static ZeroOperatorStatus ToOperatorStatus(this ZeroOperatorStateType state, bool remote)
{
if (state < ZeroOperatorStateType.Failed)
{
return(ZeroOperatorStatus.Success);
}
if (state < ZeroOperatorStateType.Bug)
{
return(ZeroOperatorStatus.LogicalError);
}
if (state < ZeroOperatorStateType.Error)
{
return(ZeroOperatorStatus.FormalError);
}
if (state <= ZeroOperatorStateType.NotSupport)
{
return(ZeroOperatorStatus.NotFind);
}
if (state == ZeroOperatorStateType.DenyAccess)
{
return(ZeroOperatorStatus.DenyAccess);
}
if (state == ZeroOperatorStateType.Unavailable)
{
return(ZeroOperatorStatus.Unavailable);
}
if (state == ZeroOperatorStateType.LocalException)
{
return(remote ? ZeroOperatorStatus.RemoteException : ZeroOperatorStatus.LocalException);
}
if (state >= ZeroOperatorStateType.LocalNoReady || state == ZeroOperatorStateType.TimeOut)
{
return(remote ? ZeroOperatorStatus.RemoteError : ZeroOperatorStatus.LocalError);
}
return(ZeroOperatorStatus.RemoteError);
}
private void ReadNetWork(PoolSocket socket)
{
var result = socket.Socket.QuietSend(GetGlobalIdDescription, ApiContext.RequestContext.RequestId);
if (!result.InteractiveSuccess)
{
socket.HaseFailed = true;
//ZeroTrace.WriteError("GetGlobalId", "Send Failed", station, commmand, argument);
//ApiContext.Current.LastError = ErrorCode.NetworkError;
State = ZeroOperatorStateType.LocalSendError;
return;
}
if (result.State == ZeroOperatorStateType.Pause)
{
socket.HaseFailed = true;
State = ZeroOperatorStateType.Pause;
return;
}
result = ReceiveString(socket.Socket);
if (!result.InteractiveSuccess)
{
socket.HaseFailed = true;
//ZeroTrace.WriteError("GlobalId", "Recv Failed", station, commmand, argument);
//ApiContext.Current.LastError = ErrorCode.NetworkError;
State = ZeroOperatorStateType.LocalRecvError;
return;
}
var old = ApiContext.RequestContext.LocalGlobalId;
if (result.TryGetValue(ZeroFrameType.GlobalId, out GlobalId))
{
ApiContext.RequestContext.LocalGlobalId = GlobalId;
LogRecorder.MonitorTrace($"GlobalId:{GlobalId}");
}
result = socket.Socket.QuietSend(CallDescription,
Commmand,
ApiContext.RequestContext.RequestId,
JsonConvert.SerializeObject(ApiContext.Current),
Argument,
ApiContext.RequestContext.RequestId, //作名称
ApiContext.RequestContext.LocalGlobalId);
ApiContext.RequestContext.LocalGlobalId = old;
if (!result.InteractiveSuccess)
{
socket.HaseFailed = true;
//ZeroTrace.WriteError(station, "Send Failed", commmand, argument);
//ApiContext.Current.LastError = ErrorCode.NetworkError;
State = ZeroOperatorStateType.LocalSendError;
return;
}
result = ReceiveString(socket.Socket);
if (!result.InteractiveSuccess)
{
socket.HaseFailed = true;
//ZeroTrace.WriteError("API", "incorrigible", commmand, globalId);
//ApiContext.Current.LastError = ErrorCode.NetworkError;
State = ZeroOperatorStateType.LocalRecvError;
return;
}
//if (result.State == ZeroOperatorStateType.NoWorker)
//{
// return;
//}
//var lr = socket.Socket.QuietSend(CloseDescription, name, globalId);
//if (!lr.InteractiveSuccess)
//{
// ZeroTrace.WriteError(station, "Close Failed", commmand, globalId);
//}
//lr = ReceiveString(socket.Socket);
//if (!lr.InteractiveSuccess)
//{
// socket.HaseFailed = true;
// ZeroTrace.WriteError(station, "Close Failed", commmand, globalId, lr.ZmqErrorMessage);
//}
result.TryGetValue(ZeroFrameType.JsonValue, out _json);
State = result.State;
}
/// <summary>
/// 状态原始文本
/// </summary>
/// <param name="state"></param>
/// <returns></returns>
public static string Text(this ZeroOperatorStateType state)
{
switch (state)
{
case ZeroOperatorStateType.Ok:
return(ZeroCommandOk);
case ZeroOperatorStateType.Plan:
return(ZeroCommandPlan);
case ZeroOperatorStateType.Runing:
return(ZeroCommandRuning);
case ZeroOperatorStateType.Bye:
return(ZeroCommandBye);
case ZeroOperatorStateType.Wecome:
return(ZeroCommandWecome);
case ZeroOperatorStateType.VoteSend:
return(ZeroVoteSended);
case ZeroOperatorStateType.Waiting:
case ZeroOperatorStateType.VoteWaiting:
return(ZeroVoteWaiting);
case ZeroOperatorStateType.VoteBye:
return(ZeroCommandBye);
case ZeroOperatorStateType.VoteStart:
return(ZeroVoteStart);
case ZeroOperatorStateType.VoteClose:
return(ZeroVoteClosed);
case ZeroOperatorStateType.VoteEnd:
return(ZeroVoteEnd);
case ZeroOperatorStateType.Error:
return(ZeroCommandError);
case ZeroOperatorStateType.Failed:
case ZeroOperatorStateType.Bug:
return(ZeroCommandFailed);
case ZeroOperatorStateType.NotFind:
return(ZeroCommandNoFind);
case ZeroOperatorStateType.NotSupport:
return(ZeroCommandNoSupport);
case ZeroOperatorStateType.FrameInvalid:
return(ZeroCommandInvalid);
case ZeroOperatorStateType.TimeOut:
return(ZeroCommandTimeout);
case ZeroOperatorStateType.NetError:
return(ZeroCommandNetError);
case ZeroOperatorStateType.NoWorker:
return(ZeroCommandNotWorker);
//case ZeroOperatorStateType.CommandArgumentError:
// return ZeroCommandArgError;
//case ZeroOperatorStateType.InstallArgumentError:
// return ZeroCommandInstallArgError;
case ZeroOperatorStateType.LocalRecvError:
return("-error. local can't recv data");
case ZeroOperatorStateType.LocalSendError:
return("-error. local can't send data");
case ZeroOperatorStateType.LocalException:
return("-error. local throw exception");
case ZeroOperatorStateType.None:
return("-unknow");
case ZeroOperatorStateType.PlanError:
return("-error. plan argument error");
case ZeroOperatorStateType.RemoteSendError:
return("-error. remote station or ZeroCenter send error");
case ZeroOperatorStateType.RemoteRecvError:
return("-error. remote station or ZeroCenter recv error");
case ZeroOperatorStateType.LocalNoReady:
return("-error. ZeroApplication no ready.");
case ZeroOperatorStateType.LocalZmqError:
return("-error. ZeroMQ error.");
default:
return(ZeroCommandError);
}
}
