archernet 1.3.0__py3-none-any.whl

archernet-1.3.0.dist-info/METADATA

@@ -0,0 +1,31 @@
+Metadata-Version: 2.4
+Name: archernet
+Version: 1.3.0
+Summary: network framework based on c library
+Home-page: https://github.com/tagaryen/pyarchernet
+Author: Archer
+Author-email: 2564928358@qq.com
+License: Apache License, Version 2.0 (Apache-2.0)
+Classifier: Development Status :: 4 - Beta
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Topic :: Software Development :: Build Tools
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.6
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+Requires-Python: >=3.6.0
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license
+Dynamic: license-file
+Dynamic: requires-python
+Dynamic: summary
+
+network framework based on c library

archernet-1.3.0.dist-info/RECORD

@@ -0,0 +1,18 @@
+archernet-1.3.0.dist-info/licenses/LICENSE,sha256=HrhfyXIkWY2tGFK11kg7vPCqhgh5DcxleloqdhrpyMY,11558
+pyarchernet/__init__.py,sha256=SzRKQHvzSiqB-w5K3LZA5AZQqp5FnHqrh3E0vD-Mur4,1411
+pyarchernet/arpc.py,sha256=Uo8UQb5J6RotbEou1BaLhk9ScQVKGdlLBmHM6PuBFoQ,9629
+pyarchernet/channel.py,sha256=RffNMmhiQkTtdwjZW1CTrPo3cbyQjzdoo-R75U_YWzA,9600
+pyarchernet/fair_lock.py,sha256=jWTQkQ95y3gbw0YLZI0jKwpQdRJhm3TeCf2p-jsuNT0,737
+pyarchernet/handlers.py,sha256=QS4O3FqYAVoV7NaOFZQbgQOBRS8i__y_3JjjzBpwebc,7804
+pyarchernet/http.py,sha256=blz9BMNSz79hd3sxHTCjaVru1eVkJqhSOQ-aoMQbxJk,40507
+pyarchernet/rs_client.py,sha256=cg4K-dZwWh7BQuIoxhjzk1hbKM3NUIKuPtEeqD9Psk4,5312
+pyarchernet/server_channel.py,sha256=QZI0YpWdhDSiyOuoEr48GSPbm8zeAwTlziBBdKVchyQ,9011
+pyarchernet/sm4util.py,sha256=ksrRozSHMvLiR-vClWq1hbaHOcH1WaHXbxtxYTuVXO4,8970
+pyarchernet/sslcontext.py,sha256=qZw4nXLZgzw3fH_-r52kg_y8WcTUZJQYt0mj0exuiwE,4869
+pyarchernet/unordered_map.py,sha256=AbenV-gNaoPyYVbcK-5hmmee7H6ySkWEe85T4yaI7Y4,1497
+pyarchernet/lib/libarchernet.dll,sha256=FUahgeDzkW9NRFudJ1AUvZARAgiuFl0sDx5TfKrKPL0,4634061
+pyarchernet/lib/libarchernet.so,sha256=Qb97Q1sRHOrqBLjabD4m2n7nrEoDNe3xcHgilsrzxfU,4530112
+archernet-1.3.0.dist-info/METADATA,sha256=N9V9d7ZTulkTb8DJNysuErVWMAUt9gMDhmVOQqtukjE,1049
+archernet-1.3.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+archernet-1.3.0.dist-info/top_level.txt,sha256=ZLUuZsHV4iIdBt28iYB0IxtsKNEolDcv-8OYMbBH_Lc,12
+archernet-1.3.0.dist-info/RECORD,,

archernet-1.3.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

archernet-1.3.0.dist-info/licenses/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed 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.

archernet-1.3.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+pyarchernet

pyarchernet/__init__.py

