Exemplo n.º 1
0
        public void Init()
        {
            _ps = Utilities.CreatePowerShell(CmdletName, typeof(GetRelease));

            var octoRepo = Utilities.AddOctopusRepo(_ps.Runspace.SessionStateProxy.PSVariable);

            // Create a project
            var project = new ProjectResource { Name = "Octopus" };
            octoRepo.Setup(o => o.Projects.FindByName("Octopus")).Returns(project);
            octoRepo.Setup(o => o.Projects.Get("projects-1")).Returns(project);
            octoRepo.Setup(o => o.Projects.Get("Gibberish")).Throws(new OctopusResourceNotFoundException("Not Found"));

            var releases = new List<ReleaseResource>
            {
                new ReleaseResource {Version = "1.0.0"},
                new ReleaseResource {Version = "1.0.1"},
                new ReleaseResource {Version = "1.1.0"}
            };

            octoRepo.Setup(o => o.Projects.GetReleases(project, 0))
                .Returns(new ResourceCollection<ReleaseResource>(releases, new LinkCollection()));

            octoRepo.Setup(o => o.Projects.GetReleaseByVersion(project, "1.0.0")).Returns(releases[0]);
            octoRepo.Setup(o => o.Projects.GetReleaseByVersion(project, "Gibberish")).Throws(new OctopusResourceNotFoundException("Not found"));

            octoRepo.Setup(o => o.Releases.Get("releases-1")).Returns(releases[0]);
            octoRepo.Setup(o => o.Releases.Get("Gibberish")).Throws(new OctopusResourceNotFoundException("Not found"));
        }
Exemplo n.º 2
0
        public void Init()
        {
            _ps = Utilities.CreatePowerShell(CmdletName, typeof(AddVariable));
            var octoRepo = Utilities.AddOctopusRepo(_ps.Runspace.SessionStateProxy.PSVariable);

            _variableSet.Variables.Clear();

            var project = new ProjectResource {DeploymentProcessId = "deploymentprocesses-1"};
            project.Links.Add("Variables", "variablesets-1");
            octoRepo.Setup(o => o.Projects.FindByName("Octopus")).Returns(project);
            octoRepo.Setup(o => o.Projects.FindByName("Gibberish")).Returns((ProjectResource) null);

            octoRepo.Setup(o => o.VariableSets.Get("variablesets-1")).Returns(_variableSet);

            var process = new DeploymentProcessResource();
            process.Steps.Add(new DeploymentStepResource {Name = "Website", Id = "Step-1"});
            octoRepo.Setup(o => o.DeploymentProcesses.Get("deploymentprocesses-1")).Returns(process);

            var envs = new List<EnvironmentResource>
            {
                new EnvironmentResource {Id = "Environments-1", Name = "DEV"}
            };

            octoRepo.Setup(o => o.Environments.FindByNames(new[] {"DEV"})).Returns(envs);
            var machines = new List<MachineResource>
            {
                new MachineResource {Id = "Machines-1", Name = "web-01"}
            };
            octoRepo.Setup(o => o.Machines.FindByNames(new[] { "web-01" })).Returns(machines);
        }
        public void Init()
        {
            _ps = Utilities.CreatePowerShell(CmdletName, typeof(AddLibraryVariable));
            var octoRepo = Utilities.AddOctopusRepo(_ps.Runspace.SessionStateProxy.PSVariable);

            _variableSet.Variables.Clear();

            var lib = new LibraryVariableSetResource { Name = "Octopus" };
            var libs = new List<LibraryVariableSetResource> {lib};
            lib.Links.Add("Variables", "variablesets-1");
            octoRepo.Setup(o => o.LibraryVariableSets.FindOne(It.IsAny<Func<LibraryVariableSetResource, bool>>()))
                .Returns(
                    (Func<LibraryVariableSetResource, bool> f) =>
                        (from l in libs where f(l) select l).FirstOrDefault());

            octoRepo.Setup(o => o.Projects.FindByName("Gibberish")).Returns((ProjectResource)null);

            octoRepo.Setup(o => o.VariableSets.Get("variablesets-1")).Returns(_variableSet);

            var process = new DeploymentProcessResource();
            process.Steps.Add(new DeploymentStepResource { Name = "Website", Id = "Step-1" });
            octoRepo.Setup(o => o.DeploymentProcesses.Get("deploymentprocesses-1")).Returns(process);

            var envs = new List<EnvironmentResource>
            {
                new EnvironmentResource {Id = "Environments-1", Name = "DEV"}
            };

            octoRepo.Setup(o => o.Environments.FindByNames(new[] { "DEV" })).Returns(envs);
            var machines = new List<MachineResource>
            {
                new MachineResource {Id = "Machines-1", Name = "web-01"}
            };
            octoRepo.Setup(o => o.Machines.FindByNames(new[] { "web-01" })).Returns(machines);
        }
Exemplo n.º 4
0
        public void Init()
        {
            _ps = Utilities.CreatePowerShell(CmdletName, typeof (RemoveVariableSet));

            var octoRepo = Utilities.AddOctopusRepo(_ps.Runspace.SessionStateProxy.PSVariable);

            // Create some library variable sets
            _sets.Clear();
            _sets.Add(new LibraryVariableSetResource {Id = "LibraryVariableSets-1", Name = "ConnectionStrings"});
            _sets.Add(_set);
            _sets.Add(new LibraryVariableSetResource {Id = "LibraryVariableSets-3", Name = "Service Endpoints"});

            octoRepo.Setup(o => o.LibraryVariableSets.Delete(It.IsAny<LibraryVariableSetResource>())).Returns(
                delegate(LibraryVariableSetResource set)
                {
                    if (_sets.Contains(set))
                        _sets.Remove(set);
                    else
                        throw new KeyNotFoundException("The given key was not present in the dictionary.");
                    return new TaskResource();
                }
                );

            octoRepo.Setup(o => o.LibraryVariableSets.Get("LibraryVariableSets-2")).Returns(_set);
            octoRepo.Setup(o => o.LibraryVariableSets.Get(It.IsNotIn(new[] {"LibraryVariableSets-2"})))
                .Throws(new OctopusResourceNotFoundException("Not Found"));

            // Allow the FindOne predicate to operate on the collection
            octoRepo.Setup(o => o.LibraryVariableSets.FindOne(It.IsAny<Func<LibraryVariableSetResource, bool>>()))
                .Returns(
                    (Func<LibraryVariableSetResource, bool> f) =>
                        (from l in _sets where f(l) select l).FirstOrDefault());
        }
Exemplo n.º 5
0
        public void Init()
        {
            _ps = Utilities.CreatePowerShell(CmdletName, typeof(GetVariableSet));

            var octoRepo = Utilities.AddOctopusRepo(_ps.Runspace.SessionStateProxy.PSVariable);

            // Create a library variable set
            const string vsId = "/api/variables/variableset-LibraryVariableSets-1";
            var libraryResources = new List<LibraryVariableSetResource>
            {
                new LibraryVariableSetResource {Id = "LibraryVariableSets-1", Name = "Octopus"},
                new LibraryVariableSetResource {Id = "LibraryVariableSets-2", Name = "Deploy"},
                new LibraryVariableSetResource {Id = "LibraryVariableSets-3", Name = "Automation"}
            };

            octoRepo.Setup(o => o.LibraryVariableSets.FindAll()).Returns(libraryResources);

            // Create a variableset
            var variableRepo = new Mock<IVariableSetRepository>();
            var vsResource = new VariableSetResource
            {
                Variables = new List<VariableResource>
                {
                    new VariableResource {Name = "Octopus"},
                    new VariableResource {Name = "Deploy"},
                    new VariableResource {Name = "Automation"},
                }
            };
            variableRepo.Setup(v => v.Get(vsId)).Returns(vsResource);

            octoRepo.Setup(o => o.VariableSets).Returns(variableRepo.Object);
        }
        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);
                }
            }
        }
 /// <summary>
 /// Called to start the COM handler.
 /// </summary>
 /// <param name="data">Data string passed in from Task Scheduler action.</param>
 public override void Start(string data)
 {
     psInstance = PowerShell.Create();
     psInstance.AddScript(data);
     result = psInstance.BeginInvoke();
     psInstance.InvocationStateChanged += PowerShellInstance_InvocationStateChanged;
 }
        protected void PrintPSCommand(PowerShell powershell)
        {

            StringBuilder command = new StringBuilder();
            DateTime currentTime = DateTime.UtcNow;
            command.Append("[" + currentTime.ToShortDateString() + " " + currentTime.ToLongTimeString() + "] ");

            for (int i = 0; i < powershell.Commands.Commands.Count; i++)
            {

                command.Append(powershell.Commands.Commands[i].CommandText + " ");

                for (int j = 0; j < powershell.Commands.Commands[i].Parameters.Count; j++)
                {
                    command.Append("-" + powershell.Commands.Commands[i].Parameters[j].Name + " ");
                    var value = powershell.Commands.Commands[i].Parameters[j].Value;
                    if (value != null)
                    {
                        command.Append("\"" + value.ToString() + "\" ");
                    }
                    command.Append("\n");
                }
            }

            Console.WriteLine(command);

        }
Exemplo n.º 9
0
        public void Init()
        {
            _ps = Utilities.CreatePowerShell(CmdletName, typeof(AddProject));
            var octoRepo = Utilities.AddOctopusRepo(_ps.Runspace.SessionStateProxy.PSVariable);

            // Create a project group
            var groupResource = new ProjectGroupResource {Name = "Octopus", Id = "projectgroups-1"};
            octoRepo.Setup(o => o.ProjectGroups.FindByName("Octopus")).Returns(groupResource);

            octoRepo.Setup(o => o.ProjectGroups.Get(It.IsIn(new[] { "projectgroups-1" })))
                .Returns(groupResource);

            octoRepo.Setup(o => o.ProjectGroups.Get(It.IsNotIn(new[] { "projectgroups-1" })))
                .Throws(new OctopusResourceNotFoundException("Not Found"));

            _projects.Clear();

            var repo = new Mock<IProjectRepository>();
            repo.Setup(e => e.Create(It.IsAny<ProjectResource>()))
                .Returns(delegate(ProjectResource p)
                {
                    _projects.Add(p);
                    return p;
                });

            octoRepo.Setup(o => o.Projects).Returns(repo.Object);
        }
Exemplo n.º 10
0
        public void Init()
        {
            _ps = Utilities.CreatePowerShell(CmdletName, typeof (GetStep));
            var octoRepo = Utilities.AddOctopusRepo(_ps.Runspace.SessionStateProxy.PSVariable);

            const string deploymentProcessId = "deploymentprocess-projects-1";

            // Create a project
            var projectResources = new List<ProjectResource>
            {
                new ProjectResource {Name = "Octopus", DeploymentProcessId = deploymentProcessId, Id = "projects-1"}
            };

            octoRepo.Setup(o => o.Projects.FindByNames(new[] {"Octopus"})).Returns(projectResources);
            octoRepo.Setup(o => o.Projects.FindByNames(new[] {"Gibberish"})).Returns(new List<ProjectResource>());
            octoRepo.Setup(o => o.Projects.Get("projects-1")).Returns(projectResources[0]);
            octoRepo.Setup(o => o.Projects.Get("Gibberish")).Throws(new OctopusResourceNotFoundException("Not Found"));

            var process = new DeploymentProcessResource();
            //{
            //    Id = "deploymentprocess-projects-1"
            //};
            process.Steps.Add(new DeploymentStepResource { Name = "Test Step" });
            process.Steps.Add(new DeploymentStepResource { Name = "Test Step 2" });

            octoRepo.Setup(o => o.DeploymentProcesses.Get(It.IsIn(new[] {deploymentProcessId})))
                .Returns(process);

            octoRepo.Setup(o => o.DeploymentProcesses.Get(It.IsNotIn(new[] {deploymentProcessId})))
                .Throws(new OctopusResourceNotFoundException("Not Found"));
        }
Exemplo n.º 11
0
 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;
 }
Exemplo n.º 12
0
        public void Init()
        {
            _ps = Utilities.CreatePowerShell(CmdletName, typeof(RemoveProjectGroup));

            var octoRepo = Utilities.AddOctopusRepo(_ps.Runspace.SessionStateProxy.PSVariable);

            // Create some library variable sets
            _groups.Clear();
            _groups.Add(new ProjectGroupResource { Id = "ProjectGroups-1", Name = "Octopus" });
            _groups.Add(_group);
            _groups.Add(new ProjectGroupResource { Id = "ProjectGroups-3", Name = "Automation" });

            octoRepo.Setup(o => o.ProjectGroups.Delete(It.IsAny<ProjectGroupResource>())).Returns(
                delegate(ProjectGroupResource set)
                {
                    if (_groups.Contains(set))
                        _groups.Remove(set);
                    else
                        throw new KeyNotFoundException("The given key was not present in the dictionary.");
                    return new TaskResource();
                }
                );

            octoRepo.Setup(o => o.ProjectGroups.Get("ProjectGroups-2")).Returns(_group);
            octoRepo.Setup(o => o.ProjectGroups.Get(It.IsNotIn(new[] { "ProjectGroups-2" })))
                .Throws(new OctopusResourceNotFoundException("Not Found"));

            octoRepo.Setup(o => o.ProjectGroups.FindByName("Test")).Returns(_group);
            octoRepo.Setup(o => o.ProjectGroups.FindByName("Gibberish")).Returns((ProjectGroupResource)null);
        }
Exemplo n.º 13
0
        public void Init()
        {
            _ps = Utilities.CreatePowerShell(CmdletName, typeof(GetDeployment));

            var octoRepo = Utilities.AddOctopusRepo(_ps.Runspace.SessionStateProxy.PSVariable);

            // Create a project
            var projectResource = new ProjectResource {Name = "Octopus"};
            octoRepo.Setup(o => o.Projects.FindByName("Octopus")).Returns(projectResource);
            octoRepo.Setup(o => o.Projects.FindByName("Gibberish")).Returns((ProjectResource) null);

            // Create a Release
            var release = new ReleaseResource { Id = "Releases-1", Links = new LinkCollection()};

            release.Links.Add("Deployments", "/api/releases/releases-1/deployments");
            octoRepo.Setup(o => o.Projects.GetReleaseByVersion(projectResource, "1.0.0")).Returns(release);
            octoRepo.Setup(o => o.Projects.GetReleaseByVersion(projectResource, "Gibberish")).Returns((ReleaseResource) null);

            // Create Deployments
            var deployments = new ResourceCollection<DeploymentResource>(new List<DeploymentResource>
            {
                new DeploymentResource {Id = "deployments-1"}
            }, new LinkCollection());
            octoRepo.Setup(o => o.Releases.GetDeployments(release, 0)).Returns(deployments);
            octoRepo.Setup(o => o.Releases.Get("Releases-1")).Returns(release);
        }
