Merge pull request #41 from alexander255/master

Rethink the exception hierarchy

Author: mhchia

multiaddr/codecs/__init__.py

@@ -8,8 +8,8 @@
 
 
 class NoneCodec:
-	SIZE = 0
-	IS_PATH = False
+    SIZE = 0
+    IS_PATH = False
 
 
 CODEC_CACHE = {}
@@ -19,4 +19,4 @@ def codec_by_name(name):
     codec = CODEC_CACHE.get(name)
     if not codec:
         codec = CODEC_CACHE[name] = importlib.import_module(".{0}".format(name), __name__)
-    return codec
+    return codec

multiaddr/codecs/_util.py

@@ -5,4 +5,4 @@ def packed_net_bytes_to_int(b):
 else:  # PY2
     def packed_net_bytes_to_int(b):
         """Convert the given big-endian byte-string to an int."""
-        return int(b.encode('hex'), 16)
+        return int(b.encode('hex'), 16)

multiaddr/codecs/fspath.py

@@ -17,19 +17,19 @@
     import sys
 
     def fsencode(path):
-        if not isinstance(path, six.binary_type):
+        if not isinstance(path, six.binary_type):  # pragma: no cover
             path = path.encode(sys.getfilesystemencoding())
         return path
 
     def fsdecode(path):
-        if not isinstance(path, six.text_type):
+        if not isinstance(path, six.text_type):  # pragma: no cover
             path = path.decode(sys.getfilesystemencoding())
         return path
 
 
 def to_bytes(proto, string):
-	return fsencode(string)
+    return fsencode(string)
 
 
 def to_string(proto, buf):
-	return fsdecode(buf)
+    return fsdecode(buf)

multiaddr/codecs/idna.py

@@ -10,8 +10,8 @@
 
 
 def to_bytes(proto, string):
-	return idna.encode(string, uts46=True)
+    return idna.encode(string, uts46=True)
 
 
 def to_string(proto, buf):
-	return idna.decode(buf)
+    return idna.decode(buf)

multiaddr/codecs/ip4.py

@@ -11,12 +11,9 @@
 
 
 def to_bytes(proto, string):
-	try:
-		return netaddr.IPAddress(string, version=4).packed
-	except Exception:
-		raise ValueError("failed to parse ip4 addr: %s" % string)
+    return netaddr.IPAddress(string, version=4).packed
 
 
 def to_string(proto, buf):
-	ip_addr = netaddr.IPAddress(packed_net_bytes_to_int(buf), version=4)
-	return six.text_type(ip_addr)
+    ip_addr = netaddr.IPAddress(packed_net_bytes_to_int(buf), version=4)
+    return six.text_type(ip_addr)

multiaddr/codecs/ip6.py

@@ -11,12 +11,9 @@
 
 
 def to_bytes(proto, string):
-	try:
-		return netaddr.IPAddress(string, version=6).packed
-	except Exception:
-		raise ValueError("failed to parse ip4 addr: %s" % string)
+    return netaddr.IPAddress(string, version=6).packed
 
 
 def to_string(proto, buf):
-	ip_addr = netaddr.IPAddress(packed_net_bytes_to_int(buf), version=6)
-	return six.text_type(ip_addr)
+    ip_addr = netaddr.IPAddress(packed_net_bytes_to_int(buf), version=6)
+    return six.text_type(ip_addr)

multiaddr/codecs/onion.py

@@ -10,42 +10,31 @@
 
 
 def to_bytes(proto, string):
-	addr = string.split(":")
-	if len(addr) != 2:
-		raise ValueError(
-		    "failed to parse %s addr: %s does not contain a port number."
-		    % (proto.name, string))
-
-	# onion address without the ".onion" substring
-	if len(addr[0]) != 16:
-		raise ValueError(
-		    "failed to parse %s addr: %s not a Tor onion address."
-		    % (proto.name, string))
-	try:
-		onion_host_bytes = base64.b32decode(addr[0].upper())
-	except Exception as ex:
-		raise ValueError(
-		    "failed to decode base32 %s addr: %s %s"
-		    % (proto.name, string, str(ex)))
-
-	# onion port number
-	try:
-		port = int(addr[1])
-	except Exception as ex:
-		raise ValueError("failed to parse %s addr: %s"
-		                 % (proto.name, str(ex)))
-	if port >= 65536:
-		raise ValueError("failed to parse %s addr: %s"
-		                 % (proto.name, "port greater than 65536"))
-	if port < 1:
-		raise ValueError("failed to parse %s addr: %s"
-		                 % (proto.name, "port less than 1"))
-
-	return b''.join((onion_host_bytes, struct.pack('>H', port)))
+    addr = string.split(":")
+    if len(addr) != 2:
+        raise ValueError("Does not contain a port number")
+
+    # onion address without the ".onion" substring
+    if len(addr[0]) != 16:
+        raise ValueError("Invalid onion host address length (must be 16 characters)")
+    try:
+        onion_host_bytes = base64.b32decode(addr[0].upper())
+    except Exception as exc:
+        six.raise_from(ValueError("Cannot decode {0!r} as base32: {1}".format(addr[0], exc)), exc)
+
+    # onion port number
+    try:
+        port = int(addr[1], 10)
+    except ValueError as exc:
+        six.raise_from(ValueError("Port number is not a base 10 integer"), exc)
+    if port not in range(1, 65536):
+        raise ValueError("Port number is not in range(1, 65536)")
+
+    return b''.join((onion_host_bytes, struct.pack('>H', port)))
 
 
 def to_string(proto, buf):
