class Acceptor(object): def __init__(self, uid, addr, port): self.messenger = Messenger(self) self.server = Server(self, port, address=addr) self.uid = uid self.promised_id = ProposalID(-1, -1) self.accepted_id = ProposalID(-1, -1) self.accepted_value = None def reset(self): # self.messenger = Messenger(self) # self.server = Server(self, port) self.server.queue = queue.Queue() self.promised_id = ProposalID(-1, -1) self.accepted_id = ProposalID(-1, -1) self.accepted_value = None def start(self): self.server.start() def fail(self): self.server.do_abort() def recover(self): self.reset() self.server.recover() def recv_message(self, msg): if msg.type == Message.MSG_PREPARE: self.recv_prepare(msg.from_uid, msg.data) # the data is simply one tuple elif msg.type == Message.MSG_ACCEPT: self.recv_accept_request(msg.from_uid, msg.data[0], msg.data[1]) def recv_prepare(self, from_uid, proposal_id): """ Called when a Prepare message is received from a Proposer """ if proposal_id == self.promised_id: # Duplicate prepare message self.messenger.send_promise(from_uid, proposal_id, self.accepted_id, self.accepted_value) elif proposal_id > self.promised_id: self.promised_id = proposal_id self.messenger.send_promise(from_uid, proposal_id, self.accepted_id, self.accepted_value) def recv_accept_request(self, from_uid, proposal_id, value): """ Called when an Accept! message is received from a Proposer """ if proposal_id >= self.promised_id: self.promised_id = proposal_id self.accepted_id = proposal_id self.accepted_value = value self.messenger.send_accepted(proposal_id, self.accepted_value)
class DandelionApp: def __init__(self, config_file=None): self._config_manager = ConfigurationManager(config_file) def start_server(self): self._server = Server( self._config_manager.local_address, self._config_manager.local_port, self._config_manager.server, # info_dict self._config_manager.content_db, ) self._server.start() def start_content_synchronizer(self): self._synchronizer = Synchronizer( self._config_manager.local_address, self._config_manager.local_port, self._config_manager.type, self._config_manager.content_db, ) self._synchronizer.start() def run_ui(self): self._ui = UI( self._config_manager.ui, self._config_manager.content_db, self._server, self._synchronizer # dict ) self._ui.run() def exit(self): self._synchronizer.stop() self._server.stop()
def test_play_match(self): server = Server() server.start(False) client1 = Client('localhost', 8081) client2 = Client('localhost', 8081) client1_moves = [(1, 1), (2, 2), (3, 3)] client2_moves = [(3, 1), (3, 2)] client1.on_move_required = lambda ct: (client1_moves if ct else client2_moves).pop(0) client1.on_game_over = lambda winner: self.assertTrue(winner) client2.on_move_required = lambda ct: (client1_moves if ct else client2_moves).pop(0) client2.on_game_over = lambda winner: self.assertTrue(winner) client1.start(False) client2.start(False) client1.wait() client2.wait() server.stop()
class DandelionApp: def __init__(self, config_file=None): self._config_manager = ConfigurationManager(config_file) def start_server(self): self._server = Server(self._config_manager.local_address, self._config_manager.local_port, self._config_manager.server, #info_dict self._config_manager.content_db) self._server.start() def start_content_synchronizer(self): self._synchronizer = Synchronizer(self._config_manager.local_address, self._config_manager.local_port, self._config_manager.type, self._config_manager.content_db) self._synchronizer.start() def run_ui(self): self._ui = UI(self._config_manager.ui, #dict self._config_manager.content_db, self._server, self._synchronizer) self._ui.run() def exit(self): self._synchronizer.stop() self._server.stop()
class WebchatManager(QObject): WEBCHAT_SERVER_PORT = 22334 def __init__(self, parent=None): QObject.__init__(self, parent) self.server = Server(self.WEBCHAT_SERVER_PORT) self.dispatcher = WebchatDispatcher(self.server) self.server.setDispatcher(self.dispatcher) def start(self): self.server.start()
class ExternalManager(QObject): EXTERNAL_SERVER_PORT = 22333 def __init__(self, parent=None): QObject.__init__(self, parent) self.server = Server(self.EXTERNAL_SERVER_PORT) self.dispatcher = ExternalDispatcher(self.server) self.server.setDispatcher(self.dispatcher) def start(self): self.server.start()
class Proposer(object): def __init__(self, owner, uid, addr, port): self.messenger = Messenger(self) self.server = Server(self, port, address=addr) self.owner = owner self.uid = uid self.proposer_uid = uid self.quorum_size = 3 self.proposed_value = None self.proposal_id = None self.last_accepted_id = (-1, -1) self.next_proposal_number = 1 self.promises_rcvd = None def reset(self): self.server.queue = queue.Queue() self.proposed_value = None self.proposal_id = None self.last_accepted_id = (-1, -1) # self.next_proposal_number = 1 self.promises_rcvd = None def start(self): self.server.start() def fail(self): self.server.do_abort() def recover(self): self.reset() self.server.recover() def set_proposal(self, value): """ Sets the proposal value for this node iff this node is not already aware of another proposal having already been accepted. """ if self.proposed_value is None: self.proposed_value = value def propose(self): """ Send the proposal (uid, proposed_value) over all acceptors """ self.owner.log.append(LogEntry(self.uid, self.proposed_value, False)) self.messenger.send_proposal(self.uid, self.proposed_value) def recv_message(self, msg): print('illegal!')
class Acceptor(object): def __init__(self, owner, uid, addr, port): self.messenger = Messenger(self) self.server = Server(self, port, address=addr) self.owner = owner self.uid = uid self.promised_id = ProposalID(-1, -1) self.accepted_id = ProposalID(-1, -1) self.accepted_value = None def reset(self): # self.messenger = Messenger(self) # self.server = Server(self, port) self.server.queue = queue.Queue() self.promised_id = ProposalID(-1, -1) self.accepted_id = ProposalID(-1, -1) self.accepted_value = None def start(self): self.server.start() def fail(self): self.server.do_abort() def recover(self): self.reset() self.server.recover() def recv_message(self, msg): if msg.type == Message.MSG_ACCEPT: self.recv_accept_request(msg.from_uid, msg.data[0], msg.data[1]) def recv_accept_request(self, from_uid, proposal_uid, value): # from_uid is same as proposal uid """ Called when an Accept! message is received from a Proposer """ # write log immediately self.owner.log.append(LogEntry(proposal_uid, value, False)) # broadcast for voting self.messenger.send_accepted(proposal_uid, value)
def run(self): server = Server(self.port) server.start() while not self.stopped: requests = server.get_requests() for r in requests: nums = r.split(',') self.connected = True if len(nums) == 2: self.connected = True self.depth_queue.append(int(nums[0])) self.angle = int(nums[1]) response = "{},{},{},{},{}\n".format( self.convert(-self.m_front_left), self.convert(-self.m_front_right), self.convert(-self.m_back_left), self.convert(-self.m_back_right), self.convert(self.m_tail)) response = response.encode('utf-8') server.offer_data(r, response) break server.stop()
class GUI(tk.Frame): # Inherits from Tk.Frame def __init__(self, master, address, port, *args, **kwargs): # Pass the arguments to the superclass tk.Frame.__init__(self, master, *args, **kwargs) self.master = master # Some GUI Configurations self.master.resizable(False, False) self.master.title("BergRat") self.master.geometry("650x650") # Create a TreeView and add som columns self.tree = ttk.Treeview(self) self.tree["columns"] = ("one", "two", "three", "four") self.tree.heading("#0", text="ID", anchor="w") self.tree.column("#0", stretch=tk.YES, width=100, anchor="w") self.tree.column("one", width=100) self.tree.heading("one", text="IP") self.tree.column("two", width=100) self.tree.heading("two", text="User") self.tree.column("three", width=100) self.tree.heading("three", text="Online") self.tree.column("four", width=100) self.tree.heading("four", text="Install Date") # Create Ba button to create a Backdoor self.button = tk.Button(self, text="Create a Backdoor", command=self.create_backdoor) # Pack all the objects self.tree.pack(fill="both", expand=True) self.button.pack() # Bind the double-click in a element from TreeView self.tree.bind("<Double-1>", lambda event: self.double_click_tree()) # After all widgets being packed, the master is show self.master.deiconify() # Start the network class self.Network = Server(address, port) # Start a Get-Sessions Thread t_get_sessions = Thread(target=self.get_sessions) t_get_sessions.daemon = True t_get_sessions.start() def create_backdoor(self): """ Method used to call the Builder """ Builder(self.master) def double_click_tree(self): """ Function used to call the remote shell """ # Check what item is selected from TreeView try: item = self.tree.selection()[0] except IndexError: return # Get the Item UID uid = int(self.tree.item(item, "text")) # Starts the remote shell RemoteShell(self.Network, uid, self.master, self.Network.Sessions[uid][2]) def get_sessions(self): """ Function used to update the TreeView with the connected users """ # Start the network self.Network.start() while True: # Creates a copy of Network.Sessions (To avoid bugs) for key in self.Network.Sessions.copy(): if not self.Network.Sessions[key][5]: # Add to TreeView self.add_user(key, self.Network.Sessions[key][1], self.Network.Sessions[key][2], self.Network.Sessions[key][3], self.Network.Sessions[key][4]) self.Network.Sessions[key][5] = True def add_user(self, uid, ip, username, online, date): """ Method used to add things to TreeView """ self.tree.insert("", "end", text=uid, values=(ip, username, online, date))
class Learner(object): def __init__(self, owner, uid, addr, port): self.messenger = Messenger(self) self.server = Server(self, port, address=addr) self.owner = owner self.uid = uid self.quorum_size = 3 self.proposals = None # maps proposal_id => [accept_count, retain_count, value] self.acceptors = None # maps from_uid => last_accepted_proposal_id self.final_value = None self.final_proposal_id = None def reset(self): self.server.queue = queue.Queue() self.proposals = None # maps proposal_id => [accept_count, retain_count, value] self.acceptors = None # maps from_uid => last_accepted_proposal_id self.final_value = None self.final_proposal_id = None def start(self): self.server.start() def fail(self): self.server.do_abort() def recover(self): self.reset() self.server.recover() @property def complete(self): return self.final_proposal_id is not None def recv_message(self, msg): if msg.type == Message.MSG_DECIDE: self.recv_accepted(msg.src, msg.data[0], msg.data[1]) def recv_accepted(self, from_uid, proposal_id, accepted_value): """ Called when an Accepted message is received from an acceptor """ if self.final_value is not None: return # already done if self.proposals is None: self.proposals = dict() self.acceptors = dict() last_proposal_number = self.acceptors.get(from_uid) if last_proposal_number is not None and not proposal_id > last_proposal_number: return # Old message self.acceptors[from_uid] = proposal_id if last_proposal_number is not None: old_proposal = self.proposals[last_proposal_number] old_proposal[1] -= 1 if old_proposal[1] == 0: del self.proposals[last_proposal_number] if not proposal_id in self.proposals: self.proposals[proposal_id] = [0, 0, accepted_value] t = self.proposals[proposal_id] assert accepted_value == t[2], 'Value mismatch for single proposal!' t[0] += 1 t[1] += 1 if t[0] == self.quorum_size: self.final_value = accepted_value self.final_proposal_id = proposal_id self.proposals = None self.acceptors = None self.messenger.on_resolution(proposal_id, accepted_value, self.owner.log)
class Node(threading.Thread): class Daemon(threading.Thread): def __init__(self, owner): threading.Thread.__init__(self) self.owner = owner #self.counter = time.time() def run(self): while True: if self.owner.in_propose_time_frame: #if time.time() - self.counter > 2: # print('Daemon is alive!') # self.counter = time.time() self.owner.in_propose_time_frame = False if self.owner.last_decided_proposer_id == self.owner.uid or self.owner.next_post is None: self.owner.next_post = self.owner.queue.get(True) print('Propose next available value {}.'.format( self.owner.next_post)) self.owner.proposer.set_proposal(self.owner.next_post) self.owner.proposer.prepare() elif self.owner.next_post is not None: print('Propose old value {}'.format( self.owner.next_post)) self.owner.proposer.set_proposal(self.owner.next_post) self.owner.proposer.prepare() def __init__(self, uid, addr, port): threading.Thread.__init__(self) self.address = addr self.port = port self.server = Server(self, port, address=addr) self.queue = queue.Queue() self.abort = False self.uid = uid self.next_post = None # local log of the Node self.log = [] self.proposer = Proposer(uid, addr, port + 1) self.acceptor = Acceptor(uid, addr, port + 2) self.learner = Learner(self, uid, addr, port + 3) self.stopped_proposal_id = None self.lock = threading.Lock() self.last_decided_proposer_id = None self.in_propose_time_frame = True self.daemon = Node.Daemon(self) def recv_message(self, msg): if msg.type == Message.MSG_STOP and msg.data[ 0] != self.stopped_proposal_id: # set local log accepted_log = msg.data[2] if len(accepted_log) > len(self.log): self.log = accepted_log if len(self.log) > 0: if self.log[-1] != msg.data[1]: self.log.append(msg.data[1]) else: self.log.append(msg.data[1]) print('Log after this round: ', self.log) self.stopped_proposal_id = msg.data[0] self.proposer.reset() self.acceptor.reset() self.learner.reset() self.last_decided_proposer_id = msg.data[0].uid time.sleep(3) self.in_propose_time_frame = True def fail(self): self.proposer.fail() self.acceptor.fail() self.learner.fail() self.abort = True self.server.do_abort() def recover(self): self.server.recover() self.proposer.recover() self.acceptor.recover() self.learner.recover() self.abort = False def run(self): self.server.start() self.proposer.start() self.acceptor.start() self.learner.start() self.daemon.start()
class Node(threading.Thread): class Daemon(threading.Thread): def __init__(self, owner): threading.Thread.__init__(self) self.owner = owner #self.counter = time.time() def run(self): while True: if self.owner.in_propose_time_frame: #if time.time() - self.counter > 2: # print('Daemon is alive!') # self.counter = time.time() self.owner.in_propose_time_frame = False if self.owner.last_decided_proposer_id == self.owner.uid or self.owner.next_post is None: self.owner.next_post = self.owner.queue.get(True) print('Propose next available value {}.'.format(self.owner.next_post)) self.owner.proposer.set_proposal(self.owner.next_post) self.owner.proposer.prepare() elif self.owner.next_post is not None: print('Propose old value {}'.format(self.owner.next_post)) self.owner.proposer.set_proposal(self.owner.next_post) self.owner.proposer.prepare() def __init__(self, uid, addr, port): threading.Thread.__init__(self) self.address = addr self.port = port self.server = Server(self, port, address=addr) self.queue = queue.Queue() self.abort = False self.uid = uid self.next_post = None # local log of the Node self.log = [] self.proposer = Proposer(uid, addr, port + 1) self.acceptor = Acceptor(uid, addr, port + 2) self.learner = Learner(self, uid, addr, port + 3) self.stopped_proposal_id = None self.lock = threading.Lock() self.last_decided_proposer_id = None self.in_propose_time_frame = True self.daemon = Node.Daemon(self) def recv_message(self, msg): if msg.type == Message.MSG_STOP and msg.data[0] != self.stopped_proposal_id: # set local log accepted_log = msg.data[2] if len(accepted_log) > len(self.log): self.log = accepted_log if len(self.log) > 0: if self.log[-1] != msg.data[1]: self.log.append(msg.data[1]) else: self.log.append(msg.data[1]) print('Log after this round: ', self.log) self.stopped_proposal_id = msg.data[0] self.proposer.reset() self.acceptor.reset() self.learner.reset() self.last_decided_proposer_id = msg.data[0].uid time.sleep(3) self.in_propose_time_frame = True def fail(self): self.proposer.fail() self.acceptor.fail() self.learner.fail() self.abort = True self.server.do_abort() def recover(self): self.server.recover() self.proposer.recover() self.acceptor.recover() self.learner.recover() self.abort = False def run(self): self.server.start() self.proposer.start() self.acceptor.start() self.learner.start() self.daemon.start()
class Proposer(object): def __init__(self, uid, addr, port): self.messenger = Messenger(self) self.server = Server(self, port, address=addr) self.uid = uid self.proposer_uid = uid self.quorum_size = 3 self.proposed_value = None self.proposal_id = None self.last_accepted_id = (-1, -1) self.next_proposal_number = 1 self.promises_rcvd = None def reset(self): self.server.queue = queue.Queue() self.proposed_value = None self.proposal_id = None self.last_accepted_id = (-1, -1) # self.next_proposal_number = 1 self.promises_rcvd = None def start(self): self.server.start() def fail(self): self.server.do_abort() def recover(self): self.reset() self.server.recover() def set_proposal(self, value): """ Sets the proposal value for this node iff this node is not already aware of another proposal having already been accepted. """ if self.proposed_value is None: self.proposed_value = value def prepare(self): """ Sends a prepare request to all Acceptors as the first step in attempting to acquire leadership of the Paxos instance. """ self.promises_rcvd = set() self.proposal_id = ProposalID(self.next_proposal_number, self.proposer_uid) self.next_proposal_number += 1 self.messenger.send_prepare(self.proposal_id) def recv_message(self, msg): if msg.type == Message.MSG_PROMISE: self.recv_promise(msg.src, msg.data[0], msg.data[1], msg.data[2]) def recv_promise(self, from_uid, proposal_id, prev_accepted_id, prev_accepted_value): """ Called when a Promise message is received from an Acceptor """ # Ignore the message if it's for an old proposal or we have already received # a response from this Acceptor if proposal_id != self.proposal_id or from_uid in self.promises_rcvd: return self.promises_rcvd.add(from_uid) if prev_accepted_id > self.last_accepted_id: self.last_accepted_id = prev_accepted_id # If the Acceptor has already accepted a value, we MUST set our proposal # to that value. if prev_accepted_value is not None: self.proposed_value = prev_accepted_value if len(self.promises_rcvd) == self.quorum_size: if self.proposed_value is not None: self.messenger.send_accept(self.proposal_id, self.proposed_value)
help='Port to listen to' ) parser.add_argument( '-v', '--verbose', action='store_true', help='Be verbose' ) args = parser.parse_args() logging.basicConfig(level=logging.DEBUG if args.verbose else logging.INFO) server = Server( args.field_size, args.row_length, args.host, args.port ) def signal_handler(sig, frame): server.stop() signal.signal(signal.SIGINT, signal_handler) server.start()
class Learner(object): class AsynchronousMessenger(threading.Thread): def __init__(self, owner, proposal_uid, value, log=None): threading.Thread.__init__(self) self.owner = owner self.proposal_uid = proposal_uid self.value = value self.log = log def run(self): time.sleep(3) self.owner.proposals = None self.owner.acceptors = None self.owner.messenger.on_resolution(self.proposal_uid, self.value, self.log) def __init__(self, owner, uid, addr, port): self.messenger = Messenger(self) self.server = Server(self, port, address=addr) self.owner = owner self.uid = uid self.quorum_size = 3 self.proposals = None # maps proposal_id => [accept_count, retain_count, value] self.acceptors = None # maps from_uid => last_accepted_proposal_id self.final_value = None self.final_proposal_id = None def reset(self): self.server.queue = queue.Queue() self.proposals = None # maps proposal_id => [accept_count, retain_count, value] self.acceptors = None # maps from_uid => last_accepted_proposal_id self.final_value = None self.final_proposal_id = None def start(self): self.server.start() def fail(self): self.server.do_abort() def recover(self): self.reset() self.server.recover() @property def complete(self): return self.final_proposal_id is not None def recv_message(self, msg): if msg.type == Message.MSG_DECIDE: self.recv_accepted(msg.src, msg.data[0], msg.data[1]) def recv_accepted(self, from_uid, proposal_uid, accepted_value): """ Called when an Accepted message is received from an acceptor """ #if self.final_value is not None: # return # already done if self.proposals is None: self.proposals = dict() self.proposals[self.uid] = 1 self.acceptors = dict() if from_uid in self.acceptors: if accepted_value in self.acceptors[from_uid]: return else: self.acceptors[from_uid].add(accepted_value) else: self.acceptors[from_uid] = {accepted_value} # self.proposals: map from proposal_uid => (num_votes, accepted_value) if proposal_uid in self.proposals: self.proposals[proposal_uid] += 1 else: self.proposals[proposal_uid] = 1 if self.proposals[proposal_uid] == self.quorum_size: accepted_value_tuple = LogEntry(proposal_uid, accepted_value, False) accepted_value_tuple_true = LogEntry(proposal_uid, accepted_value, True) is_found = False i = len(self.owner.log) - 1 while i >= 0: if self.owner.log[i] == accepted_value_tuple_true: is_found = True if self.owner.log[i] == accepted_value_tuple: self.owner.log[i].is_accepted = True is_found = True break i -= 1 if not is_found: accepted_value_tuple.is_accepted = True self.owner.log.append(accepted_value_tuple) m = Learner.AsynchronousMessenger(self, proposal_uid, accepted_value, self.owner.log) m.start()
class Node(threading.Thread): class Daemon(threading.Thread): def __init__(self, owner): threading.Thread.__init__(self) self.owner = owner def run(self): while True: if self.owner.abort: continue if self.owner.in_propose_time_frame: self.owner.in_propose_time_frame = False #if self.owner.is_last_decided or self.owner.next_post is None: self.owner.is_last_decided = False self.owner.next_post = self.owner.queue.get(True) print('Propose next available value {}.'.format(self.owner.next_post)) self.owner.proposer.set_proposal(self.owner.next_post) self.owner.proposer.propose() #elif self.owner.next_post is not None: # print('Propose old value {}'.format(self.owner.next_post)) # self.owner.proposer.set_proposal(self.owner.next_post) # self.owner.proposer.propose() def __init__(self, uid, addr, port): threading.Thread.__init__(self) self.address = addr self.port = port self.server = Server(self, port, address=addr) self.queue = queue.Queue() self.abort = False self.uid = uid self.next_post = None # local log of the Node self.log = [] self.proposer = Proposer(self, uid, addr, port + 1) self.acceptor = Acceptor(self, uid, addr, port + 2) self.learner = Learner(self, uid, addr, port + 3) self.stopped_proposal_id = None self.lock = threading.Lock() self.last_decided_proposer_id = None self.is_last_decided = False self.in_propose_time_frame = True self.daemon = Node.Daemon(self) def recv_message(self, msg): with self.lock: #if msg.type == Message.MSG_STOP and msg.data[0].number != self.stopped_proposal_id: if msg.type == Message.MSG_STOP and not self.is_last_decided: self.is_last_decided = True # set local log accepted_log = msg.data[2] if len(accepted_log) > len(self.log): self.log = accepted_log i = len(self.log) - 1 while i >= 0: if not self.log[i].is_accepted: del self.log[i] i -= 1 #print('Log after this round on site {}: '.format(self.uid)) #print('[', end='') #for log_entry in self.log: # print(log_entry, end=', ') # #print(']\n') # self.stopped_proposal_id = msg.data[0].number self.proposer.reset() self.acceptor.reset() self.learner.reset() #self.last_decided_proposer_id = msg.data[0] #if msg.data[0] == self.uid: time.sleep(6) self.in_propose_time_frame = True def fail(self): self.proposer.fail() self.acceptor.fail() self.learner.fail() self.abort = True self.server.do_abort() def recover(self): self.server.recover() self.proposer.recover() self.acceptor.recover() self.learner.recover() self.abort = False def run(self): self.server.start() self.proposer.start() self.acceptor.start() self.learner.start() self.daemon.start()