Generalize the ephemeral build managers so that any manager may manage a builder spawned by any other manager.

buildman/component/buildcomponent.py

@@ -9,6 +9,7 @@ from autobahn.wamp.exception import ApplicationError
 
 from buildman.server import BuildJobResult
 from buildman.component.basecomponent import BaseComponent
+from buildman.jobutil.buildjob import BuildJobLoadException
 from buildman.jobutil.buildpack import BuildPackage, BuildPackageException
 from buildman.jobutil.buildstatus import StatusHandler
 from buildman.jobutil.workererror import WorkerError
@@ -58,19 +59,20 @@ class BuildComponent(BaseComponent):
     yield trollius.From(self.subscribe(self._on_heartbeat, 'io.quay.builder.heartbeat'))
     yield trollius.From(self.subscribe(self._on_log_message, 'io.quay.builder.logmessage'))
 
-    self._set_status(ComponentStatus.WAITING)
+    yield trollius.From(self._set_status(ComponentStatus.WAITING))
 
   def is_ready(self):
     """ Determines whether a build component is ready to begin a build. """
     return self._component_status == ComponentStatus.RUNNING
 
+  @trollius.coroutine
   def start_build(self, build_job):
     """ Starts a build. """
     self._current_job = build_job
     self._build_status = StatusHandler(self.build_logs, build_job.repo_build.uuid)
     self._image_info = {}
 
-    self._set_status(ComponentStatus.BUILDING)
+    yield trollius.From(self._set_status(ComponentStatus.BUILDING))
 
     # Retrieve the job's buildpack.
     buildpack_url = self.user_files.get_file_url(build_job.repo_build.resource_key,
@@ -82,23 +84,27 @@ class BuildComponent(BaseComponent):
       buildpack = BuildPackage.from_url(buildpack_url)
     except BuildPackageException as bpe:
       self._build_failure('Could not retrieve build package', bpe)
-      return
+      raise trollius.Return()
 
     # Extract the base image information from the Dockerfile.
     parsed_dockerfile = None
     logger.debug('Parsing dockerfile')
 
-    build_config = build_job.build_config
+    try:
+      build_config = build_job.build_config
+    except BuildJobLoadException as irbe:
+      self._build_failure('Could not load build job information', irbe)
+
     try:
       parsed_dockerfile = buildpack.parse_dockerfile(build_config.get('build_subdir'))
     except BuildPackageException as bpe:
       self._build_failure('Could not find Dockerfile in build package', bpe)
-      return
+      raise trollius.Return()
 
     image_and_tag_tuple = parsed_dockerfile.get_image_and_tag()
     if image_and_tag_tuple is None or image_and_tag_tuple[0] is None:
       self._build_failure('Missing FROM line in Dockerfile')
-      return
+      raise trollius.Return()
 
     base_image_information = {
         'repository': image_and_tag_tuple[0],
@@ -147,9 +153,7 @@ class BuildComponent(BaseComponent):
     logger.debug('Invoking build: %s', self.builder_realm)
     logger.debug('With Arguments: %s', build_arguments)
 
-    return (self
-            .call("io.quay.builder.build", **build_arguments)
-            .add_done_callback(self._build_complete))
+    self.call("io.quay.builder.build", **build_arguments).add_done_callback(self._build_complete)
 
   @staticmethod
   def _total_completion(statuses, total_images):
@@ -276,38 +280,42 @@ class BuildComponent(BaseComponent):
     self._current_job = None
 
     # Set the component back to a running state.
-    self._set_status(ComponentStatus.RUNNING)
+    yield trollius.From(self._set_status(ComponentStatus.RUNNING))
 
   @staticmethod
   def _ping():
     """ Ping pong. """
     return 'pong'
 
+  @trollius.coroutine
   def _on_ready(self, token, version):
     if not version in SUPPORTED_WORKER_VERSIONS:
-      logger.warning('Build component (token "%s") is running an out-of-date version: %s', version)
-      return False
+      logger.warning('Build component (token "%s") is running an out-of-date version: %s', token,
+                     version)
+      raise trollius.Return(False)
 
     if self._component_status != 'waiting':
       logger.warning('Build component (token "%s") is already connected', self.expected_token)
-      return False
+      raise trollius.Return(False)
 
     if token != self.expected_token:
-      logger.warning('Builder token mismatch. Expected: "%s". Found: "%s"', self.expected_token, token)
-      return False
+      logger.warning('Builder token mismatch. Expected: "%s". Found: "%s"', self.expected_token,
+                     token)
+      raise trollius.Return(False)
 
-    self._set_status(ComponentStatus.RUNNING)
+    yield trollius.From(self._set_status(ComponentStatus.RUNNING))
 
     # Start the heartbeat check and updating loop.
     loop = trollius.get_event_loop()
     loop.create_task(self._heartbeat())
     logger.debug('Build worker %s is connected and ready', self.builder_realm)
-    return True
+    raise trollius.Return(True)
 
+  @trollius.coroutine
   def _set_status(self, phase):
     if phase == ComponentStatus.RUNNING:
       loop = trollius.get_event_loop()
-      self.parent_manager.build_component_ready(self, loop)
+      yield trollius.From(self.parent_manager.build_component_ready(self, loop))
 
     self._component_status = phase
 
@@ -344,13 +352,14 @@ class BuildComponent(BaseComponent):
       logger.debug('Checking heartbeat on realm %s', self.builder_realm)
       if (self._last_heartbeat and
           self._last_heartbeat < datetime.datetime.utcnow() - HEARTBEAT_DELTA):
-        self._timeout()
+        yield trollius.From(self._timeout())
         return
 
       yield trollius.From(trollius.sleep(HEARTBEAT_TIMEOUT))
 
+  @trollius.coroutine
   def _timeout(self):
-    self._set_status(ComponentStatus.TIMED_OUT)
+    yield trollius.From(self._set_status(ComponentStatus.TIMED_OUT))
     logger.warning('Build component with realm %s has timed out', self.builder_realm)
     self._dispose(timed_out=True)