예제 #1
0
        /// <summary>
        /// Creates a local runspace with the autoloading turned on.
        /// </summary>
        /// <returns></returns>
        internal static Runspace CreateLocalActivityRunspace(PSLanguageMode?languageMode = null, bool useCurrentThreadForExecution = true)
        {
            InitialSessionState iss = GetInitialSessionStateWithSharedTypesAndNoFormat();

            if (SystemPolicy.GetSystemLockdownPolicy() == SystemEnforcementMode.Enforce)
            {
                iss.LanguageMode = PSLanguageMode.ConstrainedLanguage;
            }

            if (languageMode != null && languageMode.HasValue)
            {
                iss.LanguageMode = languageMode.Value;
            }

            // Add a variable indicating that we're in Workflow endpoint. This enables the
            // autoloading feature.
            SessionStateVariableEntry ssve = new SessionStateVariableEntry("RunningInPSWorkflowEndpoint",
                                                                           true, "True if we're in a Workflow Endpoint", ScopedItemOptions.Constant);

            iss.Variables.Add(ssve);
            Runspace runspace = RunspaceFactory.CreateRunspace(iss);

            if (useCurrentThreadForExecution)
            {
                runspace.ThreadOptions = PSThreadOptions.UseCurrentThread;
            }

            return(runspace);
        }
        public void CreatePowerShells(PowerShell power, SessionStateVariableEntry session)
        {
            sessionStates.Add(InitialSessionState.CreateDefault());


            foreach (InitialSessionState s in sessionStates)
            {
                runspaces.Add(RunspaceFactory.CreateRunspace(iss));
            }



            pslist.Add(power);
            if (rs != null)
            {
                foreach (Runspace r in runspaces)
                {
                    foreach (PowerShell p in pslist)
                    {
                        p.Runspace = r;
                    }
                }
            }
            foreach (Runspace r in runspaces)
            {
                r.Open();
            }
        }
예제 #3
0
        public void AddVariableToSessionState()
        {
            InitialSessionState sessionState = InitialSessionState.CreateDefault();
            var variableEntry = new SessionStateVariableEntry("TestVariable", new object(), "description");

            sessionState.Variables.Add(variableEntry);

            Assert.IsTrue(sessionState.Variables.Contains(variableEntry));
        }
예제 #4
0
        public static void Initialize(Action <String> writeLine = null)
        {
            WriteLine = writeLine;
            InitialSessionState       state      = InitialSessionState.CreateDefault();
            SessionStateVariableEntry agentEntry = new SessionStateVariableEntry("Agent", typeof(Agent), "The Agent");

            state.Variables.Add(agentEntry);
            powershell = PowerShell.Create(state);
            WriteLine("PowerShell Agent Initialized");
        }
예제 #5
0
        InitialSessionState CreateInitialSessionState()
        {
            var initialSessionState = InitialSessionState.CreateDefault();

            initialSessionState.ImportPSModule(modulesToImport.ToArray());
            SessionStateVariableEntry variable = CreateDTESessionVariable();

            initialSessionState.Variables.Add(variable);
            return(initialSessionState);
        }
예제 #6
0
        private void Form1_Load(object sender, EventArgs e)
        {
            WriteText("Text Box Initialized");
            AppState.Mine = "YO";
            var me = new AppState();
            InitialSessionState       state  = InitialSessionState.CreateDefault();
            SessionStateVariableEntry Entry1 = new SessionStateVariableEntry("MyVar", me, "description");

            state.Variables.Add(Entry1);
            powershell = PowerShell.Create(state);
        }
예제 #7
0
        internal static void InitExchangePropertyContainer(InitialSessionState initialSessionState, ExchangeRunspaceConfiguration configuration)
        {
            ExchangePropertyContainer exchangePropertyContainer = new ExchangePropertyContainer();

            exchangePropertyContainer.logEntries = new CmdletLogEntries();
            exchangePropertyContainer.exchangeRunspaceConfiguration = configuration;
            exchangePropertyContainer.budget = ExchangePropertyContainer.AcquirePowerShellBudget(configuration);
            SessionStateVariableEntry item = new SessionStateVariableEntry(ExchangePropertyContainer.ExchangePropertyContainerName, exchangePropertyContainer, ExchangePropertyContainer.ExchangePropertyContainerName, ScopedItemOptions.ReadOnly | ScopedItemOptions.Constant | ScopedItemOptions.Private | ScopedItemOptions.AllScope);

            initialSessionState.Variables.Add(item);
        }
