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()
