An alias for :meth:`creamas.ds.DistributedEnvironment.spawn_slaves`.
172091
async def spawn_nodes(self, spawn_cmd, ports=None, **ssh_kwargs):
        
        return await self.spawn_slaves(spawn_cmd, ports=ports, **ssh_kwargs)
1132867
def spawn(self, *cmds: str) -> List[SublemonSubprocess]:
        
        if not self._is_running:
            raise SublemonRuntimeError(
                'Attempted to spawn subprocesses from a non-started server')

        subprocs = [SublemonSubprocess(self, cmd) for cmd in cmds]
        for sp in subprocs:
            asyncio.ensure_future(sp.spawn())
        return subprocs
1020883
def ports_to_spawn(self):
        
        return (self.config.get(config.HTTP_SERVER, dict()).get(config.PORTS)
                or self.DEFAULT_PORTS)
11942
def spawn_worker(params):
    
    setup_logging(params)
    log.info("Adding worker: idx=%s\tconcurrency=%s\tresults=%s", params.worker_index, params.concurrency,
             params.report)
    worker = Worker(params)
    worker.start()
    worker.join()
1055679
def create_spawnve(original_name):
    

    def new_spawnve(mode, path, args, env):
        import os
        send_process_created_message()
        return getattr(os, original_name)(mode, path, patch_args(args), env)

    return new_spawnve
248021
def seed(self, path, name):
        
        t = self.transloads[name] = Transload(self.addr, self, name,
                                              None, path,
                                              self.ui.startTransload(name,
                                                                     self.addr),
                                              seed=True)
        return t
47378
function spawnWorker() {

        // Create a new worker
        const worker = cluster.fork();

        // Automatically respawn the workers on exit
        worker.on("exit", function () {
            logger("Spawning new worker to replace", worker.process.pid);
            spawnWorker();
        });

        // Listen for messages from this worker
        worker.on("message", messageFromWorker);
    }
152562
function(command, options) {
	options = options || [];
	options.unshift(command);
	return childProcess.spawn(apt.command, options, apt.spawnOptions);
}
1279720
def _WorkerCommand_launcher(self):
        """"""
        return [
            self.workersArguments.pythonExecutable,
            '-m',
            'scoop.launch.__main__',
            str(self.workerAmount),
            str(self.workersArguments.verbose),
        ]
249955
def spawn_managed_host(config_file, manager, connect_on_start=True):
    

    data = manager.request_host_status(config_file)

    is_running = data['started']

    # Managed hosts run as persistent processes, so it may already be running
    if is_running:
        host_status = json.loads(data['host']['output'])
        logfile = data['host']['logfile']
    else:
        data = manager.start_host(config_file)
        host_status = json.loads(data['output'])
        logfile = data['logfile']

    host = JSHost(
        status=host_status,
        logfile=logfile,
        config_file=config_file,
        manager=manager
    )

    if not is_running and settings.VERBOSITY >= verbosity.PROCESS_START:
        print('Started {}'.format(host.get_name()))

    if connect_on_start:
        host.connect()

    return host
900918
def spawn(self, filepath, configuration_alias, replace=False):
        
        # Pass --conf as an argument to have a chance to use
        # touch reloading form .py configuration file change.
        args = ['uwsgi', '--ini', 'exec://%s %s --conf %s' % (self.binary_python, filepath, configuration_alias)]

        if replace:
            return os.execvp('uwsgi', args)

        return os.spawnvp(os.P_NOWAIT, 'uwsgi', args)
925652
def reload_using_spawn_exit(self):
        
        # Create command parts
        cmd_parts = [sys.executable] + sys.argv

        # Get env dict copy
        env_copy = os.environ.copy()

        # Spawn subprocess
        subprocess.Popen(cmd_parts, env=env_copy, close_fds=True)

        # If need force exit
        if self._force_exit:
            # Force exit
            os._exit(0)  # pylint: disable=protected-access

        # If not need force exit
        else:
            # Send interrupt to main thread
            interrupt_main()

        # Set the flag
        self._watcher_to_stop = True

        # Exit the watcher thread
        sys.exit(0)
1063730
def _spawn_redis_connection_thread(self):
        """"""
        self.logger.debug("Spawn redis connection thread")
        self.redis_connected = False
        self._redis_thread = Thread(target=self._setup_redis)
        self._redis_thread.setDaemon(True)
        self._redis_thread.start()
170786
def spawn_unless_exists title, opts={}
    new =
      if @name_map.member? title
        raise_to_front @name_map[title] unless opts[:hidden]
        false
      else
        mode = yield
        spawn title, mode, opts
        true
      end
    [@name_map[title], new]
  end
910285
def spawn(spec, kwargs, pass_fds=()):
    
    r, w = os.pipe()
    for fd in [r] + list(pass_fds):
        set_inheritable(fd, True)

    preparation_data = get_preparation_data()

    r_handle = get_handle(r)
    args, env = get_command_line(pipe_handle=r_handle)
    process = subprocess.Popen(args, env=env, close_fds=False)

    to_child = os.fdopen(w, 'wb')
    to_child.write(pickle.dumps([preparation_data, spec, kwargs]))
    to_child.close()

    return process
152616
def spawn_process(self, target, *args):
        
        p = Process(target=target, args=args)
        p.daemon = True
        if target == worker:
            p.daemon = Conf.DAEMONIZE_WORKERS
            p.timer = args[2]
            self.pool.append(p)
        p.start()
        return p
873057
def spawn_generator(self, g):
        
        try:
            return self.mapping[g]
        except KeyError:
            return g._spawn(self)