def setup_socket_handler_routers(module_name, installed_apps):
from Mojo.SocketHandlers.BaseSocketHandler import CURRENT_SESSIONS, LOGGED_IN_SESSIONS, MojoSocketHandler
endpoints = {
} #TODO: potentially add a baked-in control connection: {'/MojoControl': ControlConnection}
for appName in installed_apps:
app_socket_handler = None
#socket_init_string = 'from Apps.%s.socket_handlers import *' % (appName)
#exec(socket_init_string)
socket_module_string = 'from Apps.%s.socket_handlers import SocketConnectionHandler as app_socket_handler' % (
appName)
exec(socket_module_string)
if app_socket_handler:
endpoint_str = '/%sSocket' % appName
new_endpoint = {endpoint_str: app_socket_handler}
endpoints.update(new_endpoint)
logging.debug("--Added SocketHandler for: %s" % (appName))
else:
logging.debug("--Couldn't find any Socket Handlers for app: %s" %
(appName))
# This voodoo creates the SocketConnection class dynamically
# thisSocketConnection = type(
# 'MojoSocketHandler',
# (object,),
# dict(__endpoints__ = endpoints))
thisSocketConnection = MojoSocketHandler
thisSocketConnection.__endpoints__ = endpoints
SocketRouter = tornadio2.TornadioRouter(thisSocketConnection)
return SocketRouter
def __init__(self, uri, port):
# Creating a Tornadio2 server for the connection
MyRouter = tornadio2.TornadioRouter(MyConnection)
application = Application(MyRouter.urls, socket_io_port=port)
self.http_server = SocketServer(application,
auto_start=False,
xheaders=True)
def __init__(self):
app_router = tornadio2.TornadioRouter(EventHandler)
routes = [
(r"/static/(.*)", web.StaticFileHandler, {"path": "./static"}),
(r"/", WebHandler),
(r"/keepalive", KeepAliveHandler),
(r"/log", LogHandler),
(r"/gallery", GalleryHandler),
(r"/last-image", LastImageHandler)
]
routes.extend(app_router.urls)
self.application = web.Application(routes, socket_io_port = APP_PORT, debug = 1)
def get_app(self): self.late_init_configuration(self.io_loop) routes = [] socketio_router = tornadio2.TornadioRouter( paasmaker.pacemaker.controller.stream.StreamConnection ) # Hack to store the configuration on the socket.io router. socketio_router.configuration = self.configuration application_settings = self.configuration.get_tornado_configuration() application = tornado.web.Application( socketio_router.apply_routes(routes), **application_settings ) return application
def __init__(self):
handlers = [
URLSpec(r'/', IndexHandler, name="index"),
URLSpec(r'/connect/', ConnectHandler, name="connect"),
URLSpec(r'/disconnect/', DisconnectHandler, name="disconnect"),
URLSpec(r'/([^/]+)/reloadconfig/',
ReloadconfigHandler,
name="reloadconfig"),
URLSpec(r'/([^/]+)/add_watcher/',
WatcherAddHandler,
name="add_watcher"),
URLSpec(r'/([^/]+)/watcher/([^/]+)/',
WatcherHandler,
name="watcher"),
URLSpec(r'/([^/]+)/watcher/([^/]+)/switch_status/',
WatcherSwitchStatusHandler,
name="switch_status"),
URLSpec(r'/([^/]+)/watcher/([^/]+)/process/kill/([^/]+)/',
KillProcessHandler,
name="kill_process"),
URLSpec(r'/([^/]+)/watcher/([^/]+)/process/decr/',
DecrProcHandler,
name="decr_proc"),
URLSpec(r'/([^/]+)/watcher/([^/]+)/process/incr/',
IncrProcHandler,
name="incr_proc"),
URLSpec(r'/sockets/', SocketsHandler, name="all_sockets"),
URLSpec(r'/([^/]+)/sockets/', SocketsHandler, name="sockets"),
]
self.loader = MakoTemplateLoader(TMPLDIR)
self.router = tornadio2.TornadioRouter(SocketIOConnection)
handlers += self.router.urls
settings = {
'template_loader': self.loader,
'static_path': STATIC_PATH,
'debug': True,
'cookie_secret': 'fxCIK+cbRZe6zhwX8yIQDVS54LFfB0I+nQt0pGp3IY0='
}
tornado.web.Application.__init__(self, handlers, **settings)
class Server():
def __init__(self,
configfile=None,
basedir=None,
host="0.0.0.0",
port=5000,
debug=False):
self._configfile = configfile
self._basedir = basedir
self._host = host
self._port = port
self._debug = debug
def run(self):
# Global as I can't work out a way to get it into PrinterStateConnection
global printer
global gcodeManager
global userManager
from tornado.wsgi import WSGIContainer
from tornado.httpserver import HTTPServer
from tornado.ioloop import IOLoop
from tornado.web import Application, FallbackHandler
# first initialize the settings singleton and make sure it uses given configfile and basedir if available
self._initSettings(self._configfile, self._basedir)
# then initialize logging
self._initLogging(self._debug)
logger = logging.getLogger(__name__)
gcodeManager = gcodefiles.GcodeManager()
printer = Printer(gcodeManager)
if settings().getBoolean(["accessControl", "enabled"]):
userManagerName = settings().get(["accessControl", "userManager"])
try:
clazz = util.getClass(userManagerName)
userManager = clazz()
except AttributeError, e:
logger.exception(
"Could not instantiate user manager %s, will run with accessControl disabled!"
% userManagerName)
app.secret_key = "k3PuVYgtxNm8DXKKTw2nWmFQQun9qceV"
login_manager = LoginManager()
login_manager.session_protection = "strong"
login_manager.user_callback = load_user
if userManager is None:
login_manager.anonymous_user = users.DummyUser
principals.identity_loaders.appendleft(users.dummy_identity_loader)
login_manager.init_app(app)
if self._host is None:
self._host = settings().get(["server", "host"])
if self._port is None:
self._port = settings().getInt(["server", "port"])
logger.info("Listening on http://%s:%d" % (self._host, self._port))
app.debug = self._debug
self._router = tornadio2.TornadioRouter(self._createSocketConnection)
self._tornado_app = Application(self._router.urls +
[(".*", FallbackHandler, {
"fallback": WSGIContainer(app)
})])
self._server = HTTPServer(self._tornado_app)
self._server.listen(self._port, address=self._host)
IOLoop.instance().start()
if configuration.is_heart():
# Heart setup.
routes.extend(paasmaker.heart.controller.instance.InstanceExitController.get_routes(route_extras))
if configuration.is_router():
# Router setup.
# Connect to redis.
pass
logging.info("Setting up common routes...")
routes.extend(paasmaker.common.controller.information.InformationController.get_routes(route_extras))
routes.extend(paasmaker.pacemaker.controller.job.JobLogController.get_routes(route_extras))
# The socketio routers. It's all in a single controller for the moment.
socketio_router = tornadio2.TornadioRouter(
paasmaker.pacemaker.controller.stream.StreamConnection
)
# Hack to store the configuration on the socket.io router.
socketio_router.configuration = configuration
# Set up the application object.
# NOTE: What's happening here is that the socket.io router takes
# over routing, and passes through requests to the normal HTTP endpoints.
logging.info("Setting up the application.")
application_settings = configuration.get_tornado_configuration()
# We don't need to have a second socket_io_port, so choose a high port
# that's free for this purpose. Otherwise tornadio2 doesn't work.
tornadio_port_finder = paasmaker.util.port.FreePortFinder()
application_settings['socket_io_port'] = tornadio_port_finder.free_in_range(65000, 65500)
application = tornado.web.Application(
socketio_router.apply_routes(routes),
tornado.options.define('debug',
default=False,
type=bool,
help=("Turn on autoreload"))
tornado.options.parse_command_line()
motor_client = motor.MotorClient()
motor_client.open_sync()
motor_db = motor_client.test
cursor_manager = CursorManager(motor_db)
cursor_manager.start()
router = tornadio2.TornadioRouter(TailingHandler)
this_dir = os.path.dirname(__file__)
static_path = os.path.join(this_dir, 'static')
application = tornado.web.Application(
router.apply_routes([
(r'/chirps', ChirpsHandler),
(r'/new', NewChirpHandler),
(r'/clear', ClearChirpsHandler),
(r'/()', tornado.web.StaticFileHandler, {
'path': os.path.join(static_path, 'index.html')
}),
]),
static_path=static_path,
socket_io_port=8001,
motor_db=motor_db,
@tornado.web.asynchronous
@tornado.gen.engine
def get(self):
self.set_cookie('uid', '')
self.set_cookie('secret', '')
self.redirect("/")
if __name__ == '__main__':
pc = PikaClient(
getattr(settings, 'PIKA_HOST', 'localhost'),
getattr(settings, 'PIKA_QUEUE', 'uglyweb'),
)
current = os.path.dirname(__file__)
BaseConnection.pc = pc
router = tornadio2.TornadioRouter(BaseConnection)
coffee2js('media/coffee/', 'media/js/')
haml2html('haml/', 'templates/')
sass2css('media/sass/', 'media/css/')
application = tornado.web.Application(
router.apply_routes([
(r"/", IndexHandler),
(r'/login/', VKHandler),
(r'/logout/', LogoutHandler),
]),
debug=getattr(settings, 'DEBUG', True),
socket_io_port=getattr(settings, 'PORT', 8080),
flash_policy_port=843,
flash_policy_file=os.path.join(current, 'flashpolicy.xml'),
db_host=getattr(settings, 'DB_HOST', 'localhost'),
db_port=getattr(settings, 'DB_PORT', 27017),
if name in self.handlers:
self.handlers[name].stop()
# self.request is the TCP socket connected to the client
self.handlers[name] = kMonitorQueryHandler(name = name, query = monitorQuery, connection = self);
def sendCalls(self, name, calls):
self.emit(name, calls);
def handle(self, apiRequest):
# use cloned list in order to overcome changes in the list during the iterations
keys = self.handlers.keys()
for name in keys:
self.handlers[name].ingest(apiRequest)
kMonitorRouter = tornadio2.TornadioRouter(kMonitorClient)
routes = [
('/', IndexHandler),
('/js/.*', IndexHandler)
]
routes.extend(kMonitorRouter.urls)
application = tornado.web.Application(
routes,
socket_io_port = 8001)
def collectRequests():
address = ('localhost', 6005)
server_socket = socket(AF_INET, SOCK_DGRAM)
def launch_chatserver(bot, port=8888):
ChatConnection.bot = bot
chat_router = tornadio2.TornadioRouter(ChatConnection)
application = tornado.web.Application(chat_router.urls,
socket_io_port=port)
return tornadio2.SocketServer(application, auto_start=False)
def on_close(self):
logging.debug('MyConnection::on_close. session_id: %s' %
unicode(self.session.session_id))
if self.session.session_id in OperationNotifier.sessions:
del OperationNotifier.sessions[self.session.session_id]
MyRouter = tornadio2.TornadioRouter(
MyConnection,
namespace='dchat',
user_settings={
'enabled_protocols': [
# 'websocket',
'xhr-polling',
'flashsocket',
'xhr-multipart',
],
'xhr_polling_timeout':
30,
'heartbeat_interval':
25
})
application = WebApplication(MyRouter.urls, socket_io_port=8086)
if __name__ == "__main__":
import logging
logging.getLogger().setLevel(logging.ERROR)
tornadio2.server.SocketServer(application, auto_start=False)
ioloop.IOLoop.instance().start()
self.conn_id,
'channel':
'presence:left',
'message':
json.dumps({
'conn_id': self.conn_id,
'user_id': self.user_id
})
}))
self.add_msg_count()
def add_msg_count(self):
CLIENTS[self.api_key]['usage']['messages'] += 1
MyRouter = tornadio2.TornadioRouter(WSConnection)
if __name__ == '__main__':
try:
port = sys.argv[1]
print 'starting server on port %s' % port
io_loop = ioloop.IOLoop.instance()
# add redis monitor loop
redis_loop = ioloop.PeriodicCallback(redis_monitor,
1000,
io_loop=io_loop)
redis_loop.start()
# add usage monitor loop
usage_loop = ioloop.PeriodicCallback(usage_update,
