Service isolate rework

runtime/bin/vmservice_impl.cc

 // Copyright (c) 2013, 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.
 
 #include "bin/vmservice_impl.h"
 
 #include "include/dart_api.h"
 
 #include "bin/builtin.h"
 #include "bin/dartutils.h"
@@ skipping 76 matching lines @@
 
 
 void TriggerResourceLoad(Dart_NativeArguments args) {
   Dart_Handle library = Dart_RootLibrary();
   ASSERT(!Dart_IsError(library));
   Dart_Handle result = VmService::LoadResources(library);
   ASSERT(!Dart_IsError(result));
 }
 
 
+void NotifyServerState(Dart_NativeArguments args) {
+  Dart_EnterScope();
+  const char* ip_chars;
+  Dart_Handle ip_arg = Dart_GetNativeArgument(args, 0);
+  if (Dart_IsError(ip_arg)) {
+    VmService::SetServerIPAndPort("", 0);
+    Dart_ExitScope();
+    return;
+  }
+  Dart_Handle result = Dart_StringToCString(ip_arg, &ip_chars);
+  if (Dart_IsError(result)) {
+    VmService::SetServerIPAndPort("", 0);
+    Dart_ExitScope();
+    return;
+  }
+  Dart_Handle port_arg = Dart_GetNativeArgument(args, 1);
+  if (Dart_IsError(port_arg)) {
+    VmService::SetServerIPAndPort("", 0);
+    Dart_ExitScope();
+    return;
+  }
+  int64_t port = DartUtils::GetInt64ValueCheckRange(port_arg, 0, 65535);
+  VmService::SetServerIPAndPort(ip_chars, port);
+  Dart_ExitScope();
+}
+
 struct VmServiceIONativeEntry {
   const char* name;
   int num_arguments;
   Dart_NativeFunction function;
 };
 
 
 static VmServiceIONativeEntry _VmServiceIONativeEntries[] = {
   {"VMServiceIO_TriggerResourceLoad", 0, TriggerResourceLoad},
+  {"VMServiceIO_NotifyServerState", 2, NotifyServerState},
 };
 
 
 static Dart_NativeFunction VmServiceIONativeResolver(Dart_Handle name,
                                                      int num_arguments,
                                                      bool* auto_setup_scope) {
   const char* function_name = NULL;
   Dart_Handle result = Dart_StringToCString(name, &function_name);
   ASSERT(!Dart_IsError(result));
   ASSERT(function_name != NULL);
   *auto_setup_scope = true;
   intptr_t n =
       sizeof(_VmServiceIONativeEntries) / sizeof(_VmServiceIONativeEntries[0]);
   for (intptr_t i = 0; i < n; i++) {
     VmServiceIONativeEntry entry = _VmServiceIONativeEntries[i];
     if ((strcmp(function_name, entry.name) == 0) &&
         (num_arguments == entry.num_arguments)) {
       return entry.function;
     }
   }
   return NULL;
 }
 
 
 const char* VmService::error_msg_ = NULL;
+char VmService::server_ip_[kServerIpStringBufferSize];
+intptr_t VmService::server_port_ = 0;
 
