public XmlElement CreateMessageEventElement(XmlElement modelElement,string eventName,string messageSort, EventKind eventKind) { string umlModelType=GetEventElementUmlType(messageSort, eventKind); XmlElement createdMessageEventElement=CreateUmlAttributeAsElement(modelElement,EVENT_ELEMENT_TYPE_NAME,umlModelType); AddEventNameAttribute(createdMessageEventElement,eventName); return createdMessageEventElement; }
public EventDescription(EventKind kind, UserViewModel source, UserViewModel target, TweetViewModel tweet = null) { this.CreatedAt = DateTime.Now; this.Kind = kind; this.SourceUser = source; this.TargetUser = target; this.TargetTweet = tweet; }
protected void AddAutoCommand(EventKind eventKind, string pattern, string command) { var autoCommand = new AutoCommand( AutoCommandGroup.Default, eventKind, command, pattern); VimData.AutoCommands = VimData.AutoCommands.Concat(new[] { autoCommand }).ToFSharpList(); }
public EventFilter(EventKind internalEventKind, RequestId requestId, SuspendPolicy suspendPolicy, IEnumerable<EventRequestModifier> modifiers) { Contract.Requires<ArgumentNullException>(modifiers != null, "modifiers"); _internalEventKind = internalEventKind; _requestId = requestId; _suspendPolicy = suspendPolicy; _modifiers = new ImmutableList<EventRequestModifier>(modifiers); }
public static EventFilter CreateFilter(EventKind internalEventKind, JvmtiEnvironment environment, JniEnvironment nativeEnvironment, RequestId requestId, SuspendPolicy suspendPolicy, ImmutableList<EventRequestModifier> modifiers) { if (modifiers.Count == 0) return new PassThroughEventFilter(internalEventKind, requestId, suspendPolicy, modifiers); EventFilter[] elements = modifiers.Select(modifier => CreateFilter(internalEventKind, environment, nativeEnvironment, requestId, suspendPolicy, modifiers, modifier)).ToArray(); if (elements.Length == 1) return elements[0]; return new AggregateEventFilter(internalEventKind, requestId, suspendPolicy, modifiers, elements); }
public NotificationViewModel(MainWindowViewModel parent, UserViewModel source, UserViewModel target, string text, EventKind eventKind = EventKind.Undefined) { this.Parent = parent; this.SourceUser = source; this.TargetUser = target; this.Text = text; this.NotifyEventKind = eventKind; this.RaisePropertyChanged(() => SourceUser); this.RaisePropertyChanged(() => TargetUser); this.RaisePropertyChanged(() => Text); this.RaisePropertyChanged(() => NotifyEventKind); }
public Event(string Title, string Description, DateTime InitialDateTime, DateTime FinalDateTime, string EnviromentLocation, EventKind Kind) { this.Title = Title; this.Description = this.Description; this.InitialDateTime = InitialDateTime; this.FinalDateTime = FinalDateTime; this.EnvironmentLocation = EnvironmentLocation; this.Kind = Kind; // - Default properties. this.CreationDateTime = DateTime.Now; this.ModificationDateTime = DateTime.Now; this.Status = EventStatus.Created; }
private string GetOperationEventType(EventKind eventKind) { string operationEventType=null; if(eventKind.Equals(EventKind.ReceiveEvent)) { operationEventType=UmlModel.RECEIVE_OPERATION_EVENT; } else if(eventKind.Equals(EventKind.SendEvent)) { operationEventType=UmlModel.SEND_OPERATION_EVENT; } return operationEventType; }
private string GetEventElementUmlType(string messageSort, EventKind eventKind) { string eventElementUmlType=null; if((messageSort.Equals(UmlModel.ASYNCH_CALL))||(messageSort.Equals(UmlModel.SYNCH_CALL))) { eventElementUmlType=GetOperationEventType(eventKind); } else if(messageSort.Equals(UmlModel.ASYNCH_SIGNAL)) { eventElementUmlType=GetSignalEventType(eventKind); } return eventElementUmlType; }
internal HtmlEventArgs (HtmlObject source, ScriptObject eventObj) { this.source_element = source; this.eventObject = eventObj; eventType = (string) eventObject.GetProperty("type"); if (eventType.StartsWith ("click") || eventType.StartsWith ("dblclick") || eventType.StartsWith ("mouse")) eventKind = EventKind.Mouse; else if (eventType.StartsWith ("key")) { eventKind = EventKind.Key; } }
internal static void Write(EventKind eventKind, string message, params object[] args) { switch (eventKind) { case EventKind.Error: case EventKind.Critical: Trace.TraceError(message, args); break; case EventKind.Warning: Trace.TraceWarning(message, args); break; case EventKind.Information: case EventKind.Verbose: Trace.TraceInformation(message, args); break; } }
private static EventFilter CreateFilter(EventKind internalEventKind, JvmtiEnvironment environment, JniEnvironment nativeEnvironment, RequestId requestId, SuspendPolicy suspendPolicy, ImmutableList<EventRequestModifier> modifiers, EventRequestModifier modifier) { switch (modifier.Kind) { case ModifierKind.Count: return new CountEventFilter(internalEventKind, requestId, suspendPolicy, modifiers, modifier.Count); case ModifierKind.ThreadFilter: return new ThreadEventFilter(internalEventKind, requestId, suspendPolicy, modifiers, modifier.Thread); case ModifierKind.ClassTypeFilter: throw new NotImplementedException(); case ModifierKind.ClassMatchFilter: throw new NotImplementedException(); case ModifierKind.ClassExcludeFilter: throw new NotImplementedException(); case ModifierKind.LocationFilter: return new LocationEventFilter(internalEventKind, requestId, suspendPolicy, modifiers, modifier.Location); case ModifierKind.ExceptionFilter: return new ExceptionEventFilter(internalEventKind, requestId, suspendPolicy, modifiers, modifier.ExceptionOrNull, modifier.Caught, modifier.Uncaught); case ModifierKind.FieldFilter: throw new NotImplementedException(); case ModifierKind.Step: return new StepEventFilter(internalEventKind, requestId, suspendPolicy, modifiers, modifier.Thread, environment, nativeEnvironment, modifier.StepSize, modifier.StepDepth); case ModifierKind.InstanceFilter: throw new NotImplementedException(); case ModifierKind.SourceNameMatchFilter: throw new NotImplementedException(); case ModifierKind.Conditional: throw new NotImplementedException(); case ModifierKind.Invalid: default: throw new ArgumentException(); } }
public Event(EventKind ek, object pm) { kind = ek; eventParam = pm; }
public Error ClearEvent(EventKind eventKind, RequestId requestId) { List<RequestId> linkedRequests; if (_linkedRequests.TryRemove(requestId, out linkedRequests)) { Suspend(); foreach (RequestId request in linkedRequests) { RequestId ignored; _requestRemap.TryRemove(request, out ignored); ClearEvent(eventKind, request); } return Resume(); } byte[] packet = new byte[HeaderSize + sizeof(byte) + sizeof(int)]; int id = GetMessageId(); SerializeHeader(packet, id, EventRequestCommand.Clear); packet[HeaderSize] = (byte)eventKind; WriteInt32(packet, HeaderSize + sizeof(byte), requestId.Id); byte[] response = SendPacket(id, packet); return ReadErrorCode(response); }
public Event(EventKind kind, int floor) { Kind = kind; Floor = floor; }
private void EnqueueEvent(EventKind kind, object element) { _pendingNotifications.Enqueue(new EventPair(kind, element)); //Console.WriteLine ("Enqueued: " + _pendingNotifications.Peek()); }
public Event(EventKind kind, Address address, byte[] data = null) { this.Kind = kind; this.Address = address; this.Data = data; }
public Error SetEventInternal(JvmtiEnvironment environment, JniEnvironment nativeEnvironment, EventKind eventKind, EventFilter filter) { EventRequestModifier locationModifier = default(EventRequestModifier); EventRequestModifier stepModifier = default(EventRequestModifier); switch (eventKind) { case EventKind.Breakpoint: // we're going to need the location modifier to set the breakpoint if (filter.Modifiers.Count == 0 || filter.Modifiers[0].Kind != ModifierKind.LocationFilter) return Error.IllegalArgument; locationModifier = filter.Modifiers[0]; break; case EventKind.SingleStep: // the first modifier contains the step properties if (filter.Modifiers.Count == 0 || filter.Modifiers[0].Kind != ModifierKind.Step) return Error.IllegalArgument; stepModifier = filter.Modifiers[0]; break; case EventKind.FramePop: if (filter.InternalEventKind == EventKind.SingleStep) goto case EventKind.SingleStep; break; default: break; } lock (_eventRequests) { Dictionary<RequestId, EventFilter> requests; if (!_eventRequests.TryGetValue(eventKind, out requests)) { requests = new Dictionary<RequestId, EventFilter>(); _eventRequests.Add(eventKind, requests); } requests.Add(filter.RequestId, filter); if (requests.Count == 1) { JvmEventType? eventToEnable = GetJvmEventType(eventKind); if (eventToEnable != null) { jvmtiError error = Environment.SetEventNotificationMode(JvmEventMode.Enable, eventToEnable.Value); if (error != jvmtiError.None) return GetStandardError(error); } } } switch (eventKind) { case EventKind.Breakpoint: { Contract.Assert(locationModifier.Kind == ModifierKind.LocationFilter); jmethodID methodId = locationModifier.Location.Method; jlocation location = new jlocation((long)locationModifier.Location.Index); jvmtiError error = Environment.SetBreakpoint(methodId, location); if (error != jvmtiError.None) return GetStandardError(error); break; } case EventKind.FramePop: if (filter.InternalEventKind == EventKind.SingleStep) { using (var thread = VirtualMachine.GetLocalReferenceForThread(nativeEnvironment, stepModifier.Thread)) { if (!thread.IsAlive) return Error.InvalidThread; jvmtiError error = environment.RawInterface.NotifyFramePop(environment, thread.Value, 0); if (error != jvmtiError.None) return GetStandardError(error); } } break; default: break; } return Error.None; }
protected override async Task <bool> SendCallStack(SessionId sessionId, ExecutionContext context, string reason, int thread_id, Breakpoint bp, JObject data, JObject args, EventKind event_kind, CancellationToken token) { Frame frame = null; var commandParamsWriter = new MonoBinaryWriter(); commandParamsWriter.Write(thread_id); commandParamsWriter.Write(0); commandParamsWriter.Write(1); var retDebuggerCmdReader = await context.SdbAgent.SendDebuggerAgentCommand(CmdThread.GetFrameInfo, commandParamsWriter, token); var frame_count = retDebuggerCmdReader.ReadInt32(); if (frame_count > 0) { var frame_id = retDebuggerCmdReader.ReadInt32(); var methodId = retDebuggerCmdReader.ReadInt32(); var il_pos = retDebuggerCmdReader.ReadInt32(); retDebuggerCmdReader.ReadByte(); var method = await context.SdbAgent.GetMethodInfo(methodId, token); if (method is null) { return(false); } if (await ShouldSkipMethod(sessionId, context, event_kind, 0, method, token)) { await SendResume(sessionId, token); return(true); } SourceLocation location = method?.Info.GetLocationByIl(il_pos); if (location == null) { return(false); } Log("debug", $"frame il offset: {il_pos} method token: {method.Info.Token} assembly name: {method.Info.Assembly.Name}"); Log("debug", $"\tmethod {method.Name} location: {location}"); frame = new Frame(method, location, frame_id); context.CallStack = new List <Frame>(); context.CallStack.Add(frame); } if (!await EvaluateCondition(sessionId, context, frame, bp, token)) { context.ClearState(); await SendResume(sessionId, token); return(true); } args["why"]["type"] = context.PauseKind; await SendEvent(sessionId, "", args, token); return(true); }
/// <summary> /// 通知を発行する /// </summary> private static void IssueNotification(UserViewModel source, UserViewModel target, string text, EventKind eventKind, string soundPath = null) { if (Setting.Instance.StateProperty.IsInSilentMode) { return; } if (Setting.Instance.NotificationProperty.WindowNotificationStrategy != Configuration.Settings.NotificationStrategy.Disabled) { DispatcherHelper.BeginInvoke(() => { try { if (Setting.Instance.NotificationProperty.WindowNotificationStrategy == Configuration.Settings.NotificationStrategy.OnlyInactive && Application.Current.MainWindow.IsActive) { return; } } catch (NullReferenceException nrex) { throw new NullReferenceException("Rewrap(BEFORE-1)", nrex); } try { var nvm = new NotificationViewModel( Core.KernelService.MainWindowViewModel, source, target, text, eventKind); Core.KernelService.MainWindowViewModel.Messenger.Raise( new TransitionMessage(nvm, TransitionMode.Normal, "Notification")); } catch (NullReferenceException nrex) { throw new NullReferenceException("Rewrap(BEFORE-2)", nrex); } }); } if (Setting.Instance.NotificationProperty.SoundNotificationStrategy != Configuration.Settings.NotificationStrategy.Disabled) { DispatcherHelper.BeginInvoke(() => { try { if (Setting.Instance.NotificationProperty.SoundNotificationStrategy == Configuration.Settings.NotificationStrategy.OnlyInactive && Application.Current.MainWindow.IsActive) { return; } PlaySound(eventKind, soundPath); } catch (NullReferenceException nrex) { throw new NullReferenceException("Rewrap (AFTER)", nrex); } }, System.Windows.Threading.DispatcherPriority.Background); } }
public void setEventKind(EventKind ek) { this.eventKind = ek; }
public EventInfo(string regionName, double inRegionX, double inRegionY, double regionWidth, double regionHeight, EventKind kind, string commandName = null) { Kind = kind; InRegionX = inRegionX; InRegionY = inRegionY; RegionName = regionName; RegionWidth = regionWidth; RegionHeight = regionHeight; CommandName = commandName; }
private XmlElement CreateMessageOccurrenceSpecElement(XmlElement parentElement,XmlElement messageElement,XmlElement lifelineElement,EventKind eventKind) { string messageElementID=messageElement.GetAttribute(UmlModel.XMI_ID_ATTR_COMPLETE_NAME); string messageSort=messageElement.GetAttribute(UmlModel.MESSAGE_SORT_ATTR_NAME); MessageOccurrenceSpecElementCreator elementCreator= new MessageOccurrenceSpecElementCreator(this.XmiDocument,this.XmiDocumentBuilder,messageSort,eventKind); XmlElement newMessageOccurenceSpecElement=elementCreator.CreateMessageOccurrenceSpecificationElement(parentElement,lifelineElement,messageElementID); return newMessageOccurenceSpecElement; }
/// <summary> /// Initializes a new instance of the <see cref="ObjectChangedEvent"/> class. /// </summary> /// <param name="thing"> /// The payload <see cref="Thing"/>. /// </param> /// <param name="eventKind"> /// The event kind. /// </param> public ObjectChangedEvent(Thing thing, EventKind eventKind) { this.ChangedThing = thing; this.EventKind = eventKind; }
public void Notify(EventKind kind, Address address, byte[] bytes) { var contract = CurrentContext.Name; switch (kind) { case EventKind.GasEscrow: { Expect(contract == Nexus.GasContractName, $"event kind only in {Nexus.GasContractName} contract"); var gasInfo = Serialization.Unserialize <GasEventData>(bytes); Expect(gasInfo.price >= this.MinimumFee, "gas fee is too low"); this.MaxGas = gasInfo.amount; this.GasPrice = gasInfo.price; this.GasTarget = address; break; } case EventKind.GasPayment: { Expect(contract == Nexus.GasContractName, $"event kind only in {Nexus.GasContractName} contract"); if (address.IsNull) { Expect(gasPaymentInProgress, $"gas payment not in progress"); this.gasPaymentInProgress = false; return; // this event should be ignored, it is mostly an hack } else { Expect(!gasPaymentInProgress, $"gas payment already in progress"); this.gasPaymentInProgress = true; var gasInfo = Serialization.Unserialize <GasEventData>(bytes); this.PaidGas += gasInfo.amount; if (address != this.Chain.Address) { this.FeeTargetAddress = address; } } break; } case EventKind.ValidatorSwitch: Expect(contract == Nexus.BlockContractName, $"event kind only in {Nexus.BlockContractName} contract"); break; case EventKind.PollCreated: case EventKind.PollClosed: case EventKind.PollVote: Expect(contract == Nexus.ConsensusContractName, $"event kind only in {Nexus.ConsensusContractName} contract"); break; case EventKind.ChainCreate: case EventKind.TokenCreate: case EventKind.FeedCreate: Expect(this.IsRootChain(), $"event kind only in root chain"); break; case EventKind.FileCreate: case EventKind.FileDelete: Expect(contract == Nexus.StorageContractName, $"event kind only in {Nexus.StorageContractName } contract"); break; case EventKind.ValidatorPropose: case EventKind.ValidatorElect: case EventKind.ValidatorRemove: Expect(contract == Nexus.ValidatorContractName, $"event kind only in {Nexus.ValidatorContractName} contract"); break; case EventKind.ValueCreate: case EventKind.ValueUpdate: Expect(contract == Nexus.GovernanceContractName, $"event kind only in {Nexus.GovernanceContractName} contract"); break; } var evt = new Event(kind, address, contract, bytes); _events.Add(evt); }
/// <summary>触发事件</summary> /// <param name="session"></param> /// <param name="kind"></param> /// <param name="he"></param> /// <returns>返回是否取消操作</returns> Boolean RaiseEvent(Session session, EventKind kind, HttpProxyEventArgs he) { GetHandler(kind)?.Invoke(session, he); return(he.Cancel); }
public static void Write(EventKind eventKind, string message, params object[] args) { try { //Check Whether the Loggiing is Enabled in the Configurations int loggingLevel = 4; try { string loggingLevelValue = RoleEnvironment.GetConfigurationSettingValue("LoggingLevel"); if (!string.IsNullOrEmpty(loggingLevelValue)) { int.TryParse(loggingLevelValue, out loggingLevel); } } catch { } switch (eventKind) { case EventKind.Error: if (loggingLevel >= 0) { Trace.TraceError(message, args); LogInEventLog(EventLogEntryType.Error, message, args); } break; case EventKind.Critical: if (loggingLevel >= 1) { Trace.TraceError(message, args); LogInEventLog(EventLogEntryType.Error, message, args); } break; case EventKind.Warning: if (loggingLevel >= 2) { Trace.TraceWarning(message, args); LogInEventLog(EventLogEntryType.Warning, message, args); } break; case EventKind.Information: if (loggingLevel >= 3) { Trace.TraceInformation(message, args); LogInEventLog(EventLogEntryType.Information, message, args); } break; case EventKind.Verbose: if (loggingLevel == 4) { Trace.TraceInformation(message, args); LogInEventLog(EventLogEntryType.Information, message, args); } break; } } catch { LogInEventLog(EventLogEntryType.Error, "Failed to log message"); LogInEventLog(EventLogEntryType.Error, message, args); } }
/// <summary> /// 通知を発行する /// </summary> private static void IssueNotification(UserViewModel source, UserViewModel target, string text, EventKind eventKind, string soundPath = null) { if (Setting.Instance.StateProperty.IsInSilentMode) return; if (Setting.Instance.NotificationProperty.WindowNotificationStrategy != Configuration.Settings.NotificationStrategy.Disabled) { DispatcherHelper.BeginInvoke(() => { if (Setting.Instance.NotificationProperty.WindowNotificationStrategy == Configuration.Settings.NotificationStrategy.OnlyInactive && Application.Current.MainWindow.IsActive) return; var nvm = new NotificationViewModel( Core.KernelService.MainWindowViewModel, source, target, text, eventKind); Core.KernelService.MainWindowViewModel.Messenger.Raise( new TransitionMessage(nvm, TransitionMode.Normal, "Notification")); }); } if (Setting.Instance.NotificationProperty.SoundNotificationStrategy != Configuration.Settings.NotificationStrategy.Disabled) { DispatcherHelper.BeginInvoke(() => { if (Setting.Instance.NotificationProperty.SoundNotificationStrategy == Configuration.Settings.NotificationStrategy.OnlyInactive && Application.Current.MainWindow.IsActive) return; PlaySound(eventKind, soundPath); }, System.Windows.Threading.DispatcherPriority.Background); } }
private string GetSignalEventType(EventKind eventKind) { string signalEventType=null; if(eventKind.Equals(EventKind.ReceiveEvent)) { signalEventType=UmlModel.RECEIVE_SIGNAL_EVENT; } else if(eventKind.Equals(EventKind.SendEvent)) { signalEventType=UmlModel.SEND_SIGNAL_EVENT; } return signalEventType; }
private static void PlaySound(EventKind eventKind, string overrideSoundPath) { string path = Path.GetDirectoryName(Define.ExeFilePath); path = Path.Combine(path, Define.MediaDirectory); switch (eventKind) { case EventKind.Mention: path = Path.Combine(path, Define.MentionWavFile); break; case EventKind.DirectMessage: path = Path.Combine(path, Define.DirectMessageWavFile); break; case EventKind.Undefined: path = Path.Combine(path, Define.NewReceiveWavFile); break; case EventKind.Follow: case EventKind.Favorite: case EventKind.Retweet: case EventKind.Unfavorite: path = Path.Combine(path, Define.EventWavFile); break; default: return; } if (!String.IsNullOrEmpty(overrideSoundPath) && File.Exists(overrideSoundPath)) { path = overrideSoundPath; } if (File.Exists(path)) { Task.Factory.StartNew(() => { if (isPlaying) return; isPlaying = true; try { using (var soundplayer = new SoundPlayer(path)) { soundplayer.PlaySync(); } } catch (Exception ex) { ExceptionStorage.Register(ex, ExceptionCategory.InternalError, "通知音の再生ができませんでした。"); } isPlaying = false; }); } }
public Error ClearEventInternal(EventKind eventKind, RequestId requestId) { lock (_eventRequests) { Dictionary<RequestId, EventFilter> requests; if (!_eventRequests.TryGetValue(eventKind, out requests)) return Error.None; EventFilter eventFilter; if (!requests.TryGetValue(requestId, out eventFilter)) return Error.None; requests.Remove(requestId); if (requests.Count == 0) { JvmEventType? eventToDisable = GetJvmEventType(eventKind); if (eventToDisable != null) { jvmtiError error = Environment.SetEventNotificationMode(JvmEventMode.Disable, eventToDisable.Value); if (error != jvmtiError.None) return GetStandardError(error); } } if (eventKind == EventKind.Breakpoint) { LocationEventFilter locationFilter = eventFilter as LocationEventFilter; if (locationFilter == null) { AggregateEventFilter aggregateFilter = eventFilter as AggregateEventFilter; Contract.Assert(aggregateFilter != null); locationFilter = aggregateFilter.Filters.OfType<LocationEventFilter>().FirstOrDefault(); } Contract.Assert(locationFilter != null); jmethodID methodId = locationFilter.Location.Method; jlocation location = new jlocation((long)locationFilter.Location.Index); jvmtiError error = Environment.ClearBreakpoint(methodId, location); if (error != jvmtiError.None) return GetStandardError(error); } return Error.None; } }
public PassThroughEventFilter(EventKind internalEventKind, RequestId requestId, SuspendPolicy suspendPolicy, IEnumerable <EventRequestModifier> modifiers) : base(internalEventKind, requestId, suspendPolicy, modifiers) { }
public MessageOccurrenceSpecElementCreator(XmlDocument xmiDocument,XmlDocumentBuilder xmiDocumentBuilder,string messageSort,EventKind eventKind) : base(xmiDocument,xmiDocumentBuilder) { this.messageSort=messageSort; this.eventKind=eventKind; }
public AggregateEventFilter(EventKind internalEventKind, RequestId requestId, SuspendPolicy suspendPolicy, IEnumerable <EventRequestModifier> modifiers, IEnumerable <EventFilter> filters) : base(internalEventKind, requestId, suspendPolicy, modifiers) { Contract.Requires <ArgumentNullException>(filters != null, "filters"); _filters = filters.ToArray(); }
private DropOperationBaseEvent AssertDequeueEtwEvent(DropEtwListener etwListener, bool succeeded, EventKind kind) { var dropEvent = etwListener.DequeueDropEvent(); Assert.Equal(succeeded, dropEvent.Succeeded); Assert.Equal(kind, dropEvent.Kind); return(dropEvent); }
public CountEventFilter(EventKind internalEventKind, RequestId requestId, SuspendPolicy suspendPolicy, IEnumerable <EventRequestModifier> modifiers, int count) : base(internalEventKind, requestId, suspendPolicy, modifiers) { _count = count; }
public Error SetEvent(out RequestId requestId, EventKind eventKind, SuspendPolicy suspendPolicy, EventRequestModifier[] modifiers) { if (eventKind == EventKind.SingleStep && modifiers.Length == 1 && modifiers[0].Thread == default(ThreadId)) { ThreadId[] threads; Error threadsErrorCode = GetAllThreads(out threads); if (threadsErrorCode != Error.None) { requestId = default(RequestId); return threadsErrorCode; } requestId = default(RequestId); threadsErrorCode = Suspend(); if (threadsErrorCode != Error.None) return threadsErrorCode; List<RequestId> requests = new List<RequestId>(); foreach (var thread in threads) { EventRequestModifier modifier = modifiers[0]; modifier.Thread = thread; threadsErrorCode = SetEvent(out requestId, eventKind, suspendPolicy, new[] { modifier }); if (threadsErrorCode != Error.None) return threadsErrorCode; requests.Add(requestId); } _linkedRequests[requestId] = requests; foreach (var request in requests) _requestRemap[request] = requestId; threadsErrorCode = Resume(); if (threadsErrorCode != Error.None) return threadsErrorCode; return Error.None; } byte[] packet = new byte[HeaderSize + 6]; packet[HeaderSize] = (byte)eventKind; packet[HeaderSize + 1] = (byte)suspendPolicy; WriteInt32(packet, HeaderSize + 2, modifiers.Length); List<byte> packetData = new List<byte>(packet); foreach (EventRequestModifier modifier in modifiers) { packetData.Add((byte)modifier.Kind); switch (modifier.Kind) { case ModifierKind.Count: { byte[] additionalData = new byte[sizeof(int)]; WriteInt32(additionalData, 0, modifier.Count); packetData.AddRange(additionalData); } continue; case ModifierKind.Conditional: { byte[] additionalData = new byte[sizeof(int)]; WriteInt32(additionalData, 0, modifier.ExpressionId); packetData.AddRange(additionalData); } continue; case ModifierKind.ThreadFilter: { byte[] additionalData = new byte[ThreadIdSize]; WriteObjectId(additionalData, 0, modifier.Thread); packetData.AddRange(additionalData); } continue; case ModifierKind.ClassTypeFilter: { byte[] additionalData = new byte[ReferenceTypeIdSize]; WriteReferenceTypeId(additionalData, 0, modifier.Class); packetData.AddRange(additionalData); } continue; case ModifierKind.ClassMatchFilter: case ModifierKind.ClassExcludeFilter: { byte[] stringData = Encoding.UTF8.GetBytes(modifier.ClassPattern); byte[] sizeData = new byte[sizeof(int)]; WriteInt32(sizeData, 0, stringData.Length); packetData.AddRange(sizeData); packetData.AddRange(stringData); } continue; case ModifierKind.LocationFilter: { byte[] additionalData = new byte[LocationSize]; WriteLocation(additionalData, 0, modifier.Location); packetData.AddRange(additionalData); } continue; case ModifierKind.ExceptionFilter: { byte[] additionalData = new byte[_referenceTypeIdSize.Value + 2]; WriteReferenceTypeId(additionalData, 0, modifier.ExceptionOrNull); additionalData[_referenceTypeIdSize.Value] = (byte)(modifier.Caught ? 1 : 0); additionalData[_referenceTypeIdSize.Value + 1] = (byte)(modifier.Uncaught ? 1 : 0); packetData.AddRange(additionalData); } continue; case ModifierKind.FieldFilter: { byte[] additionalData = new byte[ReferenceTypeIdSize + FieldIdSize]; WriteReferenceTypeId(additionalData, 0, modifier.Class); WriteFieldId(additionalData, ReferenceTypeIdSize, modifier.Field); packetData.AddRange(additionalData); } continue; case ModifierKind.Step: { if (modifier.StepSize == StepSize.Statement) throw new NotSupportedException(); byte[] additionalData = new byte[ThreadIdSize + (2 * sizeof(int))]; WriteObjectId(additionalData, 0, modifier.Thread); WriteInt32(additionalData, ThreadIdSize, (int)modifier.StepSize); WriteInt32(additionalData, ThreadIdSize + sizeof(int), (int)modifier.StepDepth); packetData.AddRange(additionalData); } continue; case ModifierKind.InstanceFilter: { byte[] additionalData = new byte[ObjectIdSize]; WriteObjectId(additionalData, 0, modifier.Instance); packetData.AddRange(additionalData); } continue; case ModifierKind.SourceNameMatchFilter: { byte[] stringData = Encoding.UTF8.GetBytes(modifier.SourceNamePattern); byte[] sizeData = new byte[sizeof(int)]; WriteInt32(sizeData, 0, stringData.Length); packetData.AddRange(sizeData); packetData.AddRange(stringData); } continue; case ModifierKind.Invalid: default: throw new InvalidOperationException(); } } packet = packetData.ToArray(); int id = GetMessageId(); SerializeHeader(packet, id, EventRequestCommand.Set); byte[] response = SendPacket(id, packet); Error errorCode = ReadErrorCode(response); if (errorCode != Error.None) { requestId = default(RequestId); return errorCode; } int offset = HeaderSize; requestId = new RequestId(ReadInt32(response, ref offset)); return Error.None; }
public ThreadEventFilter(EventKind internalEventKind, RequestId requestId, SuspendPolicy suspendPolicy, IEnumerable <EventRequestModifier> modifiers, ThreadId thread) : base(internalEventKind, requestId, suspendPolicy, modifiers) { _thread = thread; }
private IEnumerable <LinuxEvent> NextEvent(Regex regex, FastStream source) { string line = string.Empty; while (true) { source.SkipWhiteSpace(); if (source.EndOfStream) { break; } EventKind eventKind = EventKind.Cpu; StringBuilder sb = new StringBuilder(); // Command - Stops at first number AFTER first word(non-whitespace) and whitespace for (;;) { if (sb.Length != 0) { if (this.IsNumberChar((char)source.Current)) { break; } sb.Append(' '); } source.ReadAsciiStringUpToTrue(sb, delegate(byte c) { return(!char.IsWhiteSpace((char)c)); }); source.SkipWhiteSpace(); } string comm = sb.ToString(); sb.Clear(); // Process ID int pid = source.ReadInt(); source.MoveNext(); // Move past the "/" // Thread ID int tid = source.ReadInt(); // CPU source.SkipWhiteSpace(); source.MoveNext(); // Move past the "[" int cpu = source.ReadInt(); source.MoveNext(); // Move past the "]" // Time source.SkipWhiteSpace(); source.ReadAsciiStringUpTo(':', sb); double time = double.Parse(sb.ToString()) * 1000; // To convert to MSec sb.Clear(); source.MoveNext(); // Move past ":" // Time Property source.SkipWhiteSpace(); int timeProp = -1; if (this.IsNumberChar((char)source.Current)) { timeProp = source.ReadInt(); } // Event Name source.SkipWhiteSpace(); source.ReadAsciiStringUpTo(':', sb); string eventName = sb.ToString(); sb.Clear(); source.MoveNext(); // Event Properties // I mark a position here because I need to check what type of event this is without screwing up the stream var markedPosition = source.MarkPosition(); source.ReadAsciiStringUpTo('\n', sb); string eventDetails = sb.ToString().Trim(); sb.Clear(); if (eventDetails.Length >= SchedulerEvent.Name.Length && eventDetails.Substring(0, SchedulerEvent.Name.Length) == SchedulerEvent.Name) { eventKind = EventKind.Scheduler; } // Now that we know the header of the trace, we can decide whether or not to skip it given our pattern if (regex != null && !regex.IsMatch(eventName)) { while (true) { source.MoveNext(); if (this.IsEndOfSample(source, source.Current, source.Peek(1))) { break; } } yield return(null); } else { LinuxEvent linuxEvent; Frame threadTimeFrame = null; // For the sake of immutability, I have to do a similar if-statement twice. I'm trying to figure out a better way // but for now this will do. ScheduleSwitch schedSwitch = null; if (eventKind == EventKind.Scheduler) { source.RestoreToMark(markedPosition); schedSwitch = this.ReadScheduleSwitch(source); source.SkipUpTo('\n'); } IEnumerable <Frame> frames = this.ReadFramesForSample(comm, pid, tid, threadTimeFrame, source); if (eventKind == EventKind.Scheduler) { linuxEvent = new SchedulerEvent(comm, tid, pid, time, timeProp, cpu, eventName, eventDetails, frames, schedSwitch); } else { linuxEvent = new CpuEvent(comm, tid, pid, time, timeProp, cpu, eventName, eventDetails, frames); } yield return(linuxEvent); } } }
public LocationEventFilter(EventKind internalEventKind, RequestId requestId, SuspendPolicy suspendPolicy, IEnumerable <EventRequestModifier> modifiers, Location location) : base(internalEventKind, requestId, suspendPolicy, modifiers) { _location = location; }
private IEnumerable <LinuxEvent> NextEvent(Regex regex, FastStream source) { string line = string.Empty; while (true) { source.SkipWhiteSpace(); if (source.EndOfStream) { break; } EventKind eventKind = EventKind.Cpu; StringBuilder sb = new StringBuilder(); // Fetch Command (processName) - Stops when it sees the pattern \s+\d+/\d int idx = FindEndOfProcessCommand(source); if (idx < 0) { break; } source.ReadFixedString(idx, sb); source.SkipWhiteSpace(); string processCommand = sb.ToString(); sb.Clear(); // Process ID int pid = source.ReadInt(); source.MoveNext(); // Move past the "/" // Thread ID int tid = source.ReadInt(); // CPU source.SkipWhiteSpace(); int cpu = -1; if (source.Peek(0) == '[') { source.MoveNext(); // Move past the "[" cpu = source.ReadInt(); source.MoveNext(); // Move past the "]" } // Time source.SkipWhiteSpace(); source.ReadAsciiStringUpTo(':', sb); double time = double.Parse(sb.ToString(), CultureInfo.InvariantCulture) * 1000; // To convert to MSec sb.Clear(); source.MoveNext(); // Move past ":" // Time Property source.SkipWhiteSpace(); int timeProp = -1; if (IsNumberChar((char)source.Current)) { timeProp = source.ReadInt(); } // Event Name source.SkipWhiteSpace(); source.ReadAsciiStringUpTo(':', sb); string eventName = sb.ToString(); sb.Clear(); source.MoveNext(); // Event Properties // I mark a position here because I need to check what type of event this is without screwing up the stream var markedPosition = source.MarkPosition(); source.ReadAsciiStringUpTo('\n', sb); string eventDetails = sb.ToString().Trim(); sb.Clear(); if (eventDetails.Length >= SchedulerEvent.Name.Length && eventDetails.Substring(0, SchedulerEvent.Name.Length) == SchedulerEvent.Name) { eventKind = EventKind.Scheduler; } // Now that we know the header of the trace, we can decide whether or not to skip it given our pattern if (regex != null && !regex.IsMatch(eventName)) { while (true) { source.MoveNext(); if (IsEndOfSample(source, source.Current, source.Peek(1))) { break; } } yield return(null); } else { LinuxEvent linuxEvent; Frame threadTimeFrame = null; // For the sake of immutability, I have to do a similar if-statement twice. I'm trying to figure out a better way // but for now this will do. ScheduleSwitch schedSwitch = null; if (eventKind == EventKind.Scheduler) { source.RestoreToMark(markedPosition); schedSwitch = ReadScheduleSwitch(source); source.SkipUpTo('\n'); } IEnumerable <Frame> frames = ReadFramesForSample(processCommand, pid, tid, threadTimeFrame, source); if (eventKind == EventKind.Scheduler) { linuxEvent = new SchedulerEvent(processCommand, tid, pid, time, timeProp, cpu, eventName, eventDetails, frames, schedSwitch); } else { linuxEvent = new CpuEvent(processCommand, tid, pid, time, timeProp, cpu, eventName, eventDetails, frames); } yield return(linuxEvent); } } }
public StepEventFilter(EventKind internalEventKind, RequestId requestId, SuspendPolicy suspendPolicy, IEnumerable <EventRequestModifier> modifiers, ThreadId thread, JvmtiEnvironment environment, JniEnvironment nativeEnvironment, StepSize size, StepDepth depth) : base(internalEventKind, requestId, suspendPolicy, modifiers, thread) { if (size == StepSize.Statement && JavaVM.DisableStatementStepping) { size = StepSize.Line; } _size = size; _depth = depth; // gather reference information for the thread using (var threadHandle = environment.VirtualMachine.GetLocalReferenceForThread(nativeEnvironment, thread)) { if (threadHandle.IsAlive) { jvmtiError error = environment.GetFrameLocation(threadHandle.Value, 0, out _lastMethod, out _lastLocation); if (error == jvmtiError.None) { error = environment.GetFrameCount(threadHandle.Value, out _stackDepth); } if (error == jvmtiError.None) { _hasMethodInfo = true; } UpdateLastLine(environment); if (error == jvmtiError.None && size == StepSize.Statement && (depth == StepDepth.Over || depth == StepDepth.Into)) { byte[] bytecode; JvmtiErrorHandler.ThrowOnFailure(environment.GetBytecodes(_lastMethod, out bytecode)); _disassembledMethod = BytecodeDisassembler.Disassemble(bytecode); TaggedReferenceTypeId declaringClass; JvmtiErrorHandler.ThrowOnFailure(environment.GetMethodDeclaringClass(nativeEnvironment, _lastMethod, out declaringClass)); using (var classHandle = environment.VirtualMachine.GetLocalReferenceForClass(nativeEnvironment, declaringClass.TypeId)) { int constantPoolCount; byte[] data; JvmtiErrorHandler.ThrowOnFailure(environment.GetConstantPool(classHandle.Value, out constantPoolCount, out data)); List <ConstantPoolEntry> entryList = new List <ConstantPoolEntry>(); int currentPosition = 0; for (int i = 0; i < constantPoolCount - 1; i++) { entryList.Add(ConstantPoolEntry.FromBytes(data, ref currentPosition)); switch (entryList.Last().Type) { case ConstantType.Double: case ConstantType.Long: // these entries take 2 slots entryList.Add(ConstantPoolEntry.Reserved); i++; break; default: break; } } _constantPool = entryList.AsReadOnly(); string classSignature; string classGenericSignature; JvmtiErrorHandler.ThrowOnFailure(environment.GetClassSignature(classHandle.Value, out classSignature, out classGenericSignature)); string methodName; string methodSignature; string methodGenericSignature; JvmtiErrorHandler.ThrowOnFailure(environment.GetMethodName(_lastMethod, out methodName, out methodSignature, out methodGenericSignature)); jobject classLoader; JvmtiErrorHandler.ThrowOnFailure(environment.GetClassLoader(classHandle.Value, out classLoader)); long classLoaderTag; JvmtiErrorHandler.ThrowOnFailure(environment.TagClassLoader(classLoader, out classLoaderTag)); ReadOnlyCollection <ExceptionTableEntry> exceptionTable; JvmtiErrorHandler.ThrowOnFailure(environment.VirtualMachine.GetExceptionTable(classLoaderTag, classSignature, methodName, methodSignature, out exceptionTable)); _evaluationStackDepths = BytecodeDisassembler.GetEvaluationStackDepths(_disassembledMethod, _constantPool, exceptionTable); } } } } }
public void addEvent(EventKind pEK) { events.Add(pEK); }
public void Notify(EventKind kind, Address address, byte[] bytes) { var evt = new Event(kind, address, bytes); _events.Add(evt); }
public async Task LargeInstanceEventsTest(EventKind kind, string kindName) { BuildXL.Utilities.Analysis.IgnoreArgument(kindName, "Kind name is only specified so enum value name shows up in test name"); if (kind == EventKind.Blob) { // Blob events don't have a large equivalent since they just have a storage id return; } var context = new OperationContext(new Context(Logger)); var harness = new LargeEventTestHarness(); var sender = harness.Sender; var configuration = new MemoryContentLocationEventStoreConfiguration(); var memoryEventHub = new MemoryEventHubClient(configuration); var eventStore = new EventHubContentLocationEventStore(configuration, harness, "TestMachine", harness, TestRootDirectoryPath / "eventwork", SystemClock.Instance); await eventStore.StartupAsync(context).ThrowIfFailure(); eventStore.StartProcessing(context, new EventSequencePoint(DateTime.UtcNow)).ThrowIfFailure(); var serializer = CreateContentLocationEventDataSerializer(); await sendAndVerifyLargeEvent(kind); using var stream = new MemoryStream(); using var writer = BuildXL.Utilities.BuildXLWriter.Create(stream); serializer.SerializeEvents(writer, harness.Events); stream.Position.Should().BeGreaterThan(ContentLocationEventDataSerializer.MaxEventDataPayloadSize, "Event should be larger than max event payload size to properly test serialization logic"); bool canSplit = kind == EventKind.AddLocation || kind == EventKind.AddLocationWithoutTouching || kind == EventKind.RemoveLocation || kind == EventKind.RemoveLocation || kind == EventKind.Touch; foreach (var eventData in harness.Events) { eventData.SerializationKind.Should().Be(kind); } configuration.Hub.EventStream.Count.Should().BeGreaterThan(0); foreach (var rawEvent in configuration.Hub.EventStream) { rawEvent.Body.Count.Should().BeLessOrEqualTo(ContentLocationEventDataSerializer.MaxEventDataPayloadSize); } if (canSplit) { // Events should be split harness.Events.Count.Should().BeGreaterThan(1); configuration.Hub.EventStream.Count.Should().BeGreaterThan(1); // No uploads/downloads should happen for splittable events harness.State.DownloadedCount.Should().Be(0); harness.State.UploadedCount.Should().Be(0); harness.State.UploadedSize.Should().Be(0); harness.State.DownloadedSize.Should().Be(0); } else { harness.Events.Count.Should().Be(1); configuration.Hub.EventStream.Count.Should().Be(1); harness.State.DownloadedCount.Should().Be(1); harness.State.UploadedCount.Should().Be(1); harness.State.UploadedSize.Should().BeGreaterOrEqualTo(stream.Position); harness.State.UploadedSize.Should().Be(harness.State.DownloadedSize); } async Task sendAndVerifyLargeEvent(EventKind kind) { const int largeEventContentCount = 50000; switch (kind) { case EventKind.AddLocation: case EventKind.AddLocationWithoutTouching: { var sent = Enumerable.Range(0, largeEventContentCount).Select(_ => new ContentHashWithSize(ContentHash.Random(), ThreadSafeRandom.Generator.Next(0, 100000))).ToList(); eventStore.AddLocations( context, sender, sent, touch: kind == EventKind.AddLocation).ThrowIfFailure(); var received = harness.Events.Cast <AddContentLocationEventData>().SelectMany(e => e.ContentHashes.SelectList((hash, index) => (hash, size: e.ContentSizes[index]))).ToList(); received.Count.Should().Be(sent.Count); for (int i = 0; i < received.Count; i++) { received[i].hash.Should().Be(new ShortHash(sent[i].Hash)); received[i].size.Should().Be(sent[i].Size); } return; } case EventKind.RemoveLocation: { var sent = Enumerable.Range(0, largeEventContentCount).Select(_ => ContentHash.Random()).ToList(); eventStore.RemoveLocations( context, sender, sent).ThrowIfFailure(); var received = harness.Events.Cast <RemoveContentLocationEventData>().SelectMany(e => e.ContentHashes).ToList(); received.Count.Should().Be(sent.Count); for (int i = 0; i < received.Count; i++) { received[i].Should().Be(new ShortHash(sent[i])); } return; } case EventKind.Touch: { var sent = Enumerable.Range(0, largeEventContentCount).Select(_ => ContentHash.Random()).ToList(); eventStore.Touch( context, sender, sent, DateTime.UtcNow).ThrowIfFailure(); var received = harness.Events.Cast <TouchContentLocationEventData>().SelectMany(e => e.ContentHashes).ToList(); received.Count.Should().Be(sent.Count); for (int i = 0; i < received.Count; i++) { received[i].Should().Be(new ShortHash(sent[i])); } return; } case EventKind.UpdateMetadataEntry: { var contentHashes = Enumerable.Range(0, largeEventContentCount).Select(_ => ContentHash.Random()).ToArray(); var sent = new UpdateMetadataEntryEventData( sender, StrongFingerprint.Random(), new MetadataEntry( new ContentHashListWithDeterminism( new ContentHashList(contentHashes), CacheDeterminism.None), DateTime.UtcNow)); await eventStore.UpdateMetadataEntryAsync(context, sent).ShouldBeSuccess(); var received = harness.Events.Cast <UpdateMetadataEntryEventData>().SelectMany(e => e.Entry.ContentHashListWithDeterminism.ContentHashList.Hashes).ToList(); received.Count.Should().Be(contentHashes.Length); for (int i = 0; i < received.Count; i++) { received[i].Should().Be(contentHashes[i]); } return; } default: throw Contract.AssertFailure($"No large event for kind {kind}. Add large event to ensure this case is tested"); } } }
public Event(EventKind eventKind) { hidden = true; this.eventKind = eventKind; initializeUI(); }
public Error SetEvent(JvmtiEnvironment environment, JniEnvironment nativeEnvironment, EventKind eventKind, SuspendPolicy suspendPolicy, ImmutableList<EventRequestModifier> modifiers, bool internalRequest, out RequestId requestId) { Contract.Requires<ArgumentNullException>(modifiers != null, "modifiers"); requestId = default(RequestId); EventKind internalEventKind = eventKind; EventRequestModifier locationModifier = default(EventRequestModifier); EventRequestModifier stepModifier = default(EventRequestModifier); switch (eventKind) { case EventKind.Breakpoint: // we're going to need the location modifier to set the breakpoint if (modifiers.Count == 0 || modifiers[0].Kind != ModifierKind.LocationFilter) return Error.IllegalArgument; locationModifier = modifiers[0]; break; case EventKind.SingleStep: // the first modifier contains the step properties if (modifiers.Count == 0 || modifiers[0].Kind != ModifierKind.Step) return Error.IllegalArgument; stepModifier = modifiers[0]; if (stepModifier.StepDepth == StepDepth.Out) { // we want to attach the filter as a frame pop request instead of a step request eventKind = EventKind.FramePop; internalEventKind = EventKind.SingleStep; } break; default: break; } requestId = new RequestId(Interlocked.Increment(ref _nextRequestId)); if (internalRequest) requestId = new RequestId(-requestId.Id); EventFilter filter = EventFilter.CreateFilter(internalEventKind, environment, nativeEnvironment, requestId, suspendPolicy, modifiers); return SetEventInternal(environment, nativeEnvironment, eventKind, filter); }
private EventFilter[] GetEventFilters(EventKind eventKind) { lock (_eventRequests) { Dictionary<RequestId, EventFilter> requests; if (!_eventRequests.TryGetValue(eventKind, out requests)) return new EventFilter[0]; return requests.Values.ToArray(); } }
public Error ClearEvent(EventKind eventKind, RequestId requestId) { if (eventKind == EventKind.SingleStep) { // this event might also be registered as a frame pop event with the same request ID Error error = ClearEventInternal(EventKind.FramePop, requestId); if (error != Error.None) return error; } return ClearEventInternal(eventKind, requestId); }
private static void AttachEvent(DependencyObject owner, EventKind kind) { var sender = owner as UIElement; if (sender == null) { return; } switch (kind) { case EventKind.Tapped: sender.AddHandler(UIElement.TappedEvent, (TappedEventHandler) ExecuteCommand, true); break; case EventKind.TextChanged: var text = sender as TextBox; if (text != null) { text.TextChanged += TextChanged; } break; case EventKind.SelectionChanged: var control = sender as Selector; if (control != null) { control.SelectionChanged += ControlSelectionChanged; } break; default: throw new NotSupportedException("Unsupported event"); } }
private static JvmEventType? GetJvmEventType(EventKind eventKind) { switch (eventKind) { case EventKind.Breakpoint: return JvmEventType.Breakpoint; case EventKind.SingleStep: return JvmEventType.SingleStep; case EventKind.ThreadStart: return JvmEventType.ThreadStart; case EventKind.ThreadEnd: return JvmEventType.ThreadEnd; case EventKind.ClassLoad: return JvmEventType.ClassLoad; case EventKind.ClassPrepare: return JvmEventType.ClassPrepare; case EventKind.ClassUnload: throw new NotSupportedException(); case EventKind.Exception: return JvmEventType.Exception; case EventKind.ExceptionCatch: return JvmEventType.ExceptionCatch; case EventKind.FieldAccess: return JvmEventType.FieldAccess; case EventKind.FieldModification: return JvmEventType.FieldModification; case EventKind.FramePop: return JvmEventType.FramePop; case EventKind.MethodEntry: return JvmEventType.MethodEntry; case EventKind.MethodExit: return JvmEventType.MethodExit; default: return null; } }
public EventPair(EventKind kind, object subject) { Kind = kind; Subject = subject; }
/// <summary> /// Sets the value of the Event attached property /// for a given dependency object. /// </summary> /// <param name="obj"> /// The object to which the property value /// is written. /// </param> /// <param name="value">Sets the Event value of the specified object.</param> public static void SetEvent(DependencyObject obj, EventKind value) { obj.SetValue(EventProperty, value); }
/// <summary> /// Sets a type of event. /// </summary> /// <param name="kind">Type of event.</param> protected void SetKind(EventKind kind) { _kind = kind; }
public static void Write(EventKind eventKind, string message, params object[] args) { try { //Check Whether the Loggiing is Enabled in the Configurations int loggingLevel = 4; try { string loggingLevelValue = RoleEnvironment.GetConfigurationSettingValue("LoggingLevel"); if (!string.IsNullOrEmpty(loggingLevelValue)) int.TryParse(loggingLevelValue, out loggingLevel); } catch { } switch (eventKind) { case EventKind.Error: if (loggingLevel >= 0) { Trace.TraceError(message, args); LogInEventLog(EventLogEntryType.Error, message, args); } break; case EventKind.Critical: if (loggingLevel >= 1) { Trace.TraceError(message, args); LogInEventLog(EventLogEntryType.Error, message, args); } break; case EventKind.Warning: if (loggingLevel >= 2) { Trace.TraceWarning(message, args); LogInEventLog(EventLogEntryType.Warning, message, args); } break; case EventKind.Information: if (loggingLevel >= 3) { Trace.TraceInformation(message, args); LogInEventLog(EventLogEntryType.Information, message, args); } break; case EventKind.Verbose: if (loggingLevel == 4) { Trace.TraceInformation(message, args); LogInEventLog(EventLogEntryType.Information, message, args); } break; } } catch { LogInEventLog(EventLogEntryType.Error, "Failed to log message"); LogInEventLog(EventLogEntryType.Error, message, args); } }
public Event(EventKind kind, Id <LsifDocument> data, IdFactory idFactory) : this(kind, "document", data.As <LsifDocument, Element>(), idFactory) { }
public static void Notify <T>(this IRuntime runtime, EventKind kind, Address address, T content) { var bytes = content == null ? new byte[0] : Serialization.Serialize(content); runtime.Notify(kind, address, bytes); }
public void eventCard(Player p, EventKind ek) { displayRecord(p.getRoleKind().ToString() + " played Event Card: " + ek.ToString()); }
public Event(EventKind kind, Id <LsifProject> data, IdFactory idFactory) : this(kind, "project", data.As <LsifProject, Element>(), idFactory) { }
public void removeEvent(EventKind pEK) { events.Remove(pEK); }