| # |
| # Licensed to the Apache Software Foundation (ASF) under one or more |
| # contributor license agreements. See the NOTICE file distributed with |
| # this work for additional information regarding copyright ownership. |
| # The ASF licenses this file to You under the Apache License, Version 2.0 |
| # (the "License"); you may not use this file except in compliance with |
| # the License. You may obtain a copy of the License at |
| # |
| # http://www.apache.org/licenses/LICENSE-2.0 |
| # |
| # Unless required by applicable law or agreed to in writing, software |
| # distributed under the License is distributed on an "AS IS" BASIS, |
| # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| # See the License for the specific language governing permissions and |
| # limitations under the License. |
| # |
| |
| import json |
| import flatbuffers |
| import apisix.runner.plugin.core as runner_plugin |
| import apisix.runner.utils.common as runner_utils |
| |
| from ipaddress import IPv4Address |
| from ipaddress import IPv6Address |
| from A6.HTTPReqCall import Rewrite as HCRw |
| from A6.HTTPReqCall import Action as HCAction |
| from A6.HTTPReqCall import Req as HCReq |
| from A6.PrepareConf import Req as PCReq |
| |
| |
| class Request: |
| |
| def __init__(self, r): |
| """ |
| Init and parse request |
| :param r: |
| rpc request object |
| """ |
| self._rpc_type = r.request.ty |
| self._rpc_buf = r.request.data |
| self._req_id = 0 |
| self.code = 0 |
| self._req_conf_token = 0 |
| self._req_method = "" |
| self._req_path = "" |
| self._req_headers = {} |
| self._req_configs = {} |
| self._req_args = {} |
| self._req_src_ip = "" |
| self._err_code = 0 |
| self.__init() |
| |
| @property |
| def rpc_type(self) -> int: |
| """ |
| get request protocol type for request handler |
| :return: |
| """ |
| return self._rpc_type |
| |
| @rpc_type.setter |
| def rpc_type(self, rpc_type: int) -> None: |
| """ |
| set request protocol type for request handler |
| :param rpc_type: |
| :return: |
| """ |
| self._rpc_type = rpc_type |
| |
| @property |
| def rpc_buf(self) -> bytes: |
| """ |
| get request buffer data for request handler |
| :return: |
| """ |
| return self._rpc_buf |
| |
| @rpc_buf.setter |
| def rpc_buf(self, rpc_buf: bytes) -> None: |
| """ |
| set request buffer data for request handler |
| :return: |
| """ |
| self._rpc_buf = rpc_buf |
| |
| @property |
| def conf_token(self) -> int: |
| """ |
| get request token for request handler |
| :return: |
| """ |
| return self._req_conf_token |
| |
| @conf_token.setter |
| def conf_token(self, req_conf_token: int) -> None: |
| """ |
| set request token for request handler |
| :return: |
| """ |
| self._req_conf_token = req_conf_token |
| |
| @property |
| def id(self) -> int: |
| """ |
| get request id for request handler |
| :return: |
| """ |
| return self._req_id |
| |
| @id.setter |
| def id(self, req_id: int) -> None: |
| """ |
| set request id for request handler |
| :return: |
| """ |
| self._req_id = req_id |
| |
| @property |
| def method(self) -> str: |
| """ |
| get request method for request handler |
| :return: |
| """ |
| return self._req_method |
| |
| @method.setter |
| def method(self, req_method: str) -> None: |
| """ |
| set request method for request handler |
| :return: |
| """ |
| self._req_method = req_method |
| |
| @property |
| def path(self) -> str: |
| """ |
| get request path for request handler |
| :return: |
| """ |
| return self._req_path |
| |
| @path.setter |
| def path(self, req_path: str) -> None: |
| """ |
| set request path for request handler |
| :return: |
| """ |
| self._req_path = req_path |
| |
| @property |
| def headers(self) -> dict: |
| """ |
| get request headers for request handler |
| :return: |
| """ |
| return self._req_headers |
| |
| @headers.setter |
| def headers(self, req_headers: dict) -> None: |
| """ |
| set request headers for request handler |
| :return: |
| """ |
| self._req_headers = req_headers |
| |
| @property |
| def configs(self) -> dict: |
| """ |
| get plugin instance and configs for request handler |
| :return: |
| """ |
| return self._req_configs |
| |
| @configs.setter |
| def configs(self, req_configs: dict) -> None: |
| """ |
| set plugin instance and configs for request handler |
| :return: |
| """ |
| self._req_configs = req_configs |
| |
| @property |
| def args(self) -> dict: |
| """ |
| get request args for request handler |
| :return: |
| """ |
| return self._req_args |
| |
| @args.setter |
| def args(self, req_args: dict) -> None: |
| """ |
| set request args for request handler |
| :return: |
| """ |
| self._req_args = req_args |
| |
| @property |
| def src_ip(self) -> str: |
| """ |
| get request source ip address for request handler |
| :return: |
| """ |
| return self._req_src_ip |
| |
| @src_ip.setter |
| def src_ip(self, req_src_ip: str) -> None: |
| """ |
| set request source ip address for request handler |
| :return: |
| """ |
| self._req_src_ip = req_src_ip |
| |
| @property |
| def err_code(self) -> int: |
| """ |
| get error code for request handler |
| :return: |
| """ |
| return self._err_code |
| |
| @err_code.setter |
| def err_code(self, err_code: int) -> None: |
| """ |
| set error code for request handler |
| :return: |
| """ |
| self._err_code = err_code |
| |
| def reset(self) -> None: |
| """ |
| reset request handler |
| :return: |
| """ |
| """ |
| reset request class |
| :return: |
| """ |
| self._rpc_type = 0 |
| self._rpc_buf = b'' |
| self._req_id = 0 |
| self._req_conf_token = 0 |
| self._req_method = "" |
| self._req_path = "" |
| self._req_headers = {} |
| self._req_configs = {} |
| self._req_args = {} |
| self._req_src_ip = "" |
| |
| def __init(self) -> None: |
| """ |
| init request handler |
| :return: |
| """ |
| if self.rpc_type == runner_utils.RPC_HTTP_REQ_CALL: |
| req = HCReq.Req.GetRootAsReq(self.rpc_buf) |
| |
| # fetch request id |
| self.id = req.Id() |
| |
| # fetch request conf token |
| self.conf_token = req.ConfToken() |
| |
| # fetch request uri |
| self.path = req.Path().decode() |
| |
| # fetch request method |
| self.method = runner_utils.get_method_name_by_code(req.Method()) |
| |
| # fetch request remote_addr |
| ip_list = runner_utils.parse_list_vector(req, runner_utils.VECTOR_TYPE_SOURCE_IP, True) |
| if ip_list: |
| if len(ip_list) == 16: |
| self.src_ip = IPv6Address(bytes(ip_list)).exploded |
| else: |
| self.src_ip = IPv4Address(bytes(ip_list)).exploded |
| |
| # fetch request headers |
| hdr_dict = runner_utils.parse_dict_vector(req, runner_utils.VECTOR_TYPE_HEADER) |
| if hdr_dict: |
| self.headers = hdr_dict |
| |
| # fetch request args |
| arg_dict = runner_utils.parse_dict_vector(req, runner_utils.VECTOR_TYPE_QUERY) |
| if arg_dict: |
| self.args = arg_dict |
| |
| if self.rpc_type == runner_utils.RPC_PREPARE_CONF: |
| req = PCReq.Req.GetRootAsReq(self.rpc_buf) |
| if req.ConfIsNone(): |
| return |
| |
| # loading plugin |
| plugins = runner_plugin.loading() |
| configs = {} |
| for i in range(req.ConfLength()): |
| name = str(req.Conf(i).Name().decode()).lower() |
| plugin = plugins.get(name) |
| if not plugin: |
| continue |
| value = req.Conf(i).Value().decode() |
| plugin = plugin() |
| plugin.config = json.loads(value) |
| configs[name] = plugin |
| self.configs = configs |
| |
| def checked(self): |
| """ |
| check request params is valid |
| :return: |
| """ |
| if len(self._req_path) == 0 and len(self._req_headers) == 0 and len(self._req_args) == 0: |
| return False |
| else: |
| return True |
| |
| @runner_utils.response_config |
| def config_handler(self, builder: flatbuffers.Builder): |
| return self.conf_token |
| |
| @runner_utils.response_call(HCAction.Action.Rewrite) |
| def call_handler(self, builder: flatbuffers.Builder): |
| if not self.checked(): |
| return None, 0 |
| |
| if len(self._req_path) <= 0: |
| self._req_path = "/" |
| path_vector = runner_utils.create_str_vector(builder, self._req_path) |
| |
| headers_vector = runner_utils.create_dict_vector(builder, self._req_headers, HCAction.Action.Rewrite, |
| runner_utils.VECTOR_TYPE_HEADER) |
| |
| args_vector = runner_utils.create_dict_vector(builder, self._req_args, HCAction.Action.Rewrite, |
| runner_utils.VECTOR_TYPE_QUERY) |
| |
| HCRw.RewriteStart(builder) |
| HCRw.RewriteAddPath(builder, path_vector) |
| HCRw.RewriteAddHeaders(builder, headers_vector) |
| HCRw.RewriteAddArgs(builder, args_vector) |
| rewrite = HCRw.RewriteEnd(builder) |
| return rewrite, self._req_id |
| |
| @runner_utils.response_unknown |
| def unknown_handler(self, builder: flatbuffers.Builder): |
| return self._err_code |
