Starts the instance
175671
def cmd_start(self, argv, help):
        """"""
        parser = argparse.ArgumentParser(
            prog="%s start" % self.progname,
            description=help,
        )
        instances = self.get_instances(command='start')
        parser.add_argument("instance", nargs=1,
                            metavar="instance",
                            help="Name of the instance from the config.",
                            choices=sorted(instances))
        parser.add_argument("-o", "--override", nargs="*", type=str,
                            dest="overrides", metavar="OVERRIDE",
                            help="Option to override in instance config for startup script (name=value).")
        args = parser.parse_args(argv)
        overrides = self._parse_overrides(args)
        overrides['instances'] = self.instances
        instance = instances[args.instance[0]]
        instance.hooks.before_start(instance)
        result = instance.start(overrides)
        instance.hooks.after_start(instance)
        if result is None:
            return
        instance.status()
11330
def start(self):
        
        if self.instance is None:
            reservation = self.ec2_backend.add_instances(
                image_id=self.ami_id,
                count=1,
                user_data="",
                security_group_names=[],
                security_group_ids=self.security_group_ids,
                instance_type=self.instance_type,
                key_name=self.ssh_keyname,
                ebs_optimized=self.ebs_optimized,
                subnet_id=self.subnet_id,
                associate_public_ip=self.associate_public_ip,
            )
            self.instance = reservation.instances[0]
            self.reported_os = {
                'Family': 'rhel (fixed)',
                'Name': 'amazon (fixed)',
                'Version': '2016.03 (fixed)'
            }
            self.platform = self.instance.platform
            self.security_group_ids = self.instance.security_groups
            self.architecture = self.instance.architecture
            self.virtualization_type = self.instance.virtualization_type
            self.subnet_id = self.instance.subnet_id
            self.root_device_type = self.instance.root_device_type

        self.ec2_backend.start_instances([self.instance.id])
969345
protected function start(): void
	{
		// Get the session id from the cookie or generate a new one if it doesn't exist.

		$this->sessionId = $this->request->getCookies()->getSigned($this->options['name'], false);

		if($this->sessionId === false)
		{
			$this->sessionId = $this->generateId();
		}

		// Create a new / update the existing session cookie

		$this->setCookie();

		// Load the session data

		$this->loadData();

		// Create a session token if we don't have one

		if(empty($this->sessionData['mako.token']))
		{
			$this->sessionData['mako.token'] = $this->generateId();
		}

		$this->token = $this->sessionData['mako.token'];
	}
900435
public void start()
        throws Exception
    {
        if (_context==null)
            throw new IllegalStateException("No context for "+this);        
        _started=true;
        if(log.isDebugEnabled())log.debug("Started "+this);
    }
66700
def start(self):
        
        Server().start(self.options,self.handler_function, self.__class__.component_type)
436748
def start(self):
        
        self.running = True
        self.thread = threading.Thread(target=self._main_loop)
        self.thread.start()
954812
void start( Instance instance, PluginInterface plugin )
	throws IOException {

		String instancePath = InstanceHelpers.computeInstancePath( instance );
		if( instance.getStatus() != InstanceStatus.DEPLOYED_STOPPED
				&& instance.getStatus() != InstanceStatus.WAITING_FOR_ANCESTOR ) {
			this.logger.fine( instancePath + " cannot be started. Prerequisite status: DEPLOYED_STOPPED or WAITING_FOR_ANCESTOR (but was " + instance.getStatus() + ")." );

		} else if( instance.getParent() != null
				&& instance.getParent().getStatus() != InstanceStatus.DEPLOYED_STARTED ) {

			// An element cannot start if its parent is not started.
			// However, if the parent is unresolved (or waiting for its parent to start),
			// then we can mark this instance as ready to start with its parent.
			this.logger.fine( instancePath + " cannot be started because its parent is not started. Parent status: " + instance.getParent().getStatus() + "." );
			if( instance.getParent().getStatus() == InstanceStatus.UNRESOLVED
					|| instance.getParent().getStatus() == InstanceStatus.WAITING_FOR_ANCESTOR ) {

				instance.setStatus( InstanceStatus.WAITING_FOR_ANCESTOR );
				this.logger.fine( instancePath + " will start as soon as its parent starts." );
			}

		} else {
			// Otherwise, start it
			try {
				if( ImportHelpers.hasAllRequiredImports( instance, this.logger )) {
					instance.data.put( FORCE, "whatever" );
					updateStateFromImports( instance, plugin, null, null );

				} else {
					this.logger.fine(
							"Instance " + InstanceHelpers.computeInstancePath( instance )
							+ " cannot be started, dependencies are missing. Requesting exports from other agents." );

					instance.setStatus( InstanceStatus.UNRESOLVED );
					this.messagingClient.sendMessageToTheDm( new MsgNotifInstanceChanged( this.appName, instance ));
					this.messagingClient.requestExportsFromOtherAgents( instance );
				}

			} catch( PluginException e ) {
				this.logger.severe( "An error occured while starting " + InstanceHelpers.computeInstancePath( instance ));
				Utils.logException( this.logger, e );

				instance.setStatus( InstanceStatus.DEPLOYED_STOPPED );
				this.messagingClient.sendMessageToTheDm( new MsgNotifInstanceChanged( this.appName, instance ));
			}
		}
	}
