def start_server(address, port):
# see http://autobahn.ws/python/websocket/programming.html
# accept both string and int, since client has to accept int
if isinstance(port, int):
port = str(port)
global lobby_count
lobby_count = 0
composite_address = 'ws://' + address + ':' + port
info("starting websocket server at {}".format(composite_address), INFO_ID)
factory = WebSocketServerFactory(composite_address)
factory.protocol = GameServerProtocol
loop = asyncio.new_event_loop()
asyncio.set_event_loop(loop)
loop = asyncio.get_event_loop()
coro = loop.create_server(factory, address, port)
server = loop.run_until_complete(coro)
try:
loop.run_forever()
except KeyboardInterrupt:
info('cleaning up.', INFO_ID)
finally:
server.close()
loop.close()
def main(*args):
"""
Starts the autobahn websockets server, and the receive loop for zeroMQ.
Defaults for the ZeroMQ address (also overridable via commandline) and the
websockets server can be overridden in the settings module.
"""
receive_loop = threading.Thread(target=backend.receive_loop, args=args)
receive_loop.start()
factory = WebSocketServerFactory()
factory.protocol = GraphProtocol
loop = asyncio.get_event_loop()
coro = loop.create_server(factory, *settings.WEBSOCKETS_ADDRESS)
server = loop.run_until_complete(coro)
try:
print('Starting the websockets server on %s:%d' % settings.WEBSOCKETS_ADDRESS)
loop.run_forever()
except KeyboardInterrupt:
pass
finally:
print('Closing down the websockets server')
server.close()
loop.close()
sys.exit(0)
def startWebsocketServer():
print(blue("Websocket server starting up..."))
try:
import asyncio
except ImportError:
## Trollius >= 0.3 was renamed
import trollius as asyncio
#Asyncio only setups an event loop in the main thread, else we need to
if threading.current_thread().name != 'MainThread':
loop = asyncio.new_event_loop()
asyncio.set_event_loop(loop)
factory = WebSocketServerFactory("ws://0.0.0.0:9000", debug = False)
factory.protocol = TranslatronProtocol
loop = asyncio.get_event_loop()
server = loop.create_server(factory, '0.0.0.0', 9000)
server = loop.run_until_complete(server)
try:
loop.run_forever()
except KeyboardInterrupt:
pass
finally:
server.close()
loop.close()
def talker(self):
# In ROS, nodes are uniquely named. If two nodes with the same
# node are launched, the previous one is kicked off. The
# anonymous=True flag means that rospy will choose a unique
# name for our 'talker' node so that multiple talkers can
# run simultaneously.
rospy.init_node('blockly_server', anonymous=True)
rospy.Subscriber("blockly", String, RobotBlocklyBackend.callback)
CodeStatus.initialize_publisher()
self.__current_block_publisher = rospy.Publisher('current_block_id', String, queue_size=5)
rospy.Service('program_is_paused', Trigger, RobotBlocklyBackend.__is_status_paused)
rospy.Service('program_completed', Empty, RobotBlocklyBackend.__set_status_completed)
rospy.Service('program_set_current_block_id', SetCurrentBlockId, self.__set_current_block_id)
factory = WebSocketServerFactory(u"ws://0.0.0.0:9000", debug=False)
factory.protocol = BlocklyServerProtocol
loop = asyncio.get_event_loop()
coro = loop.create_server(factory, '0.0.0.0', 9000)
server = loop.run_until_complete(coro)
asyncio.async(RobotBlocklyBackend.wait_until_ros_node_shutdown(loop))
loop.run_forever()
print("Closing...")
server.close()
loop.run_until_complete(server.wait_closed())
loop.close()
def start(self):
self.print_debug("start() called... debug = {}".format(self.debug))
ws = "ws"
sslcontext = None
if self.ssl:
try:
sslcontext = ssl.SSLContext(ssl.PROTOCOL_SSLv23)
sslcontext.load_cert_chain(self.sslcert, self.sslkey)
self.print_debug("using ssl")
except Exception as ex:
sslcontext = None
self.print_debug("failed to use ssl")
raise Exception("failed to use ssl: {}".format(ex))
ws = "wss"
ResourceProtocol.server = self
factory = WebSocketServerFactory(u"{0}://127.0.0.1:{1}".format(ws, self.port))
factory.protocol = ResourceProtocol
loop = asyncio.get_event_loop()
coro = loop.create_server(factory, '', self.port, ssl=sslcontext)
self.server = loop.run_until_complete(coro)
self.print_debug("server should be started now")
def start_websocket_server():
"""Function to start the websocket server."""
import asyncio
if not os.path.exists(LOGFOLDER):
os.makedirs(LOGFOLDER)
logging.basicConfig(filename=LOGFOLDER+ "/" + WEBSOCKETLOG,level=LOGLEVEL)
logging.info("Starting Server")
loop = asyncio.new_event_loop()
asyncio.set_event_loop(loop)
factory = WebSocketServerFactory(
u"ws://127.0.0.1:" + str(PORT) + "/" + WS_URL, DEBUG)
factory.protocol = GraphalyzerServerProtocol
coro = loop.create_server(factory, '0.0.0.0', PORT)
server = loop.run_until_complete(coro)
try:
logging.info("Server started")
loop.run_forever()
except KeyboardInterrupt:
pass
finally:
logging.info("Server shutting down")
server.close()
loop.close()
def main():
loop = asyncio.get_event_loop()
db = loop.run_until_complete(
aiozmq.rpc.connect_rpc(
connect=os.environ['DBSERVER_PORT_5000_TCP'],
translation_table=translation_table,
timeout=5))
# Is this good idea to have one connection?
game = loop.run_until_complete(
aiozmq.rpc.connect_rpc(
connect=os.environ['GAME_PORT_5200_TCP'],
translation_table=translation_table,
error_table=error_table,
timeout=5))
def create_protocol(*args, **kwargs):
return FrontendHandler(db=db, game=game, *args, **kwargs)
factory = WebSocketServerFactory(
url='ws://{}:{}'.format(os.environ['FRONTEND_ADDR'], os.environ['FRONTEND_PORT']),
loop=loop)
factory.protocol = create_protocol
server = loop.run_until_complete(
loop.create_server(factory, '0.0.0.0', os.environ['FRONTEND_PORT']))
try:
loop.run_forever()
except KeyboardInterrupt:
pass
finally:
server.close()
loop.close()
def talker():
# In ROS, nodes are uniquely named. If two nodes with the same
# node are launched, the previous one is kicked off. The
# anonymous=True flag means that rospy will choose a unique
# name for our 'talker' node so that multiple talkers can
# run simultaneously.
rospy.init_node("blockly_server", anonymous=True)
rospy.Subscriber("blockly", String, callback)
try:
import asyncio
except ImportError:
# Trollius >= 0.3 was renamed
import trollius as asyncio
factory = WebSocketServerFactory(u"ws://0.0.0.0:9000", debug=False)
factory.protocol = BlocklyServerProtocol
loop = asyncio.get_event_loop()
coro = loop.create_server(factory, "0.0.0.0", 9000)
server = loop.run_until_complete(coro)
try:
loop.run_forever()
except KeyboardInterrupt:
pass
finally:
server.close()
loop.close()
def launch_server():
loop = asyncio.new_event_loop()
asyncio.set_event_loop(loop)
factory = WebSocketServerFactory()
factory.protocol = MyServerProtocol
coro = loop.create_server(factory, WS_HOST, WS_PORT)
server = loop.run_until_complete(coro)
loop.run_forever()
def __init__(self, config, *args, **kwargs):
WebSocketServerFactory.__init__(self, *args, **kwargs)
for module_name, module_data in config["modules"].items():
module_import_name = re.sub('(?!^)([A-Z]+)', r'_\1', module_data["type"]).lower()
self.modules[module_name] = module_data
module_module = importlib.import_module("modules."+module_import_name)
module_object = getattr(module_module, module_data["type"])
self.modules[module_name]["module_object"] = module_object(**module_data)
def __init__(self, url, config="config.json", *args, **kwargs):
WebSocketServerFactory.__init__(self, url, *args, **kwargs)
self.clients = []
with open(config) as configfile:
self.config.update(json.load(configfile))
self.config['switchModule'] = importlib.import_module(self.config['switchModule'])
for name in self.config["switches"]:
switch_config = self.config['switches'][name]
switch_class = switch_config['class']
initial_data = switch_config
switch = getattr(self.config["switchModule"], switch_class)(initial_data=initial_data, name=name, factory=self)
self.config['switches'][name]['class'] = switch
def __init__(self, config_file):
# init before get called
self.contexts = {}
self.context_subscriptions = {}
Application.__init__(self, config_file)
WebSocketServerFactory.__init__(self)
#greenlet.greenlet.__init__(self)
# start the separate tasker process
IN.tasker.start_the_process()
def main():
factory = WebSocketServerFactory()
factory.protocol = MyServerProtocol
loop = asyncio.get_event_loop()
coro = loop.create_server(factory, '127.0.0.1', 8765)
server = loop.run_until_complete(coro)
loop.run_until_complete(asyncio.gather(*[listen_command(),
read_command(),
# write_command(),
print_stats()]))
loop.run_forever()
loop.close()
server.close()
def run_liveview_server(liveview_url):
# set new event loop because there is no default event loop.
# asyncio.set_event_loop(asyncio.new_event_loop())
factory = WebSocketServerFactory("ws://localhost:9000", debug=False)
factory.protocol = LiveviewServerProtocol(liveview_url)
loop = asyncio.get_event_loop()
coro = loop.create_server(factory, "127.0.0.1", 9000)
server = loop.run_until_complete(coro)
loop.run_forever()
server.close()
loop.close()
def main():
config = load_configuration()
ServerState.logger = get_logger(config, 'CoreWS')
address = config.get('CoreWS', 'address', '0.0.0.0')
port = int(config.get('CoreWS', 'port', '9000'))
mq_servers = comma_string_to_list(config.get('CoreMQ', 'cluster_nodes', '').split(','))
ServerState.logger.info('CoreWS Starting up...')
ws_factory = WebSocketServerFactory('ws://%s:%s/ws' % (address, port))
ws_factory.protocol = WsProtocol
loop = asyncio.get_event_loop()
server_coro = loop.create_server(ws_factory, address, port)
server = loop.run_until_complete(server_coro)
ServerState.logger.info('WebSocket Server running')
mq_factory = CoreMqClientFactory(WsMqClient, mq_servers, loop=loop)
@asyncio.coroutine
def connect(*args):
ServerState.mq_connection = None
while True:
yield asyncio.From(mq_factory.connect())
if not mq_factory.connection:
ServerState.logger.warn('No CoreMQ servers found. Retrying in 3 seconds...')
yield asyncio.From(asyncio.sleep(3))
else:
conn = mq_factory.connection[1]
conn.connected_future.add_done_callback(
lambda _: conn.begin_replication('%s:%s' % (socket.gethostname(), port))
)
ServerState.mq_connection = conn
break
mq_factory.lost_connection_callback = connect
loop.run_until_complete(connect())
try:
loop.run_forever()
except KeyboardInterrupt:
pass
finally:
ServerState.logger.info('Shutting down WebSocket Server...')
server.close()
ServerState.logger.info('Shutting down MQ Client...')
mq_factory.close()
loop.close()
ServerState.logger.info('CoreWS is now shut down')
def _start_loop(config: ConfigParser, port: int, pid_file: str):
try:
database = _get_zodb_database(config)
ClientCommunicator.zodb_database = database
rest_url = _get_rest_url(config)
ClientCommunicator.rest_url = rest_url
factory = WebSocketServerFactory('ws://localhost:{}'.format(port))
factory.protocol = ClientCommunicator
loop = asyncio.get_event_loop()
coro = loop.create_server(factory, port=port)
logger.debug('Started WebSocket server listening on port %i', port)
server = loop.run_until_complete(coro)
_run_loop_until_interrupted(loop, server)
finally:
logger.info('Stopped WebSocket server')
_remove_pid_file(pid_file)
def startWebSocketServer(address, port):
print("Starting WebSocket server...")
factory = WebSocketServerFactory()
factory.protocol = RobotServerProtocol
loop = asyncio.get_event_loop()
coro = loop.create_server(factory, address, port)
server = loop.run_until_complete(coro)
try:
loop.run_forever()
except KeyboardInterrupt:
pass
finally:
server.close()
loop.close()
setdefault()
ledDisplay.shutOff()
def main():
PORT = 8765
factory = WebSocketServerFactory('ws://localhost:%d' % PORT)
factory.protocol = TestProtocol
loop = asyncio.get_event_loop()
start_server = loop.create_server(factory, '127.0.0.1', PORT)
server = loop.run_until_complete(start_server)
try:
loop.run_forever()
except KeyboardInterrupt:
pass
finally:
server.close()
loop.close()
def installer_service(): from autobahn.asyncio.websocket import WebSocketServerFactory loop = asyncio.get_event_loop() factory = WebSocketServerFactory() factory.protocol = InstallServerProtocol loop.set_debug(True) print "Starting" coro = loop.create_server(factory, '127.0.0.1', 9190) server = loop.run_until_complete(coro) try: loop.run_forever() except KeyboardInterrupt: server.close() loop.close() finally: server.close() loop.close()
def __init__(self, url):
testee_ident = autobahn.asyncio.__ident__
self.log.info("Testee identification: {testee_ident}", testee_ident=testee_ident)
WebSocketServerFactory.__init__(self, url, server=testee_ident)
self.setProtocolOptions(failByDrop=False) # spec conformance
# self.setProtocolOptions(utf8validateIncoming = False)
if USE_STREAMING_TESTEE:
self.setProtocolOptions(failByDrop=True) # needed for streaming mode
else:
# enable permessage-deflate WebSocket protocol extension
def accept(offers):
for offer in offers:
if isinstance(offer, PerMessageDeflateOffer):
return PerMessageDeflateOfferAccept(offer)
self.setProtocolOptions(perMessageCompressionAccept=accept)
def __init__(self, url, debug=False, ident=None):
if ident is not None:
server = ident
else:
server = "AutobahnPython-Asyncio/%s" % autobahn.version
WebSocketServerFactory.__init__(self, url, debug=debug, debugCodePaths=debug, server=server)
self.setProtocolOptions(failByDrop=False) # spec conformance
self.setProtocolOptions(failByDrop=True) # needed for streaming mode
# self.setProtocolOptions(utf8validateIncoming = False)
# enable permessage-deflate
##
def accept(offers):
for offer in offers:
if isinstance(offer, PerMessageDeflateOffer):
return PerMessageDeflateOfferAccept(offer)
self.setProtocolOptions(perMessageCompressionAccept=accept)
def run(args):
use_ssl = Config.get('expose.websocket.pem') != ""
# use an ssl prefix if we have a pem file
if use_ssl:
prefix = "wss"
else:
prefix = "ws"
# build the full URL of the web socket end-point
url = "{0}://{1}:{2}".format(prefix, Config.get('expose.websocket.host'), Config.get('expose.websocket.port'))
logger.info("starting web-socket server at %s", url)
factory = WebSocketServerFactory(url)
factory.protocol = PubSubProtocol
# setup the main event loop for network i/o
loop = asyncio.get_event_loop()
# create an ssl context if we need one
if use_ssl:
context = ssl.create_default_context(ssl.Purpose.CLIENT_AUTH)
context.load_cert_chain(Config.get('expose.websocket.pem'))
logger.debug("using ssl")
else:
context = None
logger.debug("not using ssl")
coro = loop.create_server(factory, host=Config.get('expose.websocket.host'), port=Config.get('expose.websocket.port'), ssl=context)
server = loop.run_until_complete(coro)
# setup publishers coroutines
publishers = create_publishers()
loop.run_until_complete(publishers)
try:
loop.run_forever()
except KeyboardInterrupt:
pass
finally:
publishers.close()
server.close()
loop.close()
def start():
port = get_free_port()
prepare_html(port)
factory = WebSocketServerFactory(u'ws://127.0.0.1:' + str(port))
factory.protocol = MyServerProtocol
loop = asyncio.ProactorEventLoop()
asyncio.set_event_loop(loop)
coro = loop.create_server(factory, '127.0.0.1', port)
logger.info('starting server')
server = loop.run_until_complete(coro)
try:
loop.run_forever()
except KeyboardInterrupt:
pass
finally:
server.close()
loop.close()
def ws_exec():
factory = WebSocketServerFactory()
factory.protocol = MyServerProtocol
t = threading.Thread(target=md_exec,args=())
t.setDaemon(True)
t.start()
loop = asyncio.get_event_loop()
coro = loop.create_server(factory, '127.0.0.1', 9002)
server = loop.run_until_complete(coro)
print("server created")
try:
loop.run_forever()
except KeyboardInterrupt:
pass
finally:
server.close()
loop.close()
def startTwisted(self):
from twisted.python import log
log.startLogging(open("wssserver.log", "w"))
self.print_debug("startTwisted() started")
ws = "ws"
ResourceProtocol.server = self
sslcontext = None
if self.ssl:
self.print_debug("using wss... and ssl")
sslcontext = ssl.DefaultOpenSSLContextFactory(self.sslkey, self.sslcert)
ws = "wss"
factory = WebSocketServerFactory(u"{}://127.0.0.1:{}".format(ws, self.port))
factory.protocol = ResourceProtocol
listenWS(factory, sslcontext)
reactor.run()
def __init__(self, url, zmq_endpoint, server_type, debug=False, debugCodePaths=False):
WebSocketServerFactory.__init__(self, url, debug=debug, debugCodePaths=debugCodePaths)
self.tickcount = 0
self.server_type = server_type
self.cleanClientsTimeout = 1
self.clientMaxTimeout = 30
self.statsTimeout = 1
self.clients = {}
self.context = zmq.Context()
self.recv_context = self.context.socket(zmq.PULL)
self.recv_context.bind(zmq_endpoint)
self.cycleTracker = [0]
self.timeouts = [0]
self.packetLoss = [0]
self.messagesCount = 0
def ws_server(self):
''' Servidor del websocket.
'''
websocket = WebSocketServerFactory(u"ws://127.0.0.1:"+str(self.ws_port), debug=True)
websocket.protocol = WSHandle
websocket.protocol.ensemble=self.ensemble
loop = asyncio.get_event_loop()
coro = loop.create_server(websocket, '0.0.0.0', str(self.ws_port))
ws_server = loop.run_until_complete(coro)
try:
loop.run_forever()
while True:
pass
except KeyboardInterrupt:
pass
finally:
ws_server.close()
loop.close()
def talker():
# In ROS, nodes are uniquely named. If two nodes with the same
# node are launched, the previous one is kicked off. The
# anonymous=True flag means that rospy will choose a unique
# name for our 'talker' node so that multiple talkers can
# run simultaneously.
rospy.init_node('blockly_server', anonymous=True)
rospy.Subscriber("blockly", String, callback)
factory = WebSocketServerFactory(u"ws://0.0.0.0:9000", debug=False)
factory.protocol = BlocklyServerProtocol
loop = asyncio.get_event_loop()
coro = loop.create_server(factory, '0.0.0.0', 9000)
server = loop.run_until_complete(coro)
asyncio.async(wait_until_ros_node_shutdown(loop))
loop.run_forever()
print("Closing...")
server.close()
loop.run_until_complete(server.wait_closed())
loop.close()
def __init__(self, wsPort, lightAnimationController, verbose = False):
# initializations
self.port = wsPort
self.animationController = lightAnimationController
self.beVerbose = verbose
# prepare the web socket protocol
webSocketProtocol = WebSocketProtocol
webSocketProtocol.setReferences(
webSocketProtocol, self, self.animationController, self.beVerbose)
# prepare the web sockets
factory = WebSocketServerFactory()
factory.protocol = webSocketProtocol
# get the host's IP
if config.AUTO_DETECT_HOST_IP:
host = socket.gethostbyname(socket.gethostname())
else:
host = config.HOST_IP
# start the server event loop
loop = asyncio.get_event_loop()
coro = loop.create_server(factory, host, self.port)
wsServer = loop.run_until_complete(coro)
try:
if self.beVerbose:
serverAddressString = host + ':' + str(self.port)
print('WS sever: launched at', serverAddressString)
loop.run_forever()
except KeyboardInterrupt:
pass
finally:
wsServer.close()
loop.close()
def __ne__(self, other):
# Not strictly necessary, but to avoid having both x==y and x!=y
# True at the same time
return not (self == other)
if __name__ == '__main__':
root = logging.getLogger()
root.setLevel(logging.DEBUG)
ch = logging.StreamHandler(sys.stdout)
ch.setLevel(logging.DEBUG)
root.addHandler(ch)
factory = WebSocketServerFactory(u"ws://127.0.0.1:8888")
factory.protocol = MECServerProtocol
loop = asyncio.get_event_loop()
coro = loop.create_server(factory, '127.0.0.1', 8888)
server = loop.run_until_complete(coro)
try:
print 'Server Started...'
loop.run_forever()
except KeyboardInterrupt:
print "Interrupt received... exiting"
finally:
server.close()
loop.stop()
try:
res = yield self.slowsquare(x)
except Exception as e:
self.sendClose(1000, "Exception raised: {0}".format(e))
else:
self.sendMessage(json.dumps(res).encode('utf8'))
if __name__ == '__main__':
try:
import asyncio
except ImportError:
## Trollius >= 0.3 was renamed
import trollius as asyncio
factory = WebSocketServerFactory("ws://localhost:9000", debug=False)
factory.protocol = SlowSquareServerProtocol
loop = asyncio.get_event_loop()
coro = loop.create_server(factory, '127.0.0.1', 9000)
server = loop.run_until_complete(coro)
try:
loop.run_forever()
except KeyboardInterrupt:
pass
finally:
server.close()
loop.close()
def __init__(self, url):
WebSocketServerFactory.__init__(self, url)
self.clients = []
self.tickcount = 0
self.tick()
self.sendMessage(reply.encode('utf8'))
def sonar_callback(self, data):
"""
This method handles sonar data received from pymata_core.
:param data: sonar data callback message
:returns:{"method": "sonar_data_reply", "params": [DATA_VALUE]}
"""
reply = json.dumps({"method": "sonar_data_reply", "params": data})
self.sendMessage(reply.encode('utf8'))
if __name__ == '__main__':
ws_string = 'ws://' + PymataIOT.ip_addr + ':' + PymataIOT.ip_port
print('Websocket server operating on: ' + ws_string)
factory = WebSocketServerFactory(ws_string, debug=False)
factory.protocol = PymataIOT
loop = asyncio.get_event_loop()
coro = loop.create_server(factory, '0.0.0.0', int(PymataIOT.ip_port))
server = loop.run_until_complete(coro)
try:
loop.run_forever()
except KeyboardInterrupt:
pass
finally:
server.close()
loop.close()
else:
print("Text message received: {0}".format(payload.decode('utf8')))
def onClose(self, wasClean, code, reason):
print("WebSocket connection closed: {0}".format(reason))
self.exchange.kill()
if __name__ == '__main__':
try:
import asyncio
except ImportError:
# Trollius >= 0.3 was renamed
import trollius as asyncio
factory = WebSocketServerFactory(u"ws://127.0.0.1:8081", debug=False)
factory.protocol = ServerProtocol
loop = asyncio.get_event_loop()
coro = loop.create_server(factory, '0.0.0.0', 8081)
server = loop.run_until_complete(coro)
try:
loop.run_forever()
except KeyboardInterrupt:
pass
finally:
server.close()
loop.close()
from autobahn.asyncio.websocket import (WebSocketServerProtocol,
WebSocketServerFactory)
clients = set()
logging.basicConfig(level=logging.INFO)
class ChatProtocol(WebSocketServerProtocol):
def onConnect(self, request):
clients.add(self)
def onMessage(self, payload, is_binary):
for c in clients.copy():
if c is not self:
try:
c.sendMessage(payload, is_binary)
except Exception as e:
print(e)
clients.remove(c)
def onClose(self, was_clean, code, reason):
clients.remove(self)
factory = WebSocketServerFactory("ws://localhost:8765")
factory.protocol = ChatProtocol
loop = asyncio.get_event_loop()
asyncio.Task(loop.create_server(factory, port=8765))
loop.run_forever()
await asyncio.sleep(1)
return x * x
async def onMessage(self, payload, isBinary):
if not isBinary:
x = json.loads(payload.decode('utf8'))
try:
res = await self.slowsquare(x)
except Exception as e:
self.sendClose(1000, "Exception raised: {0}".format(e))
else:
self.sendMessage(json.dumps(res).encode('utf8'))
if __name__ == '__main__':
factory = WebSocketServerFactory(u"ws://127.0.0.1:9000")
factory.protocol = SlowSquareServerProtocol
loop = asyncio.get_event_loop()
coro = loop.create_server(factory, '127.0.0.1', 9000)
server = loop.run_until_complete(coro)
try:
loop.run_forever()
except KeyboardInterrupt:
pass
finally:
server.close()
loop.close()
try:
self.cameras_streaming[key].terminate()
del self.cameras_streaming[key]
except:
pass
print("[INFO] All clients has been stoped.")
def is_terminated(self):
return self.terminated
if __name__ == '__main__':
import asyncio
factory = WebSocketServerFactory(u"ws://0.0.0.0:9002")
factory.protocol = Server
loop = asyncio.get_event_loop()
coro = loop.create_server(factory, '0.0.0.0', 9002)
server = loop.run_until_complete(coro)
print("[INFO] WebSocket server has been created.")
try:
loop.run_forever()
except (KeyboardInterrupt, SystemExit):
pass
finally:
server.close()
loop.close()
def __init__(self, loop=asyncio.get_event_loop()):
self.factory = WebSocketServerFactory('ws://0.0.0.0:9000')
self.factory.protocol = SignalProtocol
coro = loop.create_server(self.factory, '0.0.0.0', 9000)
self.server = loop.run_until_complete(coro)
def __init__(self, url, debug=False, debugCodePaths=False):
WebSocketServerFactory.__init__(self,
url,
debug=debug,
debugCodePaths=debugCodePaths)
def onMessage(self, payload, isBinary):
if isBinary:
print("Binary message received: {0} bytes".format(len(payload)))
else:
print("Text message received: {0}".format(payload.decode('utf8')))
# echo back message verbatim
self.sendMessage(payload, isBinary)
def onClose(self, wasClean, code, reason):
print("WebSocket connection closed: {0}".format(reason))
if __name__ == '__main__':
import asyncio
factory = WebSocketServerFactory(u"ws://127.0.0.1:9000")
factory.protocol = MyServerProtocol
loop = asyncio.get_event_loop()
coro = loop.create_server(factory, '0.0.0.0', 9000)
server = loop.run_until_complete(coro)
try:
loop.run_forever()
except KeyboardInterrupt:
pass
finally:
server.close()
loop.close()
return exec(
self.decoded["data"]["model"]["additional_options"]["automation"])
#self.atRow(1).onVar('VI').setReadout(2).asValue(3)
#self.sendMessage(b'{"func": "setDataAtRowProp", "args":[0,"VI.readouts.1",12,""]}', False)
def onClose(self, wasClean, code, reason):
print("WebSocket connection closed: {0}".format(reason))
if __name__ == '__main__':
try:
import asyncio
except ImportError:
# Trollius >= 0.3 was renamed
import trollius as asyncio
factory = WebSocketServerFactory("ws://127.0.0.1:9000", debug=False)
factory.protocol = MyServerProtocol
loop = asyncio.get_event_loop()
coro = loop.create_server(factory, '0.0.0.0', 9000)
server = loop.run_until_complete(coro)
try:
loop.run_forever()
except KeyboardInterrupt:
pass
finally:
server.close()
loop.close()
"COMPAS": compas.__version__,
"Python": sys.version,
"Extensions": compas_pkgs
}
if __name__ == '__main__':
try:
import asyncio
except ImportError:
# Trollius >= 0.3 was renamed
import trollius as asyncio
from autobahn.asyncio.websocket import WebSocketServerFactory
factory = WebSocketServerFactory()
factory.protocol = CompasServerProtocol
ip = '127.0.0.1'
port = 9000
loop = asyncio.get_event_loop()
coro = loop.create_server(factory, '127.0.0.1', 9000)
server = loop.run_until_complete(coro)
print("starting compas_cloud server")
print("Listenning at %s:%s" % (ip, port))
try:
loop.run_forever()
except KeyboardInterrupt:
pass
def __init__(self, *args):
WebSocketServerFactory.__init__(self, *args)
self.clients = []
#moderation handlers
router.add_route(field="mod", value="trash", handler_class=TrashHandler)
router.add_route(field="mod", value="shadowban", handler_class=ShadowbanHandler)
for ban_type in Ban.ban_types:
router.add_route(field="mod", value=ban_type, handler_class=BanHandler)
router.add_route(field="mod", value="grant", handler_class=WeaponsGrantHandler)
class AutobahnLoultServerProtocol(LoultServerProtocol, WebSocketServerProtocol):
loult_state = loult_state
client_logger = logging.getLogger('client')
router = router
factory = WebSocketServerFactory(server='Lou.lt/NG') # 'ws://127.0.0.1:9000',
factory.protocol = AutobahnLoultServerProtocol
# Allow 4KiB max size for messages, in a single frame.
factory.setProtocolOptions(
autoPingInterval=60,
autoPingTimeout=30,
)
coro = loop.create_server(factory, '127.0.0.1', 9000)
scheduler_task = ensure_future(scheduler.start())
server = loop.run_until_complete(gather(coro, scheduler_task))
try:
loop.run_forever()
except KeyboardInterrupt:
logger.info('Shutting down all connections...')
} # message format used by notebook
loop = asyncio.get_event_loop()
await loop.run_in_executor(None, GW.handle_msg, msg)
def onClose(self, wasClean, code, reason):
#print("Server WebSocket connection closed: {0}".format(reason))
self.connection = None
__server = HTTPServer(('', __HTTP_PORT), serveHTTP)
_webbrowser.open(
'http://localhost:{}'.format(__HTTP_PORT)) # or webbrowser.open_new_tab()
__w = threading.Thread(target=__server.serve_forever)
__w.start()
__factory = WebSocketServerFactory(u"ws://localhost:{}/".format(__SOCKET_PORT))
__factory.protocol = WSserver
__interact_loop = asyncio.get_event_loop()
__coro = __interact_loop.create_server(__factory, '0.0.0.0', __SOCKET_PORT)
__interact_loop.run_until_complete(__coro)
# server.handle_request() is a single-shot interaction
# one-shot interact:
#interact_loop.stop()
#interact_loop.run_forever()
# Need to put interact loop inside a thread in order to get a display
# in the absence of a loop containing a rate statement.
__t = threading.Thread(target=__interact_loop.run_forever)
__t.start()
while not (httpserving
and websocketserving): # try to make sure setup is complete
def __init__(self, *args, **kwargs):
WebSocketServerFactory.__init__(self, *args, **kwargs)
self.clients = []
self.subscriptions = {}
loop = get_event_loop()
loult_state = LoultServerState()
try:
loop.run_until_complete(Ban.ensure_sets())
loult_state.can_ban = True
except BanFail:
loult_state.can_ban = False
logger.warning("ipset command dosen't work; bans are disabled.")
class AutobahnLoultServer(LoultServer, WebSocketServerProtocol):
loult_state = loult_state
client_logger = logging.getLogger('client')
factory = WebSocketServerFactory(
server='Lou.lt/NG') # 'ws://127.0.0.1:9000',
factory.protocol = AutobahnLoultServer
# Allow 4KiB max size for messages, in a single frame.
factory.setProtocolOptions(
autoPingInterval=60,
autoPingTimeout=30,
maxFramePayloadSize=4096,
maxMessagePayloadSize=4096,
)
coro = loop.create_server(factory, '127.0.0.1', 9000)
server = loop.run_until_complete(coro)
try:
loop.run_forever()
except KeyboardInterrupt:
def onMessage(self, payload, isBinary):
if isBinary:
print("Binary message received: {0} bytes".format(len(payload)))
else:
print("Text message received: {0}".format(payload.decode('utf8')))
decode_message = payload.decode('utf8')
print('success')
def onClose(self, wasClean, code, reason):
print("WebSocket connection closed: {0}".format(reason))
def send_message(self):
message = {"message": ["Hi grom the server", "to my client"]}
payload = bytes(json.dumps(message), 'utf-8')
self.sendMessage(payload)
if __name__ == '__main__':
factory = WebSocketServerFactory('ws://localhost:1100')
factory.protocol = MyBroadCasterProtocol
loop = asyncio.get_event_loop()
coro = loop.create_server(factory, 'localhost', 1100)
loop.run_until_complete(coro)
loop.run_forever()
loop.close()
await asyncio.sleep(1)
return x * x
async def onMessage(self, payload, isBinary):
if not isBinary:
x = json.loads(payload.decode('utf8'))
try:
res = await self.slowsquare(x)
except Exception as e:
self.sendClose(1000, "Exception raised: {0}".format(e))
else:
self.sendMessage(json.dumps(res).encode('utf8'))
if __name__ == '__main__':
factory = WebSocketServerFactory(u"ws://127.0.0.1:9000")
factory.protocol = SlowSquareServerProtocol
loop = asyncio.get_event_loop()
coro = loop.create_server(factory, '127.0.0.1', 9000)
server = loop.run_until_complete(coro)
try:
loop.run_forever()
except KeyboardInterrupt:
pass
finally:
server.close()
loop.close()
def test_websocket_custom_loop(self, event_loop):
factory = WebSocketServerFactory(loop=event_loop)
server = factory()
transport = Mock()
server.connection_made(transport)
