/// <summary> /// Send the specified warning record to client. /// </summary> /// <param name="record">Warning record.</param> internal void SendWarningRecordToClient(WarningRecord record) { record.SerializeExtendedInfo = (_streamSerializationOptions & RemoteStreamOptions.AddInvocationInfoToWarningRecord) != 0; SendDataAsync(RemotingEncoder.GeneratePowerShellInformational( record, _clientRunspacePoolId, _clientPowerShellId, RemotingDataType.PowerShellWarning)); }
internal void AddWarning(WarningRecord item) { if (this.warning != null) { this.warning.InternalAdd(this.psInstanceId, item); } }
internal void SendWarningRecordToClient(WarningRecord record) { using (ServerPowerShellDataStructureHandler.tracer.TraceMethod()) { record.SerializeExtendedInfo = (this.streamSerializationOptions & RemoteStreamOptions.AddInvocationInfoToWarningRecord) != (RemoteStreamOptions)0; this.SendDataAsync(RemotingEncoder.GeneratePowerShellInformational((object)record, this.clientRunspacePoolId, this.clientPowerShellId, RemotingDataType.PowerShellWarning)); } }
private void HandleWarningAdded(object sender, DataAddedEventArgs eventArgs) { int index = eventArgs.Index; PowerShell pipelinePowerShell = this.GetPipelinePowerShell(this.remotePipeline, eventArgs.PowerShellInstanceId); if (pipelinePowerShell != null) { WarningRecord item = pipelinePowerShell.Streams.Warning[index]; base.Warning.Add(item); base.Results.Add(new PSStreamObject(PSStreamObjectType.WarningRecord, item)); } }
private void HandleWarningAdded(object sender, DataAddedEventArgs eventArgs) { int index = eventArgs.Index; lock (this.syncObject) { int num2 = !this.extraPowerShellAlreadyScheduled ? 0 : 1; if ((num2 == 0) && !this.datasent[num2]) { WarningRecord record = this.localPowerShell.Streams.Warning[index]; this.localPowerShell.Streams.Warning.RemoveAt(index); this.dsHandler.SendWarningRecordToClient(record); } } }
private void HandleWarningAdded(object sender, DataAddedEventArgs eventArgs) { using (ServerPowerShellDriver.tracer.TraceEventHandlers()) { int index = eventArgs.Index; lock (this.syncObject) { if (this.datasent) { return; } WarningRecord record = this.localPowerShell.Streams.Warning[index]; this.localPowerShell.Streams.Warning.RemoveAt(index); this.dsHandler.SendWarningRecordToClient(record); } } }
protected override void ProcessRecord() { MshCommandRuntime commandRuntime = base.CommandRuntime as MshCommandRuntime; if (commandRuntime != null) { WarningRecord record = new WarningRecord(this.Message); InvocationInfo variableValue = base.GetVariableValue("MyInvocation") as InvocationInfo; if (variableValue != null) { record.SetInvocationInfo(variableValue); } commandRuntime.WriteWarning(record, false); } else { base.WriteWarning(this.Message); } }
/// <summary> /// Handles DataAdded event from Warning of PowerShell /// </summary> /// <param name="sender">sender of this information, unused</param> /// <param name="eventArgs">arguments describing this event</param> private void HandleWarningAdded(object sender, DataAddedEventArgs eventArgs) { int index = eventArgs.Index; lock (_syncObject) { int indexIntoDataSent = (!_extraPowerShellAlreadyScheduled) ? 0 : 1; if ((indexIntoDataSent == 0) && (!_datasent[indexIntoDataSent])) { WarningRecord data = LocalPowerShell.Streams.Warning[index]; // once the debug message is sent, it is removed so that // the same is not sent again by SendRemainingData() method LocalPowerShell.Streams.Warning.RemoveAt(index); // send the output data to the client DataStructureHandler.SendWarningRecordToClient(data); } } // lock .. }
/// <summary> /// This method implements the ProcessRecord method for Write-Warning command /// </summary> protected override void ProcessRecord() { // // The write-warning command must use the script's InvocationInfo rather than its own, // so we create the WarningRecord here and fill it up with the appropriate InvocationInfo; // then, we call the command runtime directly and pass this record to WriteWarning(). // MshCommandRuntime mshCommandRuntime = this.CommandRuntime as MshCommandRuntime; if (mshCommandRuntime != null) { WarningRecord record = new WarningRecord(Message); InvocationInfo invocationInfo = GetVariableValue(SpecialVariables.MyInvocation) as InvocationInfo; if (invocationInfo != null) { record.SetInvocationInfo(invocationInfo); } mshCommandRuntime.WriteWarning(record); } else { WriteWarning(Message); } }//processrecord
internal void WriteWarningInfoBuffers(WarningRecord record) { if (this.informationalBuffers != null) { this.informationalBuffers.AddWarning(record); } }
/// <summary> /// Display warning information /// </summary> internal void WriteWarning(WarningRecord record, bool overrideInquire = false) { ActionPreference preference = WarningPreference; if (overrideInquire && preference == ActionPreference.Inquire) preference = ActionPreference.Continue; if (WriteHelper_ShouldWrite(preference, lastWarningContinueStatus)) { if (record.InvocationInfo == null) { record.SetInvocationInfo(MyInvocation); } if (WarningOutputPipe != null) { if (CBhost != null && CBhost.InternalUI != null && WarningOutputPipe.NullPipe) { // If redirecting to a null pipe, still write to // information buffers. CBhost.InternalUI.WriteWarningInfoBuffers(record); } // Add note property so that the warning output is formatted correctly. PSObject warningWrap = PSObject.AsPSObject(record); if (warningWrap.Members["WriteWarningStream"] == null) { warningWrap.Properties.Add(new PSNoteProperty("WriteWarningStream", true)); } WarningOutputPipe.AddWithoutAppendingOutVarList(warningWrap); } else { // // If no pipe, write directly to host. // if (null == Host || null == Host.UI) { Diagnostics.Assert(false, "No host in CommandBase.WriteWarning()"); throw PSTraceSource.NewInvalidOperationException(); } CBhost.InternalUI.TranscribeResult(StringUtil.Format(InternalHostUserInterfaceStrings.WarningFormatString, record.Message)); CBhost.InternalUI.WriteWarningRecord(record); } } AppendWarningVarList(record); lastWarningContinueStatus = WriteHelper( null, null, preference, lastWarningContinueStatus, "WarningPreference", record.Message); }
/// <summary> /// Binds the specified argument to the specified parameter using the appropriate /// parameter binder. /// </summary> /// /// <param name="argument"> /// The argument to be bound. /// </param> /// /// <param name="parameter"> /// The metadata for the parameter to bind the argument to. /// </param> /// /// <param name="flags"> /// Flags for type coercion and validation. /// </param> /// /// <returns> /// True if the parameter was successfully bound. False if <paramref name="flags"/> /// has the flag <see cref="ParameterBindingFlags.ShouldCoerceType"/> set and the type does not match the parameter type. /// </returns> /// private bool BindParameter( CommandParameterInternal argument, MergedCompiledCommandParameter parameter, ParameterBindingFlags flags) { bool result = false; switch (parameter.BinderAssociation) { case ParameterBinderAssociation.DeclaredFormalParameters: result = DefaultParameterBinder.BindParameter( argument, parameter.Parameter, flags); break; case ParameterBinderAssociation.CommonParameters: result = CommonParametersBinder.BindParameter( argument, parameter.Parameter, flags); break; case ParameterBinderAssociation.ShouldProcessParameters: Diagnostics.Assert( _commandMetadata.SupportsShouldProcess, "The metadata for the ShouldProcessParameters should only be available if the command supports ShouldProcess"); result = ShouldProcessParametersBinder.BindParameter( argument, parameter.Parameter, flags); break; case ParameterBinderAssociation.PagingParameters: Diagnostics.Assert( _commandMetadata.SupportsPaging, "The metadata for the PagingParameters should only be available if the command supports paging"); result = PagingParametersBinder.BindParameter( argument, parameter.Parameter, flags); break; case ParameterBinderAssociation.TransactionParameters: Diagnostics.Assert( _commandMetadata.SupportsTransactions, "The metadata for the TransactionsParameters should only be available if the command supports transactions"); result = TransactionParametersBinder.BindParameter( argument, parameter.Parameter, flags); break; case ParameterBinderAssociation.DynamicParameters: Diagnostics.Assert( _commandMetadata.ImplementsDynamicParameters, "The metadata for the dynamic parameters should only be available if the command supports IDynamicParameters"); if (_dynamicParameterBinder != null) { result = _dynamicParameterBinder.BindParameter( argument, parameter.Parameter, flags); } break; } if (result && ((flags & ParameterBindingFlags.IsDefaultValue) == 0)) { // Update the current valid parameter set flags if (parameter.Parameter.ParameterSetFlags != 0) { _currentParameterSetFlag &= parameter.Parameter.ParameterSetFlags; } UnboundParameters.Remove(parameter); if (!BoundParameters.ContainsKey(parameter.Parameter.Name)) { BoundParameters.Add(parameter.Parameter.Name, parameter); } if (!BoundArguments.ContainsKey(parameter.Parameter.Name)) { BoundArguments.Add(parameter.Parameter.Name, argument); } if (parameter.Parameter.ObsoleteAttribute != null && (flags & ParameterBindingFlags.IsDefaultValue) == 0 && !BoundObsoleteParameterNames.Contains(parameter.Parameter.Name)) { string obsoleteWarning = String.Format( CultureInfo.InvariantCulture, ParameterBinderStrings.UseOfDeprecatedParameterWarning, parameter.Parameter.Name, parameter.Parameter.ObsoleteAttribute.Message); var warningRecord = new WarningRecord(ParameterBinderBase.FQIDParameterObsolete, obsoleteWarning); BoundObsoleteParameterNames.Add(parameter.Parameter.Name); if (ObsoleteParameterWarningList == null) ObsoleteParameterWarningList = new List<WarningRecord>(); ObsoleteParameterWarningList.Add(warningRecord); } } return result; }
void Warning_DataAdded(object sender, DataAddedEventArgs e) { PSDataCollection<WarningRecord> collection = sender as PSDataCollection<WarningRecord>; lastWarning = collection[e.Index]; PSObject psObj = new PSObject(lastWarning); psObj.Properties.Add(new PSNoteProperty("TimeStamp", DateTime.Now)); psObj.Properties.Add(new PSNoteProperty("Stream", "Warning")); timeStampedOutput.Add(psObj); if (Dispatcher != null) { RunOnUIThread( new DispatcherOperationCallback( delegate { NotifyWarningChanged(); return null; }), true); } else { NotifyWarningChanged(); } }
internal void SendWarningRecordToClient(WarningRecord record) { record.SerializeExtendedInfo = (this.streamSerializationOptions & RemoteStreamOptions.AddInvocationInfoToWarningRecord) != 0; this.SendDataAsync(RemotingEncoder.GeneratePowerShellInformational(record, this.clientRunspacePoolId, this.clientPowerShellId, RemotingDataType.PowerShellWarning)); }
internal RemotingWarningRecord(WarningRecord warningRecord, System.Management.Automation.Remoting.OriginInfo originInfo) : base(warningRecord.FullyQualifiedWarningId, warningRecord.Message) { this._originInfo = originInfo; }
internal void WriteWarning(WarningRecord record, bool overrideInquire = false) { ActionPreference warningPreference = this.WarningPreference; if (overrideInquire && (warningPreference == ActionPreference.Inquire)) { warningPreference = ActionPreference.Continue; } if (this.WriteHelper_ShouldWrite(warningPreference, this.lastWarningContinueStatus)) { if (record.InvocationInfo == null) { record.SetInvocationInfo(this.MyInvocation); } if (this.WarningOutputPipe != null) { if (((this.CBhost != null) && (this.CBhost.InternalUI != null)) && this.WarningOutputPipe.NullPipe) { this.CBhost.InternalUI.WriteWarningInfoBuffers(record); } PSObject obj2 = PSObject.AsPSObject(record); if (obj2.Members["WriteWarningStream"] == null) { obj2.Properties.Add(new PSNoteProperty("WriteWarningStream", true)); } this.WarningOutputPipe.AddWithoutAppendingOutVarList(obj2); } else { if ((this.Host == null) || (this.Host.UI == null)) { throw PSTraceSource.NewInvalidOperationException(); } this.CBhost.InternalUI.WriteWarningRecord(record); } } this.AppendWarningVarList(record); this.lastWarningContinueStatus = this.WriteHelper(null, null, warningPreference, this.lastWarningContinueStatus, "WarningPreference", record.Message); }
internal void WriteWarningRecord(WarningRecord record) { this.WriteWarningInfoBuffers(record); if (this.externalUI != null) { this.externalUI.WriteWarningLine(record.Message); } }
private void WriteWarningRecord(RemoteComputer powershellComputer, WarningRecord record) { powershellComputer.AddLogEntry(new LogEntry(powershellComputer.Name, record.Message, LogEntryType.Warning)); }
private void HandleRobustConnectionNotification(object sender, ConnectionStatusEventArgs e) { PSConnectionRetryStatusEventArgs eventArgs = null; WarningRecord infoRecord = null; ErrorRecord record2 = null; int maxRetryConnectionTime = this.runspacePool.MaxRetryConnectionTime; int num2 = maxRetryConnectionTime / 0xea60; switch (e.Notification) { case ConnectionStatus.NetworkFailureDetected: infoRecord = new WarningRecord("PowerShellNetworkFailureDetected", StringUtil.Format(RemotingErrorIdStrings.RCNetworkFailureDetected, this.computerName, num2)); eventArgs = new PSConnectionRetryStatusEventArgs(PSConnectionRetryStatus.NetworkFailureDetected, this.computerName, maxRetryConnectionTime, infoRecord); break; case ConnectionStatus.ConnectionRetryAttempt: infoRecord = new WarningRecord("PowerShellConnectionRetryAttempt", StringUtil.Format(RemotingErrorIdStrings.RCConnectionRetryAttempt, this.computerName)); eventArgs = new PSConnectionRetryStatusEventArgs(PSConnectionRetryStatus.ConnectionRetryAttempt, this.computerName, maxRetryConnectionTime, infoRecord); break; case ConnectionStatus.ConnectionRetrySucceeded: infoRecord = new WarningRecord("PowerShellConnectionRetrySucceeded", StringUtil.Format(RemotingErrorIdStrings.RCReconnectSucceeded, this.computerName)); eventArgs = new PSConnectionRetryStatusEventArgs(PSConnectionRetryStatus.ConnectionRetrySucceeded, this.computerName, num2, infoRecord); break; case ConnectionStatus.AutoDisconnectStarting: infoRecord = new WarningRecord("PowerShellNetworkFailedStartDisconnect", StringUtil.Format(RemotingErrorIdStrings.RCAutoDisconnectingWarning, this.computerName)); eventArgs = new PSConnectionRetryStatusEventArgs(PSConnectionRetryStatus.AutoDisconnectStarting, this.computerName, num2, infoRecord); break; case ConnectionStatus.AutoDisconnectSucceeded: infoRecord = new WarningRecord("PowerShellAutoDisconnectSucceeded", StringUtil.Format(RemotingErrorIdStrings.RCAutoDisconnected, this.computerName)); eventArgs = new PSConnectionRetryStatusEventArgs(PSConnectionRetryStatus.AutoDisconnectSucceeded, this.computerName, num2, infoRecord); break; case ConnectionStatus.InternalErrorAbort: { RuntimeException exception = new RuntimeException(StringUtil.Format(RemotingErrorIdStrings.RCInternalError, this.computerName)); record2 = new ErrorRecord(exception, "PowerShellNetworkOrDisconnectFailed", ErrorCategory.InvalidOperation, this); eventArgs = new PSConnectionRetryStatusEventArgs(PSConnectionRetryStatus.InternalErrorAbort, this.computerName, num2, record2); break; } } if (eventArgs != null) { this.connectionRetryStatus = eventArgs.Notification; if (infoRecord != null) { RemotingWarningRecord message = new RemotingWarningRecord(infoRecord, new OriginInfo(this.computerName, this.InstanceId)); this.HandleInformationalMessageReceived(this, new RemoteDataEventArgs<InformationalMessage>(new InformationalMessage(message, RemotingDataType.PowerShellWarning))); RemoteHostCall data = new RemoteHostCall(-100L, RemoteHostMethodId.WriteWarningLine, new object[] { infoRecord.Message }); try { this.HandleHostCallReceived(this, new RemoteDataEventArgs<RemoteHostCall>(data)); } catch (PSNotImplementedException) { } } if (record2 != null) { RemotingErrorRecord record4 = new RemotingErrorRecord(record2, new OriginInfo(this.computerName, this.InstanceId)); this.HandleErrorReceived(this, new RemoteDataEventArgs<ErrorRecord>(record4)); } this.RCConnectionNotification.SafeInvoke<PSConnectionRetryStatusEventArgs>(this, eventArgs); } }