Exemplo n.º 14
0
        public void Init()
        {
            _ps = Utilities.CreatePowerShell(CmdletName, typeof (GetProjectGroup));

            var octoRepo = Utilities.AddOctopusRepo(_ps.Runspace.SessionStateProxy.PSVariable);

            // Create some project groups
            var groupRepo = new Mock<IProjectGroupRepository>();
            var groupResources = new List<ProjectGroupResource>
            {
                new ProjectGroupResource {Name = "Octopus", Id = "projectgroups-1"},
                new ProjectGroupResource {Name = "Deploy", Id = "projectgroups-2"}
            };

            groupRepo.Setup(p => p.FindAll()).Returns(groupResources);
            groupRepo.Setup(p => p.FindByNames(It.IsAny<string[]>())).Returns(
                (string[] names) =>
                    (from n in names
                        from g in groupResources
                        where g.Name.Equals(n, StringComparison.InvariantCultureIgnoreCase)
                        select g).ToList());

            groupRepo.Setup(p => p.Get(It.IsAny<string>())).Returns(CreateGet(groupResources));

            octoRepo.Setup(o => o.ProjectGroups).Returns(groupRepo.Object);
        }
Exemplo n.º 15
0
 internal CompletionExecutionHelper(PowerShell powershell)
 {
     if (powershell == null)
     {
         throw PSTraceSource.NewArgumentNullException("powershell");
     }
     this.CurrentPowerShell = powershell;
 }
Exemplo n.º 16
0
        private IRSPDriverInvoke _psDriverInvoker;  // Handles nested invocation of PS drivers.

        #endregion Private Members

        #region Constructors

#if !CORECLR
        /// <summary>
        /// Default constructor for creating ServerPowerShellDrivers
        /// </summary>
        /// <param name="powershell">decoded powershell object</param>
        /// <param name="extraPowerShell">extra pipeline to be run after <paramref name="powershell"/> completes</param>
        /// <param name="noInput">whether there is input for this powershell</param>
        /// <param name="clientPowerShellId">the client powershell id</param>
        /// <param name="clientRunspacePoolId">the client runspacepool id</param>
        /// <param name="runspacePoolDriver">runspace pool driver 
        /// which is creating this powershell driver</param>
        /// <param name="apartmentState">apartment state for this powershell</param>
        /// <param name="hostInfo">host info using which the host for
        /// this powershell will be constructed</param>
        /// <param name="streamOptions">serialization options for the streams in this powershell</param>
        /// <param name="addToHistory">
        /// true if the command is to be added to history list of the runspace. false, otherwise.
        /// </param>
        /// <param name="rsToUse">
        /// If not null, this Runspace will be used to invoke Powershell.
        /// If null, the RunspacePool pointed by <paramref name="runspacePoolDriver"/> will be used.
        /// </param>
        internal ServerPowerShellDriver(PowerShell powershell, PowerShell extraPowerShell, bool noInput, Guid clientPowerShellId,
            Guid clientRunspacePoolId, ServerRunspacePoolDriver runspacePoolDriver,
            ApartmentState apartmentState, HostInfo hostInfo, RemoteStreamOptions streamOptions,
            bool addToHistory, Runspace rsToUse)
            : this(powershell, extraPowerShell, noInput, clientPowerShellId, clientRunspacePoolId, runspacePoolDriver,
                   apartmentState, hostInfo, streamOptions, addToHistory, rsToUse, null)
        {
        }
Exemplo n.º 17
0
 public AsyncJob(ScriptBlock Script)
     : base(Script.ToString())
 {
     this.Pipeline = PSRunspace.Instance.NewPipeline();
     this.Pipeline.AddCommand(Script.ToString());
     this.Pipeline.InvocationStateChanged += Pipeline_InvocationStateChanged;
     this.PSJobTypeName = "RunspaceJob";
     this.Name = string.Format("Async{0}", this.Id);
 }
Exemplo n.º 18
0
 public void SetupPowerShellEnvironment(PowerShell powerShell, string credentials)
 {
     powerShell.RemoveCredentials();
     string credentialFile = Path.Combine(this.downloadDirectoryPath, credentials);
     Assert.IsTrue(File.Exists(credentialFile), string.Format("Did not download file {0}", credentialFile));
     powerShell.ImportCredentials(credentialFile);
     foreach (string key in this.environment.Keys) powerShell.AddEnvironmentVariable(key, environment[key]);
     foreach (string key in this.PowerShellVariables.Keys) powerShell.SetVariable(key, PowerShellVariables[key]);
 }
Exemplo n.º 19
0
 /// <summary>
 /// Creates the $credential object in the given <paramref name="powershell"/> instance with
 /// user name "testuser" and password "testpass".
 /// </summary>
 /// <param name="powershell">An instance of the <see cref="PowerShell"/> object.</param>
 public static void CreateTestCredential(PowerShell powershell)
 {
     // Create the test credential
     powershell.InvokeBatchScript(
     @"$user = ""testuser""",
     @"$pass = ""testp@ss1"" | ConvertTo-SecureString -asPlainText -Force",
     @"$credential = New-Object System.Management.Automation.PSCredential($user, $pass)");
     Assert.IsTrue(powershell.Streams.Error.Count == 0);
 }
 public MsPowerShellHost(string[] modules)
 {
     InitialSessionState initial = InitialSessionState.CreateDefault();
     initial.ImportPSModule(modules);
     _space = RunspaceFactory.CreateRunspace(initial);
     _space.Open();
     _ps = PowerShell.Create();
     _ps.Runspace = _space;
     Init();
 }
Exemplo n.º 21
0
        /// <summary>
        /// This is the primary method for executing powershell scripts
        /// </summary>
        /// <param name="script"></param>
        /// <param name="args"></param>(optional)
        /// <returns>ICollection<PSObject></returns>
        public ICollection<PSObject> executeScript(string script, IDictionary<string, object> args = null)
        {
            try
            {
                // create runspace if it is null
                if (_runspace == null)
                {
                    _runspace = createRunspace();
                }

                // The PowerShell class implements a Factory Pattern, offering a Create() method that returns a new PowerShell object
                _ps = PowerShell.Create();

                // assign the runspace to the Powershell object
                _ps.Runspace = _runspace;

                // create a Command object, initializing it with the script path
                Command psCommand = new Command(script);

                // if the args Dictionary is not null, add them to the Command.Parameters collection
                if (args != null)
                {
                    foreach (var arg in args)
                    {
                        psCommand.Parameters.Add(arg.Key, arg.Value);
                    }
                }

                // add the psCommands object to the Commands property of our PowerShell object
                _ps.Commands.Commands.Add(psCommand);

                // Invoke PowerShell asynchronously
                var asyncResult = _ps.BeginInvoke();

                // Could perform other tasks here while waiting for script to complete, if needed

                // this is analogous to the "await" keyword in an async method
                asyncResult.AsyncWaitHandle.WaitOne();

                // get the result from PowerShell execution
                var result = _ps.EndInvoke(asyncResult);

                // release the resources used by the WaitHandle
                asyncResult.AsyncWaitHandle.Close();

                // return the collection of PSObjects
                return result;
            }
            catch (Exception ex)
            {
                Debug.WriteLine(ex);
                return null;
            }
        }
        // empty constructor?
        private PowerShellInstance()
        {
            // set output to blank string
            output = "";

            // instansiate powershell instance
            powerShell = PowerShell.Create();

            // instantiate our stringbuilder
            stringBuilder = new StringBuilder();
        }
Exemplo n.º 23
0
        public ExchPowershell()
        {
            string uri = string.Format("https://{0}/powershell", ServiceSettings.ExchangeServer);
            this._connection = GetConnection(uri, ServiceSettings.Username, ServiceSettings.Password, ServiceSettings.ExchangeConnection == "Kerberos" ? true : false);

            _runspace = RunspaceFactory.CreateRunspace(_connection);
            _runspace.Open();

            _powershell = PowerShell.Create();
            _powershell.Runspace = _runspace;
        }
Exemplo n.º 24
0
        public void Init()
        {
            _executor = new PesterTestExecutor();

            _runContext = new Mock<IRunContext>();

            _runspace = RunspaceFactory.CreateRunspace(new TestAdapterHost());
            _runspace.Open();
            _powerShell = PowerShell.Create();
            _powerShell.Runspace = _runspace;
        }
 public PowershellAdminModuleFixture()
 {
     _powerShell = PowerShell.Create();
     _powerShell.AddCommand("Import-Module").AddParameter("Name", typeof(CreateScope).Assembly.Location);
     _database = Guid.NewGuid().ToString("N");
     var client = new MongoClient("mongodb://localhost");
     _server = client.GetServer();
     var settings = StoreSettings.DefaultSettings();
     settings.Database = _database;
     _factory = new Factory(new ServiceFactory(null, settings), new AdminServiceRegistry());            
 }
Exemplo n.º 26
0
        public void SetupTest()
        {
            powershell = PowerShell.Create();

            MockHttpServer.SetupCertificates();

            UnitTestHelper.SetupUnitTestSubscription(powershell);

            serverName = SqlDatabaseTestSettings.Instance.ServerName;
            powershell.Runspace.SessionStateProxy.SetVariable("serverName", serverName);
        }
Exemplo n.º 27
0
        /// <summary>
        /// Constructor which creates a client remote powershell 
        /// </summary>
        /// <param name="shell">powershell instance </param>
        /// <param name="runspacePool">The runspace pool associated with
        /// this shell</param>
        internal ClientRemotePowerShell(PowerShell shell, RemoteRunspacePoolInternal runspacePool)
        {
            this.shell = shell;
            clientRunspacePoolId = runspacePool.InstanceId;
            this.runspacePool = runspacePool;

            // retrieve the computer name from the runspacepool
            // information so that it can be used in adding
            // warning to host messages
            computerName = runspacePool.ConnectionInfo.ComputerName;
        }
 internal ServerPowerShellDataStructureHandler(Guid instanceId, Guid runspacePoolId, RemoteStreamOptions remoteStreamOptions, AbstractServerTransportManager transportManager, PowerShell localPowerShell)
 {
     this.clientPowerShellId = instanceId;
     this.clientRunspacePoolId = runspacePoolId;
     this.transportManager = transportManager;
     this.streamSerializationOptions = remoteStreamOptions;
     transportManager.Closing += new EventHandler(this.HandleTransportClosing);
     if (localPowerShell != null)
     {
         localPowerShell.RunspaceAssigned += new EventHandler<PSEventArgs<Runspace>>(this.LocalPowerShell_RunspaceAssigned);
     }
 }
Exemplo n.º 29
0
        public void Init()
        {
            _ps = Utilities.CreatePowerShell(CmdletName, typeof(UpdateVariable));
            var octoRepo = Utilities.AddOctopusRepo(_ps.Runspace.SessionStateProxy.PSVariable);

            var variable = new VariableResource
            {
                Id = "variables-1",
                Name = "Test",
                Value = "Test Value",
                IsSensitive = false
            };
            variable.Scope.Add(ScopeField.Action, "actions-1");
            variable.Scope.Add(ScopeField.Environment, "environments-1");
            variable.Scope.Add(ScopeField.Role, "DB");

            _variableSet.Variables.Add(variable);

            var project = new ProjectResource { DeploymentProcessId = "deploymentprocesses-1" };
            project.Links.Add("Variables", "variablesets-1");
            octoRepo.Setup(o => o.Projects.FindByName("Octopus")).Returns(project);
            octoRepo.Setup(o => o.Projects.FindByName("Gibberish")).Returns((ProjectResource)null);

            octoRepo.Setup(o => o.VariableSets.Get("variablesets-1")).Returns(_variableSet);

            var process = new DeploymentProcessResource();
            process.Steps.Add(new DeploymentStepResource { Name = "Website", Id = "Step-1" });
            octoRepo.Setup(o => o.DeploymentProcesses.Get("deploymentprocesses-1")).Returns(process);

            var envs = new List<EnvironmentResource>
            {
                new EnvironmentResource {Id = "environments-1", Name = "DEV"},
                new EnvironmentResource {Id = "environments-2", Name = "TEST"}
            };

            octoRepo.Setup(o => o.Environments.FindByNames(It.IsAny<string[]>()))
                .Returns((string[] names) => (from n in names
                    from e in envs
                    where e.Name.Equals(n, StringComparison.InvariantCultureIgnoreCase)
                    select e).ToList());

            var machines = new List<MachineResource>
            {
                new MachineResource {Id = "machines-1", Name = "db-01"},
                new MachineResource {Id = "machines-2", Name = "web-01"}
            };
            octoRepo.Setup(o => o.Machines.FindByNames(It.IsAny<string[]>())).Returns(
                (string[] names) => (from n in names
                                     from m in machines
                                     where m.Name.Equals(n, StringComparison.InvariantCultureIgnoreCase)
                                     select m).ToList());
        }
Exemplo n.º 30
0
        public virtual void TestSetup()
        {
            powershell = PowerShell.Create();

            foreach (string moduleName in modules)
            {
                powershell.AddScript(string.Format("Import-Module \"{0}\"", Testing.GetTestResourcePath(moduleName)));
            }

            powershell.AddScript("$VerbosePreference='Continue'");
            powershell.AddScript("$DebugPreference='Continue'");
            powershell.AddScript("$ErrorActionPreference='Stop'");
        }
Exemplo n.º 31
0
 protected void SetWorkingDirectory(PowerShell powerShell, string folder)
 {
     powerShell.Runspace.SessionStateProxy.Path.SetLocation(folder);
 }
