Starts (Subscribes) the client.
969326
def start (self):
        '''
        

        '''
        self.sub = rospy.Subscriber(self.topic, LaserScan, self.__callback)
236292
def start(self):
        
        # Subscribe to broadcast prompts published by a process
        # application in the parent operating system process.
        subscribe(handler=self.forward_prompt, predicate=self.is_prompt)

        # Initialise the system actor.
        msg = SystemInitRequest(
            self.system.process_classes,
            self.infrastructure_class,
            self.system.followings,
            self.pipeline_ids
        )
        response = self.actor_system.ask(self.system_actor, msg)

        # Keep the pipeline actor addresses, to send prompts directly.
        assert isinstance(response, SystemInitResponse), type(response)

        assert list(response.pipeline_actors.keys()) == self.pipeline_ids, (
            "Configured pipeline IDs mismatch initialised system {} {}").format(
            list(self.pipeline_actors.keys()), self.pipeline_ids
        )

        self.pipeline_actors = response.pipeline_actors
462898
def __start(self):  # pragma: no cover
        """"""

        assert not self._listener_thread

        self._listener_thread = threading.Thread(target=self.__run_listener,
                                                 name='clearly-listener')
        self._listener_thread.daemon = True
        self._listener_thread.start()
        self._wait_event.wait()
        self._wait_event.clear()
968373
function subscribe() {
    console.log(' > ', 'init', ['xmlrpc_bin://' + thisHost + ':2031', 'test123']);
    rpcClient.methodCall('init', ['xmlrpc_bin://' + thisHost + ':2031', 'test123'], function (err, res) {
        console.log(err, res);
    });
}
884234
def start(self):
        
        t=threading.Thread(target=self._consume)
        t.start()
1186534
def start (self):
        '''
        

        '''
        self.subrgb = rospy.Subscriber(self.topicrgb, ImageROS)
        self.subd = rospy.Subscriber(self.topicd, ImageROS)
        self.ts = message_filters.ApproximateTimeSynchronizer([subrgb, subd], 1, 0.1, allow_headerless=True)
        self.ts.registerCallback(self.__callback)
443447
def run(self):
    """"""

    if not (self._watchman and self._watchman.is_alive()):
      raise PantsService.ServiceError('watchman is not running, bailing!')

    # Enable watchman for the build root.
    self._watchman.watch_project(self._build_root)

    subscriptions = list(self._handlers.values())

    # Setup subscriptions and begin the main event firing loop.
    for handler_name, event_data in self._watchman.subscribed(self._build_root, subscriptions):
      self._state.maybe_pause()
      if self._state.is_terminating:
        break

      if event_data:
        # As we receive events from watchman, trigger the relevant handlers.
        self.fire_callback(handler_name, event_data)
827886
def start(self):
        """"""
        self._websocket = AIOWSClient(loop=self._loop,
                                      session=self._session,
                                      url=self._ws_url,
                                      async_callback=self._async_ws_handler)
        self._websocket.start()
1361410
def subscribe(self, *, create_task=True, **params):
        
        if create_task and not self.task:
            self.task = asyncio.ensure_future(self.run(**params))
        return self.channel.subscribe()
1291036
public function boot()
    {
        $subscriber = $this->app->make(CommandSubscriber::class);

        $this->app->events->subscribe($subscriber);
    }
639049
def start(self) -> None:
        

        self._shutdown = False

        # Start listening (if server) / Open connection (if client)
        if isinstance(self._protocol, Server):
            self.create_task(self._async_listen)
        elif isinstance(self._protocol, Client):
            self.create_task(self._async_open)
        else:
            raise NotImplementedError
254845
public void start() {
    proxy.setTrustAllServers(true);
    if (outsideProxy != null) {
      proxy.setChainedProxy(getProxyAddress(outsideProxy));
    }

    addRequestFilter("authentication", new AuthenticationFilter());
    addRequestFilter("requestSizeWatchdog", new RequestSizeWatchdog());
    addResponseFilter("responseSizeWatchdog", new ResponseSizeWatchdog());
    addResponseFilter("download", new FileDownloadFilter(config));

    proxy.start(config.proxyPort());
    port = proxy.getPort();
  }
1048952
public void start() {
    input.messageHandler(new Handler<Object>() {
      @Override
      public void handle(Object message) {
        output.send(message);
        pumped++;
      }
    });
  }
3064
def subscribe(self, receiver):
        ""
        log.debug('{0}.{1} subscribe to {2}'
                  .format(receiver.__module__, receiver.__name__, self))
        self.signal.connect(receiver)
930013
public void start() {
        stop(); // <-- If server is not running nothing happens.

        if (!isInitialized()) {
            onInit();
            server = __buildServer();
        }

        try {
            server.start();
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
810484
def start(self):
        
        rs = self.connection.start_instances([self.id])
        if len(rs) > 0:
            self._update(rs[0])
139963
public function subscribe()
    {
        if (!$this->active) {
            $this->reachedEnd = false;
            $this->client->sendFrame(
                $this->getProtocol()->getSubscribeFrame(
                    $this->subscription->getDestination(),
                    $this->subscription->getSubscriptionId(),
                    $this->subscription->getAck(),
                    $this->subscription->getSelector(),
                    false
                )->addHeaders($this->getHeader())
            );
            $this->active = true;
        }
    }