docs: def _bootstrap(self, blocking, **kwargs):
          """Synchronous bootstrap (even if `blocking=False` is provided !)
  
          Create the WAMP session and configure the `_callbacks_runner`.
          """
          join_config = {}
          for key in ('authid', 'authmethods', 'authrole', 'authextra'):
              val = kwargs.pop(key)
              if val:
                  join_config[key] = val
          if self._started:
              raise AlreadyRunningError("This AutobahnSync instance is already started")
          if blocking:
              self._callbacks_runner = CallbacksRunner()
          else:
              self._callbacks_runner = ThreadedCallbacksRunner()
  
          @crochet.wait_for(timeout=30)
          def start_runner():
              ready_deferred = defer.Deferred()
              logger.debug('[CrochetReactor] start bootstrap')
  
              def register_session(config):
                  logger.debug('[CrochetReactor] start register_session')
                  self._async_session = _AsyncSession(config=config, join_config=join_config)
                  self._session = SyncSession(self._callbacks_runner, self._on_challenge_callback)
                  self._async_session.connect_to_sync(self._session)
                  self._session.connect_to_async(self._async_session)
  
                  def resolve(result):
                      logger.debug('[CrochetReactor] callback resolve: %s' % result)
                      ready_deferred.callback(result)
                      return result
  
                  self._async_session.on_join_defer.addCallback(resolve)
  
                  def resolve_error(failure):
                      logger.debug('[CrochetReactor] errback resolve_error: %s' % failure)
                      ready_deferred.errback(failure)
  
                  self._async_session.on_join_defer.addErrback(resolve_error)
                  return self._async_session
  
              self._async_runner = ApplicationRunner(**kwargs)
              d = self._async_runner.run(register_session, start_reactor=False)
  
              def connect_error(failure):
                  ready_deferred.errback(failure)
  
              d.addErrback(connect_error)
              logger.debug('[CrochetReactor] end bootstrap')
              return ready_deferred
  
          logger.debug('[MainThread] call bootstrap')
          start_runner()
          logger.debug('[MainThread] call decorated register/subscribe')
          for cb in self._on_running_callbacks:
              cb()
          self._on_running_callbacks = []
          self._started = True
          logger.debug('[MainThread] start callbacks runner')