Starts the framework

        :return: True if the bundle has been started, False if it was already
                 running
        :raise BundleException: A bundle failed to start
323224
def start(self):
        # type: () -> bool
        
        with self._lock:
            if self._state in (Bundle.STARTING, Bundle.ACTIVE):
                # Already started framework
                return False

            # Reset the stop event
            self._fw_stop_event.clear()

            # Starting...
            self._state = Bundle.STARTING
            self._dispatcher.fire_bundle_event(
                BundleEvent(BundleEvent.STARTING, self)
            )

            # Start all registered bundles (use a copy, just in case...)
            for bundle in self.__bundles.copy().values():
                try:
                    bundle.start()
                except FrameworkException as ex:
                    # Important error
                    _logger.exception(
                        "Important error starting bundle: %s", bundle
                    )
                    if ex.needs_stop:
                        # Stop the framework (has to be in active state)
                        self._state = Bundle.ACTIVE
                        self.stop()
                        return False
                except BundleException:
                    # A bundle failed to start : just log
                    _logger.exception("Error starting bundle: %s", bundle)

            # Bundle is now active
            self._state = Bundle.ACTIVE
            return True
436748
def start(self):
        
        self.running = True
        self.thread = threading.Thread(target=self._main_loop)
        self.thread.start()
174821
def on_startup(self):
        

        LOGGER.debug("> Calling '{0}' Component Framework 'on_startup' method.".format(self.__class__.__name__))

        factory_default_script_editor_file = umbra.ui.common.get_resource_path(
            self.__factory_default_script_editor_file)
        if foundations.common.path_exists(factory_default_script_editor_file) and \
                not foundations.common.path_exists(self.__default_script_editor_file):
            shutil.copyfile(factory_default_script_editor_file, self.__default_script_editor_file)

        if foundations.common.path_exists(self.__default_script_editor_file):
            self.load_file(self.__default_script_editor_file)
        else:
            self.new_file()

        startup_script = self.__engine.parameters.startup_script
        if foundations.common.path_exists(startup_script):
            self.load_file(startup_script) and self.evaluate_script()

        self.restore_session()

        for argument in self.__engine.arguments[1:]:
            file = os.path.abspath(argument)
            if foundations.common.path_exists(file):
                os.path.isfile(file) and self.load_file(file)

        return True
432695
def run(self):
        
        # Make sure everything is in sync, before starting.
        self.sync_with_prompt_toolkit()

        def pre_run():
            # Start in navigation mode.
            self.application.vi_state.input_mode = InputMode.NAVIGATION

        # Run eventloop of prompt_toolkit.
        self.application.run(pre_run=pre_run)
734933
public void start(BundleContext context) throws Exception
    {
        this.log(context, LogService.LOG_INFO, "Starting and registering the (repository) " + this.getClass().getName() + " ClassService ");
        
        bundleContext = context;

        if (context != null)
            context.registerService(ClassFinder.class.getName(), this, null);	// Should be only one of these
    }
874448
private void startBundle( final Bundle bundle )
        throws BundleException
    {
        // Don't start if bundle already active
        int bundleState = bundle.getState();
        if( bundleState == Bundle.ACTIVE )
        {
            return;
        }

        // Don't start if bundle is a fragment bundle
        Dictionary bundleHeaders = bundle.getHeaders();
        if( bundleHeaders.get( Constants.FRAGMENT_HOST ) != null )
        {
            return;
        }

        // Start bundle
        bundle.start();

        bundleState = bundle.getState();
        if( bundleState != Bundle.ACTIVE )
        {
            long bundleId = bundle.getBundleId();
            String bundleName = bundle.getSymbolicName();
            String bundleStateStr = bundleStateToString( bundleState );
            throw new BundleException(
                "Bundle (" + bundleId + ", " + bundleName + ") not started (still " + bundleStateStr + ")"
            );
        }
    }
765021
def _start(self):
        
        try:
            # Try to register to factory events
            with use_ipopo(self.__context) as ipopo:
                ipopo.add_listener(self)
        except BundleException:
            # Service not yet present
            pass

        # Register the iPOPO service listener
        self.__context.add_service_listener(self, specification=SERVICE_IPOPO)
372034
def on_startup(self):
        

        LOGGER.debug("> Calling '{0}' Component Framework 'on_startup' method.".format(self.__class__.__name__))

        if self.Autostart_TCP_Server_checkBox.isChecked():
            if not self.__tcp_server.online:
                self.__tcp_server.port = self.Port_spinBox.value()
                self.__tcp_server.start()
        return True
254415
def run(self):
        
        if not self._in_deque:
            return
        req = self._bundling_request
        del getattr(req, self.bundled_field)[:]
        getattr(req, self.bundled_field).extend(
            [e for elts in self._in_deque for e in elts])

        subresponse_field = self.subresponse_field
        if subresponse_field:
            self._run_with_subresponses(req, subresponse_field, self._kwargs)
        else:
            self._run_with_no_subresponse(req, self._kwargs)
