Bitmessage/MiNode
3
0
Fork 1
Code Pull Requests 9 Actions Activity

WIP: Handling a new pylint design checker message #17

Draft
lee.miller wants to merge 4 commits from lee.miller/MiNode:lint into v0.3
pull from: lee.miller/MiNode:lint
merge into: Bitmessage:v0.3
Conversation 0 Commits 4 Files Changed 8 +39 -53
8 changed files with 39 additions and 53 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

30
minode/connection.py
View File

@ -20,22 +20,19 @@ class ConnectionBase(threading.Thread):
Common code for the connection thread
with minimum command handlers to reuse
"""
def __init__(
self, host, port, s=None, network='ip', server=False,
i2p_remote_dest=b''
):
def __init__(self, host, port, s=None, server=False):
self.host = host
self.port = port
self.network = network
self.i2p_remote_dest = i2p_remote_dest
self.network = 'i2p' if port == 'i2p' else 'ip'
if self.network == 'i2p':
self.host_print = self.i2p_remote_dest[:8].decode()
else:
self.host_print = self.host
self.host_print = (
self.host[:8].decode() if self.network == 'i2p' else self.host)
super().__init__(name='Connection to {}:{}'.format(host, port))
self.s = s
self.server = server
self.send_queue = queue.Queue()
self.vectors_to_get = set()
@ -43,22 +40,13 @@ class ConnectionBase(threading.Thread):
self.vectors_requested = {}
self.status = 'ready'
self.tls = False
self.status = 'connected' if bool(s) else 'ready'
self.verack_received = False
self.verack_sent = False
self.s = s
self.remote_version = None
self.server = server
if bool(s):
self.status = 'connected'
self.buffer_receive = b''
self.buffer_send = b''
@ -238,7 +226,7 @@ class ConnectionBase(threading.Thread):
logging.debug('ssl.SSLError reason: %s', e.reason)
shared.node_pool.discard((self.host, self.port))
return
self.tls = True
logging.debug(
'Established TLS connection with %s:%s (%s)',
self.host_print, self.port, self.s.version())

13
minode/i2p/dialer.py
View File

@ -7,14 +7,15 @@ from .util import I2PThread
class I2PDialer(I2PThread):
def __init__(
self, state, destination, nick, sam_host='127.0.0.1', sam_port=7656
self, state, destination, nick=None, *, sam_host=None, sam_port=None
):
self.sam_host = sam_host
self.sam_port = sam_port
# Initially 127.0.0.1:7656
self.sam_host = sam_host or state.i2p_sam_host
self.sam_port = sam_port or state.i2p_sam_port
self.nick = nick
self.destination = destination
self.nick = nick or state.i2p_session_nick
super().__init__(state, name='I2P Dial to {}'.format(self.destination))
@ -27,9 +28,7 @@ class I2PDialer(I2PThread):
logging.debug('Connecting to %s', self.destination)
self._connect()
if not self.state.shutting_down and self.success:
c = self.state.connection(
self.destination, 'i2p', self.s, 'i2p',
False, self.destination)
c = self.state.connection(self.destination, 'i2p', self.s, False)
c.start()
self.state.connections.add(c)

3
minode/i2p/listener.py
View File

@ -45,8 +45,7 @@ class I2PListener(I2PThread):
logging.debug('Rejecting duplicate I2P connection.')
self.s.close()
else:
c = self.state.connection(
destination, 'i2p', self.s, 'i2p', True, destination)
c = self.state.connection(destination, 'i2p', self.s, True)
c.start()
self.state.connections.add(c)
c = None

9
minode/manager.py
View File

@ -156,10 +156,7 @@ class Manager(threading.Thread):
if port == 'i2p' and shared.i2p_enabled:
if shared.i2p_session_nick and host != shared.i2p_dest_pub:
try:
d = I2PDialer(
shared,
host, shared.i2p_session_nick,
shared.i2p_sam_host, shared.i2p_sam_port)
d = I2PDialer(shared, host)
d.start()
hosts.add(d.destination)
shared.i2p_dialers.add(d)
@ -275,7 +272,7 @@ class Manager(threading.Thread):
dest_pub_raw = base64.b64decode(
shared.i2p_dest_pub, altchars=b'-~')
obj = structure.Object(
b'\x00' * 8, int(time.time() + 2 * 3600),
int(time.time() + 2 * 3600),
shared.i2p_dest_obj_type, shared.i2p_dest_obj_version,
shared.stream, dest_pub_raw)
shared.stream, object_payload=dest_pub_raw)
proofofwork.do_pow_and_publish(obj)

10
minode/message.py
View File

@ -101,9 +101,10 @@ def _payload_read_int(data):
class Version():
"""The version message payload"""
def __init__(
self, host, port, protocol_version=shared.protocol_version,
services=shared.services, nonce=shared.nonce,
user_agent=shared.user_agent, streams=None
self, host, port,
nonce=shared.nonce, services=shared.services,
*, streams=None, user_agent=shared.user_agent,
protocol_version=shared.protocol_version,
):
self.host = host
self.port = port
@ -176,7 +177,8 @@ class Version():
raise ValueError('malformed Version message, wrong streams_count')
return cls(
host, port, protocol_version, services, nonce, user_agent, streams)
host, port, nonce, services, streams=streams,
protocol_version=protocol_version, user_agent=user_agent)
class Inv():

4
minode/proofofwork.py
View File

@ -39,8 +39,8 @@ def _worker(obj):
logging.debug(
'Finished doing POW, nonce: %s, time: %ss', nonce, time.time() - t)
obj = structure.Object(
nonce, obj.expires_time, obj.object_type, obj.version,
obj.stream_number, obj.object_payload)
obj.expires_time, obj.object_type, obj.version, obj.stream_number,
object_payload=obj.object_payload, nonce=nonce)
logging.debug(
'Object vector is %s', base64.b16encode(obj.vector).decode())

9
minode/structure.py
View File

@ -48,8 +48,8 @@ class VarInt():
class Object():
"""The 'object' message payload"""
def __init__(
self, nonce, expires_time, object_type, version,
stream_number, object_payload
self, expires_time, object_type, version, stream_number,
*, object_payload, tag=None, nonce=b'\x00' * 8
):
self.nonce = nonce
self.expires_time = expires_time
@ -60,7 +60,7 @@ class Object():
self.vector = hashlib.sha512(hashlib.sha512(
self.to_bytes()).digest()).digest()[:32]
self.tag = (
self.tag = tag or (
# broadcast from version 5 and pubkey/getpukey from version 4
self.object_payload[:32] if object_type == 3 and version == 5
or (object_type in (0, 1) and version == 4)
@ -84,7 +84,8 @@ class Object():
payload[:stream_number_varint_length]).n
payload = payload[stream_number_varint_length:]
return cls(
nonce, expires_time, object_type, version, stream_number, payload)
expires_time, object_type, version, stream_number,
object_payload=payload, nonce=nonce)
def to_bytes(self):
"""Serialize to bytes"""

14
minode/tests/test_structure.py
View File

@ -19,7 +19,7 @@ sample_addr_data = unhexlify(
# data for an object with expires_time 1697063939
# structure.Object(
# b'\x00' * 8, expires_time, 42, 1, 2, b'HELLO').to_bytes()
# expires_time, 42, 1, 2, object_payload=b'HELLO').to_bytes()
sample_object_data = unhexlify(
'000000000000000000000000652724030000002a010248454c4c4f')
@ -135,13 +135,13 @@ class TestStructure(unittest.TestCase):
self.assertEqual(obj.object_payload, b'HELLO')
obj = structure.Object(
b'\x00' * 8, int(time.time() + 3000000), 42, 1, 1, b'HELLO')
int(time.time() + 3000000), 42, 1, 1, object_payload=b'HELLO')
self.assertFalse(obj.is_valid())
obj.expires_time = int(time.time() - 11000)
self.assertFalse(obj.is_valid())
obj = structure.Object(
b'\x00' * 8, int(time.time() + 300), 42, 1, 2, b'HELLO')
int(time.time() + 300), 42, 1, 2, object_payload=b'HELLO')
vector = obj.vector
proofofwork._worker(obj) # pylint: disable=protected-access
obj = shared.objects.popitem()[1]
@ -159,8 +159,8 @@ class TestStructure(unittest.TestCase):
"""Check the main proofofwork call and worker"""
shared.vector_advertise_queue = queue.Queue()
obj = structure.Object(
b'\x00' * 8, int(time.time() + 300), 42, 1,
shared.stream, b'HELLO')
int(time.time() + 300), 42, 1,
shared.stream, object_payload=b'HELLO')
start_time = time.time()
proofofwork.do_pow_and_publish(obj)
try:
@ -189,6 +189,6 @@ class TestStructure(unittest.TestCase):
self.fail("No nonce found in the queue")
obj = structure.Object(
nonce, obj.expires_time, obj.object_type, obj.version,
obj.stream_number, obj.object_payload)
obj.expires_time, obj.object_type, obj.version, obj.stream_number,
object_payload=obj.object_payload, nonce=nonce)
self.assertTrue(obj.is_valid())