/// <summary>
        /// Starts a powershell script using the specified information.
        /// </summary>
        /// <param name="script">The powershell script to run.</param>
        /// <param name="settings">The information about the script to start.</param>
        /// <returns>Powershell objects.</returns>
        public Collection <PSObject> Start(string script, PowershellSettings settings)
        {
            if (String.IsNullOrEmpty(script))
            {
                throw new ArgumentNullException("script");
            }
            if (settings == null)
            {
                throw new ArgumentNullException("settings");
            }



            //Get Script
            this.SetWorkingDirectory(settings);

            _Log.Debug(Verbosity.Normal, String.Format("Executing: {0}", this.AppendArguments(script, settings.Arguments, true)));



            //Call
            script = this.AppendArguments(script, settings.Arguments, false);

            return(this.Invoke(script, settings));
        }
        /// <summary>
        /// Starts a powershell script using the specified information.
        /// </summary>
        /// <param name="path">The path of the script file to run.</param>
        /// <param name="settings">The information about the script to start.</param>
        /// <returns>Powershell objects.</returns>
        public Collection <PSObject> Start(FilePath path, PowershellSettings settings)
        {
            if (path == null)
            {
                throw new ArgumentNullException("path");
            }
            if (settings == null)
            {
                throw new ArgumentNullException("settings");
            }



            //Get Script
            this.SetWorkingDirectory(settings);
            string script = "&\"" + path.MakeAbsolute(settings.WorkingDirectory).FullPath + "\"";

            _Log.Debug(Verbosity.Normal, String.Format("Executing: {0}", this.AppendArguments(script, settings.Arguments, true)));



            //Call
            script = this.AppendArguments(script, settings.Arguments, false);

            return(this.Invoke(script, settings));
        }
        /// <summary>
        /// Starts a powershell script using the specified information.
        /// </summary>
        /// <param name="uri">The location of the script file to download and run.</param>
        /// <param name="path">The temporary path to download the file to.</param>
        /// <param name="settings">The information about the process to start.</param>
        /// <returns>Powershell objects.</returns>
        public Collection <PSObject> Start(Uri uri, FilePath path, PowershellSettings settings)
        {
            if (uri == null)
            {
                throw new ArgumentNullException("uri");
            }
            if (settings == null)
            {
                throw new ArgumentNullException("settings");
            }



            //Get Script
            this.SetWorkingDirectory(settings);

            string fullPath = path.MakeAbsolute(settings.WorkingDirectory).FullPath;
            string script   = "&\"" + path.MakeAbsolute(settings.WorkingDirectory).FullPath + "\"";



            //Download Script
            WebClient client = new WebClient();

            client.DownloadFile(uri, fullPath);

            _Log.Debug(Verbosity.Normal, String.Format("Executing: {0}", this.AppendArguments(script, settings.Arguments, true)));



            //Call
            script = this.AppendArguments(script, settings.Arguments, false);

            return(this.Invoke(script, settings));
        }
        /// <summary>
        /// Sets a value indicating whether security should be set to unrestricted.
        /// </summary>
        /// <param name="settings">The powershell settings.</param>
        /// <returns>The same <see cref="PowershellSettings"/> instance so that multiple calls can be chained.</returns>
        public static PowershellSettings BypassExecutionPolicy(this PowershellSettings settings)
        {
            if (settings == null)
            {
                throw new ArgumentNullException(nameof(settings));
            }

            settings.BypassExecutionPolicy = true;
            return(settings);
        }
        /// <summary>
        /// Sets a value indicating whether the output of an application is written to its on-screen console.
        /// </summary>
        /// <param name="settings">The powershell settings.</param>
        /// <param name="outputToAppConsole">true if output should be written to the app's on-screen console; otherwsie, false. The default is true.</param>
        /// <returns>The same <see cref="PowershellSettings"/> instance so that multiple calls can be chained.</returns>
        public static PowershellSettings OutputToAppConsole(this PowershellSettings settings, bool outputToAppConsole = true)
        {
            if (settings == null)
            {
                throw new ArgumentNullException("settings");
            }

            settings.OutputToAppConsole = outputToAppConsole;
            return(settings);
        }
        /// <summary>
        /// Sets the authentication mechanism to use when connecting
        /// </summary>
        /// <param name="settings">The powershell settings.</param>
        /// <param name="authenticationMechanism">The authentication mechanism to connect with.</param>
        /// <returns>The same <see cref="PowershellSettings"/> instance so that multiple calls can be chained.</returns>
        public static PowershellSettings UseAuthenticationMechanism(this PowershellSettings settings, AuthenticationMechanism authenticationMechanism)
        {
            if (settings == null)
            {
                throw new ArgumentNullException("settings");
            }

            settings.AuthenticationMechanism = authenticationMechanism;
            return(settings);
        }
        /// <summary>
        /// Executes scripts using dot sourcing
        /// </summary>
        /// <param name="settings">The powershell settings.</param>
        /// <returns>The same <see cref="PowershellSettings"/> instance so that multiple calls can be chained.</returns>
        public static PowershellSettings WithDotSourcing(this PowershellSettings settings)
        {
            if (settings == null)
            {
                throw new ArgumentNullException("settings");
            }

            settings.UseDotSourcing = true;
            return(settings);
        }
        /// <summary>
        /// Sets the optional timeout for powershell command
        /// </summary>
        /// <param name="settings">The powershell settings.</param>
        /// <param name="timeout">The timeout duration</param>
        /// <returns>The same <see cref="PowershellSettings"/> instance so that multiple calls can be chained.</returns>
        public static PowershellSettings SetTimeout(this PowershellSettings settings, int timeout)
        {
            if (settings == null)
            {
                throw new ArgumentNullException("settings");
            }

            settings.Timeout = timeout;
            return(settings);
        }
        /// <summary>
        /// Sets a value indicating whether the output of an application is written to the cake console
        /// </summary>
        /// <param name="settings">The powershell settings.</param>
        /// <param name="log">true if output should be written to the cake console; otherwise, false. The default is false.</param>
        /// <returns>The same <see cref="PowershellSettings"/> instance so that multiple calls can be chained.</returns>
        public static PowershellSettings SetLogOutput(this PowershellSettings settings, bool log = true)
        {
            if (settings == null)
            {
                throw new ArgumentNullException("settings");
            }

            settings.LogOutput = log;
            return(settings);
        }
        /// <summary>
        /// Sets the working directory for the process to be started.
        /// </summary>
        /// <param name="settings">The powershell settings.</param>
        /// <param name="path">The working directory where the powershell command is to be started.</param>
        /// <returns>The same <see cref="PowershellSettings"/> instance so that multiple calls can be chained.</returns>
        public static PowershellSettings UseWorkingDirectory(this PowershellSettings settings, DirectoryPath path)
        {
            if (settings == null)
            {
                throw new ArgumentNullException("settings");
            }

            settings.WorkingDirectory = path;
            return(settings);
        }
        /// <summary>
        /// Sets a value indicating whether the output of an application should be formatted as text
        /// </summary>
        /// <param name="settings">The powershell settings.</param>
        /// <param name="format">true if output should be written to the cake console; otherwise, false. The default is false.</param>
        /// <returns>The same <see cref="PowershellSettings"/> instance so that multiple calls can be chained.</returns>
        public static PowershellSettings SetFormatOutput(this PowershellSettings settings, bool format = true)
        {
            if (settings == null)
            {
                throw new ArgumentNullException("settings");
            }

            settings.FormatOutput = format;
            return(settings);
        }
        /// <summary>
        /// Sets the remote port to connect on.
        /// </summary>
        /// <param name="settings">The powershell settings.</param>
        /// <param name="port">The remote port to connext on.</param>
        /// <returns>The same <see cref="PowershellSettings"/> instance so that multiple calls can be chained.</returns>
        public static PowershellSettings UsePort(this PowershellSettings settings, int port)
        {
            if (settings == null)
            {
                throw new ArgumentNullException("settings");
            }

            settings.Port = port;
            return(settings);
        }
