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 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 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 handle(self, *args, **options):
addrport = options["addrport"]
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 allowing the port
# to be set as the client-side default
environ["DJANGO_SOCKETIO_PORT"] = str(self.port)
Thread(target=reload_watcher).start()
try:
print("\nSocketIOServer running on {addr}:{port}\n".format(
addr=self.addr, port=self.port))
handler = self.get_handler(*args, **options)
bind = (self.addr, int(self.port))
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 run(self, handler):
try:
from socketio.server import SocketIOServer
except ImportError:
raise ImportError('You need to install gevent_socketio')
from gevent import monkey
from gevent_zeromq import monkey_patch
monkey.patch_all()
monkey_patch()
namespace = self.options.get('namespace', 'socket.io')
policy_server = self.options.get('policy_server', False)
if self.fd is not None:
sock = socket.fromfd(self.fd, socket.AF_INET, socket.SOCK_STREAM)
else:
sock = (self.host, self.port)
socket_server = SocketIOServer(sock,
handler,
namespace=namespace,
policy_server=policy_server)
handler.socket_server = socket_server
socket_server.serve_forever()
def main():
try:
# init
lModel = RangeManager(int(sys.argv[1]), int(sys.argv[2]))
monkey.patch_all()
lApp = Flask(__name__)
lApp.debug = True
lApi = Api(lApp)
FetchRange.sModel = lModel
Report.sModel = lModel
Progress.sModel = lModel
Reset.sModel = lModel
PushNamespace.sModel = lModel
# routes
lApp.add_url_rule('/', 'poll', poll)
lApp.add_url_rule('/socket.io/<path:path>', 'socket.io', run_socketio)
lApi.add_resource(FetchRange, '/fetch')
lApi.add_resource(Report, '/report')
lApi.add_resource(Progress, '/progress')
lApi.add_resource(Reset, '/reset')
# go
lApp = SharedDataMiddleware(lApp, {})
lServer = SocketIOServer(('0.0.0.0', 5000),
lApp,
resource="socket.io",
policy_server=False)
lServer.serve_forever()
except IndexError:
print "Usage: " + sys.argv[0] + \
" <number of ranges> <timeout per range>"
except KeyboardInterrupt:
lServer.stop()
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 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 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 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 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 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 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_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 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 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 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 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 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 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 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 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 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_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 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 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()
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()
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()
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()
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 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 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 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 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', 'engine'],
omit=coverage_omit,
data_suffix=True,
branch=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()
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()
def start_socketio():
def chat(environ, start_response):
if environ['PATH_INFO'].startswith('/socket.io'):
return socketio_manage(environ, {'/chat': ChatNamespace})
dbpath = 'db/database.db'
if not os.path.exists(os.path.dirname(dbpath)):
os.makedirs(os.path.dirname(dbpath))
engine = create_engine("".join(["sqlite:///", dbpath]))
redisHost = '127.0.0.1'
redisPort = 6379
redisConnectionPool = ConnectionPool(host=redisHost, port=int(redisPort))
dbHandler = DatabaseHandler(engine, redisConnectionPool)
ChatNamespace.set_db_handler(dbHandler)
ChatNamespace.cookieName = 'chat_cookie'
sio_server = SocketIOServer(('', 8080), chat, policy_server=False)
sio_server.serve_forever()
def start_socketio():
def chat(environ, start_response):
if environ['PATH_INFO'].startswith('/socket.io'):
return socketio_manage(environ, {'/chat': ChatNamespace})
dbpath = 'db/database.db'
if not os.path.exists(os.path.dirname(dbpath)):
os.makedirs(os.path.dirname(dbpath))
engine = create_engine("".join(["sqlite:///", dbpath]))
redisHost = '127.0.0.1'
redisPort = 6379
redisConnectionPool = ConnectionPool(host=redisHost, port=int(redisPort))
dbHandler = DatabaseHandler(engine, redisConnectionPool)
ChatNamespace.set_db_handler(dbHandler)
ChatNamespace.cookieName = 'chat_cookie'
sio_server = SocketIOServer(('', 8080), chat, policy_server=False)
sio_server.serve_forever()
def run(self, handler):
try:
from socketio.server import SocketIOServer
except ImportError:
raise ImportError('You need to install gevent_socketio')
from gevent import monkey
from gevent_zeromq import monkey_patch
monkey.patch_all()
monkey_patch()
namespace = self.options.get('namespace', 'socket.io')
policy_server = self.options.get('policy_server', False)
socket_server = SocketIOServer((self.host, self.port),
handler,
namespace=namespace,
policy_server=policy_server)
handler.socket_server = socket_server
socket_server.serve_forever()
def handle(self, addrport='', *args, **options):
if not addrport:
self.addr = ''
self.port = 8000
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_psyco'):
try:
from psycogreen.gevent import patch_psycopg
except ImportError:
raise CommandError('Could not patch psycopg. '
'Is psycogreen installed?')
patch_psycopg()
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 run(self, handler):
try:
from socketio.server import SocketIOServer
except ImportError:
raise ImportError('You need to install gevent_socketio')
# sets up the ZMQ/Gevent environ
from circus import _patch # NOQA
namespace = self.options.get('namespace', 'socket.io')
policy_server = self.options.get('policy_server', False)
if self.fd is not None:
sock = socket.fromfd(self.fd, socket.AF_INET, socket.SOCK_STREAM)
else:
sock = (self.host, self.port)
socket_server = SocketIOServer(sock, handler,
namespace=namespace,
policy_server=policy_server)
handler.socket_server = socket_server
socket_server.serve_forever()
class SocketIO(object):
def __init__(self, app=None):
if app:
self.init_app(app)
self.messages = {}
self.rooms = {}
self.server = None
def init_app(self, app):
app.wsgi_app = SocketIOMiddleware(app, self)
def get_namespaces(self, base_namespace=BaseNamespace):
class GenericNamespace(base_namespace):
socketio = self
base_emit = base_namespace.emit
base_send = base_namespace.send
def initialize(self):
self.rooms = set()
def process_event(self, packet):
message = packet['name']
args = packet['args']
app = self.request
return self.socketio._dispatch_message(app, self, message,
args)
def join_room(self, room):
if self.socketio._join_room(self, room):
self.rooms.add(room)
def leave_room(self, room):
if self.socketio._leave_room(self, room):
self.rooms.remove(room)
def recv_connect(self):
if self.socketio.server is None:
self.socketio.server = self.environ['socketio'].server
ret = super(GenericNamespace, self).recv_connect()
app = self.request
self.socketio._dispatch_message(app, self, 'connect')
return ret
def recv_disconnect(self):
app = self.request
self.socketio._dispatch_message(app, self, 'disconnect')
for room in self.rooms.copy():
self.leave_room(room)
return super(GenericNamespace, self).recv_disconnect()
def recv_message(self, data):
app = self.request
return self.socketio._dispatch_message(app, self, 'message',
[data])
def recv_json(self, data):
app = self.request
return self.socketio._dispatch_message(app, self, 'json',
[data])
def emit(self, event, *args, **kwargs):
ns_name = kwargs.pop('namespace', None)
broadcast = kwargs.pop('broadcast', False)
room = kwargs.pop('room', None)
if broadcast or room:
if ns_name is None:
ns_name = self.ns_name
return self.socketio.emit(event,
*args,
namespace=ns_name,
room=room)
if ns_name is None:
return self.base_emit(event, *args, **kwargs)
return request.namespace.socket[ns_name].base_emit(
event, *args, **kwargs)
def send(self,
message,
json=False,
ns_name=None,
callback=None,
broadcast=False,
room=None):
if broadcast or room:
if ns_name is None:
ns_name = self.ns_name
return self.socketio.send(message, json, ns_name, room)
if ns_name is None:
return request.namespace.base_send(message, json, callback)
return request.namespace.socket[ns_name].base_send(
message, json, callback)
namespaces = {}
for ns_name in self.messages.keys():
namespaces[ns_name] = GenericNamespace
return namespaces
def _dispatch_message(self, app, namespace, message, args=[]):
if namespace.ns_name not in self.messages:
return
if message not in self.messages[namespace.ns_name]:
return
with app.request_context(namespace.environ):
request.namespace = namespace
for k, v in namespace.session.items():
session[k] = v
ret = self.messages[namespace.ns_name][message](*args)
for k, v in session.items():
namespace.session[k] = v
return ret
def _join_room(self, namespace, room):
if namespace.ns_name not in self.rooms:
self.rooms[namespace.ns_name] = {}
if room not in self.rooms[namespace.ns_name]:
self.rooms[namespace.ns_name][room] = set()
if namespace not in self.rooms[namespace.ns_name][room]:
self.rooms[namespace.ns_name][room].add(namespace)
return True
return False
def _leave_room(self, namespace, room):
if namespace.ns_name in self.rooms:
if room in self.rooms[namespace.ns_name]:
if namespace in self.rooms[namespace.ns_name][room]:
self.rooms[namespace.ns_name][room].remove(namespace)
if len(self.rooms[namespace.ns_name][room]) == 0:
del self.rooms[namespace.ns_name][room]
if len(self.rooms[namespace.ns_name]) == 0:
del self.rooms[namespace.ns_name]
return True
return False
def on_message(self, message, handler, **options):
ns_name = options.pop('namespace', '')
if ns_name not in self.messages:
self.messages[ns_name] = {}
self.messages[ns_name][message] = handler
def on(self, message, **options):
def decorator(f):
self.on_message(message, f, **options)
return f
return decorator
def emit(self, event, *args, **kwargs):
ns_name = kwargs.pop('namespace', None)
if ns_name is None:
ns_name = ''
room = kwargs.pop('room', None)
if room:
for client in self.rooms.get(ns_name, {}).get(room, set()):
client.base_emit(event, *args, **kwargs)
else:
if self.server:
for sessid, socket in self.server.sockets.items():
if socket.active_ns.get(ns_name):
socket[ns_name].base_emit(event, *args, **kwargs)
def send(self, message, json=False, namespace=None, room=None):
ns_name = namespace
if ns_name is None:
ns_name = ''
if room:
for client in self.rooms.get(ns_name, {}).get(room, set()):
client.base_send(message, json)
else:
if self.server:
for sessid, socket in self.server.sockets.items():
if socket.active_ns.get(ns_name):
socket[ns_name].base_send(message, json)
def run(self, app, host=None, port=None, **kwargs):
if host is None:
host = '127.0.0.1'
if port is None:
server_name = app.config['SERVER_NAME']
if server_name and ':' in server_name:
port = int(server_name.rsplit(':', 1)[1])
else:
port = 5000
# don't allow override of resource, otherwise allow SocketIOServer
# kwargs to be passed through
kwargs.pop('resource', None)
self.server = SocketIOServer((host, port),
app.wsgi_app,
resource='socket.io',
**kwargs)
if app.debug:
def run_server():
self.server.serve_forever()
if os.environ.get('WERKZEUG_RUN_MAIN') != 'true':
_log('info', ' * Running on http://%s:%d/' % (host, port))
run_with_reloader(run_server)
else:
self.server.serve_forever()
def test_client(self, app, namespace=None):
return SocketIOTestClient(app, self, namespace)
def run_server():
server = SocketIOServer((host, port),
app.wsgi_app,
resource='socket.io')
server.serve_forever()
def main():
global VERBOSE
global mdb
global collection
global port
#default access info
awsAccessKey = 'AKIAJICPBE3SSHW5SR7A'
awsSecretKey = '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'
awsBucket = 'aqueti.data'
#parse inputs
# parse command line arguments
parser = argparse.ArgumentParser(description='Python server')
parser.add_argument('-v',
action='store_const',
dest='VERBOSE',
const='True',
help='VERBOSE output')
parser.add_argument('-vv',
action='store_const',
dest='VERBOSE2',
const='True',
help='VERBOSE output')
parser.add_argument('-a',
action='store',
dest='aws_access',
help='AWS access code')
parser.add_argument('-s',
action='store',
dest='aws_secret',
help='path to data')
parser.add_argument('-b',
action='store',
dest='bucket',
help='S3 Bucket with data')
"""
parser.add_argument('-p', action='store_const', dest='printout', const='True', help='print contents of JSON file')
parser.add_argument('-d', action='store', dest='path', help='path to data')
parser.add_argument('-u', action='store_const', dest='update', const='True', help='update records')
parser.add_argument('-c', action='store', dest='collection', help='collection (table) to use')
"""
parser.add_argument('dbase', help='database name')
args = parser.parse_args()
#set VERBOSE flag as requested
if args.VERBOSE:
VERBOSE = 1
if args.VERBOSE2:
VERBOSE = 2
print "VERBOSE=2"
#extract relevant parameters
if VERBOSE > 1:
print "Using database " + args.dbase
##################################################
# connect to database and AWS server (if needed)
##################################################
#connect to database
mdb = MDB.MDB()
if VERBOSE > 1:
print "Connecting to mongodb: " + args.dbase
try:
rc = mdb.connect(args.dbase)
except:
print "MDB: Unable to connect to database: " + args.dbase
return -1
# if args.aws_access:
# awsAccessKey = args.aws_access
# if args.aws_secret:
# awsSecretKey = arts.aws_secret
# if args.bucket:
# awsBucket = args.bucket
# Connect to AWS class
#sdf - need to make this optional
# aws=AWS.AWS()
# aws.setVerbose( VERBOSE );
# if VERBOSE > 1:
# print "Connecting to AWS: "+awsAccessKey+"/"+awsSecretKey
# try:
# aws.connect( awsAccessKey, awsSecretKey )
# except:
# print "Unable to connect to AWS. Please check inputs"
# return -1
print "Starting the server on port " + str(port) + "!"
sio_server = SocketIOServer(('', port), chat, policy_server=False)
sio_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 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()
'Launch this server in another terminal window before running tests'
from socketio import socketio_manage
from socketio.namespace import BaseNamespace
from socketio.server import SocketIOServer
class Namespace(BaseNamespace):
def on_aaa(self, *args):
self.socket.send_packet(
dict(type='event', name='ddd', args=args, endpoint=self.ns_name))
class Application(object):
def __call__(self, environ, start_response):
socketio_manage(environ, {
'': Namespace,
'/chat': Namespace,
'/news': Namespace,
})
if __name__ == '__main__':
socketIOServer = SocketIOServer(('0.0.0.0', 8000), Application())
socketIOServer.serve_forever()
class SocketIO(object):
"""Create a Flask-SocketIO server.
:param app: The flask application instance. If the application instance
isn't known at the time this class is instantiated, then call
``socketio.init_app(app)`` once the application instance is
available.
"""
def __init__(self, app=None):
if app:
self.init_app(app)
self.messages = {}
self.rooms = {}
self.server = None
self.exception_handlers = {}
self.default_exception_handler = None
def init_app(self, app):
app.wsgi_app = _SocketIOMiddleware(app, self)
def _get_namespaces(self, base_namespace=BaseNamespace):
class GenericNamespace(base_namespace):
socketio = self
base_emit = base_namespace.emit
base_send = base_namespace.send
def initialize(self):
self.rooms = set()
def process_event(self, packet):
if self.socketio.server is None:
self.socketio.server = self.environ['socketio'].server
message = packet['name']
args = packet['args']
app = self.request
return self.socketio._dispatch_message(app, self, message,
args)
def join_room(self, room):
if self.socketio._join_room(self, room):
self.rooms.add(room)
def leave_room(self, room):
if self.socketio._leave_room(self, room):
self.rooms.remove(room)
def close_room(self, room):
self.socketio._close_room(self, room)
def recv_connect(self):
if self.socketio.server is None:
self.socketio.server = self.environ['socketio'].server
ret = super(GenericNamespace, self).recv_connect()
app = self.request
self.socketio._dispatch_message(app, self, 'connect')
return ret
def recv_disconnect(self):
if self.socketio.server is None:
self.socketio.server = self.environ['socketio'].server
app = self.request
self.socketio._dispatch_message(app, self, 'disconnect')
self.socketio._leave_all_rooms(self)
return super(GenericNamespace, self).recv_disconnect()
def recv_message(self, data):
if self.socketio.server is None:
self.socketio.server = self.environ['socketio'].server
app = self.request
return self.socketio._dispatch_message(app, self, 'message',
[data])
def recv_json(self, data):
if self.socketio.server is None:
self.socketio.server = self.environ['socketio'].server
app = self.request
return self.socketio._dispatch_message(app, self, 'json',
[data])
def emit(self, event, *args, **kwargs):
ns_name = kwargs.pop('namespace', None)
broadcast = kwargs.pop('broadcast', False)
room = kwargs.pop('room', None)
if broadcast or room:
if ns_name is None:
ns_name = self.ns_name
return self.socketio.emit(event,
*args,
namespace=ns_name,
room=room)
if ns_name is None:
return self.base_emit(event, *args, **kwargs)
return request.namespace.socket[ns_name].base_emit(
event, *args, **kwargs)
def send(self,
message,
json=False,
ns_name=None,
callback=None,
broadcast=False,
room=None):
if broadcast or room:
if ns_name is None:
ns_name = self.ns_name
return self.socketio.send(message, json, ns_name, room)
if ns_name is None:
return request.namespace.base_send(message, json, callback)
return request.namespace.socket[ns_name].base_send(
message, json, callback)
def disconnect(self, silent=False):
self.socketio._leave_all_rooms(self)
return super(GenericNamespace, self).disconnect(silent)
namespaces = dict(
(ns_name, GenericNamespace) for ns_name in self.messages)
return namespaces
def _dispatch_message(self, app, namespace, message, args=[]):
if namespace.ns_name not in self.messages:
return
if message not in self.messages[namespace.ns_name]:
return
with app.request_context(namespace.environ):
request.namespace = namespace
request.event = {"message": message, "args": args}
for k, v in namespace.session.items():
session[k] = v
ret = self.messages[namespace.ns_name][message](*args)
for k, v in session.items():
namespace.session[k] = v
return ret
def _join_room(self, namespace, room):
if namespace.ns_name not in self.rooms:
self.rooms[namespace.ns_name] = {}
if room not in self.rooms[namespace.ns_name]:
self.rooms[namespace.ns_name][room] = set()
if namespace not in self.rooms[namespace.ns_name][room]:
self.rooms[namespace.ns_name][room].add(namespace)
return True
return False
def _leave_room(self, namespace, room):
if namespace.ns_name in self.rooms:
if room in self.rooms[namespace.ns_name]:
if namespace in self.rooms[namespace.ns_name][room]:
self.rooms[namespace.ns_name][room].remove(namespace)
if len(self.rooms[namespace.ns_name][room]) == 0:
del self.rooms[namespace.ns_name][room]
if len(self.rooms[namespace.ns_name]) == 0:
del self.rooms[namespace.ns_name]
return True
return False
def _close_room(self, namespace, room):
self.close_room(room, namespace.ns_name)
def _leave_all_rooms(self, namespace):
if namespace.ns_name in self.rooms:
for room in self.rooms[namespace.ns_name].copy():
self._leave_room(namespace, room)
def _on_message(self, message, handler, namespace=''):
if namespace not in self.messages:
self.messages[namespace] = {}
self.messages[namespace][message] = handler
def on(self, message, namespace=''):
"""Decorator to register a SocketIO event handler.
This decorator must be applied to SocketIO event handlers. Example::
@socketio.on('my event', namespace='/chat')
def handle_my_custom_event(json):
print('received json: ' + str(json))
:param message: The name of the event. Use ``'message'`` to define a
handler that takes a string payload, ``'json'`` to
define a handler that takes a JSON blob payload,
``'connect'`` or ``'disconnect'`` to create handlers
for connection and disconnection events, or else, use a
custom event name, and use a JSON blob as payload.
:param namespace: The namespace on which the handler is to be
registered. Defaults to the global namespace.
"""
if namespace in self.exception_handlers or \
self.default_exception_handler is not None:
def decorator(event_handler):
def func(*args, **kwargs):
try:
return event_handler(*args, **kwargs)
except:
handler = self.exception_handlers.get(
namespace, self.default_exception_handler)
type, value, traceback = sys.exc_info()
return handler(value)
self._on_message(message, func, namespace)
return func
else:
def decorator(event_handler):
self._on_message(message, event_handler, namespace)
return event_handler
return decorator
def on_error(self, namespace=''):
"""Decorator to define a custom error handler for SocketIO events.
This decorator can be applied to a function that acts as an error
handler for a namespace. This handler will be invoked when a SocketIO
event handler raises an exception. The handler function must accept one
argument, which is the exception raised. Example::
@socketio.on_error(namespace='/chat')
def chat_error_handler(e):
print('An error has occurred: ' + str(e))
:param namespace: The namespace for which to register the error
handler. Defaults to the global namespace.
"""
def decorator(exception_handler):
if not callable(exception_handler):
raise ValueError('exception_handler must be callable')
self.exception_handlers[namespace] = exception_handler
return decorator
def on_error_default(self, exception_handler):
"""Decorator to define a default error handler for SocketIO events.
This decorator can be applied to a function that acts as a default
error handler for any namespaces that do not have a specific handler.
Example::
@socketio.on_error_default
def error_handler(e):
print('An error has occurred: ' + str(e))
"""
if not callable(exception_handler):
raise ValueError('exception_handler must be callable')
self.default_exception_handler = exception_handler
def emit(self, event, *args, **kwargs):
"""Emit a server generated SocketIO event.
This function emits a user-specific SocketIO event to one or more
connected clients. A JSON blob can be attached to the event as payload.
This function can be used outside of a SocketIO event context, so it is
appropriate to use when the server is the originator of an event, for
example as a result of a regular HTTP message. Example::
@app.route('/ping')
def ping():
socketio.emit('ping event', {'data': 42}, namespace='/chat')
:param event: The name of the user event to emit.
:param args: A dictionary with the JSON data to send as payload.
:param namespace: The namespace under which the message is to be sent.
Defaults to the global namespace.
:param room: Send the message to all the users in the given room. If
this parameter is not included, the event is sent to
all connected users.
"""
ns_name = kwargs.pop('namespace', '')
room = kwargs.pop('room', None)
if room is not None:
for client in self.rooms.get(ns_name, {}).get(room, set()):
client.base_emit(event, *args, **kwargs)
elif self.server:
for sessid, socket in self.server.sockets.items():
if socket.active_ns.get(ns_name):
socket[ns_name].base_emit(event, *args, **kwargs)
def send(self, message, json=False, namespace=None, room=None):
"""Send a server-generated SocketIO message.
This function sends a simple SocketIO message to one or more connected
clients. The message can be a string or a JSON blob. This is a simpler
version of ``emit()``, which should be preferred. This function can be
used outside of a SocketIO event context, so it is appropriate to use
when the server is the originator of an event.
:param message: The message to send, either a string or a JSON blob.
:param json: ``True`` if ``message`` is a JSON blob, ``False``
otherwise.
:param namespace: The namespace under which the message is to be sent.
Defaults to the global namespace.
:param room: Send the message only to the users in the given room. If
this parameter is not included, the message is sent to
all connected users.
"""
ns_name = namespace
if ns_name is None:
ns_name = ''
if room:
for client in self.rooms.get(ns_name, {}).get(room, set()):
client.base_send(message, json)
else:
if self.server:
for sessid, socket in self.server.sockets.items():
if socket.active_ns.get(ns_name):
socket[ns_name].base_send(message, json)
def close_room(self, room, namespace=''):
"""Close a room.
This function removes any users that are in the given room and then
deletes the room from the server. This function can be used outside
of a SocketIO event context.
:param room: The name of the room to close.
:param namespace: The namespace under which the room exists. Defaults
to the global namespace.
"""
if namespace in self.rooms:
if room in self.rooms[namespace]:
for ns in self.rooms[namespace][room].copy():
self._leave_room(ns, room)
def run(self, app, host=None, port=None, **kwargs):
"""Run the SocketIO web server.
:param app: The Flask application instance.
:param host: The hostname or IP address for the server to listen on.
Defaults to 127.0.0.1.
:param port: The port number for the server to listen on. Defaults to
5000.
:param use_reloader: ``True`` to enable the Flask reloader, ``False``
to disable it.
:param resource: The SocketIO resource name. Defaults to
``'socket.io'``. Leave this as is unless you know what
you are doing.
:param transports: Optional list of transports to allow. List of
strings, each string should be one of
handler.SocketIOHandler.handler_types.
:param policy_server: Boolean describing whether or not to use the
Flash policy server. Defaults to ``True``.
:param policy_listener: A tuple containing (host, port) for the
policy server. This is optional and used only
if policy server is set to true. Defaults to
0.0.0.0:843.
:param heartbeat_interval: The timeout for the server, we should
receive a heartbeat from the client within
this interval. This should be less than the
``heartbeat_timeout``.
:param heartbeat_timeout: The timeout for the client when it should
send a new heartbeat to the server. This
value is sent to the client after a
successful handshake.
:param close_timeout: The timeout for the client, when it closes the
connection it still X amounts of seconds to do
re-open of the connection. This value is sent to
the client after a successful handshake.
:param log_file: The file in which you want the PyWSGI server to write
its access log. If not specified, it is sent to
``stderr`` (with gevent 0.13).
"""
if host is None:
host = '127.0.0.1'
if port is None:
server_name = app.config['SERVER_NAME']
if server_name and ':' in server_name:
port = int(server_name.rsplit(':', 1)[1])
else:
port = 5000
resource = kwargs.pop('resource', 'socket.io')
use_reloader = kwargs.pop('use_reloader', app.debug)
self.server = SocketIOServer((host, port),
app.wsgi_app,
resource=resource,
**kwargs)
if use_reloader:
# monkey patching is required by the reloader
from gevent import monkey
monkey.patch_all()
def run_server():
self.server.serve_forever()
if os.environ.get('WERKZEUG_RUN_MAIN') != 'true':
_log('info', ' * Running on http://%s:%d/' % (host, port))
run_with_reloader(run_server)
else:
_log('info', ' * Running on http://%s:%d/' % (host, port))
self.server.serve_forever()
def test_client(self, app, namespace=None):
"""Return a simple SocketIO client that can be used for unit tests."""
return SocketIOTestClient(app, self, namespace)
def socketio_server():
server = SocketIOServer(('0.0.0.0', port),
SocketApp(),
policy_server=False)
server.start()
server.serve_forever()
404 error handler
used if a non existant route
is requested
"""
return render_template('404.html'), 404
@app.errorhandler(500)
def page_not_found(exc):
"""
500 error handler
used if there is a server error
"""
return render_template('500.html'), 500
if __name__ == '__main__':
analyzer = Analyzer()
server = SocketIOServer(('', PORT), app, resource="socket.io")
tw_thread = TweetWeather(server, analyzer, name="Tweet-Weather-Thread")
tw_thread.daemon = True
gevent.spawn(tw_thread.new_post, server)
gevent.spawn(tw_thread.connexion_lost, server)
print "Application Started: http://localhost:5000"
try:
server.serve_forever()
except KeyboardInterrupt:
tw_thread.stop()
server.stop()
sys.exit()
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):
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', [])
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.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)
