pool_simulator/pool.py at main · luminousmining/pool_simulator · GitHub

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
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
import logging
import socket
import threading
import json
import time

from algorithm import ALGORITHM
from stratums import (StratumSmartMining,
                      StratumEthash,
                      StratumKawpow,
                      StratumBlake3,
                      StratumMeowpow,
                      StratumQuaipow,
                      StratumAutolykosv2)


class Pool:

    def __init__(self, algo: str, hostname: str, port: int) -> None:
        self.algo = str(algo)
        self.hostname = str(hostname)
        self.port = int(port)
        self.__clients = dict()
        self.__socket = None
        self.alive = False
        self.threadAccept = None
        self.stratum = None

        if algo == ALGORITHM.SMART_MINING:
            self.stratum = StratumSmartMining()
        elif algo == ALGORITHM.ETHASH:
            self.stratum = StratumEthash()
        elif algo == ALGORITHM.KAWPOW:
            self.stratum = StratumKawpow()
        elif algo == ALGORITHM.MEOWPOW:
            self.stratum = StratumMeowpow()
        elif algo == ALGORITHM.QUAIPOW:
            self.stratum = StratumQuaipow()
        elif algo == ALGORITHM.BLAKE3:
            self.stratum = StratumBlake3()
        elif algo == ALGORITHM.AUTOLYKOS_V2:
            self.stratum = StratumAutolykosv2()

    def is_alive(self) -> bool:
        return self.alive

    def bind(self) -> None:
        self.alive = True

        logging.info(f'Open server {self.hostname}:{self.port} - {self.algo}')

        self.__socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        self.__socket.bind((self.hostname, self.port))
        self.__socket.listen(1)

        self.threadAccept = threading.Thread(target=self.__accept, args=())
        self.threadAccept.start()

    def __accept(self) -> None:
        sock, addr = self.__socket.accept()
        self.__clients[addr[1]] = sock
        logging.info(f'New client[{addr[1]}] connected! - Total clients {len(self.__clients)}')

        thread_loop = threading.Thread(target=self.__on_client,
                                       args=(addr[1], sock))
        thread_loop.start()

        self.threadAccept = threading.Thread(target=self.__accept, args=())
        self.threadAccept.start()

    def remove_client(self, by: str, addr: int) -> None:
        logging.warning(f'Remove client {addr} - {by}')
        if addr in self.__clients:
            del self.__clients[addr]

    def process(self) -> None:
        while self.is_alive() is True:
            try:
                time.sleep(0.1)
            except KeyboardInterrupt:
                self.alive = False

    def __on_client(self, addr, sock) -> None:
        while self.is_alive() is True:
            try:
                sock.settimeout(0.5)
                raw = sock.recv(2040)
                if not raw:
                    self.remove_client('packet is empty', addr)
                    return
                packets = raw.decode("utf-8").split('\n')
                if len(packets):
                    for packet in packets:
                        if len(packet):
                            data = json.loads(packet)
                            logging.info(f'recv <= {data}')
                            self.stratum.on_message(sock, data)
            except TimeoutError:
                pass
            except socket.timeout:
                pass
            except ConnectionAbortedError:
                self.remove_client('ConnectionAbortedError', addr)
                return
            except Exception as e:
                self.remove_client(f'Exception[{e}]', addr)
                return