def web_index(self):
# Render base template
data = self.getSessionData()
url_state = ""
if self.request.arguments.has_key("url_state") and len(
self.request.arguments["url_state"][0]) > 0:
url_state = self.request.arguments["url_state"][0]
view_name = Conf.getTheme()
if self.request.arguments.has_key("view") and len(
self.request.arguments["view"][0]) > 0:
view_name = self.request.arguments["view"][0]
theme_name = "ext-all-gray"
if self.request.arguments.has_key("theme") and len(
self.request.arguments["theme"][0]) > 0:
if self.request.arguments["theme"][0] == "Neptune":
theme_name = "ext-all-neptune"
if self.request.arguments["theme"][0] == "Classic":
theme_name = "ext-all"
open_app = ""
if self.request.arguments.has_key("open_app") and len(
self.request.arguments["open_app"][0]) > 0:
open_app = self.request.arguments["open_app"][0].strip()
icon = data['baseURL'] + Conf.getIcon()
level = str(gLogger.getLevel()).lower()
self.render("root.tpl",
iconUrl=icon,
base_url=data['baseURL'],
_dev=Conf.devMode(),
ext_version=data['extVersion'],
url_state=url_state,
extensions=data['extensions'],
credentials=data['user'],
title=Conf.getTitle(),
theme=theme_name,
root_url=Conf.rootURL(),
view=view_name,
open_app=open_app,
debug_level=level)
def __isGroupAuthApp(self, appLoc):
handlerLoc = "/".join(List.fromChar(appLoc, ".")[1:])
if not handlerLoc:
return False
if handlerLoc not in self.__handlers:
gLogger.error("Handler %s required by %s does not exist!" %
(handlerLoc, appLoc))
return False
handler = self.__handlers[handlerLoc]
auth = AuthManager(Conf.getAuthSectionForHandler(handlerLoc))
return auth.authQuery("", dict(self.__credDict), handler.AUTH_PROPS)
def __change(self, setup=None, group=None):
if not setup:
setup = self.getUserSetup()
if not group:
group = self.getUserGroup() or 'anon'
qs = False
if 'Referer' in self.request.headers:
o = urlparse.urlparse(self.request.headers['Referer'])
qs = '?%s' % o.query
url = [Conf.rootURL().strip("/"), "s:%s" % setup, "g:%s" % group]
self.redirect("/%s%s" % ("/".join(url), qs))
def run(self):
"""
Start web servers
"""
bu = Conf.rootURL().strip("/")
urls = []
for proto, port in self.__servers:
urls.append("%s://0.0.0.0:%s/%s/" % (proto, port, bu))
self.log.always("Listening on %s" % " and ".join(urls))
tornado.autoreload.add_reload_hook(self.__reloadAppCB)
tornado.ioloop.IOLoop.instance().start()
def get(self, setup, group, route):
if self.__action == "addSlash":
o = urlparse.urlparse(self.request.uri)
proto = self.request.protocol
if 'X-Scheme' in self.request.headers:
proto = self.request.headers['X-Scheme']
nurl = "%s://%s%s/" % (proto, self.request.host, o.path)
if o.query:
nurl = "%s?%s" % (nurl, o.query)
self.redirect(nurl, permanent=True)
elif self.__action == "sendToRoot":
dest = "/"
rootURL = Conf.rootURL()
if rootURL:
dest += "%s/" % rootURL.strip("/")
if setup and group:
dest += "s:%s/g:%s/" % (setup, group)
self.redirect(dest)
def getData(self):
data = {
'menu': self.__getGroupMenu(),
'user': self.__credDict,
'validGroups': [],
'setup': self.__setup,
'validSetups': gConfig.getSections("/DIRAC/Setups")['Value'],
'extensions': self.__extensions,
'extVersion': self.getExtJSVersion()
}
#Add valid groups if known
DN = self.__credDict.get("DN", "")
if DN:
result = Registry.getGroupsForDN(DN)
if result['OK']:
data['validGroups'] = result['Value']
#Calculate baseURL
baseURL = [
Conf.rootURL().strip("/"),
"s:%s" % data['setup'],
"g:%s" % self.__credDict.get('group', '')
]
data['baseURL'] = "/%s" % "/".join(baseURL)
return data
def __init__(self):
self.__handlerMgr = HandlerMgr(Conf.rootURL())
self.__servers = {}
self.log = gLogger.getSubLogger("Web")
def bootstrap(self):
"""
Configure and create web app
"""
self.log.always("\n ====== Starting DIRAC web app ====== \n")
# Load required CFG files
if not self._loadDefaultWebCFG(
): # if we have a web.cfg under etc directory we use it, otherwise we use the configuration file defined by the developer
self._loadWebAppCFGFiles()
# Calculating routes
result = self.__handlerMgr.getRoutes()
if not result['OK']:
return result
routes = result['Value']
# Initialize the session data
SessionData.setHandlers(self.__handlerMgr.getHandlers()['Value'])
# Create the app
tLoader = TemplateLoader(self.__handlerMgr.getPaths("template"))
kw = dict(debug=Conf.devMode(),
template_loader=tLoader,
cookie_secret=Conf.cookieSecret(),
log_function=self._logRequest)
# Check processes if we're under a load balancert
if Conf.balancer() and Conf.numProcesses() not in (0, 1):
tornado.process.fork_processes(Conf.numProcesses(), max_restarts=0)
kw['debug'] = False
# Debug mode?
if kw['debug']:
self.log.info("Configuring in developer mode...")
# Configure tornado app
self.__app = tornado.web.Application(routes, **kw)
self.log.notice("Configuring HTTP on port %s" % (Conf.HTTPPort()))
# Create the web servers
srv = tornado.httpserver.HTTPServer(self.__app)
port = Conf.HTTPPort()
srv.listen(port)
self.__servers[('http', port)] = srv
Conf.generateRevokedCertsFile() # it is used by nginx....
if Conf.HTTPS():
self.log.notice("Configuring HTTPS on port %s" % Conf.HTTPSPort())
sslops = dict(certfile=Conf.HTTPSCert(),
keyfile=Conf.HTTPSKey(),
cert_reqs=ssl.CERT_OPTIONAL,
ca_certs=Conf.generateCAFile())
sslprotocol = str(Conf.SSLProrocol())
aviableProtocols = [i for i in dir(ssl) if i.find('PROTOCOL') == 0]
if sslprotocol and sslprotocol != "":
if (sslprotocol in aviableProtocols):
sslops['ssl_version'] = getattr(ssl, sslprotocol)
else:
message = "%s protocol is not provided. The following protocols are provided: %s" % (
sslprotocol, str(aviableProtocols))
gLogger.warn(message)
self.log.debug(
" - %s" %
"\n - ".join(["%s = %s" % (k, sslops[k]) for k in sslops]))
srv = tornado.httpserver.HTTPServer(self.__app, ssl_options=sslops)
port = Conf.HTTPSPort()
srv.listen(port)
self.__servers[('https', port)] = srv
else:
Conf.generateCAFile(
) # if we use Nginx we have to generate the cas as well...
return result