Add withAppEngineService() to package:appengine

lib/src/appengine_internal.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.
 
 library appengine.internal;
 
 import 'dart:async';
 import 'dart:io';
 
 import 'package:gcloud/service_scope.dart' as ss;
@@ skipping 79 matching lines @@
         return new Future.value();
       }
     } else {
       return auth.clientViaMetadataServer().then((client) {
         _authClient = client;
         return new storage.Storage(client, context.applicationID);
       });
     }
   }
 
-  var context = getDockerContext();
-  var rpcService = initializeRPC();
+  if (_contextRegistry != null) {
+    return new Future.value(_contextRegistry);
+  } else {
+    var context = getDockerContext();
+    var rpcService = initializeRPC();
 
-  return getStorage(context).then((storage) {
-    return new ContextRegistry(rpcService, storage, context);
-  });
+    return getStorage(context).then((storage) {
+      _contextRegistry = new ContextRegistry(rpcService, storage, context);
+      return _contextRegistry;
+    });
+  }
 }
 
 void initializeContext(Services services) {
   db.registerDbService(services.db);
   datastore.registerDatastoreService(services.db.datastore);
   storage.registerStorageService(services.storage);
   logging.registerLoggingService(services.logging);
   modules.registerModulesService(services.modules);
   memcache.registerMemcacheService(services.memcache);
 
   if (_authClient != null) {
     gcloud_http.registerAuthClientService(_authClient);
 
     // This will automatically close the authenticated HTTP client when the
     // HTTP server shuts down.
     ss.registerScopeExitCallback(() => _authClient.close());
   }
 }
 
 void initializeRequestSpecificServices(Services services) {
   logging.registerLoggingService(services.logging);
   users.registerUserService(services.users);
 }
 
+Future withAppEngineServices(Future callback()) {
+  return initializeAppEngine().then((ContextRegistry contextRegistry) {
+    return ss.fork(() {
+      var backgroundServices = _contextRegistry.newBackgroundServices();
+      initializeContext(backgroundServices);
+      return callback();
+    });
+  });
+}
+
 Future runAppEngine(void handler(request, context), void onError(e, s)) {
-  return initializeAppEngine().then((ContextRegistry contextRegistry) {
-    _contextRegistry = contextRegistry;
+  return withAppEngineServices(() {
     var appengineServer = new AppEngineHttpServer(_contextRegistry);
-    var backgroundServices = _contextRegistry.newBackgroundServices();
+    appengineServer.run((request, context) {
+      ss.fork(() {
+        initializeRequestSpecificServices(context.services);
+        handler(request, context);
+        return request.response.done;
+      }, onError: (error, stack) {
+        var context = _contextRegistry.lookup(request);
+        if (context != null) {
+          try {
+            context.services.logging.error(
+                'Uncaught error in request handler: $error\n$stack');
+          } catch (e) {
+            print('Error while logging uncaught error: $e');
+          }
+        } else {
+          // TODO: We could log on the background ticket here.
+          print('Unable to log error, since response has already been sent.');
+        }
+        onError('Uncaught error in request handler zone: $error', stack);
 
-    ss.fork(() {
-      initializeContext(backgroundServices);
-      appengineServer.run((request, context) {
-        ss.fork(() {
-          initializeRequestSpecificServices(context.services);
-          handler(request, context);
-          return request.response.done;
-        }, onError: (error, stack) {
-          var context = _contextRegistry.lookup(request);
-          if (context != null) {
-            try {
-              context.services.logging.error(
-                  'Uncaught error in request handler: $error\n$stack');
-            } catch (e) {
-              print('Error while logging uncaught error: $e');
-            }
-          } else {
-            // TODO: We could log on the background ticket here.
-            print('Unable to log error, since response has already been sent.');
-          }
-          onError('Uncaught error in request handler zone: $error', stack);
-
-          // In many cases errors happen during request processing or response
-          // preparation. In such cases we want to close the connection, since
-          // user code might not be able to.
-          try {
-            request.response.statusCode = HttpStatus.INTERNAL_SERVER_ERROR;
-          } on StateError catch (_) {}
-            request.response.close().catchError((closeError, closeErrorStack) {
-              onError('Forcefully closing response, due to error in request '
-                      'handler zone, resulted in an error: $closeError',
-                      closeErrorStack);
-          });
+        // In many cases errors happen during request processing or response
+        // preparation. In such cases we want to close the connection, since
+        // user code might not be able to.
+        try {
+          request.response.statusCode = HttpStatus.INTERNAL_SERVER_ERROR;
+        } on StateError catch (_) {}
+          request.response.close().catchError((closeError, closeErrorStack) {
+            onError('Forcefully closing response, due to error in request '
+                    'handler zone, resulted in an error: $closeError',
+                    closeErrorStack);
         });
       });
-      return appengineServer.done;
     });
-
-    return new Future.value();
+    return appengineServer.done;
   });
 }