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 test_manage_py(self):
argv = ['./manage.py', 'runserver']
mock_call = self.patch_autoreload(argv)
autoreload.restart_with_reloader()
self.assertEqual(mock_call.call_count, 1)
self.assertEqual(mock_call.call_args[0][0],
[self.executable, '-Wall'] + argv)
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 handle(self, addrport="", *args, **options):
if not addrport:
self.addr = HOST
self.port = 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")
server.serve_forever()
except KeyboardInterrupt:
if RELOAD:
print
print "Reloading..."
restart_with_reloader()
else:
raise
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 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:
run_socket_server(self.addr, self.port, *args, **options)
except KeyboardInterrupt:
if RELOAD:
server.stop()
print "Reloading..."
restart_with_reloader()
else:
raise
def handle(self, addrport="", *args, **options):
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()
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")
server.serve_forever()
except KeyboardInterrupt:
if RELOAD:
print
print "Reloading..."
restart_with_reloader()
else:
raise
def django_reload(cls):
try:
from django.utils.autoreload import restart_with_reloader
restart_with_reloader()
from .utils import populate_apps
populate_apps()
except Exception as e:
logger.error(e.message)
def test_python_m_django(self):
main = '/usr/lib/pythonX.Y/site-packages/django/__main__.py'
argv = [main, 'runserver']
mock_call = self.patch_autoreload(argv)
with mock.patch('django.__main__.__file__', main):
autoreload.restart_with_reloader()
self.assertEqual(mock_call.call_count, 1)
self.assertEqual(mock_call.call_args[0][0], [self.executable, '-Wall', '-m', 'django'] + argv[1:])
def test_python_m_django(self):
main = '/usr/lib/pythonX.Y/site-packages/django/__main__.py'
argv = [main, 'runserver']
mock_call = self.patch_autoreload(argv)
with mock.patch('django.__main__.__file__', main):
autoreload.restart_with_reloader()
self.assertEqual(mock_call.call_count, 1)
self.assertEqual(mock_call.call_args[0][0], [self.executable, '-Wall', '-m', 'django'] + argv[1:])
def test_manage_py(self):
script = Path('manage.py')
script.touch()
self.addCleanup(script.unlink)
argv = ['./manage.py', 'runserver']
mock_call = self.patch_autoreload(argv)
autoreload.restart_with_reloader()
self.assertEqual(mock_call.call_count, 1)
self.assertEqual(mock_call.call_args[0][0],
[self.executable, '-Wall'] + argv)
def test_environment(self):
""""
With Python 2 on Windows, restart_with_reloader() coerces environment
variables to str to avoid "TypeError: environment can only contain
strings" in Python's subprocess.py.
"""
# With unicode_literals, these values are unicode.
os.environ['SPAM'] = 'spam'
with mock.patch.object(sys, 'argv', ['-c', 'pass']):
autoreload.restart_with_reloader()
def test_environment(self):
""""
With Python 2 on Windows, restart_with_reloader() coerces environment
variables to str to avoid "TypeError: environment can only contain
strings" in Python's subprocess.py.
"""
# With unicode_literals, these values are unicode.
os.environ['SPAM'] = 'spam'
with mock.patch.object(sys, 'argv', ['-c', 'pass']):
autoreload.restart_with_reloader()
def test_python_m_django(self):
main = "/usr/lib/pythonX.Y/site-packages/django/__main__.py"
argv = [main, "runserver"]
mock_call = self.patch_autoreload(argv)
with mock.patch("django.__main__.__file__", main):
with mock.patch.dict(sys.modules, {"__main__": django.__main__}):
autoreload.restart_with_reloader()
self.assertEqual(mock_call.call_count, 1)
self.assertEqual(
mock_call.call_args[0][0],
[self.executable, "-Wall", "-m", "django"] + argv[1:],
)
def test_manage_py(self):
with tempfile.TemporaryDirectory() as temp_dir:
script = Path(temp_dir) / 'manage.py'
script.touch()
argv = [str(script), 'runserver']
mock_call = self.patch_autoreload(argv)
autoreload.restart_with_reloader()
self.assertEqual(mock_call.call_count, 1)
self.assertEqual(
mock_call.call_args[0][0],
[self.executable, '-Wall'] + argv,
)
def test_manage_py(self):
with tempfile.TemporaryDirectory() as temp_dir:
script = Path(temp_dir) / "manage.py"
script.touch()
argv = [str(script), "runserver"]
mock_call = self.patch_autoreload(argv)
with mock.patch("__main__.__spec__", None):
autoreload.restart_with_reloader()
self.assertEqual(mock_call.call_count, 1)
self.assertEqual(
mock_call.call_args[0][0],
[self.executable, "-Wall"] + argv,
)
def run_tests(self):
auto_reload = False
if '-a' in sys.argv or '--autoreload' in sys.argv:
auto_reload = True
if auto_reload:
from django.utils.autoreload import restart_with_reloader, reloader_thread
if os.environ.get("RUN_MAIN") == "true":
try:
TestCommand.run_tests(self)
except LabelException:
sys.exit(1)
except:
pass
try:
reloader_thread()
except KeyboardInterrupt:
pass
else:
try:
sys.exit(restart_with_reloader())
except KeyboardInterrupt:
pass
else:
return TestCommand.run_tests(self)
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 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)
manager_conf = getattr(settings, "SOCKET_MANAGER", None)
kw = {
"resource":"socket.io",
"policy_server":True
}
if manager_conf:
kw["socket_manager_config"] = manager_conf
print "SocketManager settings %s" % manager_conf
server = SocketIOServer(bind, handler, **kw)
server.serve_forever()
except KeyboardInterrupt:
if RELOAD:
server.stop()
print "Reloading..."
restart_with_reloader()
else:
raise
def run(self):
# 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_psyco'):
# try:
# from psycogreen.gevent import patch_psycopg
# except ImportError:
# raise CommandError(
# 'Could not patch psycopg. '
# 'Is psycogreen installed?')
# patch_psycopg()
if self.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()
server = self.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, 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_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:
socks = []
for key, sock in six.iteritems(server.sockets):
socks.append(sock)
for sock in socks:
sock.kill(detach=True)
server.stop()
if RELOAD:
print 'Reloading...\n\n'
restart_with_reloader()
def handle(self, addrport="", *args, **options):
if not addrport:
self.addr = "127.0.0.1"
self.port = DEFAULT_PORT
else:
m = re.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()
if self.addr is None:
self.addr = "0.0.0.0"
# 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(self.port)
start_new_thread(reload_watcher, ())
try:
bind = (self.addr, int(self.port))
self.stdout.write("Starting development SocketIO server at %s:%s\n" % bind)
handler = self.get_handler(*args, **options)
server = SocketIOServer(bind, handler, resource="socket.io", policy_server=True, policy_listener=None)
server.serve_forever()
except KeyboardInterrupt:
if RELOAD:
server.stop()
self.stdout.write("Reloading...")
restart_with_reloader()
else:
raise
except Exception as e:
raise
def handle(self, *args, **kwargs):
self.project_dir = os.getcwd()
signal.signal(signal.SIGTERM, lambda *args: sys.exit(0))
try:
if os.environ.get(autoreload.DJANGO_AUTORELOAD_ENV) == "true":
reloader = autoreload.get_reloader()
reloader.watch_dir(os.path.join(self.project_dir, "doc"),
"**/*.rst")
autoreload.logger.info("Watching for file changes with %s",
reloader.__class__.__name__)
autoreload.start_django(reloader, self.build_and_start_server,
**kwargs)
else:
exit_code = autoreload.restart_with_reloader()
sys.exit(exit_code)
except KeyboardInterrupt:
pass
def test_environment_decoding(self):
"""The system encoding is used for decoding."""
os.environ['SPAM'] = 'spam'
os.environ['EGGS'] = b'\xc6u vi komprenas?'
with mock.patch('locale.getdefaultlocale') as default_locale:
# Latin-3 is the correct mapping.
default_locale.return_value = ('eo', 'latin3')
with mock.patch.object(sys, 'argv', ['-c', 'pass']):
autoreload.restart_with_reloader()
# CP1252 interprets latin3's C circumflex as AE ligature.
# It's incorrect but doesn't raise an error.
default_locale.return_value = ('en_US', 'cp1252')
with mock.patch.object(sys, 'argv', ['-c', 'pass']):
autoreload.restart_with_reloader()
# Interpreting the string as UTF-8 is fatal.
with self.assertRaises(UnicodeDecodeError):
default_locale.return_value = ('en_US', 'utf-8')
with mock.patch.object(sys, 'argv', ['-c', 'pass']):
autoreload.restart_with_reloader()
def test_environment_decoding(self):
"""The system encoding is used for decoding."""
os.environ['SPAM'] = 'spam'
os.environ['EGGS'] = b'\xc6u vi komprenas?'
with mock.patch('locale.getdefaultlocale') as default_locale:
# Latin-3 is the correct mapping.
default_locale.return_value = ('eo', 'latin3')
with mock.patch.object(sys, 'argv', ['-c', 'pass']):
autoreload.restart_with_reloader()
# CP1252 interprets latin3's C circumflex as AE ligature.
# It's incorrect but doesn't raise an error.
default_locale.return_value = ('en_US', 'cp1252')
with mock.patch.object(sys, 'argv', ['-c', 'pass']):
autoreload.restart_with_reloader()
# Interpreting the string as UTF-8 is fatal.
with self.assertRaises(UnicodeDecodeError):
default_locale.return_value = ('en_US', 'utf-8')
with mock.patch.object(sys, 'argv', ['-c', 'pass']):
autoreload.restart_with_reloader()
def test_manage_py(self):
argv = ['./manage.py', 'runserver']
mock_call = self.patch_autoreload(argv)
autoreload.restart_with_reloader()
self.assertEqual(mock_call.call_count, 1)
self.assertEqual(mock_call.call_args[0][0], [self.executable, '-Wall'] + argv)
def handle(self, addrport='', *args, **options):
if args:
raise CommandError('Usage is server %s' % self.args)
if not addrport:
self.addr = ''
self.port = DEFAULT_PORT
else:
m = re.match(naiveip_re, addrport)
if m is None:
raise CommandError('"%s" is not a valid port number '
'or address:port pair.' % addrport)
self.addr, _ipv4, _ipv6, _fqdn, self.port = m.groups()
if not self.port.isdigit():
raise CommandError("%r is not a valid port number." %
self.port)
if self.addr and _ipv6:
raise CommandError("ipv6 is not supported")
if not self.addr:
self.addr = '127.0.0.1'
if options.get('apiprefix') and not options.get('prefix'):
raise CommandError("--apiprefix can only be used in conjuction "
"with --prefix. ")
logger = logging.getLogger('feat')
if options.get('featlog'):
log.FluLogKeeper.init(options['featlog'])
log.set_default(log.FluLogKeeper())
log.info('featdjango',
'Use feat logging: %s' % (options['featlog'], ))
else:
log.set_default(log.PythonLogKeeper(logger))
from feat.extern.log import log as flulog
flulog.setPackageScrubList('featcredex', 'featdjango', 'feat')
log.info('featdjango', 'Use python logging')
log.info('featdjango', "Listening on %s:%s", self.addr, self.port)
if os.environ.get("RUN_MAIN") == 'true':
# this is how django autoreloader lets the child process know
# that its a child process
if options.get('elflog_path'):
stats = webserver.ELFLog(options.get('elflog_path'),
options.get('elflog_fields'))
else:
stats = None
site = server.Server(self.addr,
int(self.port),
prefix=options.get('prefix'),
apiprefix=options.get('apiprefix'),
web_statistics=stats,
thread_stats_file=options.get('stats_file'))
reactor.callWhenRunning(site.initiate)
reactor.addSystemEventTrigger('before', 'shutdown', site.cleanup)
if options.get('use_reloader'):
task = reloader.Reloader(reactor, site)
reactor.callWhenRunning(task.run)
reactor.run()
if options.get('use_reloader'):
if task.should_reload:
sys.exit(3)
else:
# in the original process we just spawn the child worker as
# many times as it tells us to
try:
while autoreload.restart_with_reloader() == 3:
pass
except KeyboardInterrupt:
pass
def django_reload(cls):
try:
from django.utils.autoreload import restart_with_reloader
restart_with_reloader()
except Exception as e:
logger.error(str(e))
def handle(self, addrport='', *args, **options):
if args:
raise CommandError('Usage is server %s' % self.args)
if not addrport:
self.addr = ''
self.port = DEFAULT_PORT
else:
m = re.match(naiveip_re, addrport)
if m is None:
raise CommandError('"%s" is not a valid port number '
'or address:port pair.' % addrport)
self.addr, _ipv4, _ipv6, _fqdn, self.port = m.groups()
if not self.port.isdigit():
raise CommandError(
"%r is not a valid port number." % self.port)
if self.addr and _ipv6:
raise CommandError("ipv6 is not supported")
if not self.addr:
self.addr = '127.0.0.1'
if options.get('apiprefix') and not options.get('prefix'):
raise CommandError("--apiprefix can only be used in conjuction "
"with --prefix. ")
logger = logging.getLogger('feat')
if options.get('featlog'):
log.FluLogKeeper.init(options['featlog'])
log.set_default(log.FluLogKeeper())
log.info('featdjango', 'Use feat logging: %s' % (
options['featlog'], ))
else:
log.set_default(log.PythonLogKeeper(logger))
from feat.extern.log import log as flulog
flulog.setPackageScrubList('featcredex', 'featdjango', 'feat')
log.info('featdjango', 'Use python logging')
log.info('featdjango', "Listening on %s:%s", self.addr, self.port)
if os.environ.get("RUN_MAIN") == 'true':
# this is how django autoreloader lets the child process know
# that its a child process
if options.get('elflog_path'):
stats = webserver.ELFLog(options.get('elflog_path'),
options.get('elflog_fields'))
else:
stats = None
site = server.Server(self.addr, int(self.port),
prefix=options.get('prefix'),
apiprefix=options.get('apiprefix'),
web_statistics=stats,
thread_stats_file=options.get('stats_file'))
reactor.callWhenRunning(site.initiate)
reactor.addSystemEventTrigger('before', 'shutdown', site.cleanup)
if options.get('use_reloader'):
task = reloader.Reloader(reactor, site)
reactor.callWhenRunning(task.run)
reactor.run()
if options.get('use_reloader'):
if task.should_reload:
sys.exit(3)
else:
# in the original process we just spawn the child worker as
# many times as it tells us to
try:
while autoreload.restart_with_reloader() == 3:
pass
except KeyboardInterrupt:
pass
def handle(self, *args, **kwargs):
"""Run the websocket server."""
# Set the settings module for the websocket server.
if 'DJANGO_SETTINGS_MODULE' not in os.environ:
os.environ['DJANGO_SETTINGS_MODULE'] = 'settings'
# Import the WSGI handler.
application = self.get_handler(*args, **kwargs)
# Print nice things to the console; make it look mostly like
# the traditional Django dev server.
print "Django version {version}, using settings '{settings}'.".format(
settings=os.environ['DJANGO_SETTINGS_MODULE'],
version=django.get_version(),
)
print ' '.join((
'SocketIO server is listening on port %d' % kwargs['port'],
'and on port 843 (Flash policy server).',
))
print 'Quit the server with CONTROL-C.'
# Create the SocketIO server.
# Pay special attention here to the `resource` keyword argument.
# The SocketIO server will only do SocketIO connections on URIs
# starting with this resource. So, using "socket.io" as your
# resource means that the SocketIO server expects its special
# connections to come in at `http://domain.com/socket.io/foo/`.
# The default on both the Python side and the JavaScript side
# is "socket.io", and this is probably the best choice. It's possible
# to use something else, but it has to match everywhere and most
# likely won't be very DRY unless you jump a lot of hoops.
socket_io_server = SocketIOServer(
(kwargs['host'], kwargs['port']),
application,
resource='socket.io',
policy_server=True,
)
# Set up the socket io server to actually serve; use the
# auto-reloader if desired.
use_reloader = kwargs['use_reloader']
if use_reloader:
spawn(reload_watcher)
# Run the socket.io server within a try/except block
# (so that if it is shut down, it can be restarted).
try:
socket_io_server.serve_forever()
except KeyboardInterrupt:
global _server_should_reload
if _server_should_reload:
# Set my "should reload" variable back to False.
_server_should_reload = False
# Kill the server.
socket_io_server.kill()
socket_io_server = None
# Now, reload a new server.
print '\nReloading server...'
restart_with_reloader()
else:
print '\r\n\n'
sys.exit(0)