CAP Theorem Revisited: How and When to Use It in Distri

    import random
    
    
    class Node(object):
    
    def __init__(self, id_):
        self.id = id_
        # (proposal number, proposal value)
        self.proposals = {}
        self.promises = {}
    
    def receive_prepare(self, n):
        if not isinstance(n, int):
            raise ValueError("Invalid prepare message")
    
        if n <= max([p[0] for p in self.promises]):
            return None  # Already promised a higher or equal numbered proposal
    
        m = min([p for p in [k for k in self.promises]] + [-1]) + 1
        self.promises[m] = []
        for acceptor in range(len(nodes)):
            if nodes[acceptor].id!= self.id:
                self.send_promise(m, nodes[acceptor])
    
        if len(self.promises[m]) > round(len(nodes)/2):
            # Sufficient agreement, can commit the highest numbered proposal seen so far
            chosen_n, chosen_val = sorted([(p[0], p[1]) for p in self.proposals])[0]
            assert chosen_n == m
    
            for acceptor in range(len(nodes)):
                if nodes[acceptor].id!= self.id:
                    nodes[acceptor].send_accepted(chosen_n, chosen_val)
    
            self.proposals = {i: v for i, (_, v) in enumerate(sorted((p for p in self.proposals), key=lambda x:x[0]))}
    
            # Apply the chosen value locally here...
    
            print "Chosen proposal:", chosen_n, chosen_val
    
            return chosen_n, chosen_val
        else:
            # Insufficent agreement, do nothing yet
            return None
    
    
    def send_promise(self, m, other):
        self.promises[m].append(other.id)
        other.receive_promise(m)
    
    def receive_promise(self, m):
        pass
    
    def send_accepted(self, m, val):
        self.proposals[(m, val)] = True
        for learner in learners:
            learner.learn()
    
    def receive_accepted(self, m, val):
        pass
    
    def learn():
        pass
    
    nodes = [Node(i+1) for i in range(5)]
    for node in nodes:
    node.start()
    
    learners = [node for node in nodes if node.role == 'LEARNER']
    
    for i in range(10):
    proposers = [random.choice(nodes) for _ in range(3)]
    n = proposers[0].propose('value'+str(i))
    
    for propser in proposers:
        res = propser.wait_for_quorum(n)
    
        if res is not None:
            break
    
    print [(node.id, node.proposals) for node in nodes]
    
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
    
    代码解读

    brew install go --cross-compile-common
    go get github.com/hashicorp/raft
    
      
    
    代码解读

    package main
    
    import (
      raft "github.com/hashicorp/raft"
    
      "fmt"
      "time"
    )
    
    type Config struct{}
    
    func (c *Config) ServerAddress() string {
      // 设置自己的ip地址和端口号
      return "localhost:8000"
    }
    
    func main() {
      config := &Config{}
    
      addr := fmt.Sprintf("%s:%d", config.ServerAddress(), 8000)
      peers := []string{"localhost:8001", "localhost:8002"}
      store := raft.NewInmemStore()
      fsm := NewFSM()
      transport := raft.NewNetworkTransport(addr,peers,store)
    
      raftLog := raft.NewLog(raft.GetLastIndex(store),[]raft.LogEntry{{Term:0, Index:0}})
      hs := NewRaftServer(config,transport,fsm,store,raftLog)
      server := make(chan bool)
    
      go func() {
    time.Sleep(time.Second*3)
    fmt.Println(hs.Start())
    server <- true
      }()
    
      <-server
    
    }
    
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
    
    代码解读

    name: node2
    listen_addr: localhost:8001
    advertise_addr: localhost:8001
    
      
      
    
    代码解读

    // node2
    conf2 := &Config{
      Name:        "node2",
      ListenAddr:  ":8001",
      AdvertiseAddr: "localhost:8001",
    }
    addrs2 := append(peers, conf2.ServerAddress())
    hs2 := NewRaftServer(conf2,transport,fsm,store,raftLog)
    go func() {
      time.Sleep(time.Second*3)
      hs2.Start()
    }()
    
    // start the cluster
    if err := hs.JoinCluster(addrs2); err!= nil {
      log.Fatalln(err)
    }
    
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
    
    代码解读