def _execute(self, transforms, *args, **kwargs): """Executes this request with the given output transforms. This is basically a copy of tornado's `_execute()` method. The only difference is the expected result. Tornado expects the result to be `None`, where we want this to be a :py:class:Model.""" verb = self.request.method.lower() headers = self.request.headers self._transforms = transforms try: if self.request.method not in self.SUPPORTED_METHODS: raise HTTPError(405) self.path_args = [self.decode_argument(arg) for arg in args] self.path_kwargs = dict((k, self.decode_argument(v, name=k)) for (k, v) in kwargs.items()) # If XSRF cookies are turned on, reject form submissions without # the proper cookie if self.request.method not in ("GET", "HEAD", "OPTIONS") and \ self.application.settings.get("xsrf_cookies"): self.check_xsrf_cookie() result = self.prepare() if is_future(result): result = yield result if result is not None: raise TypeError("Expected None, got %r" % result) if self._prepared_future is not None: # Tell the Application we've finished with prepare() # and are ready for the body to arrive. self._prepared_future.set_result(None) if self._finished: return if _has_stream_request_body(self.__class__): # In streaming mode request.body is a Future that signals # the body has been completely received. The Future has no # result; the data has been passed to self.data_received # instead. try: yield self.request.body except iostream.StreamClosedError: return method = getattr(self, self.request.method.lower()) result = method(*self.path_args, **self.path_kwargs) if is_future(result): result = yield result if result is not None: self._provide_result(verb, headers, result) if self._auto_finish and not self._finished: self.finish() except Exception as e: self._handle_request_exception(e) if (self._prepared_future is not None and not self._prepared_future.done()): # In case we failed before setting _prepared_future, do it # now (to unblock the HTTP server). Note that this is not # in a finally block to avoid GC issues prior to Python 3.4. self._prepared_future.set_result(None)
def _execute(self, transforms, *args, **kwargs): """Executes this request with the given output transforms.""" self._transforms = transforms try: if self.request.method not in self.SUPPORTED_METHODS: raise web.HTTPError(405) self.path_args = [self.decode_argument(arg) for arg in args] self.path_kwargs = dict((k, self.decode_argument(v, name=k)) for (k, v) in kwargs.items()) # If XSRF cookies are turned on, reject form submissions without # the proper cookie if self.request.method not in ("GET", "HEAD", "OPTIONS") and \ self.application.settings.get("xsrf_cookies"): self.check_xsrf_cookie() result = self.prepare() if result is not None: result = yield result if self._prepared_future is not None: # Tell the Application we've finished with prepare() # and are ready for the body to arrive. future_set_result_unless_cancelled(self._prepared_future, None) if self._finished: return if web._has_stream_request_body(self.__class__): # In streaming mode request.body is a Future that signals # the body has been completely received. The Future has no # result; the data has been passed to self.data_received # instead. try: yield self.request.body except iostream.StreamClosedError: return #method = getattr(self, self.request.method.lower()) result = self.method(*self.path_args, **self.path_kwargs) if result is not None: result = yield result if self._auto_finish and not self._finished: self.finish() except Exception as e: try: self._handle_request_exception(e) except Exception: app_log.error("Exception in exception handler", exc_info=True) if (self._prepared_future is not None and not self._prepared_future.done()): # In case we failed before setting _prepared_future, do it # now (to unblock the HTTP server). Note that this is not # in a finally block to avoid GC issues prior to Python 3.4. self._prepared_future.set_result(None)
def _execute(self, transforms, *args, **kwargs): """ Override Tornados' native _execute When _RequestDispatcher calls 'execute', it will instantiate the handler with the application, request, and the kwargs from the URLSpec. The handler's '_execute' function is then called. This is where the 'get', 'post', etc. methods are called. Rather than directly calling 'get', 'post', etc. what _execute should do is """ self._transforms = transforms try: self.do_check_supported_methods(*args, **kwargs) # If XSRF cookies are turned on, reject form submissions without # the proper cookie self.do_check_xsrf() self.do_prepare() if self._finished: return if _has_stream_request_body(self.__class__): # In streaming mode request.body is a Future that signals # the body has been completely received. The Future has no # result; the data has been passed to self.data_received # instead. try: yield self.request.body except StreamClosedError: return self.do_call_request_method() # TODO define specific exceptions. General exception handling is bad practice except Exception as e: try: self._handle_request_exception(e) except Exception: self.logger.error("Exception in exception handler", exc_info=True) if (self._prepared_future is not None and not self._prepared_future.done()): # In case we failed before setting _prepared_future, do it # now (to unblock the HTTP server). Note that this is not # in a finally block to avoid GC issues prior to Python 3.4. self._prepared_future.set_result(None)
async def _execute(self, transforms: List["OutputTransform"], *args: bytes, **kwargs: bytes) -> None: """Executes this request with the given output transforms.""" self._transforms = transforms if hasattr(self, "_firma_http_extra_methods"): self._firma_http_extra_methods() try: if self.request.method not in self.SUPPORTED_METHODS: raise tornado.web.HTTPError(405) if hasattr(self, "_firma_unsupported_methods"): self._firma_http_unsupported_methods() if hasattr(self, "_firma_request_hook"): self._firma_request_hook() self.path_args = [self.decode_argument(arg) for arg in args] self.path_kwargs = dict((k, self.decode_argument(v, name=k)) for (k, v) in kwargs.items()) if hasattr(self, "_firma_process_args"): self.path_args = self._firma_process_args(self.path_args) # If XSRF cookies are turned on, reject form submissions without # the proper cookie if self.request.method not in ( "GET", "HEAD", "OPTIONS", ) and self.application.settings.get("xsrf_cookies"): self.check_xsrf_cookie() result = self.prepare() if result is not None: result = await result if self._prepared_future is not None: # Tell the Application we've finished with prepare() # and are ready for the body to arrive. future_set_result_unless_cancelled(self._prepared_future, None) if self._finished: return if _has_stream_request_body(self.__class__): # In streaming mode request.body is a Future that signals # the body has been completely received. The Future has no # result; the data has been passed to self.data_received # instead. try: await self.request._body_future except iostream.StreamClosedError: return method = getattr(self, self.request.method.lower()) result = method(*self.path_args, **self.path_kwargs) if result is not None: result = await result if self._auto_finish and not self._finished: self.finish() # Edit start - Think this is to catch MySQL errors? except IOError as e: print('ioerror') raise e except AssertionError as e: print('assertionerror') raise e # Edit end except Exception as e: try: self._handle_request_exception(e) except Exception: app_log.error("Exception in exception handler", exc_info=True) finally: # Unset result to avoid circular references result = None if self._prepared_future is not None and not self._prepared_future.done( ): # In case we failed before setting _prepared_future, do it # now (to unblock the HTTP server). Note that this is not # in a finally block to avoid GC issues prior to Python 3.4. self._prepared_future.set_result(None)
def _execute(self, transforms, *args, **kwargs): """Executes this request with the given output transforms.""" self._transforms = transforms try: if self.request.method not in self.SUPPORTED_METHODS: raise HTTPError(405) self.path_args = [self.decode_argument(arg) for arg in args] self.path_kwargs = dict((k, self.decode_argument(v, name=k)) for (k, v) in kwargs.items()) # If XSRF cookies are turned on, reject form submissions without # the proper cookie if self.request.method not in ("GET", "HEAD", "OPTIONS") and \ self.application.settings.get("xsrf_cookies"): self.check_xsrf_cookie() result = self.prepare() if result is not None: result = yield result if self._prepared_future is not None: future_set_result_unless_cancelled(self._prepared_future, None) if self._finished: return if _has_stream_request_body(self.__class__): try: yield self.request.body except iostream.StreamClosedError: return _request_mapping_dict_ = self._request_mapping_dict_ # type: Dict[str, Dict[re.Pattern, str]] possible_host_matcher_to_method_string = _request_mapping_dict_.get(self.request.method.lower()) method_string = '' if possible_host_matcher_to_method_string: for host_matcher_compile, _method_string in possible_host_matcher_to_method_string.items(): # host_matcher = HostMatches(host_matcher_str) target_params = host_matcher_compile.match(self.request.path) if target_params is not None: method_string = _method_string break if not method_string: if self.request.method.lower() == 'options': method_string = 'options' else: raise HTTPError(405) method = getattr(self, method_string) result = method(*self.path_args, **self.path_kwargs) if result is not None: result = yield result if self._auto_finish and not self._finished: self.finish() except Exception as e: try: self._handle_request_exception(e) except Exception: app_log.error("Exception in exception handler", exc_info=True) finally: # Unset result to avoid circular references result = None if (self._prepared_future is not None and not self._prepared_future.done()): # In case we failed before setting _prepared_future, do it # now (to unblock the HTTP server). Note that this is not # in a finally block to avoid GC issues prior to Python 3.4. self._prepared_future.set_result(None)
def _execute(self, transforms, *args, **kwargs): """Executes this request with the given output transforms.""" self._transforms = transforms # mango start self._mango_extra_methods() # mango end try: # mango start if (self.request.method not in self.SUPPORTED_METHODS) or \ (getattr(self, "_unsupported_methods", None) and ( True in self._unsupported_methods or \ self.request.method.lower() in self._unsupported_methods )): code, message = self._unsupported_method_error raise HTTPError(code, message) self._mango_check_user() # mango end self.path_args = [self.decode_argument(arg) for arg in args] self.path_kwargs = dict((k, self.decode_argument(v, name=k)) for (k, v) in list(kwargs.items())) # mango end self._mango_handle_args() # mango start # If XSRF cookies are turned on, reject form submissions without # the proper cookie if self.request.method not in ("GET", "HEAD", "OPTIONS") and \ self.application.settings.get("xsrf_cookies"): self.check_xsrf_cookie() result = self.prepare() if is_future(result): result = yield result if result is not None: raise TypeError("Expected None, got %r" % result) if self._prepared_future is not None: # Tell the Application we've finished with prepare() # and are ready for the body to arrive. self._prepared_future.set_result(None) if self._finished: return if _has_stream_request_body(self.__class__): # In streaming mode request.body is a Future that signals # the body has been completely received. The Future has no # result; the data has been passed to self.data_received # instead. try: yield self.request.body except iostream.StreamClosedError: return method = getattr(self, self.request.method.lower()) result = method(*self.path_args, **self.path_kwargs) if is_future(result): result = yield result if result is not None: raise TypeError("Expected None, got %r" % result) if self._auto_finish and not self._finished: self.finish() # mango start - Think this is to catch MySQL errors? except IOError as e: print('ioerror') raise e except AssertionError as e: print('assertionerror') raise e # mango end except Exception as e: self._handle_request_exception(e) if (self._prepared_future is not None and not self._prepared_future.done()): # In case we failed before setting _prepared_future, do it # now (to unblock the HTTP server). Note that this is not # in a finally block to avoid GC issues prior to Python 3.4. self._prepared_future.set_result(None)