本文整理汇总了Python中websockets.serve函数的典型用法代码示例。如果您正苦于以下问题:Python serve函数的具体用法?Python serve怎么用?Python serve使用的例子?那么恭喜您, 这里精选的函数代码示例或许可以为您提供帮助。
在下文中一共展示了serve函数的15个代码示例,这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞,您的评价将有助于系统推荐出更棒的Python代码示例。
示例1: __init__
def __init__(self):
""" Initialize system state and components """
try:
# Load state
self.startup() # TODO make an init without cloned state an option
# Create main event loop
self.loop = asyncio.get_event_loop()
# Create BPCon instance
self.bpcon = BPConProtocol(self.conf, self.state)
self.state.groups['G1'] = self.bpcon.peers # connect BPCon to Congregate instance
self.paxos_server = websockets.serve(self.bpcon.main_loop, self.conf['ip_addr'], self.conf['port'], ssl=self.conf['ssl'])
self.loop.run_until_complete(self.paxos_server)
log.info("Started BPCon on port {}".format(self.conf['port']))
# Create Congregate instance
self.c = CongregateProtocol(self.loop, self.conf, self.bpcon)
self.congregate_server = websockets.serve(self.c.main_loop, self.conf['ip_addr'], self.conf['port']+1, ssl=self.conf['ssl'])
self.loop.run_until_complete(self.congregate_server)
log.info("Started Congregate on port {}".format(self.conf['port']+1))
# Create API server
self.web_server = websockets.serve(self.mainloop, self.conf['ip_addr'], self.conf['port']+2)
self.loop.run_until_complete(self.web_server)
log.info("Started Web Server on port {}".format(self.conf['port']+2))
# Add self to local group
log.debug("adding self to local group")
self.join_request()
# Testing
if self.conf['is_client']:
#self.c.reconfig()
log.debug("is client. making test requests")
for x in range(1):
request = "P,{},hello{}".format(x,x)
self.local_request("P,test,value")
self.local_request("P,test1,value1")
self.local_request("P,test2,value2")
self.local_request("P,test,value3")
self.local_request("D,test2,")
self.local_request(request)
log.debug("requests complete")
else:
#self.c.request_split()
self.local_request("S,,")
#self.c.request_merge("G2")
self.group_request("M", "G2")
except Exception as e:
log.info(e)
示例2: startup
def startup(callback):
controlws = ControlWS()
controlws.callback = callback
start_server = websockets.serve(controlws.handler, 'tribot.shack', 1337)
asyncio.get_event_loop().run_until_complete(start_server)
asyncio.get_event_loop().run_forever()
示例3: listen
def listen(self, port, host):
logger.info("Server listening on %s:%s.", host, port)
self.store.lock()
green.await_coro(
websockets.serve(green.coroutine(self.accept),
host, port))
示例4: servewebsocketrunforever
def servewebsocketrunforever(portnumber):
print("serving", ipaddress, portnumber)
start_server = websockets.serve(handler, ipaddress, portnumber)
mainasyncloop.run_until_complete(start_server)
receivertask = asyncio.async(receiverall())
producertask = asyncio.async(producer())
mainasyncloop.run_forever()
示例5: __init__
def __init__(self, host, port):
self.loop = asyncio.new_event_loop()
asyncio.set_event_loop(self.loop)
self.server = websockets.serve(self.receiver, host, port, loop=self.loop)
self.host = host
self.port = port
WebSocket.loop = self.loop
示例6: testWebsocketTransport
def testWebsocketTransport():
@asyncio.coroutine
def serverRoutine(websocket, path):
print("new connection")
receiver = TransportGateway(enc, WebsocketTransport(websocket), debugMode = True)
receiver.exposeObjectImplementation(TestImplementation)
yield from asyncio.sleep(0.5)
a = yield from (receiver << Test.requestNew(1))
print(a)
b = yield from a.echo("asd")
print(b)
b = yield from a.echo("asd")
print(b)
b = yield from a.echo("asd")
print(b)
#yield from receiver.serverMode()
print("connection closed")
@asyncio.coroutine
def clientRoutine():
websocket = yield from websockets.connect('ws://localhost:8765/')
return TransportGateway(enc, WebsocketTransport(websocket), debugMode = True)
start_server = websockets.serve(serverRoutine, 'localhost', 8765)
asyncio.get_event_loop().run_until_complete(start_server)
asyncio.get_event_loop().run_forever()
示例7: main
def main():
"""
Setup and run all subroutines.
"""
global socks, queue, authed, sessions, queuehash, upkeepThread, pluginUpkeeps
pluginList = plugins.getPlugins()
pluginUpkeeps = list(filter(lambda module: hasattr(module, "upkeep"), pluginList))
comm.buildCommands(pluginList)
laserqueue.buildLists(pluginList)
# Load the queue if -b is used
if args.backup:
if os.path.exists("cache.json"):
queue = laserqueue.Queue.load(open("cache.json"))
else:
json.dump({}, open("cache.json", "w"))
color_print("Serving WebSockets on 0.0.0.0 port {port} ...", port=config["port"])
# Create the upkeep thread
upkeepThread = threading.Thread(target=upkeep)
upkeepThread.daemon = True
upkeepThread.start()
# Create the server event loop
start_server = websockets.serve(server, "0.0.0.0", config['port'])
loop = asyncio.get_event_loop()
try:
loop.run_until_complete(start_server)
loop.run_forever()
except KeyboardInterrupt:
quit(0)
示例8: start_websockets
async def start_websockets(websocket_handlers):
import websockets
futures = []
for handler, host, port in websocket_handlers:
ws_future = websockets.serve(handler, host, port)
futures.append(ws_future)
await asyncio.gather(*futures)
示例9: make_server
def make_server(self, port, listen='0.0.0.0'):
context = ssl.SSLContext(ssl.PROTOCOL_SSLv23)
context.load_cert_chain('/etc/ssl/certs/ssl-cert-snakeoil.pem',
'/etc/ssl/private/ssl-cert-snakeoil.key')
self.log.info('UVC management server started on port %i' % port)
return websockets.serve(self.handle_camera,
listen, port, ssl=context)
示例10: __run_loop
def __run_loop(self):
# Set event loop
if self.background:
logging.info("Running in background")
asyncio.set_event_loop(self.loop)
# Create the loop server
self.server = self.loop.run_until_complete(websockets.serve(self.handler, self.address, self.port))
try:
logging.info("Starting server")
self.loop.run_forever()
except KeyboardInterrupt:
logging.info("Keyboard Interrupt received.")
finally:
# Tell any clients that we're closing
self.server.close()
self.loop.run_until_complete(asyncio.sleep(0.1))
# Gather any remaining tasks so we can cancel them
asyncio.gather(*asyncio.Task.all_tasks()).cancel()
self.loop.stop()
logging.info("Cancelling pending tasks...")
self.loop.run_forever()
logging.info("Stopping Server...")
self.loop.close()
示例11: main
def main():
parser = argparse.ArgumentParser()
parser.add_argument('-c', '--config', default=default.GEOFFREY_RC_FILE)
parser.add_argument('path', nargs='+')
args = parser.parse_args()
config = Config(args.config, create=True)
main = config['geoffrey']
host = main.get('host', default.HOST)
websocket_port = main.get('websocket_port', default.WEBSOCKET_PORT)
webserver_port = main.get('webserver_port', default.WEBSERVER_PORT)
loop = asyncio.get_event_loop()
em = EventManager()
plugins = get_plugins(config, output_queue)
for subscriptions in plugins.call('get_subscriptions'):
em.add_subscriptions(subscriptions)
mask = em.get_mask()
asyncio.Task(websockets.serve(websocket_server, host, websocket_port))
asyncio.Task(watch_files(args.path, mask=mask))
asyncio.Task(em.consume_events(event_queue, output_queue))
webapp.run()
loop.run_forever()
示例12: start
def start(self):
self._debug("Starting server")
# scopeless version of self
this = self
# A handler function that represents the event loop
@asyncio.coroutine
def handler(websocket, path):
self._debug("Got client: " + str(websocket.remote_address))
while True:
# on each new loop
tasks = []
for task in this.handler_threads:
tasks.append(asyncio.async(
task(websocket)
))
# Blocking method that takes a list of thread ids
# and yields a tuple when any one is finished. The first item
# is a list of done thread ids, and the other is a list of
# thread ids that have not finished yet
done, pending = yield from asyncio.wait(
tasks,
return_when=asyncio.FIRST_COMPLETED
)
# start the websocket server
ws_server = websockets.serve(handler, self.host, self.port)
asyncio.get_event_loop().run_until_complete(ws_server)
asyncio.get_event_loop().run_forever()
示例13: run_pubsub_server
def run_pubsub_server(host, port):
logger.info("Starting pubsub server on %s:%d", host, port)
start_server = websockets.serve(client_handler, host, port, klass=get_protocol_handler_klass())
asyncio.get_event_loop().run_until_complete(start_server)
asyncio.get_event_loop().run_forever()
示例14: lance_broadcast
def lance_broadcast():
start_server = websockets.serve(handler_cast, get_lan_ip(), 8003)
loop = asyncio.new_event_loop()
asyncio.set_event_loop(loop)
asyncio.get_event_loop().run_until_complete(start_server)
print("Websocket connection launched on port 8003")
asyncio.get_event_loop().run_forever()
示例15: main
def main():
parser = argparse.ArgumentParser(description='A simple DNS tunnel over websocket')
parser.add_argument('-b', action='store', dest='bind_address', default='127.0.0.1',
help='bind to this address, default to 127.0.0.1')
parser.add_argument('-p', action='store', dest='bind_port', type=int, default=5353,
help='bind to this port, default to 5353')
parser.add_argument('--debug', action='store_true', dest='debug', default=False,
help='enable debug outputing')
args = parser.parse_args(sys.argv[1:])
if 'PORT' in os.environ:
# we are probably in heroku environment
port = int(os.environ['PORT'])
addr = '0.0.0.0'
else:
port = args.bind_port
addr = args.bind_address
if args.debug:
logging_level = logging.DEBUG
else:
logging_level = logging.INFO
logging.basicConfig(level=logging_level,
format='%(asctime)s %(levelname)-8s %(message)s',
datefmt='%Y-%m-%d %H:%M:%S')
start_server = websockets.serve(handle, addr, port)
asyncio.get_event_loop().run_until_complete(start_server)
logging.info('listening on %s:%d' % (addr, port))
asyncio.get_event_loop().run_forever()