#! / USR / бен / питон

время импорта
импорт JSON
импорт base64
импорт HTTPLIB
импорт SYS
импорт ОС
импорт os.path
импорт binascii
импорт подпроцесс
из склепа импорта склепа
импорт rdf022
Очередь импорта
от серийного импорта Последовательный
от резьбонарезания импорта темы, события
от конфигурации импорта ArgsConfig, AsicConfig
от autobahn.twisted.websocket импорта WebSocketServerFactory, WebSocketServerProtocol
из реактора импорта twisted.internet
от twisted.internet.task импорта LoopingCall
от twisted.internet.serialport импорта SerialPort
от twisted.protocols.basic импорта LineReceiver
импорт binascii
гнездо импорта
импорт запросов
от импорта requests.auth HTTPBasicAuth

VERSION = '1.1.4'

# ------- -------- hw.py
Последовательный импорт # с последовательным
#import подпроцесс
сон импорт времени # с
#import binascii

MAX_BOARDS = 8
MAX_CHIPS = 32
MAX_CLUSTERS = 6
MAX_CORES = 9

g_tail = '00000000000000000000000000000000a78e0100000001000000f615f7ce3b4fc6b8f61e8f89aedb1d0852507650533a9e3b10b9bbcc30639f279fcaa86746e1ef52d3edb3c4ad8259920d509bd073605c9bf1d59983752a6b06b817bb4ea78e011d012d59d4'

