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)
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 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 __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
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 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()
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 setup_ap(): WLAN().init(mode=WLAN.AP, ssid=coda_common.CODA_CONFIG["wifi_manager_ssid"], auth=( WLAN.WPA2, coda_common.CODA_CONFIG["wifi_manager_pwd"], ), channel=7, antenna=WLAN.INT_ANT) Server().deinit() Server().init(login=(coda_common.CODA_CONFIG["server_userid"], coda_common.CODA_CONFIG["server_pwd"]), timeout=60)
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 __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 __init__(self): from network import Server import socket server = Server() self.is_telnet_running = server.isrunning() server.deinit() self.poll = select.poll() listening = socket.socket(socket.AF_INET, socket.SOCK_STREAM) listening.bind(('', 23)) listening.listen(1) self.socket = listening.accept()[0] listening.close() self.poll.register(self.socket, select.POLLIN) self.socket.setblocking(False) self.write = self.socket.write
def destroy(self): self.socket.close() if self.is_telnet_running is True: from network import Server Server().init( login=telnet_login ) # telnet_login is appended to the code at upload time
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 __init__(self, controller=None): Service.__init__(self, 'dispatcher') self.handlers[Message.TYPE_LOGIN] = self.handle_login self.handlers[Message.TYPE_IMAGE] = self.handle_image self.handlers[Message.TYPE_RESULT] = self.handle_result self.server = Server(self, cfg.SERVER_PORT) self.protocols = {} self.nodes = {} if cfg.DASHBOARD: self.dashboard = Dashboard() self.dashboard.start() else: self.dashboard = None measure_period = float(cfg.CONTROLLER_LOOP_TIME)/cfg.MEASURES_PER_LOOP self.monitor = Monitor(self.process_measurements, measure_period) self.monitor.register_item(self.ITEM_FPS, Monitor.ITEM_RATE) self.monitor.register_item(self.ITEM_MAKESPAN, Monitor.ITEM_AVG) self.monitor.register_item(self.ITEM_THROUGHPUT, Monitor.ITEM_RATE) self.controller = controller self.controller.dashboard = self.dashboard self.controller.dispatcher = self if self.dashboard: self.dashboard.controller = controller self.imagebuf = Queue.Queue() # Buffer of encoded images # (time stamp, image data) # Initialize probe to blank image self.probe_image = self.generate_probe_image() self.tokens = Queue.Queue() self.job_id = 0 self.job_image_cache = {} self.sub_loop = 0 return
def main(): """Entry point for our simple vlc player """ app = QtWidgets.QApplication(sys.argv) player = Player() _ = Server("localhost", 10000, player.data_queue) player.show() player.resize(640, 480)
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)
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()
def run(ip, port): """ handler = logging.StreamHandler() formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s') handler.setFormatter(formatter) log = logging.getLogger('kademlia') log.addHandler(handler) log.setLevel(logging.DEBUG) """ loop = asyncio.get_event_loop() loop.set_debug(True) server = Server(storage=storage.AwesomeStorage()) loop.run_until_complete(server.listen(int(port), ip)) try: loop.run_forever() except KeyboardInterrupt: pass finally: server.stop() loop.close()
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()
def main(stdscr): finished = False gui = CursesInterface(stdscr) inpt = Input(stdscr, 0) menu = MenuScreen() game = Game() gui.initialize() inpt.initialize() while not menu.finished: events = inpt.poll_events() gui.clear() menu.update(events) render_menu(gui, menu) gui.refresh() time.sleep(0.1) if menu.current_idx == 0: gamewrapper = LocalVsGameWrapper(inpt, game) elif menu.current_idx == 1: gamewrapper = LocalAiGameWrapper(inpt, game) elif menu.current_idx == 2: gamewrapper = NetworkedGameWrapper(inpt, game, Server(), 1, 2) else: gamewrapper = NetworkedGameWrapper(inpt, game, Client(menu.get_server_ip_str()), 2, 1) gamewrapper.initialize() while not game.finished: gamewrapper.update() gui.clear() render_game(gui, game) time.sleep(0.05) gamewrapper.cleanup() while True: events = inpt.poll_events() if events: return time.sleep(0.1)
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!')
def change_access(self, user=None, passwrd=None): """change_access - change password for telnet and ftp access""" if (user is None) or (passwrd is None): print('WifiManager:: username and password must be specified') return server = Server() # from network # disable the server server.deinit() # enable the server again with new credentials # for ftp and telnet, not USB server.init(login=(user, passwrd), timeout=600) print_debug('WifiManager::password {} is changed...'.format(user))
def change_access(self, user=None, passwrd=None): """change_access - change password for telnet and ftp access""" if (user == None) or (passwrd == None): print('WifiManager:: username and password must be specified') return server = Server() # from network # disable the server server.deinit() # enable the server again with new credentials # for example: remote access, ftp and telnet, not USB server.init(login=(user, passwrd), timeout=600) if USE_DEBUG: print('WifiManager::password is changed...')
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)
if wlan.isconnected(): coda_common.CODA_CONFIG["lastssid"] = SSID coda_common.CODA_CONFIG["lastappwd"] = PWD coda_common.coda_save_config() break else: pass else: pass if wlan.isconnected(): coda_common.led_g() update_ap_list(SSID, PWD) print("ip:", wlan.ifconfig()[0]) server = Server() server.deinit() server.init(login=(coda_common.CODA_CONFIG["server_userid"], coda_common.CODA_CONFIG["server_pwd"]), timeout=60) time.sleep(1) coda_common.led_off() AP_LIST = None SCAN_LIST = None gc.collect() if coda_common.CODA_CONFIG[ "enable_app_main"] and coda_common.CODA_CONFIG["app_main"] > "": execfile(coda_common.CODA_CONFIG["app_main"])
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)
import sys import logging import asyncio import storage from network import Server # Usage: <python3> <node_ip> <node_port> <bootstrap_node_ip> <bootstrap_node_port> loop = asyncio.get_event_loop() loop.set_debug(True) server = Server(storage=storage.AwesomeStorage()) loop.run_until_complete(server.listen(int(sys.argv[2]), sys.argv[1])) bootstrap_node = (sys.argv[3], int(sys.argv[4])) loop.run_until_complete(server.bootstrap([bootstrap_node])) try: loop.run_forever() except KeyboardInterrupt: pass finally: server.stop() loop.close()
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): 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()
if len(sys.argv) != 4: print("Usage: python get.py <bootstrap node> <bootstrap port> <key>") sys.exit(1) # set up logging to file logging.basicConfig( level=logging.DEBUG, format='%(asctime)s - %(name)s - %(levelname)s - %(message)s', datefmt='%m-%d %H:%M', filemode='w') # define a Handler which writes INFO messages or higher to the sys.stderr console = logging.StreamHandler() console.setLevel(logging.INFO) # add the handler to the root logger logging.getLogger(__name__).addHandler(console) loop = asyncio.get_event_loop() loop.set_debug(True) server = Server() loop.run_until_complete(server.listen(8469)) bootstrap_node = (sys.argv[1], int(sys.argv[2])) loop.run_until_complete(server.bootstrap([bootstrap_node])) result = loop.run_until_complete(server.get(sys.argv[3])) server.stop() loop.close() print("Get result:", pickle.loads(result))
ssid=coda_common.CODA_CONFIG["wifi_manager_ssid"], auth=( WLAN.WPA2, coda_common.CODA_CONFIG["wifi_manager_pwd"], ), channel=7, antenna=WLAN.INT_ANT) Server().deinit() Server().init(login=(coda_common.CODA_CONFIG["server_userid"], coda_common.CODA_CONFIG["server_pwd"]), timeout=60) #begin code server = Server() gc.enable() time.sleep(1) wlan = WLAN() try: wlan.disconnect() except: pass wlan.init(mode=WLAN.STA) time.sleep(1) nets = [] netlist = []
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()
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)
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)
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()
pygame.init() # Set the width and height of the screen [width, height] size = (WIDTH, HEIGHT) screen = pygame.display.set_mode(size) pygame.display.set_caption("Configuration Space Visualization Tool") # Loop until the user clicks the close button. done = False # Used to manage how fast the screen updates clock = pygame.time.Clock() data_queue = queue.Queue() _ = Server("localhost", 10000, data_queue) ALPHA = 0 THETA = 0 RADIUS = 30 ORIGIN_X = WIDTH // 2 ORIGIN_Y = HEIGHT // 2 robot = Robot((ORIGIN_X, ORIGIN_Y), RADIUS) # Start the scatterplot process subprocess.Popen(["python", "plot.py"]) # Main game loop while not done: # Main event loop
import pycom import machine import ubinascii from network import WLAN from network import Bluetooth from network import Server from pytrack import Pytrack import uos from machine import Timer import math wlan = WLAN() wlan.deinit() bt = Bluetooth() bt.deinit() server = Server() server.deinit() py = Pytrack() ANSELC_ADDR = const(0x18E) py.poke_memory(ANSELC_ADDR, ~(1 << 7)) _LORA_PKG_FORMAT = "!BB%ds" _LORA_RCV_PKG_FORMAT = "!BB%ds" MY_ID = 0x0B (my_sf, my_bw_index, my_slot, guard, sync_rate) = (7, 2, 0, 40, 1 ) # default values freqs = [865000000, 865600000, 866200000, 866800000, 867400000, 868000000] # my channels # airtimes for 100-byte packets and 8 preamble symbols airtime = [[0.174336, 0.087168, 0.043584], [0.307712, 0.153856, 0.076928], [0.553984, 0.276992, 0.138496], [1.026048, 0.513024, 0.256512],
def testPutData(self): server = Server(user='******') temp = 34.3 timeLeft = 78.3 server.putEstimationData(temp, timeLeft) pass