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 server(args):
try:
from socketio.server import SocketIOServer
from ouimeaux.server import app, initialize
except ImportError:
print(
"ouimeaux server dependencies are not installed. Please run, e.g., 'pip install ouimeaux[server]'"
)
sys.exit(1)
initialize(bind=getattr(args, 'bind', None))
level = logging.INFO
if getattr(args, 'debug', False):
level = logging.DEBUG
logging.basicConfig(level=level)
try:
# TODO: Move this to configuration
listen = WemoConfiguration().listen or '0.0.0.0:5000'
try:
host, port = listen.split(':')
except Exception:
print("Invalid bind address configuration:", listen)
sys.exit(1)
SocketIOServer((host, int(port)),
app,
policy_server=False,
namespace="socket.io").serve_forever()
except (KeyboardInterrupt, SystemExit):
sys.exit(0)
def _run(self):
global app
app.add_processor(check_api_version)
app.add_processor(check_authorized)
app.add_processor(db_connect)
app = web.httpserver.StaticMiddleware(app.wsgifunc())
SocketIOServer(('0.0.0.0', 8081), app, resource="socket.io").serve_forever()
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 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 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 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():
# print 'Listening on port http://0.0.0.0:8080 and on port 10843 (flash policy server)'
SocketIOServer(('0.0.0.0', 8080),
Application(),
resource="socket.io",
policy_server=True,
policy_listener=('0.0.0.0', 10843)).serve_forever()
def start(http_host, http_port, smtp_host, smtp_port, db_path=None):
global socketio_server
# Webserver
log.notice('Starting web server on http://{0}:{1}'.format(
http_host, http_port))
socketio_server = SocketIOServer((http_host, http_port),
app,
log='default' if app.debug else None)
socketio_server.start()
# SMTP server
log.notice('Starting smtp server on {0}:{1}'.format(smtp_host, smtp_port))
SMTPServer((smtp_host, smtp_port), smtp_handler)
gevent.spawn(asyncore.loop)
# Database
connect(db_path)
create_tables()
# Wait....
try:
stopper.wait()
except KeyboardInterrupt:
print()
else:
log.debug('Received stop signal')
# Clean up
disconnect()
log.notice('Terminating')
def test_namespace_decorator(self):
SocketIOServer.default_server = SocketIOServer(listener=8000,
application=application)
ns = SocketIOServer.default_server.of('/chat')
m = {}
@namespace('/chat')
class TestNameSpace(object):
@classmethod
def on_test(cls, socket, message):
m['message'] = message
socket = ns.add(
Client(id=1,
engine_socket=EngineSocket(ready_state='OPEN'),
packet=packet,
request=Request(GET='test',
scheme='http',
headers={},
url='http://test')))
socket.on_event({'type': 2, 'data': ['test', 'hello']})
self.assertEqual(m['message'], 'hello')
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 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 main():
server = '127.0.0.1'
print 'Listening on port http://%s:8080 and on port 10843 (flash policy server)' % server
SocketIOServer((server, 8080),
Application(),
resource="socket.io",
policy_server=True,
policy_listener=(server, 10843)).serve_forever()
def main():
logger.debug(
'Listening on port http://127.0.0.1:8080 and on port 10843 (flash policy server)'
)
SocketIOServer(('127.0.0.1', 8001),
Application(),
resource="socket.io",
policy_server=True).serve_forever()
def run_dev_server():
app.debug = True
port = 5000
print "Starting latlng generator server..."
#gl = gevent.Greenlet.spawn(loop)
gl = gevent.Greenlet.spawn(loop_gps)
print "Starting map server..."
SocketIOServer(('', port), app, resource="socket.io").serve_forever()
def __init__(self):
self.app = web.app
self.server = SocketIOServer((self.address, self.port),
self.app,
log=logfile.pywsgi_access_logger(logger),
resource='socket.io',
policy_server=False)
self.add_service(ServerWrapper(self.server))
def run(self, handler):
from socketio.server import SocketIOServer
resource = self.options.get('resource', 'socket.io')
policy_server = self.options.get('policy_server', False)
SocketIOServer((self.host, self.port),
handler,
resource=resource,
policy_server=policy_server,
transports=["xhr-multipart",
"xhr-polling"]).serve_forever()
def run(self, host='localhost', port=9000):
"""
Run http and websocket server.
"""
print 'Listening on port %s and on port 10843 (flash policy server)' % port
SocketIOServer((host, port),
WSGIHandler(self.url_list, self.socketio_url_list),
resource="socket.io",
policy_server=True,
policy_listener=(host, 10843)).serve_forever()
def handle(self, **options):
print 'GO GO GO Socket IO'
print 'Listening on port %s:%s' % (options['host'], options['port'])
SocketIOServer(
('0.0.0.0', options['port']),
Application(),
resource='socket.io',
policy_server=True,
policy_listener=('0.0.0.0', 843),
).serve_forever()
def main():
global user_data_file
args = parse_arguments()
user_data_file = args.user_file
print('Listening on port 8080')
SocketIOServer(('0.0.0.0', 8080),
Application(),
resource='socket.io',
policy_server=False).serve_forever()
return 0
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 main():
http_app = SharedDataMiddleware(
app, {'/': os.path.join(os.path.dirname(__file__), 'static')})
socket_server = SocketIOServer(('', 8000),
http_app,
namespace='socket.io',
policy_server=False)
gevent.joinall([
gevent.spawn(socket_server.serve_forever),
gevent.spawn(event_subscriber, event_handler),
])
def runserver():
"""Runs webserver as SocketIOServer"""
monkey.patch_all()
print "Listening on http://%s:%s and port %s for flash policy requests" % (
app.config["BIND_IP"], app.config["HTTP_PORT"], app.config["FLASH_POLICY_PORT"])
SocketIOServer(
(app.config["BIND_IP"], app.config["HTTP_PORT"]),
app, resource="socket.io",
policy_server=True,
policy_listener=(app.config["BIND_IP"], app.config["FLASH_POLICY_PORT"])).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():
# setup server to handle webserver requests
http_server = WSGIServer(bottle_config['host'], things_app)
# setup server to handle websocket requests
sio_server = SocketIOServer(socket_config['host'],
socket_app_router,
policy_server=False)
gevent.joinall([
gevent.spawn(http_server.serve_forever),
gevent.spawn(sio_server.serve_forever)
])
def main():
print "Open your browser and go to http://localhost:3132"
ch = logging.StreamHandler(sys.stdout)
ch.setLevel(logging.DEBUG)
formatter = logging.Formatter(
'%(asctime)s - %(name)s - %(levelname)s - %(message)s')
ch.setFormatter(formatter)
application.logger.addHandler(ch)
SocketIOServer(
('', application.config['PORT']),
application,
resource="socket.io").serve_forever()
def main():
# setup server to handle webserver requests
http_server = WSGIServer(('', 8000), app)
# setup server to handle websocket requests
sio_server = SocketIOServer(('', 9999),
SocketIOApp(),
namespace="socket.io",
policy_server=False)
gevent.joinall([
gevent.spawn(http_server.serve_forever),
gevent.spawn(sio_server.serve_forever)
])
