private static bool AliasDefinitionsTypeValidationCallback(string key, object obj, PSCmdlet cmdlet, string path) { Hashtable[] hashtableArray = DISCPowerShellConfiguration.TryGetHashtableArray(obj); if (hashtableArray == null) { cmdlet.WriteVerbose(StringUtil.Format(RemotingErrorIdStrings.DISCTypeMustBeHashtableArray, key, path)); return false; } foreach (Hashtable hashtable in hashtableArray) { if (!hashtable.ContainsKey(AliasNameToken)) { cmdlet.WriteVerbose(StringUtil.Format(RemotingErrorIdStrings.DISCTypeMustContainKey, new object[] { key, AliasNameToken, path })); return false; } if (!hashtable.ContainsKey(AliasValueToken)) { cmdlet.WriteVerbose(StringUtil.Format(RemotingErrorIdStrings.DISCTypeMustContainKey, new object[] { key, AliasValueToken, path })); return false; } foreach (string str in hashtable.Keys) { if ((!string.Equals(str, AliasNameToken, StringComparison.OrdinalIgnoreCase) && !string.Equals(str, AliasValueToken, StringComparison.OrdinalIgnoreCase)) && (!string.Equals(str, AliasDescriptionToken, StringComparison.OrdinalIgnoreCase) && !string.Equals(str, AliasOptionsToken, StringComparison.OrdinalIgnoreCase))) { cmdlet.WriteVerbose(StringUtil.Format(RemotingErrorIdStrings.DISCTypeContainsInvalidKey, new object[] { str, key, path })); return false; } } } return true; }
// Keep in sync: // S.M.A.CommandProcessorBase.CheckForSevereException // S.M.A.Internal.ConsoleHost.CheckForSevereException // S.M.A.Commands.CommandsCommon.CheckForSevereException // S.M.A.Commands.UtilityCommon.CheckForSevereException /// <summary> /// Checks whether the exception is a severe exception which should /// cause immediate process failure. /// </summary> /// <param name="cmdlet">can be null</param> /// <param name="e"></param> /// <remarks> /// CB says 02/23/2005: I personally would err on the side /// of treating OOM like an application exception, rather than /// a critical system failure.I think this will be easier to justify /// in Orcas, if we tease apart the two cases of OOM better. /// But even in Whidbey, how likely is it that we couldnt JIT /// some backout code? At that point, the process or possibly /// the machine is likely to stop executing soon no matter /// what you do in this routine. So I would just consider /// AccessViolationException. (I understand why you have SO here, /// at least temporarily). /// </remarks> internal static void CheckForSevereException(PSCmdlet cmdlet, Exception e) { if (e is AccessViolationException || e is StackOverflowException) { try { if (!alreadyFailing) { alreadyFailing = true; // Get the ExecutionContext from the thread. ExecutionContext context = (null != cmdlet) ? cmdlet.Context : LocalPipeline.GetExecutionContextFromTLS(); // Log a command health event for this critical error. MshLog.LogCommandHealthEvent(context, e, Severity.Critical); } } finally { if (!designForTestability_SkipFailFast) WindowsErrorReporting.FailFast(e); } } }
internal static void MasterStreamOpen( PSCmdlet cmdlet, string filePath, string encoding, bool defaultEncoding, bool append, bool force, bool noClobber, out FileStream fileStream, out StreamWriter streamWriter, out FileInfo readOnlyFileInfo, bool isLiteralPath) { var resolvedEncoding = EncodingConversion.Convert(cmdlet, encoding); MasterStreamOpen( cmdlet, filePath, resolvedEncoding, defaultEncoding, append, force, noClobber, out fileStream, out streamWriter, out readOnlyFileInfo, isLiteralPath); }
public DomainDispatcher(PSCmdlet cmdlet) { Contract.Requires(cmdlet != null); _cmdlet = cmdlet; _dte = (DTE)cmdlet.GetVariableValue("DTE"); }
/// <summary> /// Writes a collection of format view definitions to XML file /// </summary> /// <param name="typeDefinitions">collection of PSTypeDefinition</param> /// <param name="filepath">path to XML file</param> /// <param name="cmdlet">cmdlet from which this si used</param> /// <param name="force">true - to force write the file</param> /// <param name="writeScriptBlock">true - to export scriptblocks</param> /// <param name="noclobber">true - do not overwrite the file</param> /// <param name="isLiteralPath">true - bypass wildcard expansion on the file name</param> internal static void WriteToPs1Xml(PSCmdlet cmdlet, List<ExtendedTypeDefinition> typeDefinitions, string filepath, bool force, bool noclobber, bool writeScriptBlock, bool isLiteralPath) { StreamWriter streamWriter; FileStream fileStream; FileInfo fileInfo; PathUtils.MasterStreamOpen(cmdlet, filepath, "ascii", true, false, force, noclobber, out fileStream, out streamWriter, out fileInfo, isLiteralPath); try { using (XmlWriter xmlWriter = XmlWriter.Create(streamWriter)) { var writer = new FormatXmlWriter { _writer = xmlWriter, _exportScriptBlock = writeScriptBlock }; writer.WriteToXml(typeDefinitions); } } finally { streamWriter.Dispose(); fileStream.Dispose(); } }
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 void ExecuteCmdletBase(PSCmdlet callingCmdlet) { ManagementService client = CreateManagementServiceClient(); var relyingParties = client.RelyingParties; List<string> relyingPartyRelayAddresses = new List<string>(); long relyingPartyId = -1; foreach (var relyingParty in relyingParties) { string name = relyingParty.Name; if (name == RelyingParty) { relyingPartyId = relyingParty.Id; } } foreach (RelyingPartyAddress address in client.RelyingPartyAddresses) { if (address.RelyingPartyId == relyingPartyId) { relyingPartyRelayAddresses.Add(address.Address); } } callingCmdlet.WriteObject(relyingPartyRelayAddresses, true); ; }
/// <summary> /// /// </summary> /// <param name="files"></param> /// <param name="errorId"></param> /// <param name="cmdlet"></param> /// <returns></returns> internal static Collection<string> Glob(string[] files, string errorId, PSCmdlet cmdlet) { Collection<string> retValue = new Collection<string>(); foreach (string file in files) { Collection<string> providerPaths; ProviderInfo provider = null; try { providerPaths = cmdlet.SessionState.Path.GetResolvedProviderPathFromPSPath(file, out provider); } catch (SessionStateException e) { cmdlet.WriteError(new ErrorRecord(e, errorId, ErrorCategory.InvalidOperation, file)); continue; } if (!provider.NameEquals(cmdlet.Context.ProviderNames.FileSystem)) { ReportWrongProviderType(provider.FullName, errorId, cmdlet); continue; } foreach (string providerPath in providerPaths) { if (!providerPath.EndsWith(".ps1xml", StringComparison.OrdinalIgnoreCase)) { ReportWrongExtension(providerPath, "WrongExtension", cmdlet); continue; } retValue.Add(providerPath); } } return retValue; }
private static void ShowHelpWindow(PSObject helpObj, PSCmdlet cmdlet) { Window ownerWindow = ShowCommandHelper.GetHostWindow(cmdlet); if (ownerWindow != null) { ownerWindow.Dispatcher.Invoke( new SendOrPostCallback( delegate(object ignored) { HelpWindow helpWindow = new HelpWindow(helpObj); helpWindow.Owner = ownerWindow; helpWindow.Show(); helpWindow.Closed += new EventHandler(delegate(object sender, EventArgs e) { ownerWindow.Focus(); }); }), String.Empty); return; } Thread guiThread = new Thread( (ThreadStart)delegate { HelpWindow helpWindow = new HelpWindow(helpObj); helpWindow.ShowDialog(); }); guiThread.SetApartmentState(ApartmentState.STA); guiThread.Start(); }
public void ExecuteCmdletBase(PSCmdlet callingCmdlet) { ManagementService client = CreateManagementServiceClient(); var relyingParties = client.RelyingParties; if (relyingParties != null) { foreach (var relyingParty in relyingParties) { string name = relyingParty.Name; if (name == RelyingParty) { RelyingPartyAddress address = new RelyingPartyAddress(); address.Address = RelyingPartyRelayAddress; address.EndpointType = "Reply"; client.AddRelatedObject(relyingParty, "RelyingPartyAddresses", address); client.SaveChanges(SaveChangesOptions.Batch); } } } else { throw new Exception("Failed to get the Relying Parties list from the ACS Management Service."); } }
internal static char SetDelimiter(PSCmdlet Cmdlet, string ParameterSetName, char Delimiter, bool UseCulture) { switch (ParameterSetName) { case "Delimiter": if (Delimiter == '\0') { Delimiter = ','; } return Delimiter; case "UseCulture": if (UseCulture) { string str = Registry.CurrentUser.OpenSubKey(@"Control Panel\International").GetValue("sList").ToString(); if (string.IsNullOrEmpty(str)) { Delimiter = ','; return Delimiter; } Delimiter = str[0]; } return Delimiter; } Delimiter = ','; return Delimiter; }
internal ImportCsvHelper(PSCmdlet cmdlet, char delimiter, IList<string> header, string typeName, StreamReader streamReader) { this._cmdlet = cmdlet; this._delimiter = delimiter; this._header = header; this._typeName = typeName; this._sr = streamReader; }
internal AsyncCommandRuntime(System.Management.Automation.PSCmdlet cmdlet, CancellationToken cancellationToken) { this.originalCommandRuntime = cmdlet.CommandRuntime as ICommandRuntime2; this.originalThread = System.Threading.Thread.CurrentThread; this.cancellationToken = cancellationToken; this.cmdlet = cmdlet; cmdlet.CommandRuntime = this; }
internal TerminatingErrorContext(PSCmdlet command) { if (command == null) { throw PSTraceSource.NewArgumentNullException("command"); } this._command = command; }
internal PSHostTraceListener(PSCmdlet cmdlet) : base("") { this.cachedWrite = new StringBuilder(); if (cmdlet == null) { throw new PSArgumentNullException("cmdlet"); } this.ui = cmdlet.Host.UI as InternalHostUserInterface; }
public object GetVariable(PSCmdlet cmdlet, string name) { if (_variables.ContainsKey(name)) { return _variables[name]; } return null; }
private static void ReportWrongProviderType(string providerId, string errorId, PSCmdlet cmdlet) { ErrorRecord errorRecord = new ErrorRecord( PSTraceSource.NewInvalidOperationException(UpdateDataStrings.UpdateData_WrongProviderError, providerId), errorId, ErrorCategory.InvalidArgument, null); cmdlet.WriteError(errorRecord); }
private static void ReportWrongExtension(string file, string errorId, PSCmdlet cmdlet) { ErrorRecord errorRecord = new ErrorRecord( PSTraceSource.NewInvalidOperationException(UpdateDataStrings.UpdateData_WrongExtension, file, "ps1xml"), errorId, ErrorCategory.InvalidArgument, null); cmdlet.WriteError(errorRecord); }
public GlymaConfiguration(object identity, PSCmdlet cmdlet) { Identity = identity; Load(cmdlet); FindTransactionDbConnectionParameters(); FindMapDbConnectionParameters(); FindSecurityDbConnectionParameters(); }
internal static IOctopusRepository RetrieveSession(PSCmdlet cmdlet) { var octopus = (IOctopusRepository) cmdlet.SessionState.PSVariable.GetValue("OctopusRepository"); if (octopus == null) throw new Exception( "Connection not established. Please connect to your Octopus Deploy instance with Connect-OctoServer"); return octopus; }
internal string ResolveProviderAndPath(string path, bool isLiteralPath, PSCmdlet cmdlet, bool allowNonexistingPaths, string resourceBaseName, string multipeProviderErrorId) { PathInfo info = this.ResolvePath(path, isLiteralPath, allowNonexistingPaths, cmdlet); if (info.Provider.ImplementingType != typeof(FileSystemProvider)) { throw PSTraceSource.NewInvalidOperationException(resourceBaseName, multipeProviderErrorId, new object[] { info.Provider.Name }); } return info.ProviderPath; }
internal CommandInvocationIntrinsics(System.Management.Automation.ExecutionContext context, PSCmdlet cmdlet) { this._context = context; if (cmdlet != null) { this._cmdlet = cmdlet; this.commandRuntime = cmdlet.CommandRuntime as MshCommandRuntime; } }
/// <summary> /// Gets a sql auth connection context. /// </summary> /// <param name="cmdlet">The cmdlet requesting the context</param> /// <param name="serverName">The name of the server to connect to</param> /// <param name="manageUrl">The manage url of the server</param> /// <param name="credentials">The credentials to connect to the server</param> /// <param name="sessionActivityId">The session activity ID</param> /// <param name="managementServiceUri">The URI for management service</param> /// <returns>The connection context</returns> public static IServerDataServiceContext GetContext( PSCmdlet cmdlet, string serverName, Uri manageUrl, SqlAuthenticationCredentials credentials, Guid sessionActivityId, Uri managementServiceUri) { Version version; // If a version was specified (by tests) us it. if (sqlVersion == SqlVersion.v2) { version = new Version(11, 0); } else if (sqlVersion == SqlVersion.v12) { version = new Version(12, 0); } else // If no version specified, determine the version by querying the server. { version = GetVersion(manageUrl, credentials); } sqlVersion = SqlVersion.None; IServerDataServiceContext context = null; if (version.Major >= 12) { context = new TSqlConnectionContext( sessionActivityId, manageUrl.Host, credentials, serverName); } else { context = ServerDataServiceSqlAuth.Create( managementServiceUri, sessionActivityId, credentials, serverName); // Retrieve $metadata to verify model version compatibility XDocument metadata = ((ServerDataServiceSqlAuth)context).RetrieveMetadata(); XDocument filteredMetadata = DataConnectionUtility.FilterMetadataDocument(metadata); string metadataHash = DataConnectionUtility.GetDocumentHash(filteredMetadata); if (!((ServerDataServiceSqlAuth)context).metadataHashes.Any(knownHash => metadataHash == knownHash)) { cmdlet.WriteWarning(Resources.WarningModelOutOfDate); } ((ServerDataServiceSqlAuth)context).MergeOption = MergeOption.PreserveChanges; } return context; }
public object GetVariable(PSCmdlet cmdlet, string name) { PSVariable psVariable = cmdlet.SessionState.PSVariable.Get(name); if (psVariable != null) { return psVariable.Value; } return null; }
public DomainDispatcher(PSCmdlet cmdlet) { // Not using Check here because this assembly is very small and without resources if (cmdlet == null) { throw new ArgumentNullException("cmdlet"); } _cmdlet = cmdlet; _dte = (DTE)cmdlet.GetVariableValue("DTE"); }
internal static MemoryStream ReadStream(Stream stream, long contentLength, PSCmdlet cmdlet) { MemoryStream stream3; if (stream == null) { throw new ArgumentNullException("stream"); } if (!stream.CanRead) { throw new ArgumentOutOfRangeException("stream"); } if (0L >= contentLength) { contentLength = 0x186a0L; } int capacity = (int)Math.Min(contentLength, 0x7fffffffL); MemoryStream stream2 = new MemoryStream(capacity); try { long o = 0L; byte[] buffer = new byte[0x2710]; int count = 1; while (0 < count) { if (cmdlet != null) { ProgressRecord progressRecord = new ProgressRecord(0xa681412, "Reading Web Response", string.Format("Reading response stream... (Number of bytes read: {0})", o)); cmdlet.WriteProgress(progressRecord); } count = stream.Read(buffer, 0, buffer.Length); if (0 < count) { stream2.Write(buffer, 0, count); } o += count; } if (cmdlet != null) { ProgressRecord record2 = new ProgressRecord(0xa681412, "Reading Web Response", string.Format("Reading web response completed. (Number of bytes read: {0})", o)) { RecordType = ProgressRecordType.Completed }; cmdlet.WriteProgress(record2); } stream2.SetLength(o); stream3 = stream2; } catch (Exception) { stream2.Close(); throw; } return stream3; }
internal AsyncCommandRuntime(System.Management.Automation.PSCmdlet cmdlet, CancellationToken cancellationToken) { this.originalCommandRuntime = cmdlet.CommandRuntime as ICommandRuntime2; this.originalThread = System.Threading.Thread.CurrentThread; this.cancellationToken = cancellationToken; this.cmdlet = cmdlet; if (cmdlet.PagingParameters != null) { WriteDebug("Client side pagination is enabled for this cmdlet"); } cmdlet.CommandRuntime = this; }
internal static string GetFilePathOfExistingFile(PSCmdlet cmdlet, string path) { string unresolvedProviderPathFromPSPath = cmdlet.SessionState.Path.GetUnresolvedProviderPathFromPSPath(path); if (!File.Exists(unresolvedProviderPathFromPSPath)) { return null; } else { return unresolvedProviderPathFromPSPath; } }
internal static void WriteToPS1XML(PSCmdlet cmdlet, List<ExtendedTypeDefinition> typeDefinitions, string filepath, bool force, bool noclobber, bool writeScritBlock, bool isLiteralPath) { StreamWriter writer; FileStream stream; FileInfo info; PathUtils.MasterStreamOpen(cmdlet, filepath, "ascii", true, false, force, noclobber, out stream, out writer, out info, isLiteralPath); XmlWriter writer2 = XmlWriter.Create(writer); FormatXMLHelper.WriteToXML(writer2, typeDefinitions, writeScritBlock); writer2.Close(); writer.Close(); stream.Close(); }
internal static void RestartWinRMService(PSCmdlet cmdlet, bool isErrorReported, bool force, bool noServiceRestart) { if (!isErrorReported && !noServiceRestart) { string restartWSManServiceAction = RemotingErrorIdStrings.RestartWSManServiceAction; string target = StringUtil.Format(RemotingErrorIdStrings.RestartWSManServiceTarget, "WinRM"); if (force || cmdlet.ShouldProcess(target, restartWSManServiceAction)) { cmdlet.WriteVerbose(StringUtil.Format(RemotingErrorIdStrings.RestartWSManServiceMessageV, new object[0])); cmdlet.InvokeCommand.NewScriptBlock("restart-service winrm -force -confirm:$false").InvokeUsingCmdlet(cmdlet, true, ScriptBlock.ErrorHandlingBehavior.WriteToCurrentErrorPipe, AutomationNull.Value, new object[0], AutomationNull.Value, new object[0]); } } }
internal ImportXmlHelper(string fileName, PSCmdlet cmdlet, bool isLiteralPath) { if (fileName == null) { throw PSTraceSource.NewArgumentNullException("fileName"); } if (cmdlet == null) { throw PSTraceSource.NewArgumentNullException("cmdlet"); } this._path = fileName; this._cmdlet = cmdlet; this.isLiteralPath = isLiteralPath; }
/// <summary> /// Default constructor used if no. /// </summary> internal PSHostTraceListener(PSCmdlet cmdlet) : base("") { if (cmdlet == null) { throw new PSArgumentNullException("cmdlet"); } Diagnostics.Assert( cmdlet.Host.UI is InternalHostUserInterface, "The internal host must be available to trace"); _ui = cmdlet.Host.UI as InternalHostUserInterface; }
public void Dispose() { if (cmdlet != null) { cmdlet.CommandRuntime = this.originalCommandRuntime; cmdlet = null; } semaphore?.Dispose(); semaphore = null; readyToRun?.Dispose(); readyToRun = null; completed?.Dispose(); completed = null; }
/** * This function takes in a CommandInfo (CmdletInfo or FunctionInfo) * And reads all the deprecation attributes attached to it * Prints a message on the cmdline For each of the attribute found * * the boundParameterNames is a list of parameters bound to the cmdlet at runtime, * We only process the Parameter beaking change attributes attached only params listed in this list (if present) * */ public static void ProcessCustomAttributesAtRuntime(CommandInfo commandInfo, InvocationInfo invocationInfo, String parameterSet, System.Management.Automation.PSCmdlet psCmdlet) { bool supressWarningOrError = false; try { supressWarningOrError = bool.Parse(System.Environment.GetEnvironmentVariable(SUPPRESS_ERROR_OR_WARNING_MESSAGE_ENV_VARIABLE_NAME)); } catch (Exception) { //no action } if (supressWarningOrError) { //Do not process the attributes at runtime... The env variable to override the warning messages is set return; } List <GenericBreakingChangeAttribute> attributes = new List <GenericBreakingChangeAttribute>(GetAllBreakingChangeAttributesInType(commandInfo, invocationInfo, parameterSet)); StringBuilder sb = new StringBuilder(); Action <string> appendBreakingChangeInfo = (string s) => sb.Append(s); if (attributes != null && attributes.Count > 0) { appendBreakingChangeInfo(string.Format(Resources.BreakingChangesAttributesHeaderMessage, commandInfo.Name.Split('_')[0])); foreach (GenericBreakingChangeAttribute attribute in attributes) { attribute.PrintCustomAttributeInfo(appendBreakingChangeInfo); } appendBreakingChangeInfo(string.Format(Resources.BreakingChangesAttributesFooterMessage, BREAKING_CHANGE_ATTRIBUTE_INFORMATION_LINK)); psCmdlet.WriteWarning(sb.ToString()); } List <PreviewMessageAttribute> previewAttributes = new List <PreviewMessageAttribute>(GetAllPreviewAttributesInType(commandInfo, invocationInfo)); if (previewAttributes != null && previewAttributes.Count > 0) { foreach (PreviewMessageAttribute attribute in previewAttributes) { attribute.PrintCustomAttributeInfo(psCmdlet); } } }
internal static void ExportModuleMembers(PSCmdlet cmdlet, SessionStateInternal sessionState, List <WildcardPattern> functionPatterns, List <WildcardPattern> cmdletPatterns, List <WildcardPattern> aliasPatterns, List <WildcardPattern> variablePatterns, List <string> doNotExportCmdlets) { sessionState.UseExportList = true; if (functionPatterns != null) { foreach (KeyValuePair <string, FunctionInfo> pair in sessionState.ModuleScope.FunctionTable) { if (((pair.Value.Options & ScopedItemOptions.AllScope) == ScopedItemOptions.None) && SessionStateUtilities.MatchesAnyWildcardPattern(pair.Key, functionPatterns, false)) { string str; if (pair.Value.CommandType == CommandTypes.Workflow) { str = StringUtil.Format(Modules.ExportingWorkflow, pair.Key); sessionState.ExportedWorkflows.Add((WorkflowInfo)pair.Value); } else { str = StringUtil.Format(Modules.ExportingFunction, pair.Key); sessionState.ExportedFunctions.Add(pair.Value); } cmdlet.WriteVerbose(str); } } SortAndRemoveDuplicates <FunctionInfo>(sessionState.ExportedFunctions, ci => ci.Name); SortAndRemoveDuplicates <WorkflowInfo>(sessionState.ExportedWorkflows, ci => ci.Name); } if (cmdletPatterns != null) { IDictionary <string, List <CmdletInfo> > cmdletTable = sessionState.ModuleScope.CmdletTable; if (sessionState.Module.CompiledExports.Count > 0) { CmdletInfo[] infoArray = sessionState.Module.CompiledExports.ToArray(); sessionState.Module.CompiledExports.Clear(); CmdletInfo[] infoArray2 = infoArray; for (int i = 0; i < infoArray2.Length; i++) { Predicate <string> match = null; CmdletInfo element = infoArray2[i]; if (doNotExportCmdlets != null) { if (match == null) { match = cmdletName => string.Equals(element.FullName, cmdletName, StringComparison.OrdinalIgnoreCase); } if (doNotExportCmdlets.Exists(match)) { continue; } } if (SessionStateUtilities.MatchesAnyWildcardPattern(element.Name, cmdletPatterns, false)) { string text = StringUtil.Format(Modules.ExportingCmdlet, element.Name); cmdlet.WriteVerbose(text); CmdletInfo item = new CmdletInfo(element.Name, element.ImplementingType, element.HelpFile, null, element.Context); item.SetModule(sessionState.Module); sessionState.Module.CompiledExports.Add(item); } } } foreach (KeyValuePair <string, List <CmdletInfo> > pair2 in cmdletTable) { CmdletInfo cmdletToImport = pair2.Value[0]; if (((doNotExportCmdlets == null) || !doNotExportCmdlets.Exists(cmdletName => string.Equals(cmdletToImport.FullName, cmdletName, StringComparison.OrdinalIgnoreCase))) && SessionStateUtilities.MatchesAnyWildcardPattern(pair2.Key, cmdletPatterns, false)) { string str3 = StringUtil.Format(Modules.ExportingCmdlet, pair2.Key); cmdlet.WriteVerbose(str3); CmdletInfo info2 = new CmdletInfo(cmdletToImport.Name, cmdletToImport.ImplementingType, cmdletToImport.HelpFile, null, cmdletToImport.Context); info2.SetModule(sessionState.Module); sessionState.Module.CompiledExports.Add(info2); } } SortAndRemoveDuplicates <CmdletInfo>(sessionState.Module.CompiledExports, ci => ci.Name); } if (variablePatterns != null) { foreach (KeyValuePair <string, PSVariable> pair3 in sessionState.ModuleScope.Variables) { if ((!pair3.Value.IsAllScope && (Array.IndexOf <string>(PSModuleInfo._builtinVariables, pair3.Key) == -1)) && SessionStateUtilities.MatchesAnyWildcardPattern(pair3.Key, variablePatterns, false)) { string str4 = StringUtil.Format(Modules.ExportingVariable, pair3.Key); cmdlet.WriteVerbose(str4); sessionState.ExportedVariables.Add(pair3.Value); } } SortAndRemoveDuplicates <PSVariable>(sessionState.ExportedVariables, v => v.Name); } if (aliasPatterns != null) { foreach (AliasInfo info3 in sessionState.ModuleScope.AliasTable) { if (((info3.Options & ScopedItemOptions.AllScope) == ScopedItemOptions.None) && SessionStateUtilities.MatchesAnyWildcardPattern(info3.Name, aliasPatterns, false)) { string str5 = StringUtil.Format(Modules.ExportingAlias, info3.Name); cmdlet.WriteVerbose(str5); sessionState.ExportedAliases.Add(info3); } } SortAndRemoveDuplicates <AliasInfo>(sessionState.ExportedAliases, ci => ci.Name); } }
internal static void MasterStreamOpen(PSCmdlet cmdlet, string filePath, string encoding, bool defaultEncoding, bool Append, bool Force, bool NoClobber, out FileStream fileStream, out StreamWriter streamWriter, out FileInfo readOnlyFileInfo, bool isLiteralPath) { Encoding resolvedEncoding = EncodingConversion.Convert(cmdlet, encoding); MasterStreamOpen(cmdlet, filePath, resolvedEncoding, defaultEncoding, Append, Force, NoClobber, out fileStream, out streamWriter, out readOnlyFileInfo, isLiteralPath); }
public void PrintCustomAttributeInfo(System.Management.Automation.PSCmdlet psCmdlet) { psCmdlet.WriteWarning(this._message); }
internal CommandInvocationIntrinsics(ExecutionContext context, PSCmdlet cmdlet) { this._context = context; this._cmdlet = cmdlet; this.commandRuntime = cmdlet.CommandRuntime as MshCommandRuntime; }
internal static void MasterStreamOpen(PSCmdlet cmdlet, string filePath, Encoding resolvedEncoding, bool defaultEncoding, bool Append, bool Force, bool NoClobber, out FileStream fileStream, out StreamWriter streamWriter, out FileInfo readOnlyFileInfo, bool isLiteralPath) { fileStream = null; streamWriter = null; readOnlyFileInfo = null; string path = ResolveFilePath(filePath, cmdlet, isLiteralPath); try { FileMode create = FileMode.Create; if (Append) { create = FileMode.Append; } else if (NoClobber) { create = FileMode.CreateNew; } if ((Force && (Append || !NoClobber)) && File.Exists(path)) { FileInfo info = new FileInfo(path); if ((info.Attributes & System.IO.FileAttributes.ReadOnly) == System.IO.FileAttributes.ReadOnly) { readOnlyFileInfo = info; info.Attributes &= ~System.IO.FileAttributes.ReadOnly; } } FileShare share = Force ? FileShare.ReadWrite : FileShare.Read; fileStream = new FileStream(path, create, FileAccess.Write, share); if (defaultEncoding) { streamWriter = new StreamWriter(fileStream); } else { streamWriter = new StreamWriter(fileStream, resolvedEncoding); } } catch (ArgumentException exception) { ReportFileOpenFailure(cmdlet, path, exception); } catch (IOException exception2) { if (NoClobber && File.Exists(path)) { ErrorRecord errorRecord = new ErrorRecord(exception2, "NoClobber", ErrorCategory.ResourceExists, path) { ErrorDetails = new ErrorDetails(cmdlet, "PathUtilsStrings", "UtilityFileExistsNoClobber", new object[] { filePath, "NoClobber" }) }; cmdlet.ThrowTerminatingError(errorRecord); } ReportFileOpenFailure(cmdlet, path, exception2); } catch (UnauthorizedAccessException exception3) { ReportFileOpenFailure(cmdlet, path, exception3); } catch (NotSupportedException exception4) { ReportFileOpenFailure(cmdlet, path, exception4); } catch (SecurityException exception5) { ReportFileOpenFailure(cmdlet, path, exception5); } }
internal static DirectoryInfo CreateModuleDirectory(PSCmdlet cmdlet, string moduleNameOrPath, bool force) { Dbg.Assert(cmdlet != null, "Caller should verify cmdlet != null"); Dbg.Assert(!string.IsNullOrEmpty(moduleNameOrPath), "Caller should verify !string.IsNullOrEmpty(moduleNameOrPath)"); DirectoryInfo directoryInfo = null; try { string rootedPath = Microsoft.PowerShell.Commands.ModuleCmdletBase.ResolveRootedFilePath(moduleNameOrPath, cmdlet.Context); if (string.IsNullOrEmpty(rootedPath) && moduleNameOrPath.StartsWith(".", StringComparison.OrdinalIgnoreCase)) { PathInfo currentPath = cmdlet.CurrentProviderLocation(cmdlet.Context.ProviderNames.FileSystem); rootedPath = Path.Combine(currentPath.ProviderPath, moduleNameOrPath); } if (string.IsNullOrEmpty(rootedPath)) { string personalModuleRoot = ModuleIntrinsics.GetPersonalModulePath(); rootedPath = Path.Combine(personalModuleRoot, moduleNameOrPath); } directoryInfo = new DirectoryInfo(rootedPath); if (directoryInfo.Exists) { if (!force) { string errorMessage = string.Format( CultureInfo.InvariantCulture, // directory name should be treated as culture-invariant PathUtilsStrings.ExportPSSession_ErrorDirectoryExists, directoryInfo.FullName); ErrorDetails details = new ErrorDetails(errorMessage); ErrorRecord errorRecord = new ErrorRecord( new ArgumentException(details.Message), "ExportProxyCommand_OutputDirectoryExists", ErrorCategory.ResourceExists, directoryInfo); cmdlet.ThrowTerminatingError(errorRecord); } } else { directoryInfo.Create(); } } catch (Exception e) { string errorMessage = string.Format( CultureInfo.InvariantCulture, // directory name should be treated as culture-invariant PathUtilsStrings.ExportPSSession_CannotCreateOutputDirectory, moduleNameOrPath, e.Message); ErrorDetails details = new ErrorDetails(errorMessage); ErrorRecord errorRecord = new ErrorRecord( new ArgumentException(details.Message, e), "ExportProxyCommand_CannotCreateOutputDirectory", ErrorCategory.ResourceExists, moduleNameOrPath); cmdlet.ThrowTerminatingError(errorRecord); } return(directoryInfo); }
internal static void ExportModuleMembers( PSCmdlet cmdlet, SessionStateInternal sessionState, List <WildcardPattern> functionPatterns, List <WildcardPattern> cmdletPatterns, List <WildcardPattern> aliasPatterns, List <WildcardPattern> variablePatterns) { sessionState.UseExportList = true; if (functionPatterns != null) { foreach (KeyValuePair <string, FunctionInfo> keyValuePair in (IEnumerable <KeyValuePair <string, FunctionInfo> >)sessionState.ModuleScope.FunctionTable) { if (SessionStateUtilities.MatchesAnyWildcardPattern(keyValuePair.Key, (IEnumerable <WildcardPattern>)functionPatterns, false)) { string text = ResourceManagerCache.FormatResourceString("Modules", "ExportingFunction", (object)keyValuePair.Key); cmdlet.WriteVerbose(text); sessionState.ExportedFunctions.Add(keyValuePair.Value); } } ModuleIntrinsics.SortAndRemoveDuplicates <FunctionInfo>(sessionState.ExportedFunctions, (Converter <FunctionInfo, string>)(ci => ci.Name)); } if (cmdletPatterns != null) { IDictionary <string, List <CmdletInfo> > cmdletCache = (IDictionary <string, List <CmdletInfo> >)sessionState.CmdletCache; if (sessionState.Module.CompiledExports.Count > 0) { CmdletInfo[] array = sessionState.Module.CompiledExports.ToArray(); sessionState.Module.CompiledExports.Clear(); foreach (CmdletInfo cmdletInfo1 in array) { if (SessionStateUtilities.MatchesAnyWildcardPattern(cmdletInfo1.Name, (IEnumerable <WildcardPattern>)cmdletPatterns, false)) { string text = ResourceManagerCache.FormatResourceString("Modules", "ExportingCmdlet", (object)cmdletInfo1.Name); cmdlet.WriteVerbose(text); CmdletInfo cmdletInfo2 = new CmdletInfo(cmdletInfo1.Name, cmdletInfo1.ImplementingType, cmdletInfo1.HelpFile, (PSSnapInInfo)null, cmdletInfo1.Context); cmdletInfo2.SetModule(sessionState.Module); sessionState.Module.CompiledExports.Add(cmdletInfo2); } } } foreach (KeyValuePair <string, List <CmdletInfo> > keyValuePair in (IEnumerable <KeyValuePair <string, List <CmdletInfo> > >)cmdletCache) { if (SessionStateUtilities.MatchesAnyWildcardPattern(keyValuePair.Key, (IEnumerable <WildcardPattern>)cmdletPatterns, false)) { string text = ResourceManagerCache.FormatResourceString("Modules", "ExportingCmdlet", (object)keyValuePair.Key); cmdlet.WriteVerbose(text); CmdletInfo cmdletInfo1 = keyValuePair.Value[0]; CmdletInfo cmdletInfo2 = new CmdletInfo(cmdletInfo1.Name, cmdletInfo1.ImplementingType, cmdletInfo1.HelpFile, (PSSnapInInfo)null, cmdletInfo1.Context); cmdletInfo2.SetModule(sessionState.Module); sessionState.Module.CompiledExports.Add(cmdletInfo2); } } ModuleIntrinsics.SortAndRemoveDuplicates <CmdletInfo>(sessionState.Module.CompiledExports, (Converter <CmdletInfo, string>)(ci => ci.Name)); } if (variablePatterns != null) { foreach (KeyValuePair <string, PSVariable> variable in (IEnumerable <KeyValuePair <string, PSVariable> >)sessionState.ModuleScope.Variables) { if (!variable.Value.IsAllScope && Array.IndexOf <string>(PSModuleInfo.builtinVariables, variable.Key) == -1 && SessionStateUtilities.MatchesAnyWildcardPattern(variable.Key, (IEnumerable <WildcardPattern>)variablePatterns, false)) { string text = ResourceManagerCache.FormatResourceString("Modules", "ExportingVariable", (object)variable.Key); cmdlet.WriteVerbose(text); sessionState.ExportedVariables.Add(variable.Value); } } ModuleIntrinsics.SortAndRemoveDuplicates <PSVariable>(sessionState.ExportedVariables, (Converter <PSVariable, string>)(v => v.Name)); } if (aliasPatterns == null) { return; } foreach (AliasInfo aliasInfo in sessionState.ModuleScope.AliasTable) { if ((aliasInfo.Options & ScopedItemOptions.AllScope) == ScopedItemOptions.None && SessionStateUtilities.MatchesAnyWildcardPattern(aliasInfo.Name, (IEnumerable <WildcardPattern>)aliasPatterns, false)) { string text = ResourceManagerCache.FormatResourceString("Modules", "ExportingAlias", (object)aliasInfo.Name); cmdlet.WriteVerbose(text); sessionState.ExportedAliases.Add(aliasInfo); } } ModuleIntrinsics.SortAndRemoveDuplicates <AliasInfo>(sessionState.ExportedAliases, (Converter <AliasInfo, string>)(ci => ci.Name)); }
internal static StreamReader OpenStreamReader(PSCmdlet command, string filePath, Encoding encoding, bool isLiteralPath) { FileStream fileStream = OpenFileStream(filePath, command, isLiteralPath); return(new StreamReader(fileStream, encoding)); }
/// <summary> /// Resolve a user provided file name or path (including globbing characters) /// to a fully qualified file path, using the file system provider. /// </summary> /// <param name="filePath"></param> /// <param name="command"></param> /// <returns></returns> internal static string ResolveFilePath(string filePath, PSCmdlet command) { return(ResolveFilePath(filePath, command, false)); }
internal static DirectoryInfo CreateModuleDirectory(PSCmdlet cmdlet, string moduleNameOrPath, bool force) { Dbg.Assert(cmdlet != null, "Caller should verify cmdlet != null"); Dbg.Assert(!string.IsNullOrEmpty(moduleNameOrPath), "Caller should verify !string.IsNullOrEmpty(moduleNameOrPath)"); DirectoryInfo directoryInfo = null; try { // Even if 'moduleNameOrPath' is a rooted path, 'ResolveRootedFilePath' may return null when the path doesn't exist yet, // or when it contains wildcards but cannot be resolved to a single path. string rootedPath = ModuleCmdletBase.ResolveRootedFilePath(moduleNameOrPath, cmdlet.Context); if (string.IsNullOrEmpty(rootedPath) && moduleNameOrPath.StartsWith('.')) { PathInfo currentPath = cmdlet.CurrentProviderLocation(cmdlet.Context.ProviderNames.FileSystem); rootedPath = Path.Combine(currentPath.ProviderPath, moduleNameOrPath); } if (string.IsNullOrEmpty(rootedPath)) { if (Path.IsPathRooted(moduleNameOrPath)) { rootedPath = moduleNameOrPath; } else { string personalModuleRoot = ModuleIntrinsics.GetPersonalModulePath(); if (string.IsNullOrEmpty(personalModuleRoot)) { cmdlet.ThrowTerminatingError( new ErrorRecord( new ArgumentException(StringUtil.Format(PathUtilsStrings.ExportPSSession_ErrorModuleNameOrPath, moduleNameOrPath)), "ExportPSSession_ErrorModuleNameOrPath", ErrorCategory.InvalidArgument, cmdlet)); } rootedPath = Path.Combine(personalModuleRoot, moduleNameOrPath); } } directoryInfo = new DirectoryInfo(rootedPath); if (directoryInfo.Exists) { if (!force) { string errorMessage = string.Format( CultureInfo.InvariantCulture, // directory name should be treated as culture-invariant PathUtilsStrings.ExportPSSession_ErrorDirectoryExists, directoryInfo.FullName); ErrorDetails details = new ErrorDetails(errorMessage); ErrorRecord errorRecord = new ErrorRecord( new ArgumentException(details.Message), "ExportProxyCommand_OutputDirectoryExists", ErrorCategory.ResourceExists, directoryInfo); cmdlet.ThrowTerminatingError(errorRecord); } } else { directoryInfo.Create(); } } catch (Exception e) { string errorMessage = string.Format( CultureInfo.InvariantCulture, // directory name should be treated as culture-invariant PathUtilsStrings.ExportPSSession_CannotCreateOutputDirectory, moduleNameOrPath, e.Message); ErrorDetails details = new ErrorDetails(errorMessage); ErrorRecord errorRecord = new ErrorRecord( new ArgumentException(details.Message, e), "ExportProxyCommand_CannotCreateOutputDirectory", ErrorCategory.ResourceExists, moduleNameOrPath); cmdlet.ThrowTerminatingError(errorRecord); } return(directoryInfo); }
/// <summary> /// THE method for opening a file for writing. /// Should be used by all cmdlets that write to a file. /// </summary> /// <param name="cmdlet">Cmdlet that is opening the file (used mainly for error reporting).</param> /// <param name="filePath">Path to the file (as specified on the command line - this method will resolve the path).</param> /// <param name="resolvedEncoding">Encoding (this method will convert the command line string to an Encoding instance).</param> /// <param name="defaultEncoding">If <see langword="true"/>, then we will use default .NET encoding instead of the encoding specified in <paramref name="encoding"/> parameter.</param> /// <param name="Append"></param> /// <param name="Force"></param> /// <param name="NoClobber"></param> /// <param name="fileStream">Result1: <see cref="FileStream"/> opened for writing.</param> /// <param name="streamWriter">Result2: <see cref="StreamWriter"/> (inherits from <see cref="TextWriter"/>) opened for writing.</param> /// <param name="readOnlyFileInfo">Result3: file info that should be used to restore file attributes after done with the file (<see langword="null"/> is this is not needed).</param> /// <param name="isLiteralPath">True if wildcard expansion should be bypassed.</param> internal static void MasterStreamOpen( PSCmdlet cmdlet, string filePath, Encoding resolvedEncoding, bool defaultEncoding, bool Append, bool Force, bool NoClobber, out FileStream fileStream, out StreamWriter streamWriter, out FileInfo readOnlyFileInfo, bool isLiteralPath) { fileStream = null; streamWriter = null; readOnlyFileInfo = null; // resolve the path and the encoding string resolvedPath = ResolveFilePath(filePath, cmdlet, isLiteralPath); try { // variable to track file open mode // this is controlled by append/force parameters FileMode mode = FileMode.Create; if (Append) { mode = FileMode.Append; } else if (NoClobber) { // throw IOException if file exists mode = FileMode.CreateNew; } if (Force && (Append || !NoClobber)) { if (File.Exists(resolvedPath)) { FileInfo fInfo = new FileInfo(resolvedPath); if ((fInfo.Attributes & FileAttributes.ReadOnly) == FileAttributes.ReadOnly) { // remember to reset the read-only attribute later readOnlyFileInfo = fInfo; // Clear the read-only attribute fInfo.Attributes &= ~(FileAttributes.ReadOnly); } } } // if the user knows what he/she is doing and uses "-Force" switch, // then we let more than 1 process write to the same file at the same time FileShare fileShare = Force ? FileShare.ReadWrite : FileShare.Read; // mode is controlled by force and ShouldContinue() fileStream = new FileStream(resolvedPath, mode, FileAccess.Write, fileShare); // create stream writer // NTRAID#Windows Out Of Band Releases-931008-2006/03/27 // For some reason, calling this without specifying // the encoding is different from passing Encoding.Default. if (defaultEncoding) { streamWriter = new StreamWriter(fileStream); } else { streamWriter = new StreamWriter(fileStream, resolvedEncoding); } } // These are the known exceptions for File.Load and StreamWriter.ctor catch (ArgumentException e) { // NOTE: this call will throw ReportFileOpenFailure(cmdlet, resolvedPath, e); } catch (IOException e) { if (NoClobber && File.Exists(resolvedPath)) { // This probably happened because the file already exists ErrorRecord errorRecord = new ErrorRecord( e, "NoClobber", ErrorCategory.ResourceExists, resolvedPath); errorRecord.ErrorDetails = new ErrorDetails( cmdlet, "PathUtilsStrings", "UtilityFileExistsNoClobber", filePath, "NoClobber"); // prevents localization // NOTE: this call will throw cmdlet.ThrowTerminatingError(errorRecord); } // NOTE: this call will throw ReportFileOpenFailure(cmdlet, resolvedPath, e); } catch (UnauthorizedAccessException e) { // NOTE: this call will throw ReportFileOpenFailure(cmdlet, resolvedPath, e); } catch (NotSupportedException e) { // NOTE: this call will throw ReportFileOpenFailure(cmdlet, resolvedPath, e); } catch (System.Security.SecurityException e) { // NOTE: this call will throw ReportFileOpenFailure(cmdlet, resolvedPath, e); } }
private static IEnumerable <PSObject> InvokeTopLevelPowerShell( PowerShell powerShell, CancellationToken cancellationToken, PSCmdlet cmdlet, PSInvocationSettings invocationSettings, string errorMessageTemplate) { using (var mergedOutput = new BlockingCollection <Func <PSCmdlet, IEnumerable <PSObject> > >(s_blockingCollectionCapacity)) { var asyncOutput = new PSDataCollection <PSObject>(); EventHandler <DataAddedEventArgs> outputHandler = GetStreamForwarder <PSObject>( output => mergedOutput.Add(_ => new[] { output }), swallowInvalidOperationExceptions: true); EventHandler <DataAddedEventArgs> errorHandler = GetStreamForwarder <ErrorRecord>( errorRecord => mergedOutput.Add( delegate(PSCmdlet c) { errorRecord = GetErrorRecordForRemotePipelineInvocation(errorRecord, errorMessageTemplate); HandleErrorFromPipeline(c, errorRecord, powerShell); return(Enumerable.Empty <PSObject>()); }), swallowInvalidOperationExceptions: true); EventHandler <DataAddedEventArgs> warningHandler = GetStreamForwarder <WarningRecord>( warningRecord => mergedOutput.Add( delegate(PSCmdlet c) { c.WriteWarning(warningRecord.Message); return(Enumerable.Empty <PSObject>()); }), swallowInvalidOperationExceptions: true); EventHandler <DataAddedEventArgs> verboseHandler = GetStreamForwarder <VerboseRecord>( verboseRecord => mergedOutput.Add( delegate(PSCmdlet c) { c.WriteVerbose(verboseRecord.Message); return(Enumerable.Empty <PSObject>()); }), swallowInvalidOperationExceptions: true); EventHandler <DataAddedEventArgs> debugHandler = GetStreamForwarder <DebugRecord>( debugRecord => mergedOutput.Add( delegate(PSCmdlet c) { c.WriteDebug(debugRecord.Message); return(Enumerable.Empty <PSObject>()); }), swallowInvalidOperationExceptions: true); EventHandler <DataAddedEventArgs> informationHandler = GetStreamForwarder <InformationRecord>( informationRecord => mergedOutput.Add( delegate(PSCmdlet c) { c.WriteInformation(informationRecord); return(Enumerable.Empty <PSObject>()); }), swallowInvalidOperationExceptions: true); asyncOutput.DataAdded += outputHandler; powerShell.Streams.Error.DataAdded += errorHandler; powerShell.Streams.Warning.DataAdded += warningHandler; powerShell.Streams.Verbose.DataAdded += verboseHandler; powerShell.Streams.Debug.DataAdded += debugHandler; powerShell.Streams.Information.DataAdded += informationHandler; try { // TODO/FIXME: ETW event for PowerShell invocation var asyncResult = powerShell.BeginInvoke <PSObject, PSObject>( input: null, output: asyncOutput, settings: invocationSettings, callback: delegate { try { mergedOutput.CompleteAdding(); } catch (InvalidOperationException) // ignore exceptions thrown because mergedOutput.CompleteAdding was called { } }, state: null); using (cancellationToken.Register(powerShell.Stop)) { try { foreach (Func <PSCmdlet, IEnumerable <PSObject> > mergedOutputItem in mergedOutput.GetConsumingEnumerable()) { foreach (PSObject outputObject in mergedOutputItem(cmdlet)) { yield return(outputObject); } } } finally { mergedOutput.CompleteAdding(); powerShell.EndInvoke(asyncResult); } } } finally { asyncOutput.DataAdded -= outputHandler; powerShell.Streams.Error.DataAdded -= errorHandler; powerShell.Streams.Warning.DataAdded -= warningHandler; powerShell.Streams.Verbose.DataAdded -= verboseHandler; powerShell.Streams.Debug.DataAdded -= debugHandler; powerShell.Streams.Information.DataAdded -= informationHandler; } } }