예제 #8
0
        public void NewVariableEntryWithNameValueAndDescriptionShouldHaveOptionsOfNoneAndPublicVisibility()
        {
            var value = new Object();
            var entry = new SessionStateVariableEntry("name", value, "description");

            Assert.AreEqual(ScopedItemOptions.None, entry.Options);
            Assert.AreEqual(SessionStateEntryVisibility.Public, entry.Visibility);
            Assert.AreEqual("description", entry.Description);
            Assert.AreEqual(value, entry.Value);
            Assert.AreEqual(0, entry.Attributes.Count);
        }
        InitialSessionState CreateInitialSessionState()
        {
            var initialSessionState = InitialSessionState.CreateDefault();

            string[] modulesToImport = PowerShellModules.GetModules().ToArray();
            initialSessionState.ImportPSModule(modulesToImport);
            SessionStateVariableEntry variable = CreateDTESessionVariable();

            initialSessionState.Variables.Add(variable);
            return(initialSessionState);
        }
예제 #10
0
        Runspace GetWPFCurrentThreadRunspace(InitialSessionState sessionState)
        {
            InitialSessionState clone = sessionState.Clone();

            clone.ThreadOptions = PSThreadOptions.UseCurrentThread;
            SessionStateVariableEntry window        = new SessionStateVariableEntry("Window", JobWindow, "");
            SessionStateVariableEntry namedControls = new SessionStateVariableEntry("NamedControls", this.namedControls, "");

            clone.Variables.Add(window);
            clone.Variables.Add(namedControls);
            return(RunspaceFactory.CreateRunspace(clone));
        }
예제 #11
0
        public void VariableDefinedInInitialSessionStateCanBeUsedInStatement()
        {
            string variableValue             = "testVariableValue";
            var    variableEntry             = new SessionStateVariableEntry("testVariable", variableValue, "description");
            InitialSessionState sessionState = InitialSessionState.Create();

            sessionState.Variables.Add(variableEntry);
            TestHost.InitialSessionState = sessionState;

            string output = TestHost.Execute("$testVariable");

            Assert.AreEqual(variableValue + Environment.NewLine, output);
        }
예제 #12
0
        public void NewVariableEntryCreatedWithSingleAttributeShouldHaveSingleAttribute()
        {
            var value     = new Object();
            var attribute = new CredentialAttribute();
            var entry     = new SessionStateVariableEntry("name", value, "description", ScopedItemOptions.Constant, attribute);

            Assert.AreEqual(1, entry.Attributes.Count);
            Assert.AreEqual(attribute, entry.Attributes[0]);
            Assert.AreEqual(value, entry.Value);
            Assert.AreEqual("name", entry.Name);
            Assert.AreEqual("description", entry.Description);
            Assert.AreEqual(ScopedItemOptions.Constant, entry.Options);
        }
예제 #13
0
        public void NewVariableEntryCreatedWithTwoAttributesShouldHaveSingleAttributes()
        {
            var value      = new Object();
            var attributes = new Collection <Attribute>();

            attributes.Add(new CredentialAttribute());
            attributes.Add(new CredentialAttribute());
            var entry = new SessionStateVariableEntry("name", value, "description", ScopedItemOptions.Constant, attributes);

            CollectionAssert.AreEqual(attributes, entry.Attributes);
            Assert.AreEqual(value, entry.Value);
            Assert.AreEqual("name", entry.Name);
            Assert.AreEqual("description", entry.Description);
            Assert.AreEqual(ScopedItemOptions.Constant, entry.Options);
        }
