private void DeleteModule() { if (selectedModule == null) { return; } Module module = selectedModule; selectedModule = null; dgvModuleCommands.Enabled = false; ClearModule(); if (modules.ContainsKey(module.Name)) { modules.Remove(module.Name); } if (ConfigurationHelper.Blackboard.Modules.Contains(module)) { ConfigurationHelper.Blackboard.Modules.Remove(module); } if (lstBBModules.Items.Contains(module)) { lstBBModules.Items.Remove(module); } foreach (IPrototype proto in module.Prototypes) { if (prototypes.ContainsKey(proto.Command)) { prototypes.Remove(proto.Command); } } }
private Prototype AddPrototype(Module module, string commandName, bool responseRequired, bool paramsRequired, bool hasPriority, int timeout) { if (module == null) { return(null); } Prototype proto = new Prototype(commandName, paramsRequired, responseRequired, timeout, hasPriority); module.Prototypes.Add(proto); return(proto); }
private bool IsValidInput(Module source, string s) { Command cmd; Response rsp; if ((Response.IsResponse(s) && Response.TryParse(s, source, out rsp)) || Command.IsCommand(s) && Command.TryParse(s, source, out cmd)) { return(true); } return(false); }
private void ReplacePrototype(Module module, Prototype oldPrototype, Prototype newPrototype) { if ((module == null) || (newPrototype == null)) { return; } if (oldPrototype != null) { prototypes.Remove(oldPrototype.Command); for (int i = 0; i < ConfigurationHelper.Blackboard.Modules.Count; ++i) { ConfigurationHelper.Blackboard.Modules[i].Prototypes.Remove(oldPrototype); } } //prototypes.Add(newPrototype.CommandName, newPrototype); }
private void SelectModule(Module selectedModule) { if (selectedModule == null) { dgvModuleCommands.Enabled = false; pgModuleProperties.Enabled = false; //ClearModule(); return; } if (this.selectedModule == selectedModule) { return; } this.selectedModule = selectedModule; pgModuleProperties.Enabled = true; ClearModule(); FillModuleData(); pgModuleProperties.Focus(); dgvModuleCommands.Sort(dgvModuleCommands.Columns["colCommandName"], ListSortDirection.Ascending); }
private Button CreateModuleButton(ModuleClient mc) { Button b = new Button(); b.Name = "btn" + mc.Name; b.Text = mc.Name; b.Width = flpModuleList.Width - 25; b.Anchor = AnchorStyles.Left | AnchorStyles.Right | AnchorStyles.Top; b.ImageAlign = ContentAlignment.MiddleLeft; b.TextImageRelation = TextImageRelation.ImageBeforeText; b.Image = mc.Enabled ? Properties.Resources.ExitGreen_16 : Properties.Resources.ExitRed_16; return b; }
/// <summary> /// Converts the string representation of a command to a Command object. /// A return value indicates whether the conversion succeded or not. /// </summary> /// <param name="s">A string containing the command to convert</param> /// <param name="source">The module which sent the command</param> /// <param name="destination">The destination module for the command</param> /// <param name="cmd">When this method returns, contains the Command equivalent to the command /// contained in s, if the conversion succeeded, or null if the conversion failed. /// The conversion fails if the s parameter is a null reference (Nothing in Visual Basic) or is not of the correct format. /// This parameter is passed uninitialized</param> /// <param name="ex">When this method returns, contains the Exception generated during the parse operation, /// if the conversion failed, or null if the conversion succeeded. The conversion fails if the s parameter /// is a null reference (Nothing in Visual Basic) or is not of the correct format. /// This parameter is passed uninitialized</param> /// <returns>true if conversion was successfull, false otherwise</returns> protected static bool TryParse(string s, ModuleClient source, ModuleClient destination, out Command cmd, out Exception ex) { IPrototype proto; string sCommand; string sParams; int result; int id; cmd = null; ex = null; // Module Validation if (source.Parent != destination.Parent) { ex = new Exception("Source and destination modules does not belong to the same blackboard"); return false; } // Extract Data CommandBase.XtractCommandElements(s, out sCommand, out sParams, out result, out id); if ((sCommand == null) || (result != -1)) { ex = new ArgumentException("Invalid String", "s"); return false; } // Browse for an adequate prototype proto = null; if (destination.Prototypes.Contains(sCommand)) proto = destination.Prototypes[sCommand]; // Check if command matchs a prototype. If no prototype found, asume redirection if ((proto != null) && proto.ParamsRequired && ((sParams == null) || (sParams.Length < 1))) { ex = new Exception("Invalid string. The Command requires parameters"); return false; } // Create the Command cmd = new Command(source, destination, sCommand, sParams, id); cmd.prototype = proto; cmd.sentTime = DateTime.Now; return true; }
private void module_Disconnected(ModuleClient m) { if (Disconnected != null) Disconnected(m); Log.WriteLine(4, "Disconnected from " + m.Name); }
private void module_ActionExecuted(ModuleClient m, IAction action, bool success) { Log.WriteLine(5, m.Name + ": " + action.ToString() + (success ? " Success!!!" : " failed.")); }
private static void ExtractPrototypes(ModuleClient mod, XmlDocument tmpDoc, ILogWriter log) { XmlNodeList commands; Prototype proto; List<Prototype> protoList; string cmdName; bool cmdParams; bool cmdAnswer; int cmdPriority = 1; bool cmdPriorityB; int cmdTimeOut; #region Module Commands Extraction // Leo lista de comandos. log.WriteLine(2, "\tLoading module commands..."); if (tmpDoc.GetElementsByTagName("commands").Count < 1) { log.WriteLine(3, "\tNo commands to load"); log.WriteLine(2, "\tModule skipped"); return; } commands = tmpDoc.GetElementsByTagName("commands")[0].ChildNodes; protoList = new List<Prototype>(commands.Count); #region Extraccion de Comandos de modulo for (int j = 0; j < commands.Count; ++j) { // Verifico que sea un comando cmdTimeOut = 0; if ((commands[j].Name == "command") && (commands[j].Attributes.Count >= 3) && (commands[j].Attributes["name"].Value.Length > 1) && Boolean.TryParse(commands[j].Attributes["answer"].Value, out cmdAnswer) && ( (cmdAnswer && Int32.TryParse(commands[j].Attributes["timeout"].Value, out cmdTimeOut) && (cmdTimeOut >= 0)) || !cmdAnswer )) { // Leo nombre de comando cmdName = commands[j].Attributes["name"].Value; log.WriteLine(2, "\t\tAdded command " + cmdName); // Verifico si requiere parametros if ((commands[j].Attributes["parameters"] == null) || !Boolean.TryParse(commands[j].Attributes["parameters"].Value, out cmdParams)) cmdParams = true; // Verifico si tiene prioridad if (commands[j].Attributes["priority"] != null) { if(Boolean.TryParse(commands[j].Attributes["priority"].Value, out cmdPriorityB)) cmdPriority = cmdPriorityB ? 0 : 1; else if (!Int32.TryParse(commands[j].Attributes["priority"].Value, out cmdPriority)) cmdPriority = 1; } // Creo el prototipo proto = new Prototype(cmdName, cmdParams, cmdAnswer, cmdTimeOut, cmdPriority); // Agrego el prototipo al modulo mod.Prototypes.Add(proto); protoList.Add(proto); } else log.WriteLine(4, "\t\tInvalid Command "); } #endregion // Si no hay comandos soportados por el modulo, salto el modulo if (protoList.Count < 1) { log.WriteLine(3, "\tAll commands rejected."); //log.WriteLine(2, "Module skipped"); return; } #endregion }
/// <summary> /// Converts the string representation of a response to a Response object. /// A return value indicates whether the conversion succeded or not. /// <param name="s">A string containing the response to convert</param> /// <param name="source">The module which sent the response</param> /// <param name="destination">The destination module for the response</param> /// <param name="result">When this method returns, contains the Response equivalent to the response /// contained in s, if the conversion succeeded, or null if the conversion failed. /// The conversion fails if the s parameter is a null reference (Nothing in Visual Basic) or is not of the correct format. /// This parameter is passed uninitialized</param> /// </summary> /// <returns>true if conversion was successfull, false otherwise</returns> public static bool TryParse(string s, ModuleClient source, ModuleClient destination, out Response result) { Exception ex; return TryParse(s, source, destination, out result, out ex); }
/// <summary> /// Converts the string representation of a response to a Response object. /// A return value indicates whether the conversion succeded or not. /// <param name="s">A string containing the response to convert</param> /// <param name="source">The module which sent the response</param> /// <param name="destination">The destination module for the response</param> /// <param name="response">When this method returns, contains the Response equivalent to the response /// contained in s, if the conversion succeeded, or null if the conversion failed. /// The conversion fails if the s parameter is a null reference (Nothing in Visual Basic) or is not of the correct format. /// This parameter is passed uninitialized</param> /// <param name="ex">When this method returns, contains the Exception generated during the parse operation, /// if the conversion failed, or null if the conversion succeeded. The conversion fails if the s parameter /// is a null reference (Nothing in Visual Basic) or is not of the correct format. /// This parameter is passed uninitialized</param> /// </summary> /// <returns>true if conversion was successfull, false otherwise</returns> protected static bool TryParse(string s, ModuleClient source, ModuleClient destination, out Response response, out Exception ex) { IPrototype proto; string sCommand; string sParams; bool result; int iResult; int id; ex = null; response = null; // Module Validation if (source.Parent != destination.Parent) { ex = new Exception("Source and destination modules does not belong to the same blackboard"); return false; } // Extract Data CommandBase.XtractCommandElements(s, out sCommand, out sParams, out iResult, out id); if ((sCommand == null) || (iResult == -1)) { ex = new ArgumentException("Invalid String", "s"); return false; } result = iResult == 1; // Browse for an adequate prototype proto = null; if (destination.Prototypes.Contains(sCommand)) proto = destination.Prototypes[sCommand]; // Check if response matchs a prototype. If no prototype found, asume redirection if ((proto != null) && proto.ParamsRequired && ((sParams == null) || (sParams.Length < 1))) { ex = new Exception("Invalid string. The Response requires parameters"); return false; } // Create the Response response = new Response(source, destination, sCommand, sParams, result, id); response.prototype = proto; if (!response.success) response.failReason = ResponseFailReason.ExecutedButNotSucceded; return true; }
private void SelectModule(ModuleClient selectedModule) { //if (selectedModule == null) //{ // gbModule.Enabled = false; // ClearModule(); // return; //} //if (this.selectedModule == selectedModule) // return; //this.selectedModule = selectedModule; //ClearModule(); //FillModuleData(); //txtModuleName.Focus(); throw new NotImplementedException(); }
private void ReplacePrototype(ModuleClient module, Prototype oldPrototype, Prototype newPrototype) { if ((module == null) || (newPrototype == null)) return; if (oldPrototype != null) { prototypes.Remove(oldPrototype.Command); for (int i = 0; i < ConfigurationHelper.Blackboard.Modules.Count; ++i) ConfigurationHelper.Blackboard.Modules[i].Prototypes.Remove(oldPrototype); } prototypes.Add(newPrototype.Command, newPrototype); module.Prototypes.Add(newPrototype); }
private void ModuleStop(ModuleClient module) { module.BeginStop(); btnModuleStartStopModule.Enabled = false; btnModuleStartStopModule.Text = "Stopping Module"; while (module.IsRunning) Application.DoEvents(); btnModuleStartStopModule.Text = "Start Module"; btnModuleStartStopModule.Image = Properties.Resources.run16; btnModuleStartStopModule.Enabled = true; }
private void ModuleStartStop(ModuleClient module) { if ((blackboard == null) || !blackboard.IsRunning || (module == null) || !module.Enabled) return; if (module.IsRunning) ModuleStop(module); else ModuleStart(module); }
private void ModuleRestart(ModuleClient module) { if ((blackboard == null) || !blackboard.IsRunning || (module == null) || !module.Enabled) return; module.Restart(); }
private void ModuleProcessZombieCheck(ModuleClient module) { if ((processManager == null) || (module == null)) return; }
private void PopulateModuleMenu_Start(ToolStripMenuItem mnu, ModuleClient mc) { ToolStripMenuItem mni; mni = (ToolStripMenuItem)mnu.DropDownItems.Add(mc.IsRunning ? "Running (click to stop)" : "Stopped (click to start)"); mni.Image = mc.IsRunning ? Properties.Resources.Stop_16 : Properties.Resources.run16; mni.Enabled = mc.Enabled && blackboard.IsRunning; mni.Tag = mc; mni.Click += new EventHandler(mnuiModule_Module_Start_Click); }
public ModuleWrapper(ModuleClient module) { this.module = module; }
private void DeleteModule() { if (selectedModule == null) return; ModuleClient module = selectedModule; selectedModule = null; //gbModule.Enabled = false; ClearModule(); if (modules.ContainsKey(module.Name)) modules.Remove(module.Name); if (ConfigurationHelper.Blackboard.Modules.Contains(module)) ConfigurationHelper.Blackboard.Modules.Remove(module); if (lstBBModules.Items.Contains(module)) lstBBModules.Items.Remove(module); foreach (Prototype proto in module.Prototypes) { if (prototypes.ContainsKey(proto.Command)) prototypes.Remove(proto.Command); } }
/// <summary> /// Converts the string representation of a response to a Response object. /// <param name="s">A string containing the response to convert</param> /// <param name="source">The module which sent the response</param> /// <param name="destination">The destination module for the response</param> /// </summary> /// <returns>A response object that represents the response contained in s</returns> public static Response Parse(string s, ModuleClient source, ModuleClient destination) { Exception ex; Response response; if (!TryParse(s, source, destination, out response, out ex)) throw ex; else return response; }
private void PopulateModuleMenu_ZombieCheck(ToolStripMenuItem mnu, ModuleClient mc) { ToolStripMenuItem mni = (ToolStripMenuItem)mnu.DropDownItems.Add("&Check for zombie processes"); mni.Image = Properties.Resources.ProcessInfo16; mni.Enabled = mc.Enabled && mc.IsRunning; mni.Tag = mc; mni.Click += new EventHandler(mnuiModule_Module_ZombieCheck_Click); }
/// <summary> /// Converts the string representation of a response to a Response object. /// A return value indicates whether the conversion succeded or not. /// <param name="s">A string containing the response to convert</param> /// <param name="source">The module which sent the response</param> /// <param name="response">When this method returns, contains the Response equivalent to the response /// contained in s, if the conversion succeeded, or null if the conversion failed. /// The conversion fails if the s parameter is a null reference (Nothing in Visual Basic) or is not of the correct format. /// This parameter is passed uninitialized</param> /// <param name="ex">When this method returns, contains the Exception generated during the parse operation, /// if the conversion failed, or null if the conversion succeeded. The conversion fails if the s parameter /// is a null reference (Nothing in Visual Basic) or is not of the correct format. /// This parameter is passed uninitialized</param> /// </summary> /// <returns>true if conversion was successfull, false otherwise</returns> protected static bool TryParse(string s, ModuleClient source, out Response response, out Exception ex) { IPrototype proto; //Module destination; IModuleClient destination; //Module eSource; IModuleClient eSource; string sCommand; string sParams; string sDest; bool result; int iResult; int id; ex = null; response = null; // Extract Data CommandBase.XtractCommandElements(s, out sDest, out sCommand, out sParams, out iResult, out id); if ((sCommand == null) || (iResult == -1)) { ex = new ArgumentException("Invalid String", "s"); return false; } result = iResult == 1; // Browse for prototype and validating command if (!source.Parent.FindDestinationModule(sCommand, out eSource, out proto) || (eSource != source)) //Since the response arrived from a module which can't generate it a exception is rised { ex = new Exception("Sender module and generator module does not match"); return false; } // if destination module is specified, then it mus be set if ((sDest != null) && (sDest.Length > 0) && source.Parent.Modules.Contains(sDest)) destination = source.Parent.Modules[sDest]; // Else, since there is no way at this point to determine which is destination module for response // and this is no specified, it is set to null, to allow blackboard to find an apropiate one else destination = null; // Check if response matchs a prototype if ((proto != null) && proto.ParamsRequired && ((sParams == null) || (sParams.Length < 1))) { ex = new Exception("Invalid string. The Response requires parameters"); return false; } // Create the Response response = new Response(source, destination, sCommand, sParams, result, id); response.prototype = proto; if (!response.success) response.failReason = ResponseFailReason.ExecutedButNotSucceded; return true; }
private bool InjectUserMessage(ModuleClient mc, string message) { return blackboard.Inject(mc.Name + " " + message); }
/// <summary> /// Extracts the module information from the provided xml document /// </summary> /// <param name="module">The module to load the commands in</param> /// <param name="doc">The document from where the commands will be loaded</param> /// <param name="log">The log writer</param> /// <returns>Returns a list of prototypes which contains the command information.</returns> private static Prototype[] XtractModuleCommands(ModuleClient module, XmlDocument doc, LogWriter log) { XmlNodeList commands; List<Prototype> protoList; Prototype proto; string cmdName; bool cmdParams; bool cmdAnswer; bool cmdPriority; int cmdTimeOut; // Get the list of commands. If none, return log.WriteLine(2, "\tLoading module commands..."); if (doc.GetElementsByTagName("commands").Count < 1) { log.WriteLine(3, "\tNo commands to load"); return null; } commands = doc.GetElementsByTagName("commands")[0].ChildNodes; protoList = new List<Prototype>(commands.Count); #region Module command extraction for (int j = 0; j < commands.Count; ++j) { // Verify that the node is a command cmdTimeOut = 0; if ((commands[j].Name == "command") && (commands[j].Attributes.Count >= 3) && (commands[j].Attributes["name"].Value.Length > 1) && Boolean.TryParse(commands[j].Attributes["answer"].Value, out cmdAnswer) && ( (cmdAnswer && Int32.TryParse(commands[j].Attributes["timeout"].Value, out cmdTimeOut) && (cmdTimeOut >= 0)) || !cmdAnswer )) { // Read command name cmdName = commands[j].Attributes["name"].Value; log.WriteLine(2, "\t\tAdded command " + cmdName); // Check if command require parameters if ((commands[j].Attributes["parameters"] == null) || !Boolean.TryParse(commands[j].Attributes["parameters"].Value, out cmdParams)) cmdParams = true; // Check if command has preiority if ((commands[j].Attributes["priority"] == null) || !Boolean.TryParse(commands[j].Attributes["priority"].Value, out cmdPriority)) cmdPriority = false; // Create the prototype proto = new Prototype(cmdName, cmdParams, cmdAnswer, cmdTimeOut, cmdPriority); // Add the prototype to the module module.Prototypes.Add(proto); protoList.Add(proto); } else log.WriteLine(4, "\t\tInvalid Command "); } #endregion // If there are no commands supported by the module, skip it. if (protoList.Count < 1) log.WriteLine(3, "\tAll commands rejected."); return protoList.ToArray(); }
private bool SendUserMessage(ModuleClient mc, string message) { Command c; Response r; bool success; if (Command.TryParse(message, mc, out c)) { success = mc.Send(c); Log("# Send user command [" + message + "] " + (success ? "success!" : "failed")); lblLastSendToModuleResult.Text = "Send user command: " + (success ? "success!" : "failed"); return true; } if (Response.TryParse(message, mc, out r)) { success = mc.Send(r); Log("# Send user response [" + message + "] " + (success ? "success!" : "failed")); lblLastSendToModuleResult.Text = "Send user response: " + (success ? "success!" : "failed"); return true; } return false; }
private void module_Connected(ModuleClient m) { if (Connected != null) Connected(m); Log.WriteLine(4, "Connected to " + m.Name); }
/// <summary> /// Converts the string representation of a command to a Command object. /// A return value indicates whether the conversion succeded or not. /// </summary> /// <param name="s">A string containing the command to convert</param> /// <param name="source">The module which sent the command</param> /// <param name="destination">The destination module for the command</param> /// <param name="command">When this method returns, contains the Command equivalent to the command /// contained in s, if the conversion succeeded, or null if the conversion failed. /// The conversion fails if the s parameter is a null reference (Nothing in Visual Basic) or is not of the correct format. /// This parameter is passed uninitialized</param> /// <returns>true if conversion was successfull, false otherwise</returns> public static bool TryParse(string s, ModuleClient source, ModuleClient destination, out Command command) { Exception ex; return TryParse(s, source, destination, out command, out ex); }
/// <summary> /// Adds a module to the blackboard /// </summary> private static void AddModuleToBlackboard(Blackboard blackboard, ILogWriter log, ModuleClient mod, SortedList<string, ModuleClient> disabledModules) { if (mod.Enabled) { blackboard.modules.Add(mod); log.WriteLine(2, "Loading module complete!"); } else { disabledModules.Add(mod.Name, mod); log.WriteLine(2, "Disabled module enqueued!"); } }
private void PopulateModuleMenu_Simulation(ToolStripMenuItem mnu, ModuleClient mc) { ToolStripMenuItem mni = (ToolStripMenuItem)mnu.DropDownItems.Add(mc.Simulation.SimulationEnabled ? "&Simulation enabled" : "&Simulation disabled"); mni.Image = mc.Simulation.SimulationEnabled ? Properties.Resources.CircleGreen_16 : Properties.Resources.CircleGray_16; mni.Enabled = mc.Enabled; mni.Tag = mc; mni.Click += new EventHandler(mnuiModule_Module_Simulation_Click); }
/// <summary> /// Converts the string representation of a command to a Command object. /// <param name="s">A string containing the command to convert</param> /// <param name="source">The module which sent the command</param> /// <param name="destination">The destination module for the command</param> /// </summary> /// <returns>A command object that represents the command contained in s</returns> public static Command Parse(string s, ModuleClient source, ModuleClient destination) { Exception ex; Command command; if (!TryParse(s, source, destination, out command, out ex)) throw ex; else return command; }
private void AddSecondaryModuleButton(ModuleClient mc) { Button b2 = CreateModuleButton(mc); frmBbss.FlpModuleList.Controls.Add(b2); moduleButtonsClone.Add(mc.Name, b2); }
/// <summary> /// Converts the string representation of a command to a Command object. /// A return value indicates whether the conversion succeded or not. /// </summary> /// <param name="s">A string containing the command to convert</param> /// <param name="source">The module which sent the command</param> /// <param name="cmd">When this method returns, contains the Command equivalent to the command /// contained in s, if the conversion succeeded, or null if the conversion failed. /// The conversion fails if the s parameter is a null reference (Nothing in Visual Basic) or is not of the correct format. /// This parameter is passed uninitialized</param> /// <param name="ex">When this method returns, contains the Exception generated during the parse operation, /// if the conversion failed, or null if the conversion succeeded. The conversion fails if the s parameter /// is a null reference (Nothing in Visual Basic) or is not of the correct format. /// This parameter is passed uninitialized</param> /// <returns>true if conversion was successfull, false otherwise</returns> protected static bool TryParse(string s, ModuleClient source, out Command cmd, out Exception ex) { IPrototype proto; //Module destination; IModuleClient destination; string sCommand; string sParams; string sDest; int result; int id; cmd = null; ex = null; // Extract Data CommandBase.XtractCommandElements(s, out sDest, out sCommand, out sParams, out result, out id); if ((sCommand == null) || (result != -1)) { ex = new ArgumentException("Invalid String", "s"); return false; } // Browse for destination module and prototype if (source.SupportCommand(sCommand, out proto)) destination = source; else if(!source.Parent.FindDestinationModule(sCommand, out destination, out proto)) { // No destination module found. Must check if destination is availiable if ((sDest == null) || (sDest.Length < 1) || !source.Parent.Modules.Contains(sDest)) { ex = new Exception("No destination module found for command provided"); return false; } destination = source.Parent.Modules[sDest]; proto = null; } // Check if command matchs a prototype if (proto == null) { ex = new Exception("No prototype for provided command was found"); return false; } if ((proto != null) && proto.ParamsRequired && ((sParams == null) || (sParams.Length < 1))) { ex = new Exception("Invalid string. The Command requires parameters"); return false; } // Create the Command cmd = new Command(source, destination, sCommand, sParams, id); cmd.prototype = proto; cmd.sentTime = DateTime.Now; return true; }
private void PopulateModuleMenu_Run(ToolStripMenuItem mnu, ModuleClient mc) { ToolStripMenuItem mni = (ToolStripMenuItem)mnu.DropDownItems.Add("Run (&unconditionally)"); mni.Image = Properties.Resources.ProcessWarning16; mni.Enabled = mc.Enabled; mni.Tag = mc; mni.Click += new EventHandler(mnuiModule_Module_Run_Click); }