private void CrashHander(RCProcess sender, RCProcess.StateChangeEventArgs args)
{
if (args.OldState == RCProcess.ProcessState.On && args.NewState == RCProcess.ProcessState.Crash)
{
this.RunExe(sender);
}
}
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 void comboBoxName_SelectedIndexChanged(object sender, EventArgs e)
{
RCProcess rcprocess = this.comboBoxName.SelectedItem as RCProcess;
if (rcprocess != null)
{
this.textBoxType.Text = rcprocess.Type;
this.textBoxDescription.Text = rcprocess.Description;
this.textBoxWorkingDirectory.Text = rcprocess.WorkingDirectory;
this.textBoxExecuteFileName.Text = rcprocess.ExecuteName;
this.textBoxExecuteFileArgs.Text = rcprocess.ExecuteArgs;
this.textBoxUpdateFileName.Text = rcprocess.UpdateExecuteName;
this.textBoxUpdateFileArgs.Text = rcprocess.UpdateExecuteArgs;
this.detailForm.BootedString = rcprocess.BootedString;
this.detailForm.FillCustomCommand(rcprocess.CustomCommandString);
this.textBoxStandardOutLogLines.Text = rcprocess.LogLines.ToString();
this.detailForm.ShutdownString = rcprocess.ShutdownString;
this.detailForm.PerformanceString = rcprocess.PerformanceString;
this.detailForm.FillPerformanceDescription(rcprocess.PerformanceDescription);
this.checkBoxUse.Checked = rcprocess.DefaultSelect;
this.checkBoxAutomaticStart.Checked = rcprocess.AutomaticStart;
this.checkBoxRunOnce.Checked = rcprocess.AutomaticRestart;
this.checkBoxPerformance.Checked = rcprocess.CheckPerformance;
this.detailForm.TraceChildProcess = rcprocess.TraceChildProcess;
this.detailForm.MaxChildProcessCount = rcprocess.MaxChildProcessCount;
this.detailForm.ChildProcessLogStr = rcprocess.ChildProcessLogStr;
}
}
public void AddProcess(RCProcess newProcess)
{
if (newProcess != null)
{
this._processCollection.Add(newProcess);
}
}
public ProcessPropertyDetailForm(RCProcess process, bool editable) : this()
{
this.textBoxShutdownString.Text = process.ShutdownString;
this.textBoxBootedString.Text = process.BootedString;
this.textBoxPerformanceString.Text = process.PerformanceString;
this.checkBoxTraceChildProcess.Checked = process.TraceChildProcess;
this.textBoxMaxChildProcessCount.Text = process.MaxChildProcessCount.ToString();
this.textBoxChildProcessLogStr.Text = process.ChildProcessLogStr;
this.FillCustomCommand(process.CustomCommandString);
this.FillPerformanceDescription(process.PerformanceDescription);
this.FillProperty(process.StaticProperties, process.Properties);
if (!editable)
{
this._editable = false;
this.textBoxShutdownString.Enabled = false;
this.buttonCustomCommandAdd.Enabled = false;
this.buttonCustomCommandSub.Enabled = false;
this.buttonCustomCommandUp.Enabled = false;
this.buttonCustomCommandDown.Enabled = false;
this.textBoxBootedString.Enabled = false;
this.textBoxPerformanceString.Enabled = false;
this.buttonPerformanceDescAdd.Enabled = false;
this.buttonPerformanceDescSub.Enabled = false;
this.buttonPerformanceDescUp.Enabled = false;
this.buttonPerformanceDescDown.Enabled = false;
this.buttonPropertyAdd.Enabled = false;
this.buttonPropertyDel.Enabled = false;
this.checkBoxTraceChildProcess.Enabled = false;
this.textBoxMaxChildProcessCount.Enabled = false;
this.textBoxChildProcessLogStr.Enabled = false;
}
}
private void ChildProcess_ProcessLog(RCProcess sender, RCProcess.LogEventArgs args)
{
if (this.ProcessLog != null)
{
this.ProcessLog(this, new RCClient.ProcessLogEventArgs(sender, args.Message));
}
}
private void ChildProcess_StateChange(RCProcess sender, RCProcess.StateChangeEventArgs args)
{
if (this.ProcessStateChange != null)
{
this.ProcessStateChange(this, new RCClient.ProcessStateEventArgs(sender, args.ChangedTime, args.OldState));
}
}
public void ModifyProcess(RCProcess newProcess)
{
if (newProcess != null && this._processCollection.Contains(newProcess.Name))
{
this._processCollection[newProcess.Name].Modify(newProcess);
}
}
private void BootHandler(RCProcess sender, RCProcess.StateChangeEventArgs args)
{
if (args.OldState == RCProcess.ProcessState.Booting && args.NewState == RCProcess.ProcessState.On)
{
this.RunExe(sender);
}
}
private void ChildProcess_SysCommand(RCProcess sender, RCProcess.LogEventArgs e)
{
List <string> list = new List <string>();
string t = e.Message.Substring(1);
string text = t.ParseCommand(list);
string a;
if ((a = text) != null)
{
if (a == "AddProperty")
{
this.SysCmd_AddProperty(sender, list);
return;
}
if (a == "DelProperty")
{
this.SysCmd_DelProperty(sender, list);
return;
}
if (!(a == "AddCustomCommand"))
{
return;
}
this.SysCmd_AddCustomCommand(sender, list);
}
}
public void Run(RCProcess _process)
{
this.Clear();
if (!this.Enabled || string.IsNullOrEmpty(this.Command))
{
return;
}
switch (this.ScheduleType)
{
case RCProcessScheduler.EScheduleType.AfterBoot:
this._eventHandler = new RCProcess.StateChangeEventHandler(this.BootHandler);
_process.StateChange += this.EventHandler;
return;
case RCProcessScheduler.EScheduleType.AfterCrach:
this._eventHandler = new RCProcess.StateChangeEventHandler(this.CrashHander);
_process.StateChange += this.EventHandler;
return;
case RCProcessScheduler.EScheduleType.Once:
if (this.ScheduleTime > DateTime.Now)
{
TimeSpan dueTime = TimeSpan.FromTicks(this.ScheduleTime.Ticks - DateTime.Now.Ticks);
this.timer = new Timer(new TimerCallback(this.TimerCallback), _process, dueTime, new TimeSpan(-1L));
}
return;
default:
return;
}
}
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 ProcessPropertyForm(ICollection processTemplateList) : this()
{
foreach (object obj in processTemplateList)
{
RCProcess item = (RCProcess)obj;
this.comboBoxName.Items.Add(item);
}
}
public ProcessItem(RCProcess process, bool disabled) : base(process.Name)
{
this.Process = process;
if (disabled)
{
base.ForeColor = Color.FromKnownColor(KnownColor.GrayText);
}
}
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));
}
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 KillUpdateProcess(string name)
{
RCProcess rcprocess = this._processCollection[name];
if (rcprocess != null)
{
rcprocess.KillUpdate();
}
}
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 StandardInProcess(StandardInProcessMessage message)
{
RCProcess rcprocess = this._processCollection[message.Name];
if (rcprocess != null)
{
rcprocess.StandardIn(message.Message);
}
}
private void ModifyTemplate(RCProcess process, int index)
{
if (this.processTemplateCollection.Contains(process))
{
this.processTemplateCollection[process.Name].Modify(process);
this.listViewProcessTemplate.Items.RemoveAt(index);
this.AddView(process, index);
}
}
private void RCUserHandler_ProcessRemove(RCClient sender, RCProcess process)
{
if (this.commandBridges.ContainsKey(process))
{
this.commandBridgeModified = true;
this.commandBridges.Remove(process);
}
this.CheckAndRemoveProcessLog(sender, process);
}
private void StateChangeProcess(StateChangeProcessMessage message)
{
RCProcess rcprocess = this._processCollection[message.Name];
if (rcprocess != null)
{
rcprocess.ChangeState(message.State);
}
}
private void LogProcess(LogProcessMessage message)
{
RCProcess rcprocess = this._processCollection[message.Name];
if (rcprocess != null)
{
rcprocess.AddLogManual(message.Message);
}
}
private void StopProcess(string name)
{
RCProcess rcprocess = this._processCollection[name];
if (rcprocess != null)
{
rcprocess.Stop();
}
}
public ProcessPropertyForm(RCProcess process, int version, bool editable, bool multEdit) : this()
{
this.detailForm = new ProcessPropertyDetailForm(process, editable);
this._editable = editable;
this.comboBoxName.Text = process.Name;
this.comboBoxName.Enabled = false;
this.textBoxType.Text = process.Type;
this.textBoxDescription.Text = process.Description;
this.textBoxWorkingDirectory.Text = process.WorkingDirectory;
this.textBoxExecuteFileName.Text = process.ExecuteName;
this.textBoxExecuteFileArgs.Text = process.ExecuteArgs;
if (string.IsNullOrEmpty(this.textBoxExecuteFileArgs.Text))
{
this.toolTipProperty.SetToolTip(this.textBoxExecuteFileArgs, LocalizeText.Get(260));
}
else
{
this.toolTipProperty.SetToolTip(this.textBoxExecuteFileArgs, process.ExecuteArgs);
}
this.textBoxUpdateFileName.Text = process.UpdateExecuteName;
this.textBoxUpdateFileArgs.Text = process.UpdateExecuteArgs;
this.textBoxStandardOutLogLines.Text = process.LogLines.ToString();
this.checkBoxRunOnce.Checked = process.AutomaticRestart;
this.checkBoxUse.Checked = process.DefaultSelect;
this.checkBoxAutomaticStart.Checked = process.AutomaticStart;
this.checkBoxPerformance.Checked = process.CheckPerformance;
if (!editable)
{
this.textBoxType.Enabled = false;
this.textBoxDescription.Enabled = false;
this.textBoxWorkingDirectory.Enabled = false;
this.textBoxExecuteFileName.Enabled = false;
this.textBoxExecuteFileArgs.Enabled = false;
this.textBoxUpdateFileName.Enabled = false;
this.textBoxUpdateFileArgs.Enabled = false;
this.textBoxStandardOutLogLines.Enabled = false;
this.checkBoxRunOnce.Enabled = false;
this.checkBoxUse.Enabled = false;
this.checkBoxAutomaticStart.Enabled = false;
this.checkBoxPerformance.Enabled = false;
this.buttonScheduleAdd.Enabled = false;
this.buttonScheduleSub.Enabled = false;
}
else if (multEdit)
{
this.textBoxDescription.Enabled = false;
}
if (version != 0 && version < 8)
{
this.textBoxType.Enabled = false;
}
foreach (RCProcessScheduler schedule in process.Schedules)
{
this.AddProcessSchedule(schedule);
}
}
public void UpdateProcessState(RCClient client, RCProcess process)
{
string conditionKey = this.GetConditionKey(client, process);
WorkGroupTreeNode workGroupTreeNode = this[conditionKey];
if (workGroupTreeNode != null)
{
workGroupTreeNode.RecalculateTreeColor();
}
}
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 void PerformaceUpdate(PerformanceUpdateMessage message)
{
foreach (KeyValuePair <string, RCProcess.SPerformance> keyValuePair in message.Performance)
{
RCProcess rcprocess = this._processCollection[keyValuePair.Key];
if (rcprocess != null)
{
rcprocess.UpdatePerformance(keyValuePair.Value.PrivateMemorySize, keyValuePair.Value.VirtualMemorySize, keyValuePair.Value.CPU);
}
}
}
public RCProcess ModifyProcessWithoutPrimaryInfo(RCProcess newProcess)
{
if (newProcess != null)
{
if (this._processCollection.Contains(newProcess.Name))
{
this._processCollection[newProcess.Name].ModifyEx(newProcess);
}
return(this._processCollection[newProcess.Name]);
}
return(null);
}
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);
}
}
static void Main(string[] args)
{
/*
List<Thread> handles = new List<Thread>();
for (int i = 0; i < 1024; ++i)
{
Thread tHandle = new Thread(new ThreadStart(ThreadFunc));
handles.Add(tHandle);
}
foreach (var h in handles)
{
h.Start();
}
foreach (var h in handles)
{
h.Join();
}
* */
for (int i = 0; i < 1; ++i)
{
var process = new RCProcess();
process.StartProcess();
}
Process.GetCurrentProcess().WaitForExit();
}
