def cli_server_socketio(
managed,
listen=None,
application=None,
port=None,
**kwargs
):
try:
from socketio.server import SocketIOServer
except ImportError:
print(
'import of socketio.server failed, bailing',
file=sys.stderr,
)
sys.exit(1)
if not managed and application is None:
# inspect the caller
outer_frame = inspect.getouterframes(inspect.currentframe())[2][0]
app = outer_frame.f_globals['application']
else:
app = application
# Managed (i.e. invoked by 'rain serve') invocations doesn't have the
# ``listen`` parameter passed in, but have ``port`` set.
# Just make up one listening on localhost.
if managed and listen is None:
listen = ('0.0.0.0', port, )
server = SocketIOServer(listen, app, **kwargs)
server.serve_forever()
def socketio_server():
server = SocketIOServer(
('0.0.0.0', port),
SocketApp(),
policy_server=False)
server.start()
server.serve_forever()
def run_dev_server():
global server
app.debug = True
port = 5000
dapp = DebuggedApplicationFix(app, evalex = True)
server = SocketIOServer(('' if len(sys.argv) == 1 else sys.argv[1], port), dapp, resource="socket.io")
server.serve_forever()
def main(self, host, port):
got_request_exception.connect(exception_printer)
self.stdout.write('Serving at {host}:{port}\n'.format(host = host, port = port))
application = WSGIHandler()
server = SocketIOServer((host, port), application, namespace = 'socket.io', policy_server = False)
server.serve_forever()
def handle(self, addrport="", *args, **options):
if not addrport:
self.addr = ""
self.port = DEFAULT_PORT
else:
m = match(naiveip_re, addrport)
if m is None:
raise CommandError('"%s" is not a valid port number ' "or address:port pair." % addrport)
self.addr, _, _, _, self.port = m.groups()
environ["DJANGO_SOCKETIO_PORT"] = str(self.port)
if options.get("use_reloader"):
start_new_thread(reload_watcher, ())
try:
bind = (self.addr, int(self.port))
print "SocketIOServer running on %s:%s\n\n" % bind
handler = self.get_handler(*args, **options)
server = SocketIOServer(bind, handler, resource="socket.io", policy_server=True)
server.serve_forever()
except KeyboardInterrupt:
for key, sock in six.iteritems(server.sockets):
sock.kill(detach=True)
server.stop()
if RELOAD:
print "Reloading...\n\n"
restart_with_reloader()
def spawn_server(func, port):
print "Serving port", port, func.__name__
server = SocketIOServer(("localhost", port), func,
spawn=greenlet_pool,
cors="http://localhost:3000",
policy_server=False)
server.serve_forever()
def run_gevent_server(self):
server = SocketIOServer(
(self.host, self.port),
self.app, namespace='socket.io',
policy_server=False)
log.info('Web server running on %s:%s', self.host, self.port)
server.serve_forever()
def start_server(self, addrport="", *args, **options):
if not addrport:
self.addr = '127.0.0.1'
self.port = DEFAULT_PORT
else:
m = match(naiveip_re, addrport)
if m is None:
raise CommandError('"%s" is not a valid port number '
'or address:port pair.' % addrport)
self.addr, _, _, _, self.port = m.groups()
# Make the port available here for the path:
# socketio_tags.socketio ->
# socketio_scripts.html ->
# io.Socket JS constructor
# allowing the port to be set as the client-side default there.
environ["DJANGO_SOCKETIO_PORT"] = str(self.port)
bind = (self.addr, int(self.port))
print
print "SocketIOServer running on http://%s:%s" % bind
print
handler = self.get_handler(*args, **options)
server = SocketIOServer(bind, handler, resource="zircon",
policy_server=True)
server.serve_forever()
def run(addrport, opts):
if not addrport:
addr = ''
port = settings.SIO_PORT
else:
m = match(naiveip_re, addrport)
if m is None:
raise Exception('"%s" is not a valid port number '
'or address:port pair.' % addrport)
addr, _, _, _, port = m.groups()
# Make the port available here for the path:
# socketio_tags.socketio ->
# socketio_scripts.html ->
# io.Socket JS constructor
# allowing the port to be set as the client-side default there.
os.environ["DJANGO_SOCKETIO_PORT"] = str(port)
django.setup()
try:
bind = (addr, int(port))
print
print "SocketIOServer running on %s:%s" % bind
print
#inject this setting - needed to initialize zmq in 'green' mode
settings._wrapped.USE_GEVENT=True
handler = get_handler(static=opts.use_static_handler)
server = SocketIOServer(bind, handler, resource="socket.io", policy_server=True)
server.serve_forever()
except KeyboardInterrupt:
pass
def start_server(host_address):
try:
server = SocketIOServer(host_address, app, resource='socket.io')
server.serve_forever()
except:
# assume for now server is already running
pass
def socketio_server():
#server = SocketIOServer(('0.0.0.0', 0), SocketApp(), policy_server=False)
server = SocketIOServer(('0.0.0.0', 38477), SocketApp(), policy_server=False)
server.start()
port = server.socket.getsockname()[1]
print 'http://localhost:'+str(port)+'/'
server.serve_forever()
def handle(self, addrport="", *args, **options):
if not addrport:
self.addr = ''
self.port = DEFAULT_PORT
else:
m = match(naiveip_re, addrport)
if m is None:
raise CommandError('"%s" is not a valid port number '
'or address:port pair.' % addrport)
self.addr, _, _, _, self.port = m.groups()
# Make the port available here for the path:
# socketio_tags.socketio ->
# socketio_scripts.html ->
# io.Socket JS constructor
# allowing the port to be set as the client-side default there.
environ["DJANGO_SOCKETIO_PORT"] = str(self.port)
start_new_thread(reload_watcher, ())
try:
bind = (self.addr, int(self.port))
print
print "SocketIOServer running on %s:%s" % bind
print
handler = self.get_handler(*args, **options)
server = SocketIOServer(bind, handler, resource="socket.io", policy_server=True)
server.serve_forever()
except KeyboardInterrupt:
if RELOAD:
server.stop()
print "Reloading..."
restart_with_reloader()
else:
raise
def foo():
server = SocketIOServer(
(host, port),
app,
namespace="socket.io",
policy_server=False
)
server.serve_forever()
def run_server():
#app.run('0.0.0.0', 8080, debug=True)
global app
print 'Starting SocketIO Server with Gevent Mode ...'
app = SharedDataMiddleware(app, {})
http_server = SocketIOServer(('', 80), app, namespace="socket.io", policy_server=False)
http_server.serve_forever()
def main():
parser = argparse.ArgumentParser(description='Marteau Server')
parser.add_argument('config', help='Config file', nargs='?')
parser.add_argument('--version', action='store_true',
default=False,
help='Displays Marteau version and exits.')
parser.add_argument('--log-level', dest='loglevel', default='info',
choices=LOG_LEVELS.keys() + [key.upper() for key in
LOG_LEVELS.keys()],
help="log level")
parser.add_argument('--log-output', dest='logoutput', default='-',
help="log output")
parser.add_argument('--host', help='Host', default='0.0.0.0')
parser.add_argument('--port', help='Port', type=int, default=8080)
args = parser.parse_args()
if args.version:
print(__version__)
sys.exit(0)
if args.config is None:
parser.print_usage()
sys.exit(0)
# configure the logger
configure_logger(logger, args.loglevel, args.logoutput)
# loading the config file
config = Config(args.config)
# loading the app & the queue
global_config = {}
if config.has_section('marteau'):
settings = config.get_map('marteau')
else:
settings = {}
# check is redis is running
if not redis_available():
raise IOError('Marteau needs Redis to run.')
# loading the fixtures plugins
for fixture in settings.get('fixtures', []):
import_string(fixture)
logger.info('Loaded plugins: %s' % ', '.join(get_fixtures()))
app = webapp(global_config, **settings)
try:
httpd = SocketIOServer((args.host, args.port), app,
resource="socket.io", policy_server=False)
logger.info('Hammer ready, at http://%s:%s. Where are the nails ?' %
(args.host, args.port))
httpd.serve_forever()
except KeyboardInterrupt:
sys.exit(0)
finally:
logger.info('Bye!')
def main():
global PORT
if len(sys.argv)>1:
PORT=int(sys.argv[1])
http_server = SocketIOServer(
('', PORT),App(),
policy_server=False, resource='socket.io'
)
# Start the server greenlets
http_server.serve_forever()
def start_server(host, port, hide_status, debug):
app.debug = bool(debug)
app.reloaded['hide_status'] = bool(hide_status)
server = SocketIOServer((host, int(port)), app, resource='socket.io')
print "Reloaded server started serving on: {}:{}.".format(host, port)
try:
server.serve_forever()
except socket.error:
print ("Reloaded server could not bind to port: {}. Is reloaded already"
" running?".format(port))
sys.exit(1)
def main():
# Load application and config.
app = loadapp('config:%s' % cfgfile, relative_to='.')
server = SocketIOServer((host, port), app,
namespace="socket.io")
try:
print "Serving on %s:%d (http://127.0.0.1:%d) ..." % (host, port, port)
server.serve_forever()
except socket.error, e:
print "ERROR SERVING WSGI APP: %s" % e
sys.exit(1)
def run_socket_server(addr, port, *args, **options):
bind = (addr, int(port))
print
print "SocketIOServer running on %s:%s" % bind
print
handler = get_handler(*args, **options)
server = SocketIOServer(bind, handler,
heartbeat_interval=5,
heartbeat_timeout=30,
resource="socket.io",
policy_server=True)
server.serve_forever()
def handle(self, addrport="", **kwargs):
if not addrport:
self.addr = "127.0.0.1"
self.port = 9000
else:
m = match(naiveip_re, addrport)
if m is None:
raise CommandError('"%s" is not a valid port number '
'or address:port pair.' % addrport)
self.addr, _, _, _, self.port = m.groups()
server = SocketIOServer((self.addr, int(self.port)), application)
server.serve_forever()
def run():
ip_addr = socket.gethostbyname(socket.gethostname())
print "Listening on %s:%d" % (ip_addr, 5000 if DEBUG else 80)
log = WriteWrapper(sys.stdout, socketioserver_tf_msg)
server = SocketIOServer(("", 5000 if DEBUG else 80),
app,
resource="socket.io",
log = log)
try:
server.serve_forever()
except KeyboardInterrupt:
disconnect()
print " Server Killed"
def main():
def signal_handler(signal, frame):
print "Received signal %s scheduling shutdown..." % signal
server.stop()
signal.signal(signal.SIGINT, signal_handler)
signal.signal(signal.SIGTERM, signal_handler)
print 'Listening %s:%s and port 10843 (flash policy)' % (HOST, PORT)
server = SocketIOServer(
(HOST, PORT), Application(),
resource="socket.io", policy_server=True,
policy_listener=(HOST, 10843))
server.serve_forever()
def init_webui(self):
""" Initialize and start the flask based webui. This does not check if it is
enabled, so that must happen prior to calling this
:return:
:rtype:
"""
host = config.get_default('flask', 'listen_host', 'localhost')
port = config.get_default('flask', 'listen_port', 5000, int)
from tranny.app import create_app
wsgi_app = create_app()
socketio_app = SocketIOServer((host, port), wsgi_app, resource='socket.io')
socketio_app.serve_forever()
def serve_forever(django=False):
"""Starts the gevent-socketio server."""
logger = getLogger("irc.dispatch")
logger.setLevel(settings.LOG_LEVEL)
logger.addHandler(StreamHandler())
app = IRCApplication(django)
server = SocketIOServer((settings.HTTP_HOST, settings.HTTP_PORT), app)
print "%s [%s] listening on %s:%s" % (
settings.CHAT_VERSION_STRING,
app.bot.__class__.__name__,
settings.HTTP_HOST,
settings.HTTP_PORT,
)
server.serve_forever()
class WebService:
def __init__(self, bindAddress, port):
self.__port = port
self.__bindAddr = bindAddress
print("Web server starting on " + self.__bindAddr + ":" + str(self.__port) + "...");
self.webThread = threading.Thread(target=self.__start)
self.webThread.daemon = True
self.webThread.start()
def __start(self):
self.server = SocketIOServer((self.__bindAddr, self.__port), Application())
gevent.spawn(self.__onStart)
self.server.serve_forever()
def __onStart(self):
print("Web server started on " + self.__bindAddr + ":" + str(self.__port))
def __broadcast(self, eventName, *args):
pkt = dict(type="event",
name=eventName,
args=args,
endpoint="/pop")
for sessid, socket in self.server.sockets.iteritems():
socket.send_packet(pkt)
# TODO: These "on" methods should be handled by Observer...
def onSwipeStart(self):
self.__broadcast("member-swipe-start")
def onSwipe(self, credit, cost):
self.__broadcast("member-swipe", credit, cost)
def onDeposit(self, cents):
self.__broadcast("deposit", cents)
def onPaid(self, newCredit):
self.__broadcast("paid", newCredit)
def onNotFound(self):
self.__broadcast("not-found")
def onCreditOnly(self):
self.__broadcast("credit-only")
def onCreditCompleted(self, newCredit):
self.__broadcast("credit-completed", newCredit)
def shutdown(self):
return # Nothing to do
def cli_server_socketio(
managed,
listen=None,
application=None,
port=None,
uid=None,
gid=None,
**kwargs
):
try:
from socketio.server import SocketIOServer
except ImportError:
print(
'import of socketio.server failed, bailing',
file=sys.stderr,
)
sys.exit(1)
if not managed and application is None:
# inspect the caller
outer_frame = inspect.getouterframes(inspect.currentframe())[2][0]
app = outer_frame.f_globals['application']
else:
app = application
# Managed (i.e. invoked by 'rain serve') invocations doesn't have the
# ``listen`` parameter passed in, but have ``port`` set.
# Just make up one listening on IPADDR_ANY.
if managed and listen is None:
listen = ('0.0.0.0', port, )
if uid is not None:
# Do the socket initialization early, then set{g,u}id.
sock = SocketIOServer.get_listener(
listen[0],
kwargs.get('backlog', None),
None, # TODO: more sensible default for family
)
if gid is not None:
os.setgid(gid)
os.setuid(uid)
# Use the constructed socket.
server = SocketIOServer(sock, app, **kwargs)
else:
server = SocketIOServer(listen, app, **kwargs)
server.serve_forever()
def run(self):
try:
print 'Listening at %s port %d...' % (self.host, self.port)
SocketIONamespace.set_app_class(self.app_class)
if self.debug:
self.flask_app = SocketIODebugger(self.flask_app,
evalex=True, namespace=SocketIONamespace)
server = SocketIOServer((self.host, self.port), self.flask_app,
resource='socket.io', policy_server=False)
if self.debug:
run_with_reloader(server.serve_forever)
else:
server.serve_forever()
except KeyboardInterrupt:
print '\rShutting down...'
def serve_forever(self):
"""Load dbs and run gevent wsgi server"""
from socketio.server import SocketIOServer
server = SocketIOServer((self.args.interface, int(self.args.port)),
self.application, resource="socket.io",
policy_server=False)
logger.info("Start socket.io server %r:%r",
self.args.interface, self.args.port)
try:
server.serve_forever()
except KeyboardInterrupt:
for socket in server.sockets.values():
for namespace in socket.active_ns.values():
if hasattr(namespace, 'stop_server'):
namespace.stop_server()
def __init__ (self, rz_config, wsgi_app):
self.wsgi_app = wsgi_app
sock_addr = (rz_config.listen_address, rz_config.listen_port)
SocketIOServer.__init__(self,
sock_addr,
wsgi_app,
close_timeout=60,
policy_server=False,
heartbeat_interval=20, # should be less than the heartbeat_timeout
heartbeat_timeout=40,
handler_class=RZ_WebSocket_Server.RZ_SocketIOHandler,
resource='socket.io', # URL prefix for socket.io requests
ws_handler_class=RZ_WebSocket_Server.RZ_WebSocketHandler)
self.req_probe__sock_addr = None
def handle(self, addrport='', *args, **options):
"""
Parses all arguments and starts the server. Will reload on
SIGINT unless the --noreload flag is passed.
"""
if options.get('enable_coverage'):
print "Enabling coverage for socketio server."
coverage_omit = ['*/management/*',
'*/migrations/*']
cov = coverage.coverage(source=['deckr'],
omit=coverage_omit,
data_suffix=True)
cov.start()
if not addrport:
self.addr = ''
self.port = DEFAULT_PORT
else:
address_match = match(naiveip_re, addrport)
if address_match is None:
raise CommandError('"%s" is not a valid port number '
'or address:port pair.' % addrport)
self.addr, _, _, _, self.port = address_match.groups()
environ['DJANGO_SOCKETIO_PORT'] = str(self.port)
if options.get('use_reloader'):
start_new_thread(reload_watcher, ())
try:
bind = (self.addr, int(self.port))
print 'SocketIOServer running on %s:%s\n\n' % bind
handler = get_handler(**options)
server = SocketIOServer(
bind, handler, resource='socket.io', policy_server=True)
server.serve_forever()
except KeyboardInterrupt:
server.stop()
if options.get('enable_coverage'):
cov.stop()
cov.save()
if RELOAD:
print 'Reloading...\n\n'
restart_with_reloader()
# -*- coding: utf-8 -*-
from gevent import monkey
monkey.patch_all()
import os
from psycogreen.gevent import patch_psycopg
os.environ.setdefault("DJANGO_SETTINGS_MODULE", "socketioapp.settings")
patch_psycopg()
from django.core.wsgi import get_wsgi_application
application = get_wsgi_application()
if __name__ == '__main__':
from socketio.server import SocketIOServer
server = SocketIOServer(('', 8000), application, resource="socket.io")
server.serve_forever()
def on_user_message(self, msg):
self.emit_to_room('main_room', 'msg_to_room', self.socket.session['nickname'], msg)
def recv_message(self, message):
print "PING!!!", message
# Flask routes
app = Flask(__name__)
@app.route('/')
def index():
return render_template('chat.html')
@app.route("/socket.io/<path:path>")
def run_socketio(path):
socketio_manage(request.environ, {'': ChatNamespace})
if __name__ == '__main__':
print 'Listening on http://localhost:8080'
app.debug = True
import os
from werkzeug.wsgi import SharedDataMiddleware
app = SharedDataMiddleware(app, {
'/': os.path.join(os.path.dirname(__file__), 'static')
})
from socketio.server import SocketIOServer
SocketIOServer(('0.0.0.0', 8080), app,
resource="socket.io", policy_server=False).serve_forever()
def handle(self, *args, **options):
from django.core.wsgi import get_wsgi_application
application = get_wsgi_application()
from socketio.server import SocketIOServer
server = SocketIOServer(('', 8001), application, resource="socket.io")
server.serve_forever()
import os
from gevent import monkey
monkey.patch_all()
from django.core.wsgi import get_wsgi_application
from socketio.server import SocketIOServer
PORT = 9000
os.environ.setdefault("DJANGO_SETTINGS_MODULE",
"djangosocketioexample.settings")
application = get_wsgi_application()
if __name__ == '__main__':
print('Listening on http://127.0.0.1:%s and on port 843 \
(flash policy server)' % PORT)
SocketIOServer(('', PORT), application,
resource="socket.io").serve_forever()
elif path.endswith(".swf"):
content_type = "application/x-shockwave-flash"
else:
content_type = "text/html"
start_response('200 OK', [('Content-Type', content_type)])
return [data]
# socketIO request
if path.startswith('socket.io/'):
socketio_manage(env, {'': LogStreamNS})
else:
return http404(start_response)
if __name__ == '__main__':
""" Main command line run """
try:
server = SocketIOServer(('0.0.0.0', 8000),
application,
resource='socket.io',
policy_server=True,
policy_listener=('0.0.0.0', 10843))
sub = gevent.spawn(SubLogger)
sub.link(server.stop)
server.serve_forever()
except KeyboardInterrupt:
server.stop()
def socketio_server(q):
server = SocketIOServer(('0.0.0.0', 0), SocketApp(), policy_server=False)
server.start()
port = server.socket.getsockname()[1]
q.put(port)
server.serve_forever()
from chat import app, init_chat
from gevent import monkey
from socketio.server import SocketIOServer
monkey.patch_all()
LISTEN_IP = '10.240.220.185'
LISTEN_PORT = 5000
if __name__ == '__main__':
init_chat()
print 'Listening on http://%s:%s and on port 10843 (flash policy server)' % (
LISTEN_IP, LISTEN_PORT)
SocketIOServer((LISTEN_IP, LISTEN_PORT), app,
resource="socket.io").serve_forever()
def run_server():
log.info(' * Running on http://%s:%d/' % (options.hostname, options.port))
SocketIOServer((options.hostname, options.port), get_app(MyDebuggedApplication), resource="socket.io", **ctx).serve_forever()
self.buffer = []
# Dummy request object to maintain state between Namespace
# initialization.
self.request = {}
self.django = WSGIHandler()
def __call__(self, environ, start_response):
path = environ['PATH_INFO'].strip('/')
if path.startswith("socket.io"):
# here we hand off this request to a blocking socketio manager
# the Namespace subclass handles all the socketio messages
socketio_manage(environ, {'': ColorsNamespace}, self.request)
else:
return self.django(environ, start_response)
if __name__ == '__main__':
print 'starting gevent server'
port = 80
try:
port = int(os.environ['PORT'])
except KeyError as e:
pass
print "port", port
SocketIOServer(('0.0.0.0', port),
Application(),
resource="socket.io",
transports=['websocket'],
policy_server=False).serve_forever()
def run_dev_server():
app.debug = True
port = 4200
print(" * Running on http://127.0.0.1:%i/" % port)
SocketIOServer(("", port), app, resource="socket.io").serve_forever()
except Exception:
return not_found(start_response)
if path.endswith(".js"):
content_type = "text/javascript"
elif path.endswith(".css"):
content_type = "text/css"
else:
content_type = "text/html"
start_response('200 OK', [('Content-Type', content_type)])
return [data]
if path.startswith("socket.io"):
#pdb.set_trace()
socketio_manage(environ, {'': gdbServer}, self.request)
else:
return not_found(start_response)
def not_found(start_response):
start_response('404 Not Found', [])
return ['<h1>Not Found</h1>']
if __name__ == '__main__':
port = int(os.getenv('PORT', 8000))
print 'Listening on port {}'.format(port)
SocketIOServer(('0.0.0.0', port), Application(),
resource="socket.io").serve_forever()
content_type = "application/x-shockwave-flash"
else:
content_type = "text/html"
start_response('200 OK', [('Content-Type', content_type)])
return [data]
if path.startswith("socket.io"):
socketio_manage(environ, {'/mindflex': BaseNamespace})
print 'socketio ready'
else:
return not_found(start_response)
def not_found(start_response):
start_response('404 Not Found', [])
return ['<h1>Not Found</h1>']
if __name__ == '__main__':
print '''Listening on port 8080
and on port 10843 (flash policy server)'''
server = SocketIOServer(('0.0.0.0', 8080),
Application(),
resource="socket.io",
policy_server=True,
policy_listener=('0.0.0.0', 10843))
connection = MindFlexConnection()
gevent.spawn(read_mindflex, server, connection)
server.serve_forever()
def make_server(namespaces):
return SocketIOServer(('0.0.0.0', 51324),
Application(namespaces),
resource="socket.io")
sendstr = 'data:image/jpeg;base64,' + output.getvalue().encode(
'base64')
self.emit('update', sendstr)
# Flask routes
app = Flask(__name__)
@app.route('/')
def index():
return send_file('static/index.html')
@app.route("/socket.io/<path:path>")
def run_socketio(path):
socketio_manage(request.environ, {'': SimpleCVNamespace})
if __name__ == '__main__':
print 'Listening on http://localhost:8081'
app.debug = True
from werkzeug.wsgi import SharedDataMiddleware
app = SharedDataMiddleware(
app, {'/': os.path.join(os.path.dirname(__file__), 'static')})
from socketio.server import SocketIOServer
SocketIOServer(('0.0.0.0', 8081),
app,
namespace="socket.io",
policy_server=False).serve_forever()
import sys
import logging
log = logging.getLogger(__name__)
from bradmin import app
from gevent.wsgi import WSGIServer
from socketio.server import SocketIOServer
if __name__ == "__main__":
import gevent
from gevent import monkey
monkey.patch_all()
from gevent.wsgi import WSGIServer
logging.basicConfig(stream=sys.stderr)
# app.debug = True
# app.run(host='0.0.0.0', port=80)
# app.run(host='::')
# http_server = WSGIServer(('::', 80), app)
# http_server.serve_forever()
SocketIOServer(('::', 80), app, resource="socket.io").serve_forever()
def run_dev_server():
app.debug = True
port = 6020
SocketIOServer(('', port), app, resource="socket.io").serve_forever()
if not path:
start_response('200 OK', [('Content-Type', 'text/html')])
return [
'<h1>Welcome. '
'Try the <a href="/chat.html">chat</a> example.</h1>'
]
if path == 'chat.html':
html = open("client2.html").read()
start_response('200 OK', [('Content-Type', "text/html")])
return [html]
if path.startswith("socket.io"):
socketio_manage(environ, {'/chat': ChatNamespace}, {})
else:
return not_found(start_response)
def not_found(start_response):
start_response('404 Not Found', [])
return ['<h1>Not Found</h1>']
if __name__ == '__main__':
print 'Listening on port 8085 and on port 843 (flash policy server)'
SocketIOServer(('0.0.0.0', 8085),
serve_request,
resource="socket.io",
policy_server=True,
policy_listener=('0.0.0.0', 10843)).serve_forever()
if path.endswith(".js"):
content_type = "text/javascript"
elif path.endswith(".png"):
content_type = "image/png"
elif path.endswith(".css"):
content_type = "text/css"
else:
content_type = "text/html"
start_response('200 OK', [('Content-Type', content_type)])
return [data]
if path.startswith("socket.io"):
socketio_manage(environ, {'': MultiPlayerNamespace})
else:
return notFound(start_response)
def notFound(start_response):
start_response("404", [])
return ["404"]
if __name__ == "__main__":
port = 8080
print("start listening on localhost:" + str(port) + "...")
server = SocketIOServer(("0.0.0.0", port), App(), policy_server=False)
gevent.spawn(broadcastData, server)
server.serve_forever()
from server import app
from gevent import monkey
import argparse
from socketio.server import SocketIOServer
monkey.patch_all()
parser = argparse.ArgumentParser(description='Simple deep-tac-toe flask app.')
parser.add_argument('port', type=int, default=80, help='HTTP port for app')
if __name__ == '__main__':
args = parser.parse_args()
print 'Listening on http://127.0.0.1:%s and on port 10843 (flash policy server)' % args.port
SocketIOServer(('', args.port), app, resource="socket.io").serve_forever()
def run():
reload(sys)
sys.setdefaultencoding('utf8')
try:
locale.setlocale(locale.LC_ALL, '')
except:
logging.warning('Couldn\'t set default locale')
logging.info('Ajenti %s running on platform: %s' % (ajenti.version, ajenti.platform))
if ajenti.debug:
def cmd_list_instances(ctx=None):
import pprint
if not ctx:
from ajenti.plugins import manager
ctx = manager.context
pprint.pprint(ctx._get_all_instances())
def cmd_sessions():
import pprint
sessions = SessionMiddleware.get(manager.context).sessions
return sessions
def cmd_list_instances_session():
cmd_list_instances(cmd_sessions().values()[0].appcontext)
exconsole.register(commands=[
('_manager', 'PluginManager', ajenti.plugins.manager),
('_instances', 'return all @plugin instances', cmd_list_instances),
('_sessions', 'return all Sessions', cmd_sessions),
('_instances_session', 'return all @plugin instances in session #0', cmd_list_instances_session),
])
# Load plugins
ajenti.plugins.manager.load_all()
bind_spec = (ajenti.config.tree.http_binding.host, ajenti.config.tree.http_binding.port)
if ':' in bind_spec[0]:
addrs = socket.getaddrinfo(bind_spec[0], bind_spec[1], socket.AF_INET6, 0, socket.SOL_TCP)
bind_spec = addrs[0][-1]
# Fix stupid socketio bug (it tries to do *args[0][0])
socket.socket.__getitem__ = lambda x, y: None
logging.info('Starting server on %s' % (bind_spec, ))
if bind_spec[0].startswith('/'):
if os.path.exists(bind_spec[0]):
os.unlink(bind_spec[0])
listener = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
try:
listener.bind(bind_spec[0])
except:
logging.error('Could not bind to %s' % bind_spec[0])
sys.exit(1)
listener.listen(10)
else:
listener = socket.socket(socket.AF_INET6 if ':' in bind_spec[0] else socket.AF_INET, socket.SOCK_STREAM)
try:
listener.setsockopt(socket.IPPROTO_TCP, socket.TCP_CORK, 1)
except:
try:
socket.TCP_NOPUSH = 4
listener.setsockopt(socket.IPPROTO_TCP, socket.TCP_NOPUSH, 1)
except:
logging.warn('Could not set TCP_CORK/TCP_NOPUSH')
listener.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
try:
listener.bind(bind_spec)
except:
logging.error('Could not bind to %s' % (bind_spec,))
sys.exit(1)
listener.listen(10)
stack = [
SessionMiddleware.get(manager.context),
AuthenticationMiddleware.get(manager.context),
CentralDispatcher.get(manager.context)
]
ssl_args = {}
if ajenti.config.tree.ssl.enable:
ssl_args['certfile'] = ajenti.config.tree.ssl.certificate_path
ajenti.server = SocketIOServer(
listener,
log=open(os.devnull, 'w'),
application=HttpRoot(stack).dispatch,
policy_server=False,
resource='ajenti:socket',
**ssl_args
)
# auth.log
try:
syslog.openlog(
ident=str(b'ajenti'),
facility=syslog.LOG_AUTH,
)
except:
syslog.openlog(b'ajenti')
try:
gevent.signal(signal.SIGTERM, lambda: sys.exit(0))
except:
pass
ajenti.feedback.start()
ajenti.ipc.IPCServer.get(manager.context).start()
Inflater.get(manager.context).precache()
ajenti.server.serve_forever()
if hasattr(ajenti.server, 'restart_marker'):
logging.warn('Restarting by request')
fd = 20 # Close all descriptors. Creepy thing
while fd > 2:
try:
os.close(fd)
logging.debug('Closed descriptor #%i' % fd)
except:
pass
fd -= 1
os.execv(sys.argv[0], sys.argv)
else:
logging.info('Stopped by request')
def run(config=None, plugin_providers=None, product_name='ajenti', dev_mode=False,
debug_mode=False, autologin=False):
"""
A global entry point for Ajenti.
:param config: config file implementation instance to use
:type config: :class:`aj.config.BaseConfig`
:param plugin_providers: list of plugin providers to load plugins from
:type plugin_providers: list(:class:`aj.plugins.PluginProvider`)
:param str product_name: a product name to use
:param bool dev_mode: enables dev mode (automatic resource recompilation)
:param bool debug_mode: enables debug mode (verbose and extra logging)
:param bool autologin: disables authentication and logs everyone in as the user running the panel. This is EXTREMELY INSECURE.
"""
if config is None:
raise TypeError('`config` can\'t be None')
reload_module(sys)
if hasattr(sys, 'setdefaultencoding'):
sys.setdefaultencoding('utf8')
aj.product = product_name
aj.debug = debug_mode
aj.dev = dev_mode
aj.dev_autologin = autologin
aj.init()
aj.log.set_log_params(tag='master', master_pid=os.getpid())
aj.context = Context()
aj.config = config
aj.plugin_providers = plugin_providers or []
logging.info('Loading config from %s', aj.config)
aj.config.load()
aj.config.ensure_structure()
if aj.debug:
logging.warn('Debug mode')
if aj.dev:
logging.warn('Dev mode')
try:
locale.setlocale(locale.LC_ALL, '')
except locale.Error:
logging.warning('Couldn\'t set default locale')
# install a passthrough gettext replacement since all localization is handled in frontend
# and _() is here only for string extraction
__builtins__['_'] = lambda x: x
logging.info('Ajenti Core %s', aj.version)
logging.info('Detected platform: %s / %s', aj.platform, aj.platform_string)
# Load plugins
PluginManager.get(aj.context).load_all_from(aj.plugin_providers)
if len(PluginManager.get(aj.context)) == 0:
logging.warn('No plugins were loaded!')
if aj.config.data['bind']['mode'] == 'unix':
path = aj.config.data['bind']['socket']
if os.path.exists(path):
os.unlink(path)
listener = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
try:
listener.bind(path)
except OSError:
logging.error('Could not bind to %s', path)
sys.exit(1)
if aj.config.data['bind']['mode'] == 'tcp':
host = aj.config.data['bind']['host']
port = aj.config.data['bind']['port']
listener = socket.socket(
socket.AF_INET6 if ':' in host else socket.AF_INET, socket.SOCK_STREAM
)
if aj.platform not in ['freebsd', 'osx']:
try:
listener.setsockopt(socket.IPPROTO_TCP, socket.TCP_CORK, 1)
except socket.error:
logging.warn('Could not set TCP_CORK')
listener.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
logging.info('Binding to [%s]:%s', host, port)
try:
listener.bind((host, port))
except socket.error as e:
logging.error('Could not bind: %s', str(e))
sys.exit(1)
# Fix stupid socketio bug (it tries to do *args[0][0])
socket.socket.__getitem__ = lambda x, y: None
listener.listen(10)
gateway = GateMiddleware.get(aj.context)
application = HttpRoot(HttpMiddlewareAggregator([gateway])).dispatch
aj.server = SocketIOServer(
listener,
log=open(os.devnull, 'w'),
application=application,
handler_class=RequestHandler,
policy_server=False,
transports=[
str('websocket'),
str('flashsocket'),
str('xhr-polling'),
str('jsonp-polling'),
],
)
if aj.config.data['ssl']['enable'] and aj.config.data['bind']['mode'] == 'tcp':
context = SSL.Context(SSL.TLSv1_2_METHOD)
context.set_session_id(str(id(context)))
context.set_options(SSL.OP_NO_SSLv2 | SSL.OP_NO_SSLv3 | SSL.OP_NO_TLSv1 | SSL.OP_NO_TLSv1_1)
context.set_cipher_list('ALL:!ADH:!EXP:!LOW:!RC2:!3DES:!SEED:!RC4:+HIGH:+MEDIUM')
certificate = crypto.load_certificate(
crypto.FILETYPE_PEM,
open(aj.config.data['ssl']['certificate']).read()
)
private_key = crypto.load_privatekey(
crypto.FILETYPE_PEM,
open(aj.config.data['ssl']['certificate']).read()
)
context.use_certificate(certificate)
context.use_privatekey(private_key)
if aj.config.data['ssl']['client_auth']['enable']:
# todo harden files
logging.info('Enabling SSL client authentication')
context.add_client_ca(certificate)
context.get_cert_store().add_cert(certificate)
verify_flags = SSL.VERIFY_PEER
if aj.config.data['ssl']['client_auth']['force']:
verify_flags |= SSL.VERIFY_FAIL_IF_NO_PEER_CERT
context.set_verify(verify_flags, AuthenticationService.get(aj.context).client_certificate_callback)
context.set_verify_depth(0)
aj.server.ssl_args = {'server_side': True}
aj.server.wrap_socket = lambda socket, **ssl: SSLSocket(context, socket)
logging.info('SSL enabled')
# auth.log
try:
syslog.openlog(
ident=str(aj.product),
facility=syslog.LOG_AUTH,
)
except:
syslog.openlog(aj.product)
def cleanup():
if hasattr(cleanup, 'started'):
return
cleanup.started = True
logging.info('Process %s exiting normally', os.getpid())
gevent.signal(signal.SIGINT, lambda: None)
gevent.signal(signal.SIGTERM, lambda: None)
if aj.master:
gateway.destroy()
p = psutil.Process(os.getpid())
for c in p.children(recursive=True):
try:
os.killpg(c.pid, signal.SIGTERM)
os.killpg(c.pid, signal.SIGKILL)
except OSError:
pass
def signal_handler():
cleanup()
sys.exit(0)
gevent.signal(signal.SIGINT, signal_handler)
gevent.signal(signal.SIGTERM, signal_handler)
aj.server.serve_forever()
if not aj.master:
# child process, server is stopped, wait until killed
gevent.wait()
if hasattr(aj.server, 'restart_marker'):
logging.warn('Restarting by request')
cleanup()
fd = 20 # Close all descriptors. Creepy thing
while fd > 2:
try:
os.close(fd)
logging.debug('Closed descriptor #%i', fd)
except OSError:
pass
fd -= 1
logging.warn('Will restart the process now')
if '-d' in sys.argv:
sys.argv.remove('-d')
os.execv(sys.argv[0], sys.argv)
else:
if aj.master:
logging.debug('Server stopped')
cleanup()
from socketio.server import SocketIOServer
from pyramid.paster import get_app
from gevent import monkey; monkey.patch_all()
if __name__ == '__main__':
app = get_app('development.ini')
print 'Listening on port http://0.0.0.0:8080 and on port 10843 (flash policy server)'
SocketIOServer(('0.0.0.0', 8080), app,
resource="socket.io", policy_server=True,
policy_listener=('0.0.0.0', 10843)).serve_forever()
class FlaskService( ServiceBase):
TYPE = 'FlaskService'
def __init__(self, name):
super(FlaskService,self).__init__(name)
self.app = None
self.api_list = {} # 注册api
self.db = None
self.blueprints = {}
self.logger = Logger(__name__)
self.isclosed = False
self.thread = None
self.server = None
def init(self, cfgs, **kwargs):
#from mantis.fundamental.application.app import instance
if kwargs.has_key('logger'):
self.logger = kwargs.get('logger')
self.cfgs = cfgs
if kwargs.has_key('app'):
self.app = kwargs.get('app')
else:
static_path = os.getcwd()+'/static'
template_path = os.getcwd()+'/templates'
self.app = Flask(__name__,static_folder=static_path,template_folder=template_path) # flask会自动将当前代码目录设置为项目根目录 root_path 导致读取templtes , sta它ic 目录失败
Compress(self.app) # okay
# gzip = Gzip(app) # error
active = self.getConfig().get('cfgs',{})
for k, v in active.items():
self.app.config[k] = v
self.initCors()
self.initDatabase()
self.setupRequestHooks()
self.initBlueprint()
self.setupTemplates()
def setupTemplates(self):
from werkzeug.routing import BaseConverter
from flask import Flask, send_file
class RegexConverter(BaseConverter):
def __init__(self, map, *args):
self.map = map
self.regex = args[0]
self.app.url_map.converters['regex'] = RegexConverter
@self.app.route('/<regex(".*\.html$"):template_name>')
def _template_render(template_name):
name = os.path.join(self.app.template_folder, template_name)
return send_file(name)
def initDatabase(self):
global db
if db.get() is None:
self.db = SQLAlchemy(self.app)
db.set(self.db)
def getDatabase(self):
return self.db
def initCors(self):
"""
https://flask-cors.readthedocs.io/en/latest/
:return:
"""
if self.getConfig().get('cors_enable',True):
CORS(self.app)
def getFlaskApp(self):
return self.app
def setupRequestHooks(self):
self.app.before_request(self.onRequestBefore)
self.app.teardown_request(self.onRequestTeardown)
# self.app.after_request(self._requestAfter) # todo. 导致 send_file 失败
# 当利用send_file发送二进制数据时，after_request对返回数据进行日志处理，导致数据返回失败
def _traceRequestInfo(self,opts):
import json
trace_data = {'url':request.url}
if opts.get('header'):
trace_data['headers'] = request.headers
if opts.get('body'):
trace_data['body'] = request.data.replace('\n',' ')[:opts.get('max_size')]
return json.dumps( trace_data)
def _traceResponseInfo(self,opts,response):
import json
trace_data = {'url':request.url}
if opts.get('header'):
trace_data['headers'] = response.headers
if opts.get('body'):
trace_data['body'] = response.data.replace('\n',' ')[:opts.get('max_size')]
return json.dumps( trace_data)
def onRequestBefore(self):
# pass
import time
g.start_time = time.time()
#
# trace = self.getConfig().get('http_trace',{}).get('request',{})
# options = trace.get('options',{'header':False,'body':False,'max_size':1024})
# urls = trace.get('urls',[])
# #sort urls by 'match' with desceding.
# urls = sorted(urls,cmp = lambda x,y: cmp(len(x.get('match')) , len(y.get('match')) ) )
# urls.reverse()
#
# text = ''
# for url in urls:
# m = url.get('match')
# if m:
# opts = options.copy()
# opts['header'] = url.get('header',options.get('header'))
# opts['body'] = url.get('body',options.get('body'))
# opts['max_size'] = url.get('max_size',options.get('max_size'))
# if request.url.find(m) !=-1:
# text = self._traceRequestInfo(opts)
# break
# level = self.getConfig().get('http_trace',{}).get('level','DEBUG')
# text = 'HttpRequest: '+text
# self.getLogger().log(level,text)
def onRequestTeardown(self,e):
pass
def _requestAfter(self,response):
trace = self.getConfig().get('http_trace', {}).get('response', {})
options = trace.get('options', {'header': False, 'body': False, 'max_size': 1024})
urls = trace.get('urls', [])
urls = sorted(urls, cmp=lambda x, y: cmp(len(x.get('match')), len(y.get('match'))))
urls.reverse()
text = ''
for url in urls:
m = url.get('match')
if m:
opts = options.copy()
opts['header'] = url.get('header', options.get('header'))
opts['body'] = url.get('body', options.get('body'))
opts['max_size'] = url.get('max_size', options.get('max_size'))
if request.url.find(m) != -1:
text = self._traceResponseInfo(opts,response)
break
level = self.getConfig().get('http_trace', {}).get('level', 'DEBUG')
remote_addr = ''
if request.headers.getlist("X-Forwarded-For"):
remote_addr = request.headers.getlist("X-Forwarded-For")[0]
else:
remote_addr = request.remote_addr
elapsed = int((time.time() - g.start_time) * 1000)
text = 'HTTP %s %s %s %sms '%( remote_addr ,request.method,request.url,elapsed)
self.getLogger().log(level, text)
return response
def initBlueprint(self):
from mantis.fundamental.application.app import instance
from mantis.fundamental.parser.yamlparser import YamlConfigParser
etc_dir = instance.getConfigPath()
cfgs = self.getConfig().get('blueprints',[])
for cfg in cfgs:
# module = import_module( cfgs.get('module'))
if not cfg.get('register',True):
continue
package_name = cfg.get('name','')
package = cfg.get('package')
package_url = cfg.get('url')
modules = cfg.get('modules',[])
for module in modules:
module_name = module.get('name',)
module_url = module.get("url",'')
path = '%s.%s'%(package,module_name)
load_module = import_module(path)
app = Blueprint(module_name,path)
self.blueprints[path] = app
# api_module = {'name': u'%s.%s'%(package_name,module_name),'api_list':[]}
module_name = u'%s.%s'%(package_name,module_name)
self.api_list[module_name] = []
routes = module.get('routes', [])
import_urls = module.get('import')
if import_urls:
import_path = os.path.join(etc_dir,import_urls)
urls = YamlConfigParser(import_path).props.get('routes',[])
for _ in urls:
routes.append(_)
for route in routes:
url = route.get('url','')
name = route.get('name','')
methods = filter(lambda x:len(x)>0,route.get('methods','').strip().upper().split(','))
if hasattr( load_module,name):
func = getattr( load_module,name)
path = package_url+module_url
path = path.replace('//','/')
if methods:
app.route(url,methods=methods)(func)
else:
app.route(url)(func)
self.registerBlueprint(app,path)
# path = path + '/' + url
path = path + url # todo. 2018.11.04
path = path.replace('//','/')
self.logger.debug('registered blueprint route:'+path)
api = {'url': path,
'methods': ('GET',)}
if methods:
api['methods'] = methods
self.api_list[module_name].append(api)
def registerAPIs(self,manager):
manager.register_http_service(self.api_list)
# def _initLogger(self):
# from camel.biz.logging.logger import FlaskHttpRequestLogger
# return FlaskHttpRequestLogger(self.appId)
# def start(self,block = True):
# # Application.run(self)
# http = self.getConfig().get('http')
# if http:
# self.app.run(host=http.get('host','127.0.0.1'),
# port = http.get('port',5000),
# threaded = http.get('threaded',True),
# debug = http.get('debug',True),
# process = http.get('process',1))
def select_address(self):
"""
修正http侦听地址 ， 如果port未定义或者为0 ，则进行动态选定端口
:return:
"""
from mantis.fundamental.utils.network import select_address_port
http = self.cfgs.get('http')
if not http.get('port'): # port 未定义或者为0
start = 18900
end = 18950
address = select_address_port(http.get('host'),start,end)
self.cfgs.get('http')['port'] = address[1]
def start(self, block=True):
self.select_address()
http = self.getConfig().get('http')
host = http.get('host','127.0.0.1')
port = http.get('port',5000)
# app = self.app
# if http.get('debug', False):
# app.run(host,port,debug=True)
# else:
# self.server = wsgi.WSGIServer(( host, port), app)
#
# self.server.start()
# Application.run(self)
# self.server = pywsgi.WSGIServer((host,port),app)
# self.server.start()
self.initHttpServer()
if block:
self.logger.info('Service: %s started, Listen on %s:%s ...' % (self.name, host, port))
self.server.serve_forever()
else:
self.thread = Thread(target=self.runThread)
self.thread.setDaemon(True)
self.thread.start()
def initHttpServer(self):
http = self.getConfig().get('http')
host = http.get('host', '127.0.0.1')
port = http.get('port', 5000)
app = self.app
from mantis.fundamental.application.use_gevent import USE_GEVENT
print '--' * 20
if USE_GEVENT:
from gevent import pywsgi
from socketio.server import SocketIOServer
if http.get('websocket',False):
self.server = SocketIOServer((host, port), app, resource="socket.io")
else:
self.server = pywsgi.WSGIServer((host, port), app)
self.server.start()
else:
from wsgiref.simple_server import make_server
self.server = make_server(host, port, app)
self.logger.info('Service: %s started, Listen on %s:%s ...' % (self.name, host, port))
def runThread(self):
# print 'xxxx-Service: %s started, Listen on %s:%s ...' % (self.name, host, port)
self.server.serve_forever()
def stop(self):
from mantis.fundamental.application.use_gevent import USE_GEVENT
if self.server:
if USE_GEVENT:
self.server.stop()
else:
self.server.shutdown()
def registerBlueprint(self,bp,url):
self.app.register_blueprint( bp , url_prefix= url )
gevent.spawn(event_producer, fd, q)
signal.signal(signal.SIGTERM, exit_cleanup)
signal.signal(signal.SIGINT, exit_cleanup)
signal.signal(signal.SIGQUIT, exit_cleanup)
atexit.register(exit_cleanup)
if DEBUG: print("writing pid file: %s" % PID_FILE)
with open(PID_FILE, 'w') as f:
f.write(str(os.getpid()))
# start ffmpeg processes for online models
r = requests.get(ONLINE_MODELS_URL)
if r.status_code == 200:
if DEBUG: print("starting initial ffmpeg processes for: %s" % r.content)
online_model_list = json.loads(r.content)
for model in online_model_list:
stream_dumper.start_dump(model)
print(
'Listening on port http://0.0.0.0:%s and on port %s (flash policy server)'
% (PORT, FLASH_PORT))
server = SocketIOServer(('0.0.0.0', PORT),
Application(),
resource="socket.io",
policy_server=True,
policy_listener=('0.0.0.0', FLASH_PORT))
gevent.spawn(send_img, server)
gevent.spawn(file_cleanup, PIC_PATH, CLEAN_INTERVAL, server)
server.serve_forever()
from socketio.server import SocketIOServer
from gevent import monkey
from smm import config
from smm.server import app
import logging
logger = logging.getLogger('')
monkey.patch_all()
try:
server = SocketIOServer((config.server_host, config.server_port),
app,
resource='socket.io',
transports=config.server_socketio_handlers,
policy_server=False)
logger.info('Serving at http://%s:%s' %
(config.server_host, config.server_port))
server.serve_forever()
except (KeyboardInterrupt, SystemExit):
server.stop()
log_handler.setFormatter(formatter)
root_logger.addHandler(log_handler)
try:
logger.info("Starting SocketIOServer")
available_transports = [
'htmlfile',
'xhr-multipart',
'xhr-polling',
'jsonp-polling'
]
server = SocketIOServer(
(args.host, args.port),
Application(),
resource="socket.io",
transports=available_transports,
policy_server=False
)
logger.info("Listening to http://{0}:{1}".format(args.host, args.port))
logger.debug("writing logs to %s" % args.log_file)
gevent.spawn(start_consumer, args.broker_url)
server.serve_forever()
except KeyboardInterrupt:
logger.info("Socketio server stopped")
for handler in logger.handlers:
try:
handler.close()
except AttributeError:
pass
from gevent import monkey
monkey.patch_all()
import os
import django
from django.core.handlers.wsgi import WSGIHandler
from socketio.server import SocketIOServer
os.environ['DJANGO_SETTINGS_MODULE'] = 'project.settings.development'
django.setup()
if __name__ == '__main__':
print 'Starting server at http://127.0.0.1:8000/'
SocketIOServer(('', 8000), WSGIHandler(),
resource="socket.io").serve_forever()
def main(ip, port, cmd):
# this is a bit of a hack
config.COMMAND = cmd
from webterm.app import app
SocketIOServer((ip, port), app, resource='socket.io').serve_forever()
chats.socket_connections -= 1
print "another one bites the dust! connections are now at %s" % chats.socket_connections
@socketio.on('message', namespace="/submit")
def handle_message(message):
print('received message from console: ' + message)
chats.send_to_slack(message)
gevent.sleep()
@socketio.on('message', namespace="/receive")
def handle_receive(message):
print('hmmm dunno: ' + message)
if __name__ == '__main__':
from socketio.server import SocketIOServer
from socketio.namespace import BaseNamespace
from debugger import SocketIODebugger
app.debug=True
class MyNamespace(BaseNamespace):
def on_my_message(self, data):
handle_message()
app = SocketIODebugger(app, evalex=True, namespace=MyNamespace)
SocketIOServer(('localhost', 5000), app, resource='socket.io', policy_server=False).serve_forever()
# socketio.run(app)
def run():
try:
locale.setlocale(locale.LC_ALL, '')
except:
logging.warning('Couldn\'t set default locale')
localedir = os.path.abspath(
os.path.join(os.path.split(ajenti.core.__file__)[0], 'locale'))
gettext.textdomain('ajenti')
gettext.install('ajenti', localedir, unicode=True)
logging.info('Ajenti %s running on platform: %s' %
(ajenti.version, ajenti.platform))
if ajenti.debug:
ajenti.console.register()
# Load plugins
ajenti.plugins.manager.load_all()
bind_spec = (ajenti.config.tree.http_binding.host,
ajenti.config.tree.http_binding.port)
if ':' in bind_spec[0]:
addrs = socket.getaddrinfo(bind_spec[0], bind_spec[1], socket.AF_INET6,
0, socket.SOL_TCP)
bind_spec = addrs[0][-1]
ssl_tunnel = None
if ajenti.config.tree.ssl.enable:
ssl_tunnel = SSLTunnel()
ssl_tunnel.start(bind_spec[0], bind_spec[1],
ajenti.config.tree.ssl.certificate_path)
if ssl_tunnel.check():
logging.info('SSL tunnel running fine')
bind_spec = ('127.0.0.1', ssl_tunnel.port)
atexit.register(ssl_tunnel.stop)
else:
logging.error('SSL tunnel failed to start')
# Fix stupid socketio bug (it tries to do *args[0][0])
socket.socket.__getitem__ = lambda x, y: None
logging.info('Starting server on %s' % (bind_spec, ))
listener = socket.socket(
socket.AF_INET6 if ':' in bind_spec[0] else socket.AF_INET,
socket.SOCK_STREAM)
listener.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
listener.bind(bind_spec)
listener.listen(10)
stack = [
SessionMiddleware(),
AuthenticationMiddleware(),
CentralDispatcher()
]
ajenti.server = SocketIOServer(
listener,
log=open(os.devnull, 'w'),
application=HttpRoot(stack).dispatch,
policy_server=False,
resource='ajenti:socket',
)
# auth.log
try:
syslog.openlog(
ident=str(b'ajenti'),
facility=syslog.LOG_AUTH,
)
except:
syslog.openlog(b'ajenti')
try:
gevent.signal(signal.SIGTERM, lambda: sys.exit(0))
except:
pass
ajenti.feedback.start()
ajenti.server.serve_forever()
if hasattr(ajenti.server, 'restart_marker'):
logging.warn('Restarting by request')
if ssl_tunnel:
ssl_tunnel.stop()
fd = 20 # Close all descriptors. Creepy thing
while fd > 2:
try:
os.close(fd)
logging.debug('Closed descriptor #%i' % fd)
except:
pass
fd -= 1
os.execv(sys.argv[0], sys.argv)
else:
logging.info('Stopped by request')
