def runserver(socket_port, websocket_port):
SOCKET_PORT = socket_port
WEBSOCKET_PORT = websocket_port
server = WebSocketServer('', WEBSOCKET_PORT, Bridge)
server.serve_forever()
class UnityServer:
def __init__(self, host: str, port: int):
self.logger = logging.getLogger("Unity Streamer")
self.host = host
self.port = port
self.server = WebSocketServer(self.host, self.port,
SimpleUnityWebsocketServer)
self.thread = threading.Thread(target=self.start, args=())
self.logger.debug("Unity Server Initiated")
def get_control(self):
c = VehicleControl(throttle=throttle, steering=steering)
return c
def update_frame(self, new_frame):
global frame
frame = new_frame
def start(self):
self.logger.debug("Unity Server Started")
self.server.serve_forever()
def shutdown(self):
self.server.close()
self.thread.join()
def startAsync(self):
self.thread.start()
def init_project():
server = WebSocketServer('127.0.0.1',
8000,
WafcamSocket,
select_interval=None)
launch(test_config, server)
server.serve_forever()
def init_project():
db_config = database_utils.read_env()
server = WebSocketServer('127.0.0.1',
8000,
WafcamSocket,
select_interval=None)
launch(db_config, server)
server.serve_forever()
class AnkiSocketServer(QThread):
msgHandler = pyqtSignal(str)
def run(self):
global PORT
self.server = WebSocketServer('', (PORT + 1), SimpleAnki)
print("AnkiSocketServer run on port: " + str(PORT + 1))
self.server.serve_forever()
def __init__(self, host: str, port: int):
self.logger = logging.getLogger("Unity Streamer")
self.host = host
self.port = port
self.server = WebSocketServer(self.host, self.port,
SimpleUnityWebsocketServer)
self.thread = threading.Thread(target=self.start, args=())
self.logger.debug("Unity Server Initiated")
def main():
server_tool = WebSocketServer('192.168.43.238', 8000,
WebSocketManagerBuzzer)
thread_tool = Thread(target=server_tool.serve_forever)
server_buzzer = WebSocketServer('192.168.43.238', 8001,
WebSocketManagerBuzzer)
thread_buzzer = Thread(target=server_buzzer.serve_forever)
input()
thread_tool.start()
thread_buzzer.start()
def __init__(self) -> None:
"""Initialize the service."""
self._routes: Dict[str, Callable] = {}
self._re_routes: Dict[Pattern[str], Callable] = {}
self._lock = RLock()
_stop_event = self._stop_event = threading.Event()
class _WebsocketImpl(_WebsocketTemplate):
_get_generator = WeakMethod(self._get_generator) # type: ignore
server = self._server = WebSocketServer("0.0.0.0", 0, _WebsocketImpl)
self.port = server.serversocket.getsockname()[1]
# serve_forever() doesn't let you close the server without throwing
# an exception >.<
def loop() -> None:
while not _stop_event.is_set():
server.handle_request()
self._thread = threading.Thread(target=loop, daemon=True)
for client in self.clients:
if client != self:
client.send_message(self.data)
def lightSeats()
pass
def doAnimation(animation, **params):
pass
def on(color,style=None):
pass
def off(color, style=None):
pass
def connected(self):
#for client in self.clients:
# client.send_message("new client Connected");
self.clients.append(self)
def handle_close(self):
self.clients.remove(self)
#for client in self.clients:
#client.send_message(self.address[0] + u" - disconnected")
server = WebSocketServer("", 8000, SimpleChat)
server.serve_forever()
#self.send_message(self.data)
print(self.data)
trama = self.data
def connected(self):
print(self.address, 'connected')
clients.append(self)
print(clients)
def handle_close(self):
print(self.address, 'closed')
clients.remove(self)
trama = ""
server = WebSocketServer('192.168.0.230', 8000, MyWebSocket)
def websocket_server():
while (1):
server.handle_request()
def read_text_input():
while (1):
text = input()
for client in list(clients):
client.send_message(text)
print("texto enviado", text)
from simple_websocket_server import WebSocketServer, WebSocket
# import asyncio
class SimpleEcho(WebSocket):
def handle(self):
# echo message back to client
# self.send_message(self.data)
print(self.data)
def connected(self):
print(self.address, 'connected')
def handle_close(self):
print(self.address, 'closed')
server = WebSocketServer('', 8000, SimpleEcho)
server.serve_forever()
from simple_websocket_server import WebSocketServer, WebSocket
from ChatBot import get_response
class ChatServer(WebSocket):
def handleMessage(self):
message = self.data
response = get_response(message)
self.sendMessage(response)
def handleConnected(self):
print(self.address, 'connected')
def handleClose(self):
print(self.address, 'closed')
server = WebSocketServer('', 8000, ChatServer)
server.serve_forever()
def ws_server():
print('Start Websocket server at ' + ip + ' 8001.')
server = WebSocketServer(ip, 8001, WsServer)
server.serve_forever()
def work(data):
server = WebSocketServer('0.0.0.0', 5124, SimpleEcho, data)
server.serve_forever()
def runServer():
print("Main:: Started backend WS server. Listening at port: 8765")
server = WebSocketServer('192.168.0.122', 8765, WSServer)
server.serve_forever()
self.ui.close()
if __name__ == '__main__':
parser = OptionParser(usage='usage: %prog [options]')
parser.add_option('--host',
default='',
type='string',
action='store',
dest='host',
help='hostname (localhost)')
parser.add_option('--port',
default=9503,
type='int',
action='store',
dest='port',
help='port (9503)')
(options, args) = parser.parse_args()
sslopts = {}
server = WebSocketServer(options.host, options.port, WebKeyboard,
**sslopts)
def close_sig_handler(signal, frame):
server.close()
sys.exit()
signal.signal(signal.SIGINT, close_sig_handler)
server.serve_forever()
def server_thread(port):
server = WebSocketServer('', port, ws_Server)
print ("Starting Web socket server")
server.serve_forever()
global duplicates
global new_dupes
print(new_dupes)
duplicates = new_dupes
new_dupes = []
class Server(WebSocket):
def handle(self):
print("MSG " + self.data)
for ws in connections:
ws.send_message("MSG " + self.data)
def connected(self):
print(self.address, 'connected')
connections.append(self)
def handle_close(self):
print(self.address, 'closed')
connections.remove(self)
print("Listening on PORT " + os.getenv('PORT') + " ...")
handler = Handler()
handler.start()
server = WebSocketServer("", os.getenv('PORT'), Server)
server.serve_forever()
from simple_websocket_server import WebSocketServer, WebSocket
class SimpleEcho(WebSocket):
def handle(self):
# echo message back to client
self.send_message(self.data)
def connected(self):
print(self.address, 'connected')
def handle_close(self):
print(self.address, 'closed')
server = WebSocketServer('127.0.0.1', 5678, SimpleEcho)
server.serve_forever()
from simple_websocket_server import WebSocketServer, WebSocket
import base64
from cv2 import cv2
import numpy as np
import warnings
warnings.simplefilter('ignore', DeprecationWarning)
class SimpleEcho(WebSocket):
def handle(self):
msg = self.data
img = cv2.imdecode(
np.fromstring(base64.b64decode(msg.split(',')[1]), np.uint8),
cv2.IMREAD_COLOR)
cv2.imshow('image', img)
cv2.waitKey(1)
def connected(self):
print(self.address, 'Connected')
def handle_close(self):
print(self.address, 'Closed')
server = WebSocketServer('localhost', 3000, SimpleEcho)
server.serve_forever()
else:
master = process.stdout
Thread(target=updater).start()
http_port = 9000
socket_port = 9090
opts, args = getopt.getopt(sys.argv[1:], '', ['http_port=', 'socket_port='])
for opt, arg in opts:
if opt == '--http_port':
http_port = int(arg)
elif opt == '--socket_port':
socket_port = int(arg)
http_thread = Thread(
target=lambda: MyHTTPServer(('', http_port)).serve_forever())
http_thread.daemon = True
http_thread.start()
print('HTTP listening on {}'.format(http_port))
socket_thread = Thread(target=lambda: WebSocketServer(
'0.0.0.0', socket_port, WebSocketHandler).serve_forever())
socket_thread.daemon = True
socket_thread.start()
print('WebSocket listening on {}'.format(socket_port))
while True:
time.sleep(1)
def main():
server = WebSocketServer('127.0.0.1', 8009, SimpleEcho)
server.serve_forever()
# -*- coding: utf-8 -*-
"""
Created on Wed Jun 26 08:52:19 2019
@author: janto
"""
from simple_websocket_server import WebSocketServer, WebSocket
class ssbt_socket_face_id(WebSocket):
def handle(self):
# echo message back to client
self.send_message(self.data)
def connected(self):
print(self.address, 'connected')
def handle_close(self):
print(self.address, 'closed')
server = WebSocketServer('127.0.0.1', 61613, ssbt_socket_face_id)
server.serve_forever()
print(self.address, 'closed')
class SimpleChat(WebSocket):
def handle(self):
for client in clients:
if client != self:
client.send_message(self.data)
def connected(self):
print(self.address, 'connected')
for client in clients:
client.send_message(self.address[0] + u' - connected')
clients.append(self)
def handle_close(self):
clients.remove(self)
print(self.address, 'closed')
for client in clients:
client.send_message(self.address[0] + u' - disconnected')
clients = []
sslopts = dict(certfile="/home/romain/cert.pem",
keyfile="/home/romain/key.pem",
ssl_version=ssl.PROTOCOL_TLSv1)
server = WebSocketServer('172.25.28.5', 443, SimpleChat, **sslopts)
server.serve_forever()
class ReRouter(WebSocket):
def handle(self):
# osc channel
channel = self.data[0:5].decode("utf-8")
# message type
msg_type = self.data[9:10].decode("utf-8")
# get message
number = struct.unpack(">f", self.data[12:])[0]
print(
"msg from " + channel + ". type: " + msg_type + ", with value:>>",
round(number, 2),
)
# from p5 to weki
print("Sending to weki ", channel)
client.send_message(channel, round(float(number), 2))
def connected(self):
print(self.address, "connected")
def handle_close(self):
print(self.address, "closed")
while True:
print(f"[*] I listen inputs from p5 in localhost:{p5_port}")
print(f"[*] I reroute msgs to wekinator, in localhost:{weki_port}")
server = WebSocketServer("", p5_port, ReRouter)
server.serve_forever()
@app.route('/static/<path:path>')
def send_js(path):
return send_from_directory('static', path)
connections = []
class SimpleEcho(WebSocket):
def handle(self):
# echo message back to client
print("received data:" + self.data)
for connection in connections:
connection.send_message(self.data)
def connected(self):
connections.append(self)
def handle_close(self):
connections.remove(self)
server = WebSocketServer('', 5001, SimpleEcho)
# start websocket server
threading.Thread(target=server.serve_forever).start()
# start flask server
threading.Thread(target=app.run, args=("0.0.0.0", )).start()
class SimpleEcho(WebSocket):
def handle(self):
# echo message back to client
l[0] = self.data
print l[0][2]
def connected(self):
print(self.address, 'connected')
def handle_close(self):
print(self.address, 'closed')
server = WebSocketServer('', 8000, SimpleEcho)
def srvr():
server.serve_forever()
def engine():
while True:
if l[0][2] == "R":
tmp = l[0]
tmp = tmp.encode('latin1')
js = yaml.safe_load(tmp)
a = list(js["Events"].keys())
NoE = len(js["Events"])
del server.clients[name]
open_lobbies = {}
address = socket.gethostbyname(socket.gethostname())
parser = OptionParser(usage='usage: %prog [options]', version='%prog 1.0.0')
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('--key', default='./key.pem', type='string', 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')
parser.add_option('--localhost', default=False, action='store_true', dest='localhost', help='whether to use localhost')
parser.add_option('--port', default=11000, type=int, action='store', dest='port', help='server port')
(options, args) = parser.parse_args()
sslopts = {}
if options.ssl == 1:
sslopts = dict(certfile=options.cert, keyfile=options.key, ssl_version=options.ver)
if options.localhost: address = "127.0.0.1"
print(f"Running at {address}:{options.port} {'(using TLS/SSL)' if options.ssl == 1 else '(not using TLS/SSL)'}")
server = WebSocketServer(address, options.port, MultiplayerServer, **sslopts)
def keyboardInterruptHandler(signal, frame):
print("KeyboardInterrupt (ID: {}) has been caught. Cleaning up...".format(signal))
server.close()
print("Clean up complete, terminating...")
sys.exit()
signal.signal(signal.SIGINT, keyboardInterruptHandler)
server.serve_forever()
if jsn['value'] is not None:
self.__i = jsn['value']
self.send_message('{"success": True}')
self.f()
except Exception as e:
print('???', e)
def connected(self):
print(self.address, 'connected')
def handle_close(self):
print(self.address, 'closed')
def f(self):
print('f', self.__i)
self.__i += 1
self.send_message('{"value": ' + str(self.__i) + '}')
t = threading.Timer(0.2, self.f)
t.start()
if __name__ == "__main__":
server_address = ''
server_port = 8000
server = WebSocketServer(server_address, server_port, SimpleEcho)
print('serving at %s:%d' % (server_address, server_port))
server.serve_forever()
from simple_websocket_server import WebSocketServer, WebSocket
import json
import threading
class BtcWebScoket(WebSocket):
def handle(self):
try:
print(self.data)
msg = json.loads(self.data)
msgType = msg['MsgType']
if msgType == 'PEER_INFO':
self.send_message('peer_info')
# self.send_message(json.dumps({
# 'PEERS_IN':PEERS_IN,
# 'PEERS_OUT':PEERS_OUT
# }))
except Exception as ex:
print(ex)
def connected(self):
print(self.address, 'connected')
def handle_close(self):
print(self.address, 'closed')
ws = WebSocketServer('', 9675, BtcWebScoket)
wst = threading.Thread(target=ws.serve_forever)
wst.start()