示例#13
0
        //Helpers
        private void SetWorkingDirectory(PowershellSettings settings)
        {
            if (String.IsNullOrEmpty(settings.ComputerName))
            {
                DirectoryPath workingDirectory = settings.WorkingDirectory ?? _Environment.WorkingDirectory;

                settings.WorkingDirectory = workingDirectory.MakeAbsolute(_Environment);
            }
            else if (settings.WorkingDirectory == null)
            {
                settings.WorkingDirectory = new DirectoryPath("C:/");
            }
        }
        /// <summary>
        /// Gets or sets the credentials to use when connecting
        /// </summary>
        /// <param name="settings">The powershell settings.</param>
        /// <param name="password">The password to connect with.</param>
        /// <returns>The same <see cref="PowershellSettings"/> instance so that multiple calls can be chained.</returns>
        public static PowershellSettings UsePassword(this PowershellSettings settings, string password)
        {
            if (settings == null)
            {
                throw new ArgumentNullException("settings");
            }
            if (String.IsNullOrEmpty(password))
            {
                throw new ArgumentNullException("password");
            }

            settings.Password = password;
            return(settings);
        }
        /// <summary>
        /// Gets or sets the credentials to use when connecting
        /// </summary>
        /// <param name="settings">The powershell settings.</param>
        /// <param name="username">The username to connect with.</param>
        /// <returns>The same <see cref="PowershellSettings"/> instance so that multiple calls can be chained.</returns>
        public static PowershellSettings UseUsername(this PowershellSettings settings, string username)
        {
            if (settings == null)
            {
                throw new ArgumentNullException("settings");
            }
            if (String.IsNullOrEmpty(username))
            {
                throw new ArgumentNullException("username");
            }

            settings.Username = username;
            return(settings);
        }
        /// <summary>
        /// Sets the computer name to connect to
        /// </summary>
        /// <param name="settings">The powershell settings.</param>
        /// <param name="name">The computer name</param>
        /// <returns>The same <see cref="PowershellSettings"/> instance so that multiple calls can be chained.</returns>
        public static PowershellSettings UseComputerName(this PowershellSettings settings, string name)
        {
            if (settings == null)
            {
                throw new ArgumentNullException("settings");
            }
            if (String.IsNullOrEmpty(name))
            {
                throw new ArgumentNullException("name");
            }

            settings.ComputerName = name;
            return(settings);
        }
        /// <summary>
        /// Adds the specified module to load into the initial state
        /// </summary>
        /// <param name="settings">The powershell settings.</param>
        /// <param name="module">The module to load.</param>
        /// <returns>The same <see cref="PowershellSettings"/> instance so that multiple calls can be chained.</returns>
        public static PowershellSettings WithModule(this PowershellSettings settings, string module)
        {
            if (settings == null)
            {
                throw new ArgumentNullException("settings");
            }
            if (String.IsNullOrEmpty(module))
            {
                throw new ArgumentNullException("module");
            }

            if (settings.Modules == null)
            {
                settings.Modules = new List <string>();
            }

            settings.Modules.Add(module);
            return(settings);
        }
        /// <summary>
        /// Sets the arguments for the powershell command
        /// </summary>
        /// <param name="settings">The powershell settings.</param>
        /// <param name="arguments">The arguments to append.</param>
        /// <returns>The same <see cref="PowershellSettings"/> instance so that multiple calls can be chained.</returns>
        public static PowershellSettings WithArguments(this PowershellSettings settings, Action <ProcessArgumentBuilder> arguments)
        {
            if (settings == null)
            {
                throw new ArgumentNullException("settings");
            }
            if (arguments == null)
            {
                throw new ArgumentNullException("arguments");
            }

            if (settings.Arguments == null)
            {
                settings.Arguments = new ProcessArgumentBuilder();
            }

            arguments(settings.Arguments);
            return(settings);
        }
        /// <summary>
        /// Starts a powershell script using the specified information.
        /// </summary>
        /// <param name="uri">The location of the script file to download and run.</param>
        /// <param name="path">The temporary path to download the file to.</param>
        /// <param name="settings">The information about the process to start.</param>
        /// <returns>Powershell objects.</returns>
        public Collection <PSObject> Start(Uri uri, FilePath path, PowershellSettings settings)
        {
            if (uri == null)
            {
                throw new ArgumentNullException("uri");
            }
            if (settings == null)
            {
                throw new ArgumentNullException("settings");
            }



            //Get Script
            this.SetWorkingDirectory(settings);

            string prefix   = settings.UseDotSourcing ? ". " : "&";
            string fullPath = path.MakeAbsolute(settings.WorkingDirectory).FullPath;
            string script   = prefix + "\"" + fullPath + "\"";



            //Download Script
            WebClient client = new WebClient();

            client.DownloadFile(uri, fullPath);

            LogExecutingCommand(settings, script);



            //Call
            script = this.AppendArguments(script, settings.Arguments, false);

            return(this.Invoke(script, settings));
        }
