Beispiel #1
0
        /// <summary>
        /// Executes the SQL statements in a file given its path, and a connection string to the database.
        /// </summary>
        /// <param name="scriptFilePath">The path the the SQL 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>True if the script ran, false otherwise.</returns>
        public virtual bool ExecuteNonQuerySQLFile(String scriptFilePath, String connectionString, EventLog.EventLog log)
        {
            string script = File.ReadAllAsText(scriptFilePath);

            // Check that the script file was read.
            if (!string.IsNullOrWhiteSpace(script))
            {
                return ExecuteNonQuery(script, connectionString, log);
            }
            else
            {
                // The script file was not read.
                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;
                }
            }
        }
Beispiel #3
0
        // ---------- 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>
 /// 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>
        /// 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;
            }
        }
        /// <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 encrypted connection 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);
            }
            else
            {
                // Could not retrieve the encrypted value.
                return null;
            }
        }
        /// <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();
                }
            }
        }
Beispiel #8
0
 // ---------- 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>
 private static 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;
     }
 }
Beispiel #9
0
        /// <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>();
            }
        }
Beispiel #10
0
        /// <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>
        public static 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;
            }
        }
Beispiel #11
0
 /// <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>
 public abstract List<SqlRow> ExecuteQuery(String query, String connectionString, EventLog.EventLog log);
Beispiel #12
0
 /// <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>
 public abstract bool ExecuteNonQuery(String command, String connectionString, EventLog.EventLog log);
Beispiel #13
0
 // ---------- CONSTRUCTORS ----------
 // ---------- 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>
 protected virtual bool LogException(Exception e, EventLog.EventLog log)
 {
     if (log != null)
     {
         log.Log(new Event(typeof(SqlUtility).FullName, DateTime.Now, Event.SeverityLevels.Error, e.GetType().FullName,
             "Description:\n" +
            e.Message + "\n" +
            "Stack Trace:\n" +
            e.StackTrace));
         return true;
     }
     else
     {
         return false;
     }
 }
Beispiel #14
0
        /// <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;
            }
        }
Beispiel #15
0
 /// <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>
 public override List<SqlRow> ExecuteQuery(String query, String connectionString, EventLog.EventLog log)
 {
     Exception e = null;
     return ExecuteQuery(query, connectionString, log, out e);
 }
Beispiel #16
0
 /// <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);
 }
Beispiel #17
0
        /// <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 static 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;
            }
        }
Beispiel #18
0
        /// <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>
        public override 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;
            }
        }