private void xor(int left, int right, Action <fastCSharp.net.returnValue <tcpServer._o1> > _onReturn_, fastCSharp.net.callback <fastCSharp.net.returnValue <tcpServer._o1> > _callback_, bool _isTask_)
{
fastCSharp.net.returnValue <tcpServer._o1> _returnType_ = new fastCSharp.net.returnValue <tcpServer._o1>();
try
{
fastCSharp.net.tcp.commandClient.streamCommandSocket _socket_ = TcpCommandClient.StreamSocket;
if (_socket_ != null)
{
tcpServer._i1 _inputParameter_ = new tcpServer._i1
{
left = left,
right = right,
};
_socket_.Get(_onReturn_, _callback_, _c1, ref _inputParameter_, ref _returnType_.Value, _isTask_);
return;
}
_returnType_.Type = fastCSharp.net.returnValue.type.ClientDisposed;
}
catch (Exception _error_)
{
_returnType_.Type = fastCSharp.net.returnValue.type.ClientException;
fastCSharp.log.Error.Add(_error_, null, false);
}
if (_callback_ != null)
{
_callback_.Callback(ref _returnType_);
}
else if (_onReturn_ != null)
{
_onReturn_(_returnType_);
}
}
private fastCSharp.net.tcp.commandClient.streamCommandSocket.keepCallback receive(Action <fastCSharp.net.returnValue <tcpServer._o4> > _onReturn_, fastCSharp.net.callback <fastCSharp.net.returnValue <tcpServer._o4> > _callback_, bool _isTask_)
{
fastCSharp.net.returnValue <tcpServer._o4> _returnType_ = new fastCSharp.net.returnValue <tcpServer._o4>();
try
{
fastCSharp.net.tcp.commandClient.streamCommandSocket _socket_ = TcpCommandClient.StreamSocket;
if (_socket_ != null)
{
return(_socket_.Get(_onReturn_, _callback_, _c4, ref _returnType_.Value, _isTask_));
}
_returnType_.Type = fastCSharp.net.returnValue.type.ClientDisposed;
}
catch (Exception _error_)
{
_returnType_.Type = fastCSharp.net.returnValue.type.ClientException;
fastCSharp.log.Error.Add(_error_, null, false);
}
if (_callback_ != null)
{
_callback_.Callback(ref _returnType_);
}
else if (_onReturn_ != null)
{
_onReturn_(_returnType_);
}
return(null);
}
/// <summary>
/// 获取订单字符串后发送支付请求
/// </summary>
/// <param name="order"></param>
public void Send(fastCSharp.net.returnValue<string> order)
{
bool isCheck = false;
if (order.IsReturn && order.Value != null)
{
try
{
using (PayTask alipay = new PayTask(activity))
{
IDictionary<string, string> payResult = alipay.PayV2(order.Value, isShowPayLoading);
if (payResult["resultStatus"] == "9000")
{
string result = payResult["result"];
if (checkOrderResult(result))
{
isCheck = true;
if (callback != null) callback(result);
return;
}
}
}
}
catch (System.Exception error)
{
fastCSharp.log.Default.Add(error, null, false);
}
}
if (!isCheck && callback != null) callback(null);
}
private void serverSynchronous(fastCSharp.code.cSharp.tcpBase.subByteArrayBuffer data, Action <fastCSharp.net.returnValue <tcpServer._o1> > _onReturn_, fastCSharp.net.callback <fastCSharp.net.returnValue <tcpServer._o1> > _callback_, bool _isTask_)
{
fastCSharp.net.returnValue <tcpServer._o1> _returnType_ = new fastCSharp.net.returnValue <tcpServer._o1>();
try
{
fastCSharp.net.tcp.commandClient.streamCommandSocket _socket_ = TcpCommandClient.StreamSocket;
if (_socket_ != null)
{
tcpServer._i1 _inputParameter_ = new tcpServer._i1
{
data = data,
};
_socket_.Get(_onReturn_, _callback_, _c1, ref _inputParameter_, ref _returnType_.Value, _isTask_);
return;
}
_returnType_.Type = fastCSharp.net.returnValue.type.ClientDisposed;
}
catch (Exception _error_)
{
_returnType_.Type = fastCSharp.net.returnValue.type.ClientException;
fastCSharp.log.Error.Add(_error_, null, false);
}
if (_callback_ != null)
{
_callback_.Callback(ref _returnType_);
}
else if (_onReturn_ != null)
{
_onReturn_(_returnType_);
}
}
/// <summary>
/// 设置Session值
/// </summary>
/// <param name="sessionId">Session名称</param>
/// <param name="value">值</param>
/// <returns>Session是否被更新</returns>
public bool Set(ref sessionId sessionId, valueType value)
{
fastCSharp.net.returnValue <sessionId> newSessionId = Set(sessionId, value);
if (newSessionId.IsReturn)
{
set(ref newSessionId.Value, value);
return(newSessionId.Value.Equals(ref sessionId) != 0);
}
return(false);
}
public override void Call()
{
fastCSharp.net.returnValue <_o1> value = new fastCSharp.net.returnValue <_o1>();
if (isVerify == 0)
{
get(ref value);
socket.SendStream(ref identity, ref value, flags);
}
fastCSharp.typePool <_s1> .PushNotNull(this);
}
/// <summary>
/// 接收数据处理
/// </summary>
/// <param name="buffer">接收数据</param>
private void onSend(fastCSharp.net.returnValue <fastCSharp.code.cSharp.tcpBase.subByteArrayBuffer> buffer)
{
if (buffer.Type == fastCSharp.net.returnValue.type.Success)
{
Interlocked.Add(ref ReceiveSize, buffer.Value.Buffer.Count);
}
else
{
form.error();
}
form.checkFinally();
}
/// <summary>
/// 添加TCP调用服务端
/// </summary>
/// <param name="server">TCP调用服务端信息</param>
internal override void NewServer(serverInfo server)
{
bool isCreate = newServer(ref server.Host);
if (isCreate)
{
tryCheck();
log.Default.Add("添加TCP调用服务端 " + server.Host.Host + ":" + server.Host.Port.toString(), new System.Diagnostics.StackFrame(), false);
}
fastCSharp.net.returnValue <bool> output = new fastCSharp.net.returnValue <bool> {
Type = returnValue.type.Success, Value = isCreate
};
server.Socket.SendStream(ref server.Identity, ref output, default(tcp.commandServer.commandFlags));
}
private void get(ref fastCSharp.net.returnValue value)
{
try
{
serverValue.send(socket, inputParameter.message, inputParameter.users);
value.Type = fastCSharp.net.returnValue.type.Success;
}
catch (Exception error)
{
value.Type = fastCSharp.net.returnValue.type.ServerException;
fastCSharp.log.Error.Add(error, null, true);
}
}
/// <summary>
/// 日志回调
/// </summary>
/// <param name="log"></param>
/// <returns></returns>
public bool GetLog(fastCSharp.net.returnValue <log> log)
{
Func <fastCSharp.net.returnValue <log>, bool> onLog = OnLog;
if (onLog != null)
{
//if (log.Value == null) onLog(new code.cSharp.fastCSharp.net.returnValue<log> { Type = fastCSharp.net.returnValue.type.LogStreamExpired });
//else if (onLog(log)) return true;
if (onLog(log))
{
return(true);
}
Interlocked.CompareExchange(ref OnLog, null, onLog);
}
return(false);
}
/// <summary>
/// AJAX回调处理
/// </summary>
/// <param name="value">回调值</param>
private void onReturn(fastCSharp.net.returnValue value)
{
try
{
if (value.Type == fastCSharp.net.returnValue.type.Success)
{
ajax.cancelAsynchronous();
ajax.AjaxResponse(ref response);
}
else
{
ajax.serverError500();
}
}
finally
{
ajax = null;
response = null;
typePool <callbackType> .PushNotNull(thisCallback);
}
}
private void get(ref fastCSharp.net.returnValue <_o0> value)
{
try
{
fastCSharp.demo.udpPortServer.ipPort Return;
Return = serverValue.get(inputParameter.name);
value.Value = new _o0
{
Return = Return
};
value.Type = fastCSharp.net.returnValue.type.Success;
}
catch (Exception error)
{
value.Type = fastCSharp.net.returnValue.type.ServerException;
fastCSharp.log.Error.Add(error, null, true);
}
}
private void get(ref fastCSharp.net.returnValue <_o0> value)
{
try
{
int Return;
Return = serverValue.add(inputParameter.left, inputParameter.right);
value.Value = new _o0
{
Return = Return
};
value.Type = fastCSharp.net.returnValue.type.Success;
}
catch (Exception error)
{
value.Type = fastCSharp.net.returnValue.type.ServerException;
fastCSharp.log.Error.Add(error, null, true);
}
}
private void get(ref fastCSharp.net.returnValue <_o1> value)
{
try
{
fastCSharp.code.cSharp.tcpBase.subByteArrayBuffer Return;
Return = serverValue.serverSynchronous(inputParameter.data);
value.Value = new _o1
{
Return = Return
};
value.Type = fastCSharp.net.returnValue.type.Success;
}
catch (Exception error)
{
value.Type = fastCSharp.net.returnValue.type.ServerException;
fastCSharp.log.Error.Add(error, null, true);
}
}
/// <summary>
/// 移除TCP调用服务端
/// </summary>
/// <param name="socket">TCP调用套接字</param>
/// <param name="data">参数序列化数据</param>
private void removeServer(socket socket, ref subArray <byte> data)
{
fastCSharp.net.returnValue.type returnType;
try
{
host host = new host();
if (fastCSharp.emit.dataDeSerializer.DeSerialize(ref data, ref host))
{
fastCSharp.net.returnValue <bool> output = new fastCSharp.net.returnValue <bool> {
Type = returnValue.type.Success, Value = server.removeServer(ref host)
};
socket.SendStream(ref socket.identity, ref output, default(tcp.commandServer.commandFlags));
return;
}
returnType = fastCSharp.net.returnValue.type.ServerDeSerializeError;
}
catch (Exception error)
{
returnType = fastCSharp.net.returnValue.type.ServerException;
fastCSharp.log.Error.Add(error, null, true);
}
socket.SendStream(ref socket.identity, returnType);
}
/// <summary>
/// 获取交易会话信息后发送支付请求
/// </summary>
/// <param name="order"></param>
public void Send(fastCSharp.net.returnValue <fastCSharp.openApi.weixin.api.appPrePayIdOrder> order)
{
bool isSend = false;
if (order.IsReturn && order.Value != null)
{
try
{
if (Api.SendPayReq(order))
{
Callback(isSend = true);
return;
}
}
catch (System.Exception error)
{
fastCSharp.log.Default.Add(error, null, false);
}
}
if (!isSend && Callback != null)
{
Callback(false);
}
}
/// <summary>
/// 同步调用支付
/// </summary>
/// <param name="getOrder">获取交易会话信息</param>
/// <returns>是否发送成功，不等于支付成功</returns>
public bool Pay(Func <fastCSharp.net.returnValue <fastCSharp.openApi.weixin.api.appPrePayIdOrder> > getOrder)
{
if (getOrder != null && IsApi)
{
try
{
fastCSharp.net.returnValue <fastCSharp.openApi.weixin.api.appPrePayIdOrder> order = getOrder();
if (order.IsReturn && SendPayReq(order))
{
return(true);
}
}
catch (System.Exception error)
{
fastCSharp.log.Default.Add(error, null, false);
}
}
return(false);
}
/// <summary>
/// 获取客户端IP端口信息
/// </summary>
private unsafe void get()
{
try
{
fastCSharp.net.returnValue <ipPort> ipPort = client.client.get(remoteName);
if (ipPort.Type == fastCSharp.net.returnValue.type.Success && ipPort.Value.Ip != 0 && ipPort.Value.Port != 0)
{
RemoteIp = new IPEndPoint(new IPAddress(ipPort.Value.Ip), ipPort.Value.Port);
isReceive = 0;
if (sendName == null)
{
sendName = send;
}
isSend = 1;
fastCSharp.threading.threadPool.TinyPool.Start(sendName);
if (recieveName == null)
{
recieveName = new byte[Math.Max(Math.Max(remoteName.Buffer.Count, name.Length), sizeof(int))];
}
do
{
Console.WriteLine("Receive 1");
EndPoint endPoint = RemoteIp;
if (Socket.ReceiveFrom(recieveName, 0, recieveName.Length, SocketFlags.None, ref endPoint) == remoteName.Buffer.Count && remoteName.Buffer.UnsafeArray.equal(recieveName, remoteName.Buffer.Count))
{
isReceive = 1;
break;
}
}while (DateTime.Now < timeout);
if (isReceive != 0)
{
do
{
Console.WriteLine("Receive 2");
EndPoint endPoint = RemoteIp;
int receiveLength = Socket.ReceiveFrom(recieveName, 0, recieveName.Length, SocketFlags.None, ref endPoint);
if (receiveLength == name.Length && name.equal(recieveName, name.Length))
{
while (isSend != 0)
{
Thread.Sleep(1);
}
isReceive = 2;
client.onSocket(this);
return;
}
else if (receiveLength == remoteName.Buffer.Count && remoteName.Buffer.UnsafeArray.equal(recieveName, remoteName.Buffer.Count))
{
continue;
}
else
{
Console.WriteLine("Receive Error " + receiveLength.toString());
}
}while (DateTime.Now < timeout);
}
}
}
catch (Exception error)
{
Console.WriteLine(error.ToString());
}
while (isSend != 0)
{
Thread.Sleep(1);
}
if (date.NowSecond < timeout)
{
fastCSharp.threading.timerTask.Default.Add(Start, date.NowSecond.AddSeconds(1));
}
else
{
client.onSocket(this);
}
}
/// <summary>
/// 客户端轮询
/// </summary>
/// <param name="result">轮询结果</param>
private void onLog(fastCSharp.net.returnValue <log> result)
{
if (result.Type == fastCSharp.net.returnValue.type.Success)
{
hashString name;
services services;
switch (result.Value.Type)
{
case log.type.ClientError:
Monitor.Enter(clientLock);
try
{
close();
}
finally { Monitor.Exit(clientLock); }
break;
case log.type.Check: return;
case log.type.NewGetter:
fastCSharp.log.Default.Add(serviceName + " 日志轮询客户端冲突", new System.Diagnostics.StackFrame(), false);
return;
//case log.type.VersionError:
// Monitor.Enter(clientLock);
// try
// {
// pub.Dispose(ref logKeep);
// if (getLog()) return;
// }
// finally { Monitor.Exit(clientLock); }
// break;
case log.type.HostChanged:
name = result.Value.Services.Name;
Monitor.Enter(servicesLock);
try
{
if (this.services.TryGetValue(name, out services))
{
services.SetHosts(result.Value.Services.Hosts);
}
else
{
services = result.Value.Services;
//services.Version = 1;
this.services.Add(name, services);
}
}
finally { Monitor.Exit(servicesLock); }
//if (OnServiceChanged != null) OnServiceChanged(result.Value.Services.Name);
return;
case log.type.RemoveServiceName:
//bool isChanged = false;
name = result.Value.Services.Name;
Monitor.Enter(servicesLock);
//if (this.services.TryGetValue(name, out services)) isChanged = services.Remove();
if (this.services.TryGetValue(name, out services))
{
services.Remove();
}
Monitor.Exit(servicesLock);
//if (isChanged && OnServiceChanged != null) OnServiceChanged(result.Value.Services.Name);
return;
default:
fastCSharp.log.Error.Add("不可识别的日志类型 " + result.Value.Type.ToString(), new System.Diagnostics.StackFrame(), false);
break;
}
}
else if (result.Type == fastCSharp.net.returnValue.type.LogStreamExpired)
{
Monitor.Enter(clientLock);
try
{
pub.Dispose(ref logKeep);
if (getLog())
{
return;
}
}
finally { Monitor.Exit(clientLock); }
}
Start();
}
/// <summary>
/// 创建完成回调处理
/// </summary>
/// <param name="returnValue">返回值</param>
public override void Callback(ref fastCSharp.net.returnValue <bool> returnValue)
{
OnReturn(returnValue.Type == fastCSharp.net.returnValue.type.Success && returnValue.Value);
}
public bool Verify(fastCSharp.net.tcp.commandLoadBalancingServer.commandClient client)
#endif
{
#if NOJIT
fastCSharp.net.tcp.commandLoadBalancingServer.commandClient client = (fastCSharp.net.tcp.commandLoadBalancingServer.commandClient)clientObject;
#endif
fastCSharp.net.tcp.timeVerifyServer.input input = new fastCSharp.net.tcp.timeVerifyServer.input();
fastCSharp.net.tcp.commandClient commandClient = client.TcpCommandClient;
fastCSharp.code.cSharp.tcpServer attribute = commandClient.Attribute;
string verifyString = attribute.VerifyString;
if (verifyString == null)
{
return(client.Verify(ref input).Value.Ret);
}
ulong markData = 0;
if (attribute.IsMarkData)
{
markData = attribute.VerifyHashCode;
}
input.ticks = date.UtcNow.Ticks;
do
{
input.randomPrefix = random.Default.SecureNextULongNotZero();
while (input.randomPrefix == markData)
{
input.randomPrefix = random.Default.SecureNextULongNotZero();
}
commandClient.ReceiveMarkData = attribute.IsMarkData ? markData ^ input.randomPrefix : 0UL;
commandClient.SendMarkData = 0;
input.MD5(verifyString);
long lastTicks = input.ticks;
fastCSharp.net.returnValue <fastCSharp.net.tcp.timeVerifyServer.output> isVerify = client.Verify(ref input);
if (isVerify.Value.Ret)
{
commandClient.SendMarkData = commandClient.ReceiveMarkData;
return(true);
}
if (isVerify.Type != fastCSharp.net.returnValue.type.Success || input.ticks <= lastTicks)
{
return(false);
}
++input.ticks;
log.Error.Add("TCP客户端验证时间失败重试", null, false);
}while (true);
}
