Create a ServiceObject for a socket

runtime/bin/vmservice/client/lib/src/service/object.dart

 // Copyright (c) 2014, 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.
 
 part of service;
 
 /// A [ServiceObject] is an object known to the VM service and is tied
 /// to an owning [Isolate].
 abstract class ServiceObject extends Observable {
   /// The owner of this [ServiceObject].  This can be an [Isolate], a
@@ skipping 70 matching lines @@
         break;
       case 'ServiceError':
         obj = new ServiceError._empty(owner);
         break;
       case 'ServiceException':
         obj = new ServiceException._empty(owner);
         break;
       case 'Script':
         obj = new Script._empty(owner);
         break;
+      case 'Socket':
+        obj = new Socket._empty(owner);
+        break;
       default:
         obj = new ServiceMap._empty(owner);
     }
     obj.update(map);
     return obj;
   }
 
   /// If [this] was created from a reference, load the full object
   /// from the service by calling [reload]. Else, return [this].
   Future<ServiceObject> load() {
@@ skipping 61 matching lines @@
 }
 
 abstract class ServiceObjectOwner extends ServiceObject {
   /// Creates an empty [ServiceObjectOwner].
   ServiceObjectOwner._empty(ServiceObjectOwner owner) : super._empty(owner);
 
   /// Builds a [ServiceObject] corresponding to the [id] from [map].
   /// The result may come from the cache.  The result will not necessarily
   /// be [loaded].
   ServiceObject getFromMap(ObservableMap map);
+
+  /// Creates a link to [id] relative to [this].
+  String relativeLink(String id);
 }
 
 /// State for a VM being inspected.
 abstract class VM extends ServiceObjectOwner {
   @reflectable VM get vm => this;
   @reflectable Isolate get isolate => null;
 
   @reflectable Iterable<Isolate> get isolates => _isolateCache.values;
 
   @reflectable String get link => '$id';
@@ skipping 1288 matching lines @@
       if (caller.code == code) {
         return caller.count;
       }
     }
     return 0;
   }
 
   @reflectable bool get isDartCode => kind == CodeKind.Dart;
 }
 
+
+class SocketKind {
+  final _value;
+  const SocketKind._internal(this._value);
+  String toString() => '$_value';
+
+  static SocketKind fromString(String s) {
+    if (s == 'Listening') {
+      return Listening;
+    } else if (s == 'Normal') {
+      return Normal;
+    } else if (s == 'Pipe') {
+      return Pipe;
+    } else if (s == 'Internal') {
+      return Internal;
+    }
+    Logger.root.warning('Unknown socket kind $s');
+    throw new FallThroughError();
+  }
+  static const Listening = const SocketKind._internal('Listening');
+  static const Normal = const SocketKind._internal('Normal');
+  static const Pipe = const SocketKind._internal('Pipe');
+  static const Internal = const SocketKind._internal('Internal');
+}
+
+/// A snapshot of statistics associated with a [Socket].
+class SocketStats {
+  @reflectable final int bytesRead;
+  @reflectable final int bytesWritten;
+  @reflectable final int readCalls;
+  @reflectable final int writeCalls;
+  @reflectable final int available;
+
+  SocketStats(this.bytesRead, this.bytesWritten,
+              this.readCalls, this.writeCalls,
+              this.available);
+}
+
+/// A peer to a Socket in dart:io. Sockets can represent network sockets or
+/// OS pipes. Each socket is owned by another ServceObject, for example,
+/// a process or an HTTP server.
+class Socket extends ServiceObject {
+  Socket._empty(ServiceObjectOwner owner) : super._empty(owner);
+
+  bool get canCache => true;
+
+  ServiceObject socketOwner;
+
+  @reflectable bool get isPipe => (kind == SocketKind.Pipe);
+
+  @observable SocketStats latest;
+  @observable SocketStats previous;
+
+  @observable SocketKind kind;
+
+  @observable String protocol = '';
+
+  @observable bool readClosed = false;
+  @observable bool writeClosed = false;
+  @observable bool closing = false;
+
+  /// Listening for connections.
+  @observable bool listening = false;
+
+  @observable int fd;
+
+  @observable String localAddress;
+  @observable int localPort;
+  @observable String remoteAddress;
+  @observable int remotePort;
+
+  // Updates internal state from [map]. [map] can be a reference.
+  void _update(ObservableMap map, bool mapIsRef) {
+    name = map['name'];
+    vmName = map['name'];
+
+    kind = SocketKind.fromString(map['kind']);
+
+    if (mapIsRef) {
+      return;
+    }
+
+    _loaded = true;
+
+    _upgradeCollection(map, isolate);
+
+    readClosed = map['readClosed'];
+    writeClosed = map['writeClosed'];
+    closing = map['closing'];
+    listening = map['listening'];
+
+    protocol = map['protocol'];
+
+    localAddress = map['localAddress'];
+    localPort = map['localPort'];
+    remoteAddress = map['remoteAddress'];
+    remotePort = map['remotePort'];
+
+    fd = map['fd'];
+    socketOwner = map['owner'];
+  }
+}
+
 // Returns true if [map] is a service map. i.e. it has the following keys:
 // 'id' and a 'type'.
 bool _isServiceMap(ObservableMap m) {
   return (m != null) && (m['id'] != null) && (m['type'] != null);
 }
 
 bool _hasRef(String type) => type.startsWith('@');
 String _stripRef(String type) => (_hasRef(type) ? type.substring(1) : type);
 
 /// Recursively upgrades all [ServiceObject]s inside [collection] which must
@@ skipping 27 matching lines @@
     var v = list[i];
     if ((v is ObservableMap) && _isServiceMap(v)) {
       list[i] = owner.getFromMap(v);
     } else if (v is ObservableList) {
       _upgradeObservableList(v, owner);
     } else if (v is ObservableMap) {
       _upgradeObservableMap(v, owner);
     }
   }
 }