Класс AsicBoard (объект):

    Защиту __init __ (я, com_port, reset_gpio, PRT):
        self.comport_mode = 0 # comport_mode: 0 для синхронного, 1 для асинхронных
        self.com_port = com_port
        self.reset_gpio = reset_gpio
        self.prt = PRT
        self.asic = \
        {
            '00': { '00': 0x0000, '01': 0x0000, '02': 0x0000, '03': 0x0000, '04': 0x0000, '05': 0x0000},
            '01': { '00': 0x0000, '01': 0x0000, '02': 0x0000, '03': 0x0000, '04': 0x0000, '05': 0x0000},
            '02': { '00': 0x0000, '01': 0x0000, '02': 0x0000, '03': 0x0000, '04': 0x0000, '05': 0x0000},
            '03': { '00': 0x0000, '01': 0x0000, '02': 0x0000, '03': 0x0000, '04': 0x0000, '05': 0x0000},
            '04': { '00': 0x0000, '01': 0x0000, '02': 0x0000, '03': 0x0000, '04': 0x0000, '05': 0x0000},
            '05': { '00': 0x0000, '01': 0x0000, '02': 0x0000, '03': 0x0000, '04': 0x0000, '05': 0x0000},
            '06': { '00': 0x0000, '01': 0x0000, '02': 0x0000, '03': 0x0000, '04': 0x0000, '05': 0x0000},
            '07': { '00': 0x0000, '01': 0x0000, '02': 0x0000, '03': 0x0000, '04': 0x0000, '05': 0x0000},
            '08': { '00': 0x0000, '01': 0x0000, '02': 0x0000, '03': 0x0000, '04': 0x0000, '05': 0x0000},
            '09': { '00': 0x0000, '01': 0x0000, '02': 0x0000, '03': 0x0000, '04': 0x0000, '05': 0x0000},
            '0a': { '00': 0x0000, '01': 0x0000, '02': 0x0000, '03': 0x0000, '04': 0x0000, '05': 0x0000},
            '0b': { '00': 0x0000, '01': 0x0000, '02': 0x0000, '03': 0x0000, '04': 0x0000, '05': 0x0000},
            '0c': { '00': 0x0000, '01': 0x0000, '02': 0x0000, '03': 0x0000, '04': 0x0000, '05': 0x0000},
            '0d': { '00': 0x0000, '01': 0x0000, '02': 0x0000, '03': 0x0000, '04': 0x0000, '05': 0x0000},
            '0e': { '00': 0x0000, '01': 0x0000, '02': 0x0000, '03': 0x0000, '04': 0x0000, '05': 0x0000},
            '0f': { '00': 0x0000, '01': 0x0000, '02': 0x0000, '03': 0x0000, '04': 0x0000, '05': 0x0000},
            '10': { '00': 0x0000, '01': 0x0000, '02': 0x0000, '03': 0x0000, '04': 0x0000, '05': 0x0000},
            '11': { '00': 0x0000, '01': 0x0000, '02': 0x0000, '03': 0x0000, '04': 0x0000, '05': 0x0000},
            '12': { '00': 0x0000, '01': 0x0000, '02': 0x0000, '03': 0x0000, '04': 0x0000, '05': 0x0000},
            '13': { '00': 0x0000, '01': 0x0000, '02': 0x0000, '03': 0x0000, '04': 0x0000, '05': 0x0000},
            '14': { '00': 0x0000, '01': 0x0000, '02': 0x0000, '03': 0x0000, '04': 0x0000, '05': 0x0000},
            '15': { '00': 0x0000, '01': 0x0000, '02': 0x0000, '03': 0x0000, '04': 0x0000, '05': 0x0000},
            '16': { '00': 0x0000, '01': 0x0000, '02': 0x0000, '03': 0x0000, '04': 0x0000, '05': 0x0000},
            '17': { '00': 0x0000, '01': 0x0000, '02': 0x0000, '03': 0x0000, '04': 0x0000, '05': 0x0000},
            '18': { '00': 0x0000, '01': 0x0000, '02': 0x0000, '03': 0x0000, '04': 0x0000, '05': 0x0000},
            '19': { '00': 0x0000, '01': 0x0000, '02': 0x0000, '03': 0x0000, '04': 0x0000, '05': 0x0000},
            '1а': { '00': 0x0000, '01': 0x0000, '02': 0x0000, '03': 0x0000, '04': 0x0000, '05': 0x0000},
            '1b': { '00': 0x0000, '01': 0x0000, '02': 0x0000, '03': 0x0000, '04': 0x0000, '05': 0x0000},
            '1c': { '00': 0x0000, '01': 0x0000, '02': 0x0000, '03': 0x0000, '04': 0x0000, '05': 0x0000},
            '1d': { '00': 0x0000, '01': 0x0000, '02': 0x0000, '03': 0x0000, '04': 0x0000, '05': 0x0000},
            '1е': { '00': 0x0000, '01': 0x0000, '02': 0x0000, '03': 0x0000, '04': 0x0000, '05': 0x0000},
            '1f': { '00': 0x0000, '01': 0x0000, '02': 0x0000, '03': 0x0000, '04': 0x0000, '05': 0x0000}
        }
        self.good_cores = 0
        self.bad_cores = 0

    Защиту set_comport_sync_mode (самостоятельно):
        self.comport_mode = 0

    Защиту set_comport_async_mode (самостоятельно):
        self.comport_mode = 1

    Защиту write_by_hex (самостоятельно, данные):
        если (self.comport_mode == 0):
            self.com_port.write (data.decode ( 'шестигранной') [:: - 1])
        еще:
            reactor.callFromThread (AlcheProtocol.sendLine, self.prt, data.decode ( 'шестигранной') [:: - 1])

    сброс четкости (сам):
        вернуть subprocess.call ([ 'ш', 'reset_board', self.reset_gpio], оболочки = False)

    Защита вровень (самостоятельно, рассчитывать):
        соответственно = self.com_port.read (количество) # не более 10 байтов х 32 х 6 чипов кластера = 1920 байт
        в то время как Len (соответственно) > 0:
            соответственно = self.com_port.read (количество)

    # Установки всех СБИС работать на ФАПЧ @ 360 МГц
    Защиту set_pll (самостоятельно):
        для КГП в отсортированном (self.asic):
            Полезная нагрузка = '% s' % чп + ff000100000000400c00 '+ g_tail
            self.write_by_hex (полезная нагрузка)
            time.sleep (0.02)
            Полезная нагрузка = '% s' % чп + ff0001000000a0620c00 '+ g_tail
            self.write_by_hex (полезная нагрузка)
            time.sleep (0.02)
            Полезная нагрузка = '% s' % чп + ff0001000000a0220400 '+ g_tail
            self.write_by_hex (полезная нагрузка)
            time.sleep (0.02)
            Полезная нагрузка = '% s' % чп + ff0001000000a0220000 '+ g_tail
            self.write_by_hex (полезная нагрузка)
            ''»# Overdrive 10%
            Полезная нагрузка = '% s' % чп + ff000100000000400c00 '+ g_tail
            self.write_by_hex (полезная нагрузка)
            time.sleep (0.02)
            Полезная нагрузка = '% s' % чп + ff000100000060410c00 '+ g_tail
            self.write_by_hex (полезная нагрузка)
            time.sleep (0.02)
            Полезная нагрузка = '% s' % чп + ff000100000060110400 '+ g_tail
            self.write_by_hex (полезная нагрузка)
            time.sleep (0.02)
            Полезная нагрузка = '% s' % чп + ff000100000060110000 '+ g_tail
            self.write_by_hex (полезная нагрузка)
            «»»
    Защиту set_all_idle (самостоятельно):
        Полезная нагрузка = 'ffff0001000000a0220200' + g_tail
        self.write_by_hex (полезная нагрузка)

    Защиту set_all_active (самостоятельно):
        Полезная нагрузка = 'ffff0001000000a0220000' + g_tail
        self.write_by_hex (полезная нагрузка) 

    Защиту calc_asic_cores (самостоятельно, сканирование):
        self.good_cores = 0
        self.bad_cores = 0

        если проверка:
            для КГП в отсортированном (self.asic):
                для clst в self.asic [чп]:
                    self.asic [чп] [clst] = 0x0000
            для КГП в отсортированном (self.asic):
                печать "Сканирование СИС% s ...% чп
                # Установленный режим диагностики
                Полезная нагрузка = чп + 'ff0001000000a0220100' + g_tail
                self.write_by_hex (полезная нагрузка)
                # Дать золотую работу образца, ожидать «ecff6386ebd9»
                # (CHP | 0x80) только для режима диагностики - позволяют все ответы получить вернулся
                CC = '% 02x' % (интермедиат (CHP, 16) + 128)
                Полезная нагрузка = CC + '0000000000000000000000000000000000000000000000000000a78e0100000001000000f615f7ce3b4fc6b8f61e8f89aedb1d0852507650533a9e3b10b9bbcc30639f279fcaa86746e1ef52d3edb3c4ad8259920d509bd073605c9bf1d59983752a6b06b817bb4ea78e011d012d59d4'
                self.write_by_hex (полезная нагрузка)
                CNT = 0
                в то время как True:
                    соответственно = self.com_port.read (9)
                    если Len (соответственно) == 9:
                        _chpid = соответственно [8] .encode ( 'гекс')
                        если (_chpid > '1f'):
                            печать 'CHPID заблуждается!
                        _clsid = соответственно [7] .encode ( 'гекс')
                        если (_clsid > '05'):
                            печать 'CLSID заблуждаться!
                        _corid = Ord (соответственно [6])
                        если (_corid > 8):
                            печать 'corid заблуждается!
                        _nonce = соответственно [3 :: - 1] .encode ( 'шестигранной')
                        #core_status = _nonce в 'ecff6386ebd9'
                        core_status = _nonce в '6386ebd9'
                        если core_status:
                            self.good_cores + 1 =
                            #print 'Хорошо:% d,% d,% d' % (_chpid, _clsid, _corid)
                            self.asic [_chpid] [_ CLSID] | = (1 << _corid)
                        еще:
                            self.bad_cores + 1 =
                            печати 'Плохо:% s,% s,% s,% d' % (_nonce, _chpid, _clsid, _corid)

                        CNT = 0
                    CNT + 1 =
                    если (CNT > 5):
                        ломать
        еще:
            #print self.asic
            для _chpid в self.asic:
                для _clsid в self.asic [_chpid]:
                    Маска = 0x0100
                    в то время как маска > 0:
                        если ((self.asic [_chpid] [_ CLSID] & маска) = 0):
                            self.good_cores + 1 =
                        еще:
                            self.bad_cores + 1 =
                        маскировать >>= 1

    Защиту config_workspace (я, start_of_nonce, несколько):
        n_offset = start_of_nonce
        для КГП в отсортированном (self.asic):
            # Установка дополнительного нонса = 0x0001
            Полезная нагрузка = ( '% S' % СНР) + 'ff0001000000a0220000' + g_tail
            time.sleep (0.01)
            self.write_by_hex (полезная нагрузка)

            для clst в отсортированном (self.asic [чп]):
                дс = 0
                Смещение = '% 08x' % n_offset
                Сердечники = '% 04x' % self.asic [чп] [clst]
                Полезная нагрузка = '% SFE% s% s% s' % \
                          (Чп, clst, \
                           offset.decode ( 'шестигранной') [:: - 1] .encode ( 'шестигранной'), \
                           cores.decode ( 'шестигранной') [:: - 1] .encode ( 'шестигранной')) + \
                          '00' * 104
                self.write_by_hex (полезная нагрузка)
                #Распечатать '>>> % S'% полезной нагрузки
                core_mask = self.asic [чп] [clst]
                для г в интервале (0, 15, 1):
                    если (core_mask & 0x0001):
                        дс + 1 =
                    core_mask >>= 1
                n_offset + = множественный * дс


    Защиту rev_per_4bytes (самостоятельно, данные):
        х = «»
        для я в диапазоне (0, длина (данные), 8):
            х + = данные [I + 6: I + 8] + данные [I + 4: я + 6] + данные [I + 2: I + 4] + данные [I: I + 2]
        вернуться х

    Защиту give_work (сам, чип, мишень, блок):
        header_hex = self.swap4 (блок [0: 160])
        Полезная нагрузка = чип + мишень + header_hex
        # Self.write_by_hex (полезная нагрузка)
        вернуть payload.decode ( 'шестигранной') [:: - 1]

    Защиту swap4 (я, binascii_str):
        ул = binascii.unhexlify (binascii_str)
        х = Len (ул) / 4
        ред = '' .join ([ул [я * 4: я * 4 + 4] [:: - 1] я в диапазоне (0, х)])
        вернуться binascii.hexlify (об)

    Защиту revall (я, binascii_str):
        ул = binascii.unhexlify (binascii_str)
        ДОХОД = ул [:: - 1]
        вернуться binascii.hexlify (об)



