rostrum 14.0.1

An efficient implementation of Electrum Server with token support
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86

#
# Implement an asyncio.Protocol for Electrum (clients)
#
#
import asyncio
import json
import logging
import socket

logger = logging.getLogger(__name__)


class StratumProtocol(asyncio.Protocol):
    client = None
    closed = False
    transport = None
    buf = b""
    connection_lost_called = False

    def connection_made(self, transport):
        self.transport = transport
        logger.debug("Transport connected ok")

        # To detect if server disconnected us
        sock = self.transport.get_extra_info("socket")
        if sock is not None:
            sock.setsockopt(socket.SOL_SOCKET, socket.SO_KEEPALIVE, 1)

    def connection_lost(self, exc):
        if not self.closed:
            self.closed = True
            self.close()
        if not self.connection_lost_called:
            self.connection_lost_called = True
            self.client.connection_lost(self)

    def data_received(self, data):
        self.buf += data

        # Unframe the mesage. Expecting JSON.
        *lines, self.buf = self.buf.split(b"\n")

        for line in lines:
            if not line:
                continue

            try:
                msg = line.decode("utf-8", "error").strip()
            except UnicodeError as exc:
                logger.exception("Encoding issue on %r", line)
                self.connection_lost(exc)
                return

            try:
                msg = json.loads(msg)
            except ValueError as exc:
                logger.exception("Bad JSON received from server: %r", msg)
                self.connection_lost(exc)
                return

            # logger.debug("RX:\n%s", json.dumps(msg, indent=2))

            # pylint: disable=protected-access
            try:
                self.client._got_response(msg)
            except Exception as e:
                logger.exception("Trouble handling response! (%s)", e)
                continue

    def send_data(self, message):
        """
        Given an object, encode as JSON and transmit to the server.
        """
        # logger.debug("TX:\n%s", json.dumps(message, indent=2))
        data = json.dumps(message).encode("utf-8") + b"\n"
        self.transport.write(data)

    def close(self):
        if not self.closed:
            try:
                self.transport.close()
            finally:
                self.closed = True


# EOF