public void AddClientRequest(RCClient client, bool forceRun)
{
if (!forceRun && this.listViewRCClient.InvokeRequired)
{
RCClientControl.Callback_AddClient method = new RCClientControl.Callback_AddClient(this.AddClientRequest);
base.Invoke(method, new object[]
{
client,
true
});
return;
}
int i = 0;
int num = this.listViewRCClient.Items.Count;
while (i < num)
{
int num2 = (i + num) / 2;
int num3 = ((RCClientControl.ClientItem) this.listViewRCClient.Items[num2]).CompareTo(client.Name, client.ClientIP, client.ID);
if (num3 < 0)
{
i = num2 + 1;
}
else
{
if (num3 <= 0)
{
return;
}
num = num2;
}
}
this.listViewRCClient.Items.Insert(i, new RCClientControl.ClientItem(client));
}
public void Start(int port)
{
Base.ClientServer.OnChildProcessLogAdded += this.logManager.ChildProcessLogAdded;
this.logManager.OnAddLIstenGroup += delegate(object s, ListenerGroupEventArgs e)
{
Base.ClientServer.SendMessage <ChildProcessLogConnectMessage>(e.ClientID, new ChildProcessLogConnectMessage(e.ClientID, e.ProcessName, e.PID));
};
this.logManager.OnDeleteLIstenGroup += delegate(object s, ListenerGroupEventArgs e)
{
Base.ClientServer.SendMessage <ChildProcessLogDisconnectMessage>(e.ClientID, new ChildProcessLogDisconnectMessage(e.ClientID, e.ProcessName, e.PID));
};
this.logManager.OnChildProcessLogAdded += delegate(object s, ChildProcessLogEventArgs e)
{
RCClient rcclient = s as RCClient;
e.Message.ClientID = rcclient.ID;
foreach (int userID in e.Clients)
{
Base.ControlServer.SendToUser <ChildProcessLogMessage>(userID, e.Message);
}
};
this.jobProcessor.Start();
this.tcpServer.Start(this.jobProcessor, port);
FileWatcher.Start();
FileDistributor.Start();
}
public ChildProcessListForm(RCClient client, RCProcess process)
{
this.Client = client;
this.Process = process;
this.InitializeComponent();
this.Text = string.Format("{0} {1} {2}", this.Client.Name, this.Process.Name, this.Text);
}
private static void ProcessMessage(object rawMessage, object tag)
{
if (rawMessage is FunctionReplyMessage)
{
FunctionReplyMessage functionReplyMessage = rawMessage as FunctionReplyMessage;
Base.ControlServer.SendToUser(functionReplyMessage.ClientID, new Packet(functionReplyMessage.Packet));
return;
}
if (rawMessage is ChildProcessLogReplyMessage)
{
return;
}
if (rawMessage is ChildProcessLogMessage)
{
if (Base.ClientServer.OnChildProcessLogAdded != null)
{
RCClient sender = tag as RCClient;
Base.ClientServer.OnChildProcessLogAdded(sender, new EventArgs <ChildProcessLogMessage>(rawMessage as ChildProcessLogMessage));
return;
}
}
else if (rawMessage is CheckPatchProcessResultMessage)
{
CheckPatchProcessResultMessage checkPatchProcessResultMessage = rawMessage as CheckPatchProcessResultMessage;
foreach (string message in checkPatchProcessResultMessage.CheckPatchLog)
{
Base.ControlServer.NotifyMessage(MessageType.Message, message, new object[0]);
}
}
}
internal Commands(HeroesAdminManager _manager)
{
this.manager = _manager;
this.commandDict = new Dictionary <string, Commands.CommandHandler>();
MethodInfo[] methods = base.GetType().GetMethods(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
foreach (MethodInfo methodInfo in methods)
{
object[] customAttributes = methodInfo.GetCustomAttributes(typeof(CommandHandlerAttribute), false);
if (customAttributes.Length > 0)
{
Delegate @delegate = Delegate.CreateDelegate(typeof(Commands.CommandHandler), this, methodInfo, false);
if (@delegate != null)
{
foreach (CommandHandlerAttribute commandHandlerAttribute in customAttributes)
{
if (!this.commandDict.ContainsKey(commandHandlerAttribute.Command))
{
this.commandDict.Add(commandHandlerAttribute.Command, @delegate as Commands.CommandHandler);
RCClient.Console_AddCustomCommand(RCProcess.CustomCommandParser.ToRawString(commandHandlerAttribute.Name, commandHandlerAttribute.Command, commandHandlerAttribute.Argument));
}
}
}
}
}
}
private void CheckAndAddHeroesAdmin(RCClient client)
{
foreach (RCProcess process in client.ProcessList)
{
this.CheckAndAddHeroesAdmin(client.ID, client.ClientIP, process);
}
}
public void AddClient(RCClient client)
{
foreach (RCProcess rcprocess in client.ProcessList)
{
this.IncreaseConditionCountItem(new WorkGroupCondition(client.Name, rcprocess.Name));
}
}
public void AddToWorkGroup(RCClient client)
{
foreach (RCProcess process in client.ProcessList)
{
this.AddToWorkGroup(client, process);
}
}
public void RemoveFromWorkGroup(RCClient client)
{
foreach (RCProcess process in client.ProcessList)
{
this.RemoveFromWorkGroup(client, process);
}
}
private void RCUserHandler_ProcessLog(RCClient sender, RCClient.ProcessLogEventArgs args)
{
if (this.userCounts.ContainsKey(args.Process) && args.Process.PerformanceString.Length > 0 && RCProcess.IsStandardOutputLog(args.Message) && args.Process.IsPerformanceLog(args.Message) && this.UserCountLogged != null)
{
this.UserCountLogged(args.Process, new EventArgs <string>(args.Process.GetPerformanceLog(args.Message)));
}
}
private void Client_ProcessLog(RCClient sender, RCClient.ProcessLogEventArgs args)
{
if (RCProcess.IsNotifyLog(args.Message))
{
Base.ControlServer.NotifyMessage(MessageType.Message, RCProcess.GetOriginalLog(args.Message), new object[0]);
}
this.SendControlReplyMessageToUser <LogProcessMessage>(sender.ID, new LogProcessMessage(args.Process.Name, args.Message));
}
public void OpenChildProcessLog(RCClient client, RCProcess process, int pid)
{
if (this.childProcessLogs.MakeGenerator(client, process, pid))
{
ChildProcessLogRequestMessage message = new ChildProcessLogRequestMessage(client.ID, process.Name, pid);
this._rcUser.SendMessage <ChildProcessLogRequestMessage>(message);
}
}
public void AddClients(ICollection clientList)
{
foreach (object obj in clientList)
{
RCClient client = (RCClient)obj;
this.AddClient(client);
}
}
private void ProcessCrashed(RCClient s, RCProcess e)
{
if (this.OnAlarm != null)
{
string message = string.Format("{0} - {1} {2}", s.Name, e.Description, (e.State == RCProcess.ProcessState.Freezing) ? "Freezing" : "Crash");
this.OnAlarm(s, new MainForm.AlarmEventArgs(message));
}
}
private void ProcessClientMessage(Packet packet, RCClient client)
{
Type type = this.MF.GetType(packet);
if (type == typeof(AddProcessMessage))
{
AddProcessMessage addProcessMessage;
SerializeReader.FromBinary <AddProcessMessage>(packet, out addProcessMessage);
client.ProcessMessage(addProcessMessage);
this.CheckAndAddHeroesAdmin(client.ID, client.ClientIP, addProcessMessage.Process);
return;
}
if (type == typeof(ModifyProcessMessage))
{
ModifyProcessMessage modifyProcessMessage;
SerializeReader.FromBinary <ModifyProcessMessage>(packet, out modifyProcessMessage);
client.ProcessMessage(modifyProcessMessage);
this.CheckAndAddHeroesAdmin(client.ID, client.ClientIP, modifyProcessMessage.Process);
return;
}
if (type == typeof(RemoveProcessMessage))
{
RemoveProcessMessage removeProcessMessage;
SerializeReader.FromBinary <RemoveProcessMessage>(packet, out removeProcessMessage);
client.ProcessMessage(removeProcessMessage);
this.CheckAndRemoveHeroesAdmin(client.ID, removeProcessMessage.Name);
return;
}
if (type == typeof(StateChangeProcessMessage))
{
StateChangeProcessMessage stateChangeProcessMessage;
SerializeReader.FromBinary <StateChangeProcessMessage>(packet, out stateChangeProcessMessage);
if (this.serverGroups.ContainsKey(client.ID) && stateChangeProcessMessage.State == RCProcess.ProcessState.On)
{
string processKey = this.GetProcessKey(client.ID, stateChangeProcessMessage.Name);
if (this.serverGroups[client.ID].ContainsKey(processKey))
{
string value = this.serverGroups[client.ID][processKey];
if (this.ServerGroupActivated != null)
{
this.ServerGroupActivated(this, new EventArgs <string>(value));
return;
}
}
}
}
else if (type == typeof(LogProcessMessage))
{
LogProcessMessage logProcessMessage;
SerializeReader.FromBinary <LogProcessMessage>(packet, out logProcessMessage);
RCProcess rcprocess = client[logProcessMessage.Name];
if ((rcprocess.PerformanceString.Length == 0 || !RCProcess.IsStandardOutputLog(logProcessMessage.Message) || !RCProcess.GetOriginalLog(logProcessMessage.Message).StartsWith(rcprocess.PerformanceString)) && this.ProcessLogged != null)
{
this.ProcessLogged(new KeyValuePair <RCClient, RCProcess>(client, rcprocess), new EventArgs <string>(RCProcess.GetOriginalLog(logProcessMessage.Message)));
}
}
}
private void RCUserHandler_ProcessRemove(RCClient sender, RCProcess process)
{
if (this.commandBridges.ContainsKey(process))
{
this.commandBridgeModified = true;
this.commandBridges.Remove(process);
}
this.CheckAndRemoveProcessLog(sender, process);
}
public void UpdateProcessState(RCClient client, RCProcess process)
{
string conditionKey = this.GetConditionKey(client, process);
WorkGroupTreeNode workGroupTreeNode = this[conditionKey];
if (workGroupTreeNode != null)
{
workGroupTreeNode.RecalculateTreeColor();
}
}
private void ClientInitialized(RCClient sender, object args)
{
Base.ControlServer.SendToUser <ClientAddedMessage>(new ClientAddedMessage(sender.ID, sender));
sender.ServerInfoChange += this.Client_ServerInfoChange;
sender.ProcessAdd += this.Client_ProcessAdd;
sender.ProcessModify += this.Client_ProcessModify;
sender.ProcessRemove += this.Client_ProcessRemove;
sender.ProcessStateChange += this.Client_ProcessStateChange;
sender.ProcessLog += this.Client_ProcessLog;
}
public void ChildProcessLogAdded(object sender, EventArgs <ChildProcessLogMessage> args)
{
RCClient rcclient = sender as RCClient;
LogManager.Key key = LogManager.MakeKey(rcclient.ID, args.Value.ProcessName, args.Value.ProcessID);
if (this.dict.ContainsKey(key) && this.OnChildProcessLogAdded != null)
{
this.OnChildProcessLogAdded(rcclient, new ChildProcessLogEventArgs(this.dict[key], args.Value));
}
}
public static ClientProcessItem GetShowItem(RCClient client, RCProcess process)
{
ClientProcessItem key = new ClientProcessItem(client, process);
if (ClientProcessItem.ShowItem.ContainsKey(key))
{
return(ClientProcessItem.ShowItem[key]);
}
return(null);
}
public ClientEventHandler(RCClient client)
{
client.ServerInfoChange += this.Client_ServerInfoChange;
client.ProcessAdd += this.Client_ProcessAdd;
client.ProcessModify += this.Client_ProcessModify;
client.ProcessRemove += this.Client_ProcessRemove;
client.ProcessStateChange += this.Client_ProcessStateChange;
client.ProcessLog += this.Client_ProcessLog;
client.FileDistributed += this.Client_FileDistributed;
}
private void RC_ClientRemove(object sender, EventArgs <RCClient> args)
{
RCClient rcclient = this.clientList[args.Value.ID] as RCClient;
if (rcclient == null)
{
return;
}
this.clientList.Remove(args.Value.ID);
this.rcClientControl.RemoveClient(rcclient);
}
private void AddClient(RCClient client)
{
if (!this.clientList.ContainsKey(client.ID))
{
this.clientList.Add(client.ID, client);
}
if (!this.clientNames.ContainsKey(client.Name))
{
this.clientNames.Add(client.Name, client);
}
}
public bool PreProcess(RCClient client, Packet packet)
{
Type packetType = this.GetPacketType(packet);
if (packetType == typeof(PerformanceUpdateMessage))
{
Base.ControlServer.SendToUser <ControlReplyMessage>(new ControlReplyMessage(client.ID, packet.Bytes));
return(false);
}
return(false);
}
private void RCUserHandler_ProcessAdd(RCClient sender, RCProcess process)
{
if (process.Properties.ContainsKey("commandbridge"))
{
this.commandBridges.Add(process, sender);
this.commandBridgeModified = true;
}
if (process.Properties.ContainsKey("UserCount"))
{
this.CheckAndAddProcessLog(sender, process);
}
}
public void ProcessRCClientMessage(RCClient rcClient, ArraySegment <byte> value)
{
try
{
this.MF.Handle(new Packet(value), rcClient);
}
catch (Exception ex)
{
Utility.ShowErrorMessage(LocalizeText.Get(221) + ex.ToString());
this.Stop();
}
}
private bool CheckAndAddProcessLog(RCClient client, RCProcess process)
{
if (!this.userCounts.ContainsKey(process))
{
if (!this.userCounts.ContainsValue(client))
{
client.ProcessLog += this.RCUserHandler_ProcessLog;
}
this.userCounts.Add(process, client);
return(true);
}
return(false);
}
public ClientItem(RCClient client) : base(new string[]
{
client.Name,
client.ClientIP,
client.Version.ToString()
})
{
this.Name = client.Name;
this.IP = client.ClientIP;
this.ID = client.ID;
this.Version = client.Version;
this._processCollection = client.ProcessClone();
}
private bool CheckAndRemoveProcessLog(RCClient client, RCProcess process)
{
if (this.userCounts.ContainsKey(process))
{
this.userCounts.Remove(process);
if (!this.userCounts.ContainsValue(client))
{
client.ProcessLog -= this.RCUserHandler_ProcessLog;
return(true);
}
}
return(false);
}
public void LogGenerated(RCClient client, RCProcess process, string message)
{
string key = ProcessLogGeneratorCollection.MakeKey(client, process);
if (this.dict.ContainsKey(key))
{
this.dict[key].LogGenerated(process, message);
}
if (this.allProcessLogActive > 0)
{
this.AllProcessLog.LogGenerated(process, message);
}
}
