// this function should be called after locking the lock_ object.
private OnCallback PopDelegateToCall()
{
OnCallback delegateToCall = null;
if (State != States.Pending)
{
if (State == States.Fulfilled)
{
if (onFulfill_ != null)
{
delegateToCall = onFulfill_;
}
}
else if (State == States.Rejected)
{
if (onReject_ != null)
{
delegateToCall = onReject_;
}
}
onFulfill_ = null;
onReject_ = null;
}
return(delegateToCall);
}
public Handler(OnCallback onCallback)
{
mLooper = Looper.Instance;
mQueue = mLooper.mQueue;
if (onCallback == null)
{
throw new ArgumentNullException("Don't accept a null callback");
}
mOnCallback = onCallback;
}
public void On(string e, OnCallback cb)
{
if (messegesCallback.ContainsKey(e))
{
messegesCallback[e].Add(cb);
return;
}
messegesCallback.Add(e, new List <OnCallback> {
cb
});
}
private void CallDelegate(OnCallback delegateToCall)
{
if (delegateToCall != null)
{
#if ASYNC_THEN_CALL
Task.Factory.StartNew(() => {
delegateToCall(result_);
});
#else
delegateToCall(result_);
#endif
}
}
public bool emit(string eventName, string command, string message, OnCallback callback)
{
Message m = new Message(PacketType.S_sendEventForCallback, eventName, command, message);
if (this.callbackQueue.TryAdd(m.id, callback))
{
return(this.sendMessage(m));
}
else
{
return(false);
}
}
private void SetState(States newState, object result)
{
OnCallback delegateToCall = null;
lock (lock_) {
if (State == States.Pending)
{
State = newState;
result_ = result;
delegateToCall = PopDelegateToCall();
}
}
CallDelegate(delegateToCall);
}
private static Task HandleUpdates(ITelegramBotClient botClient, Update update, CancellationToken cancellationToken)
{
switch (update.Type)
{
case UpdateType.Message:
OnMessage?.Invoke(api, new MessageEventArgs(update.Message));
break;
case UpdateType.EditedMessage:
OnMessageEdit?.Invoke(api, new MessageEditEventArgs(update.EditedMessage));
break;
case UpdateType.CallbackQuery:
OnCallback?.Invoke(api, new CallbackQueryEventArgs(update.CallbackQuery));
break;
}
return(Task.CompletedTask);
}
internal void DoneImpl(Action <object> onFulfilled,
Action <object> onRejected)
{
OnCallback handlerToCall = null;
lock (lock_) {
if (onFulfilled != null)
{
onFulfill_ += new OnCallback(onFulfilled);
}
if (onRejected != null)
{
onReject_ += new OnCallback(onRejected);
}
handlerToCall = PopDelegateToCall();
}
// User delegate can take a long time,
// we will call user delegate outside lock.
CallDelegate(handlerToCall);
}
public void SetCallbackFunction(OnCallback function)
{
OnCallbackEvent = function;
}
public Handler()
{
mLooper = Looper.Instance;
mQueue = mLooper.mQueue;
mOnCallback = null;
}
private void Run()
{
TriggerParam triggerParam = null;
while (!_toStop)
{
_running = false;
triggerParam = null;
ReturnT executeResult = null;
try
{
if (_triggerQueue.TryDequeue(out triggerParam))
{
_running = true;
byte temp;
_triggerLogIdSet.TryRemove(triggerParam.logId, out temp);
JobLogger.SetLogFileName(triggerParam.logDateTim, triggerParam.logId);
var executionContext = new JobExecutionContext()
{
BroadcastIndex = triggerParam.broadcastIndex,
BroadcastTotal = triggerParam.broadcastTotal,
ExecutorParams = triggerParam.executorParams
};
// execute
JobLogger.Log("<br>----------- xxl-job job execute start -----------<br>----------- Param:" + triggerParam.executorParams);
var handler = _jobHandlerFactory.GetJobHandler(triggerParam.executorHandler);
executeResult = handler.Execute(executionContext);
JobLogger.Log("<br>----------- xxl-job job execute end(finish) -----------<br>----------- ReturnT:" + executeResult);
}
else
{
if (!_queueHasDataEvent.WaitOne(Constants.JobThreadWaitTime))
{
ToStop("excutor idel times over limit.");
}
}
}
catch (Exception ex)
{
if (triggerParam != null)
{
if (_toStop)
{
JobLogger.Log("<br>----------- JobThread toStop, stopReason:" + _stopReason);
}
var errorMsg = ex.ToString();
executeResult = ReturnT.CreateFailedResult(errorMsg);
JobLogger.Log("<br>----------- JobThread Exception:" + errorMsg + "<br>----------- xxl-job job execute end(error) -----------");
}
else
{
_logger.LogError(ex, "JobThread exception.");
}
}
finally
{
if (triggerParam != null)
{
OnCallback?.Invoke(this, new HandleCallbackParam(triggerParam.logId, triggerParam.logDateTim, executeResult ?? ReturnT.FAIL));
}
}
}
// callback trigger request in queue
while (_triggerQueue.TryDequeue(out triggerParam))
{
var stopResult = ReturnT.CreateFailedResult(_stopReason + " [job not executed, in the job queue, killed.]");
OnCallback?.Invoke(this, new HandleCallbackParam(triggerParam.logId, triggerParam.logDateTim, stopResult));
}
}
private void OnTick()
{
animate();
OnCallback?.Invoke(this, EventArgs.Empty);
}
/// <summary>
/// 服务开启
/// </summary>
public static void ServiceOpen()
{
//标识UDP信息的加密GUID
const string broadcastMsg = "825C7B29-5B62-4242-AF76-EBDB489A6090";
//------这里检查局域网内是否开启了多个服务器
var client = new UdpClient
{
Client = { ReceiveTimeout = 1000 },
EnableBroadcast = true
};
IPAddress ip;
var refData = string.Empty;
try
{
var requestData = Encoding.UTF8.GetBytes($"{broadcastMsg}|GetServiceIp");
client.Send(requestData, requestData.Length, new IPEndPoint(IPAddress.Broadcast, 2875));
var serverEp = new IPEndPoint(IPAddress.Broadcast, 0);
var serverResponseData = client.Receive(ref serverEp);
ip = serverEp.Address;
refData = Encoding.UTF8.GetString(serverResponseData);
}
catch
{
ip = IPAddress.Broadcast;
}
if (!ip.Equals(IPAddress.Broadcast) && refData.Equals("true"))
{
Console.Write($@"当前局域网内已有服务器运行{Environment.NewLine}若要以当前机器为服务器请关闭 {ip} 上的服务器程序 !");
Console.Read();
return;
}
//------检查完毕
//服务器默认端口
var server = new UdpClient(2875);
Console.Write("服务器运行中 ... ");
//服务器端死循环监控消息
while (true)
{
try
{
var clientEp = new IPEndPoint(IPAddress.Any, 0);
var clientRequestData = server.Receive(ref clientEp);
var clientRequest = Encoding.UTF8.GetString(clientRequestData);
if (string.IsNullOrWhiteSpace(clientRequest))
{
continue;
}
var tmp = clientRequest.Split('|');
if (tmp[0] != broadcastMsg)
{
continue;
}
if (tmp[1] == "GetServiceIp")
{
var responseData = Encoding.UTF8.GetBytes("true");
server.Send(responseData, responseData.Length, clientEp);
}
else
{
OnCallback?.Invoke(tmp[1], tmp[2]);
var responseData = Encoding.UTF8.GetBytes(ReflexFunction(tmp[1], tmp[2]));
server.Send(responseData, responseData.Length, clientEp);
}
}
catch (Exception e)
{
Console.Write("服务器异常,详细错误请看日志文件 !");
TyLog.Wlog(e);
return;
}
}
}
public bool emit(string eventName, OnCallback callback)
{
return(this.emit(eventName, "", "", callback));
}
public void invokeDotNetCallback(params object[] args)
{
OnCallback?.Invoke(args);
}
protected void Call()
{
OnCallback?.Invoke();
AfterCall();
}