# ------- -------- hw.py

SUBMIT_Q_THROTTLE = 30
WEB_REFRESH_TIME = 5
LCM_REFRESH_TIME = 5
REFRESH_KHRATE_TIME = 5
STRATUM_CHK_INTERVAL = 30

первый = { '00': Нет, '01': Нет, '02': Нет, '03': Нет, '04': Нет, '05': Нет, '06': Нет, '07': Нет }
ком = { '00': Нет, '01': Нет, '02': Нет, '03': Нет, '04': Нет, '05': Нет, '06': Нет, '07': Нет }
шд = { '00': Нет, '01': Нет, '02': Нет, '03': Нет, '04': Нет, '05': Нет, '06': Нет, '07': Нет }
pool_ctrl = { '00': Нет, '01': Нет, '02': Нет, '03': Нет, '04': Нет, '05': Нет, '06': Нет, '07': Нет }
alche_protocol = { '00': Нет, '01': Нет, '02': Нет, '03': Нет, '04': Нет, '05': Нет, '06': Нет, '07': Нет }
ans_queue = { '00': Нет, '01': Нет, '02': Нет, '03': Нет, '04': Нет, '05': Нет, '06': Нет, '07': Нет }

active_brd_num = 0
active_brd = []

miner_ctrl = Событие ()
для р в pool_ctrl:
    pool_ctrl [р] = Событие ()
