Synchronous bootstrap (even if `blocking=False` is provided !)

        Create the WAMP session and configure the `_callbacks_runner`.

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')