Exemplo n.º 32
0
        /// <summary>
        /// 원격파일 복사
        /// </summary>
        private void ExPs_CopyShape(string path, string destination)
        {
            // Username and Password for the remote machine.
            var    userName = User;
            string pw       = PW;

            // Creates a secure string for the password
            SecureString securePassword = new SecureString();

            foreach (char c in pw)
            {
                securePassword.AppendChar(c);
            }
            securePassword.MakeReadOnly();

            // Creates a PSCredential object
            PSCredential creds = new PSCredential(userName, securePassword);



            // Creates the runspace for PowerShell
            Runspace runspace = RunspaceFactory.CreateRunspace();

            // Create the PSSession connection to the remote machine.
            //ComputerName
            string computerName = IP;

            PowerShell powershell = PowerShell.Create();
            PSCommand  command    = new PSCommand();

            command.AddCommand("New-PSSession");
            command.AddParameter("ComputerName", computerName);
            command.AddParameter("Credential", creds);
            powershell.Commands = command;
            runspace.Open();
            powershell.Runspace = runspace;
            Collection <PSObject> result = powershell.Invoke();



            // Takes the PSSession object and places it into a PowerShell variable
            powershell = PowerShell.Create();
            command    = new PSCommand();
            command.AddCommand("Set-Variable");
            command.AddParameter("Name", "session");
            command.AddParameter("Value", result[0]);
            powershell.Commands = command;
            powershell.Runspace = runspace;
            powershell.Invoke();



            // Calls the Copy-Item cmdlet as a script and passes the PSSession, Path and destination parameters to it
            powershell = PowerShell.Create();
            command    = new PSCommand();
            command.AddScript("Copy-Item -Path " + path + " -Destination " + destination + " -ToSession $session");
            powershell.Commands = command;
            powershell.Runspace = runspace;
            powershell.Invoke();

            // 세션종료
            powershell          = PowerShell.Create();
            powershell.Runspace = runspace;
            powershell.AddScript("Remove-PSSession $session");
            powershell.Invoke();
        }
        /// <summary>
        /// Wraps command execution into system process call.
        /// </summary>
        /// <returns></returns>
        /// <exception cref="Exception"></exception>
        public RepeatStatus Execute(StepContribution contribution, ChunkContext chunkContext)
        {
            if (Logger.IsTraceEnabled)
            {
                Logger.Trace("*** Executing PowerShell Script File: {0}", ScriptResource.GetFullPath());
            }

            //=> PowerShell will throw an error if we do not Suppress ambient transaction...
            //   see https://msdn.microsoft.com/en-us/library/system.transactions.transaction.current(v=vs.110).aspx#NotExistJustToMakeTheAElementVisible
            using (var transactionScope = new TransactionScope(TransactionScopeOption.Suppress))
            {
                /*               //=> Runspace configuration information includes the assemblies, commands, format and type files,
                 *             //   providers, and scripts that are available within the runspace.
                 *             RunspaceConfiguration runspaceConfiguration = RunspaceConfiguration.Create();*/

                //Creates a single runspace that uses the default host and runspace configuration
                using (Runspace runSpace = RunspaceFactory.CreateRunspace())
                {
                    //=> When this runspace is opened, the default host and runspace configuration
                    //   that are defined by Windows PowerShell will be used.
                    runSpace.Open();

                    //=> Set Variables so they are available to user script...
                    if (Variables != null && Variables.Any())
                    {
                        foreach (KeyValuePair <string, object> variable in Variables)
                        {
                            runSpace.SessionStateProxy.SetVariable(variable.Key, variable.Value);
                        }
                    }

                    //=> this is exit status variables to be tested on exit from power shell script...
                    //   it is defined in PwerShell global scope...and must be set by scipt writer on exit...
                    runSpace.SessionStateProxy.SetVariable("ScriptExitStatus", _scriptExitStatus);

                    //=> Allows the execution of commands from a CLR
                    //RunspaceInvoke scriptInvoker = new RunspaceInvoke(runSpace);
                    //scriptInvoker.Invoke("Set-ExecutionPolicy Unrestricted");

                    using (PowerShell psInstance = PowerShell.Create())
                    {
                        try
                        {
                            // prepare a new collection to store output stream objects
                            PSDataCollection <PSObject> outputCollection = new PSDataCollection <PSObject>();
                            outputCollection.DataAdded           += AllStreams_DataAdded;
                            psInstance.Streams.Error.DataAdded   += AllStreams_DataAdded;
                            psInstance.Streams.Verbose.DataAdded += AllStreams_DataAdded;
                            psInstance.Streams.Warning.DataAdded += AllStreams_DataAdded;
                            psInstance.Streams.Debug.DataAdded   += AllStreams_DataAdded;

                            psInstance.Runspace = runSpace;

                            //=> This tasklet should be in the same dll as ExitStatus, i.e. Summer.Batch.Core.dll
                            //   we need to get the path to loaded Summer.Batch.Core.dll so we can load it in PowerShell
                            var assemblyLocation = System.Reflection.Assembly.GetExecutingAssembly().Location;

                            //=> need to load Summer.Batch.Core into runspace so we can reference ExitStatus
                            psInstance.AddScript("[System.Reflection.Assembly]::LoadFrom(\"" + assemblyLocation + "\")").AddStatement();

                            //=> add user command and its parameters...
                            psInstance.AddCommand(ScriptResource.GetFullPath());
                            if (Parameters != null && Parameters.Any())
                            {
                                foreach (KeyValuePair <string, object> variable in Parameters)
                                {
                                    psInstance.AddParameter(variable.Key, variable.Value);
                                }
                            }

                            //=> Invoke Asynchronously...
                            IAsyncResult asyncResult = psInstance.BeginInvoke <PSObject, PSObject>(null, outputCollection);

                            // do something else until execution has completed.
                            long t0 = DateTime.Now.Ticks;
                            while (!asyncResult.IsCompleted)
                            {
                                //=> take a nap and let script do its job...
                                Thread.Sleep(new TimeSpan(_checkInterval));

                                //=> to check if job was told to stop...
                                CheckStoppingState(chunkContext);

                                //=> lets make sure we did not exceed alloted time...
                                long timeFromT0 = (long)(new TimeSpan(DateTime.Now.Ticks - t0)).TotalMilliseconds;
                                if (timeFromT0 > _timeout)
                                {
                                    //=> Stop PowerShell...
                                    psInstance.Stop();

                                    //=> behave based on TimeoutBehaviorOption
                                    if (_timeoutBehavior.Equals(TimeoutBehaviorOption.SetExitStatusToFailed))
                                    {
                                        contribution.ExitStatus = ExitStatus.Failed;
                                        break;
                                    }
                                    else if (_timeoutBehavior.Equals(TimeoutBehaviorOption.ThrowException))
                                    {
                                        //=> lets dump what we got before throwing an error...
                                        LogStreams();
                                        throw new FatalStepExecutionException("Execution of PowerShell script exceeded allotted time.", null);
                                    }
                                }
                                else if (_execution.TerminateOnly)
                                {
                                    //=> Stop PowerShell...
                                    psInstance.Stop();

                                    //=> lets dump what we got before throwing an error...
                                    LogStreams();

                                    throw new JobInterruptedException(
                                              string.Format("Job interrupted while executing PowerShell script '{0}'", ScriptResource.GetFilename()));
                                }
                                else if (_stopped)
                                {
                                    psInstance.Stop();
                                    contribution.ExitStatus = ExitStatus.Stopped;
                                    break;
                                }
                            } // end while scope

                            //=> Wait to the end of execution...
                            //psInstance.EndInvoke(_asyncResult);

                            //NOTE: asyncResult.IsCompleted will be set to true if PowerShell.Stop was called or
                            //      PowerShell completed its work

                            //=> if status not yet set (script completed)...handle completion...
                            if (contribution.ExitStatus.IsRunning())
                            {
                                //=> script needs to set exit code...if exit code not set we assume 0
                                var lastExitCode = (int)runSpace.SessionStateProxy.PSVariable.GetValue("LastExitCode", 0);

                                _scriptExitStatus = runSpace.SessionStateProxy.GetVariable("ScriptExitStatus") as ExitStatus;

                                //=> set exit status...
                                if (_scriptExitStatus != null && !_scriptExitStatus.IsRunning())
                                {
                                    if (Logger.IsTraceEnabled)
                                    {
                                        Logger.Trace("***> ScriptExitStatus returned by script => {0}", _scriptExitStatus);
                                    }

                                    contribution.ExitStatus = _scriptExitStatus;
                                }
                                else //=> let user decide on ExitStatus
                                {
                                    if (Logger.IsTraceEnabled)
                                    {
                                        if (_scriptExitStatus == null)
                                        {
                                            Logger.Trace("***> ScriptExitStatus is null. Using PowerShellExitCodeMapper to determine ExitStatus.");
                                        }
                                        else if (_scriptExitStatus.IsRunning())
                                        {
                                            Logger.Trace("***> ScriptExitStatus is EXECUTING or UNKNOWN. Using PowerShellExitCodeMapper to determine ExitStatus.");
                                        }
                                    }

                                    if (PowerShellExitCodeMapper != null)
                                    {
                                        //=> determine exit status using User Provided PowerShellExitCodeMapper
                                        contribution.ExitStatus = PowerShellExitCodeMapper.GetExitStatus(lastExitCode);
                                    }
                                    else //at this point we are not able to determine exit status, user needs to fix this...
                                    {
                                        //=> lets dump what we got before throwing an error...
                                        LogStreams();
                                        throw new FatalStepExecutionException(
                                                  "PowerShellTasklet is not able to determine ExitStatus. ScriptExitStatus is null or (is EXECUTING or UNKNOWN) and " +
                                                  "PowerShellExitCodeMapper is NOT defined. Please set $global:ScriptExitStatus or define PowerShellExitCodeMapper.", null);
                                    }
                                }
                            }

                            if (Logger.IsInfoEnabled)
                            {
                                Logger.Info("PowerShell execution exit status [{0}]", contribution.ExitStatus);
                            }

                            //=> output captured stream data to Log...
                            LogStreams();
                        }
                        catch (RuntimeException ex)
                        {
                            Logger.Error(ex.Message);
                            throw;
                        }
                    } // end PowerShell Scope

                    //=> close Runspace...
                    runSpace.Close();

                    //=> we are done...
                    return(RepeatStatus.Finished);
                } // end of Runspace Scope
            }     // end of TransactionScope
        }
Exemplo n.º 34
0
        private void AnalyzeMarkdownHelp(
            IEnumerable <string> scopes,
            string directory,
            ReportLogger <HelpIssue> helpLogger,
            List <string> processedHelpFiles,
            string savedDirectory)
        {
            var helpFolder = Directory.EnumerateDirectories(directory, "help").FirstOrDefault();
            var service    = Path.GetFileName(directory);

            if (helpFolder == null)
            {
                helpLogger.LogRecord(new HelpIssue()
                {
                    Assembly    = service,
                    Description = string.Format("{0} has no matching help folder", service),
                    Severity    = 0,
                    Remediation = string.Format("Make sure a help folder for {0} exists and it is " +
                                                "being copied to the output directory.", service),
                    Target    = service,
                    HelpFile  = service + "/folder",
                    ProblemId = MissingHelpFile
                });

                return;
            }

            var helpFiles = Directory.EnumerateFiles(helpFolder, "*.md").Select(Path.GetFileNameWithoutExtension).ToList();

            if (!helpFiles.Any())
            {
                return;
            }

            Directory.SetCurrentDirectory(directory);
            var manifestFiles = Directory.EnumerateFiles(directory, "*.psd1").ToList();

            if (manifestFiles.Count > 1)
            {
                manifestFiles = manifestFiles.Where(f => Path.GetFileName(f).IndexOf(service) >= 0).ToList();
            }

            if (manifestFiles.Count == 0)
            {
                return;
            }

            var psd1            = manifestFiles.FirstOrDefault();
            var parentDirectory = Directory.GetParent(psd1).FullName;
            var psd1FileName    = Path.GetFileName(psd1);
            var powershell      = PowerShell.Create();

            powershell.AddScript("Import-LocalizedData -BaseDirectory " + parentDirectory +
                                 " -FileName " + psd1FileName +
                                 " -BindingVariable ModuleMetadata; $ModuleMetadata.NestedModules; $ModuleMetadata.RequiredModules | % { $_[\"ModuleName\"] };");
            var cmdletResult    = powershell.Invoke();
            var nestedModules   = cmdletResult.Where(c => c.ToString().StartsWith(".")).Select(c => c.ToString().Substring(2));
            var requiredModules = cmdletResult.Where(c => !c.ToString().StartsWith(".")).Select(c => c.ToString()).ToList();

            if (nestedModules.Any())
            {
                Directory.SetCurrentDirectory(directory);

                requiredModules = requiredModules.Join(scopes,
                                                       module => 1,
                                                       dir => 1,
                                                       (module, dir) => Path.Combine(dir, module))
                                  .Where(Directory.Exists)
                                  .ToList();

                requiredModules.Add(directory);
                var allCmdlets = new List <CmdletMetadata>();
                foreach (var nestedModule in nestedModules)
                {
                    var assemblyFile = Directory.GetFiles(parentDirectory, nestedModule, SearchOption.AllDirectories).FirstOrDefault();
                    if (!File.Exists(assemblyFile))
                    {
                        continue;
                    }

                    var assemblyFileName = Path.GetFileName(assemblyFile);
                    helpLogger.Decorator.AddDecorator(h =>
                    {
                        h.HelpFile = assemblyFileName;
                        h.Assembly = assemblyFileName;
                    }, "Cmdlet");
                    processedHelpFiles.Add(assemblyFileName);
// TODO: Remove IfDef
#if NETSTANDARD
                    var proxy = new CmdletLoader();
#else
                    var proxy = EnvironmentHelpers.CreateProxy <CmdletLoader>(directory, out _appDomain);
#endif
                    var module  = proxy.GetModuleMetadata(assemblyFile, requiredModules);
                    var cmdlets = module.Cmdlets;
                    allCmdlets.AddRange(cmdlets);
                    helpLogger.Decorator.Remove("Cmdlet");
// TODO: Remove IfDef code
#if !NETSTANDARD
                    AppDomain.Unload(_appDomain);
#endif
                }

                ValidateHelpRecords(allCmdlets, helpFiles, helpLogger);
            }

            Directory.SetCurrentDirectory(savedDirectory);
        }
Exemplo n.º 35
0
        public void Execute(SetEventActionTrigger setEventActionTrigger, EventActionContext context)
        {
            var script = string.Empty;

            script = this.ScriptFile != string.Empty ? File.ReadAllText(this.ScriptFile) : this.Script;

            var powerShellScript = PowerShell.Create();

            powerShellScript.AddScript(script);

            // foreach (var prop in MessageProperties)
            // {
            // powerShellScript.AddParameter(prop.Key, prop.Value);
            // }
            powerShellScript.AddParameter("DataContext", this.DataContext);
            powerShellScript.Invoke();
            if (powerShellScript.HadErrors)
            {
                var sb = new StringBuilder();
                foreach (var error in powerShellScript.Streams.Error)
                {
                    sb.AppendLine(error.Exception.Message);
                }

                throw new Exception(sb.ToString());
            }

            var outVar = powerShellScript.Runspace.SessionStateProxy.PSVariable.GetValue("DataContext");

            if (outVar != null && outVar.ToString() != string.Empty)
            {
                try
                {
                    var po       = (PSObject)outVar;
                    var logEntry = po.BaseObject as EventLogEntry;
                    if (logEntry != null)
                    {
                        var ev = logEntry;
                        this.DataContext = Encoding.UTF8.GetBytes(ev.Message);
                    }
                    else
                    {
                        this.DataContext = Encoding.UTF8.GetBytes(outVar.ToString());
                    }

                    if (this.DataContext.Length != 0)
                    {
                        setEventActionTrigger(this, context);
                    }
                }
                catch
                {
                    // if multiple pso
                    var results = (object[])outVar;
                    foreach (var pos in results)
                    {
                        var po       = (PSObject)pos;
                        var logEntry = po.BaseObject as EventLogEntry;
                        if (logEntry != null)
                        {
                            var ev = logEntry;
                            this.DataContext = Encoding.UTF8.GetBytes(ev.Message);
                        }
                        else
                        {
                            this.DataContext = Encoding.UTF8.GetBytes(outVar.ToString());
                        }

                        if (this.DataContext.Length != 0)
                        {
                            setEventActionTrigger(this, context);
                        }
                    }
                }
            }
        }
