public override void UnsubscribeEvent(PSEventSubscriber subscriber) { if (subscriber == null) { throw new ArgumentNullException(nameof(subscriber)); } Delegate handler = (Delegate)null; lock (this.eventSubscribers) handler = this.eventSubscribers[subscriber]; if ((object)handler != null && subscriber.SourceObject != null) { if (!(subscriber.SourceObject is Type type)) { type = subscriber.SourceObject.GetType(); } BindingFlags bindingAttr = BindingFlags.IgnoreCase | BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public; EventInfo eventInfo = type.GetEvent(subscriber.EventName, bindingAttr); if (eventInfo != null && (object)handler != null) { eventInfo.RemoveEventHandler(subscriber.SourceObject, handler); } } this.DrainPendingActions(subscriber); if (subscriber.Action != null) { subscriber.Action.NotifyJobStopped(); } lock (this.eventSubscribers) { this.eventSubscribers[subscriber] = (Delegate)null; this.eventSubscribers.Remove(subscriber); } }
internal void DrainPendingActions(PSEventSubscriber subscriber) { if (this.actionQueue.Count == 0) { return; } lock (this.actionProcessingLock) { lock (((ICollection)this.actionQueue).SyncRoot) { if (this.actionQueue.Count == 0) { return; } EventAction[] array = this.actionQueue.ToArray(); this.actionQueue.Clear(); foreach (EventAction nextAction in array) { if (nextAction.Sender == subscriber && nextAction != this.processingAction) { while (this.IsExecutingEventAction) { Thread.Sleep(100); } this.InvokeAction(nextAction); } else { this.actionQueue.Enqueue(nextAction); } } } } }
internal void Invoke(PSEventSubscriber eventSubscriber, PSEventArgs eventArgs) { if (!base.IsFinishedState(base.JobStateInfo.State)) { base.SetJobState(JobState.Running); SessionState publicSessionState = this.action.SessionStateInternal.PublicSessionState; publicSessionState.PSVariable.Set("eventSubscriber", eventSubscriber); publicSessionState.PSVariable.Set("event", eventArgs); publicSessionState.PSVariable.Set("sender", eventArgs.Sender); publicSessionState.PSVariable.Set("eventArgs", eventArgs.SourceEventArgs); ArrayList resultList = new ArrayList(); try { Pipe outputPipe = new Pipe(resultList); this.action.InvokeWithPipe(false, System.Management.Automation.ScriptBlock.ErrorHandlingBehavior.WriteToExternalErrorPipe, AutomationNull.Value, AutomationNull.Value, AutomationNull.Value, outputPipe, null, eventArgs.SourceArgs); } catch (Exception exception) { CommandProcessorBase.CheckForSevereException(exception); if (!(exception is PipelineStoppedException)) { this.LogErrorsAndOutput(resultList, publicSessionState); base.SetJobState(JobState.Failed); } throw; } this.LogErrorsAndOutput(resultList, publicSessionState); this.moreData = true; } }
internal void Invoke(PSEventSubscriber eventSubscriber, PSEventArgs eventArgs) { if (this.IsFinishedState(this.JobStateInfo.State)) { return; } this.SetJobState(JobState.Running); SessionState publicSessionState = this.action.SessionStateInternal.PublicSessionState; publicSessionState.PSVariable.Set(nameof(eventSubscriber), (object)eventSubscriber); publicSessionState.PSVariable.Set("event", (object)eventArgs); publicSessionState.PSVariable.Set("sender", eventArgs.Sender); publicSessionState.PSVariable.Set(nameof(eventArgs), (object)eventArgs.SourceEventArgs); ArrayList resultList = new ArrayList(); try { this.action.InvokeWithPipe(false, false, (object)AutomationNull.Value, (object)AutomationNull.Value, (object)AutomationNull.Value, (Pipe)null, ref resultList, eventArgs.SourceArgs); } catch (Exception ex) { CommandProcessorBase.CheckForSevereException(ex); if (!(ex is PipelineStoppedException)) { this.LogErrorsAndOutput(resultList, publicSessionState); this.SetJobState(JobState.Failed); } throw; } this.LogErrorsAndOutput(resultList, publicSessionState); this.moreData = true; }
internal override PSEventSubscriber SubscribeEvent(object source, string eventName, string sourceIdentifier, PSObject data, PSEventReceivedEventHandler handlerDelegate, bool supportEvent, bool forwardEvent, bool shouldQueueAndProcessInExecutionThread, int maxTriggerCount = 0) { PSEventSubscriber subscriber = this.SubscribeEvent(source, eventName, sourceIdentifier, data, handlerDelegate, supportEvent, forwardEvent, maxTriggerCount); subscriber.ShouldProcessInExecutionThread = shouldQueueAndProcessInExecutionThread; return(subscriber); }
private void ProcessNewSubscriber( PSEventSubscriber subscriber, object source, string eventName, string sourceIdentifier, PSObject data, bool supportEvent, bool forwardEvent) { Delegate handler = (Delegate)null; if (this.eventAssembly == null) { this.debugMode = new StackFrame(0, true).GetFileName() != null; this.eventAssembly = AppDomain.CurrentDomain.DefineDynamicAssembly(new AssemblyName("PSEventHandler"), AssemblyBuilderAccess.Run); } if (this.eventModule == null) { this.eventModule = this.eventAssembly.DefineDynamicModule("PSGenericEventModule", this.debugMode); } if (source != null) { if (!(source is Type type)) { type = source.GetType(); } BindingFlags bindingAttr = BindingFlags.IgnoreCase | BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public; EventInfo eventInfo = type.GetEvent(eventName, bindingAttr); if (eventInfo == null) { throw new ArgumentException(ResourceManagerCache.FormatResourceString("EventingResources", "CouldNotFindEvent", (object)eventName), nameof(eventName)); } if (sourceIdentifier != null && sourceIdentifier.StartsWith("PowerShell.", StringComparison.OrdinalIgnoreCase)) { throw new ArgumentException(ResourceManagerCache.FormatResourceString("EventingResources", "ReservedIdentifier", (object)sourceIdentifier), nameof(sourceIdentifier)); } if (type.GetProperty("EnableRaisingEvents") != null) { type.InvokeMember("EnableRaisingEvents", BindingFlags.SetProperty, (Binder)null, source, new object[1] { (object)true }, CultureInfo.CurrentCulture); } if (source is ManagementEventWatcher managementEventWatcher) { managementEventWatcher.Start(); } MethodInfo method = eventInfo.EventHandlerType.GetMethod("Invoke"); if (method.ReturnType != typeof(void)) { throw new ArgumentException(ResourceManagerCache.GetResourceString("EventingResources", "NonVoidDelegateNotSupported"), nameof(eventName)); } object eventHandler = this.GenerateEventHandler((PSEventManager)this, source, sourceIdentifier, data, method); handler = Delegate.CreateDelegate(eventInfo.EventHandlerType, eventHandler, "EventDelegate"); eventInfo.AddEventHandler(source, handler); } lock (this.eventSubscribers) this.eventSubscribers[subscriber] = handler; }
public override PSEventSubscriber SubscribeEvent(object source, string eventName, string sourceIdentifier, PSObject data, ScriptBlock action, bool supportEvent, bool forwardEvent, int maxTriggerCount) { PSEventSubscriber subscriber = new PSEventSubscriber(this.context, this.nextSubscriptionId++, source, eventName, sourceIdentifier, action, supportEvent, forwardEvent, maxTriggerCount); this.ProcessNewSubscriber(subscriber, source, eventName, sourceIdentifier, data, supportEvent, forwardEvent); subscriber.RegisterJob(); return(subscriber); }
private void UnsubscribeEvent(PSEventSubscriber subscriber, bool skipDraining) { if (subscriber == null) { throw new ArgumentNullException("subscriber"); } Delegate delegate2 = null; lock (this.eventSubscribers) { if (subscriber.IsBeingUnsubscribed || !this.eventSubscribers.TryGetValue(subscriber, out delegate2)) { return; } subscriber.IsBeingUnsubscribed = true; } if ((delegate2 != null) && (subscriber.SourceObject != null)) { subscriber.OnPSEventUnsubscribed(subscriber.SourceObject, new PSEventUnsubscribedEventArgs(subscriber)); EventInfo info = null; Type sourceObject = subscriber.SourceObject as Type; if (sourceObject == null) { sourceObject = subscriber.SourceObject.GetType(); } BindingFlags bindingAttr = BindingFlags.Public | BindingFlags.Static | BindingFlags.Instance | BindingFlags.IgnoreCase; info = sourceObject.GetEvent(subscriber.EventName, bindingAttr); if ((info != null) && (delegate2 != null)) { info.RemoveEventHandler(subscriber.SourceObject, delegate2); } } if (!skipDraining) { this.DrainPendingActions(subscriber); } if (subscriber.Action != null) { subscriber.Action.NotifyJobStopped(); } lock (this.eventSubscribers) { this.eventSubscribers[subscriber] = null; this.eventSubscribers.Remove(subscriber); lock (this.engineEventSubscribers) { if (PSEngineEvent.EngineEvents.Contains(subscriber.SourceIdentifier)) { this.engineEventSubscribers[subscriber.SourceIdentifier].Remove(subscriber); } } } }
public override PSEventSubscriber SubscribeEvent( object source, string eventName, string sourceIdentifier, PSObject data, PSEventReceivedEventHandler handlerDelegate, bool supportEvent, bool forwardEvent) { PSEventSubscriber subscriber = new PSEventSubscriber(this.context, this.nextSubscriptionId++, source, eventName, sourceIdentifier, handlerDelegate, supportEvent, forwardEvent); this.ProcessNewSubscriber(subscriber, source, eventName, sourceIdentifier, data, supportEvent, forwardEvent); return(subscriber); }
public PSEventJob(PSEventManager eventManager, PSEventSubscriber subscriber, System.Management.Automation.ScriptBlock action, string name) : base((action == null) ? null : action.ToString(), name) { if (eventManager == null) { throw new ArgumentNullException("eventManager"); } if (subscriber == null) { throw new ArgumentNullException("subscriber"); } base.UsesResultsCollection = true; this.action = action; this.eventManager = eventManager; this.subscriber = subscriber; }
internal void SubscribeEvents(ServerSteppablePipelineDriver driver) { lock (this.syncObject) { if (!this.initialized) { this.eventManager = driver.LocalPowerShell.Runspace.Events as PSLocalEventManager; if (this.eventManager != null) { this.startSubscriber = this.eventManager.SubscribeEvent(this, "StartSteppablePipeline", Guid.NewGuid().ToString(), null, new PSEventReceivedEventHandler(this.HandleStartEvent), true, false, true, 0); this.processSubscriber = this.eventManager.SubscribeEvent(this, "RunProcessRecord", Guid.NewGuid().ToString(), null, new PSEventReceivedEventHandler(this.HandleProcessRecord), true, false, true, 0); } this.initialized = true; } } }
private void AutoUnregisterEventIfNecessary(PSEventSubscriber subscriber) { bool flag = false; if (subscriber.AutoUnregister) { lock (subscriber) { subscriber.RemainingActionsToProcess--; flag = (subscriber.RemainingTriggerCount == 0) && (subscriber.RemainingActionsToProcess == 0); } } if (flag) { this.UnsubscribeEvent(subscriber, true); } }
public PSEventJob( PSEventManager eventManager, PSEventSubscriber subscriber, ScriptBlock action, string name) : base(action == null ? (string)null : action.ToString(), name) { if (eventManager == null) { throw new ArgumentNullException(nameof(eventManager)); } if (subscriber == null) { throw new ArgumentNullException(nameof(subscriber)); } this.action = action; this.eventManager = eventManager; this.subscriber = subscriber; }
internal void DrainPendingActions(PSEventSubscriber subscriber) { if (this.actionQueue.Count != 0) { lock (this.actionProcessingLock) { lock (((ICollection)this.actionQueue).SyncRoot) { if (this.actionQueue.Count != 0) { bool flag = false; do { EventAction[] actionArray = this.actionQueue.ToArray(); this.actionQueue.Clear(); foreach (EventAction action in actionArray) { if ((action.Sender == subscriber) && (action != this.processingAction)) { while (this.IsExecutingEventAction) { Thread.Sleep(100); } bool addActionBack = false; this.InvokeAction(action, out addActionBack); if (addActionBack) { flag = true; } } else { this.actionQueue.Enqueue(action); } } }while (flag); } } } } }
public override void UnsubscribeEvent(PSEventSubscriber subscriber) { this.UnsubscribeEvent(subscriber, false); }
private void ProcessNewSubscriber(PSEventSubscriber subscriber, object source, string eventName, string sourceIdentifier, PSObject data, bool supportEvent, bool forwardEvent) { Delegate handler = null; if (this.eventAssembly == null) { StackFrame frame = new StackFrame(0, true); this.debugMode = frame.GetFileName() != null; this.eventAssembly = AppDomain.CurrentDomain.DefineDynamicAssembly(new AssemblyName("PSEventHandler"), AssemblyBuilderAccess.Run); } if (this.eventModule == null) { this.eventModule = this.eventAssembly.DefineDynamicModule("PSGenericEventModule", this.debugMode); } string a = null; bool flag = false; if (source != null) { if ((sourceIdentifier != null) && sourceIdentifier.StartsWith("PowerShell.", StringComparison.OrdinalIgnoreCase)) { throw new ArgumentException(StringUtil.Format(EventingResources.ReservedIdentifier, sourceIdentifier), "sourceIdentifier"); } EventInfo info = null; Type type = source as Type; if (type == null) { type = source.GetType(); } if (WinRTHelper.IsWinRTType(type)) { throw new InvalidOperationException(EventingResources.WinRTEventsNotSupported); } BindingFlags bindingAttr = BindingFlags.Public | BindingFlags.Static | BindingFlags.Instance | BindingFlags.IgnoreCase; info = type.GetEvent(eventName, bindingAttr); if (info == null) { throw new ArgumentException(StringUtil.Format(EventingResources.CouldNotFindEvent, eventName), "eventName"); } if (type.GetProperty("EnableRaisingEvents") != null) { try { type.InvokeMember("EnableRaisingEvents", BindingFlags.SetProperty, null, source, new object[] { true }, CultureInfo.CurrentCulture); } catch (TargetInvocationException exception) { if (exception.InnerException != null) { throw exception.InnerException; } throw; } } ManagementEventWatcher watcher = source as ManagementEventWatcher; if (watcher != null) { watcher.Start(); } MethodInfo method = info.EventHandlerType.GetMethod("Invoke"); if (method.ReturnType != typeof(void)) { throw new ArgumentException(EventingResources.NonVoidDelegateNotSupported, "eventName"); } string key = source.GetType().FullName + "|" + eventName; Type type2 = null; if (GeneratedEventHandlers.ContainsKey(key)) { type2 = GeneratedEventHandlers[key]; } else { lock (GeneratedEventHandlers) { if (GeneratedEventHandlers.ContainsKey(key)) { type2 = GeneratedEventHandlers[key]; } else { type2 = this.GenerateEventHandler(method); GeneratedEventHandlers[key] = type2; } } } object target = type2.GetConstructor(new Type[] { typeof(PSEventManager), typeof(object), typeof(string), typeof(PSObject) }).Invoke(new object[] { this, source, sourceIdentifier, data }); handler = Delegate.CreateDelegate(info.EventHandlerType, target, "EventDelegate"); info.AddEventHandler(source, handler); } else if (PSEngineEvent.EngineEvents.Contains(sourceIdentifier)) { a = sourceIdentifier; flag = string.Equals(a, "PowerShell.OnIdle", StringComparison.OrdinalIgnoreCase); } lock (this.eventSubscribers) { this.eventSubscribers[subscriber] = handler; if (a != null) { lock (this.engineEventSubscribers) { if (flag && !this._timerInitialized) { this.InitializeTimer(); this._timerInitialized = true; } List <PSEventSubscriber> list = null; if (!this.engineEventSubscribers.TryGetValue(a, out list)) { list = new List <PSEventSubscriber>(); this.engineEventSubscribers.Add(a, list); } list.Add(subscriber); if (flag && !this._isTimerActive) { this.EnableTimer(); this._isTimerActive = true; } } } } }
public abstract void UnsubscribeEvent(PSEventSubscriber subscriber);
public override void UnsubscribeEvent(PSEventSubscriber subscriber) { throw new NotSupportedException(EventingResources.RemoteOperationNotSupported); }
public EventAction(PSEventSubscriber sender, PSEventArgs args) { this.sender = sender; this.args = args; }
internal PSEventUnsubscribedEventArgs(PSEventSubscriber eventSubscriber) { this.eventSubscriber = eventSubscriber; }