def startupagent(self, sender, **kwargs):
if not self.bind_web_address:
_log.info('Web server not started.')
return
import urlparse
parsed = urlparse.urlparse(self.bind_web_address)
hostname = parsed.hostname
port = parsed.port
_log.info('Starting web server binding to {}:{}.' \
.format(hostname, port))
self.registeredroutes.append(
(re.compile('^/discovery/$'), 'callable', self._get_discovery))
self.registeredroutes.append(
(re.compile('^/discovery/allow$'), 'callable', self._allow))
self.registeredroutes.append(
(re.compile('^/$'), 'callable', self._redirect_index))
port = int(port)
vhome = os.environ.get('VOLTTRON_HOME')
logdir = os.path.join(vhome, "log")
if not os.path.exists(logdir):
os.makedirs(logdir)
self.appContainer = WebApplicationWrapper(self, hostname, port)
svr = WSGIServer((hostname, port), self.appContainer)
self._server_greenlet = gevent.spawn(svr.serve_forever)
def __init__(self, host, port):
threading.Thread.__init__(self)
self.log = logs.Logger('WebSocketsServer').getLogger()
self.port = int(port)
self.host = host
self.daemon = True
self.flag = True
self.server = WSGIServer((self.host, self.port), WSDemoApp())
pass
def run_gevent_server(host="127.0.0.1", port=9001):
from gevent import monkey; monkey.patch_all()
from ws4py.websocket import EchoWebSocket
from ws4py.server.geventserver import WebSocketWSGIApplication, WSGIServer
server = WSGIServer((host, port), WebSocketWSGIApplication(handler_cls=EchoWebSocket))
logger = logging.getLogger('autobahn_testsuite')
logger.warning("Serving gevent server on %s:%s" % (host, port))
server.serve_forever()
def __init__(self,
listen,
request_handler,
msg_handler_pool_size=1024,
indent='indented',
pingpong_trigger=0,
pingpong_timeout=0,
keyfile=None,
certfile=None):
"""
:param listen: string ip:port
:param request_handler: instance of januscloud.proxy.core.request:RequestHandler
:param msg_handler_pool_size:
:param keyfile:
:param certfile:
"""
if msg_handler_pool_size == 0:
msg_handler_pool_size = None
self._msg_handler_pool = Pool(size=msg_handler_pool_size)
self._request_handler = request_handler
self._listen = listen
if keyfile or certfile:
self._server = WSGIServer(
self._listen,
WebSocketWSGIApplication(protocols=['janus-protocol'],
handler_cls=WSServerConn),
log=logging.getLogger('websocket server'),
keyfile=keyfile,
certfile=certfile)
else:
self._server = WSGIServer(
self._listen,
WebSocketWSGIApplication(protocols=['janus-protocol'],
handler_cls=WSServerConn),
log=logging.getLogger('websocket server'),
)
self._server.set_environ({
'app.recv_msg_cbk': self._async_incoming_msg_handler,
'app.closed_cbk': self._request_handler.transport_gone,
'json_indent': indent,
'pingpong_trigger': pingpong_trigger,
'pingpong_timeout': pingpong_timeout
})
def _run_http(self):
logger.debug("Webfront engine(HTTP) is running...")
self._http_listener = WSGIServer((self.listen_addr, self.listen_port),
dispatcher)
logger.debug("Webfront engine(HTTP) is listening on port: %d",
self._http_listener.address[1])
self._http_listener.serve_forever()
def serve(blocking=False):
ws_server = WSGIServer(
('localhost', int(Config.get('server', 'ws_port'))),
WebSocketWSGIApplication(handler_cls=_LAUWebSocketHandler))
if blocking == True:
ws_server.serve_forever() # Non-blocking serve
else:
ws_server.start() # Non-blocking serve
pass
pass
def run_server(host, port, routes):
compiled_routes = [(re.compile(route), app) for route, app in routes]
def router(environ, start_response):
query_path = environ.get('PATH_INFO', '')
for route, app in compiled_routes:
if route.match(query_path):
if hasattr(app, 'get_wsgi_application'):
app = app.get_wsgi_application()
return app(environ, start_response)
start_response("404 Not Found", [('Content-type', 'text/plain')])
return []
server = WSGIServer((host, port), router)
server.serve_forever()
def _run_https(self):
logger.debug("Webfront engine(HTTPS) is running...")
conf_dir = environ.conf_dir()
keyfile = os.path.join(conf_dir, 'ava.key')
certfile = os.path.join(conf_dir, 'ava.crt')
self._https_listener = WSGIServer(
(self.listen_addr, self.secure_listen_port),
dispatcher,
keyfile=keyfile,
certfile=certfile)
logger.debug("Webfront engine(HTTPS) is listening on port: %d",
self._https_listener.address[1])
self._https_listener.serve_forever()
def main():
import argparse
from ws4py import configure_logger
configure_logger()
parser = argparse.ArgumentParser(description='Twister Server')
parser.add_argument('--host', default='127.0.0.1')
parser.add_argument('-p', '--port', default=9000, type=int)
args = parser.parse_args()
server = WSGIServer((args.host, args.port),
WebSocketWSGIApplication(handler_cls=Twister))
print "Twister running on %s:%s" % (args.host, args.port)
server.serve_forever()
import os
import gevent
from django.core.wsgi import get_wsgi_application
from gevent import pywsgi
from ws4py.server.geventserver import WSGIServer
from ws4py.server.wsgiutils import WebSocketWSGIApplication
from implement_table.core.settings import DJANGO_HOST, WEBSOCKET_HOST
from implement_table.ws.websocket import MnWebSocket
os.environ.setdefault("DJANGO_SETTINGS_MODULE",
"implement_table.core.settings")
http_server = pywsgi.WSGIServer(DJANGO_HOST, get_wsgi_application())
ws_server = WSGIServer(WEBSOCKET_HOST,
WebSocketWSGIApplication(handler_cls=MnWebSocket))
g = [
gevent.spawn(http_server.serve_forever),
gevent.spawn(ws_server.serve_forever),
# scheduler.start()
]
gevent.joinall(g, raise_error=True)
application = get_wsgi_application()
def listen(self, host, port):
server = WSGIServer((host, port), self.get_wsgi_application())
server.serve_forever()
monkey.patch_all()
from ws4py.websocket import EchoWebSocket
from ws4py.server.geventserver import WSGIServer
from ws4py.server.wsgiutils import WebSocketWSGIApplication
class CopyPastaSocket(WebSocket):
def received_message(self, message):
self.send(CopyPasta.generate_copy_pasta(message.data),
message.is_binary)
print(message.data)
self.send(CopyPasta.generate_copy_pasta(message.data),
message.is_binary)
server = WSGIServer(('localhost', 3001),
WebSocketWSGIApplication(handler_cls=CopyPastaSocket))
server.serve_forever()
# @asyncio.coroutine
# def hello(websocket, path):
# message = yield from websocket.recv()
# print("Received message {}".format(message))
# result = CopyPasta.generate_copy_pasta(message)
# yield from websocket.send(result)
# print("Sent message: {}".format(result))
# start_server = websockets.serve(hello, 'localhost', 3001)
# asyncio.get_event_loop().run_until_complete(start_server)
# asyncio.get_event_loop().run_forever()
$('#message').val("");
return false;
});
});
</script>
</head>
<body>
<form action='#' id='chatform' method='get'>
<textarea id='chat' cols='35' rows='10'></textarea>
<br />
<label for='message'>%(username)s: </label><input type='text' id='message' />
<input id='send' type='submit' value='Send' />
</form>
</body>
</html>
""" % {'username': "******" % random.randint(0, 100),
'host': self.host,
'port': self.port}
if __name__ == '__main__':
from ws4py import configure_logger
configure_logger()
parser = argparse.ArgumentParser(description='Echo gevent Server')
parser.add_argument('--host', default='127.0.0.1')
parser.add_argument('-p', '--port', default=9000, type=int)
args = parser.parse_args()
server = WSGIServer((args.host, args.port), EchoWebSocketApplication(args.host, args.port))
server.serve_forever()
def server_forever(self):
self._server = WSGIServer(
self._listen,
WebSocketWSGIApplication(handler_cls=WSServerTransport))
log.info("Starting server on {0}".format(self._listen))
self._server.serve_forever()
try:
from gunicorn.workers.ggevent import GeventPyWSGIWorker, PyWSGIHandler
class WSGIHandler(PyWSGIHandler, WebSocketWSGIHandler):
pass
class Worker(GeventPyWSGIWorker):
"""Worker for Gunicorn.
"""
server_class = WSGIServer
wsgi_handler = WSGIHandler
except ImportError:
pass
REDIS_URL = 'redis://127.0.0.1:6379/0'
application = WebSocketChannelApp(redis_url=REDIS_URL)
if __name__ == '__main__':
logger = ws4py.configure_logger(level='INFO')
parser = argparse.ArgumentParser(description='Echo gevent Server')
parser.add_argument('--host', default='127.0.0.1')
parser.add_argument('--port', default=9000, type=int)
args = parser.parse_args()
server = WSGIServer((args.host, args.port), application)
server.serve_forever()
def startupagent(self, sender, **kwargs):
import urlparse
parsed = urlparse.urlparse(self.bind_web_address)
ssl_key = self.web_ssl_key
ssl_cert = self.web_ssl_cert
if parsed.scheme == 'https':
# Admin interface is only availble to rmq at present.
if self.core.messagebus == 'rmq':
self._admin_endpoints = AdminEndpoints(
self.core.rmq_mgmt,
self._certs.get_cert_public_key(
get_fq_identity(self.core.identity)))
if ssl_key is None or ssl_cert is None:
# Because the master.web service certificate is a client to rabbitmq we
# can't use it directly therefore we use the -server on the file to specify
# the server based file.
base_filename = get_fq_identity(self.core.identity) + "-server"
ssl_cert = self._certs.cert_file(base_filename)
ssl_key = self._certs.private_key_file(base_filename)
if not os.path.isfile(ssl_cert) or not os.path.isfile(ssl_key):
self._certs.create_ca_signed_cert(base_filename,
type='server')
hostname = parsed.hostname
port = parsed.port
_log.info('Starting web server binding to {}://{}:{}.'.format(
parsed.scheme, hostname, port))
# Handle the platform.web routes here.
self.registeredroutes.append(
(re.compile('^/discovery/$'), 'callable', self._get_discovery))
self.registeredroutes.append(
(re.compile('^/discovery/allow$'), 'callable', self._allow))
# these routes are only available for rmq based message bus
# at present.
if self.core.messagebus == 'rmq':
# We need reference to the object so we can change the behavior of
# whether or not to have auto certs be created or not.
self._csr_endpoints = CSREndpoints(self.core)
for rt in self._csr_endpoints.get_routes():
self.registeredroutes.append(rt)
for rt in self._admin_endpoints.get_routes():
self.registeredroutes.append(rt)
ssl_private_key = self._certs.get_private_key(
get_fq_identity(self.core.identity))
for rt in AuthenticateEndpoints(ssl_private_key).get_routes():
self.registeredroutes.append(rt)
static_dir = os.path.join(os.path.dirname(__file__), "static")
self.registeredroutes.append((re.compile('^/.*$'), 'path', static_dir))
port = int(port)
vhome = os.environ.get('VOLTTRON_HOME')
logdir = os.path.join(vhome, "log")
if not os.path.exists(logdir):
os.makedirs(logdir)
self.appContainer = WebApplicationWrapper(self, hostname, port)
if ssl_key and ssl_cert:
svr = WSGIServer((hostname, port),
self.appContainer,
certfile=ssl_cert,
keyfile=ssl_key)
else:
svr = WSGIServer((hostname, port), self.appContainer)
self._server_greenlet = gevent.spawn(svr.serve_forever)
self.spt.daemon = True
self.spt.start()
class EchoWebSocketApplication(object):
def __init__(self, host, port):
self.host = host
self.port = port
self.ws = WebSocketWSGIApplication(handler_cls=BroadcastWebSocket)
def __call__(self, environ, start_response):
if environ['PATH_INFO'] == '/ws':
environ['ws4py.app'] = self
return self.ws(environ, start_response)
return None
if __name__ == '__main__':
from ws4py import configure_logger
configure_logger()
parser = argparse.ArgumentParser(description="Kaldiwolf's Server")
parser.add_argument('--host', default='0.0.0.0')
parser.add_argument('-p', '--port', default=9000, type=int)
args = parser.parse_args()
app = EchoWebSocketApplication(args.host, args.port)
server = WSGIServer((args.host, args.port), app)
logging.info("Going to start kaldiwolf's websocket server")
server.serve_forever()
def closed(self, code, reason):
print(("Closed down", code, reason))
def received_message(self, m):
self.cnt += 1
if self.cnt < 1000:
self.send(msg)
else:
self.close(reason='Bye bye')
print(time.time() - self.started_at)
global patched
if not patched:
patched = True
wsaccel.patch_ws4py()
start_client()
else:
server.stop()
def start_client():
ws = EchoClient('ws://127.0.0.1:9000/ws')
ws.connect()
if __name__ == '__main__':
server = WSGIServer(('127.0.0.1', 9000), EchoWebSocketApplication())
server.start()
start_client()
while not server.closed:
gevent.sleep(1)
class HQCWebSocketApplication(object):
def __init__(self, host, port):
self.host = host
self.port = port
self.ws = WebSocketWSGIApplication(handler_cls=HQCWebSocket)
self.clients = []
# TODO: remove clients when they exit
self.current_clients = {}
def __call__(self, environ, start_response):
environ['ws4py.app'] = self
return self.ws(environ, start_response)
if __name__ == '__main__':
try:
try:
PORT = int(sys.argv[1])
except IndexError:
PORT = 9000
print "Port not specified"
server = WSGIServer(('0.0.0.0', PORT),
HQCWebSocketApplication('localhost', PORT))
print "Running server on port " + str(PORT)
server.serve_forever()
except KeyboardInterrupt:
server.close()
except socket.error:
print "Server could not start properly. The socket may already be bound by another instance."
from ws4py.websocket import WebSocket
from ws4py.server.geventserver import WSGIServer
from ws4py.server.wsgiutils import WebSocketWSGIApplication
import time, random
class EchoWebSocket(WebSocket):
def received_message(self, message):
"""
Automatically sends back the provided ``message`` to
its originating endpoint.
"""
print message.__dict__
while True:
try:
value = random.uniform(50, 900000)
s = "x" * int(value)
self.send(s, message.is_binary)
time.sleep(0.01)
print "send " + str(value)
except BaseException:
print "error"
server = WSGIServer(('0.0.0.0', 9700), WebSocketWSGIApplication(handler_cls=EchoWebSocket))
server.serve_forever()
from ws4py.websocket import WebSocket
class ExampleServer(WebSocket):
def received_message(self, message):
print(message)
super().received_message(message)
if __name__ == '__main__':
from gevent import monkey
monkey.patch_all()
from ws4py.server.geventserver import WSGIServer
from ws4py.server.wsgiutils import WebSocketWSGIApplication
server = WSGIServer(('localhost', 9000),
WebSocketWSGIApplication(handler_cls=ExampleServer))
server.serve_forever()
def cli_start():
if sys.version_info.major < 3 or (sys.version_info.major <= 3
and sys.version_info.minor < 6):
logging.warning(
"\n---\n Version 0.6.9 is the last version to support Python older than 3.6\n---\n"
)
config = copy.deepcopy(SHARED_DEFAULTS)
parser = argparse.ArgumentParser(add_help=True)
parser.add_argument("-i",
"--ini",
dest="ini",
help="Config file path",
default=None)
parser.add_argument("-s",
"--secret",
dest="secret",
help="Secret used to secure your API requests")
parser.add_argument("-u",
"--admin_username",
dest="admin_user",
help="Administrator username")
parser.add_argument(
"-a",
"--admin_secret",
dest="admin_secret",
help="Secret used to secure your admin panel",
)
parser.add_argument("-host",
"--host",
dest="host",
help="Host ip on which the server listens to")
parser.add_argument(
"-p",
"--port",
type=int,
dest="port",
help="Port on which the server listens to",
)
parser.add_argument("-d",
"--debug",
dest="debug",
help="Does nothing for now")
parser.add_argument("-l",
"--log-level",
dest="log_level",
help="Does nothing for now")
parser.add_argument("-e",
"--demo",
dest="demo",
help="Does nothing, BW.compat")
parser.add_argument(
"-x",
"--allowed_post_ip",
dest="allow_posting_from",
help="comma separated list of ip's "
"that can post to server",
)
parser.add_argument(
"-c",
"--allow_cors",
dest="allow_cors",
help="comma separated list of domains's "
"that can connect to server",
)
parser.add_argument(
"--validate-requests",
dest="validate_requests",
help="Enable timestamp check on signed requests",
)
args = parser.parse_args()
parameters = (
"debug",
"log_level",
"port",
"host",
"secret",
"admin_user",
"admin_secret",
"allow_posting_from",
"allow_cors",
"validate_requests",
)
if args.ini:
parser = configparser.ConfigParser()
parser.read(args.ini)
settings = dict(parser.items("channelstream"))
for key in parameters:
try:
config[key] = settings[key]
except KeyError:
pass
else:
for key in parameters:
conf_value = getattr(args, key)
if conf_value:
config[key] = conf_value
# convert types
config["debug"] = asbool(config["debug"])
config["port"] = int(config["port"])
config["validate_requests"] = asbool(config["validate_requests"])
for key in ["allow_posting_from", "allow_cors"]:
if not config[key]:
continue
try:
listed = [ip.strip() for ip in config[key].split(",")]
config[key] = listed
except ValueError:
pass
log_level = getattr(logging, config.get("log_level", "INFO").upper())
logging.basicConfig(level=log_level)
log.info("Starting channelstream {}".format(channelstream.__version__))
url = "http://{}:{}".format(config["host"], config["port"])
log.info("Starting flash policy server on port 10843")
gc_conns_forever()
gc_users_forever()
server = StreamServer(("0.0.0.0", 10843), client_handle)
server.start()
log.info("Serving on {}".format(url))
log.info("Admin interface available on {}/admin".format(url))
if config["secret"] == "secret":
log.warning(
"Using default secret! Remember to set that for production.")
if config["admin_secret"] == "admin_secret":
log.warning(
"Using default admin secret! Remember to set that for production.")
server = WSGIServer(
(config["host"], config["port"]),
RoutingApplication(config),
log=logging.getLogger("channelstream.WSGIServer"),
)
server.serve_forever()
start_response(status, headers)
return PAGE % {
'username': "******" % random.randint(0, 100),
'host': self.host,
'port': self.port
}
class NoLog(object):
def write(*args, **kw):
pass
if __name__ == '__main__':
parser = argparse.ArgumentParser(description='Echo gevent Server')
parser.add_argument('--host', default='127.0.0.1')
parser.add_argument('-p', '--port', default=9000, type=int)
args = parser.parse_args()
server = WSGIServer((args.host, args.port),
EchoWebSocketApplication(args.host, args.port),
log=NoLog(),
backlog=100000)
try:
server.serve_forever()
except KeyboardInterrupt:
pass
def startupagent(self, sender, **kwargs):
from urllib.parse import urlparse
parsed = urlparse(self.bind_web_address)
ssl_key = self.web_ssl_key
ssl_cert = self.web_ssl_cert
rpc_caller = self.vip.rpc
if parsed.scheme == 'https':
# Admin interface is only availble to rmq at present.
if self.core.messagebus == 'rmq':
self._admin_endpoints = AdminEndpoints(
rmq_mgmt=self.core.rmq_mgmt,
ssl_public_key=self._certs.get_cert_public_key(
get_fq_identity(self.core.identity)),
rpc_caller=rpc_caller)
if ssl_key is None or ssl_cert is None:
# Because the master.web service certificate is a client to rabbitmq we
# can't use it directly therefore we use the -server on the file to specify
# the server based file.
base_filename = get_fq_identity(self.core.identity) + "-server"
ssl_cert = self._certs.cert_file(base_filename)
ssl_key = self._certs.private_key_file(base_filename)
if not os.path.isfile(ssl_cert) or not os.path.isfile(ssl_key):
self._certs.create_signed_cert_files(base_filename,
cert_type='server')
if ssl_key is not None and ssl_cert is not None and self._admin_endpoints is None:
self._admin_endpoints = AdminEndpoints(
ssl_public_key=CertWrapper.get_cert_public_key(ssl_cert),
rpc_caller=rpc_caller)
else:
self._admin_endpoints = AdminEndpoints(rpc_caller=rpc_caller)
hostname = parsed.hostname
port = parsed.port
_log.info('Starting web server binding to {}://{}:{}.'.format(
parsed.scheme, hostname, port))
# Handle the platform.web routes here.
self.registeredroutes.append(
(re.compile('^/discovery/$'), 'callable', self._get_discovery))
self.registeredroutes.append(
(re.compile('^/discovery/allow$'), 'callable', self._allow))
self.registeredroutes.append(
(re.compile(r'/gs'), 'callable', self.jsonrpc))
# these routes are only available for rmq based message bus
# at present.
if self.core.messagebus == 'rmq':
# We need reference to the object so we can change the behavior of
# whether or not to have auto certs be created or not.
self._csr_endpoints = CSREndpoints(self.core)
for rt in self._csr_endpoints.get_routes():
self.registeredroutes.append(rt)
# Register the admin endpoints regardless of whether there is an ssl context
# or not.
for rt in self._admin_endpoints.get_routes():
self.registeredroutes.append(rt)
# Allow authentication endpoint from any https connection
if parsed.scheme == 'https':
if self.core.messagebus == 'rmq':
ssl_private_key = self._certs.get_pk_bytes(
get_fq_identity(self.core.identity))
else:
ssl_private_key = CertWrapper.get_private_key(ssl_key)
for rt in AuthenticateEndpoints(
tls_private_key=ssl_private_key).get_routes():
self.registeredroutes.append(rt)
else:
# We don't have a private ssl key if we aren't using ssl.
for rt in AuthenticateEndpoints(
web_secret_key=self._web_secret_key).get_routes():
self.registeredroutes.append(rt)
static_dir = os.path.join(os.path.dirname(__file__), "static")
self.registeredroutes.append((re.compile('^/.*$'), 'path', static_dir))
port = int(port)
self.appContainer = WebApplicationWrapper(self, hostname, port)
if ssl_key and ssl_cert:
svr = WSGIServer((hostname, port),
self.appContainer,
certfile=ssl_cert,
keyfile=ssl_key)
else:
svr = WSGIServer((hostname, port), self.appContainer)
self._server_greenlet = gevent.spawn(svr.serve_forever)
from gevent import monkey; monkey.patch_all()
from ws4py.websocket import EchoWebSocket
from ws4py.server.geventserver import WSGIServer
from ws4py.server.wsgiutils import WebSocketWSGIApplication
server = WSGIServer(('localhost', 8088), WebSocketWSGIApplication(handler_cls=EchoWebSocket))
server.serve_forever()
dest="emulate",
action="store_true",
help="Emulate the hw interface")
parser.add_option("-d",
"--debug",
dest="debug",
action="store_true",
help="Provide some debugging output")
(options, args) = parser.parse_args()
DEBUG = options.debug
dirname = os.path.dirname(sys.argv[0])
controller = SingleVolumeController(dirname, options)
try:
server = WSGIServer(('', 8888),
WebSocketWSGIApplication(handler_cls=VolumeServer))
def handleHup(signum, frame):
print 'SIGHUP received: taking no action...'
def handleTerm(signum, frame):
print 'SIGTERM received: closing down...'
server.stop()
signal.signal(signal.SIGHUP, handleHup)
signal.signal(signal.SIGTERM, handleTerm)
server.serve_forever()
except KeyboardInterrupt:
pass
except Termination:
def main():
config = copy.deepcopy(SHARED_DEFAULTS)
parser = argparse.ArgumentParser(add_help=True)
parser.add_argument(
"-i", "--ini", dest="ini", help="Config file path", default=None
)
parser.add_argument(
"-v",
"--version",
dest="version",
help="Print version info and exit",
default=None,
nargs="*",
)
args = parser.parse_args()
if args.version is not None:
print(channelstream.__version__)
exit()
ini_path = args.ini or os.environ.get("CHANNELSTREAM_INI")
# set values from ini/cli
if ini_path:
parser = configparser.ConfigParser()
parser.read(ini_path)
settings = dict(parser.items("channelstream"))
for key in CONFIGURABLE_PARAMS:
try:
config[key] = settings[key]
except KeyError:
pass
else:
for key in CONFIGURABLE_PARAMS:
conf_value = os.environ.get(f"channelstream_{key}".upper())
if conf_value is not None:
config[key] = conf_value
config = set_config_types(config)
log_level = getattr(logging, (config.get("log_level") or "INFO").upper())
logging.basicConfig(level=log_level)
log.setLevel(log_level)
log.debug(pprint.pformat(config))
log.info("Starting channelstream {}".format(channelstream.__version__))
url = "http://{}:{}".format(config["host"], config["port"])
log.info("Starting flash policy server on port 10843")
gevent.spawn(gc_conns_forever)
gevent.spawn(gc_users_forever)
server = StreamServer(("0.0.0.0", 10843), client_handle)
server.start()
log.info("Serving on {}".format(url))
log.info("Admin interface available on {}/admin".format(url))
if config["secret"] == "secret":
log.warning("Using default secret! Remember to set that for production.")
if config["admin_secret"] == "admin_secret":
log.warning("Using default admin secret! Remember to set that for production.")
log.warning(f"IP's allowed to post to API {config['allow_posting_from']}")
server = WSGIServer(
(config["host"], config["port"]),
RoutingApplication(config),
log=logging.getLogger("channelstream.WSGIServer"),
)
server.serve_forever()
channel = '%s-%d' % (to_type, to_id)
from_type = self.user_type
from_id = self.obj.oid
msg['path'] = data['path']
msg['from_type'] = from_type
msg['from_id'] = from_id
if 'body' in msg:
created_at = Message.save(from_type, from_id, to_type, to_id,
msg['body'])
msg['created_at'] = created_at
ret = self.redis.publish(channel, json.dumps(msg))
return {'status': 'ok'}
def message(self, data):
print 'message.data:', data
msg = {'body': data['body']}
return self._message(data, msg)
def typing(self, data):
msg = {'typing': data['typing']} # True | False
return self._message(data, msg)
### API methods END ###
server = WSGIServer(('0.0.0.0', 9000),
WebSocketWSGIApplication(handler_cls=ChatWebSocket))
server.serve_forever()
