blob: 71bed827806c21b0c3f9a559736367125742c9ed [file] [log] [blame]
// 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;
}
}