Starts listing and watching the pipelines in the namespace and firing events.
965597
public void start() {
        doClose();

        Watcher<PipelineActivity> listener = new Watcher<PipelineActivity>() {
            @Override
            public void eventReceived(Action action, PipelineActivity pipelineActivity) {
                onEventReceived(action, pipelineActivity);
            }

            @Override
            public void onClose(KubernetesClientException e) {
                // TODO should we start watching again?
                LOG.warn("Pipeline watcher is closed: " + e, e);

                for (Watcher<PipelineActivity> listener : listeners) {
                    listener.onClose(e);
                }
            }
        };
        this.watcher = this.pipelines.watch(listener);
        PipelineActivityList list = this.pipelines.list();
        if (list != null) {
            List<PipelineActivity> items = list.getItems();
            if (items != null) {
                for (PipelineActivity item : items) {
                    onEventReceived(Watcher.Action.ADDED, item);
                }
            }
        }
    }
99303
@Validate
    public void start() {
        if (directory.isDirectory()) {
            buildFileIndex();
        }
        if (tracker != null) {
            tracker.open();
        }
        if (deployer != null) {
            deployer.start();
        }
    }
1333300
def start_processes(self, name, quantity):
        
        [self.start_process(name) for i in range(0, quantity or 0)]
585991
protected function runApplicationWithEvents()
    {
        $this->prepareEnvironment();

        if (static::$before) {
            $this->runBeforeCallbacks();
        }
        // read configs/general.php for register aliases
        $this->readGeneralConfigs();
        // register all aliases
        $this->registerAliases();
        // register helpers;
        $this->resolveHelpers();

        //execute the service providers
        $this->prepareServiceProviders();

        if (static::$after) {
            $this->runAfterCallbacks();
        }
    }
1282504
def fire_events(object, *events)
      run_action = [true, false].include?(events.last) ? events.pop : true
      
      # Generate the transitions to run for each event
      transitions = events.collect do |event_name|
        # Find the actual event being run
        event = nil
        detect {|name, machine| event = machine.events[event_name, :qualified_name]}
        
        raise(InvalidEvent.new(object, event_name)) unless event
        
        # Get the transition that will be performed for the event
        unless transition = event.transition_for(object)
          event.on_failure(object)
        end
        
        transition
      end.compact
      
      # Run the events in parallel only if valid transitions were found for
      # all of them
      if events.length == transitions.length
        TransitionCollection.new(transitions, :actions => run_action).perform
      else
        false
      end
    end
1034124
def _run_atstart():
    ''''''
    global _atstart
    for callback, args, kwargs in _atstart:
        callback(*args, **kwargs)
    del _atstart[:]
1056651
public final void fire() {
		Descriptor<?> descriptor = container.instances().get(component);
		Collection<Method> methods = descriptor.lifecycles().get(lifecycle);
		logger.debug("Event [" + lifecycle.getSimpleName()
				+ "] fires on component [" + descriptor + "]");
		
		if (methods.isEmpty() && lifecycle.equals(Failed.class)) {
			throw ((LifecycleException) args[0]);
		}
		
		for (Method method : methods) {
			if (!method.isAccessible()) {
				method.setAccessible(true);
			}
			
			try {
				if (method.getParameterTypes().length == 0) {
					method.invoke(component);
				} else {
					method.invoke(component, args);
				}
				
				continue;
			} catch (InvocationTargetException e) {
				logger.warn("Exception from [" + lifecycle.getSimpleName()
						+ " (" + method + ")] event listener on component ["
						+ descriptor + "]", e.getTargetException());
				if (lifecycle.equals(Failed.class)) {
					throw new LifecycleException(e.getTargetException(), lifecycle, component);
				} else {
					Event.of(Failed.class).with(new LifecycleException(e.getTargetException(), lifecycle, component)).on(component).fire();
				}
				
			} catch (Exception e) {
				logger.warn("Cannot fire [" + lifecycle.getSimpleName()
						+ " (" + method + ")] event on component ["
						+ descriptor + "]", e);
			}
		}
	}
441214
protected function configurePipeline(): void
    {
        $this->pipeline = new Pipeline($this->findReplaceFactory);
        $this->registerReplaceName();
        $this->registerReplaceProjectRootNamespace();
    }
228685
def start(self):
        
        self._context.add_service_listener(
            self, self.requirement.filter, self.requirement.specification
        )
488178
def start(self):
        
        component = Component(self.config, self.handlers)
        component.run()
30727
def start(self):
        
        Global.LOGGER.info("starting the flow manager")
        self._start_actions()
        self._start_message_fetcher()
        Global.LOGGER.debug("flow manager started")
1371017
public void execute() {
        OrderComparator.sortIfNecessary(webflowConfigurers);
        webflowConfigurers.forEach(c -> {
            LOGGER.trace("Registering webflow configurer [{}]", c.getName());
            c.initialize();
        });
    }
18850
private function startup()
	{
		$this->registerSigHandlers();
		$this->pruneDeadWorkers();
		Resque_Event::trigger('beforeFirstFork', $this);
		$this->registerWorker();
	}
912212
def main(self):
        
        if not os.path.isfile(self.gdcs_report):
            logging.info('Starting {} analysis pipeline'.format(self.analysistype))
            # Run the analyses
            ShortKSippingMethods(self, self.cutoff)
            # Create the reports
            self.reporter()
        else:
            self.report_parse()
144770
def run(cls):
        
        if cls._tcp_service or cls._http_service or cls._http_views or cls._tcp_views:
            cls._set_host_id()
            cls._setup_logging()
            cls._set_process_name()
            cls._set_signal_handlers()
            cls._start_pubsub()
            cls._start_server()
        else:
            cls._logger.error('No services to host')
167635
@Override
    protected void onStart()
    {
        m_mappings = new HashMap<Bundle, List<T>>();
        // listen to bundles events
        m_context.addBundleListener( m_bundleListener = new SynchronousBundleListener()
        {

            public void bundleChanged( final BundleEvent bundleEvent )
            {
                switch( bundleEvent.getType() )
                {
                    case BundleEvent.STARTED:
                        register( bundleEvent.getBundle() );
                        break;
                    case BundleEvent.STOPPED:
                        unregister( bundleEvent.getBundle() );
                        break;
                }
            }

        }
            );

        // scan already started bundles
        Bundle[] bundles = m_context.getBundles();
        if( bundles != null )
        {
            for( Bundle bundle : bundles )
            {
                if( bundle.getState() == Bundle.ACTIVE )
                {
                    register( bundle );
                }
            }
        }
    }
1232667
public static Pipeline watchers(Context context, File baseDir, Mojo mojo, boolean pomFileMonitoring) {
        return new Pipeline(mojo, baseDir, Watchers.all(context), pomFileMonitoring);
    }