docs: def cleanShutdown(self, quickMode=False, stopReactor=True, _reactor=reactor):
          """Shut down the entire process, once all currently-running builds are
          complete.
          quickMode will mark all builds as retry (except the ones that were triggered)
          """
          if self.shuttingDown:
              return
          log.msg("Initiating clean shutdown")
          self.shuttingDown = True
          # first, stop the distributor; this will finish any ongoing scheduling
          # operations before firing
          yield self.brd.disownServiceParent()
  
          # Double check that we're still supposed to be shutting down
          # The shutdown may have been cancelled!
          while self.shuttingDown:
              if quickMode:
                  for builder in self.builders.values():
                      # As we stop the builds, builder.building might change during loop
                      # so we need to copy the list
                      for build in list(builder.building):
                          # if build is waited for then this is a sub-build, so
                          # no need to retry it
                          if sum(br.waitedFor for br in build.requests):
                              results = CANCELLED
                          else:
                              results = RETRY
                          is_building = build.workerforbuilder.state == States.BUILDING
                          build.stopBuild("Master Shutdown", results)
                          if not is_building:
                              # if it is not building, then it must be a latent worker
                              # which is substantiating. Cancel it.
                              build.workerforbuilder.worker.insubstantiate()
              # then wait for all builds to finish
              dl = []
              for builder in self.builders.values():
                  for build in builder.building:
                      # build may be waiting for ping to worker to succeed which
                      # may never happen if the connection to worker was broken
                      # without TCP connection being severed
                      build.workerforbuilder.abortPingIfAny()
  
                      dl.append(build.waitUntilFinished())
              if not dl:
                  log.msg("No running jobs, starting shutdown immediately")
              else:
                  log.msg("Waiting for %i build(s) to finish" % len(dl))
                  yield defer.DeferredList(dl)
  
              # Check that there really aren't any running builds
              n = 0
              for builder in self.builders.values():
                  if builder.building:
                      num_builds = len(builder.building)
                      log.msg("Builder %s has %i builds running" %
                              (builder, num_builds))
                      n += num_builds
              if n > 0:
                  log.msg(
                      "Not shutting down, there are %i builds running" % n)
                  log.msg("Trying shutdown sequence again")
                  yield util.asyncSleep(1)
              else:
                  if stopReactor and self.shuttingDown:
                      log.msg("Stopping reactor")
                      _reactor.stop()
                  break
  
          if not self.shuttingDown:
              yield self.brd.setServiceParent(self)