358516
def start(self, *args, **kwargs):
        
        self._stop = False

        super(Plant, self).start(*args, **kwargs)
476040
def start(self):
        
        self.__stop = False
        self._queue.start()
        self._zk.start()
930265
public void start() {
    instanceLock.writeLock().lock();
    try {
      for (final Map.Entry<MongoNamespace, NamespaceChangeStreamListener> streamerEntry :
          nsStreamers.entrySet()) {
        streamerEntry.getValue().start();
      }
    } finally {
      instanceLock.writeLock().unlock();
    }
  }
1054929
public void start()
    {
        if (!state.compareAndSet(State.LATENT, State.STARTING)) {
            throw new IllegalStateException("System already starting");
        }
        for (LifeCycleListener listener : listeners) {
            listener.startingLifeCycle();
        }

        for (Object obj : managedInstances) {
            LifeCycleMethods methods = methodsMap.get(obj.getClass());
            if (!methods.hasFor(PreDestroy.class)) {
                managedInstances.remove(obj);   // remove reference to instances that aren't needed anymore
            }
        }

        state.set(State.STARTED);
        for (LifeCycleListener listener : listeners) {
            listener.startedLifeCycle();
        }
    }
1273544
def start(self):
        
        self.running = True
        self.attempt_connection()
        receiver_thread = self.create_thread_fc(self.__receiver_loop)
        receiver_thread.name = "StompReceiver%s" % getattr(receiver_thread, "name", "Thread")
        self.notify('connecting')
1060928
public function start()
    {
        // Create server instance
        $this->serverInstance = $this->createSwooleServerInstance();

        // Bind server events
        $this->bindSwooleServerEvents($this->serverInstance);

        // Start
        $this->serverInstance->start();
    }
590893
public void start() {
        synchronized (lock) {
            Log.i(DOMAIN, "Replicator is starting .....");
            if (c4repl != null) {
                Log.i(DOMAIN, "%s has already started", this);
                return;
            }

            Log.i(DOMAIN, "%s: Starting", this);
            retryCount = 0;
            internalStart();
        }
    }
418142
def start(self) -> None:
        """"""

        session = self.client.create_session(
            self.kind,
            self.proxy_user,
            self.jars,
            self.py_files,
            self.files,
            self.driver_memory,
            self.driver_cores,
            self.executor_memory,
            self.executor_cores,
            self.num_executors,
            self.archives,
            self.queue,
            self.name,
            self.spark_conf,
        )
        self.session_id = session.session_id

        not_ready = {SessionState.NOT_STARTED, SessionState.STARTING}
        intervals = polling_intervals([0.1, 0.2, 0.3, 0.5], 1.0)

        while self.state in not_ready:
            time.sleep(next(intervals))
854509
def _start(self):
        
        params = self._translate(self._options)
        self._resp = self._r_session.get(self._url, params=params, stream=True)
        self._resp.raise_for_status()
        self._lines = self._resp.iter_lines(self._chunk_size)
102880
public function start(): void
    {
        $classAndMethodName = $this->classNameGenerator->getClassAndMethodNamesForCalling();

        $this->executor->exec(...$classAndMethodName);
    }