@@ -0,0 +1,30 @@
+__package__ = "pyarchernet"
+
+import ctypes, os
+import platform
+
+ARCHERLIB = None
+if platform.system().lower() == 'windows':
+    ARCHERLIB = ctypes.CDLL(os.path.dirname(os.path.abspath(__file__)) + '/lib/libarchernet.dll')
+    ARCHERLIB.ARCHER_net_init()
+elif platform.system().lower() == 'linux':
+    ARCHERLIB = ctypes.CDLL(os.path.dirname(os.path.abspath(__file__)) + '/lib/libarchernet.so')
+    ARCHERLIB.ARCHER_net_init()
+else:
+    raise Exception(f"platform '{platform.system()}' not supported")
+
+from .channel import Channel
+from .server_channel import ServerChannel
+from .sslcontext import SSLContext
+from .handlers import Handler, BaseFrameHandler, ChannelContext, HandlerList
+from .fair_lock import FairLock
+from .arpc import ARPCClient, ARPCServer, AbstractUrlMatcher
+from .http import HttpRequest, HttpResponse, HttpServer, HttpStatusCode, BlockedHttpHandler, HttpClient, HttpClientResponse, HttpError, Multipart, FormData, StreamWriter
+from .rs_client import RSClient
+
+__all__ = ['Channel', 'ServerChannel', 'SSLContext','Handler', 'ChannelContext','HandlerList', 'BaseFrameHandler', 'FairLock', 
+           'AbstractUrlMatcher', 'ARPCClient', 'ARPCServer',
+           'HttpRequest', 'HttpResponse', 'HttpServer', 'HttpStatusCode', 'BlockedHttpHandler', 'HttpClient', 'HttpClientResponse', 'HttpError', 'Multipart', 'FormData', 'StreamWriter',
+           'RSClient']
+
+

pyarchernet/arpc.py

