private void ProcCheck(IModuleClientTcp module)
{
IModuleProcessInfo pi = module.ProcessInfo;
if ((pi == null) || (String.IsNullOrEmpty(pi.ProcessName)))
{
WriteError("No process information found for module {0}", module);
return;
}
Console.Write("Checking running instances for module {0}... ", module.Name);
try
{
int count = this.procMan.CheckModule(module);
if (count >= 0)
{
Console.WriteLine("Done! There are {0} instances of {1} being executed.", count, module.Name);
}
else
{
Console.WriteLine("Failed!");
}
}
catch (Exception ex)
{
Console.WriteLine();
WriteError("Failed: " + ex.Message);
}
}
/*
* /// <summary>
* /// Kills all modules
* /// </summary>
* public void StopModules()
* {
* lock (oLock)
* {
*
* }
* }
*/
/// <summary>
/// Waits untill a module becomes ready
/// </summary>
/// <param name="mc">The IModuleClientTcp object which contains the information about the module to wait for</param>
private void WaitModuleReady(IModuleClientTcp mc)
{
Parent.Log.WriteLine(6, "Waiting for '" + mc.Name + "' to be ready.");
do
{
mc.WaitReady(500);
} while (parent.IsRunning && !mc.Ready);
Parent.Log.WriteLine(6, "IModuleClientTcp '" + mc.Name + "' is ready.");
}
/// <summary>
/// Checks if the process of the specified module is running
/// </summary>
/// <param name="module">The module to check</param>
/// <returns>The number of running instances of the module</returns>
public int CheckModule(IModuleClientTcp module)
{
lock (oLock)
{
if (!module.IsLocal)
{
return(RemoteCheck(module));
}
return(processManager.RunningProcessesCount(module.ProcessInfo));
}
}
/// <summary>
/// Starts the specified module
/// </summary>
/// <param name="module">The module to start</param>
/// <param name="method">The method used for startup</param>
public void LaunchModule(IModuleClientTcp module, ModuleStartupMethod method)
{
bool result;
if ((method == ModuleStartupMethod.None) || (module == null) || (module.ProcessInfo == null))
{
return;
}
lock (oLock)
{
if (!module.IsLocal)
{
result = RemoteStartup(module, method);
//if (result && (method == ModuleStartupMethod.LaunchAndWaitReady))
// WaitModuleReady(module);
return;
}
switch (method)
{
case ModuleStartupMethod.LaunchAlways:
LaunchLocalModule(module);
break;
case ModuleStartupMethod.LaunchAndWaitReady:
//if (KillModule(module) && LaunchModule(module))
// WaitModuleReady(module);
KillLocalModule(module);
LaunchLocalModule(module);
break;
case ModuleStartupMethod.LaunchIfNotRunning:
LaunchLocalModuleIfNotRunning(module);
break;
case ModuleStartupMethod.KillThenLaunch:
if (KillLocalModule(module))
{
LaunchLocalModule(module);
}
break;
case ModuleStartupMethod.KillOnly:
KillLocalModule(module);
break;
}
}
}
/// <summary>
/// Fills out the MachineStatusCollection list with information from blackboard
/// </summary>
private void FillMachineStatussList()
{
//msc.Add(new MachineStatus(IPAddress.Parse("127.0.0.1"), 50, BatteryChargeStatus.Unknown));
foreach (IModuleClient m in this.Parent.Modules)
{
IModuleClientTcp module = m as IModuleClientTcp;
if (module == null)
{
continue;
}
for (int i = 0; i < module.ServerAddresses.Count; ++i)
{
if (!msc.Contains(module.ServerAddresses[i]) &&
!module.ServerAddresses[i].Equals(IPAddress.Any) &&
!module.ServerAddresses[i].Equals(IPAddress.Broadcast))
{
msc.Add(new MachineStatus(module.ServerAddresses[i], 50, BatteryChargeStatus.Unknown));
}
}
}
}
private void ProcStart(IModuleClientTcp module)
{
IModuleProcessInfo pi = module.ProcessInfo;
if ((pi == null) || String.IsNullOrEmpty(pi.ProgramPath))
{
WriteError("No process information found for module {0}", module);
return;
}
Console.Write("Attempting to start module {0}... ", module.Name);
try
{
this.procMan.LaunchModule(module, ModuleStartupMethod.LaunchAlways);
Console.WriteLine("Done!");
}
catch (Exception ex)
{
Console.WriteLine();
WriteError("Failed: " + ex.Message);
}
}
private void ProcKill(IModuleClientTcp module)
{
IModuleProcessInfo pi = module.ProcessInfo;
if ((pi == null) || (String.IsNullOrEmpty(pi.ProcessName)))
{
WriteError("No process information found for module {0}", module);
return;
}
Console.Write("Attempting to kill module {0}... ", module.Name);
try
{
this.procMan.ShutdownModule(module, ModuleShutdownMethod.KillOnly);
Console.WriteLine("Done!");
}
catch (Exception ex)
{
Console.WriteLine();
WriteError("Failed: " + ex.Message);
}
}
/// <summary>
/// Shutsdown the specified module
/// </summary>
/// <param name="module">The module to shutdown</param>
/// <param name="method">The method used for startup</param>
public void ShutdownModule(IModuleClientTcp module, ModuleShutdownMethod method)
{
bool result;
if ((method == ModuleShutdownMethod.None) || (module == null) || (module.ProcessInfo == null))
{
return;
}
lock (oLock)
{
Log.WriteLine(4, "Executing shutdown sequence...");
if (!module.IsLocal)
{
result = RemoteShutdown(module, method);
return;
}
switch (method)
{
case ModuleShutdownMethod.CloseOnly:
CloseLocalModule(module);
break;
case ModuleShutdownMethod.KillOnly:
KillLocalModule(module);
break;
case ModuleShutdownMethod.CloseThenKill:
if (!CloseLocalModule(module))
{
KillLocalModule(module);
}
break;
}
Log.WriteLine(4, "Shutdown sequence excecution complete!");
}
}
/// <summary>
/// Request to execute the module startup on remote computer
/// </summary>
/// <param name="mc">The module to start</param>
/// <param name="method">The startup sequence method</param>
private bool RemoteStartup(IModuleClientTcp mc, ModuleStartupMethod method)
{
RemoteStartupRequest request;
RemoteStartupResponse response;
SocketTcpClient client;
AutoResetEvent dataReceivedEvent;
string serialized;
Log.WriteLine(5, "Starting module '" + mc.Name + "': on remote computer.");
client = null;
foreach (IPAddress ip in mc.ServerAddresses)
{
client = new SocketTcpClient(ip, 2300);
if (client.TryConnect())
{
break;
}
}
if ((client == null) || !client.IsConnected)
{
Log.WriteLine(5, "Can not start module '" + mc.Name + "': unable to connect to remote computer.");
return(false);
}
dataReceivedEvent = new AutoResetEvent(false);
client.DataReceived += new TcpDataReceivedEventHandler(delegate(TcpPacket packet)
{
response = RemoteStartupResponse.FromXml(packet.DataString);
dataReceivedEvent.Set();
});
try
{
request = new RemoteStartupRequest(mc.Name, method, mc.ProcessInfo);
serialized = RemoteStartupRequest.ToXml(request);
client.Send(serialized);
response = null;
dataReceivedEvent.WaitOne(10000);
if (response == null)
{
Log.WriteLine(5, "Can not start module '" + mc.Name + "': no response received");
client.Disconnect();
return(false);
}
if ((response.ModuleName != request.ModuleName) ||
(response.Method != request.Method))
{
Log.WriteLine(5, "Can not start module '" + mc.Name + "': invalid response");
client.Disconnect();
return(false);
}
if (!response.Success)
{
Log.WriteLine(5, "Can not start module '" + mc.Name + "': " + response.Message);
client.Disconnect();
return(false);
}
Log.WriteLine(5, "Start module '" + mc.Name + "': Success");
client.Disconnect();
return(true);
}
catch (Exception ex)
{
Log.WriteLine(5, "Can not start module '" + mc.Name + "': " + ex.Message);
return(false);
}
finally
{
if ((client != null) && client.IsConnected)
{
client.Disconnect();
}
if (client.Socket != null)
{
client.Socket.Close();
}
}
}
/// <summary>
/// Launches a module if it is not running
/// </summary>
/// <param name="mc">The IModuleClientTcp object which contains the information about the module to launch</param>
private bool LaunchLocalModuleIfNotRunning(IModuleClientTcp mc)
{
return(processManager.LaunchProcessIfNotRunning(mc.ProcessInfo));
}
/// <summary>
/// Closes a module
/// </summary>
/// <param name="mc">The IModuleClientTcp object which contains the information about the module to close</param>
private bool CloseLocalModule(IModuleClientTcp mc)
{
return(processManager.CloseProcessWindow(mc.ProcessInfo));
}
private void ProcKill(IModuleClientTcp module)
{
IModuleProcessInfo pi = module.ProcessInfo;
if ((pi == null) || (String.IsNullOrEmpty(pi.ProcessName)))
{
WriteError("No process information found for module {0}", module);
return;
}
Console.Write("Attempting to kill module {0}... ", module.Name);
try
{
this.procMan.ShutdownModule(module, ModuleShutdownMethod.KillOnly);
Console.WriteLine("Done!");
}
catch (Exception ex)
{
Console.WriteLine();
WriteError("Failed: " + ex.Message);
}
}
public void InfoCommand(string s)
{
ConsoleColor color;
if (!this.blackboard.Modules.Contains(s))
{
Console.WriteLine("Unknown module {0}", s);
return;
}
IModuleClient m = this.blackboard.Modules[s];
WriteModule(m);
if (!String.IsNullOrEmpty(m.Alias) && (m.Alias != m.Name))
{
Console.WriteLine("Alias: {0}", m.Alias);
}
if (!m.Enabled)
{
return;
}
if (m.Simulation.SimulationEnabled)
{
color = Console.ForegroundColor;
Console.ForegroundColor = ConsoleColor.Green;
Console.WriteLine("Simulation enabled");
Console.ForegroundColor = color;
}
IModuleClientTcp tcpModule = m as IModuleClientTcp;
if (tcpModule != null)
{
color = Console.ForegroundColor;
Console.ForegroundColor = ConsoleColor.White;
Console.WriteLine();
Console.WriteLine("TCP information:");
Console.ForegroundColor = color;
StringBuilder sb = new StringBuilder(100);
foreach (System.Net.IPAddress a in tcpModule.ServerAddresses)
{
sb.Append(a.ToString());
sb.Append(", ");
}
if (sb.Length > 2)
{
sb.Length -= 2;
}
Console.WriteLine("TCP Port: {0}", tcpModule.Port);
Console.WriteLine("Addresses: {0}", sb.ToString());
}
if (m.ProcessInfo != null)
{
color = Console.ForegroundColor;
Console.ForegroundColor = ConsoleColor.White;
Console.WriteLine();
Console.WriteLine("Process information:");
Console.ForegroundColor = color;
Console.WriteLine("Process Name: {0}", m.ProcessInfo.ProcessName);
Console.WriteLine("Program Path: {0}", m.ProcessInfo.ProgramPath);
Console.WriteLine("Program Args: {0}", m.ProcessInfo.ProgramArgs);
}
color = Console.ForegroundColor;
Console.ForegroundColor = ConsoleColor.White;
Console.WriteLine();
Console.WriteLine("Prototypes (supported commands):");
Console.ForegroundColor = color;
WriteModulePrototypes(m);
Console.WriteLine();
}
private void ProcStart(IModuleClientTcp module)
{
IModuleProcessInfo pi = module.ProcessInfo;
if ((pi == null) || String.IsNullOrEmpty(pi.ProgramPath))
{
WriteError("No process information found for module {0}", module);
return;
}
Console.Write("Attempting to start module {0}... ", module.Name);
try
{
this.procMan.LaunchModule(module, ModuleStartupMethod.LaunchAlways);
Console.WriteLine("Done!");
}
catch (Exception ex)
{
Console.WriteLine();
WriteError("Failed: " + ex.Message);
}
}
/// <summary>
/// Kills a module
/// </summary>
/// <param name="mc">The IModuleClientTcp object which contains the information about the module to kill</param>
private bool KillLocalModule(IModuleClientTcp mc)
{
return(processManager.CloseThenKillProcess(mc.ProcessInfo));
}
/// <summary>
/// Launches a module
/// </summary>
/// <param name="mc">The IModuleClientTcp object which contains the information about the module to launch</param>
private bool LaunchModule(IModuleClientTcp mc)
{
return(processManager.LaunchProcess(mc.ProcessInfo));
}
private void ProcCheck(IModuleClientTcp module)
{
IModuleProcessInfo pi = module.ProcessInfo;
if ((pi == null) || (String.IsNullOrEmpty(pi.ProcessName)))
{
WriteError("No process information found for module {0}", module);
return;
}
Console.Write("Checking running instances for module {0}... ", module.Name);
try
{
int count = this.procMan.CheckModule(module);
if (count >= 0)
Console.WriteLine("Done! There are {0} instances of {1} being executed.", count, module.Name);
else
Console.WriteLine("Failed!");
}
catch (Exception ex)
{
Console.WriteLine();
WriteError("Failed: " + ex.Message);
}
}
