Process application "started" event.
559777
public void startedApplication(JPAApplInfo applInfo)
                    throws RuntimeWarning // d406994.2
    {
        final boolean isTraceOn = TraceComponent.isAnyTracingEnabled();
        if (isTraceOn && tc.isEntryEnabled())
            Tr.entry(tc, "startedApplication : " + applInfo.getApplName());

        // To save footprint, if an application does not have any JPA access, remove
        // the unnecessary appInfo object from list.
        if (applInfo.getScopeSize() == 0)
        {
            if (isTraceOn && tc.isDebugEnabled())
                Tr.debug(tc, "App has no JPA access - removing from applList");
            applList.remove(applInfo.getApplName());
        }

        if (isTraceOn && tc.isDebugEnabled())
            Tr.debug(tc, "Current application list : " + getSortedAppNames());

        if (isTraceOn && tc.isEntryEnabled())
            Tr.exit(tc, "startedApplication : " + applInfo.getApplName());
    }
118775
def start_process(self, key):
        """"""
        if key in self.processes and key in self.paused:
            os.killpg(os.getpgid(self.processes[key].pid), signal.SIGCONT)
            self.queue[key]['status'] = 'running'
            self.paused.remove(key)
            return True
        elif key not in self.processes:
            if self.queue[key]['status'] in ['queued', 'stashed']:
                self.spawn_new(key)
                return True

        return False
587501
@Handler
    public void onStart(Start event) {
        synchronized (this) {
            if (runner != null) {
                return;
            }
            buffers = new ManagedBufferPool<>(ManagedBuffer::new,
                () -> {
                    return ByteBuffer.allocateDirect(bufferSize);
                }, 2);
            runner = new Thread(this, Components.simpleObjectName(this));
            // Because this cannot reliably be stopped, it doesn't prevent
            // shutdown.
            runner.setDaemon(true);
            runner.start();
        }
    }
271515
function start() {
    proc = spawn(procCommand, procArgs, procOptions);

    var onClose = function (code) {
      if (!restarting) {
        process.exit(code);
      }
      start();
      restarting = false;
    };

    proc.on('error', function () {
      debug('restarting due error');
      restarting = true;
      proc.kill('SIGINT');
    });

    proc.on('close', onClose);
  }
1025994
def process_event(self, event_id):
    """"""
    with db.session.begin_nested():
        event = Event.query.get(event_id)
        event._celery_task = self  # internal binding to a Celery task
        event.receiver.run(event)  # call run directly to avoid circular calls
        flag_modified(event, 'response')
        flag_modified(event, 'response_headers')
        db.session.add(event)
    db.session.commit()
1128680
public void eventProcessingSuccessful(ActivityHandle ah,
			FireableEventType arg1, Object arg2, Address ad,
			ReceivableService arg4, int arg5) {
				
	}
848619
def on_start(self):
        
        LOGGER.debug("natsd.Service.on_start")
        self.service = threading.Thread(target=self.run_event_loop, name=self.serviceQ + " service thread")
        self.service.start()
        while not self.is_started:
            time.sleep(0.01)
878372
public static void run(Process process) {
    try {
      LOG.info("Starting {}.", process);
      process.start();
      LOG.info("Stopping {}.", process);
      System.exit(0);
    } catch (Throwable t) {
      LOG.error("Uncaught exception while running {}, stopping it and exiting.", process, t);
      try {
        process.stop();
      } catch (Throwable t2) {
        // continue to exit
        LOG.error("Uncaught exception while stopping {}, simply exiting.", process, t2);
      }
      System.exit(-1);
    }
  }
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)
303425
def begin_application(self, req, res):
        
        # Add the middleware processing to the event loop - this *should*
        # change the call stack so any server errors do not link back to this
        # function
        self.loop.create_task(self.http_application.handle_client_request(req, res))
364590
def process(self, buff):
        '''
            
        '''
        (self._stack, self._memory, scstateidx, self._state, 
            tmpevents, self._waitingforprop, self._parentismap) = process( buff, self.create_parser_info(), self._deserializers);
        self._scstate = self.scstatelist[scstateidx-1]
        
        self._events = tmpevents
611591
def start(self, payload):
        """"""
        # Start specific processes, if `keys` is given in the payload
        if payload.get('keys'):
            succeeded = []
            failed = []
            for key in payload.get('keys'):
                success = self.process_handler.start_process(key)
                if success:
                    succeeded.append(str(key))
                else:
                    failed.append(str(key))

            message = ''
            if len(succeeded) > 0:
                message += 'Started processes: {}.'.format(', '.join(succeeded))
                status = 'success'
            if len(failed) > 0:
                message += '\nNo paused, queued or stashed process for keys: {}'.format(', '.join(failed))
                status = 'error'

            answer = {'message': message.strip(), 'status': status}

        # Start a all processes and the daemon
        else:
            self.process_handler.start_all()
            if self.paused:
                self.paused = False
                answer = {'message': 'Daemon and all processes started.',
                          'status': 'success'}
            else:
                answer = {'message': 'Daemon already running, starting all processes.',
                          'status': 'success'}
        return answer
468013
def start(self):
        """"""
        asyncio.ensure_future(self.register(), loop=self._event_loop)

        if self._own_loop:
            _LOGGER.info("Starting up our own event loop.")
            self._event_loop.run_forever()
            self._event_loop.close()
            _LOGGER.info("Connection shut down.")
309347
public function start()
    {
        foreach ($this->processes as $pid => $process) {
            if (!$process->isStarted()) {
                $process->runAsync();
            }
        }
    }
708910
public void onApplicationEvent(ApplicationEvent e) {
		if (e instanceof LifecycleApplicationEvent) {
			LifecycleApplicationEvent le = (LifecycleApplicationEvent) e;
			if (shouldHandleEvent(e)) {
				if (le.getEventType() == LifecycleApplicationEvent.CREATED) {
					handleNewObject(le.getObject());
				} else if (le.getEventType() == LifecycleApplicationEvent.MODIFIED) {
					handleUpdatedObject(le.getObject());
				} else if (le.getEventType() == LifecycleApplicationEvent.DELETED) {
					handleDeletedObject(le.getObject());
				}
			}
		}
	}
117510
def run(self):
        ''''''
        # We left-append rather than emit (right-append) because some message
        # may have been already queued for execution before the director runs.
        global_event_queue.appendleft((INITIATE, self, (), {}))
        while global_event_queue:
            self.process_event(global_event_queue.popleft())
806786
public function onStart()
    {
        $this->setProcessName('master process');
        $this->createPidFile();

        $this->container->make('events')->dispatch('swoole.start', func_get_args());
    }