1056451
public void start() throws Exception {
        Bundle bundleToScan = bundleContext.getBundle();
        Enumeration<?> findEntries = bundleToScan.findEntries("", "*.class", true);
        if (findEntries == null) {
            LOGGER.error(new StringBuilder()
                .append("We've found an error which you should really give a shot but which does not ")
                .append("interrupt your runtime. Nevertheless we assume that this one is definitely an ")
                .append("error so give it a shot! OK, the problem is that you entered the bundle with the ")
                .append("symbolic name {} the blueprint/spring entry to scan for automount annotations. ")
                .append("Nevertheless this bundle you would like to have scanned has NO classes! Either ")
                .append("the anotation is wrong or you messed up something during the build of your bundle!")
                .toString(), bundleToScan.getSymbolicName());
            return;
        }
        while (findEntries.hasMoreElements()) {
            String className = calculateClassName((URL) findEntries.nextElement());
            Class<?> candidateClass = bundleToScan.loadClass(className);
            if (!Page.class.isAssignableFrom(candidateClass)) {
                continue;
            }
            @SuppressWarnings("unchecked")
            Class<? extends Page> pageClass = (Class<? extends Page>) candidateClass;
            PaxWicketMountPoint mountPoint = pageClass.getAnnotation(PaxWicketMountPoint.class);
            if (mountPoint != null) {
                DefaultPageMounter mountPointRegistration = new DefaultPageMounter(applicationName, bundleContext);
                mountPointRegistration.addMountPoint(mountPoint.mountPoint(), pageClass);
                mountPointRegistration.register();
                mountPointRegistrations.add(mountPointRegistration);
            }
        }
    }
878846
protected void checkStartStatus(BundleStartStatus startStatus) throws InvalidBundleContextException {
        final String m = "checkInstallStatus";
        if (startStatus.startExceptions()) {
            Map<Bundle, Throwable> startExceptions = startStatus.getStartExceptions();
            for (Entry<Bundle, Throwable> entry : startExceptions.entrySet()) {
                Bundle b = entry.getKey();
                FFDCFilter.processException(entry.getValue(), ME, m, this,
                                            new Object[] { b.getLocation() });
            }

            throw new LaunchException("Exceptions occurred while starting platform bundles", BootstrapConstants.messages.getString("error.platformBundleException"));
        }

        if (!startStatus.contextIsValid())
            throw new InvalidBundleContextException();
    }
195371
async def startup(self):
        
        if self.frozen:
            return False

        if self._error_handlers:
            self.middlewares.append(_exc_middleware_factory(self))

        # Register static paths
        for path in self.cfg.STATIC_FOLDERS:
            self.router.register_resource(SafeStaticResource(self.cfg.STATIC_PREFIX, path))

        await super(Application, self).startup()
8255
def start(**kwargs):
    
    if CORE_MANAGER.started:
        raise RuntimeConfigError('Current context has to be stopped to start '
                                 'a new context.')

    try:
        waiter = kwargs.pop('waiter')
    except KeyError:
        waiter = hub.Event()
    common_config = CommonConf(**kwargs)
    hub.spawn(CORE_MANAGER.start, *[], **{'common_conf': common_config,
                                          'waiter': waiter})
    return True
479347
public static boolean waitForBundleStartup(BundleContext context, Bundle bundle, int secsToWait)
    {
        if ((bundle.getState() & Bundle.ACTIVE) == 0)
        { // Wait for it to start up!
            if (((bundle.getState() & Bundle.RESOLVED) != 0) || ((bundle.getState() & Bundle.INSTALLED) != 0))
            {
                try {
                    bundle.start();
                } catch (BundleException e) {
                    e.printStackTrace();
                }
            }
            if ((bundle.getState() & Bundle.ACTIVE) == 0)
            { // Wait for it to start up!
                Thread thread = Thread.currentThread();
                BundleStartupListener bundleStartupListener = null;
                context.addBundleListener(bundleStartupListener = new BundleStartupListener(thread, bundleContext, bundle));
                // Wait 15 seconds for the ClassService to come up while the activator starts this service
                synchronized (thread) {
                    try {
                        thread.wait((secsToWait == -1) ? DEFAULT_SERVICE_WAIT_SECS * 1000 : secsToWait * 1000);    // Will notify me when it is up
                    } catch (InterruptedException ex) {
                        ex.printStackTrace();
                    }
                }
                context.removeBundleListener(bundleStartupListener);
            }
        }
        
        return ((bundle.getState() & Bundle.ACTIVE) != 0);
    }
545419
def onStart(self, *args, **kwarg):
        
        with transactUI(self):
            config = self.navbar.getActiveConfig()
            config.resetErrors()
            if config.isValid():
                self.clientRunner.run(self.buildCliString())
                self.showConsole()
            else:
                config.displayErrors()
                self.Layout()
248263
def start(self, blocking=False):
        
        super(StartStopable, self).start()
        self._is_running = True
        # blocking
        try:
            while blocking and self._is_running:
                time.sleep(self._start_block_timeout)
        except IOError as e:
            if not str(e).lower().startswith("[errno 4]"):
                raise
1057530
def start(self, initial_delay=0):
        
        if self.listener is None:
            raise exceptions.NoAsyncListenerError
        elif self._enabled:
            return

        self._enabled = True