private bool VerifyShadowingExistingCommandsAndWriteError(string aliasName) { CommandSearcher searcher = new CommandSearcher(aliasName, SearchResolutionOptions.None, CommandTypes.All ^ CommandTypes.Alias, this.Context); foreach (string expandedCommandName in searcher.ConstructSearchPatternsFromName(aliasName)) { CommandTypes commandTypeOfExistingCommand; if (this.ExistingCommands.TryGetValue(expandedCommandName, out commandTypeOfExistingCommand)) { // Since the alias already exists, write an error. SessionStateException aliasExists = new SessionStateException( aliasName, SessionStateCategory.Alias, "AliasAlreadyExists", SessionStateStrings.AliasWithCommandNameAlreadyExists, ErrorCategory.ResourceExists, commandTypeOfExistingCommand); WriteError( new ErrorRecord( aliasExists.ErrorRecord, aliasExists)); return(true); } } return(false); }
protected internal void WriteError(SessionStateException ex) { string errorId = String.Format("{0},{1}", ex.ErrorRecord.ErrorId, GetType().FullName); var error = new ErrorRecord(ex, errorId, ex.ErrorRecord.CategoryInfo.Category, ex.ItemName); error.CategoryInfo.Activity = GetActivityName(); WriteError(error); }
private void WriteVariableAlreadyExistsError(PSVariable variable) { var ex = new SessionStateException( String.Format("A variable with name '{0}' already exists.", variable.Name), variable.Name, SessionStateCategory.Variable); string errorId = String.Format("VariableAlreadyExists,{0}", typeof(NewVariableCommand).FullName); var error = new ErrorRecord(ex, errorId, ErrorCategory.ResourceExists, variable.Name); error.CategoryInfo.Activity = "New-Variable"; WriteError(error); }
private bool VerifyShadowingExistingCommandsAndWriteError(string aliasName) { CommandSearcher searcher = new CommandSearcher(aliasName, SearchResolutionOptions.None, CommandTypes.Workflow | CommandTypes.Script | CommandTypes.Application | CommandTypes.ExternalScript | CommandTypes.Cmdlet | CommandTypes.Filter | CommandTypes.Function, base.Context); foreach (string str in searcher.ConstructSearchPatternsFromName(aliasName)) { CommandTypes types; if (this.ExistingCommands.TryGetValue(str, out types)) { SessionStateException replaceParentContainsErrorRecordException = new SessionStateException(aliasName, SessionStateCategory.Alias, "AliasAlreadyExists", SessionStateStrings.AliasWithCommandNameAlreadyExists, ErrorCategory.ResourceExists, new object[] { types }); base.WriteError(new ErrorRecord(replaceParentContainsErrorRecordException.ErrorRecord, replaceParentContainsErrorRecordException)); return(true); } } return(false); }
/// <summary> /// Add objects received on the pipeline to an ArrayList of values, to /// take the place of the Value parameter if none was specified on the /// command line. /// </summary> protected override void ProcessRecord() { // If Force is not specified, see if the variable already exists // in the specified scope. If the scope isn't specified, then // check to see if it exists in the current scope. if (!Force) { PSVariable varFound = null; if (string.IsNullOrEmpty(Scope)) { varFound = SessionState.PSVariable.GetAtScope(Name, "local"); } else { varFound = SessionState.PSVariable.GetAtScope(Name, Scope); } if (varFound != null) { SessionStateException sessionStateException = new SessionStateException( Name, SessionStateCategory.Variable, "VariableAlreadyExists", SessionStateStrings.VariableAlreadyExists, ErrorCategory.ResourceExists); WriteError( new ErrorRecord( sessionStateException.ErrorRecord, sessionStateException)); return; } } // Since the variable doesn't exist or -Force was specified, // Call should process to validate the set with the user. string action = VariableCommandStrings.NewVariableAction; string target = StringUtil.Format(VariableCommandStrings.NewVariableTarget, Name, Value); if (ShouldProcess(target, action)) { PSVariable newVariable = new PSVariable(Name, Value, Option); if (_visibility != null) { newVariable.Visibility = (SessionStateEntryVisibility)_visibility; } if (Description != null) { newVariable.Description = Description; } try { if (string.IsNullOrEmpty(Scope)) { SessionState.Internal.NewVariable(newVariable, Force); } else { SessionState.Internal.NewVariableAtScope(newVariable, Scope, Force); } } catch (SessionStateException sessionStateException) { WriteError( new ErrorRecord( sessionStateException.ErrorRecord, sessionStateException)); return; } catch (PSArgumentException argException) { WriteError( new ErrorRecord( argException.ErrorRecord, argException)); return; } if (_passThru) { WriteObject(newVariable); } } }
/// <summary> /// The main processing loop of the command. /// </summary> /// protected override void ProcessRecord() { // If not force, then see if the alias already exists if (!Force) { AliasInfo existingAlias = null; if (String.IsNullOrEmpty(Scope)) { existingAlias = SessionState.Internal.GetAlias(Name); } else { existingAlias = SessionState.Internal.GetAliasAtScope(Name, Scope); } if (existingAlias != null) { // Throw if alias exists and is private... SessionState.ThrowIfNotVisible(this.CommandOrigin, existingAlias); // Since the alias already exists, write an error. SessionStateException aliasExists = new SessionStateException( Name, SessionStateCategory.Alias, "AliasAlreadyExists", SessionStateStrings.AliasAlreadyExists, ErrorCategory.ResourceExists); WriteError( new ErrorRecord( aliasExists.ErrorRecord, aliasExists)); return; } } // Create the alias info AliasInfo newAlias = new AliasInfo( Name, Value, Context, Option); newAlias.Description = Description; string action = AliasCommandStrings.NewAliasAction; string target = StringUtil.Format(AliasCommandStrings.NewAliasTarget, Name, Value); if (ShouldProcess(target, action)) { // Set the alias in the specified scope or the // current scope. AliasInfo result = null; try { if (String.IsNullOrEmpty(Scope)) { result = SessionState.Internal.SetAliasItem(newAlias, Force, MyInvocation.CommandOrigin); } else { result = SessionState.Internal.SetAliasItemAtScope(newAlias, Scope, Force, MyInvocation.CommandOrigin); } } catch (SessionStateException sessionStateException) { WriteError( new ErrorRecord( sessionStateException.ErrorRecord, sessionStateException)); return; } catch (PSArgumentOutOfRangeException argOutOfRange) { WriteError( new ErrorRecord( argOutOfRange.ErrorRecord, argOutOfRange)); return; } catch (PSArgumentException argException) { WriteError( new ErrorRecord( argException.ErrorRecord, argException)); return; } // Write the alias to the pipeline if PassThru was specified if (PassThru && result != null) { WriteObject(result); } } } // ProcessRecord
/// <summary> /// The main processing loop of the command. /// </summary> /// protected override void ProcessRecord() { Collection <AliasInfo> importedAliases = GetAliasesFromFile(this.ParameterSetName.Equals(LiteralPathParameterSetName, StringComparison.OrdinalIgnoreCase)); CommandOrigin origin = MyInvocation.CommandOrigin; foreach (AliasInfo alias in importedAliases) { // If not force, then see if the alias already exists // NTRAID#Windows Out Of Band Releases-906910-2006/03/17-JonN string action = AliasCommandStrings.ImportAliasAction; string target = StringUtil.Format(AliasCommandStrings.ImportAliasTarget, alias.Name, alias.Definition); if (!ShouldProcess(target, action)) { continue; } if (!Force) { AliasInfo existingAlias = null; if (String.IsNullOrEmpty(Scope)) { existingAlias = SessionState.Internal.GetAlias(alias.Name); } else { existingAlias = SessionState.Internal.GetAliasAtScope(alias.Name, Scope); } if (existingAlias != null) { // Write an error for aliases that aren't visible... try { SessionState.ThrowIfNotVisible(origin, existingAlias); } catch (SessionStateException sessionStateException) { WriteError( new ErrorRecord( sessionStateException.ErrorRecord, sessionStateException)); // Only report the error once... continue; } // Since the alias already exists, write an error. SessionStateException aliasExists = new SessionStateException( alias.Name, SessionStateCategory.Alias, "AliasAlreadyExists", SessionStateStrings.AliasAlreadyExists, ErrorCategory.ResourceExists); WriteError( new ErrorRecord( aliasExists.ErrorRecord, aliasExists)); continue; } if (VerifyShadowingExistingCommandsAndWriteError(alias.Name)) { continue; } } // if (!Force) // Set the alias in the specified scope or the // current scope. AliasInfo result = null; try { if (String.IsNullOrEmpty(Scope)) { result = SessionState.Internal.SetAliasItem(alias, Force, MyInvocation.CommandOrigin); } else { result = SessionState.Internal.SetAliasItemAtScope(alias, Scope, Force, MyInvocation.CommandOrigin); } } catch (SessionStateException sessionStateException) { WriteError( new ErrorRecord( sessionStateException.ErrorRecord, sessionStateException)); continue; } catch (PSArgumentOutOfRangeException argOutOfRange) { WriteError( new ErrorRecord( argOutOfRange.ErrorRecord, argOutOfRange)); continue; } catch (PSArgumentException argException) { WriteError( new ErrorRecord( argException.ErrorRecord, argException)); continue; } // Write the alias to the pipeline if PassThru was specified if (PassThru && result != null) { WriteObject(result); } } } // ProcessRecord
protected override void ProcessRecord() { Collection <AliasInfo> aliasesFromFile = this.GetAliasesFromFile(base.ParameterSetName.Equals("ByLiteralPath", StringComparison.OrdinalIgnoreCase)); CommandOrigin commandOrigin = base.MyInvocation.CommandOrigin; foreach (AliasInfo info in aliasesFromFile) { string importAliasAction = AliasCommandStrings.ImportAliasAction; string target = StringUtil.Format(AliasCommandStrings.ImportAliasTarget, info.Name, info.Definition); if (base.ShouldProcess(target, importAliasAction)) { if (this.Force == 0) { AliasInfo valueToCheck = null; if (string.IsNullOrEmpty(this.Scope)) { valueToCheck = base.SessionState.Internal.GetAlias(info.Name); } else { valueToCheck = base.SessionState.Internal.GetAliasAtScope(info.Name, this.Scope); } if (valueToCheck != null) { try { SessionState.ThrowIfNotVisible(commandOrigin, valueToCheck); } catch (SessionStateException exception) { base.WriteError(new ErrorRecord(exception.ErrorRecord, exception)); continue; } SessionStateException replaceParentContainsErrorRecordException = new SessionStateException(info.Name, SessionStateCategory.Alias, "AliasAlreadyExists", SessionStateStrings.AliasAlreadyExists, ErrorCategory.ResourceExists, new object[0]); base.WriteError(new ErrorRecord(replaceParentContainsErrorRecordException.ErrorRecord, replaceParentContainsErrorRecordException)); continue; } if (this.VerifyShadowingExistingCommandsAndWriteError(info.Name)) { continue; } } AliasInfo sendToPipeline = null; try { if (string.IsNullOrEmpty(this.Scope)) { sendToPipeline = base.SessionState.Internal.SetAliasItem(info, (bool)this.Force, base.MyInvocation.CommandOrigin); } else { sendToPipeline = base.SessionState.Internal.SetAliasItemAtScope(info, this.Scope, (bool)this.Force, base.MyInvocation.CommandOrigin); } } catch (SessionStateException exception3) { base.WriteError(new ErrorRecord(exception3.ErrorRecord, exception3)); continue; } catch (PSArgumentOutOfRangeException exception4) { base.WriteError(new ErrorRecord(exception4.ErrorRecord, exception4)); continue; } catch (PSArgumentException exception5) { base.WriteError(new ErrorRecord(exception5.ErrorRecord, exception5)); continue; } if ((this.PassThru != 0) && (sendToPipeline != null)) { base.WriteObject(sendToPipeline); } } } }
protected override void ProcessRecord() { ProviderInfo singleProvider = null; try { singleProvider = base.SessionState.Internal.GetSingleProvider(this.PSProvider); } catch (ProviderNotFoundException providerNotFoundException1) { ProviderNotFoundException providerNotFoundException = providerNotFoundException1; base.WriteError(new ErrorRecord(providerNotFoundException.ErrorRecord, providerNotFoundException)); return; } if (singleProvider != null) { string newDriveConfirmAction = NavigationResources.NewDriveConfirmAction; string newDriveConfirmResourceTemplate = NavigationResources.NewDriveConfirmResourceTemplate; object[] name = new object[3]; name[0] = this.Name; name[1] = singleProvider.FullName; name[2] = this.Root; string str = string.Format(Thread.CurrentThread.CurrentCulture, newDriveConfirmResourceTemplate, name); if (base.ShouldProcess(str, newDriveConfirmAction)) { if (this.Persist && !singleProvider.Name.Equals("FileSystem", StringComparison.OrdinalIgnoreCase)) { ErrorRecord errorRecord = new ErrorRecord(new NotSupportedException(FileSystemProviderStrings.PersistNotSupported), "DriveRootNotNetworkPath", ErrorCategory.InvalidArgument, this); base.ThrowTerminatingError(errorRecord); } PSDriveInfo pSDriveInfo = new PSDriveInfo(this.Name, singleProvider, this.Root, this.Description, base.Credential, this.Persist); try { base.SessionState.Drive.New(pSDriveInfo, this.Scope, this.CmdletProviderContext); } catch (PSNotSupportedException pSNotSupportedException1) { PSNotSupportedException pSNotSupportedException = pSNotSupportedException1; base.WriteError(new ErrorRecord(pSNotSupportedException.ErrorRecord, pSNotSupportedException)); } catch (DriveNotFoundException driveNotFoundException1) { DriveNotFoundException driveNotFoundException = driveNotFoundException1; base.WriteError(new ErrorRecord(driveNotFoundException.ErrorRecord, driveNotFoundException)); } catch (ProviderNotFoundException providerNotFoundException3) { ProviderNotFoundException providerNotFoundException2 = providerNotFoundException3; base.WriteError(new ErrorRecord(providerNotFoundException2.ErrorRecord, providerNotFoundException2)); } catch (PSArgumentException pSArgumentException1) { PSArgumentException pSArgumentException = pSArgumentException1; base.WriteError(new ErrorRecord(pSArgumentException.ErrorRecord, pSArgumentException)); } catch (ItemNotFoundException itemNotFoundException1) { ItemNotFoundException itemNotFoundException = itemNotFoundException1; base.WriteError(new ErrorRecord(itemNotFoundException.ErrorRecord, itemNotFoundException)); } catch (SessionStateOverflowException sessionStateOverflowException) { throw; } catch (SessionStateException sessionStateException1) { SessionStateException sessionStateException = sessionStateException1; base.WriteError(new ErrorRecord(sessionStateException.ErrorRecord, sessionStateException)); } } } }
protected override void ProcessRecord() { if (base.Force == 0) { AliasInfo valueToCheck = null; if (string.IsNullOrEmpty(base.Scope)) { valueToCheck = base.SessionState.Internal.GetAlias(base.Name); } else { valueToCheck = base.SessionState.Internal.GetAliasAtScope(base.Name, base.Scope); } if (valueToCheck != null) { SessionState.ThrowIfNotVisible(base.CommandOrigin, valueToCheck); SessionStateException replaceParentContainsErrorRecordException = new SessionStateException(base.Name, SessionStateCategory.Alias, "AliasAlreadyExists", SessionStateStrings.AliasAlreadyExists, ErrorCategory.ResourceExists, new object[0]); base.WriteError(new ErrorRecord(replaceParentContainsErrorRecordException.ErrorRecord, replaceParentContainsErrorRecordException)); return; } } AliasInfo alias = new AliasInfo(base.Name, base.Value, base.Context, base.Option) { Description = base.Description }; string newAliasAction = AliasCommandStrings.NewAliasAction; string target = StringUtil.Format(AliasCommandStrings.NewAliasTarget, base.Name, base.Value); if (base.ShouldProcess(target, newAliasAction)) { AliasInfo sendToPipeline = null; try { if (string.IsNullOrEmpty(base.Scope)) { sendToPipeline = base.SessionState.Internal.SetAliasItem(alias, (bool)base.Force, base.MyInvocation.CommandOrigin); } else { sendToPipeline = base.SessionState.Internal.SetAliasItemAtScope(alias, base.Scope, (bool)base.Force, base.MyInvocation.CommandOrigin); } } catch (SessionStateException exception2) { base.WriteError(new ErrorRecord(exception2.ErrorRecord, exception2)); return; } catch (PSArgumentOutOfRangeException exception3) { base.WriteError(new ErrorRecord(exception3.ErrorRecord, exception3)); return; } catch (PSArgumentException exception4) { base.WriteError(new ErrorRecord(exception4.ErrorRecord, exception4)); return; } if ((base.PassThru != 0) && (sendToPipeline != null)) { base.WriteObject(sendToPipeline); } } }
protected override void ProcessRecord() { if (this.Force == 0) { PSVariable atScope = null; if (string.IsNullOrEmpty(base.Scope)) { atScope = base.SessionState.PSVariable.GetAtScope(this.name, "local"); } else { atScope = base.SessionState.PSVariable.GetAtScope(this.name, base.Scope); } if (atScope != null) { SessionStateException replaceParentContainsErrorRecordException = new SessionStateException(this.name, SessionStateCategory.Variable, "VariableAlreadyExists", SessionStateStrings.VariableAlreadyExists, ErrorCategory.ResourceExists, new object[0]); base.WriteError(new ErrorRecord(replaceParentContainsErrorRecordException.ErrorRecord, replaceParentContainsErrorRecordException)); return; } } string newVariableAction = VariableCommandStrings.NewVariableAction; string target = StringUtil.Format(VariableCommandStrings.NewVariableTarget, this.Name, this.Value); if (base.ShouldProcess(target, newVariableAction)) { PSVariable variable = new PSVariable(this.name, this._value, this.options); if (this._visibility.HasValue) { variable.Visibility = this._visibility.Value; } if (this.description != null) { variable.Description = this.description; } try { if (string.IsNullOrEmpty(base.Scope)) { base.SessionState.Internal.NewVariable(variable, (bool)this.Force); } else { base.SessionState.Internal.NewVariableAtScope(variable, base.Scope, (bool)this.Force); } } catch (SessionStateException exception2) { base.WriteError(new ErrorRecord(exception2.ErrorRecord, exception2)); return; } catch (PSArgumentException exception3) { base.WriteError(new ErrorRecord(exception3.ErrorRecord, exception3)); return; } if (this.passThru) { base.WriteObject(variable); } } }