def _start_lazy_function(self, lazy_func: Callable[..., None],
request: BoltRequest) -> None:
# Start a lazy function asynchronously
func_name: str = get_name_for_callable(lazy_func)
self.logger.debug(debug_running_lazy_listener(func_name))
copied_request = self._build_lazy_request(request, func_name)
self.lazy_listener_runner.start(function=lazy_func,
request=copied_request)
def _register_listener(
self,
functions: Sequence[Callable[..., Awaitable[Optional[BoltResponse]]]],
primary_matcher: AsyncListenerMatcher,
matchers: Optional[Sequence[Callable[..., Awaitable[bool]]]],
middleware: Optional[Sequence[Union[Callable, AsyncMiddleware]]],
auto_acknowledgement: bool = False,
) -> Optional[Callable[..., Awaitable[Optional[BoltResponse]]]]:
value_to_return = None
if not isinstance(functions, list):
functions = list(functions)
if len(functions) == 1:
# In the case where the function is registered using decorator,
# the registration should return the original function.
value_to_return = functions[0]
for func in functions:
if not inspect.iscoroutinefunction(func):
name = get_name_for_callable(func)
raise BoltError(error_listener_function_must_be_coro_func(name))
listener_matchers = [
AsyncCustomListenerMatcher(app_name=self.name, func=f)
for f in (matchers or [])
]
listener_matchers.insert(0, primary_matcher)
listener_middleware = []
for m in middleware or []:
if isinstance(m, AsyncMiddleware):
listener_middleware.append(m)
elif isinstance(m, Callable) and inspect.iscoroutinefunction(m):
listener_middleware.append(
AsyncCustomMiddleware(app_name=self.name, func=m)
)
else:
raise ValueError(error_unexpected_listener_middleware(type(m)))
self._async_listeners.append(
AsyncCustomListener(
app_name=self.name,
ack_function=functions.pop(0),
lazy_functions=functions,
matchers=listener_matchers,
middleware=listener_middleware,
auto_acknowledgement=auto_acknowledgement,
)
)
return value_to_return
def _run(
self,
listener: Listener,
req: BoltRequest,
resp: BoltResponse,
) -> Optional[BoltResponse]:
resp, next_was_not_called = listener.run_middleware(req=req, resp=resp)
if next_was_not_called:
return None
return self.listener_runner.run(
request=req,
response=resp,
listener_name=get_name_for_callable(listener.ack_function),
listener=listener,
)
def run( # type: ignore
self,
request: BoltRequest,
response: BoltResponse,
listener_name: str,
listener: Listener,
starting_time: Optional[float] = None,
) -> Optional[BoltResponse]:
ack = request.context.ack
starting_time = starting_time if starting_time is not None else time.time(
)
if self.process_before_response:
if not request.lazy_only:
try:
returned_value = listener.run_ack_function(
request=request, response=response)
if isinstance(returned_value, BoltResponse):
response = returned_value
if ack.response is None and listener.auto_acknowledgement:
ack(
) # automatic ack() call if the call is not yet done
except Exception as e:
# The default response status code is 500 in this case.
# You can customize this by passing your own error handler.
if response is None:
response = BoltResponse(status=500)
response.status = 500
self.listener_error_handler.handle(
error=e,
request=request,
response=response,
)
ack.response = response
for lazy_func in listener.lazy_functions:
if request.lazy_function_name:
func_name = get_name_for_callable(lazy_func)
if func_name == request.lazy_function_name:
self.lazy_listener_runner.run(function=lazy_func,
request=request)
# This HTTP response won't be sent to Slack API servers.
return BoltResponse(status=200)
else:
continue
else:
self._start_lazy_function(lazy_func, request)
if response is not None:
self._debug_log_completion(starting_time, response)
return response
elif ack.response is not None:
self._debug_log_completion(starting_time, ack.response)
return ack.response
else:
if listener.auto_acknowledgement:
# acknowledge immediately in case of Events API
ack()
if not request.lazy_only:
# start the listener function asynchronously
def run_ack_function_asynchronously():
nonlocal ack, request, response
try:
listener.run_ack_function(request=request,
response=response)
except Exception as e:
# The default response status code is 500 in this case.
# You can customize this by passing your own error handler.
if listener.auto_acknowledgement:
self.listener_error_handler.handle(
error=e,
request=request,
response=response,
)
else:
if response is None:
response = BoltResponse(status=500)
response.status = 500
if ack.response is not None: # already acknowledged
response = None
self.listener_error_handler.handle(
error=e,
request=request,
response=response,
)
ack.response = response
self.listener_executor.submit(run_ack_function_asynchronously)
for lazy_func in listener.lazy_functions:
if request.lazy_function_name:
func_name = get_name_for_callable(lazy_func)
if func_name == request.lazy_function_name:
self.lazy_listener_runner.run(function=lazy_func,
request=request)
# This HTTP response won't be sent to Slack API servers.
return BoltResponse(status=200)
else:
continue
else:
self._start_lazy_function(lazy_func, request)
# await for the completion of ack() in the async listener execution
while ack.response is None and time.time() - starting_time <= 3:
time.sleep(0.01)
if response is None and ack.response is None:
self.logger.warning(warning_did_not_call_ack(listener_name))
return None
if response is None and ack.response is not None:
response = ack.response
self._debug_log_completion(starting_time, response)
return response
if response is not None:
return response
# None for both means no ack() in the listener
return None
async def async_dispatch(self, req: AsyncBoltRequest) -> BoltResponse:
"""Applies all middleware and dispatches an incoming request from Slack to the right code path.
:param req: An incoming request from Slack.
:return: The response generated by this Bolt app.
"""
starting_time = time.time()
self._init_context(req)
resp: BoltResponse = BoltResponse(status=200, body="")
middleware_state = {"next_called": False}
async def async_middleware_next():
middleware_state["next_called"] = True
for middleware in self._async_middleware_list:
middleware_state["next_called"] = False
if self._framework_logger.level <= logging.DEBUG:
self._framework_logger.debug(f"Applying {middleware.name}")
resp = await middleware.async_process(req=req,
resp=resp,
next=async_middleware_next)
if not middleware_state["next_called"]:
if resp is None:
return BoltResponse(
status=404,
body={"error": "no next() calls in middleware"})
return resp
for listener in self._async_listeners:
listener_name = get_name_for_callable(listener.ack_function)
self._framework_logger.debug(
debug_checking_listener(listener_name))
if await listener.async_matches(req=req, resp=resp):
# run all the middleware attached to this listener first
(
middleware_resp,
next_was_not_called,
) = await listener.run_async_middleware(req=req, resp=resp)
if next_was_not_called:
if middleware_resp is not None:
if self._framework_logger.level <= logging.DEBUG:
debug_message = debug_return_listener_middleware_response(
listener_name,
middleware_resp.status,
middleware_resp.body,
starting_time,
)
self._framework_logger.debug(debug_message)
return middleware_resp
# The last listener middleware didn't call next() method.
# This means the listener is not for this incoming request.
continue
if middleware_resp is not None:
resp = middleware_resp
self._framework_logger.debug(
debug_running_listener(listener_name))
listener_response: Optional[
BoltResponse] = await self._async_listener_runner.run(
request=req,
response=resp,
listener_name=listener_name,
listener=listener,
)
if listener_response is not None:
return listener_response
self._framework_logger.warning(warning_unhandled_request(req))
return BoltResponse(status=404, body={"error": "unhandled request"})