| // Copyright (c) 2016, the Dart project authors. Please see the AUTHORS file |
| // for details. All rights reserved. Use of this source code is governed by a |
| // BSD-style license that can be found in the LICENSE file. |
| |
| import 'package:logging/logging.dart'; |
| import 'package:observatory/models.dart' as M; |
| import 'package:observatory/service.dart' as S; |
| |
| class VMUpdateEvent implements M.VMUpdateEvent { |
| final DateTime timestamp; |
| final M.VMRef vm; |
| VMUpdateEvent(this.timestamp, this.vm) { |
| assert(timestamp != null); |
| assert(vm != null); |
| } |
| } |
| |
| class IsolateStartEvent implements M.IsolateStartEvent { |
| final DateTime timestamp; |
| final M.IsolateRef isolate; |
| IsolateStartEvent(this.timestamp, this.isolate) { |
| assert(timestamp != null); |
| assert(isolate != null); |
| } |
| } |
| |
| class IsolateRunnableEvent implements M.IsolateRunnableEvent { |
| final DateTime timestamp; |
| final M.IsolateRef isolate; |
| IsolateRunnableEvent(this.timestamp, this.isolate) { |
| assert(timestamp != null); |
| assert(isolate != null); |
| } |
| } |
| |
| class IsolateExitEvent implements M.IsolateExitEvent { |
| final DateTime timestamp; |
| final M.IsolateRef isolate; |
| IsolateExitEvent(this.timestamp, this.isolate) { |
| assert(timestamp != null); |
| assert(isolate != null); |
| } |
| } |
| |
| class IsolateUpdateEvent implements M.IsolateUpdateEvent { |
| final DateTime timestamp; |
| final M.IsolateRef isolate; |
| IsolateUpdateEvent(this.timestamp, this.isolate) { |
| assert(timestamp != null); |
| assert(isolate != null); |
| } |
| } |
| |
| class IsolateReloadEvent implements M.IsolateReloadEvent { |
| final DateTime timestamp; |
| final M.IsolateRef isolate; |
| final M.ErrorRef error; |
| IsolateReloadEvent(this.timestamp, this.isolate, this.error) { |
| assert(timestamp != null); |
| assert(isolate != null); |
| assert(error != null); |
| } |
| } |
| |
| class ServiceExtensionAddedEvent implements M.ServiceExtensionAddedEvent { |
| final DateTime timestamp; |
| final M.IsolateRef isolate; |
| final String extensionRPC; |
| ServiceExtensionAddedEvent(this.timestamp, this.isolate, this.extensionRPC) { |
| assert(timestamp != null); |
| assert(isolate != null); |
| assert(extensionRPC != null); |
| } |
| } |
| |
| class DebuggerSettingsUpdateEvent implements M.DebuggerSettingsUpdateEvent { |
| final DateTime timestamp; |
| final M.IsolateRef isolate; |
| DebuggerSettingsUpdateEvent(this.timestamp, this.isolate) { |
| assert(timestamp != null); |
| assert(isolate != null); |
| } |
| } |
| |
| class PauseStartEvent implements M.PauseStartEvent { |
| final DateTime timestamp; |
| final M.IsolateRef isolate; |
| PauseStartEvent(this.timestamp, this.isolate) { |
| assert(timestamp != null); |
| assert(isolate != null); |
| } |
| } |
| |
| class PauseExitEvent implements M.PauseExitEvent { |
| final DateTime timestamp; |
| final M.IsolateRef isolate; |
| PauseExitEvent(this.timestamp, this.isolate) { |
| assert(timestamp != null); |
| assert(isolate != null); |
| } |
| } |
| |
| class PauseBreakpointEvent implements M.PauseBreakpointEvent { |
| final DateTime timestamp; |
| final M.IsolateRef isolate; |
| final Iterable<M.Breakpoint> pauseBreakpoints; |
| final M.Frame topFrame; |
| final bool atAsyncSuspension; |
| |
| /// [optional] |
| final M.Breakpoint? breakpoint; |
| PauseBreakpointEvent( |
| this.timestamp, |
| this.isolate, |
| Iterable<M.Breakpoint> pauseBreakpoints, |
| this.topFrame, |
| this.atAsyncSuspension, |
| [this.breakpoint]) |
| : pauseBreakpoints = new List.unmodifiable(pauseBreakpoints) { |
| assert(timestamp != null); |
| assert(isolate != null); |
| assert(pauseBreakpoints != null); |
| assert(topFrame != null); |
| assert(atAsyncSuspension != null); |
| } |
| } |
| |
| class PauseInterruptedEvent implements M.PauseInterruptedEvent { |
| final DateTime timestamp; |
| final M.IsolateRef isolate; |
| final M.Frame? topFrame; |
| final bool atAsyncSuspension; |
| PauseInterruptedEvent( |
| this.timestamp, this.isolate, this.topFrame, this.atAsyncSuspension) { |
| assert(timestamp != null); |
| assert(isolate != null); |
| assert(atAsyncSuspension != null); |
| } |
| } |
| |
| class PausePostRequestEvent implements M.PausePostRequestEvent { |
| final DateTime timestamp; |
| final M.IsolateRef isolate; |
| final M.Frame? topFrame; |
| final bool atAsyncSuspension; |
| PausePostRequestEvent( |
| this.timestamp, this.isolate, this.topFrame, this.atAsyncSuspension) { |
| assert(timestamp != null); |
| assert(isolate != null); |
| assert(atAsyncSuspension != null); |
| } |
| } |
| |
| class PauseExceptionEvent implements M.PauseExceptionEvent { |
| final DateTime timestamp; |
| final M.IsolateRef isolate; |
| final M.Frame topFrame; |
| final M.InstanceRef exception; |
| PauseExceptionEvent( |
| this.timestamp, this.isolate, this.topFrame, this.exception) { |
| assert(timestamp != null); |
| assert(isolate != null); |
| assert(topFrame != null); |
| assert(exception != null); |
| } |
| } |
| |
| class ResumeEvent implements M.ResumeEvent { |
| final DateTime timestamp; |
| final M.IsolateRef isolate; |
| final M.Frame? topFrame; |
| ResumeEvent(this.timestamp, this.isolate, this.topFrame) { |
| assert(timestamp != null); |
| assert(isolate != null); |
| } |
| } |
| |
| class BreakpointAddedEvent implements M.BreakpointAddedEvent { |
| final DateTime timestamp; |
| final M.IsolateRef isolate; |
| final M.Breakpoint breakpoint; |
| BreakpointAddedEvent(this.timestamp, this.isolate, this.breakpoint) { |
| assert(timestamp != null); |
| assert(isolate != null); |
| assert(breakpoint != null); |
| } |
| } |
| |
| class BreakpointResolvedEvent implements M.BreakpointResolvedEvent { |
| final DateTime timestamp; |
| final M.IsolateRef isolate; |
| final M.Breakpoint breakpoint; |
| BreakpointResolvedEvent(this.timestamp, this.isolate, this.breakpoint) { |
| assert(timestamp != null); |
| assert(isolate != null); |
| assert(breakpoint != null); |
| } |
| } |
| |
| class BreakpointRemovedEvent implements M.BreakpointRemovedEvent { |
| final DateTime timestamp; |
| final M.IsolateRef isolate; |
| final M.Breakpoint breakpoint; |
| BreakpointRemovedEvent(this.timestamp, this.isolate, this.breakpoint) { |
| assert(timestamp != null); |
| assert(isolate != null); |
| assert(breakpoint != null); |
| } |
| } |
| |
| class InspectEvent implements M.InspectEvent { |
| final DateTime timestamp; |
| final M.IsolateRef isolate; |
| final M.InstanceRef inspectee; |
| InspectEvent(this.timestamp, this.isolate, this.inspectee) { |
| assert(timestamp != null); |
| assert(isolate != null); |
| assert(inspectee != null); |
| } |
| } |
| |
| class NoneEvent implements M.NoneEvent { |
| final DateTime timestamp; |
| final M.IsolateRef isolate; |
| NoneEvent(this.timestamp, this.isolate) { |
| assert(timestamp != null); |
| assert(isolate != null); |
| } |
| } |
| |
| class GCEvent implements M.GCEvent { |
| final DateTime timestamp; |
| final M.IsolateRef isolate; |
| GCEvent(this.timestamp, this.isolate) { |
| assert(timestamp != null); |
| assert(isolate != null); |
| } |
| } |
| |
| class LoggingEvent implements M.LoggingEvent { |
| final DateTime timestamp; |
| final M.IsolateRef isolate; |
| final Map logRecord; |
| LoggingEvent(this.timestamp, this.isolate, this.logRecord) { |
| assert(timestamp != null); |
| assert(isolate != null); |
| assert(logRecord != null); |
| } |
| } |
| |
| class ExtensionEvent implements M.ExtensionEvent { |
| final DateTime timestamp; |
| final M.IsolateRef isolate; |
| final String extensionKind; |
| final M.ExtensionData extensionData; |
| ExtensionEvent( |
| this.timestamp, this.isolate, this.extensionKind, this.extensionData) { |
| assert(timestamp != null); |
| assert(isolate != null); |
| assert(extensionKind != null); |
| assert(extensionData != null); |
| } |
| } |
| |
| class TimelineEventsEvent implements M.TimelineEventsEvent { |
| final DateTime timestamp; |
| final M.IsolateRef isolate; |
| final Iterable<M.TimelineEvent> timelineEvents; |
| TimelineEventsEvent( |
| this.timestamp, this.isolate, Iterable<M.TimelineEvent> timelineEvents) |
| : timelineEvents = new List.unmodifiable(timelineEvents) { |
| assert(timestamp != null); |
| assert(isolate != null); |
| assert(timelineEvents != null); |
| } |
| } |
| |
| class ConnectionClosedEvent implements M.ConnectionClosedEvent { |
| final DateTime timestamp; |
| final String reason; |
| ConnectionClosedEvent(this.timestamp, this.reason) { |
| assert(timestamp != null); |
| assert(reason != null); |
| } |
| } |
| |
| class ServiceRegisteredEvent implements M.ServiceRegisteredEvent { |
| final DateTime timestamp; |
| final String service; |
| final String method; |
| final String alias; |
| ServiceRegisteredEvent( |
| this.timestamp, this.service, this.method, this.alias) { |
| assert(timestamp != null); |
| assert(service != null); |
| assert(method != null); |
| assert(alias != null); |
| } |
| } |
| |
| class ServiceUnregisteredEvent implements M.ServiceUnregisteredEvent { |
| final DateTime timestamp; |
| final String service; |
| final String method; |
| ServiceUnregisteredEvent(this.timestamp, this.service, this.method) { |
| assert(timestamp != null); |
| assert(service != null); |
| assert(method != null); |
| } |
| } |
| |
| M.Event? createEventFromServiceEvent(S.ServiceEvent event) { |
| switch (event.kind) { |
| case S.ServiceEvent.kVMUpdate: |
| return new VMUpdateEvent(event.timestamp!, event.vm); |
| case S.ServiceEvent.kIsolateStart: |
| return new IsolateStartEvent(event.timestamp!, event.isolate!); |
| case S.ServiceEvent.kIsolateRunnable: |
| return new IsolateRunnableEvent(event.timestamp!, event.isolate!); |
| case S.ServiceEvent.kIsolateUpdate: |
| return new IsolateUpdateEvent(event.timestamp!, event.isolate!); |
| case S.ServiceEvent.kIsolateReload: |
| return new IsolateReloadEvent( |
| event.timestamp!, event.isolate!, event.error!); |
| case S.ServiceEvent.kIsolateExit: |
| return new IsolateExitEvent(event.timestamp!, event.isolate!); |
| case S.ServiceEvent.kBreakpointAdded: |
| return new BreakpointAddedEvent( |
| event.timestamp!, event.isolate!, event.breakpoint!); |
| case S.ServiceEvent.kBreakpointResolved: |
| return new BreakpointResolvedEvent( |
| event.timestamp!, event.isolate!, event.breakpoint!); |
| case S.ServiceEvent.kBreakpointRemoved: |
| return new BreakpointRemovedEvent( |
| event.timestamp!, event.isolate!, event.breakpoint!); |
| case S.ServiceEvent.kDebuggerSettingsUpdate: |
| return new DebuggerSettingsUpdateEvent(event.timestamp!, event.isolate!); |
| case S.ServiceEvent.kResume: |
| return new ResumeEvent(event.timestamp!, event.isolate!, event.topFrame); |
| case S.ServiceEvent.kPauseStart: |
| return new PauseStartEvent(event.timestamp!, event.isolate!); |
| case S.ServiceEvent.kPauseExit: |
| return new PauseExitEvent(event.timestamp!, event.isolate!); |
| case S.ServiceEvent.kPausePostRequest: |
| return new PausePostRequestEvent(event.timestamp!, event.isolate!, |
| event.topFrame, event.atAsyncSuspension!); |
| case S.ServiceEvent.kPauseBreakpoint: |
| return new PauseBreakpointEvent( |
| event.timestamp!, |
| event.isolate!, |
| event.pauseBreakpoints!, |
| event.topFrame!, |
| event.atAsyncSuspension!, |
| event.breakpoint); |
| case S.Isolate.kLoggingStream: |
| return new LoggingEvent( |
| event.timestamp!, event.isolate!, event.logRecord!); |
| case S.ServiceEvent.kPauseInterrupted: |
| return new PauseInterruptedEvent(event.timestamp!, event.isolate!, |
| event.topFrame, event.atAsyncSuspension!); |
| case S.ServiceEvent.kPauseException: |
| return new PauseExceptionEvent( |
| event.timestamp!, event.isolate!, event.topFrame!, event.exception!); |
| case S.ServiceEvent.kInspect: |
| return new InspectEvent( |
| event.timestamp!, event.isolate!, event.inspectee!); |
| case S.ServiceEvent.kGC: |
| return new GCEvent(event.timestamp!, event.isolate!); |
| case S.ServiceEvent.kServiceRegistered: |
| return new ServiceRegisteredEvent( |
| event.timestamp!, event.service!, event.method!, event.alias!); |
| case S.ServiceEvent.kServiceUnregistered: |
| return new ServiceUnregisteredEvent( |
| event.timestamp!, event.service!, event.method!); |
| case S.ServiceEvent.kNone: |
| return new NoneEvent(event.timestamp!, event.isolate!); |
| default: |
| // Ignore unrecognized events. |
| Logger.root.severe('Unrecognized event: $event'); |
| return null; |
| } |
| } |