Exemplo n.º 36
0
        ///  <summary>
        /// Создать пользователя в домене AD, подключившись к контроллеру по WinRM:Powershell
        ///  </summary>
        /// <param name="user"></param>
        // /// <param name="server">Имя контроллера домена к которому нужно подключиться</param>
        /// <param name="creds"></param>
        /// <param name="path">Путь к OU</param>
        public static void AddUser(AdUser user, PSCredential creds, Splash splash)
        {
            if (splash != null)
            {
                splash.Status = "Генерим скрипт.";
            }
            string Script = $"import-module activedirectory;" +
                            $"$sec_pass = ConvertTo-SecureString {user.Password} -AsPlainText -Force;" +
                            $"New-ADUser -Name '{user.FullName}'" +
                            $" -AccountPassword $sec_pass" +
                            $" -DisplayName '{user.DisplayName}'" +
                            $" -GivenName '{user.FirstName}'" +
                            $" -Surname '{user.SurName}'" +
                            $" -Path '{user.Domain.LoginOU}'" +
                            $" -SamAccountName '{user.Login}'" +
                            $" -UserPrincipalName '{user.UPN}'" +
                            $" -enabled $true;";

            Debug.WriteLine(Script);

            if (splash != null)
            {
                splash.Status = "Создаём ранспейс.";
            }
            WSManConnectionInfo connInfo = new WSManConnectionInfo(new Uri($"http://{user.Domain.DC}:5985"), "http://schemas.microsoft.com/powershell/Microsoft.PowerShell", creds);
            Runspace            runspace = RunspaceFactory.CreateRunspace(connInfo);
            PowerShell          shell    = PowerShell.Create(RunspaceMode.NewRunspace);

            if (splash != null)
            {
                splash.Status = $"Открываем ранспейс на сервере {user.Domain.DC}";
            }
            runspace.Open();
            shell.Runspace = runspace;
            if (splash != null)
            {
                splash.Status = $"Добавляем скрипт в пайплайн.";
            }
            shell.AddScript(Script);
            try {
                if (splash != null)
                {
                    splash.Status = $"Выполняем скрипт.";
                }
                Collection <PSObject> result = shell.Invoke();
                if (shell.HadErrors)
                {
                    foreach (ErrorRecord errorRecord in shell.Streams.Error)
                    {
                        Debug.WriteLine(errorRecord.Exception);
                        throw errorRecord.Exception;
                    }
                }
                foreach (PSObject psObject in result)
                {
                    Debug.WriteLine(psObject.ToString());
                }
            }
            catch (Exception e) {
                Debug.WriteLine(e);
                //throw;
            }

            runspace.CloseAsync();
            shell.Dispose();
        }
        public object ExecuteEndpoint(ExecutionContext context, Endpoint endpoint)
        {
            var script         = endpoint.ScriptBlock.ToString();
            var scriptBlockAst = endpoint.ScriptBlock.Ast as ScriptBlockAst;

            if (scriptBlockAst.ParamBlock == null && context.Parameters.Any())
            {
                if (Log.IsDebugEnabled)
                {
                    Log.Debug("Parameters--------------");
                    foreach (var variable in context.Parameters)
                    {
                        Log.Debug($"{variable.Key} = {variable.Value}");
                    }
                }

                var paramBlockBuilder = new StringBuilder();
                paramBlockBuilder.Append("param(");

                foreach (var parameter in context.Parameters)
                {
                    paramBlockBuilder.Append($"${parameter.Key},");
                }
                paramBlockBuilder.Remove(paramBlockBuilder.Length - 1, 1);
                paramBlockBuilder.Append(")");
                paramBlockBuilder.AppendLine();

                script = paramBlockBuilder.ToString() + script;
            }

            Collection <PSObject> output;
            string json;

            using (var ps = PowerShell.Create())
            {
                using (var runspaceRef = _runspace.GetRunspace())
                {
                    Runspace.DefaultRunspace = runspaceRef.Runspace;
                    ps.Runspace = runspaceRef.Runspace;

                    if (endpoint.Variables != null)
                    {
                        Log.Debug("Scope variables--------------");
                        SetVariables(ps.Runspace, endpoint.Variables);
                    }

                    if (context.Variables != null)
                    {
                        Log.Debug("Context variables--------------");
                        SetVariables(ps.Runspace, context.Variables);
                    }

                    SetVariable(ps.Runspace, "DashboardHub", _hubContext);
                    SetVariable(ps.Runspace, "Cache", MemoryCache);
                    SetVariable(ps.Runspace, "StateRequestService", _stateRequestService);
                    SetVariable(ps.Runspace, "ConnectionId", context.ConnectionId);
                    SetVariable(ps.Runspace, Constants.SessionId, context.SessionId);

                    if (context.User != null)
                    {
                        SetVariable(ps.Runspace, "ClaimsPrinciple", context.User);
                    }

                    ps.AddStatement().AddScript(script);

                    foreach (var parameter in context.Parameters)
                    {
                        ps.AddParameter(parameter.Key, parameter.Value);
                    }

                    try
                    {
                        output = ps.Invoke();

                        if (ps.HadErrors)
                        {
                            if (ps.Streams.Error.Any())
                            {
                                var error = ps.Streams.Error[0].Exception.Message;

                                Log.Warn($"Error executing endpoint script. {error}");

                                return(new { Error = new Error {
                                                 Message = error
                                             } });
                            }
                        }
                    }
                    catch (Exception ex)
                    {
                        Log.Warn(ex, "Error executing endpoint script.");

                        return(new { Error = new Error {
                                         Message = ex.Message, Location = ex.StackTrace
                                     } });
                    }
                }
            }

            if (context.NoSerialization)
            {
                return(output.Select(m => m.BaseObject).ToArray());
            }

            json = output.FirstOrDefault()?.BaseObject as string;
            if (json != null)
            {
                return(json);
            }

            if (!output.Where(m => m != null).Select(m => m.BaseObject).OfType <InputAction>().Any() && !output.Where(m => m != null).Select(m => m.BaseObject).OfType <Component>().Any())
            {
                return(output.Where(m => m != null).Select(m => m.BaseObject));
            }

            return(FindComponents(output));
        }
        public void Init()
        {
            _ps = Utilities.CreatePowerShell(CmdletName, typeof(UpdateLibraryVariable));
            var octoRepo = Utilities.AddOctopusRepo(_ps.Runspace.SessionStateProxy.PSVariable);

            // Create some library variable sets
            _sets.Clear();
            _sets.Add(new LibraryVariableSetResource {
                Id = "LibraryVariableSets-1", Name = "ConnectionStrings", VariableSetId = "variables-1"
            });
            _sets.Add(new LibraryVariableSetResource {
                Id = "LibraryVariableSets-3", Name = "Service Endpoints", VariableSetId = "variables-3"
            });

            var variable = new VariableResource
            {
                Id          = "variables-1",
                Name        = "Test",
                Value       = "Test Value",
                IsSensitive = false
            };

            variable.Scope.Add(ScopeField.Action, "actions-1");
            variable.Scope.Add(ScopeField.Environment, "environments-1");
            variable.Scope.Add(ScopeField.Role, "DB");

            _variableSet.Variables.Add(variable);

            _sets[0].Links.Add("Variables", "variablesets-1");
            octoRepo.Setup(o => o.LibraryVariableSets.FindOne(It.IsAny <Func <LibraryVariableSetResource, bool> >()))
            .Returns(
                (Func <LibraryVariableSetResource, bool> f) =>
                (from l in _sets where f(l) select l).FirstOrDefault());
            octoRepo.Setup(o => o.Projects.FindByName("Gibberish")).Returns((ProjectResource)null);

            octoRepo.Setup(o => o.VariableSets.Get("variablesets-1")).Returns(_variableSet);

            var process = new DeploymentProcessResource();

            process.Steps.Add(new DeploymentStepResource {
                Name = "Website", Id = "Step-1"
            });
            octoRepo.Setup(o => o.DeploymentProcesses.Get("deploymentprocesses-1")).Returns(process);

            var envs = new List <EnvironmentResource>
            {
                new EnvironmentResource {
                    Id = "environments-1", Name = "DEV"
                },
                new EnvironmentResource {
                    Id = "environments-2", Name = "TEST"
                }
            };

            octoRepo.Setup(o => o.Environments.FindByNames(It.IsAny <string[]>()))
            .Returns((string[] names) => (from n in names
                                          from e in envs
                                          where e.Name.Equals(n, StringComparison.InvariantCultureIgnoreCase)
                                          select e).ToList());

            var machines = new List <MachineResource>
            {
                new MachineResource {
                    Id = "machines-1", Name = "db-01"
                },
                new MachineResource {
                    Id = "machines-2", Name = "web-01"
                }
            };

            octoRepo.Setup(o => o.Machines.FindByNames(It.IsAny <string[]>())).Returns(
                (string[] names) => (from n in names
                                     from m in machines
                                     where m.Name.Equals(n, StringComparison.InvariantCultureIgnoreCase)
                                     select m).ToList());
        }
