docs: def run(self):
          """Launch the broker(s) and worker(s) assigned on every hosts."""
          # Launch the broker(s)
          for hostname, nb_brokers in self.broker_hosts:
              for ind in range(nb_brokers):
                  if self.externalHostname in utils.localHostnames:
                      self.brokers.append(localBroker(
                          debug=self.debug,
                          nice=self.nice,
                          backend=self.backend,
                      ))
                  else:
                      self.brokers.append(remoteBroker(
                          hostname=hostname,
                          pythonExecutable=self.python_executable,
                          debug=self.debug,
                          nice=self.nice,
                          backend=self.backend,
                          rsh=self.rsh,
                          ssh_executable=self.ssh_executable,
                      ))
  
          # Share connection information between brokers
          if self.b > 1:
              for broker in self.brokers:
                  # Only send data of other brokers to a given broker
                  connect_data = [
                      BrokerInfo(
                          x.getHost(),
                          *x.getPorts(),
                          externalHostname=x.getHost()
                      )
                      for x in self.brokers
                      if x is not broker
                  ]
                  broker.sendConnect(connect_data)
  
          # Launch the workers
          shells = []
          origin_launched = False
          for hostname, nb_workers in self.worker_hosts:
              self.workers.append(self.LAUNCH_HOST_CLASS(hostname, self.rsh,
                                                         self.ssh_executable))
              total_workers_host = min(nb_workers, self.workersLeft)
  
              self.setWorkerInfo(hostname, total_workers_host, not origin_launched)
              origin_launched = True
              self.workersLeft -= total_workers_host
  
              # Launch every workers at the same time
              scoop.logger.debug(
                  "{0}: Launching '{1}'".format(
                      hostname,
                      self.workers[-1].getCommand(),
                  )
              )
              shells.append(self.workers[-1].launch(
                  (self.brokers[0].brokerPort,
                   self.brokers[0].infoPort)
                      if self.tunnel else None,
              ))
              if self.workersLeft <= 0:
                  # We've launched every worker we needed, so let's exit the loop
                  break
          rootProcess = shells[0][0]
  
          # Wait for the root program
          try:
              if self.workers[0].isLocal():
                  self.errors = self.workers[0].subprocesses[0].wait()
              else:
                  self.errors = rootProcess.wait()
          except KeyboardInterrupt:
              pass
          scoop.logger.info('Root process is done.')
          return self.errors