利用python多线程实现区块链paxos算法解决用户共识

# 1。协议日志状态持久性存储，和恢复，而不是伪造的有此刻。
# 2。没有办法让客户知道谁是主要的
# 3。一个失败了然后醒来的领导者将不知道最高承诺的实例是什么。这是可以帮助的，但是代码是
#足够复杂，它不是这么多的错误条件的痛苦。
# 4。对读者的练习：通知客户其请求的结果。
# 5。垃圾收集不必要的建议，并重新提出那些似乎已经停滞。很容易做到这recvmessage。
# Paxos实现观念来达成
#历史价值（可能在一个状态机表示命令）
#我们有两个主要的球员：PaxosLeader和paxosacceptor。paxosleader侦听来自外部客户的建议
#跑哪paxosacceptors协议目前是正确的。
#如果领导者失败，另一位领导人将接管一旦意识到。如果客户失败，协议仍将运行至
#一半以上都失败了。
#这是设计运行在一个机器：每个演员都有一个端口号，但都绑定到本地主机。要合理
#琐碎的概括。
#看到演示使用文件的底部。

import threading, socket, pickle, queue


class Message(object):
    MSG_ACCEPTOR_AGREE = 0
    MSG_ACCEPTOR_ACCEPT = 1
    MSG_ACCEPTOR_REJECT = 2
    MSG_ACCEPTOR_UNACCEPT = 3
    MSG_ACCEPT = 4
    MSG_PROPOSE = 5
    MSG_EXT_PROPOSE = 6
    MSG_HEARTBEAT = 7

    def __init__(self, command=None):
        self.command = command

    def copyAsReply(self, message):
        self.proposalID, self.instanceID, self.to, self.source = message.proposalID, message.instanceID, message.source, message.to
        self.value = message.value


class MessagePump(threading.Thread):
    #“”“messagepump封装socket连接，并负责送邮件的主人”“”
    class MPHelper(threading.Thread):
        #“”这个帮助类的原因是要尽可能快地从套接字上拔出东西，以避免
        #填充缓冲区。回想起来，使用TCP可能更容易些：“”
        def __init__(self, owner):
            self.owner = owner
            threading.Thread.__init__(self)

        def run(self):
            while not self.owner.abort:
                try:
                    (bytes, addr) = self.owner.socket.recvfrom(2048)
                    msg = pickle.loads(bytes)
                    msg.source = addr[1]
                    self.owner.queue.put(msg)
                except:
                    pass

    def __init__(self, owner, port, timeout=2):
        self.owner = owner
        threading.Thread.__init__(self)
        self.abort = False
        self.timeout = 2
        self.port = port
        self.socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
        self.socket.setsockopt(socket.SOL_SOCKET, socket.SO_RCVBUF, 200000)
        self.socket.bind(("localhost", port))
        self.socket.settimeout(timeout)
        self.queue = queue.Queue()
        self.helper = MessagePump.MPHelper(self)

    def run(self):
        self.helper.start()
        while not self.abort:
            message = self.waitForMessage()
            # 这需要被阻塞，否则有一个世界
            #多线程在等待我们  # 疼痛
            self.owner.recvMessage(message)

    def waitForMessage(self):
        try:
            msg = self.queue.get(True, 3)
            return msg
        except:  # ugh, specialise the exception!
            return None

    def sendMessage(self, message):
        bytes = pickle.dumps(message)
        address = ("localhost", message.to)
        self.socket.sendto(bytes, address)
        return True

    def doAbort(self):
        self.abort = True


import random


class AdversarialMessagePump(MessagePump):
 #“”对抗性消息泵随机延迟消息并以任意顺序传递它们“”
    def __init__(self, owner, port, timeout=2):
        MessagePump.__init__(self, owner, port, timeout)
        self.messages = set()

    def waitForMessage(self):
        try:
            msg = self.queue.get(True, 0.1)
            self.messages.add(msg)
        except:  # ugh, specialise the exception!
            pass
        if len(self.messages) > 0 and random.random() < 0.95:  # Arbitrary!
            msg = random.choice(list(self.messages))
            self.messages.remove(msg)
        else:
            msg = None
        return msg


class InstanceRecord(object):
    #这是一个簿记类，它记录了我们在某一特定记录中所看到或承诺的所有建议，承兑人和领导者“

    def __init__(self):
        self.protocols = {}
        self.highestID = (-1, -1)
        self.value = None

    def addProtocol(self, protocol):
        self.protocols[protocol.proposalID] = protocol
        if protocol.proposalID[1] > self.highestID[1] or (
                protocol.proposalID[1] == self.highestID[1] and protocol.proposalID[0] > self.highestID[0]):
            self.highestID = protocol.proposalID

    def getProtocol(self, protocolID):
        return self.protocols[protocolID]

    def cleanProtocols(self):
        keys = self.protocols.keys()
        for k in keys:
            protocol = self.protocols[k]
            if protocol.state == PaxosLeaderProtocol.STATE_ACCEPTED:
                print( "Deleting pr