Esempio n. 1
0
        private async Task RunCommandAndRedirectOutputAsync(Renci.SshNet.SshCommand cmd, Func <string, Task> writeOutput, RedirectOutputOptions redirectOutputOption)
        {
            await Task.Run(() =>
            {
                var asynch = cmd.BeginExecute();

                var taskList = new List <Task>();

                if (redirectOutputOption.HasFlag(RedirectOutputOptions.RedirectStandardOutput))
                {
                    var stream = cmd.OutputStream;
                    taskList.Add(RedirectStreamAsync(writeOutput, asynch, stream));
                }

                if (redirectOutputOption.HasFlag(RedirectOutputOptions.RedirectErrorOutput))
                {
                    var stream = cmd.ExtendedOutputStream;
                    taskList.Add(RedirectStreamAsync(writeOutput, asynch, stream));
                }

                Task.WaitAny(taskList.ToArray());

                cmd.EndExecute(asynch);
            });
        }
Esempio n. 2
0
        public static void RunScript(string scriptText, string directory, Action <string> writeLineOutput, RedirectOutputOptions redirectOutputOption)
        {
            using (Runspace runspace = RunspaceFactory.CreateRunspace())
            {
                runspace.Open();
                if (!string.IsNullOrWhiteSpace(directory))
                {
                    runspace.SessionStateProxy.Path.SetLocation(directory);
                }

                using (Pipeline pipeline = runspace.CreatePipeline())
                {
                    pipeline.Commands.AddScript(scriptText);

                    pipeline.InvokeAsync();

                    var handles = new WaitHandle[2];
                    handles[0] = pipeline.Output.WaitHandle;
                    handles[1] = pipeline.Error.WaitHandle;
                    pipeline.Input.Close();

                    while (pipeline.PipelineStateInfo.State == PipelineState.Running)
                    {
                        switch (WaitHandle.WaitAny(handles))
                        {
                        case 0:
                            while (pipeline.Output.Count > 0)
                            {
                                foreach (PSObject result in pipeline.Output.NonBlockingRead())
                                {
                                    if (redirectOutputOption.HasFlag(RedirectOutputOptions.RedirectStandardOutput))
                                    {
                                        writeLineOutput(result.ToString());
                                    }
                                }
                            }
                            break;

                        case 1:
                            while (pipeline.Error.Count > 0)
                            {
                                foreach (PSObject result in pipeline.Error.NonBlockingRead())
                                {
                                    if (redirectOutputOption.HasFlag(RedirectOutputOptions.RedirectErrorOutput))
                                    {
                                        writeLineOutput(result.ToString());
                                    }
                                }
                            }
                            break;

                        default:

                            break;
                        }
                    }

                    runspace.Close();
                }
            }
        }