submitter_ctrl = Событие ()
stat_reset = Событие ()

stratum_proxy_isRunning = False
ws_client = []

LCM = rdf022.get_lcm ()
Защиту lcm_disp (MSG):
    сбщ = ( 'IP-:' + rdf022.get_ip (), MSG)
    lcm.messages = сбщ
    lcm.refresh ()

Класс CoinRPC (объект):
    Защиту __init __ (я, хост, порт, имя пользователя, пароль):
        self.host = хост
        self.port = порт
        self.username = имя пользователя
        self.password = пароль
        self.url = 'HTTP: //' + self.host + ':' + self.port

    Защиту восстановить (я, хост, порт, имя пользователя, пароль):
        self.host = хост
        self.port = порт
        self.username = имя пользователя
        self.password = пароль        
        self.url = 'HTTP: //' + self.host + ':' + self.port

    Защиту getwork (само данные = нет):
        Полезная нагрузка = { 'версии': '1.1', 'метод': 'getwork', 'PARAMS': [], 'ID': '1'}

        полезная нагрузка [ 'PARAMS'] = ([], если данные (не None) остальные данные)

        пытаться:
            г = requests.post (self.url, \
                                AUTH = HTTPBasicAuth (self.username, self.password), \
                                данные = json.dumps (полезная нагрузка), \
                                Тайм-аут = 30)
            соответственно = r.json ()
            если (соответственно [ 'ошибки'] не является None):
                печать "- ошибка RPC!
                печать r.text
                возвращения None
            еще:
                вернуться соотв [ «результат»]

        кроме requests.ConnectionError:
            печать "- ошибка соединения HTTP!
            возвращения None

        кроме requests.Timeout:
            Печать "- HTTP соединение тайм-аут!
            возвращения None

        кроме исключений при е:
            печать "- RPC общая ошибка!
            печать E
            возвращения None

Класс Отправитель (Thread):
    Защиту __init __ (Я):
        Тема .__ __ инициализации (само)
        self.daemon = True
        self.coin_rpc = CoinRPC (config.host, config.port, config.username, config.password)

    Защита пробег (Я):
        в то время как True:
            если submitter_ctrl.isSet ():
                submitter_ctrl.clear ()

            (Ставка, данные, цель, nonce_bin) = submit_queue.get ()
            Печать '- Q (% d) -' % submit_queue.qsize ()
            = nonce_bin нонс [:: - 1] .encode ( 'шестигранной')
            решение = данные [: 152] + Nonce + данные [160: 256]
            param_arr = [раствор]

            не submit_result = None
            для г в диапазоне (5):
                submit_result = self.coin_rpc.getwork (param_arr)
                если (submit_result не является None):
                    hash_queue.put ((ставка, submit_result, цель, nonce_bin))
                    ломать
                еще:
                    self.coin_rpc.reconnect (config.host, config.port, config.username, config.password)
                    печать '** отправить переподключение ... **
                    time.sleep (0,1)

            submit_queue.task_done ()
            time.sleep (0,05)

