Starts the Application.

    :return: Definition success.
    :rtype: bool
761316
def main():
    

    components_paths = []
    for path in (os.path.join(umbra.__path__[0], Constants.factory_components_directory),
                 os.path.join(umbra.__path__[0], Constants.factory_addons_components_directory)):
        os.path.exists(path) and components_paths.append(path)
    return umbra.engine.run(umbra.engine.Umbra,
                            umbra.engine.get_command_line_parameters_parser().parse_args(
                                [unicode(argument, Constants.default_codec, Constants.codec_error) for argument in
                                 sys.argv]),
                            components_paths,
                            ("factory.script_editor", "factory.preferences_manager", "factory.components_manager_ui"))
119732
def setup_app(app, throw=True):
    
    success = True
    try:
        for func in SETUP_FUNCS:
            try:
                func(app)
            except Exception:
                success = False
                if throw:
                    raise
                else:
                    msg = "Failed to run setup function %r(app)"
                    logger.exception(msg, func.__name__)
    finally:
        setattr(app, 'is_set_up', success)
287440
def start(self):
        
        self.running = True
        while self.running:
            self.update_prompt()
            try:
                self.cmdloop()
            except KeyboardInterrupt:
                print()
            except botocore.exceptions.BotoCoreError as e:
                print(e)
            except ParseException as e:
                print(self.engine.pformat_exc(e))
            except Exception:
                traceback.print_exc()
            self.engine.reset()
75335
def run(self):
        
        LOGGER.debug('Initializing process')

        # Setup logging
        self.logging_config = self.setup_logging()

        # Register the signal handlers
        self.setup_signal_handlers()

        # Create the application instance
        try:
            self.app = self.create_application()
        except exceptions.NoRoutesException:
            return

        # Create the HTTPServer
        self.http_server = self.create_http_server()

        # Hold on to the IOLoop in case it's needed for responding to signals
        self.ioloop = ioloop.IOLoop.instance()

        # Start the IOLoop, blocking until it is stopped
        try:
            self.ioloop.start()
        except KeyboardInterrupt:
            pass
436748
def start(self):
        
        self.running = True
        self.thread = threading.Thread(target=self._main_loop)
        self.thread.start()
602832
def run(self):
        
        self.set_state(self.STATE_ACTIVE)
        self.setup_consumers()

        # Set the SIGCHLD handler for child creation errors
        signal.signal(signal.SIGCHLD, self.on_sigchld)

        # Set the SIGALRM handler for poll interval
        signal.signal(signal.SIGALRM, self.on_timer)

        # Kick off the poll timer
        signal.setitimer(signal.ITIMER_REAL, self.poll_interval, 0)

        # Loop for the lifetime of the app, pausing for a signal to pop up
        while self.is_running:
            if not self.is_sleeping:
                self.set_state(self.STATE_SLEEPING)
            signal.pause()

        # Note we're exiting run
        LOGGER.info('Exiting Master Control Program')
293588
def start_app(app_id, is_finished=False):
    
    state = constant.STATE_APP_RUNNING if is_finished else constant.STATE_APP_STARTING
    app_update_state(app_id, state)
460712
def start(self):
        
        running = self._webcam.start()
        if not running:
            return running

        running &= self._phoxi.start()
        if not running:
            self._webcam.stop()
        return running
1061069
def start(self):
        

        if self.run is True:
            self.job = multiprocessing.Process(target=self.indicator)
            self.job.start()
            return self.job
372898
def init_app(self, app):
        

        self.__app = app
        self.__app.before_first_request(self.__setup)

        self.tracer.enabled = self.__app.config.get('TRACE_ENABLED', self.tracer.enabled)
1150545
def start(self):
        
        log.info("WSSAPI.start(): Starting Basic Facilities")
        self.running = True
        if self._controller_thread is None or not self._controller_thread.is_alive():
            self._controller_thread = Thread(target=self._controller,
                                             daemon=True,
                                             name='%s Controller Thread' %
                                                  self.name)
            self._controller_thread.start()
1205128
def start(self):
        

        if self.is_running():
            msg = "Daemon already running (pidfile:%s)" % self.pidfile
            self.logger.error(msg)
            return msg

        initres = self.init()

        if not initres[0]:
            return initres[1]

        # 
        self.daemonize()
        return self.run()
1215239
def start(self):
        
        self._assert_not_running()
        if self._configs.clear_log:
            self.clear_adb_log()
        self._start()
595102
def start(self):
        
        self.thread = threading.Thread(target=self._animate)
        self.thread.start()
        return
17663
def start(self):
        
        with self._operational_lock:
            if self.is_alive:
                return

            self._thread = threading.Thread(
                target=self._thread_main, name=_WORKER_THREAD_NAME
            )
            self._thread.daemon = True
            self._thread.start()
            atexit.register(self._main_thread_terminated)
284840
def start(self):
        
        assert not self._started
        self._listening_stream.on_recv(self._recv_callback)
        self._started = True
231574
def start(self, threaded=True):
        
        self.running = True
        if threaded:
            self._thread = Thread(target=self._run)
            self._thread.start()
        else:
            self._run()