def setup_sync(self): """ Initialises variables and network objects needed to sync players. """ if SYNC_IS_SERVER: self.server = network.Server('', port=10000) if SYNC_CLIENT_TO: self.client = network.Client(SYNC_CLIENT_TO, port=10000)
def __init__(self): self.d = diler.Diler(self) self.logins = {} self.money = 10000 self.clients = [] #[(conn, addr)] self.server = network.Server() try: self.f = open('file.txt', 'a') except IOError as e: print('Файла с логинами не существует!') print('Создаю новый файл') self.f = open('file.txt', 'w+') self.main()
def host_cb(self, wid=None): """Host a game.""" # Create server self.connection = network.Server(self) # Deactivate options self.conn_but.deactivate() self.menubar.find_item('Game/Join Game').deactivate() self.host_but.deactivate() self.menubar.find_item('Game/Host Game').deactivate() self.host_but.label('WAITING...') self.status_box.label('Waiting for a connection.')
def start_server(address=None, port=None): utils.log("Starting...") # initialize game env.Game.init(True) # start the host service env.Game.network_object = network.Server(address=address, port=port) networking_thread = threading.Thread(target=env.Game.network_object.start) networking_thread.start() utils.log("Ready!") while not env.Game.stopped: # update currently active state env.Game.States.get_active().update()
def wifiTask(): global wifi_wdt_lock, wifi_stop_flag logger = Logger(name='WIFI ' + __version__, level=logging.INFO, filename=None) logger.info('** WIFI Task started **') wlan = WLAN() wlan.deinit() uid = str(binascii.hexlify(machine.unique_id())[6:]) Ssid = 'ENS-PP-' + uid[2:8] logger.info('Using Hidden AP SSID:' + Ssid) wlan.init(mode=WLAN.AP, ssid=Ssid, auth=(WLAN.WPA2, 'Li56#fd0gertQQ'), channel=8, antenna=WLAN.INT_ANT, hidden=True) server = network.Server() server.deinit() # disable the server # enable the server again with new settings server.init(login=('ensuser', 'n0ty0urbu5ine55'), timeout=120) wifi_ap_init_done = True while not wifi_stop_flag.locked(): if wifi_wdt_lock.locked(): wifi_wdt_lock.release() time.sleep(1) if fota_wifi_release_sem.locked() and wifi_ap_init_done == True: wlan.deinit() wifi_ap_init_done = False wlan = None logger.info('Deinit AP mode for FOTA') try: wlan.deinit() except: pass logger.error('** WIFI Task ended **')
def __init__(self, id, port, remoteAddr=None): id %= MAX self.id = id self.port = port routing.table[id] = ('', port) self.fingers = [id] * SIZE self.starts = [] tmp = 1 for i in range(SIZE): self.starts.append((id + tmp) % MAX) tmp *= 2 self.predecessor = id self.server = network.Server(id, port, log=True) self.server.register_instance(self) if remoteAddr is not None: self._join(remoteAddr) self.server.serve()
def __init__(self, port, recv = None, httpdirs = None, server = None, proxy = (), http_connection = _Httpd_connection, websocket = Websocket, error = None, *a, **ka): # {{{ '''Create a webserver. Additional arguments are passed to the network.Server. @param port: Port to listen on. Same format as in python-network. @param recv: Communication object class for new websockets. @param httpdirs: Locations of static web pages to serve. @param server: Server to use, or None to start a new server. @param proxy: Tuple of virtual proxy prefixes that should be ignored if requested. ''' ## Communication object for new websockets. self.recv = recv self._http_connection = http_connection ## Sequence of directories that that are searched to serve. # This can be used to make a list of files that are available to the web server. self.httpdirs = httpdirs self._proxy = proxy self._websocket = websocket self._error = error if error is not None else lambda msg: print(msg) ## Extensions which are handled from httpdirs. # More items can be added by the user program. self.exts = { 'html': self.reply_html, 'js': self.reply_js, 'css': self.reply_css } ## Currently connected websocket connections. self.websockets = set() if server is None: ## network.Server object. self.server = network.Server(port, self, *a, **ka) else: self.server = server
import machine if machine.Pin("G17", mode=machine.Pin.IN, pull=machine.Pin.PULL_UP).value() == 0: machine.main("noop.py") import config machine.WDT(timeout=config.WATCHDOG_TIMEOUT * 1000) import pycom pycom.heartbeat_on_boot(False) pycom.heartbeat(False) pycom.wifi_on_boot(False) import network network.WLAN().deinit() network.Bluetooth().deinit() network.Server().deinit()
def __init__(self): self.server = network.Server() self.world = locations.World() self.world.server = self.server
import os import machine import pycom import network import config import ubinascii uart = machine.UART(0, 115200) os.dupterm(uart) pycom.heartbeat(False) server = network.Server(login=(config.USERNAME, config.PASSWORD), timeout=60) macdev = ubinascii.hexlify(machine.unique_id(), ':').decode() print("MAC address:", macdev) wlan = network.WLAN() # Default is WLAN.AP, so LoPy is accessible via telnet. print("WLAN MODE: ", wlan.mode()) machine.main('main.py') print('==========Starting main.py==========\n')
def __init__(self, color): Human.__init__(self, color) self.server = network.Server() self.type = 'Human(Client)'
def runMain(): import pycom #first thing first pycom.wdt_on_boot(True) pycom.wdt_on_boot_timeout(60000 * 5) # 5 min import _thread import uos from globs import * from helpers import hardwareInit, buildPFAlarmMessage, initConfigurationVariable, getConfigurationVariable, getRandom import pycom import time import machine from machine import Pin from loratask import loraTask from modbus import readRegisters, initModbus, deinitModbus, readPilot, getLatestInstMeasurments, MB_SUCCESS from network import WLAN from machine import WDT import binascii import network from machine import WDT import gc import _thread from queuewrapper import QueueWrapper print('** MAIN POC ' + __version__ + ' By ' + __author__ + ' Copyright ' + __copyright__ + ' **') print(str(uos.uname())) DEFAULT_STACK_SIZE = 5000 _thread.stack_size(DEFAULT_STACK_SIZE) AS = 0 try: from deviceid import antenna_setting AS = antenna_setting except: print('antenna_setting internal') else: print('antenna_setting is' + str(AS)) initConfigurationVariable(NVS_ANTENNA_CONFIGURATION, AS) antenna = getConfigurationVariable(NVS_ANTENNA_CONFIGURATION) # init the Hardware ( mainly the LoRa switch) and get the running mode, PF or NORMAL mode = hardwareInit(antenna) pycom.nvs_set(POWER_FAIL_STATE, mode) if mode == MODE_POWER_FAIL: LED_OUT = Pin(LED_OUT_PIN) LED_OUT.value(1) timeOfFault = pycom.nvs_get(POWER_FAIL_TS) alarmLoraMessageToSend = buildPFAlarmMessage(timeOfFault) lora_queue_immediate_semaphore.acquire(0) LoraQueueImmediate.put(alarmLoraMessageToSend) _thread.start_new_thread( loraTask, () ) # we just start the lora Task, send the PF alarm and go back to sleep if lora_stop_flag.locked(): lora_stop_flag.release() time.sleep_ms(WAIT_TIME_BEFORE_SLEEP * 10) # time for the LoRA MAC layer to send that message rand = int(getRandom() * 20) # 0-20 value #machine.deepsleep((WAKEUP_DELAY+rand)*1000) # GO TO SLEEP NOW AND PRESERVE POWER from wdttask import wdtTask from wifitask import wifiTask from loopimpedancetask import loopImpedanceTask from modbustask import modbusTask from maintask import mainTask from eventtask import eventTask from computingtask import computingTask FCTMode = False # if true this mode is used in the factory during FCT SERIAL_NUMBER_REGISTER = 48888 # only works for M11 and C11 with SPM93 MIN_SERIAL_NUMBER_VAL = 10000000 MAX_SERIAL_NUMBER_VAL = 99999999 # Read config variables CT = 20 # default is 20 for M11 (only apply to M11) try: from deviceid import ctRatio CT = ctRatio except: pass print('M11 SW Ct Ratio is' + str(CT)) RO = int(getRandom() * 300) # 0-300 value try: from deviceid import radio_offset RO = radio_offset except: print('Radio Offset not defined, using random ' + str(RO)) else: print('Radio Offset is' + str(RO)) DT = 0 # assume M11 try: from deviceid import deviceType DT = deviceType except: print('Device type is not defined, using M11') FCTMode = True # no config means FCT phase else: print('Device type is' + str(DT)) if FCTMode == True: print('FCT mode') # read the S/N from the meter initModbus() serial_number = 0 dev_type = 0 MB_ADD = 22 MODEL_M11 = "00" #M11 MODEL_M11E_20 = "01" #M11E-20 Model = MODEL_M11 # ONLY SUPPORT m11 AT PRESENT try: raw_serial_number = readRegisters(MB_ADD, dev_type, SERIAL_NUMBER_REGISTER, 2) # convert to Uint32 serial_number = int(raw_serial_number[2] << 8 | raw_serial_number[3] | raw_serial_number[0] << 24 | raw_serial_number[1] << 16) except: print("Calibration mode") serial_number = 0 print('S/N:' + str(serial_number)) uid = str(binascii.hexlify(machine.unique_id())) #validate Ssid = "TESTPP" if serial_number >= MIN_SERIAL_NUMBER_VAL and serial_number <= MAX_SERIAL_NUMBER_VAL: # calibration successfull use the SN as SSID # # Read current and voltage M11 (5A - 230V) if successfull append S if not append F Result = "F" try: res = readPilot(MB_ADD, dev_type, 20) # M11, address 22 with ct is 20 if res != MB_SUCCESS: res = readPilot(MB_ADD, dev_type, 20) # M11, address 22 with ct is 20 if res != MB_SUCCESS: res = readPilot(MB_ADD, dev_type, 20) # M11, address 22 with ct is 20 data = getLatestInstMeasurments() V = float(data[INST_VOLTAGE]) I = float(data[INST_CURRENT]) print("Voltage:" + str(V) + "V - Current" + str(I) + "A") if (V >= 228) and (V <= 232) and (I >= 4.8) and (I <= 5.2): Result = "S" Model = MODEL_M11E_20 # if this is successful then it means we have CT ratio set up except: pass if dev_type == 0: DEV = "M" else: DEV = "C" Ssid = DEV + "{0:0=8d}".format(serial_number) + "-{0:0=3d}".format( VERSION_SOFTWARE) + uid[2:14].upper() + Result + Model # M19000001-022000000000000S03 # TSSSSSSSSFFFMMMMMMMMMMMMRII else: #possible calibration in progress # display serial port must be high impedance: deinitModbus() p3 = Pin('P3', mode=Pin.IN, pull=None) p4 = Pin('P4', mode=Pin.IN, pull=None) wdt = WDT(timeout=60000 * 5) # 7 min print("Released display lines and waiting") while True: #forever loop there wdt.feed() time.sleep(10) print('SSID:' + Ssid) wlan = WLAN() wlan.init(mode=WLAN.AP, ssid=Ssid, auth=(WLAN.WPA2, 'powerpilot'), channel=8, antenna=WLAN.INT_ANT, hidden=False) server = network.Server() server.deinit() # disable the server # enable the server again with new settings server.init(login=('factory', 'pilot'), timeout=120) else: # FCTMode == False # Init the configurable parameters in NVS if needed (first time) initConfigurationVariable(NVS_RADIO_DELAY, RO) initConfigurationVariable(NVS_HV_ALARM, VOLTAGE_EXCURSION_6_HIGH_THRESOLD) initConfigurationVariable(NVS_LV_ALARM, VOLTAGE_EXCURSION_6_LOW_THRESOLD) initConfigurationVariable(NVS_VHV_ALARM, VOLTAGE_EXCURSION_10_HIGH_THRESOLD) initConfigurationVariable(NVS_VLV_ALARM, VOLTAGE_EXCURSION_10_LOW_THRESOLD) initConfigurationVariable(NVS_CT_RATIO, CT) initConfigurationVariable(NVS_DEVICE_TYPE, DT) initConfigurationVariable(NVS_INST_DATA_FREQ, 10) time_set_flag.acquire(0) #time need to be set (released = TIME is set) # NORMAL MODE, start all tasks _thread.start_new_thread(modbusTask, ()) gc.mem_free() _thread.start_new_thread(loopImpedanceTask, ()) _thread.start_new_thread(eventTask, ()) _thread.start_new_thread(wdtTask, ()) gc.mem_free() _thread.start_new_thread(computingTask, ()) #_thread.stack_size(DEFAULT_STACK_SIZE ) _thread.start_new_thread(loraTask, ()) _thread.start_new_thread(wifiTask, ()) gc.mem_free() _thread.start_new_thread(mainTask, ()) time.sleep(1) if mb_stop_flag.locked(): mb_stop_flag.release() if compute_stop_flag.locked(): compute_stop_flag.release() if event_stop_flag.locked(): event_stop_flag.release() if li_stop_flag.locked(): li_stop_flag.release() if wifi_stop_flag.locked(): wifi_stop_flag.release() if lora_stop_flag.locked(): lora_stop_flag.release() if main_stop_flag.locked(): main_stop_flag.release()
def __init__(self): self.d = diler.Diler() self.clients = [] #[(conn, addr)] self.server = network.Server() self.main()
#!/usr/bin/env python3 # coding: utf-8 import multiprocessing import classe import instance import matchmaking import login import network if __name__ == "__main__": import logging logging.basicConfig(level=logging.DEBUG) server = network.Server("0.0.0.0", 9000) try: logging.info("Démarrage du serveur") server.start() except: logging.exception("Exception inconnue") finally: logging.info("Arrêt du serveur") for process in multiprocessing.active_children(): logging.info("Arrêt des processus fils %r", process) process.terminate() process.join() logging.info("Terminé")
""" network server test for the CC3200 based boards. """ import os import network mch = os.uname().machine if not "LaunchPad" in mch and not "WiPy" in mch: raise Exception("Board not supported!") server = network.Server() print(server.timeout() == 300) print(server.isrunning() == True) server.deinit() print(server.isrunning() == False) server.init(login=("test-user", "test-password"), timeout=60) print(server.isrunning() == True) print(server.timeout() == 60) server.deinit() print(server.isrunning() == False) server.init() print(server.isrunning() == True) try: server.init(1) except: print("Exception")
server.clients -= 1 server.CLIENTS.remove(connection) print( f"\n[CLIENT DISCONNECTED] [{address}] Just Disconnected!" ) print(f"[ACTIVE CONNECTIONS] {server.clients}\n") break except Exception as e: if connection in clients: code = clients[connection] servers[code].remove(connection) clients.pop(connection) for conn in servers[code]: server.send("[OPPONENT LEFT]", conn) clients.pop(conn) servers.pop(code) server.clients -= 1 server.CLIENTS.remove(connection) print(f"\n[CLIENT DISCONNECTED] [{address}] Just Disconnected!") print(f"[ACTIVE CONNECTIONS] {server.clients}\n") break connection.close() server = network.Server(handle_client, 5555, 'localhost')
lecturas = n.readsens() print("Sending Data") n.send(lecturas) #Envío de las lecturas print("Data Sent, sleeping ...") print('- ' * 20) n.py.setup_int_wake_up(rising=1,falling=0) #Activa la interrupcion por Botón n.py.setup_sleep(sleep_time-ajuste) n.py.go_to_sleep(False) #Dispositivo enviado a Deepsleep elif (py.get_wake_reason() == WAKE_REASON_PUSH_BUTTON): uart = UART(0, 115200) #Se activa la UART os.dupterm(uart) wlan = WLAN() wlan.init(mode=WLAN.AP, ssid='lopy-pysense', auth=(network.WLAN.WPA2,'lopy-pysense'), channel=7,antenna=WLAN.INT_ANT) #Init Wi-Fi server = network.Server() #Init FTP Server print("Device entered into debugging mode") print("Please do not connect to battery") pycom.heartbeat(True) #Se activa el Heartbeat while(1): if py.button_pressed(): print("Resetting") machine.reset() else: #Si viene de Boot o Hard Reset print('Power on or hard reset') sleep_time = 100 #Valor por defecto de sleep_time (Minimo segun Fair Acess Policy TTN) data_rate = 5 pycom.wifi_on_boot(False) # disable WiFi on boot TODO: Intentar en versiones posteriores, da un Core Error. pycom.heartbeat_on_boot(False) try:
def startServer(): server = network.Server() server.listen()
async def run_services(opts): data_dir = opts.get("data_dir") mapping = config.json.load(opts["config"]) preferences = config.from_mapping(mapping) logger = log.new_logger("icbd", preferences.logging_verbosity) registry = log.Registry() registry.register(logger) logger.info("Starting server process with pid %d.", os.getpid()) container = di.default_container connection = sqlite.Connection(preferences.database_filename) ipfilter_storage = ipfilter.sqlite.Storage() ipfilter_cached = ipfilter.cache.Storage(ipfilter_storage) container.register(logging.Logger, logger) container.register(log.Registry, registry) container.register(config.Config, preferences) container.register(ipc.Broadcast, ipc.Broadcast()) container.register(shutdown.Shutdown, shutdown.Shutdown()) container.register(ipfilter.Connection, connection) container.register(ipfilter.Storage, ipfilter_cached) container.register(broker.Broker, broker.memory.Broker()) container.register(session.Store, session.memory.Store()) container.register(session.AwayTimeoutTable, timer.TimeoutTable()) container.register(session.NotificationTimeoutTable, timer.TimeoutTable()) container.register(reputation.Reputation, reputation.memory.Reputation()) container.register(group.Store, group.memory.Store()) container.register(nickdb.Connection, connection) container.register(nickdb.NickDb, nickdb.sqlite.NickDb()) container.register(statsdb.Connection, connection) container.register(statsdb.StatsDb, statsdb.sqlite.StatsDb()) container.register(confirmation.Connection, connection) container.register(confirmation.Confirmation, confirmation.sqlite.Confirmation()) container.register(passwordreset.Connection, connection) container.register(passwordreset.PasswordReset, passwordreset.sqlite.PasswordReset()) container.register(motd.Motd, motd.plaintext.Motd(os.path.join(data_dir, "motd"))) container.register(manual.Manual, manual.plaintext.Manual(os.path.join(data_dir, "help"))) container.register(news.News, news.plaintext.News(os.path.join(data_dir, "news"))) container.register( template.Template, template.plaintext.Template(os.path.join(data_dir, "templates"))) container.register(mail.Connection, connection) container.register(mail.Sink, mail.sqlite.Sink()) container.register(avatar.Connection, connection) container.register(avatar.Reader, avatar.sqlite.Reader()) container.register( avatar.Writer, avatar.sqlite.Writer(preferences.avatar_reload_timeout, preferences.avatar_retry_timeout, preferences.avatar_max_errors, preferences.avatar_error_timeout)) if avatar.is_available(): container.register( avatar.Storage, avatar.fs.AsciiFiles(preferences.avatar_directory, preferences.avatar_ascii_width, preferences.avatar_ascii_height)) else: logger.info("Avatar preview not available.") container.register(avatar.Storage, avatar.void.Storage()) with connection.enter_scope() as scope: container.resolve(ipfilter.Storage).setup(scope) container.resolve(nickdb.NickDb).setup(scope) container.resolve(statsdb.StatsDb).setup(scope) container.resolve(confirmation.Confirmation).setup(scope) container.resolve(mail.Sink).setup(scope) container.resolve(avatar.Reader).setup(scope) container.resolve(avatar.Writer).setup(scope) container.resolve(passwordreset.PasswordReset).setup(scope) scope.complete() container.resolve(avatar.Storage).setup() bus = ipc.Bus() await bus.start() if os.name == "posix": loop = asyncio.get_event_loop() loop.add_signal_handler(signal.SIGINT, lambda: server.close()) loop.add_signal_handler(signal.SIGTERM, lambda: server.close()) processes = [MailProcess()] if avatar.is_available(): processes.append(AvatarProcess()) asyncio.gather(*[p.spawn(opts) for p in processes]) failed = False try: server = network.Server() await server.run() except asyncio.CancelledError: pass except: logger.warning(traceback.format_exc()) failed = True await bus.close() for p in processes: p.exit() logger.info("Server stopped.") with container.resolve(nickdb.Connection).enter_scope() as scope: container.resolve(nickdb.NickDb).set_signoff(scope, core.NICKSERV, dateutils.now()) scope.complete() sys.exit(server.exit_code if not failed else core.EXIT_FAILURE)
def run(self): """ Main body for cv manager (It should only be called by threading.Thread, use start() to launch it) """ self.stopped = False vs = self.video_stream.start() \ if isinstance(self.video_stream, imutils.video.videostream.VideoStream) \ else self.video_stream # Inits video streaming server if self.server_enabled: self.server = network.Server(self.server_port) self.server.start() while not self.stopped: frame = vs.read() \ if isinstance(self.video_stream, imutils.video.videostream.VideoStream) \ else vs.read()[1] if frame is None: if isinstance(self.video_stream, imutils.video.videostream.VideoStream): print( "Something went wrong when trying to start video stream :(" ) break else: # Reset cap to replay it if it is a video vs.set(cv2.CAP_PROP_POS_FRAMES, 0) continue # Resize frame if required if not self.camera_resolution is None: frame = imutils.resize(frame, width=self.camera_resolution) # get a list of the names of items required by server server_requests = self.server.get_requests( ) if self.server_enabled else [] # run each core for name in self.tracking_cores: if not self.tracking_cores_enabled[ name]: # bypass disabled core continue (x, y, size, frames) = self.tracking_cores[name].find( frame.copy()) # run core self.tracking_cores_result[name] = (x, y, size) # save result for i, f in enumerate(frames): frame_name = name + "," + str(i) # encode and send frame to client if frame_name in server_requests: self.server.offer_data(frame_name, CVManager.__encode(f)) # show frames in desktop is enabled if self.enable_imshow: cv2.imshow(frame_name, f) self.new_frame_event.set( ) # set the event so wait() method can be released self.new_frame_event = threading.Event() if self.path: self.out.write(frame) cv2.waitKey(self.delay) # wait # stop the manager if isinstance(self.video_stream, imutils.video.videostream.VideoStream): vs.stop() self.stop()
#!/usr/bin/python2.7 # -*- coding: utf-8 -*- #!/usr/bin/python2.7 # -*- coding: utf8 -*- # ======================================== # Projet: PyJoke # Rôle: Lance le serveur PyJoke # Auteur: kadeseb # Crée le: 09/10/2016 # ======================================== if __name__ == '__main__': print '======================' print '= PyJoke Server [v2] =' print '======================' import network as Network import command as Command ############################ # Gestionnaire de commande # ############################ manager = Command.Manager() ########### # Serveur # ########### server = Network.Server(manager) server.start() manager.run()
try: httpd = Server(config['port'], Connection, disconnect_cb=_disconnect, httpdirs=fhs.read_data('html', dir=True, multiple=True), address=config['address'], log=config['log'], tls=tls) udevsocket = fhs.write_runtime('udev.socket', packagename='franklin', opened=False) os.makedirs(os.path.dirname(udevsocket), exist_ok=True) if os.path.exists(udevsocket): os.unlink(udevsocket) udevserver = network.Server(udevsocket, Admin_Connection) except OSError: log('failed to start server: %s' % sys.exc_info()[1]) sys.exit(1) # }}} # Initialization. {{{ def create_machine(uuid=None): # {{{ if uuid is None: uuid = protocol.new_uuid() process = subprocess.Popen( (fhs.read_data('driver.py', opened=False), '--uuid', uuid, '--allow-system', config['allow-system']) + (('--system', ) if fhs.is_system else ()), stdin=subprocess.PIPE,
break except: pass print(f"[{address}] {message[0]}") if message[0] == "QUIT": quit(connection, address) break elif message[0] == 'SHARE': servers[message[1][0]] = message[1][1] server.send(['SHARED'], connection) update_servers_json(servers) print('[SERVER] Server Data Updated!') elif message[0] == 'UPDATE': if message[1] not in servers: servers[message[1]] = [] server.send(['UPDATE', servers[message[1]]], connection) print('[SERVER] Server Data Sent!') except Exception as e: print('Error:', e) quit(connection, address) break connection.close() server = network.Server(handle_client, 5555, socket.gethostbyname(''))
def host(): server = network.Server() server.call_listenLoop() time.sleep(10) server.close()