Класс AlcheProtocol (LineReceiver):
    Защиту __init __ (я, ставка):
        self.bid = ставка
        self._busyReceiving = False
        self._buffer = B ''

    Защиту connectionMade (самостоятельно):
        печать self.bid + подключен AlcheProtocol.
        # Self.delimiter = B ''

    Защиту sendLine (я, строка):
        Возвращение self.transport.write (линия)

    Защиту DataReceived (самостоятельно, данные):
        если self._busyReceiving:
            self._buffer + = данные
            вернуть
        пытаться:
            self._busyReceiving = True
            self._buffer + = данные
            в то время как self._buffer и не self.paused:
                если (LEN (self._buffer) >= 9):
                    линия = self._buffer [0: 9]
                    self._buffer = self._buffer [9:]
                    почему = self.ansReceived (линия)
                    если (почему или self.transport и self.transport.disconnecting):
                        вернуться почему
                еще:
                    вернуть
        в конце концов:
            self._busyReceiving = False   

    Защиту ansReceived (самостоятельно, данные):
        ans_queue [self.bid] .Put (данные)

Класс Miner (Thread):
    Защиту __init __ (я, ставка, доска, arg_config, alcheprotocol):
        Тема .__ __ инициализации (само)
        self.bid = ставка
        self.daemon = True
        self.brd = доска
        self.config = arg_config
        self.time_start = time.time ()
        self.work_timeout = 3
        self.targetstr = ''
        self.diff = 1
        self.alche_protocol = alcheprotocol
        self.coin_rpc = CoinRPC (config.host, config.port, config.username, config.password)

    Защиту do_work (я, datastr, targetstr):
        если (! targetstr = self.targetstr):
            self.targetstr = targetstr
            self.diff = 0x0000ffff00000000 / длинный (targetstr [48:64] .decode ( 'шестигранной') [:: - 1] .encode ( 'шестигранной'), 16)
            # Self.work_timeout = self.diff * 65536/1000000 / 32
            self.work_timeout = self.diff * 3,54 / BRD [self.bid] .good_cores
            если (self.work_timeout < 8):
                self.work_timeout = 8
        т = '0' * 48 + targetstr [48:64]
        Полезная нагрузка = self.brd.give_work ( 'и далее', т, datastr)
        Печать '- (% s) - разница:% 0.2f, work_timeout:% 0.2f' % (self.bid, self.diff, self.work_timeout)
        self.time_start = time.time ()
        reactor.callFromThread (AlcheProtocol.sendLine, self.alche_protocol, полезная нагрузка)

        пытаться:
            Данные = ans_queue [self.bid] .get (таймаут = self.work_timeout)
            дт = time.time () - self.time_start
            если (== данные 'ffffffffffffffffff'):
                печать «== (% s) == Чистая работа! <% 0.2f>'% (Self.bid, дт)
                com_resp = ''
            еще:
                печать «== (% s) ==% s <% 0.2f>'% (Self.bid, data.encode (' шестигранной '), дт)
                com_resp = данные
        кроме Queue.Empty:
            com_resp = ''

        вернуться com_resp [: 4]

    Защита итерация (Я):
        не работа = None
        для г в диапазоне (5):
            работа = self.coin_rpc.getwork ()
            если (работа не является None):
                ломать
        если работа не None:
            печать «ERR: Работа не None»
            вернуться Ложные

        nonce_bin = self.do_work (работа [ 'данные'], работа [ 'цель'])

        если Len (nonce_bin) == 4:
            submit_queue.put ((self.bid, работа [ 'данные'], работа [ 'цель'], nonce_bin))
            если (submit_queue.qsize () > SUBMIT_Q_THROTTLE):
                печать '... Nap на% 0.2f сек ...' % (active_brd_num * submit_queue.qsize () / SUBMIT_Q_THROTTLE)
                time.sleep (active_brd_num * submit_queue.qsize () / SUBMIT_Q_THROTTLE)

        возвращающие

    Защита пробег (Я):

        iterate_result = False

        в то время как True:
            miner_ctrl.wait ()
            если pool_ctrl [self.bid] .isSet ():
                iterate_result = False
                pool_ctrl [self.bid] .clear ()
            если (iterate_result == False):
                self.coin_rpc.reconnect (config.host, config.port, config.username, config.password)
            iterate_result = self.iterate ()