示例#20
0
        private Collection <PSObject> Invoke(string script, PowershellSettings settings)
        {
            //Create Runspace
            Runspace runspace = null;

            if (String.IsNullOrEmpty(settings.ComputerName))
            {
                //Local
                runspace = RunspaceFactory.CreateRunspace(new CakePSHost(_Log, settings.OutputToAppConsole));
            }
            else
            {
                //Remote
                WSManConnectionInfo connection = new WSManConnectionInfo();

                connection.ComputerName = settings.ComputerName;

                if (settings.Port > 0)
                {
                    connection.Port = settings.Port;
                }
                else
                {
                    connection.Port = 5985;
                }

                if (!String.IsNullOrEmpty(settings.Username))
                {
                    connection.Credential = new PSCredential(settings.Username, settings.Password.MakeSecure());
                }

                if (settings.Timeout.HasValue)
                {
                    connection.OperationTimeout = settings.Timeout.Value;
                    connection.OpenTimeout      = settings.Timeout.Value;
                }

                runspace = RunspaceFactory.CreateRunspace(new CakePSHost(_Log, settings.OutputToAppConsole), connection);
            }

            runspace.Open();



            //Create Pipline
            Collection <PSObject> results = null;

            using (Pipeline pipeline = runspace.CreatePipeline())
            {
                //Invoke Command
                if (settings.WorkingDirectory != null)
                {
                    var path = string.Format(CultureInfo.InvariantCulture, "\"{0}\"", settings.WorkingDirectory.FullPath);
                    pipeline.Commands.AddScript("Set-Location -Path " + path);
                }

                if ((settings.Modules != null) && (settings.Modules.Count > 0))
                {
                    settings.Modules.ToList().ForEach(m => pipeline.Commands.AddScript("Import-Module " + m));
                }

                pipeline.Commands.AddScript(script);

                if (settings.FormatOutput)
                {
                    pipeline.Commands.Add("Out-String");
                }

                results = pipeline.Invoke();



                //Log Errors
                if (pipeline.Error.Count > 0)
                {
                    while (!pipeline.Error.EndOfPipeline)
                    {
                        PSObject value = (PSObject)pipeline.Error.Read();

                        if (value != null)
                        {
                            ErrorRecord record = (ErrorRecord)value.BaseObject;

                            if (record != null)
                            {
                                _Log.Error(Verbosity.Normal, record.Exception.Message);
                            }
                        }
                    }
                }
            }

            runspace.Close();
            runspace.Dispose();



            //Log Results
            if (settings.LogOutput)
            {
                foreach (PSObject res in results)
                {
                    _Log.Debug(Verbosity.Normal, res.ToString());
                }
            }

            return(results);
        }
 public static Collection <PSObject> StartPowershellFile(this ICakeContext context, FilePath path, PowershellSettings settings)
 {
     return(new PowershellRunner(context.Environment, context.Log).Start(path, settings));
 }
 public static Collection <PSObject> StartPowershellScript(this ICakeContext context, string script, PowershellSettings settings)
 {
     return(new PowershellRunner(context).Start(script, settings));
 }
        private Collection <PSObject> Invoke(string script, PowershellSettings settings)
        {
            //Linux Support
            if (_Environment.Platform.Family != PlatformFamily.Windows)
            {
                var tool = new PwshScriptRunner(_Context.FileSystem, _Context.Environment, _Context.ProcessRunner, _Context.Tools);
                tool.RunScript(script, settings);

                return(new Collection <PSObject>());
            }



            //Create Runspace
            Runspace runspace = null;

            if (String.IsNullOrEmpty(settings.ComputerName))
            {
                //Local
                runspace = RunspaceFactory.CreateRunspace(new CakePSHost(_Log, settings.OutputToAppConsole));
            }
            else
            {
                //Remote
                WSManConnectionInfo connection = new WSManConnectionInfo();

                connection.ComputerName = settings.ComputerName;

                if (settings.Port > 0)
                {
                    connection.Port = settings.Port;
                }
                else
                {
                    connection.Port = 5985;
                }

                if (!String.IsNullOrEmpty(settings.Username))
                {
                    connection.Credential = new PSCredential(settings.Username, settings.Password.MakeSecure());
                    connection.AuthenticationMechanism = settings.AuthenticationMechanism;
                }

                if (settings.Timeout.HasValue)
                {
                    connection.OperationTimeout = settings.Timeout.Value;
                    connection.OpenTimeout      = settings.Timeout.Value;
                }

                runspace = RunspaceFactory.CreateRunspace(new CakePSHost(_Log, settings.OutputToAppConsole), connection);
            }

            runspace.Open();



            //Create Pipline
            using (Pipeline pipeline = runspace.CreatePipeline())
                using (var powershellInstance = PowerShell.Create())
                {
                    if (settings.BypassExecutionPolicy)
                    {
                        powershellInstance.Runspace = runspace;
                        powershellInstance.AddScript("Set-ExecutionPolicy Unrestricted");
                        powershellInstance.Invoke();
                    }

                    //Invoke Command
                    if (settings.WorkingDirectory != null)
                    {
                        var path = string.Format(CultureInfo.InvariantCulture, "\"{0}\"",
                                                 settings.WorkingDirectory.FullPath);

                        pipeline.Commands.AddScript("Set-Location -Path " + path);
                    }

                    if ((settings.Modules != null) && (settings.Modules.Count > 0))
                    {
                        settings.Modules.ToList().ForEach(m => pipeline.Commands.AddScript("Import-Module " + m));
                    }

                    pipeline.Commands.AddScript(script);

                    if (settings.FormatOutput)
                    {
                        pipeline.Commands.Add("Out-Default");
                    }

                    //Bind Events
                    pipeline.Output.DataReady += Output_DataReady;
                    pipeline.Error.DataReady  += Error_DataReady;
                    pipeline.StateChanged     += Pipeline_StateChanged;

                    pipeline.InvokeAsync();

                    //Wait
                    while (!_complete)
                    {
                        Thread.Sleep(500);
                    }

                    //Handle Exceptions
                    var exceptions = _pipelineResults
                                     .Select(result => result.BaseObject)
                                     .OfType <Exception>().ToArray();

                    var errors = _pipelineResults
                                 .Select(b => b.BaseObject)
                                 .OfType <ErrorRecord>()
                                 .Select(er => er.Exception ?? new Exception(er.ErrorDetails.Message)).ToArray();

                    if (exceptions.Any() || (settings.ExceptionOnScriptError && errors.Any()))
                    {
                        var exceptionString = string.Join(" - ", exceptions.Select(e => e.ToString()));
                        exceptionString += string.Join(" - ", errors.Select(e => e.ToString()));
                        throw new AggregateException($"Failed to Execute Powershell Script: {exceptionString}", exceptions);
                    }
                }

            runspace.Close();
            runspace.Dispose();

            return(_pipelineResults);
        }