Exemplo n.º 39
0
        public void Analyze(IEnumerable <string> cmdletProbingDirs,
                            Func <IEnumerable <string>, IEnumerable <string> > directoryFilter,
                            Func <string, bool> cmdletFilter,
                            IEnumerable <string> modulesToAnalyze)
        {
            var savedDirectory     = Directory.GetCurrentDirectory();
            var processedHelpFiles = new List <string>();
            var issueLogger        = Logger.CreateLogger <SignatureIssue>(signatureIssueReportLoggerName);

            List <string> probingDirectories = new List <string>();

            if (directoryFilter != null)
            {
                cmdletProbingDirs = directoryFilter(cmdletProbingDirs);
            }

            foreach (var baseDirectory in cmdletProbingDirs.Where(s => !s.Contains("ServiceManagement") &&
                                                                  !s.Contains("Stack") && Directory.Exists(Path.GetFullPath(s))))
            {
                //Add current directory for probing
                probingDirectories.Add(baseDirectory);
                probingDirectories.AddRange(Directory.EnumerateDirectories(Path.GetFullPath(baseDirectory)));

                foreach (var directory in probingDirectories)
                {
                    if (modulesToAnalyze != null &&
                        modulesToAnalyze.Any() &&
                        !modulesToAnalyze.Where(m => directory.EndsWith(m)).Any())
                    {
                        continue;
                    }

                    var service       = Path.GetFileName(directory);
                    var manifestFiles = Directory.EnumerateFiles(directory, "*.psd1").ToList();
                    if (manifestFiles.Count > 1)
                    {
                        manifestFiles = manifestFiles.Where(f => Path.GetFileName(f).IndexOf(service) >= 0).ToList();
                    }

                    if (!manifestFiles.Any())
                    {
                        continue;
                    }

                    var psd1            = manifestFiles.FirstOrDefault();
                    var parentDirectory = Directory.GetParent(psd1).FullName;
                    var psd1FileName    = Path.GetFileName(psd1);
                    IEnumerable <string> nestedModules   = null;
                    List <string>        requiredModules = null;
                    PowerShell           powershell      = PowerShell.Create();
                    powershell.AddScript("Import-LocalizedData -BaseDirectory " + parentDirectory +
                                         " -FileName " + psd1FileName +
                                         " -BindingVariable ModuleMetadata; $ModuleMetadata.NestedModules; $ModuleMetadata.RequiredModules | % { $_[\"ModuleName\"] };");
                    var cmdletResult = powershell.Invoke();
                    nestedModules   = cmdletResult.Where(c => c.ToString().StartsWith(".")).Select(c => c.ToString().Substring(2));
                    requiredModules = cmdletResult.Where(c => !c.ToString().StartsWith(".")).Select(c => c.ToString()).ToList();

                    if (nestedModules.Any())
                    {
                        Directory.SetCurrentDirectory(directory);

                        requiredModules = requiredModules.Join(cmdletProbingDirs,
                                                               module => 1,
                                                               dir => 1,
                                                               (module, dir) => Path.Combine(dir, module))
                                          .Where(f => Directory.Exists(f))
                                          .ToList();

                        requiredModules.Add(directory);

                        foreach (var nestedModule in nestedModules)
                        {
                            var assemblyFile = Directory.GetFiles(parentDirectory, nestedModule, SearchOption.AllDirectories).FirstOrDefault();
                            if (File.Exists(assemblyFile))
                            {
                                issueLogger.Decorator.AddDecorator(a => a.AssemblyFileName = assemblyFile, "AssemblyFileName");
                                processedHelpFiles.Add(assemblyFile);
                                var proxy =
#if !NETSTANDARD
                                    EnvironmentHelpers.CreateProxy <CmdletLoader>(directory, out _appDomain);
#else
                                    new CmdletLoader();
#endif
                                var module  = proxy.GetModuleMetadata(assemblyFile, requiredModules);
                                var cmdlets = module.Cmdlets;

                                if (cmdletFilter != null)
                                {
                                    cmdlets = cmdlets.Where <CmdletMetadata>((cmdlet) => cmdletFilter(cmdlet.Name)).ToList <CmdletMetadata>();
                                }

                                foreach (var cmdlet in cmdlets)
                                {
                                    Logger.WriteMessage("Processing cmdlet '{0}'", cmdlet.ClassName);
                                    string defaultRemediation = "Determine if the cmdlet should implement ShouldProcess and " +
                                                                "if so determine if it should implement Force / ShouldContinue";
                                    if (!cmdlet.SupportsShouldProcess && cmdlet.HasForceSwitch)
                                    {
                                        issueLogger.LogSignatureIssue(
                                            cmdlet: cmdlet,
                                            severity: 0,
                                            problemId: SignatureProblemId.ForceWithoutShouldProcessAttribute,
                                            description: string.Format("{0} Has  -Force parameter but does not set the SupportsShouldProcess " +
                                                                       "property to true in the Cmdlet attribute.", cmdlet.Name),
                                            remediation: defaultRemediation);
                                    }
                                    if (!cmdlet.SupportsShouldProcess && cmdlet.ConfirmImpact != ConfirmImpact.Medium)
                                    {
                                        issueLogger.LogSignatureIssue(
                                            cmdlet: cmdlet,
                                            severity: 2,
                                            problemId: SignatureProblemId.ConfirmLeveleWithNoShouldProcess,
                                            description:
                                            string.Format("{0} Changes the ConfirmImpact but does not set the " +
                                                          "SupportsShouldProcess property to true in the cmdlet attribute.",
                                                          cmdlet.Name),
                                            remediation: defaultRemediation);
                                    }
                                    if (!cmdlet.SupportsShouldProcess && cmdlet.IsShouldProcessVerb)
                                    {
                                        issueLogger.LogSignatureIssue(
                                            cmdlet: cmdlet,
                                            severity: 1,
                                            problemId: SignatureProblemId.ActionIndicatesShouldProcess,
                                            description:
                                            string.Format(
                                                "{0} Does not support ShouldProcess but the cmdlet verb {1} indicates that it should.",
                                                cmdlet.Name, cmdlet.VerbName),
                                            remediation: defaultRemediation);
                                    }
                                    if (cmdlet.ConfirmImpact != ConfirmImpact.Medium)
                                    {
                                        issueLogger.LogSignatureIssue(
                                            cmdlet: cmdlet,
                                            severity: 2,
                                            problemId: SignatureProblemId.ConfirmLevelChange,
                                            description:
                                            string.Format("{0} changes the confirm impact.  Please ensure that the " +
                                                          "change in ConfirmImpact is justified", cmdlet.Name),
                                            remediation:
                                            "Verify that ConfirmImpact is changed appropriately by the cmdlet. " +
                                            "It is very rare for a cmdlet to change the ConfirmImpact.");
                                    }
                                    if (!cmdlet.IsApprovedVerb)
                                    {
                                        issueLogger.LogSignatureIssue(
                                            cmdlet: cmdlet,
                                            severity: 1,
                                            problemId: SignatureProblemId.CmdletWithUnapprovedVerb,
                                            description:
                                            string.Format(
                                                "{0} uses the verb '{1}', which is not on the list of approved " +
                                                "verbs for PowerShell commands. Use the cmdlet 'Get-Verb' to see " +
                                                "the full list of approved verbs and consider renaming the cmdlet.",
                                                cmdlet.Name, cmdlet.VerbName),
                                            remediation: "Consider renaming the cmdlet to use an approved verb for PowerShell.");
                                    }

                                    if (!cmdlet.HasSingularNoun)
                                    {
                                        issueLogger.LogSignatureIssue(
                                            cmdlet: cmdlet,
                                            severity: 1,
                                            problemId: SignatureProblemId.CmdletWithPluralNoun,
                                            description:
                                            string.Format(
                                                "{0} uses the noun '{1}', which does not follow the enforced " +
                                                "naming convention of using a singular noun for a cmdlet name.",
                                                cmdlet.Name, cmdlet.NounName),
                                            remediation: "Consider using a singular noun for the cmdlet name.");
                                    }

                                    if (!cmdlet.OutputTypes.Any())
                                    {
                                        issueLogger.LogSignatureIssue(
                                            cmdlet: cmdlet,
                                            severity: 1,
                                            problemId: SignatureProblemId.CmdletWithNoOutputType,
                                            description:
                                            string.Format(
                                                "Cmdlet '{0}' has no defined output type.", cmdlet.Name),
                                            remediation: "Add an OutputType attribute that declares the type of the object(s) returned " +
                                            "by this cmdlet. If this cmdlet returns no output, please set the output " +
                                            "type to 'bool' and make sure to implement the 'PassThru' parameter.");
                                    }

                                    foreach (var parameter in cmdlet.GetParametersWithPluralNoun())
                                    {
                                        issueLogger.LogSignatureIssue(
                                            cmdlet: cmdlet,
                                            severity: 1,
                                            problemId: SignatureProblemId.ParameterWithPluralNoun,
                                            description:
                                            string.Format(
                                                "Parameter {0} of cmdlet {1} does not follow the enforced " +
                                                "naming convention of using a singular noun for a parameter name.",
                                                parameter.Name, cmdlet.Name),
                                            remediation: "Consider using a singular noun for the parameter name.");
                                    }

                                    foreach (var parameterSet in cmdlet.ParameterSets)
                                    {
                                        if (parameterSet.Name.Contains(" "))
                                        {
                                            issueLogger.LogSignatureIssue(
                                                cmdlet: cmdlet,
                                                severity: 1,
                                                problemId: SignatureProblemId.ParameterSetWithSpace,
                                                description:
                                                string.Format(
                                                    "Parameter set '{0}' of cmdlet '{1}' contains a space, which " +
                                                    "is discouraged for PowerShell parameter sets.",
                                                    parameterSet.Name, cmdlet.Name),
                                                remediation: "Remove the space(s) in the parameter set name.");
                                        }

                                        if (parameterSet.Parameters.Any(p => p.Position >= 4))
                                        {
                                            issueLogger.LogSignatureIssue(
                                                cmdlet: cmdlet,
                                                severity: 1,
                                                problemId: SignatureProblemId.ParameterWithOutOfRangePosition,
                                                description:
                                                string.Format(
                                                    "Parameter set '{0}' of cmdlet '{1}' contains at least one parameter " +
                                                    "with a position larger than four, which is discouraged.",
                                                    parameterSet.Name, cmdlet.Name),
                                                remediation: "Limit the number of positional parameters in a single parameter set to " +
                                                "four or fewer.");
                                        }
                                    }

                                    if (cmdlet.ParameterSets.Count() > 2 && cmdlet.DefaultParameterSetName == "__AllParameterSets")
                                    {
                                        issueLogger.LogSignatureIssue(
                                            cmdlet: cmdlet,
                                            severity: 1,
                                            problemId: SignatureProblemId.MultipleParameterSetsWithNoDefault,
                                            description:
                                            string.Format(
                                                "Cmdlet '{0}' has multiple parameter sets, but no defined default parameter set.",
                                                cmdlet.Name),
                                            remediation: "Define a default parameter set in the cmdlet attribute.");
                                    }
                                }

#if !NETSTANDARD
                                AppDomain.Unload(_appDomain);
#endif
                                issueLogger.Decorator.Remove("AssemblyFileName");
                            }
                        }
                        Directory.SetCurrentDirectory(savedDirectory);
                    }
                }
            }
        }
        public void SaveOnlyMarkedPropertiesInSpecifiedViews()
        {
            var initialSessionState = InitialSessionState.CreateDefault();

            initialSessionState.Commands.Add(
                new SessionStateCmdletEntry(
                    CmdletName,
                    typeof(NewFormatPs1XmlCommand),
                    null));

            using (var runspace = RunspaceFactory.CreateRunspace(initialSessionState))
            {
                runspace.Open();
                using (var powershell = PowerShell.Create())
                {
                    powershell.Runspace = runspace;

                    var cmdlet = new Command(CmdletName);

                    powershell.Commands.AddCommand(cmdlet);
                    cmdlet.Parameters.Add("ModulePath", Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "Dummy.psd1"));
                    cmdlet.Parameters.Add("OnlyMarkedProperties");
                    cmdlet.Parameters.Add("OutputPath", AppDomain.CurrentDomain.BaseDirectory);

                    var results = powershell.Invoke <string>();

                    var es = powershell.Streams.Error;

                    Assert.True(es.Count == 0, string.Join("\n,", es));
                    Assert.True(results.Count > 0);

                    var ws = powershell.Streams.Warning;
                    Assert.True(ws.Count == 2);

                    string filepath = null;
                    try
                    {
                        filepath = results.First();
                        Assert.NotNull(filepath);
                        Assert.True(File.Exists(filepath));

                        var xelement = XElement.Load(filepath);
                        var config   = xelement.Elements().ToList();

                        TestXmlMarked(config,
                                      // entrytype (1), prop-name or script-block (2), target (3), label (4), table-column-width (5), position (6), group-by-this-param (7)
                                      new List <Tuple <EntryType, string, View, string, uint?, uint?, bool> >
                        {
                            Tuple.Create <EntryType, string, View, string, uint?, uint?, bool>(EntryType.ScriptBlock, "$_.Foo", View.List, "PsDummyOutput1 Id", 0, null, false),
                            Tuple.Create <EntryType, string, View, string, uint?, uint?, bool>(EntryType.PropertyName, "RequestId", View.Both, "RequestId", null, 1, false),
                            Tuple.Create <EntryType, string, View, string, uint?, uint?, bool>(EntryType.PropertyName, "Name", View.Both, null, 16, null, false),
                            Tuple.Create <EntryType, string, View, string, uint?, uint?, bool>(EntryType.PropertyName, "Type", View.Both, "PsDummyOutput1 Type", null, 3, false),
                            Tuple.Create <EntryType, string, View, string, uint?, uint?, bool>(EntryType.ScriptBlock, "$_.PsDummyOutput2.Name", View.Both, "PsDummyOutput2 Name", null, null, true),
                            Tuple.Create <EntryType, string, View, string, uint?, uint?, bool>(EntryType.ScriptBlock, "$_.PsDummyOutput2.Location", View.Both, "PsDummyOutput2 Location", null, 0, false),
                            Tuple.Create <EntryType, string, View, string, uint?, uint?, bool>(EntryType.PropertyName, "StatusCode", View.None, null, null, null, false),
                            Tuple.Create <EntryType, string, View, string, uint?, uint?, bool>(EntryType.ScriptBlock, "S_.Foo", View.List, null, null, null, false),
                        },
                                      $"{ExpectedAssemblyName}.Models.PsDummyOutput1");

                        TestXmlGroupBy(config,
                                       new List <Tuple <GroupBy, View> >
                        {
                            new Tuple <GroupBy, View> (new GroupBy {
                                ScriptBlock = "$_.PsDummyOutput2.Name", Label = "PsDummyOutput2 Name"
                            }, View.Both),
                        },
                                       $"{ExpectedAssemblyName}.Models.PsDummyOutput1");
                    }
                    finally
                    {
                        if (filepath != null)
                        {
                            File.Delete(filepath);
                        }
                    }
                }
            }
        }
Exemplo n.º 41
0
        public static DscBreakpointCapability CheckForCapability(
            RunspaceDetails runspaceDetails,
            PowerShellContext powerShellContext,
            ILogger logger)
        {
            DscBreakpointCapability capability = null;

            // DSC support is enabled only for Windows PowerShell.
            if ((runspaceDetails.PowerShellVersion.Version.Major < 6) &&
                (runspaceDetails.Context != RunspaceContext.DebuggedRunspace))
            {
                using (PowerShell powerShell = PowerShell.Create())
                {
                    powerShell.Runspace = runspaceDetails.Runspace;

                    // Attempt to import the updated DSC module
                    powerShell.AddCommand("Import-Module");
                    powerShell.AddArgument(@"C:\Program Files\DesiredStateConfiguration\1.0.0.0\Modules\PSDesiredStateConfiguration\PSDesiredStateConfiguration.psd1");
                    powerShell.AddParameter("PassThru");
                    powerShell.AddParameter("ErrorAction", "Ignore");

                    PSObject moduleInfo = null;

                    try
                    {
                        moduleInfo = powerShell.Invoke().FirstOrDefault();
                    }
                    catch (RuntimeException e)
                    {
                        logger.WriteException("Could not load the DSC module!", e);
                    }

                    if (moduleInfo != null)
                    {
                        logger.Write(LogLevel.Verbose, "Side-by-side DSC module found, gathering DSC resource paths...");

                        // The module was loaded, add the breakpoint capability
                        capability = new DscBreakpointCapability();
                        runspaceDetails.AddCapability(capability);

                        powerShell.Commands.Clear();
                        powerShell.AddScript("Write-Host \"Gathering DSC resource paths, this may take a while...\"");
                        powerShell.Invoke();

                        // Get the list of DSC resource paths
                        powerShell.Commands.Clear();
                        powerShell.AddCommand("Get-DscResource");
                        powerShell.AddCommand("Select-Object");
                        powerShell.AddParameter("ExpandProperty", "ParentPath");

                        Collection <PSObject> resourcePaths = null;

                        try
                        {
                            resourcePaths = powerShell.Invoke();
                        }
                        catch (CmdletInvocationException e)
                        {
                            logger.WriteException("Get-DscResource failed!", e);
                        }

                        if (resourcePaths != null)
                        {
                            capability.dscResourceRootPaths =
                                resourcePaths
                                .Select(o => (string)o.BaseObject)
                                .ToArray();

                            logger.Write(LogLevel.Verbose, $"DSC resources found: {resourcePaths.Count}");
                        }
                        else
                        {
                            logger.Write(LogLevel.Verbose, $"No DSC resources found.");
                        }
                    }
                    else
                    {
                        logger.Write(LogLevel.Verbose, $"Side-by-side DSC module was not found.");
                    }
                }
            }

            return(capability);
        }
    public async Task <ExOResult> GetExoMailbox(bool invokeAsync = true)
    {
        var  sw = System.Diagnostics.Stopwatch.StartNew();
        long elapsedConnect = 0, elapsedCmds = 0, elapsedTotal = 0;

        // Stage #1
        InitialSessionState iss = InitialSessionState.CreateDefault();

        iss.ImportPSModule(new string[] { "ExchangeOnlineManagement" });

        using var exchangeRunspace = RunspaceFactory.CreateRunspace(iss);
        exchangeRunspace.Open();

        using (var pipeLine = exchangeRunspace.CreatePipeline())
        {
            var connectCmd = new Command("Connect-ExchangeOnline");
            connectCmd.Parameters.Add("AppId", AppId);
            connectCmd.Parameters.Add("Organization", Organization);
            connectCmd.Parameters.Add("Certificate", Certificate);

            pipeLine.Commands.Add(connectCmd);

            try
            {
                pipeLine.Invoke();
            }
            catch (Exception e)
            {
                return(new ExOResult(e.ToString(), "", 0, 0, 0));
            }

            elapsedConnect = sw.ElapsedMilliseconds;
            if (pipeLine.Error != null && pipeLine.Error.Count > 0)
            {
                throw new NotImplementedException(); // Error handing code below is not tested
#pragma warning disable CS0162                       // Unreachable code detected
                var errors         = pipeLine.Error.ReadToEnd();
                var errStringified = "!Errors! " + String.Join(" :: ", errors.Select(error => error.ToString()).ToList());
                return(new ExOResult(errStringified, "", elapsedConnect, 0, 0));

#pragma warning restore CS0162 // Unreachable code detected
            }
        }

        // Stage #2
        using var ps = PowerShell.Create();
        ps.Runspace  = exchangeRunspace;

        ps.Commands.AddCommand("Get-EXOMailBox").AddParameter("ResultSize", "unlimited");
        List <PSObject> results = await ps.InvokeAsyncConditionally(invokeAsync);

        elapsedCmds = sw.ElapsedMilliseconds;
        var err    = ps.StreamsErrorToString();
        var result = ResultsToSimpleString(results);

        // https://docs.microsoft.com/en-us/powershell/module/exchange/disconnect-exchangeonline?view=exchange-ps
        ps.Commands.Clear();
        ps.Commands.AddCommand("Disconnect-ExchangeOnline").AddParameter("Confirm", false);
        var disconnectResult = await ps.InvokeAsyncConditionally(invokeAsync);

        var disconnectErr = ps.StreamsErrorToString();

        sw.Stop();
        elapsedTotal = sw.ElapsedMilliseconds;

        return(new ExOResult(err, result, elapsedConnect, elapsedCmds, elapsedTotal));
    }
 public static void InvokeCommand(this PowerShell pwsh, PSCommand psCommand, PSInvocationSettings invocationSettings = null)
 {
     pwsh.Commands = psCommand;
     pwsh.InvokeAndClear(invocationSettings);
 }
        private bool TryInvokeUserDefinedReadLine(out string input, bool useUserDefinedCustomReadLine)
        {
            // We're using GetCommands instead of GetCommand so we don't auto-load a module should the command exist, but isn't loaded.
            // The idea is that if someone hasn't defined the command (say because they started -noprofile), we shouldn't auto-load
            // this function.

            input = null;
            if (!useUserDefinedCustomReadLine)
            {
                return(false);
            }

            // If we need to look for user defined custom readline command, then we need to wait for Runspace to be created.

            // [danthom] TODO: What to do about this?
            //var runspace = this.parent.LocalRunspace;
            //if (runspace != null
            //    && runspace.Engine.Context.EngineIntrinsics.InvokeCommand.GetCommands(CustomReadlineCommand, CommandTypes.All, nameIsPattern: false).Any())
            //{
            //    PowerShell ps;
            //    if (runspace.ExecutionContext.EngineHostInterface.NestedPromptCount > 0)
            //    {
            //        ps = PowerShell.Create(RunspaceMode.CurrentRunspace);
            //    }
            //    else
            //    {
            //        ps = PowerShell.Create();
            //        ps.Runspace = runspace;
            //    }

            //    try
            //    {
            //        var result = ps.AddCommand(CustomReadlineCommand).Invoke();
            //        if (result.Count == 1)
            //        {
            //            input = PSObject.Base(result[0]) as string;
            //            return true;
            //        }
            //    }
            //    catch (Exception e)
            //    {
            //        // TODO: what
            //        //CommandProcessorBase.CheckForSevereException(e);
            //        Util.FailFast( "Exception in TryInvokeUserDefinedReadLine.", e );
            //    }
            //}

            // Here's my attempt at duplicating the functionality of the above code,
            // without having access to PowerShell-internal stuff (which requires me to
            // turn some of the logic inside-out because I can't access the session state
            // when we are nested).

            PowerShell ps = null;

            try
            {
                var runspace = _parent.Runspace;
                if (null == runspace)
                {
                    return(false);
                }

                if (runspace.RunspaceAvailability == RunspaceAvailability.AvailableForNestedCommand)
                {
                    // Nested

                    // We don't have an easy way to check if we have a readline command
                    // defined-- we can't access the SessionState directly when nested (else
                    // we get an error complaining "A pipeline is already running. Concurrent
                    // SessionStateProxy method call is not allowed."). We could run some
                    // script, but we don't want readline commands to cause any auto-loading,
                    // so we have to save the old $PSModuleAutoloadingPreference, set it to
                    // "none", then check for the command (using a wildcard to make sure we
                    // don't generate errors if it doesn't exist), then restore the
                    // $PSModuleAutoloadingPreference... which seems like a pain.  So instead,
                    // if we are nested, I'm just going to remember what we had in the
                    // outer-most (non-nested) shell. This means that you won't be able to
                    // change the readline function when nested, but I think that's a fairly
                    // corner-case scenario.
                    // parent._ExecScriptNoExceptionHandling( ps,
                    //                                        Util.Sprintf( ...
                    //                                        false,
                    //                                        false );

                    if (m_customReadlineFuncExists)
                    {
                        ps = PowerShell.Create(RunspaceMode.CurrentRunspace);
                    }
                }
                else
                {
                    // Not Nested
                    if (runspace.SessionStateProxy.InvokeCommand.GetCommands(CustomReadlineCommand, CommandTypes.All, nameIsPattern: false).Any())
                    {
                        m_customReadlineFuncExists = true;
                        ps          = PowerShell.Create();
                        ps.Runspace = runspace;
                    }
                    else
                    {
                        m_customReadlineFuncExists = false;
                    }
                }

                if (null == ps)
                {
                    return(false);
                }

                var result = ps.AddCommand(CustomReadlineCommand).Invoke();
                if (result.Count == 1)
                {
                    //input = PSObject.Base(result[0]) as string; [danthom]
                    input = PSObjectSubstitute.Base(result[0]) as string;
                    return(true);
                }
                else if (result.Count > 1)
                {
                    var msg = Util.Sprintf("Custom readline function returned multiple results ({0}).",
                                           result.Count);

                    LogManager.Trace(msg);
                    Util.Fail(msg);   // not a true invariant; just want to stop in the debugger if this ever happens
                    try
                    {
                        ps.Commands.Clear();
                        ps.AddCommand("Write-Warning").AddParameter("Message", msg);
                        ps.Invoke();
                    }
                    catch (Exception e2)
                    {
                        Util.Fail(Util.Sprintf("Could not write warning about multi-result readline! {0}",
                                               Util.GetExceptionMessages(e2)));
                    }
                }
            }
            catch (Exception e)
            {
                // I've seen us get into this situation when running "rmo psreadline" from
                // within a nested prompt. It seems the prompt function doesn't want to
                // get reset until we exit the nested prompt.
                LogManager.Trace("Custom readline function failed: {0}", e.ToString());
                try
                {
                    ps.Commands.Clear();
                    ps.AddCommand("Write-Warning").AddParameter("Message",
                                                                Util.Sprintf("Custom readline function failed: {0}",
                                                                             Util.GetExceptionMessages(e)));
                    ps.Invoke();
                }
                catch (Exception e2)
                {
                    Util.Fail(Util.Sprintf("Could not write warning about failed readline! {0}",
                                           Util.GetExceptionMessages(e2)));
                }
            }

            input = null;
            return(false);
        }
