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 Context( IContext context, object dynamicParameters ) { Context c = context as Context; if( null == c ) { throw new ArgumentException( "the context provided is of an incompatible type"); } _provider = c._provider; PathProcessor = c.PathProcessor; DynamicParameters = dynamicParameters; }
protected ItemContentReaderWriterBase(CmdletProvider provider, Item item, FileSystemCmdletProviderEncoding encoding, bool raw) { Item = item; Provider = provider; Raw = raw; if (encoding == FileSystemCmdletProviderEncoding.Unknown) { encoding = FileSystemCmdletProviderEncoding.Byte; } Encoding = new FileSystemContentWriterDynamicParameters() {Encoding = encoding}.EncodingType; }
public Context( IContext context, object dynamicParameters ) { Context c = context as Context; if( null == c ) { throw new ArgumentException( "the context provided is of an incompatible type"); } _provider = c._provider; _drive = c._drive; _path = c._path; _pathProcessor = c._pathProcessor; DynamicParameters = dynamicParameters; _recurse = c.Recurse; PathTopologyVersion = c.PathTopologyVersion; }
public ItemContentWriter(CmdletProvider provider, Item item, string path, FileSystemCmdletProviderEncoding encoding, string extension, bool raw, bool fileBased, bool versioned, string language) : base(provider, item, encoding, raw) { if (Encoding != null && !Raw) { encoder = Encoding.GetEncoder(); } if (!string.IsNullOrEmpty(extension)) { this.extension = extension.StartsWith(".") ? extension : "." + extension; } this.fileBased = fileBased; this.path = path; this.versioned = versioned; this.language = language ?? Item?.Language?.Name; database = Item?.Database?.Name ?? PathUtilities.GetDrive(path, "master"); }
internal Collection<string> GetGlobbedProviderPaths(string path, ProviderRuntime runtime, bool itemMustExist, out CmdletProvider provider) { var results = new Collection<string>(); ProviderInfo providerInfo; // get internal path, resolve home path and set provider info and drive info (if resolved) path = GetProviderSpecificPath(path, runtime, out providerInfo); provider = _sessionState.Provider.GetInstance(providerInfo); if (!ShouldGlob(path, runtime)) { // Although even ItemCmdletProvider supports ItemExists, PS doesn't seem // to throw errors when resolving paths with ItemProviders, only for ContainerProviders or higher // this behavior can be seen in the tests var containerProvider = provider as ContainerCmdletProvider; if (itemMustExist && containerProvider != null && !containerProvider.ItemExists(path, runtime)) { var msg = String.Format("An item with path {0} doesn't exist", path); runtime.WriteError(new ItemNotFoundException(msg).ErrorRecord); return results; } results.Add(path); return results; } if (providerInfo.Capabilities.HasFlag(ProviderCapabilities.ExpandWildcards)) { var filter = new IncludeExcludeFilter(runtime.Include, runtime.Exclude, runtime.IgnoreFiltersForGlobbing); foreach (var expanded in CmdletProvider.As<ItemCmdletProvider>(provider).ExpandPath(path, runtime)) { if (filter.Accepts(expanded)) { results.Add(expanded); } } } else { results = BuiltInGlobbing(provider, path, runtime); } return results; }
/// <summary> /// Gets an instance of an ISecurityDescriptorCmdletProvider given the provider ID. /// </summary> /// /// <param name="providerInstance"> /// An instance of a CmdletProvider. /// </param> /// /// <returns> /// An instance of a ISecurityDescriptorCmdletProvider for the specified provider ID. /// </returns> /// /// <throws> /// ArgumentNullException if providerId is null. /// NotSupportedException if the providerId is not for a provider /// that is derived from ISecurityDescriptorCmdletProvider. /// </throws> /// internal static ISecurityDescriptorCmdletProvider GetPermissionProviderInstance(CmdletProvider providerInstance) { if (providerInstance == null) { throw PSTraceSource.NewArgumentNullException("providerInstance"); } ISecurityDescriptorCmdletProvider permissionCmdletProvider = providerInstance as ISecurityDescriptorCmdletProvider; if (permissionCmdletProvider == null) { throw PSTraceSource.NewNotSupportedException( ProviderBaseSecurity.ISecurityDescriptorCmdletProvider_NotSupported); } return permissionCmdletProvider; } // GetPermissionProviderInstance
public FileSystemContentReaderWriter(string path, string streamName, FileMode mode, FileAccess access, FileShare share, Encoding encoding, bool usingByteEncoding, bool waitForChanges, CmdletProvider provider, bool isRawStream) { this.delimiter = "\n"; if (string.IsNullOrEmpty(path)) { throw PSTraceSource.NewArgumentNullException("path"); } tracer.WriteLine("path = {0}", new object[] { path }); tracer.WriteLine("mode = {0}", new object[] { mode }); tracer.WriteLine("access = {0}", new object[] { access }); this.path = path; this.streamName = streamName; this.mode = mode; this.access = access; this.share = share; this.encoding = encoding; this.usingByteEncoding = usingByteEncoding; this.waitForChanges = waitForChanges; this.provider = provider; this.isRawStream = isRawStream; this.CreateStreams(path, streamName, mode, access, share, encoding); }
public ProviderContext(CmdletProvider provider, string path, PSDriveInfo drive, IPathResolver pathProcessor, object dynamicParameters, Version topology) : this(provider, path, drive, pathProcessor, dynamicParameters, topology, false) { }
internal Collection<string> GetGlobbedProviderPathsFromMonadPath(string path, bool allowNonexistingPaths, CmdletProviderContext context, out ProviderInfo provider, out CmdletProvider providerInstance) { if (path == null) { throw PSTraceSource.NewArgumentNullException("path"); } if (context == null) { throw PSTraceSource.NewArgumentNullException("context"); } using (pathResolutionTracer.TraceScope("Resolving MSH path \"{0}\" to PROVIDER-INTERNAL path", new object[] { path })) { TraceFilters(context); if (IsProviderQualifiedPath(path)) { context.Drive = null; } PSDriveInfo drive = null; if (this.GetProviderPath(path, context, out provider, out drive) == null) { providerInstance = null; tracer.WriteLine("provider returned a null path so return an empty array", new object[0]); pathResolutionTracer.WriteLine("Provider '{0}' returned null", new object[] { provider }); return new Collection<string>(); } if (drive != null) { context.Drive = drive; } Collection<string> collection = new Collection<string>(); foreach (PathInfo info2 in this.GetGlobbedMonadPathsFromMonadPath(path, allowNonexistingPaths, context, out providerInstance)) { collection.Add(info2.ProviderPath); } return collection; } }
internal Collection<string> GetGlobbedProviderPathsFromMonadPath(string path, bool allowNonexistingPaths, out ProviderInfo provider, out CmdletProvider providerInstance) { providerInstance = null; if (path == null) { throw PSTraceSource.NewArgumentNullException("path"); } CmdletProviderContext context = new CmdletProviderContext(this.sessionState.Internal.ExecutionContext); return this.GetGlobbedProviderPathsFromMonadPath(path, allowNonexistingPaths, context, out provider, out providerInstance); }
internal Collection<PathInfo> GetGlobbedMonadPathsFromMonadPath (string path, bool allowNonexistingPaths, CmdletProviderContext context, out CmdletProvider providerInstance) { providerInstance = null; if (path == null) { throw PSTraceSource.NewArgumentNullException ("path"); } if (context == null) { throw PSTraceSource.NewArgumentNullException ("context"); } Collection<PathInfo> collection = new Collection<PathInfo>(); using (pathResolutionTracer.TraceScope("Resolving MSH path \"{0}\" to MSH path", new object[] { path })) { TraceFilters(context); if (IsHomePath(path)) { using (pathResolutionTracer.TraceScope("Resolving HOME relative path.", new object[0])) { path = this.GetHomeRelativePath(path); } } bool isProviderDirectPath = IsProviderDirectPath(path); bool isProviderQualifiedPath = IsProviderQualifiedPath(path); if (isProviderDirectPath || isProviderQualifiedPath) { collection = this.ResolvePSPathFromProviderPath(path, context, allowNonexistingPaths, isProviderDirectPath, isProviderQualifiedPath, out providerInstance); } else { collection = this.ResolveDriveQualifiedPath(path, context, allowNonexistingPaths, out providerInstance); } if (((allowNonexistingPaths || (collection.Count >= 1)) || WildcardPattern.ContainsWildcardCharacters(path)) || ((context.Include != null) && (context.Include.Count != 0))) { return collection; } if ((context.Exclude != null) && (context.Exclude.Count != 0)) { return collection; } ItemNotFoundException exception = new ItemNotFoundException(path, "PathNotFound", SessionStateStrings.PathNotFound); pathResolutionTracer.TraceError("Item does not exist: {0}", new object[] { path }); throw exception; } }
internal Collection<PathInfo> GetGlobbedMonadPathsFromMonadPath(string path, bool allowNonexistingPaths, out CmdletProvider providerInstance) { CmdletProviderContext context = new CmdletProviderContext(this.sessionState.Internal.ExecutionContext); return this.GetGlobbedMonadPathsFromMonadPath(path, allowNonexistingPaths, context, out providerInstance); }
internal string GetDriveRootRelativePathFromPSPath (string path, CmdletProviderContext context, bool escapeCurrentLocation, out PSDriveInfo workingDriveForPath, out CmdletProvider providerInstance) { if (path == null) { throw PSTraceSource.NewArgumentNullException ("path"); } if (OSHelper.IsUnix) { int index = path.IndexOf ("::"); if (index != -1) { path = path.Substring (index + 2); } } workingDriveForPath = null; string driveName = null; if (this.sessionState.Drive.Current != null) { driveName = this.sessionState.Drive.Current.Name; } bool flag = false; if (this.IsAbsolutePath(path, out driveName)) { tracer.WriteLine("Drive Name: {0}", new object[] { driveName }); try { workingDriveForPath = this.sessionState.Drive.Get(driveName); } catch (DriveNotFoundException) { if (this.sessionState.Drive.Current == null) { throw; } if (Environment.OSVersion.Platform == PlatformID.MacOSX || Environment.OSVersion.Platform == PlatformID.Unix) { flag = path.StartsWith ("/", StringComparison.OrdinalIgnoreCase); workingDriveForPath = this.sessionState.Drive.Current; } else { string str2 = OSHelper.IsUnix ? this.sessionState.Drive.Current.Root : this.sessionState.Drive.Current.Root.Replace('/', '\\'); string tempPath = OSHelper.IsUnix ? path : path.Replace('/', '\\'); if ((str2.IndexOf(":", StringComparison.CurrentCulture) >= 0) && tempPath.StartsWith(str2, StringComparison.OrdinalIgnoreCase)) { flag = true; if (!OSHelper.IsUnix) { path = path.Substring(str2.Length); path = path.TrimStart(new char[] { '\\' }); path = '\\' + path; } workingDriveForPath = this.sessionState.Drive.Current; } if (!flag) { throw; } } } if (!flag) /* && !OSHelper.IsUnix */ { path = path.Substring(driveName.Length + 1); } } else { workingDriveForPath = this.sessionState.Drive.Current; } if (workingDriveForPath == null) { ItemNotFoundException exception = new ItemNotFoundException(path, "PathNotFound", SessionStateStrings.PathNotFound); pathResolutionTracer.TraceError("Item does not exist: {0}", new object[] { path }); throw exception; } try { providerInstance = this.sessionState.Internal.GetContainerProviderInstance(workingDriveForPath.Provider); context.Drive = workingDriveForPath; return this.GenerateRelativePath(workingDriveForPath, path, escapeCurrentLocation, providerInstance, context); } catch (PSNotSupportedException) { providerInstance = null; return ""; } }
/// <summary> /// Constructor for the content stream /// </summary> /// /// <param name="path"> /// The path to the file to get the content from. /// </param> /// /// <param name="streamName"> /// The name of the Alternate Data Stream to get the content from. If null or empty, returns /// the file's primary content. /// </param> /// /// <param name="mode"> /// The file mode to open the file with. /// </param> /// /// <param name="access"> /// The file access requested in the file. /// </param> /// /// <param name="share"> /// The file share to open the file with /// </param> /// /// <param name="encoding"> /// The encoding of the file to be read or written. /// </param> /// /// <param name="usingByteEncoding"> /// If true, bytes will be read from the file. If false, the specified encoding /// will be used to read the file. /// </param> /// /// <param name="waitForChanges"> /// If true, we will perform blocking reads on the file, waiting for new content to be appended /// </param> /// /// <param name="provider"> /// The CmdletProvider invoking this stream /// </param> /// /// <param name="isRawStream"> /// Indicates raw stream. /// </param> /// /// <param name="suppressNewline"> /// False to add a newline to the end of the output string, true if not. /// </param> /// public FileSystemContentReaderWriter( string path, string streamName, FileMode mode, FileAccess access, FileShare share, Encoding encoding, bool usingByteEncoding, bool waitForChanges, CmdletProvider provider, bool isRawStream, bool suppressNewline) : this(path, streamName, mode, access, share, encoding, usingByteEncoding, waitForChanges, provider, isRawStream) { _suppressNewline = suppressNewline; }
/// <summary> /// Creates an instance of the provider. /// </summary> /// <returns> /// An instance of the provider or null if one could not be created. /// </returns> /// <exception cref="ProviderNotFoundException"> /// If an instance of the provider could not be created because the /// type could not be found in the assembly. /// </exception> internal Provider.CmdletProvider CreateInstance() { // It doesn't really seem that using thread local storage to store an // instance of the provider is really much of a performance gain and it // still causes problems with the CmdletProviderContext when piping two // commands together that use the same provider. // get-child -filter a*.txt | get-content // This pipeline causes problems when using a cached provider instance because // the CmdletProviderContext gets changed when get-content gets called. // When get-content finishes writing content from the first output of get-child // get-child gets control back and writes out a FileInfo but the WriteObject // from get-content gets used because the CmdletProviderContext is still from // that cmdlet. // Possible solutions are to not cache the provider instance, or to maintain // a CmdletProviderContext stack in ProviderBase. Each method invocation pushes // the current context and the last action of the method pops back to the // previous context. #if USE_TLS // Next see if we already have an instance in thread local storage object providerInstance = Thread.GetData(instance); if (providerInstance == null) { #else object providerInstance = null; #endif // Finally create an instance of the class Exception invocationException = null; try { providerInstance = Activator.CreateInstance(this.ImplementingType); } catch (TargetInvocationException targetException) { invocationException = targetException.InnerException; } catch (MissingMethodException) { } catch (MemberAccessException) { } catch (ArgumentException) { } #if USE_TLS // cache the instance in thread local storage Thread.SetData(instance, providerInstance); } #endif if (providerInstance == null) { ProviderNotFoundException e = null; if (invocationException != null) { e = new ProviderNotFoundException( this.Name, SessionStateCategory.CmdletProvider, "ProviderCtorException", SessionStateStrings.ProviderCtorException, invocationException.Message); } else { e = new ProviderNotFoundException( this.Name, SessionStateCategory.CmdletProvider, "ProviderNotFoundInAssembly", SessionStateStrings.ProviderNotFoundInAssembly); } throw e; } Provider.CmdletProvider result = providerInstance as Provider.CmdletProvider; Dbg.Diagnostics.Assert( result != null, "DiscoverProvider should verify that the class is derived from CmdletProvider so this is just validation of that"); result.SetProviderInformation(this); return result; }
private bool IsItemContainer(CmdletProvider provider, string path, ProviderRuntime providerRuntime) { NavigationCmdletProvider navigationProvider = provider as NavigationCmdletProvider; if (navigationProvider == null) return false; return navigationProvider.IsItemContainer(path, providerRuntime); }
public ProviderContext(IProviderContext providerContext, object dynamicParameters) { ProviderContext c = providerContext as ProviderContext; if (null == c) { throw new ArgumentException("the providerContext provided is of an incompatible type"); } provider = c.provider; drive = c.drive; path = c.path; pathProcessor = c.pathProcessor; DynamicParameters = dynamicParameters; recurse = c.Recurse; PathTopologyVersion = c.PathTopologyVersion; }
internal Collection<string> GetGlobbedProviderPathsFromProviderPath(string path, bool allowNonexistingPaths, string providerId, out CmdletProvider providerInstance) { providerInstance = null; if (path == null) { throw PSTraceSource.NewArgumentNullException("path"); } CmdletProviderContext context = new CmdletProviderContext(this.sessionState.Internal.ExecutionContext); Collection<string> collection = this.GetGlobbedProviderPathsFromProviderPath(path, allowNonexistingPaths, providerId, context, out providerInstance); if (context.HasErrors()) { ErrorRecord record = context.GetAccumulatedErrorObjects()[0]; if (record != null) { throw record.Exception; } } return collection; }
/// <summary> /// Constructor for the content stream /// </summary> /// /// <param name="path"> /// The path to the file to get the content from. /// </param> /// /// <param name="streamName"> /// The name of the Alternate Data Stream to get the content from. If null or empty, returns /// the file's primary content. /// </param> /// /// <param name="mode"> /// The file mode to open the file with. /// </param> /// /// <param name="access"> /// The file access requested in the file. /// </param> /// /// <param name="share"> /// The file share to open the file with /// </param> /// /// <param name="delimiter"> /// The delimiter to use when reading strings. Each time read is called, all contents up to an including /// the delimiter is read. /// </param> /// /// <param name="encoding"> /// The encoding of the file to be read or written. /// </param> /// /// <param name="waitForChanges"> /// If true, we will perform blocking reads on the file, waiting for new content to be appended /// </param> /// /// <param name="provider"> /// The CmdletProvider invoking this stream /// </param> /// /// <param name="isRawStream"> /// Indicates raw stream. /// </param> /// public FileSystemContentReaderWriter( string path, string streamName, FileMode mode, FileAccess access, FileShare share, string delimiter, Encoding encoding, bool waitForChanges, CmdletProvider provider, bool isRawStream) : this(path, streamName, mode, access, share, encoding, false, waitForChanges, provider, isRawStream) { _delimiter = delimiter; _usingDelimiter = true; }
public ProviderContext(CmdletProvider provider, string path, PSDriveInfo drive, IPathResolver pathProcessor, object dynamicParameters, bool recurse) : this(provider, path, drive, pathProcessor, dynamicParameters, new Version(1, 0), recurse) { }
internal string GenerateRelativePath(PSDriveInfo drive, string path, bool escapeCurrentLocation, CmdletProvider providerInstance, CmdletProviderContext context) { if (path == null) { throw PSTraceSource.NewArgumentNullException("path"); } if (drive == null) { throw PSTraceSource.NewArgumentNullException("drive"); } string currentLocation = drive.CurrentLocation; bool flag1 = OSHelper.IsUnix && drive.Root.StartsWith ("/"); if (!flag1 && !string.IsNullOrEmpty(currentLocation) && currentLocation.StartsWith(drive.Root, StringComparison.Ordinal)) { currentLocation = currentLocation.Substring(drive.Root.Length); } if (escapeCurrentLocation) { currentLocation = WildcardPattern.Escape(currentLocation); } if (!string.IsNullOrEmpty(path)) { var flag6 = OSHelper.IsUnix; var flag7 = flag6; if (!flag6) flag6 = (path[0] != '/'); if ((path[0] != '\\') && flag6) { Label_024B: if ((path.Length > 0) && this.HasRelativePathTokens(path)) { if (context.Stopping) { throw new PipelineStoppedException(); } bool flag = false; bool flag2 = path.StartsWith("..", StringComparison.Ordinal); bool flag3 = path.Length == 2; bool flag4 = (path.Length > 2) && ((path[2] == '\\') || (path[2] == '/')); if (flag7) flag4 = flag7; if (flag2 && (flag3 || flag4)) { if (!string.IsNullOrEmpty(currentLocation)) { currentLocation = this.sessionState.Internal.GetParentPath(providerInstance, currentLocation, drive.Root, context); } tracer.WriteLine("Parent path = {0}", new object[] { currentLocation }); path = path.Substring(2); tracer.WriteLine("path = {0}", new object[] { path }); flag = true; if (path.Length != 0) { if (!flag7) { if ((path[0] == '\\') || (path[0] == '/')) { path = path.Substring(1); } } tracer.WriteLine("path = {0}", new object[] { path }); if (path.Length != 0) { goto Label_024B; } } goto Label_0260; } if (path.Equals(".", StringComparison.OrdinalIgnoreCase)) { flag = true; path = string.Empty; goto Label_0260; } if (path.StartsWith(@".\", StringComparison.Ordinal) || path.StartsWith("./", StringComparison.Ordinal)) { path = path.Substring(@".\".Length); flag = true; tracer.WriteLine("path = {0}", new object[] { path }); if (path.Length == 0) { goto Label_0260; } } if ((path.Length == 0) || !flag) { goto Label_0260; } goto Label_024B; } } else { currentLocation = string.Empty; path = path.Substring(1); tracer.WriteLine("path = {0}", new object[] { path }); } } Label_0260: if (!string.IsNullOrEmpty(path)) { currentLocation = this.sessionState.Internal.MakePath(providerInstance, currentLocation, path, context); } NavigationCmdletProvider provider = providerInstance as NavigationCmdletProvider; if (provider != null) { string str2 = this.sessionState.Internal.MakePath(context.Drive.Root, currentLocation, context); string str3 = provider.ContractRelativePath(str2, context.Drive.Root, false, context); if (!string.IsNullOrEmpty(str3)) { flag1 = OSHelper.IsUnix && context.Drive.Root.StartsWith ("/"); if (!flag1 && str3.StartsWith(context.Drive.Root, StringComparison.Ordinal)) { currentLocation = str3.Substring(context.Drive.Root.Length); } else { currentLocation = str3; } } else { currentLocation = ""; } } tracer.WriteLine("result = {0}", new object[] { currentLocation }); return currentLocation; }
internal Collection<string> GetGlobbedProviderPathsFromProviderPath(string path, bool allowNonexistingPaths, string providerId, CmdletProviderContext context, out CmdletProvider providerInstance) { providerInstance = null; if (path == null) { throw PSTraceSource.NewArgumentNullException("path"); } if (providerId == null) { throw PSTraceSource.NewArgumentNullException("providerId"); } if (context == null) { throw PSTraceSource.NewArgumentNullException("context"); } using (pathResolutionTracer.TraceScope("Resolving PROVIDER-INTERNAL path \"{0}\" to PROVIDER-INTERNAL path", new object[] { path })) { TraceFilters(context); return this.ResolveProviderPathFromProviderPath(path, providerId, allowNonexistingPaths, context, out providerInstance); } }
/// <summary> /// Constructor for the content stream /// </summary> /// /// <param name="path"> /// The path to the file to get the content from. /// </param> /// /// <param name="streamName"> /// The name of the Alternate Data Stream to get the content from. If null or empty, returns /// the file's primary content. /// </param> /// /// <param name="mode"> /// The file mode to open the file with. /// </param> /// /// <param name="access"> /// The file access requested in the file. /// </param> /// /// <param name="share"> /// The file share to open the file with /// </param> /// /// <param name="encoding"> /// The encoding of the file to be read or written. /// </param> /// /// <param name="usingByteEncoding"> /// If true, bytes will be read from the file. If false, the specified encoding /// will be used to read the file. /// </param> /// /// <param name="waitForChanges"> /// If true, we will perform blocking reads on the file, waiting for new content to be appended /// </param> /// /// <param name="provider"> /// The CmdletProvider invoking this stream /// </param> /// /// <param name="isRawStream"> /// Indicates raw stream. /// </param> /// public FileSystemContentReaderWriter( string path, string streamName, FileMode mode, FileAccess access, FileShare share, Encoding encoding, bool usingByteEncoding, bool waitForChanges, CmdletProvider provider, bool isRawStream) { if (String.IsNullOrEmpty(path)) { throw PSTraceSource.NewArgumentNullException("path"); } if (s_tracer.IsEnabled) { s_tracer.WriteLine("path = {0}", path); s_tracer.WriteLine("mode = {0}", mode); s_tracer.WriteLine("access = {0}", access); } _path = path; _streamName = streamName; _mode = mode; _access = access; _share = share; _encoding = encoding; _usingByteEncoding = usingByteEncoding; _waitForChanges = waitForChanges; _provider = provider; _isRawStream = isRawStream; CreateStreams(path, streamName, mode, access, share, encoding); }
private void InitializeProvider(CmdletProvider providerInstance, ProviderInfo provider) { List<PSDriveInfo> drives = new List<PSDriveInfo>(); DriveCmdletProvider driveProvider = providerInstance as DriveCmdletProvider; if (driveProvider != null) { Collection<PSDriveInfo> collection = driveProvider.DoInitializeDefaultDrives(); if ((collection != null) && (collection.Count > 0)) { drives.AddRange(collection); _providersCurrentDrive[provider] = collection[0]; } } if (drives.Count > 0) { foreach (PSDriveInfo driveInfo in drives) { if (driveInfo != null) { // TODO: need to set driveInfo.Root // TODO:this should be automatically called when using DriveIntrinsics.New! #providerSupport driveProvider.DoNewDrive(driveInfo); try { //always to global scope _executionContext.SessionState.Drive.New(driveInfo, SessionStateScope<PSDriveInfo>.ScopeSpecifiers.Global.ToString()); } catch { // TODO: What should we do if the drive name is not unique? // => I guess overwrite the old one and write a warning (however this works from here) } } } } }
private Collection<PathInfo> ResolveDriveQualifiedPath(string path, CmdletProviderContext context, bool allowNonexistingPaths, out CmdletProvider providerInstance) { providerInstance = null; PSDriveInfo workingDriveForPath = null; Collection<PathInfo> collection = new Collection<PathInfo>(); pathResolutionTracer.WriteLine("Path is DRIVE-QUALIFIED", new object[0]); string str = this.GetDriveRootRelativePathFromPSPath(path, context, true, out workingDriveForPath, out providerInstance); pathResolutionTracer.WriteLine("DRIVE-RELATIVE path: {0}", new object[] { str }); pathResolutionTracer.WriteLine("Drive: {0}", new object[] { workingDriveForPath.Name }); pathResolutionTracer.WriteLine("Provider: {0}", new object[] { workingDriveForPath.Provider }); context.Drive = workingDriveForPath; providerInstance = this.sessionState.Internal.GetContainerProviderInstance(workingDriveForPath.Provider); ContainerCmdletProvider provider = providerInstance as ContainerCmdletProvider; ItemCmdletProvider provider2 = providerInstance as ItemCmdletProvider; ProviderInfo providerInfo = providerInstance.ProviderInfo; string item = null; string providerPath = null; if (workingDriveForPath.Hidden) { item = GetProviderQualifiedPath(str, providerInfo); providerPath = str; } else { item = GetDriveQualifiedPath(str, workingDriveForPath); providerPath = this.GetProviderPath(path, context); } pathResolutionTracer.WriteLine("PROVIDER path: {0}", new object[] { providerPath }); Collection<string> collection2 = new Collection<string>(); if (!context.SuppressWildcardExpansion) { if (CmdletProviderManagementIntrinsics.CheckProviderCapabilities(ProviderCapabilities.ExpandWildcards, providerInfo)) { pathResolutionTracer.WriteLine("Wildcard matching is being performed by the provider.", new object[0]); if ((provider2 != null) && WildcardPattern.ContainsWildcardCharacters(str)) { foreach (string str4 in provider2.ExpandPath(providerPath, context)) { collection2.Add(this.GetDriveRootRelativePathFromProviderPath(str4, workingDriveForPath, context)); } } else { collection2.Add(this.GetDriveRootRelativePathFromProviderPath(providerPath, workingDriveForPath, context)); } } else { pathResolutionTracer.WriteLine("Wildcard matching is being performed by the engine.", new object[0]); collection2 = this.ExpandMshGlobPath(str, allowNonexistingPaths, workingDriveForPath, provider, context); } } else if (provider2 != null) { if (allowNonexistingPaths || provider2.ItemExists(providerPath, context)) { collection2.Add(item); } } else { collection2.Add(item); } if ((((!allowNonexistingPaths && (collection2.Count < 1)) && !WildcardPattern.ContainsWildcardCharacters(path)) && ((context.Include == null) || (context.Include.Count == 0))) && ((context.Exclude == null) || (context.Exclude.Count == 0))) { ItemNotFoundException exception = new ItemNotFoundException(path, "PathNotFound", SessionStateStrings.PathNotFound); pathResolutionTracer.TraceError("Item does not exist: {0}", new object[] { path }); throw exception; } foreach (string str5 in collection2) { if (context.Stopping) { throw new PipelineStoppedException(); } item = null; if (workingDriveForPath.Hidden) { if (IsProviderDirectPath(str5)) { item = str5; } else { item = GetProviderQualifiedPath(str5, providerInfo); } } else { item = GetDriveQualifiedPath(str5, workingDriveForPath); } collection.Add(new PathInfo(workingDriveForPath, providerInfo, item, this.sessionState)); pathResolutionTracer.WriteLine("RESOLVED PATH: {0}", new object[] { item }); } return collection; }
private void InitializeProvider(CmdletProvider providerInstance, ProviderInfo provider) { List<PSDriveInfo> drives = new List<PSDriveInfo>(); DriveCmdletProvider driveProvider = providerInstance as DriveCmdletProvider; if (driveProvider != null) { Collection<PSDriveInfo> collection = driveProvider.DoInitializeDefaultDrives(); if ((collection != null) && (collection.Count > 0)) { drives.AddRange(collection); _providersCurrentDrive[provider] = collection[0]; } } if (drives.Count > 0) { foreach (PSDriveInfo driveInfo in drives) { if (driveInfo != null) { // TODO: need to set driveInfo.Root driveProvider.DoNewDrive(driveInfo); try { _drives.Add(driveInfo.Name, driveInfo); } catch { // TODO: What should we do if the drive name is not unique? } } } } }
private Collection<string> ResolveProviderPathFromProviderPath(string providerPath, string providerId, bool allowNonexistingPaths, CmdletProviderContext context, out CmdletProvider providerInstance) { providerInstance = this.sessionState.Internal.GetProviderInstance(providerId); ContainerCmdletProvider containerProvider = providerInstance as ContainerCmdletProvider; ItemCmdletProvider provider2 = providerInstance as ItemCmdletProvider; Collection<string> collection = new Collection<string>(); if (!context.SuppressWildcardExpansion) { if (CmdletProviderManagementIntrinsics.CheckProviderCapabilities(ProviderCapabilities.ExpandWildcards, providerInstance.ProviderInfo)) { pathResolutionTracer.WriteLine("Wildcard matching is being performed by the provider.", new object[0]); if ((provider2 != null) && WildcardPattern.ContainsWildcardCharacters(providerPath)) { collection = new Collection<string>(provider2.ExpandPath(providerPath, context)); } else { collection.Add(providerPath); } } else { pathResolutionTracer.WriteLine("Wildcard matching is being performed by the engine.", new object[0]); if (containerProvider != null) { collection = this.GetGlobbedProviderPathsFromProviderPath(providerPath, allowNonexistingPaths, containerProvider, context); } else { collection.Add(providerPath); } } } else if (provider2 != null) { if (allowNonexistingPaths || provider2.ItemExists(providerPath, context)) { collection.Add(providerPath); } } else { collection.Add(providerPath); } if (((allowNonexistingPaths || (collection.Count >= 1)) || WildcardPattern.ContainsWildcardCharacters(providerPath)) || ((context.Include != null) && (context.Include.Count != 0))) { return collection; } if ((context.Exclude != null) && (context.Exclude.Count != 0)) { return collection; } ItemNotFoundException exception = new ItemNotFoundException(providerPath, "PathNotFound", SessionStateStrings.PathNotFound); pathResolutionTracer.TraceError("Item does not exist: {0}", new object[] { providerPath }); throw exception; }
private bool ItemExists(CmdletProvider provider, string path, ProviderRuntime providerRuntime) { ItemCmdletProvider itemProvider = provider as ItemCmdletProvider; if (itemProvider == null) return false; return itemProvider.ItemExists(path, providerRuntime); }
private Collection<PathInfo> ResolvePSPathFromProviderPath(string path, CmdletProviderContext context, bool allowNonexistingPaths, bool isProviderDirectPath, bool isProviderQualifiedPath, out CmdletProvider providerInstance) { Collection<PathInfo> collection = new Collection<PathInfo>(); providerInstance = null; string providerId = null; PSDriveInfo drive = null; string providerPath = null; if (isProviderDirectPath) { pathResolutionTracer.WriteLine("Path is PROVIDER-DIRECT", new object[0]); providerPath = path; providerId = this.sessionState.Path.CurrentLocation.Provider.Name; } else if (isProviderQualifiedPath) { pathResolutionTracer.WriteLine("Path is PROVIDER-QUALIFIED", new object[0]); providerPath = ParseProviderPath(path, out providerId); } pathResolutionTracer.WriteLine("PROVIDER-INTERNAL path: {0}", new object[] { providerPath }); pathResolutionTracer.WriteLine("Provider: {0}", new object[] { providerId }); Collection<string> collection2 = this.ResolveProviderPathFromProviderPath(providerPath, providerId, allowNonexistingPaths, context, out providerInstance); drive = providerInstance.ProviderInfo.HiddenDrive; foreach (string str3 in collection2) { string str4 = str3; if (context.Stopping) { throw new PipelineStoppedException(); } string str5 = null; if (IsProviderDirectPath(str4)) { str5 = str4; } else { str5 = string.Format(CultureInfo.InvariantCulture, "{0}::{1}", new object[] { providerId, str4 }); } collection.Add(new PathInfo(drive, providerInstance.ProviderInfo, str5, this.sessionState)); pathResolutionTracer.WriteLine("RESOLVED PATH: {0}", new object[] { str5 }); } return collection; }