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 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 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 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 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_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 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 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_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():
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 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 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 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("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 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 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 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 __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 __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 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 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 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 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 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 __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 _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 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 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 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 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()
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 talker(self, port=8128):
factory = WebSocketServerFactory(u"ws://0.0.0.0:%d" % port)
factory.protocol = self.protocol
self.loop = asyncio.get_event_loop()
coro = self.loop.create_server(factory, '0.0.0.0', port)
server = self.loop.run_until_complete(coro)
asyncio.ensure_future(self.wait_until_shutdown(self.loop))
# signal.signal(signal.SIGINT, self.signal_handler)
self.loop.run_forever()
info("Closing...")
server.close()
self.loop.run_until_complete(server.wait_closed())
self.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 run():
import asyncio
from autobahn.asyncio.websocket import WebSocketServerFactory
factory = WebSocketServerFactory()
factory.protocol = MessageServer
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 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 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 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, protocol, ip='127.0.0.1', port=9000):
global flyermmap, flyersem, flyerqueue
self.queue = posix_ipc.MessageQueue("/flyerqueue")
memory = posix_ipc.SharedMemory("flyermmap")
self.sem = posix_ipc.Semaphore("flyersem")
self.memmap = mmap.mmap(memory.fd, memory.size)
flyermmap = self.memmap
flyersem = self.sem
flyerqueue = self.queue
memory.close_fd()
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 run(secret_key):
form = '[%(asctime)s] %(levelname)s: %(message)s'
logger = logging.getLogger("WSServer")
logging.basicConfig(level=logging.INFO, format=form)
log_handler = logging.FileHandler('logs/log.txt')
log_handler.setFormatter(logging.Formatter(form))
logger.addHandler(log_handler)
logger.info('Start %s:%s' % (IP, PORT))
Handler.secret_key = secret_key
factory = WebSocketServerFactory(u"ws://%s:%s" % (IP, PORT))
factory.protocol = Handler
loop = asyncio.get_event_loop()
coro = loop.create_server(factory, IP, PORT)
loop.run_until_complete(coro)
thread = Thread(loop.run_forever)
return thread
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()
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 exception_handler(loop,context):
#print "got exception: " + context["message"];
print "got exception: " + str(context)
loop.stop()
exit(1)
try:
import asyncio
except ImportError:
## Trollius >= 0.3 was renamed
import trollius as asyncio
server_url = "ws://%s:%d" % (server_host, int(server_port))
factory = WebSocketServerFactory(server_url, debug = False)
factory.protocol = StreamingMarconiServerProtocol
loop = asyncio.get_event_loop()
coro = loop.create_server(factory, server_host, server_port)
server = loop.run_until_complete(coro)
loop.set_exception_handler(exception_handler)
try:
loop.run_forever()
except KeyboardInterrupt:
pass
finally:
server.close()
loop.stop()
loop.close()
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
@return:{"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()
# py >2.7 try: import asyncio except ImportError: import trollius as asyncio from iotsensorprotocol import IotSensorProtocol from autobahn.asyncio.websocket import WebSocketServerFactory factory = WebSocketServerFactory() factory.protocol = IotSensorProtocol loop = asyncio.get_event_loop() #TODO: get ip from os coro = loop.create_server(factory, '192.168.99.40', 9000) server = loop.run_until_complete(coro) try: loop.run_forever() except KeyboardInterrupt: pass finally: server.close() loop.close()
if '-f' in sys.argv:
input_file = sys.argv[sys.argv.index('-f') + 1]
if args.interface == 'c3telem':
print('Opening C3-style serial telemetry from serial port',input_file)
interface = InterfaceC3Telemetry(input_file)
interface.start()
elif args.interface == 'c2log':
print('Replaying C2 format log file',input_file)
interface = InterfaceC2Log(input_file)
interface.start()
else:
print('No interface type specified. Use `-i list` to list available types.')
interface = InterfaceNull()
factory = WebSocketServerFactory("ws://localhost:9000", debug = False)
factory.protocol = CANServer
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()
print("WebSocket connection closed: {0}".format(reason))
CONNECTIONS.remove(self)
if __name__ == '__main__':
# import logging
# logging.basicConfig(level=logging.DEBUG)
port="7778"
if len(sys.argv) == 2:
port = sys.argv[1]
CONNECTIONS = []
queue = asyncio.Queue()
factory = WebSocketServerFactory("ws://localhost:{}".format(port), debug=False)
factory.protocol = MyServerProtocol
loop = asyncio.get_event_loop()
# loop.add_reader(sys.stdin, functools.partial(handleStdin, sys.stdin))
coro = loop.create_server(factory, '127.0.0.1', int(port))
server = loop.run_until_complete(asyncio.wait(
[coro, asyncio.async(MyServerProtocol.sendLine())]))
try:
loop.run_forever()
except KeyboardInterrupt:
pass
finally:
server.close()
loop.close()
try:
loop.run_until_complete(Ban.test_ban())
loult_state.can_ban = True
except BanFail:
loult_state.can_ban = False
logger.warning("nft 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,
)
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...')
for client in chain.from_iterable((channel.clients for channel in loult_state.chans.values())):