예제 #14
0
 public bool CreatePsPipeline()
 {
     _startTime           = DateTime.MinValue;
     _endTime             = DateTime.MinValue;
     _taskCompleted       = false;
     _taskStatus          = Status.NOTSTARTED;
     _resultDataTable     = null;
     _resultStringBuilder = new StringBuilder();
     try
     {
         InitialSessionState iss = InitialSessionState.CreateDefault();
         foreach (var v in _variables)
         {
             SessionStateVariableEntry variable = new SessionStateVariableEntry(v.Key, v.Value, null);
             iss.Variables.Add(variable);
         }
         _runspace = RunspaceFactory.CreateRunspace(initialSessionState: iss);
     }
     catch
     {
         _taskCompleted = true;
         _taskStatus    = Status.FAILED;
         throw;
     }
     try
     {
         _runspace.Open();
         _pipeline = _runspace.CreatePipeline();
         foreach (var scriptFile in _scriptFiles)
         {
             string scriptContent = System.IO.File.ReadAllText(scriptFile);
             _pipeline.Commands.AddScript(scriptContent);
         }
         _pipeline.Commands.AddScript(_scriptText);
     }
     catch
     {
         _taskStatus = Status.FAILED;
         throw;
     }
     return(true);
 }
예제 #15
0
        internal static Runspace CreateLocalActivityRunspace(PSLanguageMode?languageMode = null, bool useCurrentThreadForExecution = true)
        {
            InitialSessionState initialSessionStateWithSharedTypesAndNoFormat = LocalRunspaceProvider.GetInitialSessionStateWithSharedTypesAndNoFormat();

            if (SystemPolicy.GetSystemLockdownPolicy() == SystemEnforcementMode.Enforce)
            {
                initialSessionStateWithSharedTypesAndNoFormat.LanguageMode = PSLanguageMode.ConstrainedLanguage;
            }
            if (languageMode.HasValue && languageMode.HasValue)
            {
                initialSessionStateWithSharedTypesAndNoFormat.LanguageMode = languageMode.Value;
            }
            SessionStateVariableEntry sessionStateVariableEntry = new SessionStateVariableEntry("RunningInPSWorkflowEndpoint", (object)((bool)1), "True if we're in a Workflow Endpoint", ScopedItemOptions.Constant);

            initialSessionStateWithSharedTypesAndNoFormat.Variables.Add(sessionStateVariableEntry);
            Runspace runspace = RunspaceFactory.CreateRunspace(initialSessionStateWithSharedTypesAndNoFormat);

            if (useCurrentThreadForExecution)
            {
                runspace.ThreadOptions = PSThreadOptions.UseCurrentThread;
            }
            return(runspace);
        }
