public static Stream CreatePsPath(SessionState session, string filePath) { string parentPath = session.Path.ParseParent(filePath, null); string childName = session.Path.ParseChildName(filePath); var parentItems = session.InvokeProvider.Item.Get(parentPath); if (parentItems.Count > 1) { throw new IOException(string.Format(CultureInfo.InvariantCulture, "PowerShell path {0} is ambiguous", parentPath)); } else if (parentItems.Count < 1) { throw new DirectoryNotFoundException("No such directory"); } DirectoryInfo parentAsDir = parentItems[0].BaseObject as DirectoryInfo; if (parentAsDir != null) { return File.Create(Path.Combine(parentAsDir.FullName, childName)); } DiscDirectoryInfo parentAsDiscDir = parentItems[0].BaseObject as DiscDirectoryInfo; if (parentAsDiscDir != null) { return parentAsDiscDir.FileSystem.OpenFile(Path.Combine(parentAsDiscDir.FullName, childName), FileMode.Create, FileAccess.ReadWrite); } throw new FileNotFoundException("Path is not a directory", parentPath); }
protected override void ProcessRecord() { IBuildDefinition[] builddefinitions; try { if (_projectCollectionUri != null) { var uri = new Uri(_projectCollectionUri); var tpc = TfsTeamProjectCollectionFactory.GetTeamProjectCollection(uri); var buildserver = tpc.GetService<IBuildServer>(); builddefinitions = buildserver.QueryBuildDefinitions(ProjectName); } else { var x = new SessionState(); var currentDirectory = x.Path.CurrentLocation.Path; builddefinitions = Core.GetBuildDefinitionsByLocalPath(currentDirectory); if (builddefinitions == null) { throw new Exception("No mapped workspace could be found at this path"); } } WriteObject(builddefinitions, true); } catch (Exception ex) { WriteObject(ex, true); } base.ProcessRecord(); }
public static InitialSessionState GenerateInitialSessionState(System.Management.Automation.SessionState sessionState) { var initialSessionState = InitialSessionState.CreateDefault2(); var modulePaths = sessionState.InvokeCommand.InvokeScript("Get-Module").Select(m => m.BaseObject).Cast <PSModuleInfo>().Select(m => m.Path).ToArray(); initialSessionState.ImportPSModule(modulePaths); var commands = sessionState.InvokeCommand.InvokeScript("Get-ChildItem -Path Function:\\").Select(m => m.BaseObject).Cast <FunctionInfo>(); foreach (var command in commands) { initialSessionState.Commands.Add(new SessionStateFunctionEntry(command.Name, command.Definition)); } var variables = sessionState.InvokeCommand.InvokeScript("Get-Variable").Select(m => m.BaseObject).Cast <PSVariable>(); foreach (var variable in variables) { if (variable.Options.HasFlag(ScopedItemOptions.Constant) || variable.Options.HasFlag(ScopedItemOptions.ReadOnly)) { continue; } initialSessionState.Variables.Add(new SessionStateVariableEntry(variable.Name, variable.Value, variable.Description)); } return(initialSessionState); }
public static SftpSession AddToSftpSessionCollection(SftpClient sftpclient, SessionState pssession) { //Set initial variables var obj = new SftpSession(); var sftpSessions = new List<SftpSession>(); var index = 0; // Retrive existing sessions from the globla variable. var sessionvar = pssession.PSVariable.GetValue("Global:SFTPSessions") as List<SftpSession>; // If sessions exist we set the proper index number for them. if (sessionvar != null) { sftpSessions.AddRange(sessionvar); index = sftpSessions.Count; } // Create the object that will be saved obj.SessionId = index; obj.Host = sftpclient.ConnectionInfo.Host; obj.Session = sftpclient; sftpSessions.Add(obj); // Set the Global Variable for the sessions. pssession.PSVariable.Set((new PSVariable("Global:SFTPSessions", sftpSessions, ScopedItemOptions.AllScope))); return obj; }
internal ProviderRuntime(SessionState sessionState, bool force, bool avoidWildcardExpansion) : this() { SessionState = sessionState; AvoidGlobbing = avoidWildcardExpansion; Force = force; }
private static InitialSessionState GetSessionState(SessionState sessionState) { var initialSessionState = InitialSessionState.CreateDefault2(); CaptureVariables(sessionState, initialSessionState); CaptureFunctions(sessionState, initialSessionState); return initialSessionState; }
internal PathInfo(PSDriveInfo drive, ProviderInfo provider, Path path, SessionState sessionState) { Drive = drive; Provider = provider; _path = path; _sessionState = sessionState; }
internal ProviderInfo(SessionState sessionState, Type implementingType, string name, string description, string home, string helpFile, PSSnapInInfo psSnapIn) { this.helpFile = ""; if (sessionState == null) { throw PSTraceSource.NewArgumentNullException("sessionState"); } if (implementingType == null) { throw PSTraceSource.NewArgumentNullException("implementingType"); } if (string.IsNullOrEmpty(name)) { throw PSTraceSource.NewArgumentException("name"); } if (string.IsNullOrEmpty(name)) { throw PSTraceSource.NewArgumentException("name"); } this.sessionState = sessionState; this.name = name; this.description = description; this.home = home; this.implementingType = implementingType; this.helpFile = helpFile; this.pssnapin = psSnapIn; this.hiddenDrive = new PSDriveInfo(this.FullName, this, "", "", null); this.hiddenDrive.Hidden = true; }
internal static bool IsCurrentDriveAD(SessionState sessionState) { PSDriveInfo current = sessionState.Drive.Current; ProviderInfo provider = current.Provider; bool flag = string.Compare(provider.Name, "ActiveDirectory", StringComparison.OrdinalIgnoreCase) == 0; return flag; }
internal static string GetCurrentPartitionPath(SessionState sessionState) { ADRootDSE rootDSE; string str = null; ADDriveInfo current = sessionState.Drive.Current as ADDriveInfo; if (current != null) { using (ADObjectSearcher aDObjectSearcher = new ADObjectSearcher(current.SessionInfo)) { rootDSE = aDObjectSearcher.GetRootDSE(); rootDSE.SessionInfo = current.SessionInfo; } string currentDriveLocation = ProviderUtils.GetCurrentDriveLocation(sessionState, current.SessionInfo); if (currentDriveLocation != string.Empty) { try { str = ADForestPartitionInfo.ExtractAndValidatePartitionInfo(rootDSE, currentDriveLocation); } catch (ArgumentException argumentException1) { ArgumentException argumentException = argumentException1; object[] objArray = new object[1]; objArray[0] = currentDriveLocation; throw new ArgumentException(string.Format(CultureInfo.CurrentCulture, StringResources.ProviderUtilInvalidDrivePath, objArray), argumentException); } } else { return string.Empty; } } return str; }
public static SshSession AddToSshSessionCollection(SshClient sshclient, SessionState pssession) { //Set initial variables var obj = new SshSession(); var sshSessions = new List<SshSession>(); var index = 0; // Retrieve existing sessions from the global variable. var sessionvar = pssession.PSVariable.GetValue("Global:SshSessions") as List<SshSession>; // If sessions exist we set the proper index number for them. if (sessionvar != null && sessionvar.Count > 0) { sshSessions.AddRange(sessionvar); // Get the SessionId of the last item and count + 1 SshSession lastSession = sshSessions[sshSessions.Count - 1]; index = lastSession.SessionId + 1; } // Create the object that will be saved obj.SessionId = index; obj.Host = sshclient.ConnectionInfo.Host; obj.Session = sshclient; sshSessions.Add(obj); // Set the Global Variable for the sessions. pssession.PSVariable.Set((new PSVariable("Global:SshSessions", sshSessions, ScopedItemOptions.AllScope))); return obj; }
internal void InternalDispose(bool isDisposing) { this.myInvocation = null; this.state = null; this.commandInfo = null; this.context = null; }
//private string _projectCollectionUri; //[AllowNull] //[Parameter(ParameterSetName = "ParamByUri")] //public string ProjectCollectionUri //{ // get { return _projectCollectionUri; } // set // { // if (Uri.IsWellFormedUriString(value, UriKind.Absolute)) // { // _projectCollectionUri = value; // } // } //} protected override void ProcessRecord() { PendingChange[] pc; try { //if (_projectCollectionUri != null) //{ //var uri = new Uri(_projectCollectionUri); //var tpc = TfsTeamProjectCollectionFactory.GetTeamProjectCollection(uri); //var vcs = tpc.GetService<VersionControlServer>(); //tpc.ConfigurationServer.Connect(ConnectOptions.IncludeServices); //tpc.ConfigurationServer.Authenticate(); ///builds = buildserver.QueryBuilds(ProjectName); //} var x = new SessionState(); var currentDirectory = x.Path.CurrentLocation.Path; var wk = Core.GetWorkspaceByLocalPath(currentDirectory); pc = wk.GetPendingChanges(); if (pc == null) { throw new Exception("No mapped workspace could be found at this path"); } WriteObject(pc, true); } catch (Exception ex) { WriteObject(ex, true); } base.ProcessRecord(); }
public ExecutionContext(PSHost host, RunspaceConfiguration config) : this() { RunspaceConfiguration = config; LocalHost = host; SessionStateGlobal = new SessionStateGlobal(this); SessionState = new SessionState(SessionStateGlobal); }
internal LocationGlobber(SessionState sessionState) { if (sessionState == null) { throw PSTraceSource.NewArgumentNullException("sessionState"); } this.sessionState = sessionState; }
internal SessionState(SessionState sessionState) { SessionStateGlobal = sessionState.SessionStateGlobal; Drive = sessionState.Drive; Path = sessionState.Path; Provider = sessionState.Provider; PSVariable = sessionState.PSVariable; }
internal static PSObject GetPsObject(SessionState provider, Notification notification) { var psobj = PSObject.AsPSObject(notification); psobj.Properties.Add(new PSNoteProperty("Type", notification.GetType().Name)); return psobj; }
/// <summary> /// Gets an provider path for the given component key path. /// </summary> /// <param name="session">The <see cref="SessionState"/> for resolving key paths.</param> /// <param name="path">The component key path to resolve.</param> /// <returns>A provider path for the given component path.</returns> public static string ResolveKeyPath(SessionState session, string path) { if (session != null) { return session.Path.GetUnresolvedPSPathFromKeyPath(path); } return null; }
public IAzureHDInsightConnectionSessionManager Create(SessionState sessionState) { if (singleton == null) { singleton = new AzureHDInsightConnectionSessionManagerSimulator(); } return singleton; }
/// <summary> /// /// </summary> /// <param name="literalPath"></param> /// <param name="session"></param> internal UnresolvedPscxPathImpl(string literalPath, SessionState session) { PscxArgumentException.ThrowIfIsNullOrEmpty(literalPath); PscxArgumentException.ThrowIfIsNull(session); _providerPath = session.Path.GetUnresolvedProviderPathFromPSPath(literalPath, out _providerInfo, out _driveInfo); _isUnresolved = true; _sourcePath = literalPath; }
internal static ADSessionInfo GetCurrentDriveSessionInfo(SessionState sessionState) { ADSessionInfo aDSessionInfo = null; ADDriveInfo current = sessionState.Drive.Current as ADDriveInfo; if (current != null) { aDSessionInfo = current.SessionInfo.Copy(); } return aDSessionInfo; }
internal ProviderInfo(SessionState sessionState, Type implementingType, string name, string description, string home, string helpFile, PSSnapInInfo psSnapIn) { _sessionState = sessionState; PSSnapIn = psSnapIn; Name = name; Description = description; Home = home; ImplementingType = implementingType; Capabilities = GetCapabilities(implementingType); HelpFile = helpFile; }
private ExecutionContext() { // TODO: create a "Global Session state" if (_sessionStateGlobal == null) _sessionStateGlobal = new SessionStateGlobal(this); // TODO: initialize all the default settings _pipelineStack = new Stack<Pipeline>(); _variables = new Dictionary<string, PSVariable>(StringComparer.CurrentCultureIgnoreCase); SessionState = new SessionState(_sessionStateGlobal); }
protected ProviderInfo(ProviderInfo providerInfo) { _sessionState = providerInfo._sessionState; PSSnapIn = providerInfo.PSSnapIn; Name = providerInfo.Name; Description = providerInfo.Description; Home = providerInfo.Home; ImplementingType = providerInfo.ImplementingType; Capabilities = providerInfo.Capabilities; HelpFile = providerInfo.HelpFile; }
internal PSModuleInfo(string path, string name, SessionState sessionState) { HasExplicitExports = false; Path = path; Name = name; SessionState = sessionState; ExportedVariables = new Dictionary<string, PSVariable>(); ExportedFunctions = new Dictionary<string, FunctionInfo>(); ExportedAliases = new Dictionary<string, AliasInfo>(); ExportedCmdlets = new Dictionary<string, CmdletInfo>(); }
private PSModuleInfo LoadModuleByPath(Path path) { // ALWAYS derive from global scope: the Scope parameter only defines where stuff is imported to var sessionState = new SessionState(_executionContext.SessionStateGlobal.RootSessionState); sessionState.IsScriptScope = true; sessionState.PSVariable.Set("PSScriptRoot", path.GetDirectory()); var moduleInfo = new PSModuleInfo(path, path.GetFileNameWithoutExtension(), sessionState); sessionState.SetModule(moduleInfo); LoadFileIntoModule(moduleInfo, path); return moduleInfo; }
/// <summary> /// Retrieve the dictonary with all connections from session /// </summary> /// <param name="sessionState"> /// </param> /// <returns> /// The <see cref="Dictionary"/>. /// </returns> private static Dictionary<string, ComputeServiceConnection> GetComputeServiceConnectionsFromSession( SessionState sessionState) { if (sessionState == null) throw new ArgumentNullException("sessionState"); PSVariable connectionsVariable = sessionState.PSVariable.Get(VariableNames.ComputeSessions); if (connectionsVariable == null) return null; var connections = (Dictionary<string, ComputeServiceConnection>) connectionsVariable.Value; return connections; }
private static IEnumerable<FunctionInfo> GetFunctions(SessionState sessionState) { try { var functionDrive = sessionState.InvokeProvider.Item.Get("function:"); return (Dictionary<string, FunctionInfo>.ValueCollection)functionDrive[0].BaseObject; } catch (DriveNotFoundException) { return new FunctionInfo[] { }; } }
//internal static PSObject GetPSObject(CmdletProvider provider, Item item) internal static PSObject GetPsObject(SessionState provider, Item item) { PSObject psobj = PSObject.AsPSObject(item); List<string> propertySet; if (allPropertySets.ContainsKey(item.TemplateID)) { propertySet = allPropertySets[item.TemplateID]; } else { item.Fields.ReadAll(); propertySet = new List<string>(item.Fields.Count); foreach (Field field in item.Fields) { if (field.Name != "ID") // don't map - native property { propertySet.Add(field.Name); } } allPropertySets.Add(item.TemplateID, propertySet); } foreach (string field in propertySet) { if (!String.IsNullOrEmpty(field)) { bool duplicate = psobj.Properties[field] == null; string getter = item.Fields[field] != null && item.Fields[field].TypeKey == "datetime" ? String.Format("[Sitecore.DateUtil]::IsoDateToDateTime($this[\"{0}\"])", field) : String.Format("$this[\"{0}\"]", field); string setter = String.Format("[{0}]::Modify($this, \"{1}\", $Args );", typeof (ItemShellExtensions).FullName, field); psobj.Properties.Add(new PSScriptProperty( duplicate ? field : String.Format("_{0}", field), provider.InvokeCommand.NewScriptBlock(getter), provider.InvokeCommand.NewScriptBlock(setter))); } } foreach (string customGetter in customGetters.Keys) { psobj.Properties.Add(new PSScriptProperty( customGetter, provider.InvokeCommand.NewScriptBlock(customGetters[customGetter]))); } return psobj; }
public static bool TryTranslatePSPath(SessionState session, string psPath, out string path, out bool? exists, out string errorMessage) { if (String.IsNullOrEmpty(psPath)) { throw new ArgumentException( String.Format( CultureInfo.CurrentCulture, CommonResources.Argument_Cannot_Be_Null_Or_Empty, "psPath")); } bool succeeded = false; path = null; exists = null; errorMessage = null; if (!session.Path.IsValid(psPath)) { errorMessage = String.Format( CultureInfo.CurrentCulture, Resources.Cmdlet_InvalidPathSyntax, psPath); } else { try { // we do not glob wildcards (literalpath.) exists = session.InvokeProvider.Item.Exists(psPath, force: false, literalPath: true); ProviderInfo provider; PSDriveInfo drive; // translate pspath, not trying to glob. path = session.Path.GetUnresolvedProviderPathFromPSPath(psPath, out provider, out drive); // ensure path is on the filesystem (not registry, certificate, variable etc.) if (provider.ImplementingType != typeof (FileSystemProvider)) { errorMessage = Resources.Cmdlet_InvalidProvider; } else { succeeded = true; } } catch (ProviderNotFoundException) { errorMessage = Resources.Cmdlet_InvalidProvider; } catch (DriveNotFoundException ex) { errorMessage = String.Format( CultureInfo.CurrentCulture, Resources.Cmdlet_InvalidPSDrive, ex.ItemName); } } return succeeded; }
internal static void ValidateAbsolutePath(SessionState state, string key, string[] paths, string filePath) { if (paths != null) { foreach (string str2 in paths) { string str; if (!state.Path.IsPSAbsolute(str2, out str)) { throw new InvalidOperationException(StringUtil.Format(RemotingErrorIdStrings.DISCPathsMustBeAbsolute, new object[] { key, str2, filePath })); } } } }
public static Endpoint TryGenerateEndpoint(this object obj, string id, System.Management.Automation.SessionState sessionState, object[] argumentList = null) { if (obj == null) { return(null); } if (obj is Endpoint endpoint) { endpoint.Name = id; return(endpoint); } if (obj is ScriptBlock scriptBlock) { return(GenerateCallback(scriptBlock, id, sessionState)); } throw new Exception($"Expected UDEndpoint or ScriptBlock but got {obj.GetType()}"); }
public static Endpoint GenerateCallback(this ScriptBlock endpoint, string id, PSCmdlet cmdlet, System.Management.Automation.SessionState sessionState, object[] argumentList = null) { if (endpoint == null) { return(null); } var logger = LogManager.GetLogger("CallbackCmdlet"); var callback = new Endpoint(); callback.Name = id; callback.ScriptBlock = endpoint; callback.Variables = new Dictionary <string, object>(); callback.ArgumentList = argumentList; try { var variables = endpoint.Ast.FindAll(x => x is VariableExpressionAst, true).Cast <VariableExpressionAst>().Select(m => m.VariablePath.ToString()); foreach (var variableName in variables) { var variable = sessionState.PSVariable.Get(variableName); if (variable != null && !variable.Options.HasFlag(ScopedItemOptions.Constant) && !variable.Options.HasFlag(ScopedItemOptions.ReadOnly)) { if (!callback.Variables.ContainsKey(variable.Name)) { callback.Variables.Add(variable.Name, sessionState.PSVariable.GetValue(variable.Name)); } } } } catch (Exception ex) { logger.Error(ex, "Failed to look up variables."); } callback.SessionId = sessionState.PSVariable.Get(Constants.SessionId)?.Value as string; callback.Page = sessionState.PSVariable.Get(Constants.UDPage)?.Value as Page; var hostState = cmdlet.GetHostState(); hostState.EndpointService.Register(callback); return(callback); }
internal PSModuleInfo CreateModule(string path, ExternalScriptInfo scriptInfo, IScriptExtent scriptPosition, SessionState ss, object privateData, params object[] arguments) { ArrayList list; return(this.CreateModuleImplementation(GetModuleName(path), path, scriptInfo, scriptPosition, ss, privateData, out list, arguments)); }
internal PathInfo(PSDriveInfo drive, string path, SessionState sessionState) { Drive = drive; Provider = drive == null ? null : drive.Provider; SetPathTypes(path, sessionState); }
internal ProviderInfo(SessionState sessionState, Type implementingType, string name, string description, string home, string helpFile, PSSnapInInfo psSnapIn) : this(sessionState, implementingType, name, description, home, helpFile, psSnapIn, null) { }
internal ChildItemCmdletProviderIntrinsics(SessionState sessionState) : base(sessionState) { }
private PSModuleInfo CreateModuleImplementation( string name, string path, object moduleCode, Token callerToken, SessionState ss, out ArrayList result, params object[] arguments) { if (ss == null) { ss = new SessionState(this._context.EngineSessionState, true, true); } SessionStateInternal engineSessionState = this._context.EngineSessionState; PSModuleInfo psModuleInfo = new PSModuleInfo(name, path, this._context, ss); ss.Internal.Module = psModuleInfo; bool flag = false; int num = 0; try { ArrayList resultList = (ArrayList)null; this._context.EngineSessionState = ss.Internal; this._context.EngineSessionState.SetVariableValue("PSScriptRoot", (object)Path.GetDirectoryName(path), CommandOrigin.Internal); switch (moduleCode) { case ExternalScriptInfo externalScriptInfo: this._context.EngineSessionState.SetVariableValue("MyInvocation", (object)new InvocationInfo((CommandInfo)externalScriptInfo, callerToken), CommandOrigin.Internal); scriptBlock = externalScriptInfo.ScriptBlock; break; case ScriptBlock scriptBlock: scriptBlock = scriptBlock.Clone(true); scriptBlock.SessionState = ss; break; case string _: scriptBlock = ScriptBlock.Create(this._context, (string)moduleCode); break; } if (scriptBlock == null) { throw ModuleIntrinsics.tracer.NewInvalidOperationException(); } scriptBlock.SessionStateInternal = ss.Internal; try { if (arguments == null) { scriptBlock.InvokeWithPipe(false, true, (object)AutomationNull.Value, (object)AutomationNull.Value, (object)AutomationNull.Value, (Pipe)null, ref resultList); } else { scriptBlock.InvokeWithPipe(false, true, (object)AutomationNull.Value, (object)AutomationNull.Value, (object)AutomationNull.Value, (Pipe)null, ref resultList, arguments); } } catch (ExitException ex) { num = (int)ex.Argument; flag = true; } result = resultList; } finally { this._context.EngineSessionState = engineSessionState; } if (flag) { this._context.SetVariable("global:LASTEXITCODE", (object)num); } return(psModuleInfo); }
/// <summary> /// Initializes a new instance of the LocationChangedEventArgs class. /// </summary> /// <param name="sessionState"> /// The public session state instance associated with this runspace. /// </param> /// <param name="oldPath"> /// The path we changed locations from. /// </param> /// <param name="newPath"> /// The path we change locations to. /// </param> internal LocationChangedEventArgs(SessionState sessionState, PathInfo oldPath, PathInfo newPath) { SessionState = sessionState; OldPath = oldPath; NewPath = newPath; }
internal DriveManagementIntrinsics(SessionState sessionState, SessionStateScope <PSDriveInfo> driveScope) { _sessionState = sessionState; _scope = driveScope; }
public bool MoveNext() { this._currentMatch = null; if (this.currentState == SearchState.SearchingAliases) { this._currentMatch = this.SearchForAliases(); if ((this._currentMatch != null) && SessionState.IsVisible(this._commandOrigin, this._currentMatch)) { return(true); } this._currentMatch = null; this.currentState = SearchState.SearchingFunctions; } if (this.currentState == SearchState.SearchingFunctions) { this._currentMatch = this.SearchForFunctions(); if (this._currentMatch != null) { return(true); } this.currentState = SearchState.SearchingCmdlets; } if (this.currentState == SearchState.SearchingCmdlets) { this._currentMatch = this.SearchForCmdlets(); if (this._currentMatch != null) { return(true); } this.currentState = SearchState.SearchingBuiltinScripts; } if (this.currentState == SearchState.SearchingBuiltinScripts) { this._currentMatch = this.SearchForBuiltinScripts(); if (this._currentMatch != null) { return(true); } this.currentState = SearchState.StartSearchingForExternalCommands; } if (this.currentState == SearchState.StartSearchingForExternalCommands) { if ((this.commandTypes & (CommandTypes.Application | CommandTypes.ExternalScript)) == 0) { return(false); } if ((this._commandOrigin == System.Management.Automation.CommandOrigin.Runspace) && (this.commandName.IndexOfAny(_pathSeparators) >= 0)) { bool flag = false; if (((this._context.EngineSessionState.Applications.Count == 1) && this._context.EngineSessionState.Applications[0].Equals("*", StringComparison.OrdinalIgnoreCase)) || ((this._context.EngineSessionState.Scripts.Count == 1) && this._context.EngineSessionState.Scripts[0].Equals("*", StringComparison.OrdinalIgnoreCase))) { flag = true; } else { foreach (string str in this._context.EngineSessionState.Applications) { if (checkPath(str, this.commandName)) { flag = true; break; } } if (!flag) { foreach (string str2 in this._context.EngineSessionState.Scripts) { if (checkPath(str2, this.commandName)) { flag = true; break; } } } } if (!flag) { return(false); } } this.currentState = SearchState.PowerShellPathResolution; this._currentMatch = this.ProcessBuiltinScriptState(); if (this._currentMatch != null) { this.currentState = SearchState.QualifiedFileSystemPath; return(true); } } if (this.currentState == SearchState.PowerShellPathResolution) { this.currentState = SearchState.QualifiedFileSystemPath; this._currentMatch = this.ProcessPathResolutionState(); if (this._currentMatch != null) { return(true); } } if ((this.currentState == SearchState.QualifiedFileSystemPath) || (this.currentState == SearchState.PathSearch)) { this._currentMatch = this.ProcessQualifiedFileSystemState(); if (this._currentMatch != null) { return(true); } } if (this.currentState == SearchState.PathSearch) { this.currentState = SearchState.PowerShellRelativePath; this._currentMatch = this.ProcessPathSearchState(); if (this._currentMatch != null) { return(true); } } return(false); }
internal PathIntrinsics(SessionState sessionState) { _sessionState = sessionState; _sessionStateGlobal = sessionState.SessionStateGlobal; }
internal ProviderHelpProvider(HelpSystem helpSystem) : base(helpSystem) { this._helpFiles = new Hashtable(); this._sessionState = helpSystem.ExecutionContext.SessionState; }
/// <summary> /// Constructor for the ProviderInfo class. /// </summary> /// /// <param name="sessionState"> /// The instance of session state that the provider is being added to. /// </param> /// /// <param name="implementingType"> /// The type that implements the provider /// </param> /// /// <param name="name"> /// The alternate name to use for the provider instead of the one specified /// in the .cmdletprovider file. /// </param> /// /// <param name="description"> /// The description of the provider. /// </param> /// /// <param name="home"> /// The home path for the provider. This must be an MSH path. /// </param> /// /// <param name="helpFile"> /// The help file for the provider. /// </param> /// /// <param name="psSnapIn"> /// The Snap-In for the provider. /// </param> /// /// <exception cref="ArgumentNullException"> /// If <paramref name="implementingType"/> or <paramref name="sessionState"/> is null. /// </exception> /// /// <exception cref="ArgumentException"> /// If <paramref name="name"/> is null or empty. /// </exception> /// internal ProviderInfo( SessionState sessionState, Type implementingType, string name, string description, string home, string helpFile, PSSnapInInfo psSnapIn) { // Verify parameters if (sessionState == null) { throw PSTraceSource.NewArgumentNullException("sessionState"); } if (implementingType == null) { throw PSTraceSource.NewArgumentNullException("implementingType"); } if (String.IsNullOrEmpty(name)) { throw PSTraceSource.NewArgumentException("name"); } if (String.IsNullOrEmpty(name)) { throw PSTraceSource.NewArgumentException("name"); } _sessionState = sessionState; Name = name; Description = description; Home = home; ImplementingType = implementingType; HelpFile = helpFile; PSSnapIn = psSnapIn; #if SUPPORTS_CMDLETPROVIDER_FILE LoadProviderFromPath(path); #endif // Create the hidden drive. The name doesn't really // matter since we are not adding this drive to a scope. _hiddenDrive = new PSDriveInfo( this.FullName, this, "", "", null); _hiddenDrive.Hidden = true; // TODO:PSL // this is probably not right here if (implementingType == typeof(Microsoft.PowerShell.Commands.FileSystemProvider) && !Platform.IsWindows) { VolumeSeparatedByColon = false; } }
internal PSModuleInfo(string path, ExecutionContext context, SessionState sessionState) : this((string)null, path, context, sessionState) { }
private PSModuleInfo CreateModuleImplementation(string name, string path, object moduleCode, IScriptExtent scriptPosition, SessionState ss, object privateData, out ArrayList result, params object[] arguments) { if (ss == null) { ss = new SessionState(this._context, true, true); } SessionStateInternal engineSessionState = this._context.EngineSessionState; PSModuleInfo info = new PSModuleInfo(name, path, this._context, ss); ss.Internal.Module = info; info.PrivateData = privateData; bool flag = false; int newValue = 0; try { ScriptBlock scriptBlock; this._context.EngineSessionState = ss.Internal; ExternalScriptInfo scriptCommandInfo = moduleCode as ExternalScriptInfo; if (scriptCommandInfo != null) { scriptBlock = scriptCommandInfo.ScriptBlock; this._context.Debugger.RegisterScriptFile(scriptCommandInfo); } else { scriptBlock = moduleCode as ScriptBlock; if (scriptBlock != null) { PSLanguageMode?languageMode = scriptBlock.LanguageMode; scriptBlock = scriptBlock.Clone(true); scriptBlock.LanguageMode = languageMode; scriptBlock.SessionState = ss; } else if (moduleCode is string) { scriptBlock = ScriptBlock.Create(this._context, (string)moduleCode); } } if (scriptBlock == null) { throw PSTraceSource.NewInvalidOperationException(); } scriptBlock.SessionStateInternal = ss.Internal; InvocationInfo invocationInfo = new InvocationInfo(scriptCommandInfo, scriptPosition); info._definitionExtent = scriptBlock.Ast.Extent; ArrayList resultList = new ArrayList(); try { Pipe outputPipe = new Pipe(resultList); scriptBlock.InvokeWithPipe(false, ScriptBlock.ErrorHandlingBehavior.WriteToCurrentErrorPipe, AutomationNull.Value, AutomationNull.Value, AutomationNull.Value, outputPipe, invocationInfo, arguments ?? new object[0]); } catch (ExitException exception) { newValue = (int)exception.Argument; flag = true; } result = resultList; } finally { this._context.EngineSessionState = engineSessionState; } if (flag) { this._context.SetVariable(SpecialVariables.LastExitCodeVarPath, newValue); } return(info); }
// creates a new scope and sets the parent session state's scope as predecessor internal SessionState(SessionState parentSession) : this(parentSession.SessionStateGlobal, parentSession) { }
internal PSModuleInfo CreateModule(string name, string path, ScriptBlock scriptBlock, SessionState ss, out ArrayList results, params object[] arguments) { return(this.CreateModuleImplementation(name, path, scriptBlock, null, ss, null, out results, arguments)); }
public static Endpoint GenerateCallback(this ScriptBlock endpoint, string id, System.Management.Automation.SessionState sessionState) { var logger = LogManager.GetLogger("CallbackCmdlet"); var callback = new Endpoint(); callback.Name = id; callback.ScriptBlock = endpoint; try { var variables = sessionState.InvokeCommand.InvokeScript("Get-Variable") .Select(m => m.BaseObject) .OfType <PSVariable>() .Where(m => !SkippedVariables.Any(x => x.Equals(m.Name, StringComparison.OrdinalIgnoreCase)) && m.GetType().Name != "SessionStateCapacityVariable" && m.GetType().Name != "NullVariable" && m.GetType().Name != "QuestionMarkVariable" && !((m.Options & ScopedItemOptions.AllScope) == ScopedItemOptions.AllScope || (m.Options & ScopedItemOptions.Constant) == ScopedItemOptions.Constant || (m.Options & ScopedItemOptions.ReadOnly) == ScopedItemOptions.ReadOnly)) .Select(m => new KeyValuePair <string, object>(m.Name, sessionState.PSVariable.GetValue(m.Name))) .ToArray(); // var property = sessionState.GetType().GetProperty("Internal", System.Reflection.BindingFlags.Static | System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance); // var internalVariables = property.GetValue(sessionState, null); // var variableTable = internalVariables.GetType().GetMethod("GetVariableTable", System.Reflection.BindingFlags.Static | System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance); // var variableTableInstance = variableTable.Invoke(internalVariables, null); callback.Variables = new Dictionary <string, object>(); foreach (var variable in variables) { if (callback.Variables.ContainsKey(variable.Key)) { callback.Variables[variable.Key] = variable.Value; } else { callback.Variables.Add(variable.Key, variable.Value); } } callback.Modules = sessionState.InvokeCommand.InvokeScript("Get-Module") .Select(m => m.BaseObject) .OfType <PSModuleInfo>() .Select(m => m.Path) .ToList(); } catch (Exception ex) { logger.Error(ex, "Failed to look up variables."); } callback.SessionId = sessionState.PSVariable.Get(Constants.SessionId)?.Value as string; var dashboardService = sessionState.PSVariable.Get("DashboardService")?.Value as DashboardService; if (dashboardService != null) { dashboardService.EndpointService.Register(callback); } return(callback); }
internal ProviderInfo(SessionState sessionState, Type implementingType, string name, string helpFile, PSSnapInInfo psSnapIn) : this(sessionState, implementingType, name, string.Empty, string.Empty, helpFile, psSnapIn) { }
public static Endpoint GenerateCallback(this ScriptBlock endpoint, string id, System.Management.Automation.SessionState sessionState, object[] argumentList = null) { if (endpoint == null) { return(null); } var logger = LogManager.GetLogger("CallbackCmdlet"); var callback = new Endpoint(); callback.Name = id; callback.ScriptBlock = endpoint; callback.Variables = new Dictionary <string, object>(); callback.ArgumentList = argumentList; try { var variables = endpoint.Ast.FindAll(x => x is VariableExpressionAst, true).Cast <VariableExpressionAst>().Select(m => m.VariablePath.ToString()); foreach (var variableName in variables) { var variable = sessionState.InvokeCommand.InvokeScript($"Get-Variable -Name '{variableName}' -ErrorAction SilentlyContinue").Select(m => m.BaseObject).OfType <PSVariable>().FirstOrDefault(); if (variable != null && !variable.Options.HasFlag(ScopedItemOptions.Constant) && !variable.Options.HasFlag(ScopedItemOptions.ReadOnly)) { if (!callback.Variables.ContainsKey(variable.Name)) { callback.Variables.Add(variable.Name, sessionState.PSVariable.GetValue(variable.Name)); } } } } catch (Exception ex) { logger.Error(ex, "Failed to look up variables."); } callback.SessionId = sessionState.PSVariable.Get(Constants.SessionId)?.Value as string; callback.Page = sessionState.PSVariable.Get(Constants.UDPage)?.Value as Page; var dashboardService = sessionState.PSVariable.Get("DashboardService")?.Value as DashboardService; if (dashboardService != null) { dashboardService.EndpointService.Register(callback); } return(callback); }
// creates a new scope and sets the parent session state's scope as predecessor internal SessionState(SessionState parentSession) : this(parentSession.SessionStateGlobal, parentSession._functionScope, parentSession._variableScope, parentSession._driveScope, parentSession._aliasScope) { }
internal AliasHelpProvider(HelpSystem helpSystem) : base(helpSystem) { this._sessionState = helpSystem.ExecutionContext.SessionState; this._commandDiscovery = helpSystem.ExecutionContext.CommandDiscovery; this._context = helpSystem.ExecutionContext; }
public bool MoveNext() { bool flag1 = false; this._currentMatch = (CommandInfo)null; if (this.currentState == CommandSearcher.SearchState.Reset) { this._currentMatch = this.ProcessResetState(); if (this._currentMatch != null && SessionState.IsVisible(this._commandOrigin, this._currentMatch)) { flag1 = true; goto label_48; } else { this.currentState = CommandSearcher.SearchState.AliasResolution; } } if (this.currentState == CommandSearcher.SearchState.AliasResolution) { this._currentMatch = this.ProcessAliasState(); if (this._currentMatch != null) { flag1 = true; goto label_48; } else { this.currentState = CommandSearcher.SearchState.FunctionResolution; } } if (this.currentState == CommandSearcher.SearchState.FunctionResolution) { this._currentMatch = this.ProcessFunctionState(); if (this._currentMatch != null) { flag1 = true; goto label_48; } else { this.currentState = CommandSearcher.SearchState.CmdletResolution; } } if (this.currentState == CommandSearcher.SearchState.CmdletResolution) { this._currentMatch = this.ProcessCmdletState(); if (this._currentMatch != null) { flag1 = true; goto label_48; } else { this.currentState = CommandSearcher.SearchState.BuiltinScriptResolution; } } if (this.currentState == CommandSearcher.SearchState.BuiltinScriptResolution) { if ((this.commandTypes & (CommandTypes.ExternalScript | CommandTypes.Application)) == (CommandTypes)0) { flag1 = false; goto label_48; } else { if (this._commandOrigin == CommandOrigin.Runspace && this.commandName.IndexOfAny(this._pathSeparators) >= 0) { bool flag2 = false; if (this._context.EngineSessionState.Applications.Count == 1 && this._context.EngineSessionState.Applications[0].Equals("*", StringComparison.OrdinalIgnoreCase) || this._context.EngineSessionState.Scripts.Count == 1 && this._context.EngineSessionState.Scripts[0].Equals("*", StringComparison.OrdinalIgnoreCase)) { flag2 = true; } else { foreach (string application in this._context.EngineSessionState.Applications) { if (this.checkPath(application, this.commandName)) { flag2 = true; break; } } if (!flag2) { foreach (string script in this._context.EngineSessionState.Scripts) { if (this.checkPath(script, this.commandName)) { flag2 = true; break; } } } } if (!flag2) { flag1 = false; goto label_48; } } this.currentState = CommandSearcher.SearchState.PowerShellPathResolution; this._currentMatch = this.ProcessBuiltinScriptState(); if (this._currentMatch != null) { this.currentState = CommandSearcher.SearchState.QualifiedFileSystemPath; flag1 = true; goto label_48; } } } if (this.currentState == CommandSearcher.SearchState.PowerShellPathResolution) { this.currentState = CommandSearcher.SearchState.QualifiedFileSystemPath; this._currentMatch = this.ProcessPathResolutionState(); if (this._currentMatch != null) { flag1 = true; goto label_48; } } if (this.currentState == CommandSearcher.SearchState.QualifiedFileSystemPath || this.currentState == CommandSearcher.SearchState.PathSearch) { this._currentMatch = this.ProcessQualifiedFileSystemState(); if (this._currentMatch != null) { flag1 = true; goto label_48; } } if (this.currentState == CommandSearcher.SearchState.PathSearch) { this.currentState = CommandSearcher.SearchState.PowerShellRelativePath; this._currentMatch = this.ProcessPathSearchState(); if (this._currentMatch != null) { flag1 = true; } } label_48: return(flag1); }