示例#24
0
 private void LogExecutingCommand(PowershellSettings settings, string script, bool safe = true)
 {
     _Log.Debug(Verbosity.Normal, String.Format("Executing: {0}", this.AppendArguments(script, settings.Arguments, safe).EscapeCurleyBrackets()));
 }
示例#25
0
        private Collection<PSObject> Invoke(string script, PowershellSettings settings)
        {
            //Create Runspace
            Runspace runspace = null;

            if (String.IsNullOrEmpty(settings.ComputerName))
            {
                //Local
                runspace = RunspaceFactory.CreateRunspace(new CakePSHost(_Log, settings.OutputToAppConsole));
            }
            else
            {
                //Remote
                WSManConnectionInfo connection = new WSManConnectionInfo();

                connection.ComputerName = settings.ComputerName;

                if (settings.Port > 0)
                {
                    connection.Port = settings.Port;
                }
                else
                {
                    connection.Port = 5985;
                }

                if (!String.IsNullOrEmpty(settings.Username))
                {
                    connection.Credential = new PSCredential(settings.Username, settings.Password.MakeSecure());
                }

                if (settings.Timeout.HasValue)
                {
                    connection.OperationTimeout = settings.Timeout.Value;
                    connection.OpenTimeout = settings.Timeout.Value;
                }

                runspace = RunspaceFactory.CreateRunspace(new CakePSHost(_Log, settings.OutputToAppConsole), connection);
            }

            runspace.Open();



            //Create Pipline
            using (Pipeline pipeline = runspace.CreatePipeline())
            {
                //Invoke Command
                if (settings.WorkingDirectory != null)
                {
                    var path = string.Format(CultureInfo.InvariantCulture, "\"{0}\"",
                        settings.WorkingDirectory.FullPath);
                    pipeline.Commands.AddScript("Set-Location -Path " + path);
                }

                if ((settings.Modules != null) && (settings.Modules.Count > 0))
                {
                    settings.Modules.ToList().ForEach(m => pipeline.Commands.AddScript("Import-Module " + m));
                }

                pipeline.Commands.AddScript(script);

                if (settings.FormatOutput)
                {
                    pipeline.Commands.Add("Out-Default");
                }

                //Bind Events
                pipeline.Output.DataReady += Output_DataReady;
                pipeline.Error.DataReady += Error_DataReady;
                pipeline.StateChanged += Pipeline_StateChanged;

                pipeline.InvokeAsync();

                //Wait
                while (!_complete)
                {
                    Thread.Sleep(500);
                }

                //Handle Exceptions
                var exceptions = _pipelineResults.Where(result => result.BaseObject is Exception)
                    .Select(e => e.BaseObject as Exception).ToArray();

                if (exceptions.Length > 0)
                {
                    var exceptionString = string.Join(" - ", exceptions.Select(e => e.ToString()));
                    throw new AggregateException($"Failed to Execute Powershell Script: {exceptionString}", exceptions);
                }
            }

            runspace.Close();
            runspace.Dispose();

            return _pipelineResults;
        }
示例#26
0
 private void LogExecutingCommand(PowershellSettings settings, string script, bool safe = true)
 {
     _Log.Debug(Verbosity.Normal,
                String.Format("Executing: {0}",
                              this.AppendArguments(script, settings.Arguments, safe).Replace("{", "{{").Replace("}", "}}")));
 }