def start_websocket_server(cert, key, port):
stat("Starting websocket server")
try:
verbo("Reading SSL/TLS certificate")
with open(cert) as f:
pass
except:
stat("!! FAILED TO READ SSL/TLS CERTIFICATE !!")
exit(2)
try:
verbo("Reading SSL/TLS key")
with open(key) as f:
pass
except:
stat("!! FAILED TO READ SSL/TLS PRIVATE KEY!!")
exit(2)
verbo("SSL/TLS Check PASSED")
verbo("Will now start websocket server on port " + str(port))
server = SimpleSSLWebSocketServer('', port, SimpleServer, cert, key)
thread.start_new_thread(server.serveforever, ())
stat("Websocket server is now running")
def start(self):
if self.server is None:
if not self.use_ssl:
self.server = SimpleWebSocketServer(self.host,
self.port,
self.ws_class,
selectInterval=0.1)
else:
self.server = SimpleSSLWebSocketServer(
self.host,
self.port,
self.ws_class,
self.certfile,
self.keyfile,
version=self.ssl_version,
selectInterval=0.1,
ssl_context=None)
print(' - Starting WS Server, {}:{}'.format(self.host, self.port))
self.th = threading.Thread(target=start_new_server,
args=(self.server, ))
self.th.start()
return None
def run(self):
asyncio.set_event_loop(self.network.asyncio_loop)
host = self.config.get('websocket_server')
port = self.config.get('websocket_port', 9999)
certfile = self.config.get('ssl_chain')
keyfile = self.config.get('ssl_privkey')
self.server = SimpleSSLWebSocketServer(host, port, ElectrumWebSocket, certfile, keyfile)
self.server.serveforever()
def run(port=8000):
server = SimpleSSLWebSocketServer(DOMAIN, port, WebSocketHandler,
".ssl/site.crt", ".ssl/site.key")
Thread(target=server.serveforever, daemon=True).start()
logger.info(f"Listening for WebSocket connections on {port}...")
# TODO: Make this if configurable
if True:
handle_clients()
def user_session_wsserver(server_status):
host = "localhost"
port = 4334
socket_class = session_websocket
cert = "./webclient/server.pem"
key = "./webclient/key.pem"
server = SimpleSSLWebSocketServer(host, port, socket_class, cert, key)
#server = SimpleWebSocketServer(host=host, port=port)
print("wss ready to serve")
server.serveforever()
def run(self):
t = WsClientThread(self.config, self.net_server)
t.start()
host = self.config.get('websocket_server')
port = self.config.get('websocket_port', 9999)
certfile = self.config.get('ssl_chain')
keyfile = self.config.get('ssl_privkey')
self.server = SimpleSSLWebSocketServer(host, port, ElectrumWebSocket, certfile, keyfile)
self.server.serveforever()
def __init__(self, config):
self.config = config
self.users = []
wshost = self.config['wsserver']['host']
wsport = self.config['wsserver']['port']
wscert = self.config['wsserver']['certfile']
wskey = self.config['wsserver']['keyfile']
self.server = SimpleSSLWebSocketServer(wshost,wsport,WebSocketWrapper,wscert,wskey,ssl.PROTOCOL_TLS)
self.server.cool_core = self
self.auth = Auth(self.config, self)
self.media = Media(self.config, self)
self.validator = MessageValidator(self.config, self)
def WebSocket_thread():
global WebSocketServer
if USE_SSL:
WebSocketServer = SimpleSSLWebSocketServer(
IP,
PORT,
WebSocket_server,
selectInterval=0.001,
certfile="./cert.pem",
keyfile="./key.pem",
version=ssl.PROTOCOL_TLSv1_2)
else:
WebSocketServer = SimpleWebSocketServer(IP,
PORT,
WebSocket_server,
selectInterval=0.001)
try:
WebSocketServer.serveforever()
except:
pass
print("Websocket server closed.")
def mock_server():
"""
Fixture for creating a mock RT server. The server is designed
to behave very similarly to the actual RT server, but returns
dummy responses to most messages.
The server runs in a background thread and is cleaned up as part of the
fixture's tear-down step.
Yields:
tests.mock_rt_server.MockRealtimeLogbook: An object used to record
information about the messages received and sent by the mock server.
"""
logbook = MockRealtimeLogbook()
logbook.url = "wss://127.0.0.1:8765/v2"
MockRealtimeServer.logbook = logbook
server = SimpleSSLWebSocketServer("127.0.0.1",
8765,
MockRealtimeServer,
ssl_context=server_ssl_context())
server_should_stop = False
def server_runner():
while not server_should_stop:
server.serveonce()
thread = threading.Thread(name="server_runner", target=server_runner)
thread.daemon = True
thread.start()
yield logbook
server_should_stop = True
thread.join(timeout=60.0)
assert (not thread.is_alive()
) # check if the join timed out (this should never happen)
def portMap(val):
if val == "triforce":
return 26
#Scrittura valori sulle porte GPIO in base al valore
def portWrite(porta, stato):
porta = int(porta)
if stato == '1':
GPIO.output(porta, GPIO.HIGH)
if stato == '0':
GPIO.output(porta, GPIO.LOW)
if stato == '-1':
GPIO.output(porta, not GPIO.input(porta))
print("Stato cambiato:" + str(GPIO.input(porta)))
return (GPIO.input(porta))
try:
if __name__ == '__main__':
server = SimpleSSLWebSocketServer(
'0.0.0.0', 5000, SimpleServer,
'/etc/letsencrypt/live/my.awesome.domain/cert.pem',
'/etc/letsencrypt/live/my.awesome.domain/privkey.pem',
ssl.PROTOCOL_TLSv1)
server.serveforever()
except KeyboardInterrupt:
GPIO.cleanup()
print "cleaning up gpio before closing"
#queue.declare()
def startMQ(
message
): # Access the CLODUAMQP_URL environment variable and parse it (fallback to localhost)
#for message in Queue(mainchannel,'broadcast-all'):
print("message from process")
message.ack()
broadcast(message.body)
def startMQ1():
print("starting to listen")
mainchannelout.basic.consume(startMQ, 'broadcast-all', no_ack=False)
mainchannelout.start_consuming()
print("listening done")
mq = threading.Thread(target=startMQ1)
mq.start()
server = SimpleSSLWebSocketServer(
"",
8800,
SimpleChat,
"/etc/letsencrypt/live/api.ooblex.com/fullchain.pem",
"/etc/letsencrypt/live/api.ooblex.com/privkey.pem",
version=ssl.PROTOCOL_TLSv1)
server.serveforever()
def start_server():
parser = OptionParser(usage="usage: %prog [options]", version="%prog 1.0")
parser.add_option("--host",
default='',
type='string',
action="store",
dest="host",
help="hostname (localhost)")
parser.add_option("--port",
default=9001,
type='int',
action="store",
dest="port",
help="port (9001)")
parser.add_option("--example",
default='echo',
type='string',
action="store",
dest="example",
help="echo, chat")
parser.add_option("--ssl",
default=0,
type='int',
action="store",
dest="ssl",
help="ssl (1: on, 0: off (default))")
parser.add_option("--cert",
default='./cert.pem',
type='string',
action="store",
dest="cert",
help="cert (./cert.pem)")
parser.add_option("--ver",
default=ssl.PROTOCOL_TLSv1,
type=int,
action="store",
dest="ver",
help="ssl version")
(options, args) = parser.parse_args()
os.system("rm ./unix_socket")
cls = SimpleEcho
if options.example == 'chat':
cls = SimpleChat
if options.ssl == 1:
server = SimpleSSLWebSocketServer(options.host,
options.port,
cls,
options.cert,
options.cert,
version=options.ver)
else:
server = SimpleWebSocketServer(options.host, options.port, cls)
# def close_sig_handler(signal, frame):
# server.close()
# sys.exit()
# serverThread = threading.Thread(target=other_thread)
# serverThread.daemon = True
# serverThread.start()
#signal.signal(signal.SIGINT, close_sig_handler)
server.serveforever()
action="store",
dest="key",
help="key (./key.pem)")
parser.add_option("--ver",
default=ssl.PROTOCOL_TLSv1,
type=int,
action="store",
dest="ver",
help="ssl version")
(options, args) = parser.parse_args()
if options.ssl == 1:
server = SimpleSSLWebSocketServer(options.host,
options.port,
ZJUSPCServer,
options.cert,
options.key,
version=options.ver)
else:
server = SimpleWebSocketServer(options.host, options.port,
ZJUSPCServer)
def close_sig_handler(signal, frame):
server.close()
sys.exit()
signal.signal(signal.SIGINT, close_sig_handler)
threading._start_new_thread(cluster.dispatchData, ())
print("start server")
server.serveforever()
wiringpi.wiringPiSetup()
wiringpi.pinMode(LED_GRN, OUTPUT)
wiringpi.digitalWrite(LED_GRN, OFF)
def setPin(pin_name, pin_state):
wiringpi.digitalWrite(pin_name, pin_state)
class socketHandler(WebSocket):
def handleMessage(self):
# echo message back to client
msg = self.data
if msg == "ledon":
wiringpi.digitalWrite(LED_GRN, ON)
elif msg == "ledoff":
wiringpi.digitalWrite(LED_GRN, OFF)
self.sendMessage(msg)
def handleConnected(self):
print(self.address, 'connected')
def handleClose(self):
print(self.address, 'closed')
init()
wssServer = SimpleSSLWebSocketServer('', 9800, socketHandler,
'/home/pi-box/cert/certificate.crt',
'/home/pi-box/cert/private.key')
wssServer.serveforever()
def handleClose(self):
try:
os.remove(self.verifyPath)
self.running = 0
except:
pass
if __name__ == "__main__":
pidfile = '/usr/local/CyberCP/WebTerminal/pid'
writeToFile = open(pidfile, 'w')
writeToFile.write(str(os.getpid()))
writeToFile.close()
SSHServer.findSSHPort()
server = SimpleSSLWebSocketServer('0.0.0.0',
'5678',
WebTerminalServer,
'/usr/local/lscp/conf/cert.pem',
'/usr/local/lscp/conf/key.pem',
version=ssl.PROTOCOL_TLSv1)
def close_sig_handler(signal, frame):
server.close()
sys.exit()
signal.signal(signal.SIGINT, close_sig_handler)
server.serveforever()
def processMessage(message):
print("message from process")
message.ack()
try:
sendClient(message.body)
except:
print("error with sendClient")
def checkMessages():
mainChannel_in.basic.consume(processMessage, 'broadcast-all', no_ack=False)
mainChannel_in.start_consuming()
mq = threading.Thread(target=checkMessages)
mq.start()
print("Main API server starting")
server = SimpleSSLWebSocketServer(
"",
8800,
SimpleChat,
"/etc/letsencrypt/live/" + config.DOMAIN_CONFIG['domain'] +
"/fullchain.pem",
"/etc/letsencrypt/live/" + config.DOMAIN_CONFIG['domain'] + "/privkey.pem",
version=ssl.PROTOCOL_TLSv1)
server.serveforever()
print("API.py STOPPED!!!!!!!!")
state = parse_state( self.data )
action = rl_test(state)
self.sendMessage( str(action) ) # send action as string
def handleConnected(self):
print( str(datetime.now()), self.address, 'connected')
def handleClose(self):
print( str(datetime.now()), self.address, 'closed')
def parse_state(s):
state = s
return state
def rl_test(state):
return "500"
if __name__ == "__main__":
host = ''
port = 8000
cert = "./cert.pem"
key = "./cert.pem"
ver = ssl.PROTOCOL_TLSv1
server = SimpleSSLWebSocketServer(host, port, SimpleWSS, cert, key, version=ver)
def close_sig_handler(signal, frame):
server.close()
sys.exit()
signal.signal(signal.SIGINT, close_sig_handler)
server.serveforever()
parser.add_argument(
'--sslver', type=int, default=ssl.PROTOCOL_TLSv1_2,
help="SSL Protocol Version (example: 5)")
args = parser.parse_args()
address, port = args.listen.split(':')
if not address:
address = ''
port = int(port) if port else 8989
print("Starting server at " + address + ":" + str(port))
if(args.ssl):
print("SSL Enabled")
if args.ssl:
server = SimpleSSLWebSocketServer(address, port, SimpleServer, args.cert, args.key, version=args.sslver)
else:
server = SimpleWebSocketServer(address, port, SimpleServer)
ser = serial.Serial(args.port, baudrate = args.baud, timeout=1)
device = ser.name
serial = serial.threaded.ReaderThread(ser, SimpleSerial)
serial.start()
def close_sig_handler(signal, frame):
serial.close()
server.close()
sys.exit(0)
signal.signal(signal.SIGINT, close_sig_handler)
server.serveforever()
result = json.loads(translated)
result['server'] = server
result['source'] = fromLang
result['target'] = toLang
self.sendMessage(json.dumps(result, sort_keys=True, indent=4))
except ValueError as error:
print("invalid json: %s" % error)
self.sendMessage(
json.dumps({'result': 'ERROR: {}'.format(error)},
sort_keys=True,
indent=4))
def handleConnected(self):
print(self.address, 'connected')
def handleClose(self):
print(self.address, 'closed')
if args.ssl == 1:
print("open ssl connection with version " + str(args.ver))
server = SimpleSSLWebSocketServer('',
args.port,
Translate,
args.cert,
args.key,
version=args.ver)
else:
server = SimpleWebSocketServer('', args.port, Translate)
server.serveforever()
def handleMessage(self):
print(self.address, self.data)
if ':' in self.data:
data = self.data
seperatedData = data.split(':')
returnMessage = handlecommand(seperatedData[0], seperatedData[1],
self)
# Handling closing via command
if returnMessage == 'close':
print(self.address, "Disconnected")
self.sendMessage(u'Returned:' + returnMessage)
self.handleClosed()
self.sendMessage(u'Returned:' + returnMessage)
# Update the certificate files in the config
# In order to use SSL you'll need to link the ip to a domain and SSL the domain.
if sslEnable:
server = SimpleSSLWebSocketServer(ipToListenOn, portToListenOn,
DaemonWebsocketService, sslCert, sslKey)
print("Websockets Live and listening on port: " + str(portToListenOn))
else:
server = SimpleWebSocketServer(ipToListenOn, portToListenOn,
DaemonWebsocketService)
print("Websockets Live and listening on port: " + str(portToListenOn))
server.serveforever()
serverImages[serverId] = images
return serverImages
def sendDataToServers(self, servers, data):
# loop servers
for (serverId, images) in enumerate(data):
serverWS = modelServerWS[serverId]
serverWS.sendData(images)
def getServerAdress(self, servers, id):
# loop servers
for (i, server) in enumerate(servers):
serverId = server['id']
serverAdress = server['address']
if (serverId == id):
break
return serverAdress
cls = UdssServer
host = 'localhost'
port = 9000
cert = '../cert/cert.pem'
key = '../cert/key.pem'
protocol = ssl.PROTOCOL_TLSv1
print("Starting UDSS main server ...")
server = SimpleSSLWebSocketServer(host, port, cls, cert, key, version=protocol)
server.serveforever()
parser.add_option("--ver",
default=ssl.PROTOCOL_TLSv1,
type=int,
action="store",
dest="ver",
help="ssl version")
(options, args) = parser.parse_args()
cls = SimpleEcho
if options.example == 'chat':
cls = SimpleChat
if options.ssl == 1:
server = SimpleSSLWebSocketServer(options.host,
options.port,
cls,
options.cert,
options.cert,
version=options.ver)
else:
server = SimpleWebSocketServer(options.host, options.port, cls)
def close_sig_handler(signal, frame):
server.close()
sys.exit()
signal.signal(signal.SIGINT, close_sig_handler)
server.serveforever()
os._exit(1)
try:
print("- Reading SSL/TLS key...")
with open(key) as f:
pass
except:
print("!! FAILED TO READ SSL/TLS PRIVATE KEY!!")
print("Hard exiting...")
os._exit(1)
print("SSL/TLS check was successfull.")
print("- Starting secure websocket server (WSS) on port 8000...")
server = SimpleSSLWebSocketServer('', 8000, SimpleServer, cert, key)
thread.start_new_thread(server.serveforever, ())
print("- Starting music server...")
thread.start_new_thread(start_mopidy, ())
time.sleep(6)
#websocketclient.enableTrace(True)
ws = websocketclient.WebSocketApp("ws://localhost:6680/mopidy/ws",
on_message=message_thread,
on_error=on_error,
on_close=on_close)
ws.on_open = on_open
connected = False
while (connected == False):
print("-- Checking for running server...")
print n
def handleClose(self):
print self.address, 'closed'
for client in self.server.connections.itervalues():
if client != self:
try:
client.sendMessage(
str(self.address[0]) + ' - disconnected')
except Exception as n:
print n
host = 'localhost'
port = 5000
server = SimpleSSLWebSocketServer(host, port, SimpleChat)
def close_sig_handler(signal, frame):
server.close()
sys.exit()
signal.signal(signal.SIGINT, close_sig_handler)
#server.serveforever()
# Controllers
@app.errorhandler(404)
def page_not_found(error):