Exemplo n.º 45
0
 public CommandCompletion CompleteInput(string input, int cursorIndex, Hashtable options, PowerShell powershell)
 {
     return(ReadLine.MockedCompleteInput(input, cursorIndex, options, powershell));
 }
Exemplo n.º 46
0
        public void LaunchCleanup(string connectionString)
        {
            TimeSpan timeout = new TimeSpan(0, 10, 0); // max run time

            string cleanUpScript     = string.Empty;
            string cleanUpScriptPath = string.Empty;
            string commandText       = string.Empty;
            string scriptName        = "CleanUpAfterTests.ps1";

            string rootPath  = UpNLevels(Environment.CurrentDirectory, 4);
            string sqlScript = Path.Combine(rootPath, "_PowerShellScripts", scriptName);

            if (File.Exists(sqlScript))
            {
                commandText = File.ReadAllText(sqlScript);
            }
            else
            {
                //Check alternative location (for HM deployed as a Web Job)
                rootPath  = Environment.CurrentDirectory;
                sqlScript = Path.Combine(rootPath, scriptName);
                if (File.Exists(sqlScript))
                {
                    commandText = File.ReadAllText(sqlScript);
                }
                else
                {
                    throw new FileNotFoundException($"The PowerShell script is not found in this location: {sqlScript}");
                }
            }

            Console.WriteLine("Running clean-up script...");
            using (PowerShell ps = PowerShell.Create())
            {
                // the streams (Error, Debug, Progress, etc) are available on the PowerShell instance.
                // we can review them during or after execution.
                // we can also be notified when a new item is written to the stream (like this):
                ps.Streams.Error.DataAdded += error_DataAdded;
                ps.Streams.Debug.DataAdded += debug_DataAdded;

                ps.AddCommand("Set-ExecutionPolicy").AddParameter("ExecutionPolicy", "RemoteSigned").AddParameter("Scope", "Process").Invoke();

                Pipeline pipeLine     = ps.Runspace.CreatePipeline();
                Command  cleanCommand = new Command(cleanUpScript, true);
                cleanCommand.Parameters.Add("connectionString", connectionString);
                cleanCommand.Parameters.Add("dbName", "");
                pipeLine.Commands.Add(cleanCommand);
                pipeLine.Commands.Add("Out-String");

                DateTime startTime = DateTime.UtcNow;
                pipeLine.InvokeAsync();
                while (pipeLine.PipelineStateInfo.State == PipelineState.Running || pipeLine.PipelineStateInfo.State == PipelineState.Stopping)
                {
                    if (startTime + timeout < DateTime.UtcNow)
                    {
                        //Timeout condition
                        Console.WriteLine("Operation timeout, exiting");
                        break;
                    }
                    Thread.Sleep(500);
                }

                var output = pipeLine.Output.ReadToEnd();

                foreach (PSObject outputItem in output)
                {
                    Console.WriteLine(outputItem.BaseObject?.ToString());
                }

                if (pipeLine.PipelineStateInfo.State == PipelineState.Failed)
                {
                    Console.WriteLine("Execution completed with error. Reason: " + pipeLine.PipelineStateInfo.Reason.Message);
                }
                else
                {
                    Console.WriteLine("Execution has finished. The pipeline state: " + pipeLine.PipelineStateInfo.State);
                }
            }
        }
Exemplo n.º 47
0
        public static void AddMailUser(AdUser user, PSCredential creds, Splash splash, string server = "fbi-exch01.fbi.local")
        {
            if (splash != null)
            {
                splash.Status = $"Генерим скрипт.";
            }
            string Script = $"New-Mailbox -Name '{user.FullName}'" +
                            $" -Alias '{user.Login}'" +
                            $" -OrganizationalUnit '{user.Domain.MailboxOU}'" +
                            $" -UserPrincipalName '{user.Login}@fbi.local'" +
                            $" -SamAccountName '{user.Login}'" +
                            $" -FirstName '{user.FirstName}'" +
                            $" -Initials ''" +
                            $" -LastName '{user.SurName}'" +
                            $" -LinkedMasterAccount '{user.Domain.AD}\\{user.Login}'" +
                            $" -LinkedDomainController '{user.Domain.DC}'";

            Debug.WriteLine(Script);
            if (splash != null)
            {
                splash.Status = $"Создаём подключение к {server}.";
            }
            WSManConnectionInfo connInfo = new WSManConnectionInfo(new Uri($"https://{server}/Powershell"), "http://schemas.microsoft.com/powershell/Microsoft.Exchange", creds);
            Runspace            runspace = RunspaceFactory.CreateRunspace(connInfo);
            PowerShell          shell    = PowerShell.Create(RunspaceMode.NewRunspace);

            if (splash != null)
            {
                splash.Status = $"Открываем подключение к {server}.";
            }
            runspace.Open();
            shell.Runspace = runspace;

            shell.AddScript(Script);
            try {
                if (splash != null)
                {
                    splash.Status = $"Выполняем скрипт.";
                }
                Collection <PSObject> result = shell.Invoke();
                if (shell.HadErrors)
                {
                    foreach (ErrorRecord errorRecord in shell.Streams.Error)
                    {
                        Debug.WriteLine(errorRecord.Exception);
                        throw errorRecord.Exception;
                    }
                }
                foreach (PSObject psObject in result)
                {
                    Debug.WriteLine(psObject.ToString());
                }
            }
            catch (Exception e) {
                Debug.WriteLine(e);
                //throw;
            }

            runspace.CloseAsync();
            shell.Dispose();
        }
Exemplo n.º 48
0
        /// <summary>
        /// Sets up the PowerShell shell stream event handlers.
        /// </summary>
        /// <param name="shell">The PowerShell shell.</param>
        private static void SetupStreamEventHandlers(PowerShell shell)
        {
            Logger.Instance.WriteMethodEntry(EventIdentifier.RunPowerShellScriptSetupStreamEventHandlers);

            try
            {
                shell.Streams.ClearStreams();
                shell.Streams.Error.DataAdded += delegate(object sender, DataAddedEventArgs e)
                {
                    PSDataCollection <ErrorRecord> errorStream = (PSDataCollection <ErrorRecord>)sender;
                    ErrorRecord record = errorStream[e.Index];
                    if (record == null)
                    {
                        return;
                    }

                    StringBuilder builder = new StringBuilder();
                    builder.AppendLine(record.ToString());

                    if (record.InvocationInfo != null)
                    {
                        builder.AppendLine();
                        builder.AppendLine(record.InvocationInfo.PositionMessage);
                    }

                    Logger.Instance.WriteError(EventIdentifier.RunPowerShellScriptSetupStreamEventHandlersErrorEvents, builder.ToString());
                };
                shell.Streams.Warning.DataAdded += delegate(object sender, DataAddedEventArgs e)
                {
                    PSDataCollection <WarningRecord> warningStream = (PSDataCollection <WarningRecord>)sender;
                    WarningRecord record = warningStream[e.Index];
                    if (record != null)
                    {
                        Logger.Instance.WriteWarning(EventIdentifier.RunPowerShellScriptSetupStreamEventHandlersWarningEvents, record.ToString());
                    }
                };
                shell.Streams.Debug.DataAdded += delegate(object sender, DataAddedEventArgs e)
                {
                    PSDataCollection <DebugRecord> debugStream = (PSDataCollection <DebugRecord>)sender;
                    DebugRecord record = debugStream[e.Index];
                    if (record != null)
                    {
                        Logger.Instance.WriteInfo(EventIdentifier.RunPowerShellScriptSetupStreamEventHandlersDebugEvents, record.ToString());
                    }
                };
                shell.Streams.Verbose.DataAdded += delegate(object sender, DataAddedEventArgs e)
                {
                    PSDataCollection <VerboseRecord> versboseStream = (PSDataCollection <VerboseRecord>)sender;
                    VerboseRecord record = versboseStream[e.Index];
                    if (record != null)
                    {
                        Logger.Instance.WriteVerbose(EventIdentifier.RunPowerShellScriptSetupStreamEventHandlersEvents, record.ToString());
                    }
                };
                shell.Streams.Progress.DataAdded += delegate(object sender, DataAddedEventArgs e)
                {
                    PSDataCollection <ProgressRecord> progressStream = (PSDataCollection <ProgressRecord>)sender;
                    ProgressRecord record = progressStream[e.Index];
                    if (record != null)
                    {
                        Logger.Instance.WriteInfo(EventIdentifier.RunPowerShellScriptSetupStreamEventHandlersProgressEvents, record.ToString());
                    }
                };
            }
            finally
            {
                Logger.Instance.WriteMethodExit(EventIdentifier.RunPowerShellScriptSetupStreamEventHandlers);
            }
        }