@@ -0,0 +1,273 @@
+import json, traceback, threading, time
+from typing import Callable
+from abc import abstractmethod
+from .handlers import Handler, BaseFrameHandler, ChannelContext, NetError, HandlerList
+from .channel import Channel
+from .server_channel import ServerChannel
+from .sslcontext import SSLContext
+
+NOTFOUND = b'\0\0\0\0NOTFOUND'
+NOTFOUND_LEN = len(NOTFOUND)
+
+def _check_is_not_found(input: bytes):
+    if input is None or len(input) != NOTFOUND_LEN:
+        return False
+    for i in range(0, NOTFOUND_LEN):
+        if NOTFOUND[i] != input[i]:
+            return False
+    return True
+
+class AbstractUrlMatcher():
+
+    @abstractmethod
+    def on_message(self, msg: dict) -> dict:
+        '''
+        收到对方的消息时
+        '''
+        pass
+
+
+class _ARPCHandler(Handler):
+    
+    __url_map: dict
+
+    __ex_cb: Callable
+
+    def __init__(self):
+        self.__url_map = {}
+        self.__ex_cb = None
+        super().__init__()
+        
+    def on_error(self, ctx: ChannelContext, e: Exception):
+        if self.__ex_cb is not None:
+            self.__ex_cb(e)
+        else:
+            traceback.print_exception(e)
+    
+    def add_url_matcher(self, url: str, matcher: AbstractUrlMatcher):
+        self.__url_map[url] = matcher
+    
+    def get_url_matcher(self, url: str) -> AbstractUrlMatcher:
+        if url not in self.__url_map:
+            return None
+        return self.__url_map[url]
+
+    @property
+    def exception_handler(self) -> Callable:
+        return self.__ex_cb
+
+    @exception_handler.setter
+    def exception_handler(self, ex_cb: Callable):
+        self.__ex_cb = ex_cb
+
+
+
+
+class _ARPCServerHandler(_ARPCHandler):
+
+    def __init__(self):
+        super().__init__()
+    
+    def __send_not_found(self, ctx: ChannelContext):
+        data = NOTFOUND_LEN.to_bytes(2, byteorder="big", signed=False) + NOTFOUND
+        ctx.to_prev_handler_on_write(data)
+
+    def on_read(self, ctx: ChannelContext, data: bytes):
+        try: 
+            off_s, off_e = 0, 2
+            url_len = int.from_bytes(data[off_s:off_e], byteorder="big", signed=False)
+            off_s, off_e = off_e, off_e + url_len
+            url = data[off_s:off_e]
+            if _check_is_not_found(url):
+                super().on_error(ctx, NetError("Client send not found"))
+                return 
+            url = str(url, 'utf-8')
+            off_s = off_e
+            matcher = super().get_url_matcher(url)
+            if matcher is None:
+                super().on_error(ctx, NetError("Can not found matcher for url {}".format(url)))
+                self.__send_not_found(ctx)
+            else:
+                res = matcher.on_message(json.loads(str(data[off_s:], 'utf-8')))
+                res = {} if res is None else res
+                res_bs = data[:2+url_len] + bytes(json.dumps(res), 'utf-8')
+                ctx.to_prev_handler_on_write(res_bs)
+        except Exception as e:
+            super().on_error(ctx, e)
+        
+
+
+class ARPCServer():
+    def __init__(self, threads: int = 0, sslctx: SSLContext = None):
+        if not isinstance(threads, int):
+            raise ValueError("Threads must be a int")
+        if sslctx is not None and not isinstance(sslctx, SSLContext):
+            raise ValueError("Sslctx must be SSLContext")
+        if threads > 128:
+            threads = 128
+        if threads < 0:
+            threads = 0
+        self.__threads = threads
+        self.__sslctx = sslctx
+        self.__handler =  _ARPCServerHandler()
+
+    def listen_async(self, host: str, port: int):
+        self.__do_listen(host, port, handler=self.__handler, is_async=True)
+
+    def listen(self, host: str, port: int):
+        self.__do_listen(host, port, handler=self.__handler, is_async=False)
+    
+    def __do_listen(self, host: str, port: int, handler: _ARPCServerHandler, is_async: bool):
+        if not isinstance(host, str):
+            raise ValueError("host must be a int")
+        if not isinstance(port, int):
+            raise ValueError("port must be a int")
+        handlerList = HandlerList()
+        handlerList.add_handler(BaseFrameHandler())
+        handlerList.add_handler(self.__handler)
+        self.__server = ServerChannel(host, port, self.__threads, self.__sslctx, handlerlist=handlerList)
+        if is_async:
+            self.__server.listen_async()
+        else:
+            self.__server.listen()
+
+    def close(self):
+        self.__server.close()
+
+    def add_url_matcher(self, url: str, matcher: AbstractUrlMatcher):
+        if not isinstance(url, str):
+            raise ValueError("url must be a int")
+        if not isinstance(matcher, AbstractUrlMatcher):
+            raise ValueError("matcher must be AbstractUrlMatcher")
+        self.__handler.add_url_matcher(url, matcher=matcher)
+
+class _ARPCClientHandler(_ARPCHandler):
+
+    __cb_map: dict
+
+    def __init__(self, active_cb: Callable):
+        self.__cb = active_cb
+        self.__cb_map = {}
+        super().__init__()
+
+    def on_connect(self, ctx: ChannelContext):
+        self.__cb(ctx, True)
+
+    def on_read(self, ctx: ChannelContext, data: bytes):
+        try: 
+            off_s, off_e = 0, 2
+            url_len = int.from_bytes(data[off_s:off_e], byteorder="big", signed=False)
+            off_s, off_e = off_e, url_len + off_e
+            url = data[off_s:off_e]
+            if _check_is_not_found(url):
+                super().on_error(ctx, NetError("Server send not found"))
+                return 
+            url = str(url, 'utf-8')
+            data = str(data[off_e:], 'utf-8')
+            cb = self.get_url_cb(url)
+            if cb is None:
+                super().on_error(ctx, NetError("Can not found matcher for url {}".format(url)))
+            else:
+                cb(json.loads(data))
+        except Exception as e:
+            super().on_error(ctx, e)
+
+    def on_close(self, ctx: ChannelContext):
+        self.__cb(ctx, False)
+
+    def get_url_cb(self, url: str) -> Callable:
+        if url not in self.__cb_map:
+            return None
+        return self.__cb_map[url]
+
+    def add_url_cb(self, url: str, cb: Callable):
+        self.__cb_map[url] = cb
+
+
+class ARPCClient():
+    
+    __TIMEOUT = 2
+
+    __host: str
+    __port: int
+    __active: bool
+    __ctx: SSLContext
+    __ctx_lock: threading.Lock
+    __ctx_cnd: threading.Condition
+
+    def __init__(self, host: str, port: int, sslctx: SSLContext = None):
+        if not isinstance(host, str):
+            raise ValueError("host must be a int")
+        if not isinstance(port, int):
+            raise ValueError("port must be int")
+        if sslctx is not None and not isinstance(sslctx, SSLContext):
+            raise ValueError("sslctx must be SSLContext")
+        self.__host = host
+        self.__port = port
+        self.__sslctx = sslctx
+        self.__active = False
+        self.__ctx_lock = threading.Lock()
+        self.__ctx_cnd = threading.Condition(self.__ctx_lock)
+
+        def client_connected_cb(ctx: ChannelContext, active: bool):
+            self.__active = active
+            self.__ctx = ctx
+            with self.__ctx_lock:
+                self.__ctx_cnd.notify()
+
+        self.__handler = _ARPCClientHandler(client_connected_cb)
+    
+    def __do_connect(self):
+        if self.__active:
+            return
+        handlerList = HandlerList()
+        handlerList.add_handler(BaseFrameHandler())
+        handlerList.add_handler(self.__handler)
+        self.__channel = Channel(self.__host, self.__port, sslctx=self.__sslctx, handlerlist=handlerList)
+        self.__channel.connect_async()
+        
+        start = int(time.time())
+        with self.__ctx_lock:
+            self.__ctx_cnd.wait(ARPCClient.__TIMEOUT)
+        if start + ARPCClient.__TIMEOUT <= int(time.time()):
+            raise NetError("Connect timeout")
+    
+    def call(self, url: str, data: dict) -> dict:
+        if not isinstance(url, str):
+            raise ValueError("url must be a int")
+        if not isinstance(data, dict):
+            raise ValueError("data must be dict")
+        self.__do_connect()
+        msg = {'res': None}
+        msg_lock = threading.Lock()
+        msg_cnd = threading.Condition(msg_lock)
+        def msg_cb(res: dict):
+            msg['res'] = res
+            with msg_lock:
+                msg_cnd.notify_all()
+        self.call_async(url, data, msg_cb)
+        start = int(time.time())
+        with msg_lock:
+            msg_cnd.wait(ARPCClient.__TIMEOUT)
+        if start + ARPCClient.__TIMEOUT <= int(time.time()):
+            raise NetError("Read timeout")
+        if msg['res'] == None:
+            raise NetError("Can not get response")
+        return msg['res']
+    
+    def call_async(self, url: str, data: dict, msg_callback: Callable):
+        if not isinstance(url, str):
+            raise ValueError("url must be a int")
+        if not isinstance(data, dict):
+            raise ValueError("data must be dict")
+        if msg_callback is not None and not isinstance(msg_callback, Callable):
+            raise ValueError("msg_callback must be Callable")
+        self.__do_connect()
+        self.__handler.add_url_cb(url, msg_callback)
+        res = b'{}' if data is None else json.dumps(data)
+        url_bs = bytes(url, 'utf-8')
+        res_bs = len(url_bs).to_bytes(2, byteorder="big", signed=False) + url_bs + bytes(res, 'utf-8')
+        self.__ctx.to_prev_handler_on_write(res_bs)
+
+    def close(self):
+        self.__channel.close()