Start the publisher process.
337344
def _start_pub_proc(self,
                        publisher_type,
                        publisher_opts,
                        pub_id):
        '''
        
        '''
        log.debug('Starting the publisher process for %s', publisher_type)
        publisher = NapalmLogsPublisherProc(self.opts,
                                            self.publish_address,
                                            self.publish_port,
                                            publisher_type,
                                            self.serializer,
                                            self.__priv_key,
                                            self.__signing_key,
                                            publisher_opts,
                                            disable_security=self.disable_security,
                                            pub_id=pub_id)
        proc = Process(target=publisher.start)
        proc.start()
        proc.description = 'Publisher process'
        log.debug('Started publisher process as %s with PID %s', proc._name, proc.pid)
        return proc
968327
public void start() {
		lock.lock();
		try {
			if (State.NOT_STARTED.equals(state)) {
				spiderThread.addSpiderListener(this);
				spiderThread.start();
				state = State.RUNNING;
				SpiderEventPublisher.publishScanEvent(
						ScanEventPublisher.SCAN_STARTED_EVENT, this.scanId, this.target, user);
			}
		} finally {
			lock.unlock();
		}
	}
128839
def handle_publish(self, package, _):
        '''
        
        '''
        try:
            self.publisher.publish(package)
            return package
        # Add an extra fallback in case a forked process leeks through
        except Exception:
            log.critical('Unexpected error while polling master events',
                         exc_info=True)
            return None
511886
public void run()
    {
        try
        {
            log.info("Starting Publisher thread");

            while (!Thread.currentThread().isInterrupted())
            {
                Collection<ScriptSession> sessions = serverContext.getScriptSessionsByPage("/dwr/gi/index.html");
                ScriptProxy proxy = new ScriptProxy(sessions);

                Corporation corp = corporations.getNextChangedCorporation();
                proxy.addFunctionCall("OpenAjax.publish", "gidemo", "corporation", corp);

                int timeToSleep = random.nextInt(2500);
                Thread.sleep(timeToSleep);
            }
        }
        catch (InterruptedException ex)
        {
            // Ignore, we expect this
        }
        finally
        {
            log.info("Stopping Publisher thread");
        }
    }
277639
public function commit()
    {
        if ($this->disabled) {
            return;
        }
        foreach ($this->activePublishers as $key => $publisher) {
            $publisher->publish();
        }
        $this->activePublishers = [];
    }
805212
protected function registerAssetPublisher(): void
    {
        $this->app->singleton('asset.publisher', function (Application $app) {
            $publicPath = $app->publicPath();

            // The asset "publisher" is responsible for moving package's assets into the
            // web accessible public directory of an application so they can actually
            // be served to the browser. Otherwise, they would be locked in vendor.
            $publisher = new Asset($app->make('files'), $publicPath);

            $publisher->setPackagePath($app->basePath().'/vendor');

            return $publisher;
        });
    }
385630
def run(self):
        '''
        
        '''
        salt.utils.process.appendproctitle(self.__class__.__name__)
        self.io_loop = tornado.ioloop.IOLoop()
        with salt.utils.asynchronous.current_ioloop(self.io_loop):
            if self.opts['ipc_mode'] == 'tcp':
                epub_uri = int(self.opts['tcp_master_pub_port'])
                epull_uri = int(self.opts['tcp_master_pull_port'])
            else:
                epub_uri = os.path.join(
                    self.opts['sock_dir'],
                    'master_event_pub.ipc'
                )
                epull_uri = os.path.join(
                    self.opts['sock_dir'],
                    'master_event_pull.ipc'
                )

            self.publisher = salt.transport.ipc.IPCMessagePublisher(
                self.opts,
                epub_uri,
                io_loop=self.io_loop
            )

            self.puller = salt.transport.ipc.IPCMessageServer(
                self.opts,
                epull_uri,
                io_loop=self.io_loop,
                payload_handler=self.handle_publish,
            )

            # Start the master event publisher
            with salt.utils.files.set_umask(0o177):
                self.publisher.start()
                self.puller.start()
                if (self.opts['ipc_mode'] != 'tcp' and (
                        self.opts['publisher_acl'] or
                        self.opts['external_auth'])):
                    os.chmod(os.path.join(
                        self.opts['sock_dir'], 'master_event_pub.ipc'), 0o666)

            # Make sure the IO loop and respective sockets are closed and
            # destroyed
            Finalize(self, self.close, exitpriority=15)

            self.io_loop.start()
1334153
def publish(self, message, key=None, **kws):
        """"""
        return PSPut(self, message, key, **kws)
352405
public void publishTo(final K key, final Publisher<V> publisher) {
        registered.get(key).fromStream(Spouts.from(publisher));
    }
810401
def start(self, *args, **kwargs):
        
        self._stop = False
        super(ReadProbes, self).start(*args, **kwargs)
17095
def stop(self):
        
        LOGGER.debug("exiting publish")
        if self._publisher is not None:
            self._publisher.stop()
            self._publisher = None
        if self._broadcaster is not None:
            self._broadcaster.stop()
            self._broadcaster = None
912373
def start(self):
        """"""
        self.publish_properties()
        self.subscribe_topics()
        gc.collect()

        self.set_state("ready")

        while True:
            try:
                if not utils.wlan.isconnected():
                    utils.wifi_connect()

                # publish device data
                self.publish_data()

                # check for new mqtt messages
                self.mqtt.check_msg()

                idle()
                sleep(1)
            except KeyboardInterrupt:
                self.set_state("disconnected")
                self.mqtt.disconnect()
99303
@Validate
    public void start() {
        if (directory.isDirectory()) {
            buildFileIndex();
        }
        if (tracker != null) {
            tracker.open();
        }
        if (deployer != null) {
            deployer.start();
        }
    }
221669
def start(self):
        """"""
        # observers for this channel only need to wait for one value
        self._observer_params.update(dict(once=True))
        super(CurrentResourceValue, self).start()
        self._api.ensure_notifications_thread()
        self._api._mds_rpc_post(
            device_id=self.device_id,
            method='GET',
            uri=self.resource_path,
            async_id=self.async_id,
            _wrap_with_consumer=False,
        )
859014
protected function triggerPublish()
    {
        $this->info('Starting publishing vendor assets.');
        $this->call('vendor:publish');
        $this->info('Publishing vendor assets finished.');

        // Reload config
        $this->laravel['Illuminate\Foundation\Bootstrap\LoadConfiguration']->bootstrap($this->laravel);
    }
1273821
protected void start() {
    if (waterMarkEventGenerator != null) {
      LOG.fine("Starting waterMarkEventGenerator");
      waterMarkEventGenerator.start();
    }
    LOG.fine("Starting trigger policy");
    triggerPolicy.start();
  }
1290270
def run():
    """"""
    args = parse()
    build_results = [build(p) for p in glob.iglob(glob_path)]

    if not args['publish']:
        return

    for entry in build_results:
        publish(entry)