Exemplo n.º 49
0
        static void Main(string[] args)
        {
            var handle = GetStdHandle((uint)StandardHandleId.Output);

            GetConsoleMode(handle, out var mode);
            var vtEnabled = SetConsoleMode(handle, mode | ENABLE_VIRTUAL_TERMINAL_PROCESSING);

            var iss = InitialSessionState.CreateDefault2();

            if (args.Any())
            {
                iss.ImportPSModule(args[0]);
            }
            iss.ExecutionPolicy = ExecutionPolicy.Bypass;
            var rs = RunspaceFactory.CreateRunspace(iss);

            rs.Open();
            Runspace.DefaultRunspace = rs;

            PSConsoleReadLine.SetOptions(new SetPSReadLineOption
            {
                HistoryNoDuplicates = false,
                PredictionViewStyle = PredictionViewStyle.ListView,
                PredictionSource    = PredictionSource.HistoryAndPlugin,
            });

            if (vtEnabled)
            {
                var options = PSConsoleReadLine.GetOptions();
                options.CommandColor = "#8181f7";
                options.StringColor  = "\x1b[38;5;100m";
            }

            using (var ps = PowerShell.Create(rs))
            {
                var executionContext = ps.AddScript("$ExecutionContext").Invoke <EngineIntrinsics>().First();

                // Detect if the read loop will enter VT input mode.
                var vtInputEnvVar = Environment.GetEnvironmentVariable("PSREADLINE_VTINPUT");
                var stdin         = GetStdHandle((uint)StandardHandleId.Input);
                GetConsoleMode(stdin, out var inputMode);
                if (vtInputEnvVar == "1" || (inputMode & ENABLE_VIRTUAL_TERMINAL_INPUT) != 0)
                {
                    Console.WriteLine("\x1b[33mDefault input mode = virtual terminal\x1b[m");
                }
                else
                {
                    Console.WriteLine("\x1b[33mDefault input mode = Windows\x1b[m");
                }

                // This is a workaround to ensure the command analysis cache has been created before
                // we enter into ReadLine.  It's a little slow and infrequently needed, so just
                // uncomment if you hit a hang, run it once, then comment it out again.
                //ps.Commands.Clear();
                //ps.AddCommand("Get-Command").Invoke();

                executionContext.InvokeProvider.Item.Set("function:prompt", ScriptBlock.Create("'TestHostPS> '"));

                while (true)
                {
                    ps.Commands.Clear();
                    Console.Write(string.Join("", ps.AddCommand("prompt").Invoke <string>()));

                    var line = PSConsoleReadLine.ReadLine(rs, executionContext, true);
                    Console.WriteLine(line);
                    line = line.Trim().ToLower();
                    if (line.Equals("exit"))
                    {
                        Environment.Exit(0);
                    }
                    if (line.Equals("cmd"))
                    {
                        PSConsoleReadLine.SetOptions(new SetPSReadLineOption {
                            EditMode = EditMode.Windows
                        });
                    }
                    if (line.Equals("emacs"))
                    {
                        PSConsoleReadLine.SetOptions(new SetPSReadLineOption {
                            EditMode = EditMode.Emacs
                        });
                    }
                    if (line.Equals("vi"))
                    {
                        PSConsoleReadLine.SetOptions(new SetPSReadLineOption {
                            EditMode = EditMode.Vi
                        });
                    }
                    if (line.Equals("nodupes"))
                    {
                        PSConsoleReadLine.SetOptions(new SetPSReadLineOption {
                            HistoryNoDuplicates = true
                        });
                    }
                    if (line.Equals("vtinput"))
                    {
                        Environment.SetEnvironmentVariable("PSREADLINE_VTINPUT", "1");
                    }
                    if (line.Equals("novtinput"))
                    {
                        Environment.SetEnvironmentVariable("PSREADLINE_VTINPUT", "0");
                    }
                    if (line.Equals("listview"))
                    {
                        PSConsoleReadLine.SetOptions(new SetPSReadLineOption {
                            PredictionViewStyle = PredictionViewStyle.ListView
                        });
                    }
                    if (line.Equals("inlineview"))
                    {
                        PSConsoleReadLine.SetOptions(new SetPSReadLineOption {
                            PredictionViewStyle = PredictionViewStyle.InlineView
                        });
                    }
                    if (line.Equals("history"))
                    {
                        PSConsoleReadLine.SetOptions(new SetPSReadLineOption {
                            PredictionSource = PredictionSource.History
                        });
                    }
                    if (line.Equals("plugin"))
                    {
                        PSConsoleReadLine.SetOptions(new SetPSReadLineOption {
                            PredictionSource = PredictionSource.Plugin
                        });
                    }
                    if (line.Equals("historyplugin"))
                    {
                        PSConsoleReadLine.SetOptions(new SetPSReadLineOption {
                            PredictionSource = PredictionSource.HistoryAndPlugin
                        });
                    }
                    if (line.StartsWith("import-module"))
                    {
                        ps.AddScript(line).Invoke();
                    }
                    if (line.StartsWith("get-module"))
                    {
                        var modules = ps.AddScript(line).Invoke().ToList();
                        foreach (var m in modules)
                        {
                            Console.WriteLine(((PSModuleInfo)m.BaseObject).Name);
                        }
                    }
                }
            }
        }
Exemplo n.º 50
0
        /// <summary>
        /// Installs function app dependencies specified in functionAppRoot\requirements.psd1.
        /// </summary>
        internal void InstallFunctionAppDependencies(PowerShell pwsh, ILogger logger)
        {
            try
            {
                if (Dependencies.Count == 0)
                {
                    // If there are no dependencies to install, log and return.
                    logger.Log(LogLevel.Trace, PowerShellWorkerStrings.FunctionAppDoesNotHaveDependentModulesToInstall, isUserLog: true);
                    return;
                }

                if (!_shouldUpdateFunctionAppDependencies)
                {
                    // The function app already has the latest dependencies installed.
                    logger.Log(LogLevel.Trace, PowerShellWorkerStrings.LatestFunctionAppDependenciesAlreadyInstalled, isUserLog: true);
                    return;
                }

                // Install the function dependencies.
                logger.Log(LogLevel.Trace, PowerShellWorkerStrings.InstallingFunctionAppDependentModules, isUserLog: true);

                if (Directory.Exists(DependenciesPath))
                {
                    // Save-Module supports downloading side-by-size module versions. However, we only want to keep one version at the time.
                    // If the ManagedDependencies folder exits, remove all its contents.
                    DependencyManagementUtils.EmptyDirectory(DependenciesPath);
                }
                else
                {
                    // If the destination path does not exist, create it.
                    Directory.CreateDirectory(DependenciesPath);
                }

                try
                {
                    foreach (DependencyInfo module in Dependencies)
                    {
                        string moduleName    = module.Name;
                        string latestVersion = module.LatestVersion;

                        // Save the module to the given path
                        pwsh.AddCommand("PowerShellGet\\Save-Module")
                        .AddParameter("Repository", Repository)
                        .AddParameter("Name", moduleName)
                        .AddParameter("RequiredVersion", latestVersion)
                        .AddParameter("Path", DependenciesPath)
                        .AddParameter("Force", true)
                        .AddParameter("ErrorAction", "Stop")
                        .InvokeAndClearCommands();

                        var message = string.Format(PowerShellWorkerStrings.ModuleHasBeenInstalled, moduleName, latestVersion);
                        logger.Log(LogLevel.Trace, message, isUserLog: true);
                    }
                }
                finally
                {
                    // Clean up
                    pwsh.AddCommand(Utils.RemoveModuleCmdletInfo)
                    .AddParameter("Name", "PackageManagement, PowerShellGet")
                    .AddParameter("Force", true)
                    .AddParameter("ErrorAction", "SilentlyContinue")
                    .InvokeAndClearCommands();
                }
            }
            catch (Exception e)
            {
                var errorMsg = string.Format(PowerShellWorkerStrings.FailToInstallFuncAppDependencies, e.Message);
                throw new DependencyInstallationException(errorMsg, e);
            }
        }
Exemplo n.º 51
0
        public IActionResult ExtractPs()
        {
            var res = PowerShell.InvokeFile(@"scripts\test.ps1");

            return(StatusCode(res.Ok ? 200 : 500, res));
        }
Exemplo n.º 52
0
        /// <summary>
        /// 원격서버스크립트수행
        /// </summary>
        private void ExPs_GisTbloader()
        {
            // Username and Password for the remote machine.
            var    userName = User;
            string pw       = PW;

            // Creates a secure string for the password
            SecureString securePassword = new SecureString();

            foreach (char c in pw)
            {
                securePassword.AppendChar(c);
            }
            securePassword.MakeReadOnly();

            // Creates a PSCredential object
            PSCredential creds = new PSCredential(userName, securePassword);



            // Creates the runspace for PowerShell
            Runspace runspace = RunspaceFactory.CreateRunspace();

            // Create the PSSession connection to the remote machine.
            //ComputerName
            string computerName = IP;

            PowerShell powershell = PowerShell.Create();
            PSCommand  command    = new PSCommand();

            command.AddCommand("New-PSSession");
            command.AddParameter("ComputerName", computerName);
            command.AddParameter("Credential", creds);
            powershell.Commands = command;
            runspace.Open();
            powershell.Runspace = runspace;
            Collection <PSObject> result = powershell.Invoke();



            // Takes the PSSession object and places it into a PowerShell variable
            powershell = PowerShell.Create();
            command    = new PSCommand();
            command.AddCommand("Set-Variable");
            command.AddParameter("Name", "session");
            command.AddParameter("Value", result[0]);
            powershell.Commands = command;
            powershell.Runspace = runspace;
            powershell.Invoke();



            // Calls the Copy-Item cmdlet as a script and passes the PSSession, Path and destination parameters to it

            // 1.gisLoader 실행
            powershell = PowerShell.Create();
            command    = new PSCommand();
            command.AddScript(@"Invoke-Command -Session $session  -ScriptBlock {Invoke-Expression -Command:'cmd /c gisLoader d:\shape\WTL_SPLY_LS.shp infofms.WTL_SPLY_LS' }");
            powershell.Commands = command;
            powershell.Runspace = runspace;
            powershell.Invoke();

            // 2.tbloader 실행
            powershell = PowerShell.Create();
            command    = new PSCommand();
            command.AddScript(@"Invoke-Command  -Session $session -ScriptBlock {Invoke-Expression -Command:'cmd /c tbloader userid=infouser/infouser control=d:\shape\WTL_SPLY_LS.ctl' } ");
            powershell.Commands = command;
            powershell.Runspace = runspace;
            powershell.Invoke();

            // 세션종료
            powershell          = PowerShell.Create();
            powershell.Runspace = runspace;
            powershell.AddScript("Remove-PSSession $session");
            powershell.Invoke();
        }
Exemplo n.º 53
0
        public void GetRestorableDroppedDatabaseWithSqlAuth()
        {
            using (var powershell = PowerShell.Create())
            {
                // Create a context
                NewAzureSqlDatabaseServerContextTests.CreateServerContextSqlAuth(powershell, "$context");

                var testSession = MockServerHelper.DefaultSessionCollection.GetSession(
                    "UnitTests.GetRestorableDroppedDatabaseWithSqlAuth");
                DatabaseTestHelper.SetDefaultTestSessionSettings(testSession);
                testSession.RequestValidator =
                    new Action <HttpMessage, HttpMessage.Request>(
                        (expected, actual) =>
                {
                    Assert.AreEqual(expected.RequestInfo.Method, actual.Method);
                    Assert.AreEqual(expected.RequestInfo.UserAgent, actual.UserAgent);
                    if (expected.Index < 3)
                    {
                        DatabaseTestHelper.ValidateHeadersForODataRequest(expected.RequestInfo, actual);
                    }
                    else
                    {
                        Assert.Fail("No more requests expected.");
                    }
                });

                using (var exceptionManager = new AsyncExceptionManager())
                {
                    Collection <PSObject> databases, database1, database2;
                    using (new MockHttpServer(exceptionManager, MockHttpServer.DefaultServerPrefixUri, testSession))
                    {
                        databases = powershell.InvokeBatchScript(
                            @"Get-AzureSqlDatabase -RestorableDropped " +
                            @"-Context $context");
                    }

                    Assert.AreEqual(0, powershell.Streams.Error.Count, "Errors during run!");
                    Assert.AreEqual(0, powershell.Streams.Warning.Count, "Warnings during run!");
                    powershell.Streams.ClearStreams();

                    // Expecting testdb1, testdb2, possibly dropped databases from previous runs
                    Assert.IsTrue(
                        databases.Count >= 2,
                        "Expecting at-least two RestorableDroppedDatabase objects");

                    Assert.IsTrue(
                        databases[0].BaseObject is RestorableDroppedDatabase,
                        "Expecting a RestorableDroppedDatabase object");

                    Assert.IsTrue(
                        databases[1].BaseObject is RestorableDroppedDatabase,
                        "Expecting a RestorableDroppedDatabase object");

                    var database1Object       = (RestorableDroppedDatabase)databases[0].BaseObject;
                    var database1DeletionDate = database1Object.DeletionDate.ToUniversalTime().ToString(deletionDateStringFormat);

                    var database2Object       = (RestorableDroppedDatabase)databases[1].BaseObject;
                    var database2DeletionDate = database2Object.DeletionDate.ToUniversalTime().ToString(deletionDateStringFormat);

                    using (new MockHttpServer(
                               exceptionManager, MockHttpServer.DefaultServerPrefixUri, testSession))
                    {
                        database1 = powershell.InvokeBatchScript(
                            @"Get-AzureSqlDatabase -RestorableDropped " +
                            @"-Context $context " +
                            @"-DatabaseName " + database1Object.Name + @" " +
                            @"-DatabaseDeletionDate " + database1DeletionDate);
                        database2 = powershell.InvokeBatchScript(
                            @"Get-AzureSqlDatabase -RestorableDropped " +
                            @"-Context $context " +
                            @"-DatabaseName " + database2Object.Name + @" " +
                            @"-DatabaseDeletionDate " + database2DeletionDate);
                    }

                    Assert.IsTrue(
                        database1.Single().BaseObject is RestorableDroppedDatabase,
                        "Expecting a RestorableDroppedDatabase object");
                    var refreshedDatabase1Object = (RestorableDroppedDatabase)database1.Single().BaseObject;
                    Assert.AreEqual(
                        database1Object.Name, refreshedDatabase1Object.Name,
                        "Expected db name to be " + database1Object.Name);

                    Assert.IsTrue(
                        database2.Single().BaseObject is RestorableDroppedDatabase,
                        "Expecting a RestorableDroppedDatabase object");
                    var refreshedDatabase2Object = (RestorableDroppedDatabase)database2.Single().BaseObject;
                    Assert.AreEqual(
                        database2Object.Name, refreshedDatabase2Object.Name,
                        "Expected db name to be " + database2Object.Name);
                    Assert.AreEqual(
                        database2Object.Edition, refreshedDatabase2Object.Edition,
                        "Expected edition to be " + database2Object.Edition);
                    Assert.AreEqual(
                        database2Object.MaxSizeBytes, refreshedDatabase2Object.MaxSizeBytes,
                        "Expected max size to be " + database2Object.MaxSizeBytes);
                }
            }
        }
Exemplo n.º 54
0
        /// <summary>
        /// Create pipeline.
        /// </summary>
        internal Pipeline CreatePipeline(string line, bool addToHistory, bool useNestedPipelines)
        {
            // This method allows input commands to work against no-language runspaces. If a runspace
            // is pushed, it tries to parse the line using a ScriptBlock object. If a runspace is not
            // pushed, or if the parsing fails, in these cases it reverts to calling CreatePipeline
            // using the unparsed line.

            Pipeline pipeline = null;

            // In Start-PSSession scenario try to create a pipeline by parsing the line as a script block.
            if (this.IsRunspaceOverridden)
            {
                // Win8: exit should work to escape from the restrictive session
                if ((_runspaceRef.Value is RemoteRunspace) &&
                    (!string.IsNullOrEmpty(line) && string.Equals(line.Trim(), "exit", StringComparison.OrdinalIgnoreCase)))
                {
                    line = "Exit-PSSession";
                }

                PSCommand psCommand = ParsePsCommandUsingScriptBlock(line, null);
                if (psCommand != null)
                {
                    pipeline = useNestedPipelines ?
                               _runspaceRef.Value.CreateNestedPipeline(psCommand.Commands[0].CommandText, addToHistory) :
                               _runspaceRef.Value.CreatePipeline(psCommand.Commands[0].CommandText, addToHistory);

                    pipeline.Commands.Clear();

                    foreach (Command command in psCommand.Commands)
                    {
                        pipeline.Commands.Add(command);
                    }
                }
            }

            // If that didn't work out fall-back to the traditional approach.
            if (pipeline == null)
            {
                pipeline = useNestedPipelines ?
                           _runspaceRef.Value.CreateNestedPipeline(line, addToHistory) :
                           _runspaceRef.Value.CreatePipeline(line, addToHistory);
            }

            // Add robust connection callback if this is a pushed runspace.
            RemotePipeline remotePipeline = pipeline as RemotePipeline;

            if (this.IsRunspaceOverridden && remotePipeline != null)
            {
                PowerShell shell = remotePipeline.PowerShell;
                if (shell.RemotePowerShell != null)
                {
                    shell.RemotePowerShell.RCConnectionNotification +=
                        new EventHandler <PSConnectionRetryStatusEventArgs>(HandleRCConnectionNotification);
                }

                // Add callback to write robust connection errors from stream.
                shell.ErrorBuffer.DataAdded += (sender, eventArgs) =>
                {
                    RemoteRunspace remoteRunspace           = _runspaceRef.Value as RemoteRunspace;
                    PSDataCollection <ErrorRecord> erBuffer = sender as PSDataCollection <ErrorRecord>;
                    if (remoteRunspace != null && erBuffer != null &&
                        remoteRunspace.RunspacePool.RemoteRunspacePoolInternal.Host != null)
                    {
                        Collection <ErrorRecord> erRecords = erBuffer.ReadAll();
                        foreach (var er in erRecords)
                        {
                            remoteRunspace.RunspacePool.RemoteRunspacePoolInternal.Host.UI.WriteErrorLine(er.ToString());
                        }
                    }
                };
            }

            pipeline.SetHistoryString(line);

            return(pipeline);
        }