Класс Stat (Thread):
    Защиту __init __ (Я):
        Тема .__ __ инициализации (само)
        self.daemon = True
        self.acc_kh = { '00': 0,00, '01': 0,00, '02': 0,00, '03': 0,00, '04': 0,00, '05': 0,00, '06': 0,00, '07' : 0,00}
        self.khrate = { '00': 0,00, '01': 0,00, '02': 0,00, '03': 0,00, '04': 0,00, '05': 0,00, '06': 0,00, '07' : 0,00, 'принято': 0, 'отклонен': 0, 'так': 0}
        self.total_accepted = 0
        self.total_rejected = 0
        self.miner_stt_time = time.time ()
        self.reset_stt_time ()

    Защиту reset_stt_time (самостоятельно):
        self.miner_stt_time = time.time ()
        self.khrate [ 'так'] = self.miner_stt_time

    Защиту reset_stat (самостоятельно):
        для б в [ '00', '01', '02', '03', '04', '05', '06', '07']:
            self.acc_kh [Ь] = 0.00
            self.khrate [Ь] = 0.00
        self.khrate [ 'принято'] = 0
        self.khrate [ 'отвергнуты'] = 0
        self.total_accepted = 0
        self.total_rejected = 0
        self.reset_stt_time ()

    Защиту refresh_khrate (самостоятельно):
        для я в [ '00', '01', '02', '03', '04', '05', '06', '07']:
            self.khrate [I] = self.acc_kh [I] / (time.time () - self.miner_stt_time)

    Защита пробег (Я):
        в то время как True:
            (Ставка, стер, TGT, nnc_bin) = hash_queue.get ()

            Diff = 0x0000ffff00000000 / длинный (TGT [48:64] .decode ( 'шестигранной') [:: - 1] .encode ( 'шестигранной'), 16)
            _acc_kh = self.acc_kh [ставка]
            _acc_kh + = Diff * 65,536 * 1
            self.acc_kh [ставка] = _acc_kh
            self.khrate [ставка] = _acc_kh / (time.time () - self.miner_stt_time)

            если ср:
                self.total_accepted + 1 =
                self.khrate [ 'принято'] = self.total_accepted
            еще:
                self.total_rejected + 1 =
                self.khrate [ 'отвергнуты'] = self.total_rejected

            hash_queue.task_done ()




Класс StratumProxy (объект):
    Защиту __init __ (Я):
        не self.proxy = None
        self.isRunning = False
        не self.stratum_host = None
        не self.stratum_port = None

    Защиту get_params (самостоятельно):
        Возвращение (self.stratum_host, self.stratum_port)

    Защиту начать (я, stratum_host, stratum_port, getwork_port, имя пользователя, пароль):
        self.stratum_host = stratum_host
        self.stratum_port = stratum_port

        если не self.isRunning:
            если ( 'ghash.io' в stratum_host):
                self.proxy = subprocess.Popen ([ '/ USR / бен / питон', 'прослойка-горно-прокси / mining_proxy.py', \
                                                '-o', stratum_host, '-p', stratum_port '-GP', getwork_port, \
                                                '-чу', имя пользователя, '-cp', пароль '-pa', 'Scrypt', \
                                                '-nm', '-q'], стандартный вывод = subprocess.PIPE, оболочки = False)
            еще:
                self.proxy = subprocess.Popen ([ '/ USR / бен / питон', 'прослойка-горно-прокси / mining_proxy.py', \
                                                '-o', stratum_host, '-p', stratum_port '-GP', getwork_port, \
                                                '-чу', имя пользователя, '-cp', пароль '-pa', 'Scrypt', \
                                                '-nm', '-cd', '-q'], стандартный вывод = subprocess.PIPE, оболочки = False)
            self.isRunning = True

    Защита остановка (Я):
        если self.isRunning:
            self.proxy.kill ()
            os.wait ()
            self.isRunning = False