-	addr_bytes, port_bytes = (buf[:-2], buf[-2:])
-	addr = base64.b32encode(addr_bytes).decode('ascii').lower()
-	port = six.text_type(struct.unpack('>H', port_bytes)[0])
-	return u':'.join([addr, port])
+    addr_bytes, port_bytes = (buf[:-2], buf[-2:])
+    addr = base64.b32encode(addr_bytes).decode('ascii').lower()
+    port = six.text_type(struct.unpack('>H', port_bytes)[0])
+    return u':'.join([addr, port])

multiaddr/codecs/p2p.py

@@ -11,17 +11,14 @@
 
 
 def to_bytes(proto, string):
-	# the address is a base58-encoded string
-	try:
-		if six.PY2 and isinstance(string, unicode):
-			string = string.encode("ascii")
-		mm = base58.b58decode(string)
-	except Exception as ex:
-		raise ValueError("failed to parse p2p addr: %s %s" % (string, str(ex)))
-	if len(mm) < 5:
-		raise ValueError("invalid P2P multihash: %s" % mm)
-	return mm
+    # the address is a base58-encoded string
+    if six.PY2 and isinstance(string, unicode):
+        string = string.encode("ascii")
+    mm = base58.b58decode(string)
+    if len(mm) < 5:
+        raise ValueError("P2P MultiHash too short: len() < 5")
+    return mm
 
 
 def to_string(proto, buf):
-	return base58.b58encode(buf).decode('ascii')
+    return base58.b58encode(buf).decode('ascii')

multiaddr/codecs/uint16be.py

@@ -9,17 +9,15 @@
 
 
 def to_bytes(proto, string):
-	try:
-		return struct.pack('>H', int(string, 10))
-	except ValueError as ex:
-		raise ValueError("failed to parse %s addr: %s"
-		                 % (proto.name, str(ex)))
-	except struct.error:
-		raise ValueError("failed to parse %s addr: %s" %
-		                 (proto.name, "greater than 65536"))
+    try:
+        return struct.pack('>H', int(string, 10))
+    except ValueError as exc:
+        six.raise_from(ValueError("Not a base 10 integer"), exc)
+    except struct.error as exc:
+        six.raise_from(ValueError("Integer not in range(65536)"), exc)
 
 
 def to_string(proto, buf):
-	if len(buf) != 2:
-		raise ValueError("Not a uint16")
-	return six.text_type(struct.unpack('>H', buf)[0])
+    if len(buf) != 2:
+        raise ValueError("Invalid integer length (must be 2 bytes / 16 bits)")
+    return six.text_type(struct.unpack('>H', buf)[0])

multiaddr/exceptions.py

@@ -0,0 +1,88 @@
+class Error(Exception):
+    pass
+
+
+class LookupError(LookupError, Error):
+    pass
+
+
+class ProtocolLookupError(LookupError):
+    """
+    MultiAddr did not contain a protocol with the requested code
+    """
+    
+    def __init__(self, proto, string):
+        self.proto  = proto
+        self.string = string
+        
+        super(ProtocolLookupError, self).__init__(
+            "MultiAddr {0!r} does not contain protocol {1}".format(string, proto)
+        )
+
+
+class ParseError(ValueError, Error):
+    pass
+
+
+class StringParseError(ParseError):
+    """
+    MultiAddr string representation could not be parsed
+    """
+
+    def __init__(self, message, string, protocol=None, original=None):
+        self.message  = message
+        self.string   = string
+        self.protocol = protocol
+        self.original = original
+
+        if protocol:
+            message = "Invalid MultiAddr {0!r} protocol {1}: {2}".format(string, protocol, message)
+        else:
+            message = "Invalid MultiAddr {0!r}: {1}".format(string, message)
+
+        super(StringParseError, self).__init__(message)
+
+
+class BinaryParseError(ParseError):
+    """
+    MultiAddr binary representation could not be parsed
+    """
+
+    def __init__(self, message, binary, protocol, original=None):
+        self.message  = message
+        self.binary   = binary
+        self.protocol = protocol
+        self.original = original
+
+        message = "Invalid binary MultiAddr protocol {0}: {1}".format(protocol, message)
+
+        super(BinaryParseError, self).__init__(message)
+
+
+class ProtocolManagerError(Error):
+    pass
+
+
+class ProtocolExistsError(ProtocolManagerError):
+    """
+    Protocol with the given name or code already exists
+    """
+    def __init__(self, proto, kind="name"):
+        self.proto = proto
+        self.kind  = kind
+
+        super(ProtocolExistsError, self).__init__(
+            "Protocol with {0} {1!r} already exists".format(kind, getattr(proto, kind))
+        )
+
+class ProtocolNotFoundError(ProtocolManagerError):
+    """
+    No protocol with the given name or code found
+    """
+    def __init__(self, value, kind="name"):
+        self.value = value
+        self.kind  = kind
+
+        super(ProtocolNotFoundError, self).__init__(
+            "No protocol with {0} {1!r} found".format(kind, value)
+        )