SecuredBMAEndpoint

duniterpy/__init__.py

@@ -18,7 +18,7 @@
 
 PROTOCOL_VERSION="1"
 
-MANAGED_API=["BASIC_MERKLED_API"]
+MANAGED_API=["BASIC_MERKLED_API", "BMAS"]
 
 __author__      = 'Caner Candan & inso'
 __version__     = '0.30.6'

duniterpy/api/bma/api.py

@@ -39,10 +39,11 @@ ERROR_SCHEMA = {
     "required": ["ucode", "message"]
 }
 
+
 class ConnectionHandler(object):
     """Helper class used by other API classes to ease passing server connection information."""
 
-    def __init__(self, server, port, session=None):
+    def __init__(self, http_scheme, ws_scheme, server, port, session=None):
         """
         Init instance of connection handler
 
@@ -50,6 +51,8 @@ class ConnectionHandler(object):
         :param int port: Port
         :param aiohttp.ClientSession|None session: Session AIOHTTP
         """
+        self.http_scheme = http_scheme
+        self.ws_scheme = ws_scheme
         self.server = server
         self.port = port
         if session is None:
@@ -149,9 +152,10 @@ class API(object):
         :param str path: the request path
         :rtype: aiohttp.ClientResponse
         """
-        logging.debug("Request : {0}".format(self.reverse_url("http", path)))
+        logging.debug("Request : {0}".format(self.reverse_url(self.connection_handler.http_scheme, path)))
         with aiohttp.Timeout(15):
-            response = await self.connection_handler.session.get(self.reverse_url("http", path), params=kwargs,headers=self.headers)
+            url = self.reverse_url(self.connection_handler.http_scheme, path)
+            response = await self.connection_handler.session.get(url, params=kwargs,headers=self.headers)
             if response.status != 200:
                 try:
                     error_data = parse_error(await response.text())
@@ -174,7 +178,7 @@ class API(object):
         logging.debug("POST : {0}".format(kwargs))
         with aiohttp.Timeout(15):
             response = await self.connection_handler.session.post(
-                self.reverse_url("http", path),
+                self.reverse_url(self.connection_handler.http_scheme, path),
                 data=kwargs,
                 headers=self.headers
             )
@@ -187,5 +191,5 @@ class API(object):
         :param str path: the url path
         :rtype: aiohttp.ClientWebSocketResponse
         """
-        url = self.reverse_url("ws", path)
+        url = self.reverse_url(self.connection_handler.ws_scheme, path)
         return self.connection_handler.session.ws_connect(url)

duniterpy/documents/__init__.py

 from .block import Block, BlockUID, block_uid
 from .certification import Identity, Certification, Revocation
 from .membership import Membership
-from .peer import endpoint, BMAEndpoint, UnknownEndpoint, Peer
+from .peer import endpoint, BMAEndpoint, UnknownEndpoint, Peer, SecuredBMAEndpoint
 from .transaction import SimpleTransaction, Transaction, InputSource
 from .document import Document, MalformedDocumentError
 

duniterpy/documents/peer.py

@@ -101,6 +101,8 @@ def endpoint(value):
             if value.startswith(api):
                 if api == "BASIC_MERKLED_API":
                     return BMAEndpoint.from_inline(value)
+                if api == "BMAS":
+                    return SecuredBMAEndpoint.from_inline(value)
         return UnknownEndpoint.from_inline(value)
     else:
         raise TypeError("Cannot convert {0} to endpoint".format(value))
@@ -186,11 +188,11 @@ class BMAEndpoint(Endpoint):
         :rtype: ConnectionHandler
         """
         if self.server:
-            return ConnectionHandler(self.server, self.port, session)
+            return ConnectionHandler("http", "ws", self.server, self.port, session)
         elif self.ipv4:
-            return ConnectionHandler(self.ipv4, self.port, session)
+            return ConnectionHandler("http", "ws", self.ipv4, self.port, session)
         else:
-            return ConnectionHandler("[{0}]".format(self.ipv6), self.port, session)
+            return ConnectionHandler("http", "ws", "[{0}]".format(self.ipv6), self.port, session)
 
     def __str__(self):
         return self.inline()
@@ -204,3 +206,45 @@ class BMAEndpoint(Endpoint):
 
     def __hash__(self):
         return hash((self.server, self.ipv4, self.ipv6, self.port))
+
+
+class SecuredBMAEndpoint(BMAEndpoint):
+    re_inline = re.compile('^BMAS(?: ([a-z0-9-_.]*(?:.[a-zA-Z])))?(?: ((?:[0-9.]{1,4}){4}))?(?: ((?:[0-9a-f:]{4,5}){4,8}))?(?: ([0-9]+))$')
+
+    def __init__(self, server, ipv4, ipv6, port):
+        self.server = server
+        self.ipv4 = ipv4
+        self.ipv6 = ipv6
+        self.port = port
+
+    @classmethod
+    def from_inline(cls, inline):
+        m = SecuredBMAEndpoint.re_inline.match(inline)
+        if m is None:
+            raise MalformedDocumentError("BMAEndpoint")
+        server = m.group(1)
+        ipv4 = m.group(2)
+        ipv6 = m.group(3)
+        port = int(m.group(4))
+        return cls(server, ipv4, ipv6, port)
+
+    def inline(self):
+        return "BASIC_MERKLED_API{DNS}{IPv4}{IPv6}{PORT}" \
+                    .format(DNS=(" {0}".format(self.server) if self.server else ""),
+                            IPv4=(" {0}".format(self.ipv4) if self.ipv4 else ""),
+                            IPv6=(" {0}".format(self.ipv6) if self.ipv6 else ""),
+                            PORT=(" {0}".format(self.port) if self.port else ""))
+
+    def conn_handler(self, session=None):
+        """
+        Return connection handler instance for the endpoint
+
+        :param aiohttp.ClientSession session: AIOHTTP client session instance
+        :rtype: ConnectionHandler
+        """
+        if self.server:
+            return ConnectionHandler("https", "wss", self.server, self.port, session)
+        elif self.ipv4:
+            return ConnectionHandler("https", "wss", self.ipv4, self.port, session)
+        else:
+            return ConnectionHandler("https", "wss", "[{0}]".format(self.ipv6), self.port, session)