Класс WebUIProtocol (WebSocketServerProtocol):
    Защиту __init __ (Я):
        self.command_option = { 'версия': self.web_version, \
                               'Войти в систему': self.web_login, \
                               'Контроль': self.web_control, \
                               'Hashrate': self.web_hashrate, \
                               'Pool_config': self.web_pool_config, \
                               'Host_config': self.web_host_config, \
                               'Access_ctrl': self.web_access_ctrl, \
                               'Обновить': self.web_upgrade, \
                               'Diag_report': self.web_diag_report, \
                               'Clean_job': self.clean_job
                              }
        не self.stratum_proxy = None

    Защиту OnConnect (я, запрос):
        печать «Подключение ...»

    Защиту OnOpen (самостоятельно):
        если (. self.transport.getPeer () хост = '127.0.0.1'!):
            ws_client.append (Я)
        печать 'Открытие ... [% s]% self.transport.getPeer (). хост

    Защиту OnClose (самость, wasClean, код причины):
        пытаться:
            ws_client.remove (Я)
        кроме ValueError:
            проходить
        печать "Закрыть ... [% s]% self.transport.getPeer (). хоста

    Защиту OnMessage (самостоятельно, данные, isBinary):
        #if (данные == 'hashrate'):
        # Self.sendMessage (json.dumps (global_khrate), isBinary = False)
        пытаться:
            web_req = json.loads (данные)
            если (web_req == None):
                напечатает Непризнанную команду!
            MTD = web_req [ 'метод']
            self.command_option [MTD] (web_req)
        кроме исключений, е:
            #print е
            данные для печати
            RSP = 'результат' {: false, 'ошибка': '! Ошибка команды' + Ул (е), 'ID': '0'}
            печать json.dumps (RSP)
            self.sendMessage (json.dumps (RSP))
            вернуться Ложные

    Защиту web_version (я, REQ):
        ws_client.append (Я)
        RSP = { 'результат': false, 'Ошибка': Нет, 'ID': Нет}
        RSP [ 'ID'] = REQ [ 'ID']
        RSP [ 'результат'] = версия
        self.sendMessage (json.dumps (RSP))

        вернуть

    Защиту web_login (я, REQ):
        RSP = { 'результат': false, 'Ошибка': Нет, 'ID': Нет}
        PWD = REQ [ 'PARAMS'] [0]
        RSP [ 'ID'] = REQ [ 'ID']

        F = открыт ( 'access_code', 'г')
        crypted_pwd = f.readline (). rstrip ()
        f.close ()
        #print '(% s) (% s)' % (PWD, crypted_pwd)
        если (крипты (PWD, crypted_pwd) == crypted_pwd):
            RSP [ 'результат'] = True
        еще:
            RSP [ 'результат'] = False

        self.sendMessage (json.dumps (RSP))

        вернуть

    Защиту web_control (я, REQ):
        напечатает контроль ... "
        если (REQ [ 'Params'] [0] == 'идти'):
            config.read_config ()
            Распечатать '>Начало...'
            если (config.protocol == 'прослойка + ТСР:'):
                stratum_host = config.host
                stratum_port = config.port
                config.host = 'локальный'
                config.port = '8332'
                # Запуск прослойка добыча прокси
                Распечатать '>запуск прослойка прокси ...
                stratum_proxy.start (stratum_host, stratum_port, config.port, config.username, config.password)
                time.sleep (3)
            # Стартап рудничные темы ...
            miner_ctrl.set ()
        еще:
            # Остановить все шахтер нить
            miner_ctrl.clear ()
            stat_reset.set ()
            # Установить все платы бездействовать
            для Ь в отсортированном (шд):
                шд [Ь] .set_all_idle ()
            пытаться:
                Распечатать '>остановить роговой прокси ...
                stratum_proxy.stop ()
            кроме OSError:
                проходить
            # Сброс стат
            stat.reset_stat ()

        вернуть

    Защиту web_hashrate (я, REQ):
        печать 'report_hashrate ...'
        RSP = { 'результат': false, 'Ошибка': Нет, 'ID': Нет}
        RSP [ 'результат'] = json.dumps (global_khrate)
        RSP [ 'ID'] = REQ [ 'ID']
        self.sendMessage (json.dumps (RSP))
        вернуть

    Защиту web_pool_config (я, REQ):
        RSP = { 'результат': false, 'Ошибка': Нет, 'ID': Нет}

        если Len (REQ [ 'PARAMS']) == 0:
            config.read_config ()
            RSP [ 'результат'] = [config.protocol, config.host, config.port, config.username, config.password]
            RSP [ 'ошибки'] = нет нет
            RSP [ 'ID'] = REQ [ 'ID']
            self.sendMessage (json.dumps (RSP))
        еще:
            stratum_mtr.stop ()
            (Протокол, хост, порт, имя пользователя, пароль) = (я для г в REQ [ 'Params'])
            (Config.protocol, config.host, config.port, config.username, config.password) = (протокол, хост, порт, имя пользователя, пароль)
            кр = config.save_config ()
            если (сг):
                RSP [ 'результат'] = ["ОК"]
                RSP [ 'ошибки'] = нет нет
                RSP [ 'ID'] = REQ [ 'ID']
                self.sendMessage (json.dumps (RSP))
                # Информировать все нити, чтобы изменить информацию о пуле
                для р в pool_ctrl:
                    pool_ctrl [р] .set ()
                submitter_ctrl.set ()

                # Сброс стат
                stat.reset_stat ()

                # Остановить все шахтер нить
                miner_ctrl.clear ()
                stat_reset.set ()
                # Установить все платы бездействовать
                для Ь в отсортированном (шд):
                    шд [Ь] .set_all_idle ()
                пытаться:
                    Распечатать '>остановить роговой прокси ...
                    stratum_proxy.stop ()
                кроме OSError:
                    проходить

                time.sleep (1)

                # Начать все шахтер нить
                если (config.protocol == 'прослойка + ТСР:'):
                    stratum_host = config.host
                    stratum_port = config.port
                    config.host = 'локальный'
                    config.port = '8332'
                    # Запуск прослойка добыча прокси
                    Распечатать '>запуск прослойка прокси ...
                    stratum_proxy.start (stratum_host, stratum_port, config.port, config.username, config.password)
                    time.sleep (3)
                # Запуск Минтер темы ...
                miner_ctrl.set ()
            stratum_mtr.start (STRATUM_CHK_INTERVAL)

    Защиту web_host_config (я, REQ):
        RSP = { 'результат': false, 'Ошибка': Нет, 'ID': Нет}

        если Len (REQ [ 'PARAMS']) == 0:
            F = открытые ( '/ и т.д. / сеть / интерфейсы', 'г')
            РИФ = f.readlines ()
            f.close ()
            связывание = «»
            IPADDR = ''
            маска подсети = «»
            Шлюз = «»
            DNS = ''
            фиксированный = False
            для я в FIF:
                а = '', если i.lstrip (). StartsWith ( '#') еще я
                если ( 'DHCP' в) и ( 'eth1' в):
                    Связывание = 'dhcpc'
                    ломать
                если ( «статический» в) и ( «eth1» в):
                    Связывание = 'fixedip'
                    фиксированный = True
                    Продолжать
                если исправлено:
                    аа = a.split ()
                    для J в диапазоне (LEN (аа)):
                        если «адрес» в аа [J]:
                            IPADDR = аа [J + 1]
                        если «маска подсети» в аа [J]:
                            = аа маска подсети [J + 1]
                        если «шлюз» в аа [J]:
                            Шлюз = аа [J + 1]
                        если «ДНС-сервера имен» в аа [J]:
                            = аа DNS [J + 1]
            RSP [ 'результат'] = [связывание, IPADDR, маска подсети, шлюз, DNS]
            RSP [ 'ошибки'] = нет нет
            RSP [ 'ID'] = REQ [ 'ID']
            self.sendMessage (json.dumps (RSP))
        еще:
            (Связывание, IPADDR, маска подсети, шлюз, DNS) = (я для г в REQ [ 'Params'])
            F = открытые ( '/ и т.д. / сеть / интерфейсы', 'W +')
            f.write ( '# петлевой сетевой интерфейс \ п')
            f.write ( 'авто л \ п')
            f.write ( 'IFACE ло инет шлейф \ п \ п')
            f.write ( '# первичный сетевой интерфейс \ п')
            f.write ( 'авто eth1 \ п')
            если (связывание 'dhcpc' ==):
                f.write ( 'IFACE eth1 инет DHCP \ п')
            еще:
                f.write ( 'IFACE eth1 инет статические \ п')
                f.write ( 'адрес' + IPADDR + '\ п')
                f.write ( 'маска сети' + маска сети + '\ п')
                f.write ( 'шлюз' + шлюз + \ п ')
                f.write ( 'ДНС-NameServers' + '+ DNS \ п')
            f.close ()

            RSP [ 'результат'] = ["ОК"]
            RSP [ 'ошибки'] = нет нет
            RSP [ 'ID'] = REQ [ 'ID']
            self.sendMessage (json.dumps (RSP))

            time.sleep (0,5)
            subprocess.call ([ '/ SBIN / ifdown', 'eth1'], оболочки = False)
            time.sleep (0,5)
            subprocess.call ([ '/ SBIN / ifup', 'eth1'], оболочки = False)

    Защиту web_access_ctrl (я, REQ):
        RSP = { 'результат': false, 'Ошибка': Нет, 'ID': Нет}
        печать 'access_ctrl ...'
        (Old_password, новый_пароль) = (REQ [ 'PARAMS'] [0], [REQ 'PARAMS'] [1])
        F = открыт ( 'access_code', 'г')
        crypted_pwd = f.readline (). rstrip ()
        f.close ()
        если (крипты (old_password, crypted_pwd) == crypted_pwd):
            F = открыт ( 'access_code', 'W')
            new_crypt = крипты (новый_пароль, 'TomSoong')
            f.write (new_crypt + '\ п')
            f.close ()
            RSP [ 'результат'] = [ 'ОК']
        еще:
            RSP [ 'результат'] = [ 'неправильно']
        RSP [ 'ID'] = REQ [ 'ID']
        self.sendMessage (json.dumps (RSP))

        вернуть

    Защиту web_upgrade (я, REQ):
        напечатает обновления ...
        вернуть
-------------------------
--------------------------
--------------------------