-bool VmService::Start(const char *server_ip, intptr_t server_port) {
-  bool r = _Start(server_ip, server_port);
-  if (!r) {
-    return r;
-  }
-  // Start processing messages in a new thread.
-  Thread::Start(ThreadMain, static_cast<uword>(NULL));
-  return true;
-}
+bool VmService::Setup(const char* server_ip, intptr_t server_port) {
+  Dart_Isolate isolate = Dart_CurrentIsolate();
+  ASSERT(isolate != NULL);
 
+  SetServerIPAndPort("", 0);
 
-bool VmService::_Start(const char *server_ip, intptr_t server_port) {
-  ASSERT(Dart_CurrentIsolate() == NULL);
-  Dart_Isolate isolate = Dart_GetServiceIsolate(NULL);
-  if (isolate == NULL) {
-    error_msg_ = "Dart_GetServiceIsolate failed.";
-    return false;
-  }
-  Dart_EnterIsolate(isolate);
-  Dart_EnterScope();
-  // Install our own library tag handler.
+  Dart_Handle result;
+
+  // Load main script.
   Dart_SetLibraryTagHandler(LibraryTagHandler);
-  Dart_Handle result;
-  Dart_Handle library;
-  library = LoadScript(kVMServiceIOLibraryScriptResourceName);
-  // Expect a library.
+  Dart_Handle library = LoadScript(kVMServiceIOLibraryScriptResourceName);
   ASSERT(library != Dart_Null());
   SHUTDOWN_ON_ERROR(library);
+  result = Dart_SetNativeResolver(library, VmServiceIONativeResolver, NULL);
+  SHUTDOWN_ON_ERROR(result);
   result = Dart_FinalizeLoading(false);
-  ASSERT(!Dart_IsError(result));
+  SHUTDOWN_ON_ERROR(result);
+
+  // Make runnable.
   Dart_ExitScope();
   Dart_ExitIsolate();
   bool retval = Dart_IsolateMakeRunnable(isolate);
   if (!retval) {
     Dart_EnterIsolate(isolate);
     Dart_ShutdownIsolate();
     error_msg_ = "Invalid isolate state - Unable to make it runnable.";
     return false;
   }
-
   Dart_EnterIsolate(isolate);
   Dart_EnterScope();
+
   library = Dart_RootLibrary();
-  result = Dart_SetNativeResolver(library, VmServiceIONativeResolver, NULL);
-  ASSERT(!Dart_IsError(result));
-  // Set requested TCP port.
+  SHUTDOWN_ON_ERROR(library);
+
+  // Set HTTP server state.
   DartUtils::SetStringField(library, "_ip", server_ip);
   // If we have a port specified, start the server immediately.
   bool auto_start = server_port >= 0;
   if (server_port < 0) {
     // Adjust server_port to port 0 which will result in the first available
     // port when the HTTP server is started.
     server_port = 0;
   }
-  // Set initial state.
   DartUtils::SetIntegerField(library, "_port", server_port);
-  Dart_SetField(library,
-                DartUtils::NewString("_autoStart"),
-                Dart_NewBoolean(auto_start));
-  // We cannot register for signals on windows.
+  result = Dart_SetField(library,
+                         DartUtils::NewString("_autoStart"),
+                         Dart_NewBoolean(auto_start));
+  SHUTDOWN_ON_ERROR(result);
+
+  // Are we running on Windows?
 #if defined(TARGET_OS_WINDOWS)
   Dart_Handle is_windows = Dart_True();
 #else
   Dart_Handle is_windows = Dart_False();
 #endif
-  Dart_SetField(library, DartUtils::NewString("_isWindows"), is_windows);
-
+  result =
+      Dart_SetField(library, DartUtils::NewString("_isWindows"), is_windows);
+  SHUTDOWN_ON_ERROR(result);
 
   // Get _getWatchSignalInternal from dart:io.
   Dart_Handle dart_io_str = Dart_NewStringFromCString(DartUtils::kIOLibURL);
+  SHUTDOWN_ON_ERROR(dart_io_str);
   Dart_Handle io_lib = Dart_LookupLibrary(dart_io_str);
+  SHUTDOWN_ON_ERROR(io_lib);
   Dart_Handle function_name =
       Dart_NewStringFromCString("_getWatchSignalInternal");
+  SHUTDOWN_ON_ERROR(function_name);
   Dart_Handle signal_watch = Dart_Invoke(io_lib, function_name, 0, NULL);
-  // Invoke main.
-  result = Dart_Invoke(library, DartUtils::NewString("main"), 1, &signal_watch);
-  SHUTDOWN_ON_ERROR(result);
-
-  Dart_ExitScope();
-  Dart_ExitIsolate();
-
+  SHUTDOWN_ON_ERROR(signal_watch);
+  Dart_Handle field_name = Dart_NewStringFromCString("_signalWatch");
+  SHUTDOWN_ON_ERROR(field_name);
+  result =
+      Dart_SetField(library, field_name, signal_watch);
+  SHUTDOWN_ON_ERROR(field_name);
   return true;
 }
 
 
 const char* VmService::GetErrorMessage() {
   return error_msg_ == NULL ? "No error." : error_msg_;
 }
 
 
+void VmService::SetServerIPAndPort(const char* ip, intptr_t port) {
+  if (ip == NULL) {
+    ip = "";
+  }
+  strncpy(server_ip_, ip, kServerIpStringBufferSize);
+  server_ip_[kServerIpStringBufferSize - 1] = '\0';
+  server_port_ = port;
+}
+
+
 Dart_Handle VmService::GetSource(const char* name) {
   const intptr_t kBufferSize = 512;
   char buffer[kBufferSize];
   snprintf(&buffer[0], kBufferSize-1, "%s/%s", kLibrarySourceNamePrefix, name);
   const char* vmservice_source = NULL;
   int r = Resources::ResourceLookup(buffer, &vmservice_source);
   ASSERT(r != Resources::kNoSuchInstance);
   return Dart_NewStringFromCString(vmservice_source);
 }
 
@@ skipping 98 matching lines @@
     return url;
   }
   Dart_Handle source = GetSource(url_string);
   if (Dart_IsError(source)) {
     return source;
   }
   return Dart_LoadSource(library, url, source, 0, 0);
 }
 
 
-void VmService::ThreadMain(uword parameters) {
-  ASSERT(Dart_CurrentIsolate() == NULL);
-  Dart_Isolate service_isolate = Dart_GetServiceIsolate(NULL);
-  Dart_EnterIsolate(service_isolate);
-  Dart_EnterScope();
-  Dart_Handle result = Dart_RunLoop();
-  if (Dart_IsError(result)) {
-    printf("Service exited with an error:\n%s\n", Dart_GetError(result));
-  }
-  Dart_ExitScope();
-  Dart_ExitIsolate();
-}
-
-
-
 }  // namespace bin
 }  // namespace dart