def __init__(self,
host=config.HOST_ADDRESS,
port=config.SERVER_PORT,
socket=GDBFrontendSocket):
threading.Thread.__init__(self)
self.server = SimpleWebSocketServer.SimpleWebSocketServer(
host, port, socket)
def run_competition_viewer_process(vehicle_state_data, mission_information_data):
competition_viewer_server = SimpleWebSocketServer.SimpleWebSocketServer('', 8000,
SUASSystem.CompetitionViewerSocket,
vehicle_state_data,
mission_information_data
)
competition_viewer_server.serveforever()
def __init__(self):
log( "Cannybots BLE Agent v{} starting...".format(VERSION))
self.keepRunning = True
self.wsService = SimpleEcho
self.ws = SimpleWebSocketServer('', 3141, self.wsService)
self.ble = Adafruit_BluefruitLE.get_provider()
self.ble.initialize()
def __init__(self):
global ws
global wsService
self.keepRunning = True
wsService = BuzzWebSocket
ws = SimpleWebSocketServer('', 3141, wsService)
self.ble = Adafruit_BluefruitLE.get_provider()
self.ble.initialize()
from SimpleWebSocketServer import *
clients = []
class Serve(WebSocket):
def handleMessage(self):
for client in clients:
if client != self:
client.sendMessage(self.data)
return
def handleConnected(self):
clients.append(self)
def handleClose(self):
clients.remove(self)
server = SimpleWebSocketServer("", 9999, Serve)
server.serveforever()
'button': globalData['/simulator-button'],
'laststep': laststep,
'temp': globalData['/simulator-temp']
})))
time.sleep(0.3)
publishThread = threading.Thread(target=publishWs)
publishThread.daemon = True
publishThread.start()
class McastWebService(WebSocket):
def handleConnected(self):
global clientLastUpdate
print self.address, 'connected'
clientLastUpdate["%s%s" % (self.address)] = 0
clients.append(self)
def handleClose(self):
global clientLastUdate
clients.remove(self)
del clientLastUpdate["%s%s" % (self.address)]
print self.address, 'closed'
sys.stderr.write("Starting WebSocket Server\n")
server = SimpleWebSocketServer('', 54662, McastWebService)
server.serveforever()
#1;Secret Sever Key;topic_id;poster_name;post_id
with protect_locker:
trigger_chain_messages(data_split[2], data_split[3],
data_split[4])
self.close()
elif (data_split[0] == "2"): #Server informs a new track from a user.
if (data_split[1] != config.SERVER_KEY):
self.close()
#TODO
self.close()
elif (data_split[0] == "3"): #Server informs a track has been removed
if (data_split[1] != config.SERVER_KEY):
self.close()
#TODO
self.close()
# In[13]:
if (config.USE_SSL == 1):
server = SimpleSSLWebSocketServer(config.SERVER_IP, config.SERVER_PORT,
ClientManager, config.SSL_CERT_PATH,
config.SSL_KEY_PATH)
else:
server = SimpleWebSocketServer(config.SERVER_IP, config.SERVER_PORT,
ClientManager)
server.serveforever()
from SimpleWebSocketServer import *
clients = []
class Serve(WebSocket):
def handleMessage(self):
for client in clients:
if client != self:
client.sendMessage(self.data)
return
def handleConnected(self):
clients.append(self)
def handleClose(self):
clients.remove(self)
server = SimpleWebSocketServer('', 9999, Serve)
server.serveforever()
# https://www.tutorialspoint.com/creating-a-proxy-webserver-in-python
import SimpleWebSocketServer
import SimpleHTTPSServer
import urllib
PORT = 8261
class JustAProxy(SimpleHTTPSServer.SimpleWebSocketServer):
def do_GET(self):
url=self.path[1:]
self.send_response(200)
self.end_headers()
self.copyfile(urllib.urlopen(url), self.wfile)
print(url)
httpd = SimpleWebSocketServer.SimpleWebSocketServer('localhost',PORT,JustAProxy)
print ("Proxy Srever at" , str(PORT))
httpd.serveforever()
data = unicode(trameGalileo)
self.data = data
Galileo.sendMessage(self.data)
def handleConnected(self):
print(self.address, 'connected')
affiche = self.address
# i compare the IP address to know who start the connexion
if affiche[0] == ('192.168.1.215'):
print('Galileo is connected')
Galileo = self
else:
print('Monitor connected')
# i put Monitor info in a array
global Monitor
Monitor.append(self)
# SEND THE MAP TO MONITOR#
data = unicode(essai)
self.data = data
self.sendMessage(self.data)
#close the connexion
def handleClose(self):
print(self.address, 'closed')
### THE MAIN ###
server = SimpleWebSocketServer('0.0.0.0', 5000, SimpleEcho)
server.serveforever()
def server_start():
server = swss.SimpleWebSocketServer('localhost',
8001,
MyWebsocketExample,
selectInterval=0.1)
server.serveforever()
import SimpleWebSocketServer as swss
class Socket(swss.WebSocket):
def handleMessage(self):
print(self.data)
def handleConnected(self):
print(self.address, 'connected')
def handleClose(self):
print(self.address, 'closed')
server = swss.SimpleWebSocketServer('0.0.0.0', 9111, Socket)
server.serveforever()
class BLEAgent:
def __init__(self):
log( "Cannybots BLE Agent v{} starting...".format(VERSION))
self.keepRunning = True
self.wsService = SimpleEcho
self.ws = SimpleWebSocketServer('', 3141, self.wsService)
self.ble = Adafruit_BluefruitLE.get_provider()
self.ble.initialize()
def startWebSocketServer(self):
self.wsWorkerThread = Thread(target=self._websocket_worker)
self.wsWorkerThread.daemon = True
self.wsWorkerThread.name = 'WebSocketMsgWorker'
self.wsWorkerThread.start()
def _websocket_worker(self):
try:
log("Starting WebSocket server")
self.ws.serveforever()
except Exception as err:
log( "ERROR: WebSocker server error: " + err.message + ", stacktrace: " + repr(traceback.format_exc()))
self.keepRunning = False
def startBLE(self):
log("Starting BLE")
self.ble.clear_cached_data()
log('Cache cleared')
self.adapter = self.ble.get_default_adapter()
#log(repr(self.adapter.list_adapters()))
log('Powering on...')
self.adapter.power_on()
log('Using adapter: {0}'.format(self.adapter.name))
log('Disconnecting any connected UART devices...')
#self.ble.disconnect_devices([UART_SERVICE_UUID])
print('Searching for UART device...')
try:
self.adapter.start_scan()
self.device = self.ble.find_device(service_uuids=[UART_SERVICE_UUID])
if self.device is None:
raise RuntimeError('Failed to find UART device!')
finally:
self.adapter.stop_scan()
log('Connecting to device...')
self.device.connect()
try:
log('Discovering services...')
self.device.discover([UART_SERVICE_UUID], [TX_CHAR_UUID, RX_CHAR_UUID])
self.uart = self.device.find_service(UART_SERVICE_UUID)
self.rx = uart.find_characteristic(RX_CHAR_UUID)
self.tx = uart.find_characteristic(TX_CHAR_UUID)
log('Sending message to device...')
self.tx.write_value('Hello world!\r\n')
# need to be thread safe, e.g. use Queues!
def received(data):
print('Received: {0}'.format(data))
# Turn on notification of RX characteristics using the callback above.
log('Subscribing to RX characteristic changes...')
self.rx.start_notify(received)
except Exception as err:
log( "ERROR: Start BLE " + err.message + ", stacktrace: " + repr(traceback.format_exc()))
def isConnected(self):
wsOK = True
bleOK = True
if (wsOK and bleOK and self.keepRunning):
return True
else:
if (not bleOK):
log( "Not connected to BLE")
if (not wsOK):
log( "Not running webocket")
return False
def start(self):
try:
self.startWebSocketServer();
self.startBLE();
while True:
sleep(CONNECTION_CHECK_DELAY)
print "connection check.."
if not self.isConnected():
break
except Exception as err:
log( "ERROR: Main (General) " + err.message + ", stacktrace: " + repr(traceback.format_exc()))
# def start(self):
# self.ble.run_mainloop_with(self._start)
def stop(self):
log( "Cannybots BLE Agent exiting...")
self.device.disconnect()
self.keepRunning=False;
connections = []
class MessageHandler(WebSocket):
def handleMessage(self):
self.sendMessage(self.data)
def handleConnected(self):
connections.append(self)
self.sendMessage(u"CARMINE Connected")
def handleClose(self):
connections.remove(self)
server = SimpleWebSocketServer('', 8000, MessageHandler, 0.016)
def _(msg):
for con in list(connections):
con.sendMessage(u"" + msg)
class Carmine:
__module__ = __name__
def __init__(self, c_instance):
self.instance = c_instance
self.slisten = {}
self.clisten = {}
self.song = self.instance.song()
if __name__ == '__main__':
#Init SIGINT
"""
def close_sig_handler(signal, frame):
if server:
server.close()
if socketio.server:
socketio.server.stop();
sys.exit()
signal.signal(signal.SIGINT, close_sig_handler)
"""
print 'Server start !'
cabsWS = CabWS
server = SimpleWebSocketServer('', 9741, cabsWS)
print 'Start Flask SocketIO server !'
t1 = threading.Thread(target=thread_flask)
t1.start()
print 'Server WS Cab start !'
server.serveforever()
print 'Server stop !'
t1.join()