Exemplo n.º 55
0
        public void GetRestorableDroppedDatabaseWithSqlAuthNonExistentDb()
        {
            using (var powershell = PowerShell.Create())
            {
                // Create a context
                NewAzureSqlDatabaseServerContextTests.CreateServerContextSqlAuth(powershell, "$context");

                var testSession = MockServerHelper.DefaultSessionCollection.GetSession(
                    "UnitTests.GetRestorableDroppedDatabaseWithSqlAuthNonExistentDb");
                DatabaseTestHelper.SetDefaultTestSessionSettings(testSession);
                testSession.RequestValidator =
                    new Action <HttpMessage, HttpMessage.Request>(
                        (expected, actual) =>
                {
                    Assert.AreEqual(expected.RequestInfo.Method, actual.Method);
                    Assert.AreEqual(expected.RequestInfo.UserAgent, actual.UserAgent);
                    if (expected.Index < 1)
                    {
                        DatabaseTestHelper.ValidateHeadersForODataRequest(expected.RequestInfo, actual);
                    }
                    else
                    {
                        Assert.Fail("No more requests expected.");
                    }
                });

                using (var exceptionManager = new AsyncExceptionManager())
                {
                    using (new MockHttpServer(
                               exceptionManager, MockHttpServer.DefaultServerPrefixUri, testSession))
                    {
                        powershell.InvokeBatchScript(
                            @"Get-AzureSqlDatabase -RestorableDropped " +
                            @"-Context $context " +
                            @"-DatabaseName testdbnonexistent " +
                            @"-DatabaseDeletionDate '10/01/2013 12:00:00 AM'");
                    }

                    Assert.AreEqual(
                        1, powershell.Streams.Error.Count,
                        "Expecting errors");
                    Assert.AreEqual(
                        2, powershell.Streams.Warning.Count,
                        "Expecting tracing IDs");
                    Assert.AreEqual(
                        string.Format(
                            CultureInfo.InvariantCulture,
                            "Database '{0}' with deletion date '{1}' not found.",
                            testSession.SessionProperties["Servername"] + ".testdbnonexistent",
                            new DateTime(2013, 10, 01, 0, 0, 0, DateTimeKind.Utc)),
                        powershell.Streams.Error.First().Exception.Message,
                        "Unexpected error message");
                    Assert.IsTrue(
                        powershell.Streams.Warning.Any(w => w.Message.StartsWith("Client Session Id")),
                        "Expecting Client Session Id");
                    Assert.IsTrue(
                        powershell.Streams.Warning.Any(w => w.Message.StartsWith("Client Request Id")),
                        "Expecting Client Request Id");
                }
            }
        }
Exemplo n.º 56
0
        /// <summary>
        /// Runs the PowerShell script.
        /// </summary>
        /// <param name="script">The script.</param>
        /// <param name="scriptArguments">The PowerShell script arguments.</param>
        /// <param name="scriptParameters">The PowerShell script parameters.</param>
        /// <returns>The output of the script.</returns>
        private object RunScript(string script, IEnumerable scriptArguments, Dictionary <string, object> scriptParameters)
        {
            Logger.Instance.WriteMethodEntry(EventIdentifier.RunPowerShellScriptRunScript);

            WindowsImpersonationContext context = null;
            LogOnUser logOnUser = null;

            try
            {
                PSCredential credential = this.GetPowerShellCredential();

                logOnUser = this.LogOnUser(credential);

                if (logOnUser != null)
                {
                    context = logOnUser.Impersonate();
                }

                // Establish a new runspace for the Powershell script
                InitialSessionState initialSessionState = InitialSessionState.CreateDefault();

                bool progressPreference = Logger.Instance.ShouldTrace(TraceEventType.Information);
                bool debugPreference    = Logger.Instance.ShouldTrace(TraceEventType.Information);
                bool verbosePreference  = Logger.Instance.ShouldTrace(TraceEventType.Verbose);

                initialSessionState.Variables.Add(new SessionStateVariableEntry("ProgressPreference", progressPreference ? "Continue" : "SilentlyContinue", string.Empty));
                initialSessionState.Variables.Add(new SessionStateVariableEntry("DebugPreference", debugPreference ? "Continue" : "SilentlyContinue", string.Empty));
                initialSessionState.Variables.Add(new SessionStateVariableEntry("VerbosePreference", verbosePreference ? "Continue" : "SilentlyContinue", string.Empty));
                initialSessionState.Variables.Add(new SessionStateVariableEntry("AECWorkflowInstanceId", Logger.GetContextItem("WorkflowInstanceId"), string.Empty));
                initialSessionState.Variables.Add(new SessionStateVariableEntry("AECRequestId", Logger.GetContextItem("RequestId"), string.Empty));
                initialSessionState.Variables.Add(new SessionStateVariableEntry("AECActorId", Logger.GetContextItem("ActorId"), string.Empty));
                initialSessionState.Variables.Add(new SessionStateVariableEntry("AECTargetId", Logger.GetContextItem("TargetId"), string.Empty));
                initialSessionState.Variables.Add(new SessionStateVariableEntry("AECWorkflowDefinitionId", Logger.GetContextItem("WorkflowDefinitionId"), string.Empty));
                initialSessionState.Variables.Add(new SessionStateVariableEntry("Credential", credential, null));

                using (Runspace runspace = RunspaceFactory.CreateRunspace(initialSessionState))
                {
                    runspace.Open();
                    using (PowerShell shell = PowerShell.Create())
                    {
                        shell.Runspace = runspace;

                        SetupStreamEventHandlers(shell);

                        // Add the script to the PowerShell instance to prepare for execution
                        shell.AddScript(script);

                        StringBuilder scriptParams = new StringBuilder();

                        if (scriptParameters != null)
                        {
                            foreach (string s in scriptParameters.Keys)
                            {
                                shell.AddParameter(s, scriptParameters[s]);

                                scriptParams.AppendFormat(CultureInfo.InvariantCulture, "-{0} '{1}' ", s, scriptParameters[s]);
                            }
                        }
                        else if (scriptArguments != null)
                        {
                            foreach (object o in scriptArguments)
                            {
                                shell.AddArgument(o);
                                scriptParams.AppendFormat(CultureInfo.InvariantCulture, "'{0}' ", o);
                            }
                        }

                        if (this.InputType != PowerShellInputType.None)
                        {
                            Logger.Instance.WriteVerbose(EventIdentifier.RunPowerShellScriptRunScript, "The PowerShell script parameters are: '{0}'.", scriptParams);
                        }

                        // Execute the script and identify if any errors occurred
                        // In most circumstances, errors will not be raised as exceptions but will instead
                        // be presented in the Error collection for the PowerShell instance
                        Collection <PSObject> results;

                        try
                        {
                            results = shell.Invoke();
                        }
                        catch (Exception ex)
                        {
                            throw Logger.Instance.ReportError(EventIdentifier.RunPowerShellScriptRunScriptInvocationError, new WorkflowActivityLibraryException(Messages.RunPowerShellScript_ScriptInvocationError, ex, ex.Message));
                        }

                        // Let's go soft on the the non-terminating errors and trapped exceptions.
                        // We'll just log the error streams.
                        // If script wants to kill the activity, it should throw an exception.
                        if (shell.Streams.Error.Count != 0)
                        {
                            StringBuilder message = new StringBuilder();
                            message.AppendFormat(Messages.RunPowerShellScript_ScriptExecutionFailedError, shell.Streams.Error.Count);
                            foreach (ErrorRecord error in shell.Streams.Error)
                            {
                                message.AppendFormat("{0}\n", error);
                            }

                            Logger.Instance.WriteError(EventIdentifier.RunPowerShellScriptRunScriptExecutionFailedError, message.ToString());
                        }

                        if (this.ReturnType == PowerShellReturnType.None)
                        {
                            return(null);
                        }

                        if (results != null && results.Count == 1)
                        {
                            return(results[0].BaseObject);
                        }

                        if (results == null || results.Count < 1)
                        {
                            return(null);
                        }

                        // If multiple values were found for the lookup, verify that they are of a consistent type
                        Type type           = null;
                        bool consistentType = true;
                        foreach (PSObject pso in results)
                        {
                            if (type == null)
                            {
                                type = pso.BaseObject.GetType();

                                Logger.Instance.WriteVerbose(EventIdentifier.RunPowerShellScriptRunScript, "The PowerShell script returned type: '{0}'.", type);
                            }
                            else if (pso.BaseObject.GetType() != type)
                            {
                                consistentType = false;
                                Logger.Instance.WriteError(EventIdentifier.RunPowerShellScriptRunScriptInconsistentScriptReturnTypeError, Messages.RunPowerShellScript_InconsistentScriptReturnTypeError, pso.BaseObject.GetType(), type);
                            }
                        }

                        // If we have multiple values of an inconsistent type, there is a problem
                        // which needs to be addressed by the administrator
                        if (!consistentType)
                        {
                            throw Logger.Instance.ReportError(EventIdentifier.RunPowerShellScriptRunScriptInconsistentScriptReturnTypeError, new WorkflowActivityLibraryException(Messages.RunPowerShellScript_InvalidReturnTypeError));
                        }

                        // Because we have multiple values returned for the PowerShell script,
                        // we want to return them in the form of a strongly-typed list
                        // For example: List<string> instead of List<object>
                        // Use reflection to create a new strongly-typed list
                        Type listType  = typeof(List <>).MakeGenericType(new Type[] { type });
                        var  typedList = Activator.CreateInstance(listType);

                        // Using reflection, fetch the add method for the new list
                        // and invoke it to add each value from the original PSobject collection to the new collection
                        // Return the strongly-typed list
                        MethodInfo add = listType.GetMethod("Add");
                        foreach (PSObject pso in results)
                        {
                            add.Invoke(typedList, new object[] { pso.BaseObject });
                        }

                        return(typedList);
                    }
                }
            }
            catch (Exception ex)
            {
                throw Logger.Instance.ReportError(EventIdentifier.RunPowerShellScriptRunScriptExecutionFailedError, ex);
            }
            finally
            {
                if (context != null)
                {
                    context.Undo();
                }

                if (logOnUser != null)
                {
                    logOnUser.Dispose();
                }

                Logger.Instance.WriteMethodExit(EventIdentifier.RunPowerShellScriptRunScript);
            }
        }
 public static void ImportModule(this PowerShell pwsh, string moduleNameOrPath)
 {
     pwsh.AddCommand("Microsoft.PowerShell.Core\\Import-Module")
     .AddParameter("-Name", moduleNameOrPath)
     .InvokeAndClear();
 }
Exemplo n.º 58
0
        /// <summary>
        /// Override inside a safe lock.
        /// </summary>
        /// <param name="remoteRunspace">Runspace to override.</param>
        /// <param name="syncObject">Object to use in synchronization.</param>
        /// <param name="isRunspacePushed">Set is runspace pushed.</param>
        internal void Override(RemoteRunspace remoteRunspace, object syncObject, out bool isRunspacePushed)
        {
            lock (_localSyncObject)
            {
                _stopInvoke = false;
            }

            try
            {
                if (syncObject != null)
                {
                    lock (syncObject)
                    {
                        _runspaceRef.Override(remoteRunspace);
                        isRunspacePushed = true;
                    }
                }
                else
                {
                    _runspaceRef.Override(remoteRunspace);
                    isRunspacePushed = true;
                }

                if ((remoteRunspace.GetCurrentlyRunningPipeline() != null))
                {
                    // Don't execute command if pushed runspace is already running one.
                    return;
                }

                using (PowerShell powerShell = PowerShell.Create())
                {
                    powerShell.AddCommand("Get-Command");
                    powerShell.AddParameter("Name", new string[] { "Out-Default", "Exit-PSSession" });
                    powerShell.Runspace = _runspaceRef.Value;

                    bool isReleaseCandidateBackcompatibilityMode =
                        _runspaceRef.Value.GetRemoteProtocolVersion() == RemotingConstants.ProtocolVersionWin7RC;
                    powerShell.IsGetCommandMetadataSpecialPipeline = !isReleaseCandidateBackcompatibilityMode;
                    int expectedNumberOfResults = isReleaseCandidateBackcompatibilityMode ? 2 : 3;

                    powerShell.RemotePowerShell.HostCallReceived += new EventHandler <RemoteDataEventArgs <RemoteHostCall> >(HandleHostCall);

                    IAsyncResult asyncResult            = powerShell.BeginInvoke();
                    PSDataCollection <PSObject> results = new PSDataCollection <PSObject>();

                    while (!_stopInvoke)
                    {
                        asyncResult.AsyncWaitHandle.WaitOne(1000);

                        if (asyncResult.IsCompleted)
                        {
                            results = powerShell.EndInvoke(asyncResult);
                            break;
                        }
                    }

                    if (powerShell.Streams.Error.Count > 0 || results.Count < expectedNumberOfResults)
                    {
                        throw RemoteHostExceptions.NewRemoteRunspaceDoesNotSupportPushRunspaceException();
                    }
                }
            }
            catch (Exception)
            {
                _runspaceRef.Revert();
                isRunspacePushed = false;
                throw;
            }
        }
 // Have a single place to get a PowerShellManager for testing.
 // This is to guarantee that the well known paths are setup before calling the constructor of PowerShellManager.
 internal static PowerShellManager NewTestPowerShellManager(ConsoleLogger logger, PowerShell pwsh = null)
 {
     return(pwsh != null ? new PowerShellManager(logger, pwsh) : new PowerShellManager(logger, id: 2));
 }
 public static Collection <TResult> InvokeCommand <TResult>(this PowerShell pwsh, PSCommand psCommand, PSInvocationSettings invocationSettings = null)
 {
     pwsh.Commands = psCommand;
     return(pwsh.InvokeAndClear <TResult>(invocationSettings));
 }