/// <summary>
/// 示例发布以后的后续处理
/// </summary>
/// <param name="server"></param>
/// <param name="sender"></param>
/// <param name="customData"></param>
/// <returns></returns>
public DeployState OnExample(AutoCSer.Deploy.Server server, AutoCSer.Net.TcpInternalServer.ServerSocketSender sender, byte[] customData)
{
string path = AutoCSer.Web.Config.Deploy.ServerPath + @"www.AutoCSer.com\Download\";
System.IO.File.Copy(path + "AutoCSer.zip", path + "AutoCSer.Example.zip", true);
return(DeployState.Success);
}
/// <summary>
/// 命令处理
/// </summary>
/// <param name="index">命令序号</param>
/// <param name="sender">TCP 内部服务套接字数据发送</param>
/// <param name="data">命令数据</param>
public override void DoCommand(int index, AutoCSer.Net.TcpInternalServer.ServerSocketSender sender, ref SubArray <byte> data)
{
AutoCSer.Net.TcpServer.ReturnType returnType;
switch (index - 128)
{
case 0:
returnType = AutoCSer.Net.TcpServer.ReturnType.Unknown;
try
{
_p1 inputParameter = new _p1();
if (sender.DeSerialize(ref data, ref inputParameter, true))
{
(_s0 /**/.Pop() ?? new _s0()).Set(sender, Value, AutoCSer.Net.TcpServer.ServerTaskType.Timeout, ref inputParameter);
return;
}
returnType = AutoCSer.Net.TcpServer.ReturnType.ServerDeSerializeError;
}
catch (Exception error)
{
returnType = AutoCSer.Net.TcpServer.ReturnType.ServerException;
sender.AddLog(error);
}
sender.Push(returnType);
return;
default: return;
}
}
/// <summary>
/// 命令处理
/// </summary>
/// <param name="index">命令序号</param>
/// <param name="sender">TCP 内部服务套接字数据发送</param>
/// <param name="data">命令数据</param>
public override void DoCommand(int index, AutoCSer.Net.TcpInternalServer.ServerSocketSender sender, ref SubArray <byte> data)
{
AutoCSer.Net.TcpServer.ReturnType returnType;
switch (index - 128)
{
case 0:
returnType = AutoCSer.Net.TcpServer.ReturnType.Unknown;
try
{
{
(_s0 /**/.Pop() ?? new _s0()).Set(sender, Value, AutoCSer.Net.TcpServer.ServerTaskType.Timeout);
return;
}
}
catch (Exception error)
{
returnType = AutoCSer.Net.TcpServer.ReturnType.ServerException;
sender.AddLog(error);
}
sender.Push(returnType);
return;
default: return;
}
}
private bool clear(AutoCSer.Net.TcpInternalServer.ServerSocketSender sender, IndexIdentity identity)
{
if (checkCommand(sender, Command.clear))
{
Clear(ref identity);
return(true);
}
return(false);
}
private bool setFileSource(AutoCSer.Net.TcpInternalServer.ServerSocketSender sender, IndexIdentity identity, byte[][] files)
{
if ((uint)identity.Index < (uint)deployPool.PoolIndex && checkCommand(sender, Command.setFileSource))
{
object arrayLock = deployPool.ArrayLock;
Monitor.Enter(arrayLock);
if (deployPool.Array[identity.Index].SetFiles(identity.Identity, files))
{
Monitor.Exit(arrayLock);
return(true);
}
Monitor.Exit(arrayLock);
}
return(false);
}
private int addWaitRunSwitch(AutoCSer.Net.TcpInternalServer.ServerSocketSender sender, IndexIdentity identity, int taskIndex)
{
if ((uint)identity.Index < (uint)deployPool.PoolIndex && checkCommand(sender, Command.addWaitRunSwitch))
{
object arrayLock = deployPool.ArrayLock;
Monitor.Enter(arrayLock);
try
{
return(deployPool.Array[identity.Index].AddTask(identity.Identity, new Task {
TaskIndex = taskIndex, Type = TaskType.WaitRunSwitch
}));
}
finally { Monitor.Exit(arrayLock); }
}
return(-1);
}
private int addRun(AutoCSer.Net.TcpInternalServer.ServerSocketSender sender, IndexIdentity identity, KeyValue <string, int>[] files, ClientTask.Run run)
{
if ((uint)identity.Index < (uint)deployPool.PoolIndex && checkCommand(sender, Command.addRun))
{
object arrayLock = deployPool.ArrayLock;
Monitor.Enter(arrayLock);
try
{
return(deployPool.Array[identity.Index].AddTask(identity.Identity, new Task {
FileIndexs = files, ServerDirectory = new DirectoryInfo(run.ServerPath), Type = TaskType.Run, RunFileName = run.FileName, RunSleep = run.Sleep, IsWaitRun = run.IsWait
}));
}
finally { Monitor.Exit(arrayLock); }
}
return(-1);
}
private int addAssemblyFiles(AutoCSer.Net.TcpInternalServer.ServerSocketSender sender, IndexIdentity identity, KeyValue <string, int>[] files, ClientTask.AssemblyFile assemblyFile)
{
if ((uint)identity.Index < (uint)deployPool.PoolIndex && checkCommand(sender, Command.addAssemblyFiles))
{
object arrayLock = deployPool.ArrayLock;
Monitor.Enter(arrayLock);
try
{
return(deployPool.Array[identity.Index].AddTask(identity.Identity, new Task {
FileIndexs = files, ServerDirectory = new DirectoryInfo(assemblyFile.ServerPath), Type = TaskType.AssemblyFile
}));
}
finally { Monitor.Exit(arrayLock); }
}
return(-1);
}
private DeployState start(AutoCSer.Net.TcpInternalServer.ServerSocketSender sender, IndexIdentity identity, DateTime time)
{
if ((uint)identity.Index < (uint)deployPool.PoolIndex && checkCommand(sender, Command.start))
{
object arrayLock = deployPool.ArrayLock;
Monitor.Enter(arrayLock);
try
{
return(deployPool.Array[identity.Index].Start(identity.Identity, time, new Timer {
Server = this, Identity = identity
}));
}
finally { Monitor.Exit(arrayLock); }
}
return(DeployState.IdentityError);
}
private int addCustom(AutoCSer.Net.TcpInternalServer.ServerSocketSender sender, IndexIdentity identity, ClientTask.Custom custom)
{
if ((uint)identity.Index < (uint)deployPool.PoolIndex && checkCustom(sender, custom.CallName))
{
object arrayLock = deployPool.ArrayLock;
Monitor.Enter(arrayLock);
try
{
return(deployPool.Array[identity.Index].AddTask(identity.Identity, new Task {
Sender = sender, RunFileName = custom.CallName, CustomData = custom.CustomData, Type = TaskType.Custom
}));
}
finally { Monitor.Exit(arrayLock); }
}
return(-1);
}
private bool clearAll(AutoCSer.Net.TcpInternalServer.ServerSocketSender sender)
{
if (checkCommand(sender, Command.clearAll))
{
object arrayLock = deployPool.ArrayLock;
Monitor.Enter(arrayLock);
DeployInfo[] deployArray = deployPool.Array;
int poolIndex = deployPool.PoolIndex;
while (poolIndex != 0)
{
deployArray[--poolIndex].Clear();
}
deployPool.ClearIndexContinue();
Monitor.Exit(arrayLock);
GC.Collect();
return(true);
}
return(false);
}
private int addFiles(AutoCSer.Net.TcpInternalServer.ServerSocketSender sender, IndexIdentity identity, Directory directory, ClientTask.WebFile webFile, TaskType taskType)
{
//System.IO.FileInfo file = new System.IO.FileInfo(@"ServerDeSerializeError" + AutoCSer.Date.NowTime.Set().Ticks.ToString());
//System.IO.File.WriteAllBytes(file.FullName, data.ToArray());
//Console.WriteLine(file.FullName);
if ((uint)identity.Index < (uint)deployPool.PoolIndex && checkCommand(sender, Command.addFiles))
{
object arrayLock = deployPool.ArrayLock;
Monitor.Enter(arrayLock);
try
{
return(deployPool.Array[identity.Index].AddTask(identity.Identity, new Task {
Directory = directory, ServerDirectory = new DirectoryInfo(webFile.ServerPath), Type = taskType
}));
}
finally { Monitor.Exit(arrayLock); }
}
return(-1);
}
private IndexIdentity create(AutoCSer.Net.TcpInternalServer.ServerSocketSender sender, IndexIdentity clientId)
{
if (checkCommand(sender, Command.create))
{
int index, identity;
object arrayLock = deployPool.ArrayLock;
Monitor.Enter(arrayLock);
try
{
index = deployPool.GetIndexContinue();
identity = deployPool.Array[index].Set(ref clientId);
}
finally { Monitor.Exit(arrayLock); }
return(new IndexIdentity {
Index = index, Identity = identity
});
}
return(new IndexIdentity {
Index = -1
});
}
/// <summary>
/// 命令处理
/// </summary>
/// <param name="index">命令序号</param>
/// <param name="sender">TCP 内部服务套接字数据发送</param>
/// <param name="data">命令数据</param>
public override void DoCommand(int index, AutoCSer.Net.TcpInternalServer.ServerSocketSender sender, ref SubArray <byte> data)
{
AutoCSer.Net.TcpServer.ReturnType returnType;
switch (index - 128)
{
case 1:
returnType = AutoCSer.Net.TcpServer.ReturnType.Unknown;
try
{
_p1 inputParameter = new _p1();
if (sender.DeSerialize(ref data, ref inputParameter))
{
(_s1 /**/.Pop() ?? new _s1()).Set(sender, Value, AutoCSer.Net.TcpServer.ServerTaskType.Queue, ref inputParameter);
return;
}
returnType = AutoCSer.Net.TcpServer.ReturnType.ServerDeSerializeError;
}
catch (Exception error)
{
returnType = AutoCSer.Net.TcpServer.ReturnType.ServerException;
sender.AddLog(error);
}
sender.Push(returnType);
return;
case 2:
returnType = AutoCSer.Net.TcpServer.ReturnType.Unknown;
try
{
{
_p3 outputParameter = new _p3();
_s2 serverCall = _s2 /**/.Pop() ?? new _s2();
serverCall.AsynchronousCallback = sender.GetCallback <_p3, AutoCSer.Net.TcpRegister.ServerLog>(_c2, ref outputParameter);
serverCall.Set(sender, Value, AutoCSer.Net.TcpServer.ServerTaskType.QueueLink);
return;
}
}
catch (Exception error)
{
returnType = AutoCSer.Net.TcpServer.ReturnType.ServerException;
sender.AddLog(error);
}
sender.Push(returnType);
return;
case 3:
returnType = AutoCSer.Net.TcpServer.ReturnType.Unknown;
try
{
_p4 inputParameter = new _p4();
if (sender.DeSerialize(ref data, ref inputParameter))
{
(_s3 /**/.Pop() ?? new _s3()).Set(sender, Value, AutoCSer.Net.TcpServer.ServerTaskType.Queue, ref inputParameter);
return;
}
returnType = AutoCSer.Net.TcpServer.ReturnType.ServerDeSerializeError;
}
catch (Exception error)
{
returnType = AutoCSer.Net.TcpServer.ReturnType.ServerException;
sender.AddLog(error);
}
sender.Push(returnType);
return;
default: return;
}
}
/// <summary>
/// 命令处理
/// </summary>
/// <param name="index">命令序号</param>
/// <param name="sender">TCP 内部服务套接字数据发送</param>
/// <param name="data">命令数据</param>
public override void DoCommand(int index, AutoCSer.Net.TcpInternalServer.ServerSocketSender sender, ref SubArray <byte> data)
{
AutoCSer.Net.TcpServer.ReturnType returnType;
switch (index - 128)
{
case 0:
returnType = AutoCSer.Net.TcpServer.ReturnType.Unknown;
try
{
_p1 inputParameter = new _p1();
if (sender.DeSerialize(ref data, ref inputParameter, true))
{
_p2 outputParameter = new _p2();
AutoCSer.Web.SearchServer.Server /**/.TcpStaticServer._M1(inputParameter.p0, sender.GetCallback <_p2, AutoCSer.Web.SearchServer.SearchItem[]>(_c1, ref outputParameter));
return;
}
returnType = AutoCSer.Net.TcpServer.ReturnType.ServerDeSerializeError;
}
catch (Exception error)
{
returnType = AutoCSer.Net.TcpServer.ReturnType.ServerException;
sender.AddLog(error);
}
sender.Push(returnType);
return;
case 1:
returnType = AutoCSer.Net.TcpServer.ReturnType.Unknown;
try
{
_p3 inputParameter = new _p3();
if (sender.DeSerialize(ref data, ref inputParameter))
{
_p4 _outputParameter_ = new _p4();
bool Return;
Return = AutoCSer.Web.SearchServer.Server /**/.TcpStaticServer._M2(sender, inputParameter.p2, inputParameter.p3, inputParameter.p0, ref inputParameter.p1);
if (Return)
{
sender.SetVerifyMethod();
}
_outputParameter_.p0 = inputParameter.p1;
_outputParameter_.Return = Return;
sender.Push(_c2, ref _outputParameter_);
return;
}
returnType = AutoCSer.Net.TcpServer.ReturnType.ServerDeSerializeError;
}
catch (Exception error)
{
returnType = AutoCSer.Net.TcpServer.ReturnType.ServerException;
sender.AddLog(error);
}
sender.Push(returnType);
return;
case 2:
returnType = AutoCSer.Net.TcpServer.ReturnType.Unknown;
try
{
_p5 inputParameter = new _p5();
if (sender.DeSerialize(ref data, ref inputParameter))
{
(_s2 /**/.Pop() ?? new _s2()).Set(sender, AutoCSer.Net.TcpServer.ServerTaskType.Timeout, ref inputParameter);
return;
}
returnType = AutoCSer.Net.TcpServer.ReturnType.ServerDeSerializeError;
}
catch (Exception error)
{
returnType = AutoCSer.Net.TcpServer.ReturnType.ServerException;
sender.AddLog(error);
}
sender.Push(returnType);
return;
default: return;
}
}
private static readonly AutoCSer.Net.TcpServer.OutputInfo _c1 = new AutoCSer.Net.TcpServer.OutputInfo {
OutputParameterIndex = 2, IsBuildOutputThread = true
};
private static readonly AutoCSer.Net.TcpServer.OutputInfo _c2 = new AutoCSer.Net.TcpServer.OutputInfo {
OutputParameterIndex = 4, IsSimpleSerializeOutputParamter = true, IsBuildOutputThread = true
};
sealed class _s2 : AutoCSer.Net.TcpStaticServer.ServerCall <_s2, _p5>
{
private void get(ref AutoCSer.Net.TcpServer.ReturnValue <_p6> value)
{
try
{
string Return;
Return = AutoCSer.Web.SearchServer.SearchItem /**/.TcpStaticServer._M3(inputParameter.p0);
value.Value.Return = Return;
value.Type = AutoCSer.Net.TcpServer.ReturnType.Success;
}
catch (Exception error)
{
value.Type = AutoCSer.Net.TcpServer.ReturnType.ServerException;
Sender.AddLog(error);
}
}
/// <summary>
/// 发布服务更新以后的后续处理
/// </summary>
/// <param name="server"></param>
/// <param name="sender"></param>
/// <param name="customData"></param>
/// <returns></returns>
public DeployState OnDeployServerUpdated(Server server, AutoCSer.Net.TcpInternalServer.ServerSocketSender sender, byte[] customData)
{
AutoCSer.Threading.ThreadPool.TinyBackground.Start(server.OnDeployServerUpdated);
return(DeployState.Success);
}
/// <summary>
/// 游戏服务更新以后的后续处理
/// </summary>
/// <param name="server"></param>
/// <param name="sender"></param>
/// <param name="customData"></param>
/// <returns></returns>
public DeployState OnGameServerUpdated(Server server, AutoCSer.Net.TcpInternalServer.ServerSocketSender sender, byte[] customData)
{
AutoCSer.Deploy.Server.UpdateSwitchFile(@"C:\AutoCSer\GameServer\", "AutoCSer.GameServer.exe")
.StartProcessDirectory();
return(DeployState.Success);
}
/// <summary>
/// 命令处理
/// </summary>
/// <param name="index">命令序号</param>
/// <param name="sender">TCP 内部服务套接字数据发送</param>
/// <param name="data">命令数据</param>
public override void DoCommand(int index, AutoCSer.Net.TcpInternalServer.ServerSocketSender sender, ref SubArray <byte> data)
{
AutoCSer.Net.TcpServer.ReturnType returnType;
switch (index - 128)
{
case 0:
returnType = AutoCSer.Net.TcpServer.ReturnType.Unknown;
try
{
_p1 inputParameter = new _p1();
if (sender.DeSerialize(ref data, ref inputParameter))
{
_p2 outputParameter = new _p2();
Value.append(inputParameter.p0, sender.GetCallback <_p2, ulong>(_c0, ref outputParameter));
return;
}
returnType = AutoCSer.Net.TcpServer.ReturnType.ServerDeSerializeError;
}
catch (Exception error)
{
returnType = AutoCSer.Net.TcpServer.ReturnType.ServerException;
sender.AddLog(error);
}
sender.Push(returnType);
return;
case 1:
returnType = AutoCSer.Net.TcpServer.ReturnType.Unknown;
try
{
_p3 inputParameter = new _p3();
if (sender.DeSerialize(ref data, ref inputParameter))
{
(_s1 /**/.Pop() ?? new _s1()).Set(sender, Value, AutoCSer.Net.TcpServer.ServerTaskType.Queue, ref inputParameter);
return;
}
returnType = AutoCSer.Net.TcpServer.ReturnType.ServerDeSerializeError;
}
catch (Exception error)
{
returnType = AutoCSer.Net.TcpServer.ReturnType.ServerException;
sender.AddLog(error);
}
sender.Push(returnType);
return;
case 2:
returnType = AutoCSer.Net.TcpServer.ReturnType.Unknown;
try
{
_p5 inputParameter = new _p5();
if (sender.DeSerialize(ref data, ref inputParameter))
{
_p6 outputParameter = new _p6();
Value.read(inputParameter.p0, inputParameter.p1, sender.GetCallback <_p6, AutoCSer.DiskBlock.ClientBuffer>(_c2, ref outputParameter));
return;
}
returnType = AutoCSer.Net.TcpServer.ReturnType.ServerDeSerializeError;
}
catch (Exception error)
{
returnType = AutoCSer.Net.TcpServer.ReturnType.ServerException;
sender.AddLog(error);
}
sender.Push(returnType);
return;
default: return;
}
}
/// <summary>
/// 检测自定义任务权限
/// </summary>
/// <param name="sender"></param>
/// <param name="customName"></param>
/// <returns></returns>
protected virtual bool checkCustom(AutoCSer.Net.TcpInternalServer.ServerSocketSender sender, string customName)
{
return(true);
}
public static void SetReadCommand(AutoCSer.Net.TcpInternalServer.ServerSocketSender sender)
{
sender.SetCommand((int)command.register);
sender.SetCommand((int)command.getLog);
}
/// <summary>
/// 命令处理
/// </summary>
/// <param name="index">命令序号</param>
/// <param name="sender">TCP 内部服务套接字数据发送</param>
/// <param name="data">命令数据</param>
public override void DoCommand(int index, AutoCSer.Net.TcpInternalServer.ServerSocketSender sender, ref SubArray <byte> data)
{
AutoCSer.Net.TcpServer.ReturnType returnType;
switch (index - 128)
{
case 0:
returnType = AutoCSer.Net.TcpServer.ReturnType.Unknown;
try
{
_p1 inputParameter = new _p1();
if (sender.DeSerialize(ref data, ref inputParameter, true))
{
(_s0 /**/.Pop() ?? new _s0()).Set(sender, AutoCSer.Net.TcpServer.ServerTaskType.Timeout, ref inputParameter);
return;
}
returnType = AutoCSer.Net.TcpServer.ReturnType.ServerDeSerializeError;
}
catch (Exception error)
{
returnType = AutoCSer.Net.TcpServer.ReturnType.ServerException;
sender.AddLog(error);
}
sender.Push(returnType);
return;
case 1:
returnType = AutoCSer.Net.TcpServer.ReturnType.Unknown;
try
{
_p3 inputParameter = new _p3();
if (sender.DeSerialize(ref data, ref inputParameter))
{
_p4 _outputParameter_ = new _p4();
bool Return;
Return = AutoCSer.Web.SearchServer.Server /**/.TcpStaticServer._M2(sender, inputParameter.p2, inputParameter.p0, ref inputParameter.p1);
if (Return)
{
sender.SetVerifyMethod();
}
_outputParameter_.p0 = inputParameter.p1;
_outputParameter_.Return = Return;
sender.Push(_c2, ref _outputParameter_);
return;
}
returnType = AutoCSer.Net.TcpServer.ReturnType.ServerDeSerializeError;
}
catch (Exception error)
{
returnType = AutoCSer.Net.TcpServer.ReturnType.ServerException;
sender.AddLog(error);
}
sender.Push(returnType);
return;
case 2:
returnType = AutoCSer.Net.TcpServer.ReturnType.Unknown;
try
{
_p5 inputParameter = new _p5();
if (sender.DeSerialize(ref data, ref inputParameter))
{
(_s2 /**/.Pop() ?? new _s2()).Set(sender, AutoCSer.Net.TcpServer.ServerTaskType.Timeout, ref inputParameter);
return;
}
returnType = AutoCSer.Net.TcpServer.ReturnType.ServerDeSerializeError;
}
catch (Exception error)
{
returnType = AutoCSer.Net.TcpServer.ReturnType.ServerException;
sender.AddLog(error);
}
sender.Push(returnType);
return;
case 4:
returnType = AutoCSer.Net.TcpServer.ReturnType.Unknown;
try
{
_p7 inputParameter = new _p7();
if (sender.DeSerialize(ref data, ref inputParameter, true))
{
(_s4 /**/.Pop() ?? new _s4()).Set(sender, AutoCSer.Net.TcpServer.ServerTaskType.Timeout, ref inputParameter);
return;
}
returnType = AutoCSer.Net.TcpServer.ReturnType.ServerDeSerializeError;
}
catch (Exception error)
{
returnType = AutoCSer.Net.TcpServer.ReturnType.ServerException;
sender.AddLog(error);
}
sender.Push(returnType);
return;
default: return;
}
}
private static string myName(AutoCSer.Net.TcpInternalServer.ServerSocketSender client)
{
return(MyName(client));
}
public static bool _M2(AutoCSer.Net.TcpInternalServer.ServerSocketSender _sender_, string userID, ulong randomPrefix, byte[] md5Data, ref long ticks)
{
return(AutoCSer.Web.SearchServer.Server.verify(_sender_, userID, randomPrefix, md5Data, ref ticks));
}
/// <summary>
/// 调用自定义任务
/// </summary>
/// <param name="server"></param>
/// <param name="sender"></param>
/// <param name="task"></param>
/// <returns></returns>
internal virtual DeployState Call(Server server, AutoCSer.Net.TcpInternalServer.ServerSocketSender sender, Task task)
{
return(DeployState.Success);
}
private string myName(AutoCSer.Net.TcpInternalServer.ServerSocketSender client)
{
return(TcpStaticServer.GetSession.MyName(client));
}
/// <summary>
/// 命令处理
/// </summary>
/// <param name="index">命令序号</param>
/// <param name="sender">TCP 内部服务套接字数据发送</param>
/// <param name="data">命令数据</param>
public override void DoCommand(int index, AutoCSer.Net.TcpInternalServer.ServerSocketSender sender, ref SubArray <byte> data)
{
AutoCSer.Net.TcpServer.ReturnType returnType;
switch (index - 128)
{
case 0:
returnType = AutoCSer.Net.TcpServer.ReturnType.Unknown;
try
{
_p1 inputParameter = new _p1();
if (sender.DeSerialize(ref data, ref inputParameter))
{
_p2 outputParameter = new _p2();
Value.append(inputParameter.p0, sender.GetCallback <_p2, ulong>(_c0, ref outputParameter));
return;
}
returnType = AutoCSer.Net.TcpServer.ReturnType.ServerDeSerializeError;
}
catch (Exception error)
{
returnType = AutoCSer.Net.TcpServer.ReturnType.ServerException;
sender.AddLog(error);
}
sender.Push(returnType);
return;
case 1:
returnType = AutoCSer.Net.TcpServer.ReturnType.Unknown;
try
{
_p3 inputParameter = new _p3();
if (sender.DeSerialize(ref data, ref inputParameter))
{
_p4 _outputParameter_ = new _p4();
bool Return;
Return = Value.verify(sender, inputParameter.p2, inputParameter.p3, inputParameter.p0, ref inputParameter.p1);
if (Return)
{
sender.SetVerifyMethod();
}
_outputParameter_.p0 = inputParameter.p1;
_outputParameter_.Return = Return;
sender.Push(_c1, ref _outputParameter_);
return;
}
returnType = AutoCSer.Net.TcpServer.ReturnType.ServerDeSerializeError;
}
catch (Exception error)
{
returnType = AutoCSer.Net.TcpServer.ReturnType.ServerException;
sender.AddLog(error);
}
sender.Push(returnType);
return;
case 2:
returnType = AutoCSer.Net.TcpServer.ReturnType.Unknown;
try
{
_p5 inputParameter = new _p5();
if (sender.DeSerialize(ref data, ref inputParameter))
{
_p6 outputParameter = new _p6();
Value.read(inputParameter.p0, inputParameter.p1, sender.GetCallback <_p6, AutoCSer.DiskBlock.ClientBuffer>(_c2, ref outputParameter));
return;
}
returnType = AutoCSer.Net.TcpServer.ReturnType.ServerDeSerializeError;
}
catch (Exception error)
{
returnType = AutoCSer.Net.TcpServer.ReturnType.ServerException;
sender.AddLog(error);
}
sender.Push(returnType);
return;
default: return;
}
}
private static bool login(AutoCSer.Net.TcpInternalServer.ServerSocketSender client, string user, string password)
{
return(Login(client, user, password));
}
/// <summary>
/// 检测任务权限
/// </summary>
/// <param name="sender"></param>
/// <param name="command"></param>
/// <returns></returns>
protected virtual bool checkCommand(AutoCSer.Net.TcpInternalServer.ServerSocketSender sender, Command command)
{
return(true);
}
