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")
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 run_server():
logging.basicConfig(
format='%(asctime)s <%(levelname)s> %(message)s',
level=logging.DEBUG,
)
logging.info('Starting server')
localIP = utils.get_local_ip()
port = 5678
serverString = u"ws://" + localIP + ":" + str(port)
logging.info("Creating server on: " + serverString)
factory = WebSocketServerFactory(serverString)
factory.protocol = WosciServerProtocol
asyncioLoop = asyncio.get_event_loop()
coRoutine = asyncioLoop.create_server(factory, host=None, port=port)
server = asyncioLoop.run_until_complete(coRoutine)
try:
asyncioLoop.run_forever()
except KeyboardInterrupt:
logging.warning("Received KeyboardInterrupt. Closing server.")
finally:
logging.info("Closing server...")
server.close()
asyncioLoop.stop()
logging.info("Bye bye!")
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 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):
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)
socket_host = "127.0.0.1"
socket_port = 9002
socket_url = "ws://%s:%s" % (socket_host, socket_port)
factory = WebSocketServerFactory(socket_url)
factory.protocol = BlocklyServerProtocol
loop = asyncio.get_event_loop()
coro = loop.create_server(factory, '0.0.0.0', socket_port)
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_websocket_server():
"""
Function to get the websocket server going and run the event loop
that feeds it.
"""
# We need a new loop in case some other process has already started the
# main loop. In principle we might be able to do a check for a running
# loop but this works whether or not a loop is running.
__interact_loop = asyncio.new_event_loop()
# Need to do two things before starting the server factory:
#
# 1. Set our loop to be the default event loop on this thread
asyncio.set_event_loop(__interact_loop)
# 2. Line below is courtesy of
# https://github.com/crossbario/autobahn-python/issues/1007#issuecomment-391541322
txaio.config.loop = __interact_loop
# Now create the factory, start the server then run the event loop forever.
__factory = WebSocketServerFactory(
u"ws://localhost:{}/".format(__SOCKET_PORT))
__factory.protocol = WSserver
__coro = __interact_loop.create_server(__factory, '0.0.0.0', __SOCKET_PORT)
__interact_loop.run_until_complete(__coro)
__interact_loop.run_forever()
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 ws_api():
class ChooWebsocketServerProtocol(WebSocketServerProtocol):
def onConnect(self, request):
pass
def onOpen(self):
self.instance = ChooInstance(lambda r: self.sendMessage(r))
def onMessage(self, payload, isBinary):
result = self.instance.handle_msg(payload)
self.sendMessage(result)
def connectionLost(self, reason):
self.instance.abort_queries()
loop = asyncio.new_event_loop()
asyncio.set_event_loop(loop)
factory = WebSocketServerFactory('ws://%s:%d' %
(args.ws_host, args.ws_port))
factory.protocol = ChooWebsocketServerProtocol
factory.setProtocolOptions(allowHixie76=True)
loop = asyncio.get_event_loop()
coro = loop.create_server(factory, args.ws_host, args.ws_port)
loop.run_until_complete(coro)
loop.run_forever()
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('rosimple_server', anonymous=True)
rospy.Subscriber("rosimple", 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 = ROSimpleServerProtocol
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 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 __init__(self):
self.loop = asyncio.get_event_loop()
self.wsthread = threading.Thread(target=self.__run_loop,
args=(self.loop, ))
self.factory = WebSocketServerFactory(u"ws://{}:{}".format(
config.PRIVATE_HOST_IP, config.WEBSOCKET_PORT))
self.factory.protocol = A3EWebsocketServerProtocol
def __init__(self, protocol, host='127.0.0.1', port='9000'):
self.host = host
self.port = port
self.protocol = protocol
self.url = f"ws://{host}:{port}"
self.factory = WebSocketServerFactory(self.url)
self.factory.protocol = protocol
self.server = None
def __init__(self, protocol, port=9000):
self.factory = WebSocketServerFactory()
self.factory.protocol = protocol
self.port = port
# ASYNCIO server params
self.loop = None
self.coro = None
self.server = None
def __init__(self, ip, port):
ip_str = str(ip)
port_int = int(port)
wsip = u"ws://" + ip_str + u":" + str(port_int)
factory = WebSocketServerFactory(wsip)
factory.protocol = ChallengeProtocolB
self.loop = trollius.get_event_loop()
self.coro = self.loop.create_server(factory, ip_str, port_int)
#self.server = self.loop.run_until_complete(self.coro)
print("WebSockets configured on %s" % wsip)
def main():
try:
import asyncio
except ImportError:
# Trollius >= 0.3 was renamed
import trollius as 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)
import asyncio_redis
@asyncio.coroutine
def example():
"""
The function that subscribes to redis channel and waits for messages. Once one appear the function stores it in
global messages.
@return:
"""
# Create connection
connection = yield from asyncio_redis.Connection.create(
host='127.0.0.1', port=6379)
# Create subscriber.
subscriber = yield from connection.start_subscribe()
# Subscribe to channel.
yield from subscriber.subscribe(['our-channel'])
# Inside a while loop, wait for incoming events.
while True:
reply = yield from subscriber.next_published()
messages.append(repr(reply.value))
logging.info('Received: {} on channel {}'.format(
repr(reply.value), repr(reply.channel)))
#print('Received: ', repr(reply.value), 'on channel', reply.channel)
# When finished, close the connection.
connection.close()
loop = asyncio.get_event_loop()
server = asyncio. async (coro)
subscriber = asyncio. async (example())
try:
loop.run_forever()
except KeyboardInterrupt:
pass
finally:
server.close()
loop.close()
def test_websocket_custom_loop(self):
def time_gen():
yield
yield
loop = AsyncioTestLoop(time_gen)
factory = WebSocketServerFactory(loop=loop)
server = factory()
transport = Mock()
server.connection_made(transport)
def __init__(self, protocol, ip='127.0.0.1', port=9000):
ip_str = str(ip)
port_int = int(port)
wsip = u"ws://" + ip_str + u":" + str(port_int)
factory = WebSocketServerFactory(wsip)
factory.protocol = protocol
self.loop = trollius.get_event_loop()
#self.loop.set_debug(False)
self.coro = self.loop.create_server(factory, ip_str, port_int)
self.server = self.loop.run_until_complete(self.coro)
print("WebSockets configured on %s" % wsip)
def __init__(self, loop=asyncio.get_event_loop()):
sslcontext = ssl.SSLContext(ssl.PROTOCOL_SSLv23)
sslcontext.load_cert_chain(certfile='server.crt', keyfile='server.key')
self.factory = WebSocketServerFactory('wss://0.0.0.0:9001')
self.factory.protocol = SignalProtocol
coro = loop.create_server(self.factory,
'0.0.0.0',
9001,
ssl=sslcontext)
self.server = loop.run_until_complete(coro)
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_server(host='0.0.0.0', port=2087, loop=None):
factory = WebSocketServerFactory()
factory.protocol = LspWebsocketHandler
if not loop:
loop = asyncio.get_event_loop()
coroutine = loop.create_server(factory, host, port)
server = loop.run_until_complete(coroutine)
try:
loop.run_forever()
except KeyboardInterrupt:
pass
finally:
server.close()
loop.close()
def server():
factory = WebSocketServerFactory(URI)
factory.protocol = ServerProtocol
loop = asyncio.get_event_loop()
coro = loop.create_server(factory, IP, PORT)
server = loop.run_until_complete(coro)
try:
loop.run_forever()
except KeyboardInterrupt:
pass
finally:
server.close()
loop.close()
def sockets():
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()
def test_async_on_connect_server(self):
# see also issue 757
# for python 3.5, this can be "async def foo"
def foo(x):
f = txaio.create_future()
txaio.resolve(f, x * x)
return f
values = []
def on_connect(req):
f = txaio.create_future()
def cb(x):
f = foo(42)
f.add_callbacks(f, lambda v: values.append(v), None)
return f
txaio.add_callbacks(f, cb, None)
return f
factory = WebSocketServerFactory()
server = factory()
server.onConnect = on_connect
transport = Mock()
server.connection_made(transport)
# need/want to insert real-fake handshake data?
server.data = b"\r\n".join([
b'GET /ws HTTP/1.1',
b'Host: www.example.com',
b'Sec-WebSocket-Version: 13',
b'Origin: http://www.example.com.malicious.com',
b'Sec-WebSocket-Extensions: permessage-deflate',
b'Sec-WebSocket-Key: tXAxWFUqnhi86Ajj7dRY5g==',
b'Connection: keep-alive, Upgrade',
b'Upgrade: websocket',
b'\r\n', # last string doesn't get a \r\n from join()
])
server.processHandshake()
import asyncio
from asyncio.test_utils import run_once
run_once(asyncio.get_event_loop())
self.assertEqual(1, len(values))
self.assertEqual(42 * 42, values[0])
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 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 __init__(self, hostname="localhost", port="8080", processor=None):
self.hostname = hostname
self.port = port
self.processor = processor
factory = WebSocketServerFactory(u"ws://" + hostname + u":" +
str(port))
protocol = EventProtocol
protocol.processor = processor
protocol.app = self
factory.protocol = protocol
self.loop = asyncio.get_event_loop()
self.server = self.loop.create_server(factory, '0.0.0.0', port)
def start_server(host='127.0.0.1', port=9000):
address = 'ws://' + host + ':' + str(port)
factory = WebSocketServerFactory(address)
factory.protocol = MyServerProtocol
loop = asyncio.get_event_loop()
coro = loop.create_server(factory, '0.0.0.0', port)
server = loop.run_until_complete(coro)
try:
loop.run_forever()
except KeyboardInterrupt:
pass
finally:
server.close()
loop.close()
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 run(self):
self.loop = asyncio.new_event_loop()
asyncio.set_event_loop(self.loop)
if self.mode == settings.NetworkEngineMode.HOST:
self.factory = WebSocketServerFactory()
self.factory.protocol = ConnectFourServerProtocol
self.coro = self.loop.create_server(self.factory, self.ip, 80)
elif self.mode == settings.NetworkEngineMode.JOIN:
self.factory = WebSocketClientFactory()
self.factory.protocol = ConnectFourClientProtocol
self.coro = self.loop.create_connection(self.factory, self.ip, 80)
self.connection = self.loop.run_until_complete(self.coro)
self.loop.run_forever()
def startServer():
factory = WebSocketServerFactory()
factory.protocol = ServerProtocol
factory.setProtocolOptions(autoPingInterval=1)
factory.setProtocolOptions(requireMaskedClientFrames=False)
loop = asyncio.get_event_loop()
coro = loop.create_server(factory, HOST, PORT)
server = loop.run_until_complete(coro)
print('Autobahn server is started at ws://{}:{}'.format(HOST, PORT))
try:
loop.run_forever()
except KeyboardInterrupt:
pass
finally:
server.close()
loop.close()