예제 #16
0
 public void Add(SessionStateVariableEntry session)
 {
     sSVarEntries.Add(session);
     iss.Variables.Add(sSVarEntries);
 }
        private static List <string> GetSingleAstRequiredModules(Ast ast, Token[] tokens)
        {
            List <string> modules   = new List <string>();
            List <string> resources = new List <string>();
            var           imports   = tokens.Where(token =>
                                                   String.Compare(token.Text, "Import-DscResource", StringComparison.OrdinalIgnoreCase) == 0);

            //
            // Create a function with the same name as Import-DscResource keyword and use powershell
            // argument function binding to emulate Import-DscResource argument binding.
            //
            InitialSessionState       initialSessionState            = InitialSessionState.Create();
            SessionStateFunctionEntry importDscResourcefunctionEntry = new SessionStateFunctionEntry(
                "Import-DscResource", @"param($Name, $ModuleName)
                if ($ModuleName) 
                {
                    foreach ($m in $ModuleName) { $global:modules.Add($m) }
                } else {
                    foreach ($n in $Name) { $global:resources.Add($n) }
                }
            ");

            initialSessionState.Commands.Add(importDscResourcefunctionEntry);
            initialSessionState.LanguageMode = PSLanguageMode.RestrictedLanguage;
            var moduleVarEntry    = new SessionStateVariableEntry("modules", modules, "");
            var resourcesVarEntry = new SessionStateVariableEntry("resources", resources, "");

            initialSessionState.Variables.Add(moduleVarEntry);
            initialSessionState.Variables.Add(resourcesVarEntry);

            using (System.Management.Automation.PowerShell powerShell = System.Management.Automation.PowerShell.Create(initialSessionState))
            {
                foreach (var import in imports)
                {
                    int startOffset      = import.Extent.StartOffset;
                    var asts             = ast.FindAll(a => IsCandidateForImportDscResourceAst(a, startOffset), true);
                    int longestLen       = -1;
                    Ast longestCandidate = null;
                    foreach (var candidatAst in asts)
                    {
                        int curLen = candidatAst.Extent.EndOffset - candidatAst.Extent.StartOffset;
                        if (curLen > longestLen)
                        {
                            longestCandidate = candidatAst;
                            longestLen       = curLen;
                        }
                    }
                    // longestCandidate should contain AST for import-dscresource, like "Import-DSCResource -Module x -Name y".
                    if (longestCandidate != null)
                    {
                        string importText = longestCandidate.Extent.Text;
                        // We invoke-command "importText" here. Script injection is prevented:
                        // We checked that file represents a valid AST without errors.
                        powerShell.AddScript(importText);
                        powerShell.Invoke();
                        powerShell.Commands.Clear();
                    }
                }
            }
            modules.AddRange(resources.Select(GetModuleNameForDscResource));
            return(modules);
        }
예제 #18
0
        static void PowershellThread(object state)
        {
            var cliArgs = (PsEntrypointArgs)state;

            if (!string.IsNullOrWhiteSpace(cliArgs.EntrypointScript))
            {
                cliArgs.EntrypointCommand = System.IO.File.ReadAllText(cliArgs.EntrypointScript);
            }

            if (!string.IsNullOrWhiteSpace(cliArgs.ShutdownScript))
            {
                cliArgs.ShutdownCommand = System.IO.File.ReadAllText(cliArgs.ShutdownScript);
            }

            var initialSessionState = InitialSessionState.CreateDefault();
            var entrypointVariable  = new SessionStateVariableEntry(EntrypointVariableName, (IEntrypointState)EntrypointState, EntrypointVariableDescription, ScopedItemOptions.AllScope | ScopedItemOptions.ReadOnly);

            initialSessionState.Variables.Add(entrypointVariable);

            var psHost = new PsEntrypointPSHost();

            using (var runspace = RunspaceFactory.CreateRunspace(psHost, initialSessionState))
            {
                PowerShell powershell;
                runspace.Open();

                // run entrypoint command
                using (powershell = PowerShell.Create())
                {
                    powershell.Runspace = runspace;
                    powershell.AddCommand("Set-ExecutionPolicy").AddParameter("-ExecutionPolicy", "Bypass").AddParameter("-Scope", "Process").Invoke();

                    if (!string.IsNullOrWhiteSpace(cliArgs.EntrypointScript))
                    {
                        var entrypointScript = runspace.SessionStateProxy.InvokeCommand.GetCommand(cliArgs.EntrypointScript, CommandTypes.ExternalScript);
                        powershell.AddCommand(entrypointScript);
                    }
                    else
                    {
                        powershell.AddScript(cliArgs.EntrypointCommand);
                    }

                    var entrypointResult = powershell.BeginInvoke();
                    logger.WriteLog("Entrypoint started");
                    Thread.Sleep(5);
                    try
                    {
                        foreach (var result in powershell.EndInvoke(entrypointResult))
                        {
                            Console.WriteLine(result.ToString());
                        }
                    }
                    catch (ThreadInterruptedException)
                    {
                        logger.WriteLog("Entrypoint interrupted. Terminating...");
                        powershell.Stop();
                    }
                    catch (Exception problem)
                    {
                        logger.WriteLog($"Entrypoint crashed: {problem}");
                    }
                    finally
                    {
                        logger.WriteLog("Entrypoint stopped");
                    }
                }

                // signal entrypoint terminated
                entrypointTerminated.Set();

                // run shutdown command
                if (!string.IsNullOrWhiteSpace(cliArgs.ShutdownCommand))
                {
                    using (powershell = PowerShell.Create())
                    {
                        powershell.Runspace = runspace;

                        if (!string.IsNullOrWhiteSpace(cliArgs.ShutdownScript))
                        {
                            var shutdownScript = runspace.SessionStateProxy.InvokeCommand.GetCommand(cliArgs.ShutdownScript, CommandTypes.ExternalScript);
                            powershell.AddCommand(shutdownScript);
                        }
                        else
                        {
                            powershell.AddScript(cliArgs.ShutdownCommand);
                        }

                        var shutdownResult = powershell.BeginInvoke();
                        Console.WriteLine("Shutdown initiated");
                        Thread.Sleep(5);
                        try
                        {
                            foreach (var result in powershell.EndInvoke(shutdownResult))
                            {
                                Console.WriteLine(result.ToString());
                            }
                            logger.WriteLog("Shutdown completed");
                        }
                        catch (ThreadInterruptedException)
                        {
                            logger.WriteLog("Shutdown interrupted. Terminating...");
                            powershell.Stop();
                        }
                        catch (Exception problem)
                        {
                            logger.WriteLog($"Shutdown crashed: {problem}");
                        }
                        finally
                        {
                            logger.WriteLog("Shutdown ended");
                        }
                    }
                }
                runspace.Close();
            }

            shutdownTerminated.Set();
        }
예제 #19
0
        public override InitialSessionState GetInitialSessionState(PSSenderInfo senderInfo)
        {
            InitialSessionState state = null;
            bool        flag          = false;
            string      str           = TryGetValue(this.configHash, ConfigFileContants.SessionType);
            SessionType type          = SessionType.Default;
            bool        flag2         = this.IsNonDefaultVisibiltySpecified(ConfigFileContants.VisibleCmdlets);
            bool        flag3         = this.IsNonDefaultVisibiltySpecified(ConfigFileContants.VisibleFunctions);
            bool        flag4         = this.IsNonDefaultVisibiltySpecified(ConfigFileContants.VisibleAliases);
            bool        flag5         = this.IsNonDefaultVisibiltySpecified(ConfigFileContants.VisibleProviders);

            if (!string.IsNullOrEmpty(str))
            {
                type = (SessionType)Enum.Parse(typeof(SessionType), str, true);
                switch (type)
                {
                case SessionType.Empty:
                    state = InitialSessionState.Create();
                    goto Label_00AD;

                case SessionType.RestrictedRemoteServer:
                    state = InitialSessionState.CreateRestricted(SessionCapabilities.RemoteServer);
                    if (flag5)
                    {
                        InitialSessionState state2 = InitialSessionState.CreateDefault2();
                        state.Providers.Add(state2.Providers);
                    }
                    goto Label_00AD;
                }
                state = InitialSessionState.CreateDefault2();
            }
            else
            {
                state = InitialSessionState.CreateDefault2();
            }
Label_00AD:
            if (this.configHash.ContainsKey(ConfigFileContants.AssembliesToLoad))
            {
                string[] strArray = TryGetStringArray(this.configHash[ConfigFileContants.AssembliesToLoad]);
                if (strArray != null)
                {
                    foreach (string str2 in strArray)
                    {
                        state.Assemblies.Add(new SessionStateAssemblyEntry(str2));
                    }
                }
            }
            if (this.configHash.ContainsKey(ConfigFileContants.ModulesToImport))
            {
                object[] objArray = TryGetObjectsOfType <object>(this.configHash[ConfigFileContants.ModulesToImport], new Type[] { typeof(string), typeof(Hashtable) });
                if ((this.configHash[ConfigFileContants.ModulesToImport] != null) && (objArray == null))
                {
                    PSInvalidOperationException exception = new PSInvalidOperationException(StringUtil.Format(RemotingErrorIdStrings.DISCTypeMustBeStringOrHashtableArray, ConfigFileContants.ModulesToImport));
                    exception.SetErrorId("InvalidModulesToImportKeyEntries");
                    throw exception;
                }
                if (objArray != null)
                {
                    Collection <ModuleSpecification> modules = new Collection <ModuleSpecification>();
                    foreach (object obj2 in objArray)
                    {
                        ModuleSpecification item = null;
                        string str4 = obj2 as string;
                        if (!string.IsNullOrEmpty(str4))
                        {
                            item = new ModuleSpecification(str4);
                        }
                        else
                        {
                            Hashtable moduleSpecification = obj2 as Hashtable;
                            if (moduleSpecification != null)
                            {
                                item = new ModuleSpecification(moduleSpecification);
                            }
                        }
                        if (item != null)
                        {
                            if (string.Equals(InitialSessionState.CoreModule, item.Name, StringComparison.OrdinalIgnoreCase))
                            {
                                if (type == SessionType.Empty)
                                {
                                    state.ImportCorePSSnapIn();
                                }
                            }
                            else
                            {
                                modules.Add(item);
                            }
                        }
                    }
                    state.ImportPSModule(modules);
                }
            }
            if (this.configHash.ContainsKey(ConfigFileContants.AliasDefinitions))
            {
                Hashtable[] hashtableArray = TryGetHashtableArray(this.configHash[ConfigFileContants.AliasDefinitions]);
                if (hashtableArray != null)
                {
                    foreach (Hashtable hashtable2 in hashtableArray)
                    {
                        SessionStateAliasEntry entry = this.CreateSessionStateAliasEntry(hashtable2);
                        if (entry != null)
                        {
                            state.Commands.Add(entry);
                        }
                    }
                }
            }
            if (this.configHash.ContainsKey(ConfigFileContants.FunctionDefinitions))
            {
                Hashtable[] hashtableArray2 = TryGetHashtableArray(this.configHash[ConfigFileContants.FunctionDefinitions]);
                if (hashtableArray2 != null)
                {
                    foreach (Hashtable hashtable3 in hashtableArray2)
                    {
                        SessionStateFunctionEntry entry2 = this.CreateSessionStateFunctionEntry(hashtable3);
                        if (entry2 != null)
                        {
                            state.Commands.Add(entry2);
                        }
                    }
                }
            }
            if (this.configHash.ContainsKey(ConfigFileContants.VariableDefinitions))
            {
                Hashtable[] hashtableArray3 = TryGetHashtableArray(this.configHash[ConfigFileContants.VariableDefinitions]);
                if (hashtableArray3 != null)
                {
                    foreach (Hashtable hashtable4 in hashtableArray3)
                    {
                        if (!hashtable4.ContainsKey(ConfigFileContants.VariableValueToken) || !(hashtable4[ConfigFileContants.VariableValueToken] is ScriptBlock))
                        {
                            SessionStateVariableEntry entry3 = this.CreateSessionStateVariableEntry(hashtable4);
                            if (entry3 != null)
                            {
                                state.Variables.Add(entry3);
                            }
                        }
                    }
                }
            }
            if (this.configHash.ContainsKey(ConfigFileContants.TypesToProcess))
            {
                string[] strArray2 = TryGetStringArray(this.configHash[ConfigFileContants.TypesToProcess]);
                if (strArray2 != null)
                {
                    foreach (string str5 in strArray2)
                    {
                        if (!string.IsNullOrEmpty(str5))
                        {
                            state.Types.Add(new SessionStateTypeEntry(str5));
                        }
                    }
                }
            }
            if (this.configHash.ContainsKey(ConfigFileContants.FormatsToProcess))
            {
                string[] strArray3 = TryGetStringArray(this.configHash[ConfigFileContants.FormatsToProcess]);
                if (strArray3 != null)
                {
                    foreach (string str6 in strArray3)
                    {
                        if (!string.IsNullOrEmpty(str6))
                        {
                            state.Formats.Add(new SessionStateFormatEntry(str6));
                        }
                    }
                }
            }
            if ((flag2 || flag3) || (flag4 || flag5))
            {
                flag = true;
            }
            if (flag)
            {
                state.Variables.Add(new SessionStateVariableEntry("PSModuleAutoLoadingPreference", PSModuleAutoLoadingPreference.None, string.Empty, ScopedItemOptions.None));
                if (type == SessionType.Default)
                {
                    state.ImportPSCoreModule(InitialSessionState.EngineModules.ToArray <string>());
                }
                if (!flag2)
                {
                    state.Commands.Remove("Import-Module", typeof(SessionStateCmdletEntry));
                }
                if (!flag4)
                {
                    state.Commands.Remove("ipmo", typeof(SessionStateAliasEntry));
                }
            }
            return(state);
        }