/// <summary>
        /// This sample uses the PowerShell class to execute
        /// a script that generates the numbers from 1 to 10 with delays
        /// between each number. It uses the asynchronous capabilities of
        /// the pipeline to manage the execution of the pipeline and
        /// retrieve results as soon as they are available from a
        /// a script.
        /// </summary>
        /// <param name="args">Unused</param>
        /// <remarks>
        /// This sample demonstrates the following:
        /// 1. Creating instances of the PowerShell class.
        /// 2. Using these instances to execute a string as a PowerShell script.
        /// 3. Using the BeginInvoke method and the events on the PowerShell and
        ///    output pipe classes to process script output asynchronously.
        /// 4. Using the PowerShell Stop() method to interrupt an executing pipeline.
        /// </remarks>
        static void Main(string[] args)
        {
            Console.WriteLine("Print the numbers from 1 to 10. Hit any key to halt processing\n");

            PowerShell powershell = PowerShell.Create();

            // Create a pipeline with a script that generates the numbers from 1 to 10. One
            // number is generated every half second.
            powershell.AddScript("1..10 | foreach {$_ ; start-sleep -milli 500}");

            // Add the event handlers.  If we didn't care about hooking the DataAdded
            // event, we would let BeginInvoke create the output stream for us.
            PSDataCollection<PSObject> output = new PSDataCollection<PSObject>();
            output.DataAdded += new EventHandler<DataAddedEventArgs>(Output_DataAdded);
            powershell.InvocationStateChanged += new EventHandler<PSInvocationStateChangedEventArgs>(Powershell_InvocationStateChanged);

            IAsyncResult asyncResult = powershell.BeginInvoke<PSObject, PSObject>(null, output);

            // Wait for things to happen. If the user hits a key before the
            // pipeline has completed, then call the PowerShell Stop() method
            // to halt processing.
            Console.ReadKey();
            if (powershell.InvocationStateInfo.State != PSInvocationState.Completed)
            {
                // Stop the pipeline...
                Console.WriteLine("\nStopping the pipeline!\n");
                powershell.Stop();

                // Wait for the PowerShell state change messages to be displayed...
                System.Threading.Thread.Sleep(500);
                Console.WriteLine("\nPress a key to exit");
                Console.ReadKey();
            }
        }

        public PSObject Execute(string script)
        {
            using (Runspace runspace = CreateRunspace())
              {
            runspace.Open();

            using (var powerShell = System.Management.Automation.PowerShell.Create())
            {
              powerShell.Runspace = runspace;

              powerShell.AddScript(script);

              powerShell.Streams.Error.DataAdded += OnError;
              powerShell.Streams.Debug.DataAdded += OnDebug;
              powerShell.Streams.Warning.DataAdded += OnWarning;
              powerShell.Streams.Progress.DataAdded += OnProgress;
              powerShell.Streams.Verbose.DataAdded += OnVerbose;

              var outputCollection = new PSDataCollection<PSObject>();

              outputCollection.DataAdded += OnOutput;

              IAsyncResult invokeResult = powerShell.BeginInvoke<PSObject, PSObject>(null, outputCollection);

              powerShell.EndInvoke(invokeResult);

              if (_errorCount != 0)
              {
            throw new PowerShellScriptExecutionException(powerShell.Streams.Error);
              }

              return outputCollection.LastOrDefault();
            }
              }
        }

		public DirectExecutionActivitiesCommandRuntime(PSDataCollection<PSObject> output, ActivityImplementationContext implementationContext, Type cmdletType)
		{
			if (output != null)
			{
				if (implementationContext != null)
				{
					if (cmdletType != null)
					{
						this._output = output;
						this._implementationContext = implementationContext;
						this._cmdletType = cmdletType;
						return;
					}
					else
					{
						throw new ArgumentNullException("cmdletType");
					}
				}
				else
				{
					throw new ArgumentNullException("implementationContext");
				}
			}
			else
			{
				throw new ArgumentNullException("output");
			}
		}

 internal ServerSteppablePipelineDriver(PowerShell powershell, bool noInput, Guid clientPowerShellId, Guid clientRunspacePoolId, ServerRunspacePoolDriver runspacePoolDriver, ApartmentState apartmentState, HostInfo hostInfo, System.Management.Automation.RemoteStreamOptions streamOptions, bool addToHistory, Runspace rsToUse, ServerSteppablePipelineSubscriber eventSubscriber, PSDataCollection<object> powershellInput)
 {
     this.localPowerShell = powershell;
     this.clientPowerShellId = clientPowerShellId;
     this.clientRunspacePoolId = clientRunspacePoolId;
     this.remoteStreamOptions = streamOptions;
     this.apartmentState = apartmentState;
     this.noInput = noInput;
     this.addToHistory = addToHistory;
     this.eventSubscriber = eventSubscriber;
     this.powershellInput = powershellInput;
     this.input = new PSDataCollection<object>();
     this.inputEnumerator = this.input.GetEnumerator();
     this.input.ReleaseOnEnumeration = true;
     this.dsHandler = runspacePoolDriver.DataStructureHandler.CreatePowerShellDataStructureHandler(clientPowerShellId, clientRunspacePoolId, this.remoteStreamOptions, null);
     this.remoteHost = this.dsHandler.GetHostAssociatedWithPowerShell(hostInfo, runspacePoolDriver.ServerRemoteHost);
     this.dsHandler.InputEndReceived += new EventHandler(this.HandleInputEndReceived);
     this.dsHandler.InputReceived += new EventHandler<RemoteDataEventArgs<object>>(this.HandleInputReceived);
     this.dsHandler.StopPowerShellReceived += new EventHandler(this.HandleStopReceived);
     this.dsHandler.HostResponseReceived += new EventHandler<RemoteDataEventArgs<RemoteHostResponse>>(this.HandleHostResponseReceived);
     this.dsHandler.OnSessionConnected += new EventHandler(this.HandleSessionConnected);
     if (rsToUse == null)
     {
         throw PSTraceSource.NewInvalidOperationException("RemotingErrorIdStrings", "NestedPipelineMissingRunspace", new object[0]);
     }
     this.localPowerShell.Runspace = rsToUse;
     eventSubscriber.SubscribeEvents(this);
     this.stateOfSteppablePipeline = PSInvocationState.NotStarted;
 }

 public ContainerParentJob(string command, string name, JobIdentifier jobId, string jobType) : base(command, name, jobId)
 {
     this._moreData = true;
     this._tracer = PowerShellTraceSourceFactory.GetTraceSource();
     this._executionError = new PSDataCollection<ErrorRecord>();
     base.PSJobTypeName = jobType;
 }

		internal IAsyncResult BeginInvokePowerShell(System.Management.Automation.PowerShell command, PSDataCollection<PSObject> input, PSDataCollection<PSObject> output, PSActivityEnvironment policy, AsyncCallback callback, object state)
		{
			if (command != null)
			{
				ConnectionAsyncResult connectionAsyncResult = new ConnectionAsyncResult(state, callback, command.InstanceId);
				this._structuredTracer.OutOfProcessRunspaceStarted(command.ToString());
				ActivityInvoker activityInvoker = new ActivityInvoker();
				activityInvoker.Input = input;
				activityInvoker.Output = output;
				activityInvoker.Policy = policy;
				activityInvoker.PowerShell = command;
				activityInvoker.AsyncResult = connectionAsyncResult;
				ActivityInvoker activityInvoker1 = activityInvoker;
				connectionAsyncResult.Invoker = activityInvoker1;
				this._requests.Enqueue(activityInvoker1);
				PSOutOfProcessActivityController.PerfCountersMgr.UpdateCounterByValue(PSWorkflowPerformanceCounterSetInfo.CounterSetId, 19, (long)1, true);
				PSOutOfProcessActivityController.PerfCountersMgr.UpdateCounterByValue(PSWorkflowPerformanceCounterSetInfo.CounterSetId, 20, (long)1, true);
				this.CheckAndStartServicingThread();
				return connectionAsyncResult;
			}
			else
			{
				throw new ArgumentNullException("command");
			}
		}

        /// <summary>
        /// Private constructor that does most of the work constructing a remote pipeline object.
        /// </summary>
        /// <param name="runspace">RemoteRunspace object</param>
        /// <param name="addToHistory">AddToHistory</param>
        /// <param name="isNested">IsNested</param>
        private RemotePipeline(RemoteRunspace runspace, bool addToHistory, bool isNested)
            : base(runspace)
        {
            _addToHistory = addToHistory;
            _isNested = isNested;
            _isSteppable = false;
            _runspace = runspace;
            _computerName = ((RemoteRunspace)_runspace).ConnectionInfo.ComputerName;
            _runspaceId = _runspace.InstanceId;

            //Initialize streams
            _inputCollection = new PSDataCollection<object>();
            _inputCollection.ReleaseOnEnumeration = true;

            _inputStream = new PSDataCollectionStream<object>(Guid.Empty, _inputCollection);
            _outputCollection = new PSDataCollection<PSObject>();
            _outputStream = new PSDataCollectionStream<PSObject>(Guid.Empty, _outputCollection);
            _errorCollection = new PSDataCollection<ErrorRecord>();
            _errorStream = new PSDataCollectionStream<ErrorRecord>(Guid.Empty, _errorCollection);

            // Create object stream for method executor objects.
            MethodExecutorStream = new ObjectStream();
            IsMethodExecutorStreamEnabled = false;

            SetCommandCollection(_commands);

            //Create event which will be signalled when pipeline execution
            //is completed/failed/stoped. 
            //Note:Runspace.Close waits for all the running pipeline
            //to finish.  This Event must be created before pipeline is 
            //added to list of running pipelines. This avoids the race condition
            //where Close is called after pipeline is added to list of 
            //running pipeline but before event is created.
            PipelineFinishedEvent = new ManualResetEvent(false);
        }

        public void ExecuteScript(ScriptConfigElement e)
        {
            using (_instance = PowerShell.Create())
            {
                _instance.AddScript(File.ReadAllText(e.PathToScript));

                PSDataCollection<PSObject> outputCollection = new PSDataCollection<PSObject>();
                outputCollection.DataAdded += outputCollection_DataAdded;
                _instance.Streams.Progress.DataAdded += Progress_DataAdded;
                _instance.Streams.Error.DataAdded += Error_DataAdded;
                _instance.Streams.Verbose.DataAdded += Verbose_DataAdded;
                _instance.Streams.Debug.DataAdded += Debug_DataAdded;
                _instance.Streams.Warning.DataAdded += Warning_DataAdded;

                IAsyncResult result = _instance.BeginInvoke<PSObject, PSObject>(null,
                    outputCollection);

                while (result.IsCompleted == false)
                {
                    Thread.Sleep(500);
                }

                foreach (PSObject o in outputCollection)
                {
                    Console.WriteLine(o.GetType());
                    Console.WriteLine(o);
                }
            }
        }

        public static string ExtractErrorFromErrorRecord(this Runspace runspace, ErrorRecord record)
        {
            Pipeline pipeline = runspace.CreatePipeline("$input", false);
            pipeline.Commands.Add("out-string");

            Collection<PSObject> result;
            using (PSDataCollection<object> inputCollection = new PSDataCollection<object>())
            {
                inputCollection.Add(record);
                inputCollection.Complete();
                result = pipeline.Invoke(inputCollection);
            }

            if (result.Count > 0)
            {
                string str = result[0].BaseObject as string;
                if (!string.IsNullOrEmpty(str))
                {
                    // Remove \r\n, which is added by the Out-String cmdlet.
                    return str.Substring(0, str.Length - 2);
                }
            }

            return String.Empty;
        }

 internal PSInformationalBuffers(Guid psInstanceId)
 {
     this.psInstanceId = psInstanceId;
     this.progress = new PSDataCollection<ProgressRecord>();
     this.verbose = new PSDataCollection<VerboseRecord>();
     this.debug = new PSDataCollection<DebugRecord>();
     this.warning = new PSDataCollection<WarningRecord>();
 }

        /// <summary>
        /// Starts the pipeline script async.
        /// </summary>
        public void BeginInvoke(Queue<PSObject> queue, int count)
        {
            var input = new PSDataCollection<PSObject>(count);
            while (--count >= 0)
                input.Add(queue.Dequeue());
            input.Complete();

            _async = _posh.BeginInvoke(input);
        }

 internal ServerPowerShellDriver(PowerShell powershell, PowerShell extraPowerShell, bool noInput, Guid clientPowerShellId, Guid clientRunspacePoolId, ServerRunspacePoolDriver runspacePoolDriver, ApartmentState apartmentState, HostInfo hostInfo, System.Management.Automation.RemoteStreamOptions streamOptions, bool addToHistory, Runspace rsToUse)
 {
     this.clientPowerShellId = clientPowerShellId;
     this.clientRunspacePoolId = clientRunspacePoolId;
     this.remoteStreamOptions = streamOptions;
     this.apartmentState = apartmentState;
     this.localPowerShell = powershell;
     this.extraPowerShell = extraPowerShell;
     this.localPowerShellOutput = new PSDataCollection<PSObject>();
     this.noInput = noInput;
     this.addToHistory = addToHistory;
     this.dsHandler = runspacePoolDriver.DataStructureHandler.CreatePowerShellDataStructureHandler(clientPowerShellId, clientRunspacePoolId, this.remoteStreamOptions, this.localPowerShell);
     this.remoteHost = this.dsHandler.GetHostAssociatedWithPowerShell(hostInfo, runspacePoolDriver.ServerRemoteHost);
     if (!noInput)
     {
         this.input = new PSDataCollection<object>();
         this.input.ReleaseOnEnumeration = true;
         this.input.IdleEvent += new EventHandler<EventArgs>(this.HandleIdleEvent);
     }
     this.RegisterPipelineOutputEventHandlers(this.localPowerShellOutput);
     if (this.localPowerShell != null)
     {
         this.RegisterPowerShellEventHandlers(this.localPowerShell);
         this.datasent[0] = false;
     }
     if (extraPowerShell != null)
     {
         this.RegisterPowerShellEventHandlers(extraPowerShell);
         this.datasent[1] = false;
     }
     this.RegisterDataStructureHandlerEventHandlers(this.dsHandler);
     if (rsToUse != null)
     {
         this.localPowerShell.Runspace = rsToUse;
         if (extraPowerShell != null)
         {
             extraPowerShell.Runspace = rsToUse;
         }
     }
     else
     {
         this.localPowerShell.RunspacePool = runspacePoolDriver.RunspacePool;
         if (extraPowerShell != null)
         {
             extraPowerShell.RunspacePool = runspacePoolDriver.RunspacePool;
         }
     }
 }

        public async Task Update(ChocolateyPackageVersion package)
        {
            using (var powershell = PowerShell.Create())
            {
                var command = string.Format("cup {0}", package.Id);

                powershell.AddScript(command);
                powershell.Streams.Error.DataAdded += ErrorDataAdded;
                powershell.Streams.Warning.DataAdded += WarningDataAdded;

                var outputCollection = new PSDataCollection<PSObject>();
                outputCollection.DataAdded += this.SendOutput;
                
                await Task.Factory.StartNew(() => powershell.Invoke(null, outputCollection, null));
            }
        }

        public async Task Uninstall(ChocolateyPackageVersion package)
        {
            using (var powershell = PowerShell.Create())
            {
                var command = string.Format(
                    "cuninst {0} -version {1}",
                    package.Id,
                    package.Version);

                powershell.AddScript(command);

                var outputCollection = new PSDataCollection<PSObject>();
                outputCollection.DataAdded += this.SendOutput;

                await Task.Factory.StartNew(() => powershell.Invoke(null, outputCollection, null));
            }
        }

        private async Task<PSDataCollection<ErrorRecord>> InvokePowerShellScript(Dictionary<string, string> envVars, TraceWriter traceWriter)
        {
            InitialSessionState iss = InitialSessionState.CreateDefault();
            PSDataCollection<ErrorRecord> errors = new PSDataCollection<ErrorRecord>();

            using (Runspace runspace = RunspaceFactory.CreateRunspace(iss))
            {
                runspace.Open();
                SetRunspaceEnvironmentVariables(runspace, envVars);
                RunspaceInvoke runSpaceInvoker = new RunspaceInvoke(runspace);
                runSpaceInvoker.Invoke("Set-ExecutionPolicy -Scope Process -ExecutionPolicy Unrestricted");

                using (
                    System.Management.Automation.PowerShell powerShellInstance =
                        System.Management.Automation.PowerShell.Create())
                {
                    powerShellInstance.Runspace = runspace;
                    _moduleFiles = GetModuleFilePaths(_host.ScriptConfig.RootScriptPath, _functionName);
                    if (_moduleFiles.Any())
                    {
                        powerShellInstance.AddCommand("Import-Module").AddArgument(_moduleFiles);
                        LogLoadedModules();
                    }

                    _script = GetScript(_scriptFilePath);
                    powerShellInstance.AddScript(_script, true);

                    PSDataCollection<PSObject> outputCollection = new PSDataCollection<PSObject>();
                    outputCollection.DataAdded += (sender, e) => OutputCollectionDataAdded(sender, e, traceWriter);

                    powerShellInstance.Streams.Error.DataAdded += (sender, e) => ErrorDataAdded(sender, e, traceWriter);

                    IAsyncResult result = powerShellInstance.BeginInvoke<PSObject, PSObject>(null, outputCollection);
                    await Task.Factory.FromAsync<PSDataCollection<PSObject>>(result, powerShellInstance.EndInvoke);

                    foreach (ErrorRecord errorRecord in powerShellInstance.Streams.Error)
                    {
                        errors.Add(errorRecord);
                    }
                }

                runspace.Close();
            }

            return errors;
        }

        public async Task Install(ChocolateyPackageVersion package, string arguments, CancellationToken cancellationToken)
        {
            var args = string.IsNullOrEmpty(arguments) ? string.Empty : " -installArguments " + arguments;

            using (var powershell = PowerShell.Create())
            {
                var command = string.Format(
                    "cinst {0} -version {1}{2}",
                    package.Id,
                    package.Version,
                    args);

                powershell.AddScript(command);

                var outputCollection = new PSDataCollection<PSObject>();
                outputCollection.DataAdded += this.SendOutput;

                await Task.Factory.StartNew(() => powershell.Invoke(null, outputCollection, null), cancellationToken);
            }
        }

        private async Task RunScript()
        {
            if (!File.Exists(Name))
            {
                return;
            }
            if (Type.Equals("Powershell"))
            {
                using (var powerShellInstance = PowerShell.Create())
                {
                    var scriptContents = File.ReadAllText(Name);
                    powerShellInstance.AddScript(scriptContents);
                    // prepare a new collection to store output stream objects
                    var outputCollection = new PSDataCollection<PSObject>();
                    outputCollection.DataAdded += outputCollection_DataAdded;
                    powerShellInstance.Streams.Error.DataAdded += Error_DataAdded;
                    // begin invoke execution on the pipeline
                    // use this overload to specify an output stream buffer
                    var result = powerShellInstance.BeginInvoke<PSObject, PSObject>(null, outputCollection);
                    while (result.IsCompleted == false)
                    {
                        Thread.Sleep(1000);
                    }
                    await
                        Console.Out.WriteLineAsync("Execution has stopped. The pipeline state: " +
                                                   powerShellInstance.InvocationStateInfo.State);
                }
            }
            else if (Type.Equals("cmd"))
            {
                try
                {
                    await RunProcessAsync(Name);
                }
                catch (Exception ex)
                {

                    Console.WriteLine(ex.Message);
                }
            }
        }

        public static void ExecuteCommand(String command, PSHost host)
        {
            Console.WriteLine("Executing command:");

            string outputLine = command;
            int ichNewline = command.IndexOfAny("\r\n".ToCharArray());
            if (ichNewline > 0)
                outputLine = command.Substring(0, ichNewline);

            Console.WriteLine(outputLine);

            using (Runspace space = RunspaceFactory.CreateRunspace(host))
            {
                space.Open();
                using (PowerShell ps = PowerShell.Create())
                {
                    ps.Runspace = space;
                    ps.AddScript(command);

                    // Create the output buffer for the results.
                    PSDataCollection<PSObject> output = new PSDataCollection<PSObject>();
                    IAsyncResult async = ps.BeginInvoke();
                    foreach (PSObject result in ps.EndInvoke(async))
                    {
                        Console.WriteLine(result.ToString());
                    }

                    PSDataStreams streams = ps.Streams;

                    if (streams.Error != null)
                    {
                        foreach (ErrorRecord record in streams.Error)
                        {
                            Console.WriteLine(GetMessageFromErrorRecord(record));
                            throw record.Exception;
                        }
                    }
                }
            }
        }

        public string CopyNodeJSExe()
        {
            string azureCouchDBInstallFolder;

            azureCouchDBInstallFolder = General.Instance.GetAzureCouchDBInstallFolder();

            try
            {
                if (Directory.Exists(AzureNodeJSSdkBinPath) == false)
                {
                    throw new Exception("Node js not installed.");
                }

                string destination = Path.Combine(azureCouchDBInstallFolder, @"WorkerRole\Node\bin");
                if (Directory.Exists(destination) == false)
                {
                    Directory.CreateDirectory(destination);
                }

                string nodeExeLocation = Path.Combine(AzureNodeJSSdkBinPath, "node.exe");

                using (PowerShell ps = PowerShell.Create())
                {
                    ps.AddScript(String.Format("COPY-ITEM \"{0}\" \"{1}\" ", nodeExeLocation, destination));
                    PSDataCollection<PSObject> output = new PSDataCollection<PSObject>();
                    IAsyncResult async = ps.BeginInvoke();
                    foreach (PSObject result in ps.EndInvoke(async))
                    {
                        Console.WriteLine(result.ToString());
                    }
                }
            }
            catch
            {
                return "Error copying Node executable.";
            }
            return "Node Executable copied Successfully.";
        }

        /// <summary>
        /// To display an exception using the display formatter, 
        /// run a second pipeline passing in the error record.
        /// The runtime will bind this to the $input variable,
        /// which is why $input is being piped to the Out-String
        /// cmdlet. The WriteErrorLine method is called to make sure 
        /// the error gets displayed in the correct error color.
        /// </summary>
        /// <param name="e">The exception to display.</param>
        private void ReportException(Exception e)
        {
            if (e != null)
            {
                object error;
                IContainsErrorRecord icer = e as IContainsErrorRecord;
                if (icer != null)
                {
                    error = icer.ErrorRecord;
                }
                else
                {
                    error = (object)new ErrorRecord(e, "Host.ReportException", ErrorCategory.NotSpecified, null);
                }

                lock (this.instanceLock)
                {
                    this.currentPowerShell = PowerShell.Create();
                }

                this.currentPowerShell.Runspace = this.myRunSpace;

                try
                {
                    this.currentPowerShell.AddScript("$input").AddCommand("out-string");

                    // Do not merge errors, this function will swallow errors.
                    Collection<PSObject> result;
                    PSDataCollection<object> inputCollection = new PSDataCollection<object>();
                    inputCollection.Add(error);
                    inputCollection.Complete();
                    result = this.currentPowerShell.Invoke(inputCollection);

                    if (result.Count > 0)
                    {
                        string str = result[0].BaseObject as string;
                        if (!string.IsNullOrEmpty(str))
                        {
                            // Remove \r\n, which is added by the Out-String cmdlet.
                            this.myHost.UI.WriteErrorLine(str.Substring(0, str.Length - 2));
                        }
                    }
                }
                finally
                {
                    // Dispose of the pipeline and set it to null, locking it  because
                    // currentPowerShell may be accessed by the ctrl-C handler.
                    lock (this.instanceLock)
                    {
                        this.currentPowerShell.Dispose();
                        this.currentPowerShell = null;
                    }
                }
            }
        }