/// <summary> /// Writes a configuration item's value to a file. /// </summary> /// <param name="value">The value to write to the file.</param> /// <param name="log">The event log to log exceptions to. May be null for no logging.</param> /// <returns>True if the write was successful, false otherwise.</returns> protected bool Write(string value, EventLog.EventLog log) { // Write the value to the file. File file = null; try { file = new File(FilePath, false); return(file.WriteLine(value)); } catch (Exception e) { // There was an error opening the file. LogException(e, log); return(false); } finally { // Close the file. if (file != null) { file.Close(); } } }
/// <summary> /// Retrieves an AES 256 encrypted value from the configuration file. /// </summary> /// <param name="log">The event log to log exceptions to. May be null for no logging.</param> /// <returns>The value or null if not found or it could not be decrypted.</returns> protected string SecureGet(EventLog.EventLog log) { // Get the raw value of the encrypted string. string value = Get(log); // Decrypt the string if the raw value contains one. if (!string.IsNullOrWhiteSpace(value)) { // Get the encrypted string containing the key, initialization vector, value, and key and // initialization vector lengths from the file. // Read only the first line of the file, as this is all that is necessary for the encrypted // format. StringReader reader = new StringReader(Get(log)); string encryptedValue = reader.ReadLine(); // Check that an encrypted value was retrieved. if (!string.IsNullOrWhiteSpace(encryptedValue)) { // The encrypted value was retrieved. // Decrypt the encrypted value. return(AES256.DecryptConsolidatedString(encryptedValue)); } } // Could not retrieve the encrypted value. return(null); }
/// <summary> /// Runs SQL script files given their path. /// </summary> /// <param name="connectionString">The connection string to use when creating the database.</param> /// <param name="scriptPaths">The paths to the script files on the filesystem.</param> /// <param name="log">The event log to log execptions to. May be null for no logging.</param> /// <returns>True if all scripts ran, false otherwise.</returns> public virtual bool RunScript(string connectionString, string[] scriptPaths, EventLog.EventLog log) { // Check that the connection string and script paths were provided. if (!string.IsNullOrWhiteSpace(connectionString) && scriptPaths != null) { // The connection string and script paths were provided. // Check that the files exist. foreach (string path in scriptPaths) { if (!File.Exists(path)) { // A file does not exist. return(false); } } // Execute the scripts. foreach (string path in scriptPaths) { if (!ExecuteNonQuerySQLFile(path, connectionString, log)) { // There was an error running the script. return(false); } } return(true); } else { // The connection string and script paths were not provided. return(false); } }
// ---------- CONSTRUCTORS ---------- /// <summary> /// Creates a stored procedure. /// </summary> /// <param name="connectionString">The connection string for the SQL database to which the procedure belongs.</param> /// <param name="procedureName">The name of the procedure.</param> /// <param name="log">An event log to log exceptions to. May be null if no exception logging is desired.</param> public OracleStoredProcedure(string connectionString, string procedureName, EventLog.EventLog log) { // Check that parameters were supplied. if (!string.IsNullOrEmpty(connectionString) && !string.IsNullOrEmpty(procedureName)) { // Initialize the connection and command. Name = procedureName; Connection = new OracleConnection(connectionString); Command = new OracleCommand(Name, (OracleConnection)Connection); Command.CommandType = CommandType.StoredProcedure; } Log = log; }
/// <summary> /// Logs an exception to the event log. /// </summary> /// <param name="e">The exception to log.</param> /// <param name="log">The event log to log the execption to.</param> /// <returns>True if the exception was logged successfully. False otherwise.</returns> protected override bool LogException(Exception e, EventLog.EventLog log) { if (log != null) { log.Log(new Event(typeof(MongoDBUtility).FullName, DateTime.Now, Event.SeverityLevels.Error, e.GetType().FullName, "Description:\n" + e.Message + "\n" + "Stack Trace:\n" + e.StackTrace)); return(true); } else { return(false); } }
// ---------- METHODS ---------- /// <summary> /// Logs an exception to the event log. /// </summary> /// <param name="e">The exception to log.</param> /// <param name="log">The event log to log the execption to.</param> /// <returns>True if the exception was logged successfully. False otherwise.</returns> static private bool LogException(Exception e, EventLog.EventLog log) { if (log != null) { log.Log(new Event(typeof(PowerShell).FullName, DateTime.Now, Event.SeverityLevels.Error, e.GetType().FullName, "Description:\n" + e.Message + "\n" + "Stack Trace:\n" + e.StackTrace)); return(true); } else { return(false); } }
// ----- CONSTRUCTORS ----- /// <summary> /// Loads a configuration item with the specified name from its file located /// in a folder at the supplied path. /// </summary> /// <param name="folderPath">The path of the folder containing the configuration item.</param> /// <param name="name">The name of the configuration item.</param> /// <param name="encrypted">Whether to store the item in an encrypted format.</param> /// <param name="value">(Optional) The value of the configuration item. (Supplying a null value will retrieve the value stored /// in the item if it already exists).</param> /// <param name="log">(Optional) The event log to log exceptions to. May be null for no logging.</param> /// <param name="readOnly">Whether the configuration item should be opened for reading only. Default: true</param> public ConfigurationItem(String folderPath, String name, Boolean encrypted, String value = null, EventLog.EventLog log = null, Boolean readOnly = true) { if (!String.IsNullOrWhiteSpace(folderPath) && !String.IsNullOrWhiteSpace(name)) { FolderPath = folderPath; Name = name; Encrypted = encrypted; eventLog = log; this.readOnly = readOnly; // If the value is not null, set the value. if (value != null) { // Initialize the value. Value = value; } } }
/// <summary> /// Writes an AES 256 encrypted value to its configuration file. /// </summary> /// <param name="value">The value to write to the file.</param> /// <param name="log">The event log to log execptions to. May be null for no logging.</param> /// <returns>True if the write was successful, false otherwise.</returns> protected bool SecureWrite(string value, EventLog.EventLog log) { // Create a consolidated encrypted string value for storage in the file. string consolidatedString = AES256.CreateConsolidatedString(value); // Check that the consolidated string value was created successfully. if (!string.IsNullOrWhiteSpace(consolidatedString)) { // The consolidated string value was created successfully. // Write the consolidated string value containing the encrypted value to a file. return(Write(consolidatedString, log)); } else { // The consolidated string value was not created. return(false); } }
// ---------- CONSTRUCTORS ---------- /// <summary> /// Inititalizes the PowerShellScript environment. /// </summary> /// <param name="log">An event log to log exceptions to. May be null if no exception logging is desired.</param> /// <param name="pool">A runspace pool for the scripting environment to use. May be null if a new Runspace pool is desired.</param> public PowerShellScript(EventLog.EventLog log, RunspacePool pool) { RunspacePool = null; Log = log; if (pool != null) { RunspacePool = pool; // Open the Runspace Pool so it's ready for use. if (RunspacePool.RunspacePoolStateInfo.State != RunspacePoolState.Opened) { RunspacePool.Open(); } } else { InitializeRunspacePool(); } }
/// <summary> /// Retrieves the value of a configuration item from its file. /// </summary> /// <param name="log">The event log to log exceptions to. May be null for no logging.</param> /// <returns>The value of the configuration item or null if not found.</returns> protected string Get(EventLog.EventLog log) { File file = null; try { // Get the file. file = new File(FilePath, false, readOnly); // Check that the file exists. if (file.Exists()) { // Return the value of the item from the file. return(file.ReadAllAsText()); } else { // The file doesn't exist. Return null. return(null); } } catch (Exception e) { // There was an error opening or reading from the file. LogException(e, log); return(null); } finally { // Close the file. if (file != null) { file.Close(); } } }
/// <summary> /// Executes the non-query TSQL command provided. /// </summary> /// <param name="command">The TSQL command text to execute.</param> /// <param name="connectionString">The connection string of the database to execute the script against.</param> /// <param name="log">The event log to log execptions to. May be null for no logging.</param> /// <returns>True if the command ran, false otherwise.</returns> override public bool ExecuteNonQuery(String command, String connectionString, EventLog.EventLog log) { // Check that the command and connection string are supplied. if (!string.IsNullOrWhiteSpace(command) && !string.IsNullOrWhiteSpace(connectionString)) { SqlConnection connection = new SqlConnection(connectionString); Server server = new Server(new ServerConnection(connection)); try { server.ConnectionContext.ExecuteNonQuery(command); return(true); } catch (ExecutionFailureException e) { // A non-SQL statement was included in the script. LogException(e, log); return(false); } } else { // The script file was not read. return(false); } }
/// <summary> /// Executes the PL/SQL query provided. /// </summary> /// <param name="query">The PL/SQL query text to execute.</param> /// <param name="connectionString">The connection string of the database to execute the script against.</param> /// <param name="log">The event log to log execptions to. May be null for no logging.</param> /// <returns>A list of rows of data returned from the query.</returns> override public List <SqlRow> ExecuteQuery(String query, String connectionString, EventLog.EventLog log) { Exception e = null; return(ExecuteQuery(query, connectionString, log, out e)); }
/// <summary> /// Runs a PowerShell command/script synchronously. /// </summary> /// <param name="commandText">The text of the command to run.</param> /// <param name="runspace">An open PowerShell Runspace this script will use to invoke its pipeline.</param> /// <param name="log">[Optional] The event log to log execptions to. May be null for no logging.</param> /// <param name="input">[Optional] A collection of strings representing command-line input sent to the script during execution.</param> /// <param name="parameterList">An array of key/value objects defining additional parameters to supply to the PowerShell script.</param> /// <returns>A collection of PSObjects that are the result of the script/command run. Null if an error occurred while processing the command / script.</returns> static public Collection <PSObject> RunSynchronously(string commandText, ref Runspace runspace, EventLog.EventLog log = null, PSDataCollection <string> input = null, params KeyValuePair <String, Object>[] parameterList) { try { // Create the script object. PS script = PS.Create(); // Use the runspace supplied or create a new one if not supplied. if (runspace == null) { runspace = RunspaceFactory.CreateRunspace(CreateRunspaceConnectionInfo()); } // Verify that the runspace is open, otherwise open it. if (runspace.RunspaceStateInfo.State != RunspaceState.Opened) { runspace.Open(); } // Add the runspace to the script object. script.Runspace = runspace; // Create the PowerShell command object. Command command = new Command(commandText, true); // Add parameters to the command. if (parameterList != null) { foreach (KeyValuePair <string, object> param in parameterList) { command.Parameters.Add(new CommandParameter(param.Key, param.Value)); } } // Add the command to the script object. script.Commands.AddCommand(command); // Initialize the script input object if nothing was supplied. if (input == null) { input = new PSDataCollection <string>(); } // Invoke the command syncronously. return(script.Invoke(input)); } catch (Exception e) { LogException(e, log); return(null); } }
/// <summary> /// Executes the SQL query in a file given its path, and a connection string to the database. /// </summary> /// <param name="scriptFilePath">The path the the TSQL script file to execute.</param> /// <param name="connectionString">The connection string of the database to execute the script against.</param> /// <param name="log">The event log to log execptions to. May be null for no logging.</param> /// <returns>A list of rows of data returned from the query.</returns> public virtual List <SqlRow> ExecuteQuerySQLFile(String scriptFilePath, String connectionString, EventLog.EventLog log) { string script = File.ReadAllAsText(scriptFilePath); // Check that the script file was read. if (!string.IsNullOrWhiteSpace(script)) { return(ExecuteQuery(script, connectionString, log)); } else { // The script file was not read. return(new List <SqlRow>()); } }
/// <summary> /// Executes the SQL query provided. /// </summary> /// <param name="query">The query text to execute.</param> /// <param name="connectionString">The connection string of the database to execute the script against.</param> /// <param name="log">The event log to log execptions to. May be null for no logging.</param> /// <returns>A list of rows of data returned from the query.</returns> abstract public List <SqlRow> ExecuteQuery(String query, String connectionString, EventLog.EventLog log);
/// <summary> /// Executes the non-query SQL command provided. /// </summary> /// <param name="command">The SQL command text to execute.</param> /// <param name="connectionString">The connection string of the database to execute the script against.</param> /// <param name="log">The event log to log execptions to. May be null for no logging.</param> /// <returns>True if the command ran, false otherwise.</returns> abstract public bool ExecuteNonQuery(String command, String connectionString, EventLog.EventLog log);
/// <summary> /// Executes the TSQL query provided. /// </summary> /// <param name="query">The TSQL query text to execute.</param> /// <param name="connectionString">The connection string of the database to execute the script against.</param> /// <param name="log">The event log to log execptions to. May be null for no logging.</param> /// <returns>A list of rows of data returned from the query.</returns> override public List <SqlRow> ExecuteQuery(String query, String connectionString, EventLog.EventLog log) { // Check that the query and connection string are supplied. if (!string.IsNullOrWhiteSpace(query) && !string.IsNullOrWhiteSpace(connectionString)) { using (SqlConnection connection = new SqlConnection(connectionString)) { Server server = new Server(new ServerConnection(connection)); try { // Execute the query. List <SqlRow> results = new List <SqlRow>(); using (SqlDataReader reader = server.ConnectionContext.ExecuteReader(query)) { while (reader.Read()) { // Add each row's data to the results list. SqlRow row = new SqlRow(); for (int i = 0; i < reader.FieldCount; i++) { row.Add(i, reader.GetName(i), reader.GetValue(i)); } results.Add(row); } } return(results); } catch (ExecutionFailureException e) { // A non-SQL statement was included in the script. LogException(e, log); return(new List <SqlRow>()); } } } else { // The script file was not read. return(new List <SqlRow>()); } }
/// <summary> /// Runs a PowerShell command/script asynchronously. /// </summary> /// <param name="commandText">The text of the command to run.</param> /// <param name="pool">An open PowerShell Runspace pool this script will use to invoke its pipeline.</param> /// <param name="callback">The callback function used to process the results of the asynchronous run.</param> /// <param name="log">[Optional] The event log to log execptions to. May be null for no logging.</param> /// <param name="input">[Optional] A collection of strings representing command-line input sent to the script during execution.</param> /// <param name="stateValues">[Optional] A collection of named state values that should be passed through the invocation to the callback function.</param> /// <param name="parameterList">An array of key/value objects defining additional parameters to supply to the PowerShell script.</param> /// <returns>An WaitHandle object that can be used to determine when the scrip has completed execution. Null if an error occurred while processing the command / script.</returns> static public WaitHandle RunAsynchronously(string commandText, ref RunspacePool pool, ProcessResults callback, EventLog.EventLog log = null, PSDataCollection <string> input = null, Dictionary <String, Object> stateValues = null, params KeyValuePair <String, Object>[] parameterList) { try { // Create the script object. PS script = PS.Create(); // Use the runspace pool supplied or create a new one if not supplied. if (pool == null) { pool = RunspaceFactory.CreateRunspacePool(DEFAULT_MIN_RUNSPACES_IN_POOL, DEFAULT_MAX_RUNSPACES_IN_POOL, CreateRunspaceConnectionInfo()); } // Verify that the pool is open, otherwise open it. if (pool.RunspacePoolStateInfo.State != RunspacePoolState.Opened) { pool.Open(); } // Add the runspace pool to the script object. script.RunspacePool = pool; // Create the PowerShell command object. Command command = new Command(commandText, true); // Add parameters to the command. if (parameterList != null) { foreach (KeyValuePair <string, object> param in parameterList) { command.Parameters.Add(new CommandParameter(param.Key, param.Value)); } } // Add the command to the script object. script.Commands.AddCommand(command); // Initialize the script input object if nothing was supplied. if (input == null) { input = new PSDataCollection <string>(); } // Initialize the state object to maintain data across the invocation. PowerShellScriptState state = new PowerShellScriptState(script); // Add the callback function used to process the results of the script invocation. state.StateVariables.Add(PROCESS_RESULTS_CALLBACK, callback); // Add any state values passed into the method. if (stateValues != null) { foreach (string key in stateValues.Keys) { state.StateVariables.Add(key, stateValues[key]); } } // Invoke the command asyncronously. return((script.BeginInvoke(input, new PSInvocationSettings(), ProcessAsynchronousResults, state)).AsyncWaitHandle); } catch (Exception e) { LogException(e, log); return(null); } }
/// <summary> /// Executes the non-query PL/SQL command provided. /// </summary> /// <param name="command">The PL/SQL command text to execute.</param> /// <param name="connectionString">The connection string of the database to execute the script against.</param> /// <param name="log">The event log to log execptions to. May be null for no logging.</param> /// <returns>True if the command ran, false otherwise.</returns> override public bool ExecuteNonQuery(String command, String connectionString, EventLog.EventLog log) { // Check that the command and connection string are supplied. if (!string.IsNullOrWhiteSpace(command) && !string.IsNullOrWhiteSpace(connectionString)) { // Get the connection to the database. using (OracleConnection connection = new OracleConnection(connectionString)) { try { // Open the connection to the server. connection.Open(); // Create a command that contains the text of the script. using (OracleCommand oracleCommand = new OracleCommand()) { oracleCommand.Connection = connection; oracleCommand.CommandText = command; oracleCommand.CommandType = CommandType.Text; // Execute the command. oracleCommand.ExecuteNonQuery(); return(true); } } catch (OracleException e) { // There was an error executing the script. LogException(e, log); return(false); } catch (Exception e) { // There was an error executing the script. LogException(e, log); return(false); } } } else { // The script file was not read. return(false); } }
/// <summary> /// Executes the PL/SQL query provided. /// </summary> /// <param name="query">The PL/SQL query text to execute.</param> /// <param name="connectionString">The connection string of the database to execute the script against.</param> /// <param name="log">The event log to log execptions to. May be null for no logging.</param> /// <param name="exception">Outputs an exception if there was one during the processing of the query. Null otherwise.</param> /// <returns>A list of rows of data returned from the query.</returns> public List <SqlRow> ExecuteQuery(String query, String connectionString, EventLog.EventLog log, out Exception exception) { // Check that the query and connection string are supplied. if (!string.IsNullOrWhiteSpace(query) && !string.IsNullOrWhiteSpace(connectionString)) { // Get the connection to the database. using (OracleConnection connection = new OracleConnection(connectionString)) { try { // Open the connection to the server. connection.Open(); // Create a command that contains the text of the script. using (OracleCommand queryCommand = new OracleCommand()) { queryCommand.Connection = connection; queryCommand.CommandText = query; queryCommand.CommandType = CommandType.Text; // Execute the query. List <SqlRow> results = new List <SqlRow>(); using (OracleDataReader reader = queryCommand.ExecuteReader()) { if (reader.HasRows) { // Add each row's data to the results list. while (reader.Read()) { SqlRow row = new SqlRow(); for (int columnNum = 0; columnNum < reader.FieldCount; columnNum++) { row.Add(columnNum, reader.GetName(columnNum), reader.GetValue(columnNum)); } results.Add(row); } } } exception = null; return(results); } } catch (OracleException e) { // There was an error executing the script. LogException(e, log); exception = e; return(new List <SqlRow>()); } catch (Exception e) { // There was an error executing the script. LogException(e, log); exception = e; return(new List <SqlRow>()); } } } else { // The script file was not read. exception = null; return(new List <SqlRow>()); } }
/// <summary> /// Runs a PowerShell command/script synchronously. /// </summary> /// <param name="commandText">The text of the command to run.</param> /// <param name="runspace">An open PowerShell Runspace this script will use to invoke its pipeline.</param> /// <param name="log">[Optional] The event log to log execptions to. May be null for no logging.</param> /// <param name="input">[Optional] A collection of strings representing command-line input sent to the script during execution.</param> /// <param name="parameterList">An array of key/value objects defining additional parameters to supply to the PowerShell script.</param> /// <returns>A collection of PSObjects that are the result of the script/command run. Null if an error occurred while processing the command / script.</returns> public Collection <PSObject> RunSynchronously(string commandText, ref Runspace runspace, EventLog.EventLog log = null, PSDataCollection <string> input = null, params KeyValuePair <String, Object>[] parameterList) { // Run the script synchronously. return(PowerShell.RunSynchronously(commandText, ref runspace, Log, input, parameterList)); }