public VirtualDiskPSDriveInfo(PSDriveInfo toCopy, string root, VirtualDisk disk) : base(toCopy.Name, toCopy.Provider, root, toCopy.Description, toCopy.Credential) { _disk = disk; _volMgr = new VolumeManager(_disk); _fsCache = new Dictionary<string, DiscFileSystem>(); }
protected override PSDriveInfo NewDrive(PSDriveInfo drive) { if (drive == null) { WriteError(new ErrorRecord( new ArgumentNullException("drive"), "NullDrive", ErrorCategory.InvalidArgument, null)); return null; } SFGAO attributes; SFGAO isContainerQuery = SFGAO.Browsable | SFGAO.Folder; IdList pidl = GetPidlFromPath(drive.Root, isContainerQuery, out attributes); if ((attributes & isContainerQuery) == SFGAO.None) { WriteError(new ErrorRecord( new ArgumentException("drive.Root"), "NotAContainer", ErrorCategory.InvalidArgument, null)); return null; } return new ShellPSDriveInfo((ShellFolder)ShellItem.GetShellItem(pidl, new ShellItem.ShellItemKnownInfo() { LoadedAttributes = isContainerQuery, Attributes = attributes }), drive); }
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; }
protected override Collection<PSDriveInfo> InitializeDefaultDrives() { PSDriveInfo item = new PSDriveInfo("Env", ProviderInfo, string.Empty, string.Empty, null); Collection<PSDriveInfo> collection = new Collection<PSDriveInfo>(); collection.Add(item); return collection; }
/// <summary> /// Initializes the specified VFS drive. /// </summary> /// <param name="drive">The drive to initialize.</param> /// <returns>The <see cref="VfsDriveInfo"/> object which represents the initialized drive.</returns> protected override VfsDriveInfo InitializeNewDrive(PSDriveInfo drive) { if (drive is OrchardDriveInfo) { return (VfsDriveInfo)drive; } var driveParameters = (OrchardDriveParameters)DynamicParameters; if (driveParameters == null) { return null; } if (!OrchardPsSnapIn.VerifyOrchardDirectory(driveParameters.OrchardRoot)) { this.WriteError( ThrowHelper.InvalidRootPathException(driveParameters.OrchardRoot), ErrorIds.InvalidRootDirectory, ErrorCategory.InvalidArgument, drive); return null; } VfsDriveInfo orchardDrive = null; this.TryCritical( () => orchardDrive = this.InitializeOrchardDrive(drive, driveParameters), ErrorIds.OrchardInitFailed, ErrorCategory.OpenError); return orchardDrive; }
// NewDrive /// <summary> /// Removes a drive from the provider. /// </summary> /// <param name = "drive">The drive to remove.</param> /// <returns>The drive removed.</returns> protected override PSDriveInfo RemoveDrive(PSDriveInfo drive) { // check if drive object is null if (drive == null) { WriteError(new ErrorRecord( new ArgumentNullException("drive"), "NullDrive", ErrorCategory.InvalidArgument, drive) ); return null; } // dispose database on drive var ravenDBPSDriveInfo = drive as RavenDBPSDriveInfo; if (ravenDBPSDriveInfo == null) { return null; } ravenDBPSDriveInfo.Database.Dispose(); return ravenDBPSDriveInfo; }
protected virtual PSDriveInfo RemoveDrive(PSDriveInfo drive) { using (PSTransactionManager.GetEngineProtectionScope()) { return drive; } }
internal UpdatableHelpSystemDrive(PSCmdlet cmdlet, string path, PSCredential credential) { for (int i = 0; i < 6; i++) { this._driveName = Path.GetFileNameWithoutExtension(Path.GetRandomFileName()); this._cmdlet = cmdlet; if (path.EndsWith(@"\", StringComparison.OrdinalIgnoreCase) || path.EndsWith("/", StringComparison.OrdinalIgnoreCase)) { path = path.Remove(path.Length - 1); } PSDriveInfo atScope = cmdlet.SessionState.Drive.GetAtScope(this._driveName, "local"); if (atScope != null) { if (atScope.Root.Equals(path)) { return; } if (i < 5) { continue; } cmdlet.SessionState.Drive.Remove(this._driveName, true, "local"); } atScope = new PSDriveInfo(this._driveName, cmdlet.SessionState.Internal.GetSingleProvider("FileSystem"), path, string.Empty, credential); cmdlet.SessionState.Drive.New(atScope, "local"); return; } }
public DriveInfo(PSDriveInfo driveInfo, NewDriveParameters parameters) : base(driveInfo) { if (parameters != null) Directory = parameters.Directory; EnsureDescription(); }
internal PathInfo(PSDriveInfo drive, ProviderInfo provider, Path path, SessionState sessionState) { Drive = drive; Provider = provider; _path = path; _sessionState = sessionState; }
protected override void ProcessRecord() { var provider = SessionState.Provider.GetOne(PSProvider); var driveInfo = new PSDriveInfo(Name, provider, Root, Description, Credential); var realDrive = SessionState.Drive.New(driveInfo, Scope ?? "local", ProviderRuntime); WriteObject(realDrive); }
internal CmdletProviderContext(CmdletProviderContext contextToCopyFrom) { this.credentials = PSCredential.Empty; this._origin = CommandOrigin.Internal; this.accumulatedObjects = new Collection<PSObject>(); this.accumulatedErrorObjects = new Collection<ErrorRecord>(); this.stopReferrals = new Collection<CmdletProviderContext>(); if (contextToCopyFrom == null) { throw PSTraceSource.NewArgumentNullException("contextToCopyFrom"); } this.executionContext = contextToCopyFrom.ExecutionContext; this.command = contextToCopyFrom.command; if (contextToCopyFrom.Credential != null) { this.credentials = contextToCopyFrom.Credential; } this.drive = contextToCopyFrom.Drive; this.force = (bool) contextToCopyFrom.Force; this.CopyFilters(contextToCopyFrom); this.suppressWildcardExpansion = contextToCopyFrom.SuppressWildcardExpansion; this.dynamicParameters = contextToCopyFrom.DynamicParameters; this._origin = contextToCopyFrom._origin; this.stopping = contextToCopyFrom.Stopping; contextToCopyFrom.StopReferrals.Add(this); this.copiedContext = contextToCopyFrom; }
public int CompareTo(PSDriveInfo drive) { if (drive == null) { throw PSTraceSource.NewArgumentNullException("drive"); } return string.Compare(this.Name, drive.Name, true, CultureInfo.CurrentCulture); }
protected override Collection<PSDriveInfo> InitializeDefaultDrives() { PSDriveInfo drive = new PSDriveInfo("Objects", this.ProviderInfo, @"\", "Object Manager Root Directory", null); PSDriveInfo session = new PSDriveInfo("SessionObjects", this.ProviderInfo, String.Format(@"\Sessions\{0}\BaseNamedObjects", Process.GetCurrentProcess().SessionId), "Current Session Objects", null); Collection<PSDriveInfo> drives = new Collection<PSDriveInfo>() { drive, session }; return drives; }
internal PSDriveInfo NewDrive(PSDriveInfo drive, CmdletProviderContext context) { base.Context = context; if (((drive.Credential != null) && (drive.Credential != PSCredential.Empty)) && !CmdletProviderManagementIntrinsics.CheckProviderCapabilities(ProviderCapabilities.Credentials, base.ProviderInfo)) { throw PSTraceSource.NewNotSupportedException("SessionStateStrings", "NewDriveCredentials_NotSupported", new object[0]); } return this.NewDrive(drive); }
public static string MakePath(string path, PSDriveInfo drive) { string format = "{0}:" + '\\' + "{1}"; if (path.StartsWith("\\")) { format = "{0}:{1}"; } return string.Format(format, new object[] { drive.Name, path }); }
protected override PSDriveInfo NewDrive(PSDriveInfo drive) { if( drive is DTEDrive ) { return drive; } return new DTEDrive( drive, DTE2 ); }
protected override PSDriveInfo NewDrive(PSDriveInfo drive) { var sqlServerPsDriveInfo = new SqlServerPsDriveInfo(drive); if (!sqlServerPsDriveInfo.ItemExists(drive.Root)) { ThrowTerminatingError(new ErrorRecord(null, "BadServer", ErrorCategory.InvalidArgument, drive.Root)); } return sqlServerPsDriveInfo; }
protected PSDriveInfo(PSDriveInfo driveInfo) { Name = driveInfo.Name; Provider = driveInfo.Provider; Root = driveInfo.Root; Description = driveInfo.Description; Credential = driveInfo.Credential; CurrentLocation = driveInfo.CurrentLocation; }
public Context(CmdletProvider provider, string path, PSDriveInfo drive, IPathNodeProcessor pathProcessor, object dynamicParameters, Version topology, bool recurse) { _pathProcessor = pathProcessor; DynamicParameters = dynamicParameters; _provider = provider; _path = path; _drive = drive; _recurse = recurse; PathTopologyVersion = topology; }
public ProviderContext(CmdletProvider provider, string path, PSDriveInfo drive, IPathResolver pathProcessor, object dynamicParameters, Version topology, bool recurse) { this.pathProcessor = pathProcessor; DynamicParameters = dynamicParameters; this.provider = provider; this.path = path; this.drive = drive; this.recurse = recurse; PathTopologyVersion = topology; }
public SQLiteDrive(PSDriveInfo driveInfo, string connectionString, SQLiteProvider.DriveParams driveParams) : base(driveInfo) { _driveParams = driveParams ?? new SQLiteProvider.DriveParams(); _driveParams.ConnectionString = Regex.Replace(connectionString, @"^\[(.+)\].*", "$1" ); if( _driveParams.ConnectionString.ToLowerInvariant().Contains( InMemoryConnectionString ) ) { _driveParams.PersistentConnection = new SwitchParameter( true ); } }
protected override PSDriveInfo NewDrive(PSDriveInfo drive) { if (drive is GenericEntityContextDrive) { return drive; } var p = this.DynamicParameters as GenericEntityContextDrive.NewParams; return new GenericEntityContextDrive( p.ContextType, drive ); }
protected override PSDriveInfo NewDrive(PSDriveInfo drive) { var bipsDrive = drive as BipsDrive; if (null != bipsDrive) { return bipsDrive; } return new BipsDrive( drive ); }
protected override PSDriveInfo RemoveDrive(PSDriveInfo drive) { var testdrive = drive as TestDrive; if (testdrive == null) { throw new InvalidOperationException("Drive is not a TestDrive!"); } testdrive.IsRemoved = true; return testdrive; }
protected override PSDriveInfo NewDrive(PSDriveInfo drive) { if (drive is HuddleDocumentLibraryInfo) { return drive; } var libraryParams = this.DynamicParameters as DocumentLibraryParameters; return new HuddleDocumentLibraryInfo(driveInfo: drive, driveParams: libraryParams); }
protected override PSDriveInfo RemoveDrive(PSDriveInfo drive) { var ds = drive as DataSourceDrive; if( null != ds) { var sources = ds.DataSources.ToList(); sources.ForEach(d=>d.Dispose()); sources.ForEach( ds.Remove ); } return base.RemoveDrive(drive); }
protected override PSDriveInfo NewDrive(PSDriveInfo drive) { var uri = new Uri(drive.Root); /* drive.Root.Replace('/', '\\') */ var newDrive = new PSDriveInfo( drive.Name, drive.Provider, uri.Host, drive.Description, drive.Credential); return new ODataDrive(uri, newDrive ); }
protected override System.Collections.ObjectModel.Collection<System.Management.Automation.PSDriveInfo> InitializeDefaultDrives() { var driveInfo = new PSDriveInfo( "Triggers", ProviderInfo, "", "Data Source Triggers", null ); var drive = new TriggerDrive(driveInfo); return new Collection<PSDriveInfo> { drive }; }
internal Drive CreateCloudDrive(PSDriveInfo driveInfo, CloudDriveParameters parameters) { var rootName = CreateRootName(driveInfo); var asyncGateway = default(IAsyncCloudGateway); if (GatewayManager.TryGetAsyncCloudGatewayForSchema(rootName.Schema, out asyncGateway)) return new AsyncCloudDrive(CreateDriveInfo(driveInfo), rootName, asyncGateway, parameters); var gateway = default(ICloudGateway); if (GatewayManager.TryGetCloudGatewayForSchema(rootName.Schema, out gateway)) return new CloudDrive(CreateDriveInfo(driveInfo), rootName, gateway, parameters); throw new KeyNotFoundException(string.Format(CultureInfo.CurrentCulture, Resources.NoGatewayForSchema, rootName.Schema)); }
/// <summary> /// Compares this instance to the specified object. The object must be a PSDriveInfo. /// </summary> /// <param name="obj"> /// An object to compare. /// </param> /// <returns> /// A signed number indicating the relative values of this /// instance and object specified. /// </returns> /// <exception cref="ArgumentException"> /// If <paramref name="obj"/> is not a PSDriveInfo instance. /// </exception> public int CompareTo(object obj) { PSDriveInfo drive = obj as PSDriveInfo; if (drive == null) { ArgumentException e = PSTraceSource.NewArgumentException( nameof(obj), SessionStateStrings.OnlyAbleToComparePSDriveInfo); throw e; } return(CompareTo(drive)); }
internal CmdletProviderContext(PSCmdlet command, PSCredential credentials, PSDriveInfo drive) { this.command = command != null ? (Cmdlet)command : throw CmdletProviderContext.tracer.NewArgumentNullException(nameof(command)); this._origin = command.CommandOrigin; if (credentials != null) { this.credentials = credentials; } this.drive = drive; if (command.Host == null) { throw CmdletProviderContext.tracer.NewArgumentException("command.Host"); } this.executionContext = command.Context != null ? command.Context : throw CmdletProviderContext.tracer.NewArgumentException("command.Context"); this.streamObjects = true; this.streamErrors = true; }
protected ProviderInfo(ProviderInfo providerInfo) { this.helpFile = ""; if (providerInfo == null) { throw PSTraceSource.NewArgumentNullException("providerInfo"); } this.name = providerInfo.Name; this.implementingType = providerInfo.ImplementingType; this.capabilities = providerInfo.capabilities; this.description = providerInfo.description; this.hiddenDrive = providerInfo.hiddenDrive; this.home = providerInfo.home; this.helpFile = providerInfo.helpFile; this.pssnapin = providerInfo.pssnapin; this.sessionState = providerInfo.sessionState; }
/// <summary> /// Constructs an instance of the class using an existing reference /// as a template. /// </summary> /// <param name="providerInfo"> /// The provider information to copy to this instance. /// </param> /// <remarks> /// This constructor should be used by derived types to easily copying /// the base class members from an existing ProviderInfo. /// This is designed for use by a <see cref="System.Management.Automation.Provider.CmdletProvider"/> /// during calls to their <see cref="System.Management.Automation.Provider.CmdletProvider.Start(ProviderInfo)"/> method. /// </remarks> /// <exception cref="ArgumentNullException"> /// If <paramref name="providerInfo"/> is null. /// </exception> protected ProviderInfo(ProviderInfo providerInfo) { if (providerInfo == null) { throw PSTraceSource.NewArgumentNullException("providerInfo"); } Name = providerInfo.Name; ImplementingType = providerInfo.ImplementingType; _capabilities = providerInfo._capabilities; Description = providerInfo.Description; _hiddenDrive = providerInfo._hiddenDrive; Home = providerInfo.Home; HelpFile = providerInfo.HelpFile; PSSnapIn = providerInfo.PSSnapIn; _sessionState = providerInfo._sessionState; VolumeSeparatedByColon = providerInfo.VolumeSeparatedByColon; }
internal CmdletProviderContext(CmdletProviderContext contextToCopyFrom) { this.executionContext = contextToCopyFrom != null ? contextToCopyFrom.ExecutionContext : throw CmdletProviderContext.tracer.NewArgumentNullException(nameof(contextToCopyFrom)); this.command = contextToCopyFrom.command; if (contextToCopyFrom.Credential != null) { this.credentials = contextToCopyFrom.Credential; } this.drive = contextToCopyFrom.Drive; this.force = (bool)contextToCopyFrom.Force; this.CopyFilters(contextToCopyFrom); this.suppressWildcardExpansion = contextToCopyFrom.SuppressWildcardExpansion; this.dynamicParameters = contextToCopyFrom.DynamicParameters; this._origin = contextToCopyFrom._origin; this.stopping = contextToCopyFrom.Stopping; contextToCopyFrom.StopReferrals.Add(this); this.copiedContext = contextToCopyFrom; }
internal PathInfo(PSDriveInfo drive, ProviderInfo provider, string path, SessionState sessionState) { if (provider == null) { throw PSTraceSource.NewArgumentNullException("provider"); } if (path == null) { throw PSTraceSource.NewArgumentNullException("path"); } if (sessionState == null) { throw PSTraceSource.NewArgumentNullException("sessionState"); } this.drive = drive; this.provider = provider; this.path = path; this.sessionState = sessionState; }
internal CmdletProviderContext(System.Management.Automation.ExecutionContext executionContext) { this.credentials = PSCredential.Empty; this._origin = CommandOrigin.Internal; this.accumulatedObjects = new Collection <PSObject>(); this.accumulatedErrorObjects = new Collection <ErrorRecord>(); this.stopReferrals = new Collection <CmdletProviderContext>(); if (executionContext == null) { throw PSTraceSource.NewArgumentNullException("executionContext"); } this.executionContext = executionContext; this._origin = CommandOrigin.Internal; this.drive = executionContext.EngineSessionState.CurrentDrive; if ((executionContext.CurrentCommandProcessor != null) && (executionContext.CurrentCommandProcessor.Command is Cmdlet)) { this.command = (Cmdlet)executionContext.CurrentCommandProcessor.Command; } }
protected PSDriveInfo(PSDriveInfo driveInfo) { this.credentials = PSCredential.Empty; if (driveInfo == null) { throw PSTraceSource.NewArgumentNullException("driveInfo"); } this.name = driveInfo.Name; this.provider = driveInfo.Provider; this.credentials = driveInfo.Credential; this.currentWorkingDirectory = driveInfo.CurrentLocation; this.description = driveInfo.Description; this.driveBeingCreated = driveInfo.driveBeingCreated; this.hidden = driveInfo.hidden; this.isAutoMounted = driveInfo.isAutoMounted; this.root = driveInfo.root; this.persist = driveInfo.Persist; this.Trace(); }
/// <summary> /// Constructs a new instance of the PSDriveInfo using another PSDriveInfo /// as a template. /// </summary> /// <param name="driveInfo"> /// An existing PSDriveInfo object that should be copied to this instance. /// </param> /// <remarks> /// A protected constructor that derived classes can call with an instance /// of this class. This allows for easy creation of derived PSDriveInfo objects /// which can be created in CmdletProvider's NewDrive method using the PSDriveInfo /// that is passed in. /// </remarks> /// <exception cref="ArgumentNullException"> /// If <paramref name="PSDriveInfo"/> is null. /// </exception> protected PSDriveInfo(PSDriveInfo driveInfo) { if (driveInfo == null) { throw PSTraceSource.NewArgumentNullException(nameof(driveInfo)); } _name = driveInfo.Name; _provider = driveInfo.Provider; Credential = driveInfo.Credential; _currentWorkingDirectory = driveInfo.CurrentLocation; Description = driveInfo.Description; this.MaximumSize = driveInfo.MaximumSize; DriveBeingCreated = driveInfo.DriveBeingCreated; _hidden = driveInfo._hidden; IsAutoMounted = driveInfo.IsAutoMounted; _root = driveInfo._root; Persist = driveInfo.Persist; this.Trace(); }
public static bool FinDriveFromPath(string path, ProviderInfo provider, out PSDriveInfo foundDrive) { PSDriveInfo info = null; bool found = false; foreach (var drive in provider.Drives.OrderByDescending(x => x.Name.Length)) { if (path.StartsWith(drive.Name, StringComparison.OrdinalIgnoreCase)) { info = drive; found = true; break; } } if (info == null) { info = provider.HiddenDrive; } foundDrive = info; return(found); }
internal static string ResolveFilePath(string filePath, PSCmdlet command) { string str; try { ProviderInfo provider = (ProviderInfo)null; Collection <string> providerPathFromPsPath = command.SessionState.Path.GetResolvedProviderPathFromPSPath(filePath, out provider); if (!provider.NameEquals(command.Context.ProviderNames.FileSystem)) { PathUtils.ReportWrongProviderType((Cmdlet)command, provider.FullName); } if (providerPathFromPsPath.Count > 1) { PathUtils.ReportMultipleFilesNotSupported((Cmdlet)command); } if (providerPathFromPsPath.Count == 0) { PathUtils.ReportWildcardingFailure((Cmdlet)command, filePath); } str = providerPathFromPsPath[0]; } catch (ItemNotFoundException ex) { str = (string)null; } if (string.IsNullOrEmpty(str)) { CmdletProviderContext context = new CmdletProviderContext((Cmdlet)command); ProviderInfo provider = (ProviderInfo)null; PSDriveInfo drive = (PSDriveInfo)null; str = command.SessionState.Path.GetUnresolvedProviderPathFromPSPath(filePath, context, out provider, out drive); context.ThrowFirstErrorOrDoNothing(); if (!provider.NameEquals(command.Context.ProviderNames.FileSystem)) { PathUtils.ReportWrongProviderType((Cmdlet)command, provider.FullName); } } return(str); }
/// <summary> /// The constructor of the PathInfo object. /// </summary> /// <param name="drive"> /// The drive that contains the path /// </param> /// <param name="provider"> /// The provider that contains the path. /// </param> /// <param name="path"> /// The path this object represents. /// </param> /// <param name="sessionState"> /// The session state associated with the drive, provider, and path information. /// </param> /// <exception cref="ArgumentNullException"> /// If <paramref name="drive"/>, <paramref name="provider"/>, /// <paramref name="path"/>, or <paramref name="sessionState"/> is null. /// </exception> internal PathInfo(PSDriveInfo drive, ProviderInfo provider, string path, SessionState sessionState) { if (provider == null) { throw PSTraceSource.NewArgumentNullException(nameof(provider)); } if (path == null) { throw PSTraceSource.NewArgumentNullException(nameof(path)); } if (sessionState == null) { throw PSTraceSource.NewArgumentNullException(nameof(sessionState)); } _drive = drive; _provider = provider; _path = path; _sessionState = sessionState; }
internal PSDriveInfo GetDrive(string name) { if (name == null) { throw PSTraceSource.NewArgumentNullException("name"); } PSDriveInfo info = null; if (OSHelper.IsUnix && name == "Microsoft.PowerShell.Core\\FileSystem") { name = "/"; } if (this.GetDrives().ContainsKey(name)) { return(this.GetDrives()[name]); } if (this.GetAutomountedDrives().ContainsKey(name)) { info = this.GetAutomountedDrives()[name]; } return(info); }
internal void RemoveDrive(PSDriveInfo drive) { if (drive == null) { throw PSTraceSource.NewArgumentNullException("drive"); } if (this._drives != null) { if (this.GetDrives().ContainsKey(drive.Name)) { this.GetDrives().Remove(drive.Name); } else if (this.GetAutomountedDrives().ContainsKey(drive.Name)) { this.GetAutomountedDrives()[drive.Name].IsAutoMountedManuallyRemoved = true; if (drive.IsNetworkDrive) { this.GetAutomountedDrives().Remove(drive.Name); } } } }
/// <summary> /// Constructs the context under which the core command providers /// operate. /// </summary> /// <param name="command"> /// The command object that is running. /// </param> /// <param name="credentials"> /// The credentials the core command provider should use. /// </param> /// <param name="drive"> /// The drive under which this context should operate. /// </param> /// <exception cref="ArgumentNullException"> /// If <paramref name="command"/> is null. /// </exception> /// <exception cref="ArgumentException"> /// If <paramref name="command"/> contains a null Host or Context reference. /// </exception> internal CmdletProviderContext( PSCmdlet command, PSCredential credentials, PSDriveInfo drive) { // verify the command parameter if (command == null) { throw PSTraceSource.NewArgumentNullException(nameof(command)); } _command = command; Origin = command.CommandOrigin; if (credentials != null) { _credentials = credentials; } Drive = drive; if (command.Host == null) { throw PSTraceSource.NewArgumentException("command.Host"); } if (command.Context == null) { throw PSTraceSource.NewArgumentException("command.Context"); } ExecutionContext = command.Context; // Stream will default to true because command methods will be used. PassThru = true; _streamErrors = true; }
public int CompareTo(PSDriveInfo drive) { return(string.Compare(Name, drive.Name, true, CultureInfo.CurrentUICulture)); }
public bool Equals(PSDriveInfo drive) { return(CompareTo(drive) == 0); }
/// <summary> /// Get provider specific help info. /// </summary> internal MamlCommandHelpInfo GetProviderSpecificHelpInfo(string helpItemName) { if (InternalTestHooks.BypassOnlineHelpRetrieval) { // By returning null, we force get-help to return generic help // which includes a helpUri that points to the fwlink defined in the cmdlet code. return(null); } // Get the provider. ProviderInfo providerInfo = null; PSDriveInfo driveInfo = null; string resolvedProviderPath = null; CmdletProviderContext cmdletProviderContext = new CmdletProviderContext(_executionContext); try { string psPath = _requestedPath; if (string.IsNullOrEmpty(_requestedPath)) { psPath = _pathIntrinsics.CurrentLocation.Path; } resolvedProviderPath = _executionContext.LocationGlobber.GetProviderPath( psPath, cmdletProviderContext, out providerInfo, out driveInfo); } // ignore exceptions caused by provider resolution catch (ArgumentNullException) { } catch (ProviderNotFoundException) { } catch (DriveNotFoundException) { } catch (ProviderInvocationException) { } catch (NotSupportedException) { } catch (InvalidOperationException) { } catch (ItemNotFoundException) { } if (providerInfo == null) { return(null); } // Does the provider know how to generate MAML. CmdletProvider cmdletProvider = providerInfo.CreateInstance(); ICmdletProviderSupportsHelp provider = cmdletProvider as ICmdletProviderSupportsHelp; // Under JEA sessions the resolvedProviderPath will be null, we should allow get-help to continue. if (provider == null) { return(null); } bool isJEASession = false; if (this._executionContext.InitialSessionState != null && this._executionContext.InitialSessionState.Providers != null && providerInfo != null) { foreach ( Runspaces.SessionStateProviderEntry sessionStateProvider in this._executionContext.InitialSessionState.Providers[providerInfo.Name]) { if (sessionStateProvider.Visibility == SessionStateEntryVisibility.Private) { isJEASession = true; break; } } } if (resolvedProviderPath == null) { if (isJEASession) { return(null); } else { throw new ItemNotFoundException(_requestedPath, "PathNotFound", SessionStateStrings.PathNotFound); } } // ok we have path and valid provider that supplys content..initialize the provider // and get the help content for the path. cmdletProvider.Start(providerInfo, cmdletProviderContext); // There should be exactly one resolved path. string providerPath = resolvedProviderPath; // Get the MAML help info. Don't catch exceptions thrown by provider. string mamlXmlString = provider.GetHelpMaml(helpItemName, providerPath); if (string.IsNullOrEmpty(mamlXmlString)) { return(null); } // process the MAML content only if it is non-empty. XmlDocument mamlDoc = InternalDeserializer.LoadUnsafeXmlDocument( mamlXmlString, false, /* ignore whitespace, comments, etc. */ null); /* default maxCharactersInDocument */ MamlCommandHelpInfo providerSpecificHelpInfo = MamlCommandHelpInfo.Load(mamlDoc.DocumentElement, HelpCategory.Provider); return(providerSpecificHelpInfo); }
internal MamlCommandHelpInfo GetProviderSpecificHelpInfo(string helpItemName) { ProviderInfo info = null; PSDriveInfo drive = null; string str = null; CmdletProviderContext context = new CmdletProviderContext(this._executionContext); try { string str2 = this._requestedPath; if (string.IsNullOrEmpty(this._requestedPath)) { str2 = this._pathIntrinsics.CurrentLocation.Path; } str = this._executionContext.LocationGlobber.GetProviderPath(str2, context, out info, out drive); } catch (ArgumentNullException) { } catch (ProviderNotFoundException) { } catch (DriveNotFoundException) { } catch (ProviderInvocationException) { } catch (NotSupportedException) { } catch (InvalidOperationException) { } catch (ItemNotFoundException) { } if (info == null) { return(null); } CmdletProvider provider = info.CreateInstance(); ICmdletProviderSupportsHelp help = provider as ICmdletProviderSupportsHelp; if (help == null) { return(null); } if (str == null) { throw new ItemNotFoundException(this._requestedPath, "PathNotFound", SessionStateStrings.PathNotFound); } provider.Start(info, context); string path = str; string helpMaml = help.GetHelpMaml(helpItemName, path); if (string.IsNullOrEmpty(helpMaml)) { return(null); } return(MamlCommandHelpInfo.Load(InternalDeserializer.LoadUnsafeXmlDocument(helpMaml, false, null).DocumentElement, HelpCategory.Provider)); }
/// <summary> /// Changes the current working directory to the path specified. /// </summary> /// <param name="path"> /// The path of the new current working directory. /// </param> /// <param name="context"> /// The context the provider uses when performing the operation. /// </param> /// <param name="literalPath"> /// Indicate if the path is a literal path. /// </param> /// <returns> /// The PathInfo object representing the path of the location /// that was set. /// </returns> /// <exception cref="ArgumentNullException"> /// If <paramref name="path"/> is null. /// </exception> /// <exception cref="ArgumentException"> /// If <paramref name="path"/> does not exist, is not a container, or /// resolved to multiple containers. /// </exception> /// <exception cref="ProviderNotFoundException"> /// If <paramref name="path"/> refers to a provider that does not exist. /// </exception> /// <exception cref="DriveNotFoundException"> /// If <paramref name="path"/> refers to a drive that does not exist. /// </exception> /// <exception cref="ProviderInvocationException"> /// If the provider associated with <paramref name="path"/> threw an /// exception. /// </exception> /// <exception cref="ItemNotFoundException"> /// If the <paramref name="path"/> could not be resolved. /// </exception> internal PathInfo SetLocation(string path, CmdletProviderContext context, bool literalPath) { if (path == null) { throw PSTraceSource.NewArgumentNullException("path"); } PathInfo current = CurrentLocation; string originalPath = path; string driveName = null; ProviderInfo provider = null; string providerId = null; switch (originalPath) { case string originalPathSwitch when !literalPath && originalPathSwitch.Equals("-", StringComparison.Ordinal): if (_setLocationHistory.UndoCount <= 0) { throw new InvalidOperationException(SessionStateStrings.LocationUndoStackIsEmpty); } path = _setLocationHistory.Undo(this.CurrentLocation).Path; break; case string originalPathSwitch when !literalPath && originalPathSwitch.Equals("+", StringComparison.Ordinal): if (_setLocationHistory.RedoCount <= 0) { throw new InvalidOperationException(SessionStateStrings.LocationRedoStackIsEmpty); } path = _setLocationHistory.Redo(this.CurrentLocation).Path; break; default: var pushPathInfo = GetNewPushPathInfo(); _setLocationHistory.Push(pushPathInfo); break; } PSDriveInfo previousWorkingDrive = CurrentDrive; // First check to see if the path is a home path if (LocationGlobber.IsHomePath(path)) { path = Globber.GetHomeRelativePath(path); } if (LocationGlobber.IsProviderDirectPath(path)) { // The path is a provider-direct path so use the current // provider and its hidden drive but don't modify the path // at all. provider = CurrentLocation.Provider; CurrentDrive = provider.HiddenDrive; } else if (LocationGlobber.IsProviderQualifiedPath(path, out providerId)) { provider = GetSingleProvider(providerId); CurrentDrive = provider.HiddenDrive; } else { // See if the path is a relative or absolute // path. if (Globber.IsAbsolutePath(path, out driveName)) { // Since the path is an absolute path // we need to change the current working // drive PSDriveInfo newWorkingDrive = GetDrive(driveName); CurrentDrive = newWorkingDrive; // If the path is simply a colon-terminated drive, // not a slash-terminated path to the root of a drive, // set the path to the current working directory of that drive. string colonTerminatedVolume = CurrentDrive.Name + ':'; if (CurrentDrive.VolumeSeparatedByColon && (path.Length == colonTerminatedVolume.Length)) { path = Path.Combine(colonTerminatedVolume + Path.DirectorySeparatorChar, CurrentDrive.CurrentLocation); } // Now that the current working drive is set, // process the rest of the path as a relative path. } } if (context == null) { context = new CmdletProviderContext(this.ExecutionContext); } if (CurrentDrive != null) { context.Drive = CurrentDrive; } CmdletProvider providerInstance = null; Collection <PathInfo> workingPath = null; try { workingPath = Globber.GetGlobbedMonadPathsFromMonadPath( path, false, context, out providerInstance); } catch (LoopFlowException) { throw; } catch (PipelineStoppedException) { throw; } catch (ActionPreferenceStopException) { throw; } catch (Exception) { // Reset the drive to the previous drive and // then rethrow the error CurrentDrive = previousWorkingDrive; throw; } if (workingPath.Count == 0) { // Set the current working drive back to the previous // one in case it was changed. CurrentDrive = previousWorkingDrive; throw new ItemNotFoundException( path, "PathNotFound", SessionStateStrings.PathNotFound); } // We allow globbing the location as long as it only resolves a single container. bool foundContainer = false; bool pathIsContainer = false; bool pathIsProviderQualifiedPath = false; bool currentPathisProviderQualifiedPath = false; for (int index = 0; index < workingPath.Count; ++index) { CmdletProviderContext normalizePathContext = new CmdletProviderContext(context); PathInfo resolvedPath = workingPath[index]; string currentPath = path; try { string providerName = null; currentPathisProviderQualifiedPath = LocationGlobber.IsProviderQualifiedPath(resolvedPath.Path, out providerName); if (currentPathisProviderQualifiedPath) { // The path should be the provider-qualified path without the provider ID // or :: string providerInternalPath = LocationGlobber.RemoveProviderQualifier(resolvedPath.Path); try { currentPath = NormalizeRelativePath(GetSingleProvider(providerName), providerInternalPath, string.Empty, normalizePathContext); } catch (NotSupportedException) { // Since the provider does not support normalizing the path, just // use the path we currently have. } catch (LoopFlowException) { throw; } catch (PipelineStoppedException) { throw; } catch (ActionPreferenceStopException) { throw; } catch (Exception) { // Reset the drive to the previous drive and // then rethrow the error CurrentDrive = previousWorkingDrive; throw; } } else { try { currentPath = NormalizeRelativePath(resolvedPath.Path, CurrentDrive.Root, normalizePathContext); } catch (NotSupportedException) { // Since the provider does not support normalizing the path, just // use the path we currently have. } catch (LoopFlowException) { throw; } catch (PipelineStoppedException) { throw; } catch (ActionPreferenceStopException) { throw; } catch (Exception) { // Reset the drive to the previous drive and // then rethrow the error CurrentDrive = previousWorkingDrive; throw; } } // Now see if there was errors while normalizing the path if (normalizePathContext.HasErrors()) { // Set the current working drive back to the previous // one in case it was changed. CurrentDrive = previousWorkingDrive; normalizePathContext.ThrowFirstErrorOrDoNothing(); } } finally { normalizePathContext.RemoveStopReferral(); } bool isContainer = false; CmdletProviderContext itemContainerContext = new CmdletProviderContext(context); itemContainerContext.SuppressWildcardExpansion = true; try { isContainer = IsItemContainer( resolvedPath.Path, itemContainerContext); if (itemContainerContext.HasErrors()) { // Set the current working drive back to the previous // one in case it was changed. CurrentDrive = previousWorkingDrive; itemContainerContext.ThrowFirstErrorOrDoNothing(); } } catch (NotSupportedException) { if (currentPath.Length == 0) { // Treat this as a container because providers that only // support the ContainerCmdletProvider interface are really // containers at their root. isContainer = true; } } finally { itemContainerContext.RemoveStopReferral(); } if (isContainer) { if (foundContainer) { // The path resolved to more than one container // Set the current working drive back to the previous // one in case it was changed. CurrentDrive = previousWorkingDrive; throw PSTraceSource.NewArgumentException( "path", SessionStateStrings.PathResolvedToMultiple, originalPath); } else { // Set the path to use path = currentPath; // Mark it as a container pathIsContainer = true; // Mark whether or not it was provider-qualified pathIsProviderQualifiedPath = currentPathisProviderQualifiedPath; // Mark that we have already found one container. Finding additional // should be an error foundContainer = true; } } } if (pathIsContainer) { // Remove the root slash since it is implied that the // current working directory is relative to the root. if (!LocationGlobber.IsProviderDirectPath(path) && path.StartsWith(StringLiterals.DefaultPathSeparator) && !pathIsProviderQualifiedPath) { path = path.Substring(1); } s_tracer.WriteLine( "New working path = {0}", path); CurrentDrive.CurrentLocation = path; } else { // Set the current working drive back to the previous // one in case it was changed. CurrentDrive = previousWorkingDrive; throw new ItemNotFoundException( originalPath, "PathNotFound", SessionStateStrings.PathNotFound); } // Now make sure the current drive is set in the provider's // current working drive hashtable ProvidersCurrentWorkingDrive[CurrentDrive.Provider] = CurrentDrive; // Set the $PWD variable to the new location this.SetVariable(SpecialVariables.PWDVarPath, this.CurrentLocation, false, true, CommandOrigin.Internal); // If an action has been defined for location changes, invoke it now. if (PublicSessionState.InvokeCommand.LocationChangedAction != null) { var eventArgs = new LocationChangedEventArgs(PublicSessionState, current, CurrentLocation); PublicSessionState.InvokeCommand.LocationChangedAction.Invoke(ExecutionContext.CurrentRunspace, eventArgs); s_tracer.WriteLine("Invoked LocationChangedAction"); } return(this.CurrentLocation); }
/// <summary> /// Determines if the specified path is the current working directory /// or a parent of the current working directory. /// </summary> /// <param name="path"> /// A monad namespace absolute or relative path. /// </param> /// <param name="context"> /// The context the provider uses when performing the operation. /// </param> /// <returns> /// true, if the path is the current working directory or a parent of the current /// working directory. false, otherwise. /// </returns> /// <exception cref="ArgumentNullException"> /// If <paramref name="path"/> is null. /// </exception> /// <exception cref="ProviderNotFoundException"> /// If the path is a provider-qualified path for a provider that is /// not loaded into the system. /// </exception> /// <exception cref="DriveNotFoundException"> /// If the <paramref name="path"/> refers to a drive that could not be found. /// </exception> /// <exception cref="ProviderInvocationException"> /// If the provider used to build the path threw an exception. /// </exception> /// <exception cref="NotSupportedException"> /// If the provider that the <paramref name="path"/> represents is not a NavigationCmdletProvider /// or ContainerCmdletProvider. /// </exception> /// <exception cref="InvalidOperationException"> /// If the <paramref name="path"/> starts with "~" and the home location is not set for /// the provider. /// </exception> /// <exception cref="ProviderInvocationException"> /// If the provider specified by <paramref name="providerId"/> threw an /// exception when its GetParentPath or MakePath was called while /// processing the <paramref name="path"/>. /// </exception> internal bool IsCurrentLocationOrAncestor(string path, CmdletProviderContext context) { bool result = false; if (path == null) { throw PSTraceSource.NewArgumentNullException("path"); } PSDriveInfo drive = null; ProviderInfo provider = null; string providerSpecificPath = Globber.GetProviderPath( path, context, out provider, out drive); if (drive != null) { s_tracer.WriteLine("Tracing drive"); drive.Trace(); } Dbg.Diagnostics.Assert( providerSpecificPath != null, "There should always be a way to generate a provider path for a " + "given path"); if (drive != null) { context.Drive = drive; } // Check to see if the path that was specified is within the current // working drive if (drive == CurrentDrive) { // The path needs to be normalized to get rid of relative path tokens // so they don't interfere with our path comparisons below CmdletProviderContext normalizePathContext = new CmdletProviderContext(context); try { providerSpecificPath = NormalizeRelativePath(path, null, normalizePathContext); } catch (NotSupportedException) { // Since the provider does not support normalizing the path, just // use the path we currently have. } catch (LoopFlowException) { throw; } catch (PipelineStoppedException) { throw; } catch (ActionPreferenceStopException) { throw; } finally { normalizePathContext.RemoveStopReferral(); } if (normalizePathContext.HasErrors()) { normalizePathContext.ThrowFirstErrorOrDoNothing(); } s_tracer.WriteLine("Provider path = {0}", providerSpecificPath); // Get the current working directory provider specific path PSDriveInfo currentWorkingDrive = null; ProviderInfo currentDriveProvider = null; string currentWorkingPath = Globber.GetProviderPath( ".", context, out currentDriveProvider, out currentWorkingDrive); Dbg.Diagnostics.Assert( currentWorkingDrive == CurrentDrive, "The current working drive should be the CurrentDrive."); s_tracer.WriteLine( "Current working path = {0}", currentWorkingPath); // See if the path is the current working directory or a parent // of the current working directory s_tracer.WriteLine( "Comparing {0} to {1}", providerSpecificPath, currentWorkingPath); if (String.Compare(providerSpecificPath, currentWorkingPath, StringComparison.CurrentCultureIgnoreCase) == 0) { // The path is the current working directory so // return true s_tracer.WriteLine("The path is the current working directory"); result = true; } else { // Check to see if the specified path is a parent // of the current working directory string lockedDirectory = currentWorkingPath; while (lockedDirectory.Length > 0) { // We need to allow the provider to go as far up the tree // as it can even if that means it has to traverse higher // than the mount point for this drive. That is // why we are passing the empty string as the root here. lockedDirectory = GetParentPath( drive.Provider, lockedDirectory, String.Empty, context); s_tracer.WriteLine( "Comparing {0} to {1}", lockedDirectory, providerSpecificPath); if (String.Compare(lockedDirectory, providerSpecificPath, StringComparison.CurrentCultureIgnoreCase) == 0) { // The path is a parent of the current working // directory s_tracer.WriteLine( "The path is a parent of the current working directory: {0}", lockedDirectory); result = true; break; } } } } else { s_tracer.WriteLine("Drives are not the same"); } return(result); }
internal PathInfo(PSDriveInfo drive, string path, SessionState sessionState) { Drive = drive; Provider = drive == null ? null : drive.Provider; SetPathTypes(path, sessionState); }
public string GetUnresolvedProviderPathFromPSPath(string path, out ProviderInfo provider, out PSDriveInfo drive) { throw new NotImplementedException(); }
} // SetLocation /// <summary> /// Changes the current working directory to the path specified /// </summary> /// /// <param name="path"> /// The path of the new current working directory /// </param> /// /// <param name="context"> /// The context the provider uses when performing the operation. /// </param> /// /// <returns> /// The PathInfo object representing the path of the location /// that was set. /// </returns> /// /// <exception cref="ArgumentNullException"> /// If <paramref name="path"/> is null. /// </exception> /// /// <exception cref="ArgumentException"> /// If <paramref name="path"/> does not exist, is not a container, or /// resolved to multiple containers. /// </exception> /// /// <exception cref="ProviderNotFoundException"> /// If <paramref name="path"/> refers to a provider that does not exist. /// </exception> /// /// <exception cref="DriveNotFoundException"> /// If <paramref name="path"/> refers to a drive that does not exist. /// </exception> /// /// <exception cref="ProviderInvocationException"> /// If the provider associated with <paramref name="path"/> threw an /// exception. /// </exception> /// /// <exception cref="ItemNotFoundException"> /// If the <paramref name="path"/> could not be resolved. /// </exception> /// internal PathInfo SetLocation(string path, CmdletProviderContext context) { if (path == null) { throw PSTraceSource.NewArgumentNullException("path"); } string originalPath = path; string driveName = null; ProviderInfo provider = null; string providerId = null; PSDriveInfo previousWorkingDrive = CurrentDrive; // First check to see if the path is a home path if (LocationGlobber.IsHomePath(path)) { path = Globber.GetHomeRelativePath(path); } if (LocationGlobber.IsProviderDirectPath(path)) { // The path is a provider-direct path so use the current // provider and its hidden drive but don't modify the path // at all. provider = CurrentLocation.Provider; CurrentDrive = provider.HiddenDrive; } else if (LocationGlobber.IsProviderQualifiedPath(path, out providerId)) { provider = GetSingleProvider(providerId); CurrentDrive = provider.HiddenDrive; } else { // See if the path is a relative or absolute // path. if (Globber.IsAbsolutePath(path, out driveName)) { // Since the path is an absolute path // we need to change the current working // drive PSDriveInfo newWorkingDrive = GetDrive(driveName); CurrentDrive = newWorkingDrive; // Now that the current working drive is set, // process the rest of the path as a relative path. } } if (context == null) { context = new CmdletProviderContext(this.ExecutionContext); } if (CurrentDrive != null) { context.Drive = CurrentDrive; } CmdletProvider providerInstance = null; Collection <PathInfo> workingPath = null; try { workingPath = Globber.GetGlobbedMonadPathsFromMonadPath( path, false, context, out providerInstance); } catch (LoopFlowException) { throw; } catch (PipelineStoppedException) { throw; } catch (ActionPreferenceStopException) { throw; } catch (Exception) // Catch-all OK, 3rd party callout { // Reset the drive to the previous drive and // then rethrow the error CurrentDrive = previousWorkingDrive; throw; } if (workingPath.Count == 0) { // Set the current working drive back to the previous // one in case it was changed. CurrentDrive = previousWorkingDrive; throw new ItemNotFoundException( path, "PathNotFound", SessionStateStrings.PathNotFound); } // We allow globbing the location as long as it only resolves a single container. bool foundContainer = false; bool pathIsContainer = false; bool pathIsProviderQualifiedPath = false; bool currentPathisProviderQualifiedPath = false; for (int index = 0; index < workingPath.Count; ++index) { CmdletProviderContext normalizePathContext = new CmdletProviderContext(context); PathInfo resolvedPath = workingPath[index]; string currentPath = path; try { string providerName = null; currentPathisProviderQualifiedPath = LocationGlobber.IsProviderQualifiedPath(resolvedPath.Path, out providerName); if (currentPathisProviderQualifiedPath) { // The path should be the provider-qualified path without the provider ID // or :: string providerInternalPath = LocationGlobber.RemoveProviderQualifier(resolvedPath.Path); try { currentPath = NormalizeRelativePath(GetSingleProvider(providerName), providerInternalPath, String.Empty, normalizePathContext); } catch (NotSupportedException) { // Since the provider does not support normalizing the path, just // use the path we currently have. } catch (LoopFlowException) { throw; } catch (PipelineStoppedException) { throw; } catch (ActionPreferenceStopException) { throw; } catch (Exception) // Catch-all OK, 3rd party callout { // Reset the drive to the previous drive and // then rethrow the error CurrentDrive = previousWorkingDrive; throw; } } else { try { currentPath = NormalizeRelativePath(resolvedPath.Path, CurrentDrive.Root, normalizePathContext); } catch (NotSupportedException) { // Since the provider does not support normalizing the path, just // use the path we currently have. } catch (LoopFlowException) { throw; } catch (PipelineStoppedException) { throw; } catch (ActionPreferenceStopException) { throw; } catch (Exception) // Catch-all OK, 3rd party callout { // Reset the drive to the previous drive and // then rethrow the error CurrentDrive = previousWorkingDrive; throw; } } // Now see if there was errors while normalizing the path if (normalizePathContext.HasErrors()) { // Set the current working drive back to the previous // one in case it was changed. CurrentDrive = previousWorkingDrive; normalizePathContext.ThrowFirstErrorOrDoNothing(); } } finally { normalizePathContext.RemoveStopReferral(); } // Check to see if the path is a container bool isContainer = false; CmdletProviderContext itemContainerContext = new CmdletProviderContext(context); itemContainerContext.SuppressWildcardExpansion = true; try { isContainer = IsItemContainer( resolvedPath.Path, itemContainerContext); if (itemContainerContext.HasErrors()) { // Set the current working drive back to the previous // one in case it was changed. CurrentDrive = previousWorkingDrive; itemContainerContext.ThrowFirstErrorOrDoNothing(); } } catch (NotSupportedException) { if (currentPath.Length == 0) { // Treat this as a container because providers that only // support the ContainerCmdletProvider interface are really // containers at their root. isContainer = true; } } finally { itemContainerContext.RemoveStopReferral(); } if (isContainer) { if (foundContainer) { // The path resolved to more than one container // Set the current working drive back to the previous // one in case it was changed. CurrentDrive = previousWorkingDrive; throw PSTraceSource.NewArgumentException( "path", SessionStateStrings.PathResolvedToMultiple, originalPath); } else { // Set the path to use path = currentPath; // Mark it as a container pathIsContainer = true; // Mark whether or not it was provider-qualified pathIsProviderQualifiedPath = currentPathisProviderQualifiedPath; // Mark that we have already found one container. Finding additional // should be an error foundContainer = true; } } } if (pathIsContainer) { // Remove the root slash since it is implied that the // current working directory is relative to the root. if (!LocationGlobber.IsProviderDirectPath(path) && path.StartsWith(StringLiterals.DefaultPathSeparatorString, StringComparison.CurrentCulture) && !pathIsProviderQualifiedPath) { path = path.Substring(1); } s_tracer.WriteLine( "New working path = {0}", path); CurrentDrive.CurrentLocation = path; } else { // Set the current working drive back to the previous // one in case it was changed. CurrentDrive = previousWorkingDrive; throw new ItemNotFoundException( originalPath, "PathNotFound", SessionStateStrings.PathNotFound); } // Now make sure the current drive is set in the provider's // current working drive hashtable ProvidersCurrentWorkingDrive[CurrentDrive.Provider] = CurrentDrive; // Set the $PWD variable to the new location this.SetVariable(SpecialVariables.PWDVarPath, this.CurrentLocation, false, true, CommandOrigin.Internal); return(this.CurrentLocation); } // SetLocation
public PSDriveInfo New(PSDriveInfo drive, string scope) { var runtime = new ProviderRuntime(_scope.SessionState); return(New(drive, scope, runtime)); }
internal bool TryGet(string driveName, out PSDriveInfo info) { info = _scope.Get(driveName, false); return(info != null); }
internal PSDriveInfo New(PSDriveInfo drive, string scope, ProviderRuntime providerRuntime) { // make sure the provider can intitalize this drive properly drive = GetProvider(drive).NewDrive(drive, providerRuntime); return(NewSkipInit(drive, scope)); }
public PSDriveInfo New(PSDriveInfo drive, string scope) { using (DriveManagementIntrinsics.tracer.TraceMethod()) return(this.sessionState.NewDrive(drive, scope)); }
/// <summary> /// Resolves the specified path to PathInfo objects /// </summary> /// /// <param name="pathToResolve"> /// The path to be resolved. Each path may contain glob characters. /// </param> /// /// <param name="allowNonexistingPaths"> /// If true, resolves the path even if it doesn't exist. /// </param> /// /// <param name="currentCommandContext"> /// The context under which the command is running. /// </param> /// /// <returns> /// A string representing the resolved path. /// </returns> /// private PathInfo ResolvePath( string pathToResolve, bool allowNonexistingPaths, CmdletProviderContext currentCommandContext) { Collection <PathInfo> results = new Collection <PathInfo>(); try { // First resolve path Collection <PathInfo> pathInfos = SessionState.Path.GetResolvedPSPathFromPSPath( pathToResolve, currentCommandContext); foreach (PathInfo pathInfo in pathInfos) { results.Add(pathInfo); } } catch (PSNotSupportedException notSupported) { WriteError( new ErrorRecord( notSupported.ErrorRecord, notSupported)); } catch (System.Management.Automation.DriveNotFoundException driveNotFound) { WriteError( new ErrorRecord( driveNotFound.ErrorRecord, driveNotFound)); } catch (ProviderNotFoundException providerNotFound) { WriteError( new ErrorRecord( providerNotFound.ErrorRecord, providerNotFound)); } catch (ItemNotFoundException pathNotFound) { if (allowNonexistingPaths) { ProviderInfo provider = null; System.Management.Automation.PSDriveInfo drive = null; string unresolvedPath = SessionState.Path.GetUnresolvedProviderPathFromPSPath( pathToResolve, currentCommandContext, out provider, out drive); PathInfo pathInfo = new PathInfo( drive, provider, unresolvedPath, SessionState); results.Add(pathInfo); } else { WriteError( new ErrorRecord( pathNotFound.ErrorRecord, pathNotFound)); } } if (results.Count == 1) { return(results[0]); } else if (results.Count > 1) { Exception e = PSTraceSource.NewNotSupportedException(); WriteError( new ErrorRecord(e, "NotSupported", ErrorCategory.NotImplemented, results)); return(null); } else { return(null); } } // ResolvePath
internal void New(PSDriveInfo drive, string scope, CmdletProviderContext context) { using (DriveManagementIntrinsics.tracer.TraceMethod()) this.sessionState.NewDrive(drive, scope, context); }