def GET(self, *args):
l = len(args)
if l == 0:
use_query = db.query('SELECT COUNT(DISTINCT UKEY) AS USE_COUNT FROM USEFLAGS')
use_tuple = use_query[0]
use_data = {'USE_COUNT':use_tuple['USE_COUNT']}
if helpers.is_json_request():
return helpers.serialize(use_data)
else:
return render.use(use_data)
elif l == 1:
global_use_query = db.query('SELECT COUNT(DISTINCT UUID) AS GLOBAL_COUNT\
FROM GLOBAL_USEFLAGS RIGHT OUTER JOIN USEFLAGS\
ON GLOBAL_USEFLAGS.UKEY = USEFLAGS.UKEY\
WHERE USEFLAG=$useflag', vars={'useflag':args[0]})
plus_use_query = db.query('SELECT COUNT(DISTINCT IPKEY) AS PLUS_COUNT\
FROM PLUS_USEFLAGS RIGHT OUTER JOIN USEFLAGS\
ON PLUS_USEFLAGS.UKEY = USEFLAGS.UKEY\
WHERE USEFLAG=$useflag', vars={'useflag':args[0]})
minus_use_query = db.query('SELECT COUNT(DISTINCT IPKEY) AS MINUS_COUNT\
FROM MINUS_USEFLAGS RIGHT OUTER JOIN USEFLAGS\
ON MINUS_USEFLAGS.UKEY = USEFLAGS.UKEY\
WHERE USEFLAG=$useflag', vars={'useflag':args[0]})
unset_use_query = db.query('SELECT COUNT(DISTINCT IPKEY) AS UNSET_COUNT\
FROM UNSET_USEFLAGS RIGHT OUTER JOIN USEFLAGS\
ON UNSET_USEFLAGS.UKEY = USEFLAGS.UKEY\
WHERE USEFLAG=$useflag', vars={'useflag':args[0]})
global_use_tuple = global_use_query[0]
plus_use_tuple = plus_use_query[0]
minus_use_tuple = minus_use_query[0]
unset_use_tuple = unset_use_query[0]
use_data = {
'GLOBAL_COUNT':global_use_tuple['GLOBAL_COUNT'],
'PLUS_COUNT':plus_use_tuple['PLUS_COUNT'],
'MINUS_COUNT':minus_use_tuple['MINUS_COUNT'],
'UNSET_COUNT':unset_use_tuple['UNSET_COUNT']
}
if helpers.is_json_request():
return helpers.serialize(use_data)
else:
return render.use_useflag(args[0], use_data)
else:
return config.internalerror()
def GET(self):
profile_count = db.select('ENV', what='PROFILE, COUNT(UUID) AS HOSTS', group='PROFILE')
profile_data = dict()
for t in profile_count:
profile_data[t['PROFILE']] = {'HOSTS':t['HOSTS']}
if helpers.is_json_request():
return helpers.serialize(profile_data)
else:
return render.profile(profile_data)
def GET(self):
mirror_count = db.query('SELECT MIRROR,COUNT(UUID) AS HOSTS\
FROM HOST_MIRRORS NATURAL JOIN GENTOO_MIRRORS GROUP BY MIRROR')
mirror_data = dict()
for t in mirror_count:
mirror_data[t['MIRROR']] = {'HOSTS':t['HOSTS']}
if helpers.is_json_request():
return helpers.serialize(mirror_data)
else:
return render.mirror(mirror_data)
def GET(self):
feature_count = db.query('SELECT FEATURE,COUNT(UUID) AS HOSTS\
FROM HOST_FEATURES NATURAL JOIN FEATURES GROUP BY FEATURE')
feature_data = dict()
for t in feature_count:
feature_data[t['FEATURE']] = {'HOSTS':t['HOSTS']}
if helpers.is_json_request():
return helpers.serialize(feature_data)
else:
return render.feature(feature_data)
def GET(self):
repo_count = db.query('SELECT REPO,COUNT(DISTINCT IPKEY) AS PACKAGES,\
COUNT(DISTINCT UUID) AS HOSTS\
FROM INSTALLED_PACKAGES NATURAL JOIN REPOSITORIES GROUP BY REPO')
repo_data = dict()
for t in repo_count:
repo_data[t['REPO']] = {'HOSTS':t['HOSTS'], 'PACKAGES':t['PACKAGES']}
if helpers.is_json_request():
return helpers.serialize(repo_data)
else:
return render.repo(repo_data)
def __GET_CPV(self, cat, pkg, ver):
p_query = db.query('SELECT COUNT(DISTINCT UUID) AS HOST_COUNT\
FROM INSTALLED_PACKAGES RIGHT OUTER JOIN PACKAGES\
ON INSTALLED_PACKAGES.PKEY = PACKAGES.PKEY\
WHERE CAT=$cat AND PKG=$pkg AND VER=$ver', vars={'cat':cat, 'pkg':pkg, 'ver':ver})
p_tuple = p_query[0]
p_data = {
'HOST_COUNT':p_tuple['HOST_COUNT'],
}
if helpers.is_json_request():
return helpers.serialize(p_data)
else:
return render.package_cpv(cat, pkg, ver, p_data)
def GET(self):
arch_count = db.select("ENV", what="ARCH, COUNT(UUID) AS HOSTS", group="ARCH")
arch_data = dict()
for t in arch_count:
arch_data[t["ARCH"]] = {"HOSTS": t["HOSTS"]}
if helpers.is_json_request():
return helpers.serialize(arch_data)
else:
# generate plot
x_ticklabels = arch_data.keys()
y_values = [arch_data[a]["HOSTS"] for a in x_ticklabels]
arch_plot = helpers.barchart(
title="Hosts per arch",
x_label="Arch",
y_label="Number of Hosts",
x_ticklabels=x_ticklabels,
y_values=y_values,
)
return render.arch(arch_data, arch_plot)
def __GET_CP(self, top, cat, pkg):
"""
Get category/package-version
"""
p_query = db.query('SELECT COUNT(DISTINCT UUID) AS HOST_COUNT, \
COUNT(DISTINCT CAT, PKG, VER) AS CPV_COUNT\
FROM INSTALLED_PACKAGES RIGHT OUTER JOIN PACKAGES\
ON INSTALLED_PACKAGES.PKEY = PACKAGES.PKEY\
WHERE CAT=$cat AND PKG=$pkg', vars={'cat':cat, 'pkg':pkg})
p_tuple = p_query[0]
p_data = {
'HOST_COUNT':p_tuple['HOST_COUNT'],
'CPV_COUNT':p_tuple['CPV_COUNT'],
'TOP_CPV':self.__top(top, cat, pkg)
}
if helpers.is_json_request():
return helpers.serialize(p_data)
else:
return render.package_cp(cat, pkg, p_data)
def GET(self):
keyword_count = db.query('SELECT KEYWORD,\
COUNT(DISTINCT IPKEY) AS PACKAGES,\
COUNT(DISTINCT UUID) AS HOSTS\
FROM GLOBAL_KEYWORDS NATURAL JOIN KEYWORDS\
NATURAL JOIN INSTALLED_PACKAGES GROUP BY KEYWORD')
keyword_data = dict()
for t in keyword_count:
keyword_data[t['KEYWORD']] = {'HOSTS':t['HOSTS'], 'PACKAGES':t['PACKAGES']}
if helpers.is_json_request():
return helpers.serialize(keyword_data)
else:
# generate plot
x_ticklabels = keyword_data.keys()
y_values = [ keyword_data[k]['PACKAGES'] for k in x_ticklabels ]
keyword_plot = helpers.barchart(title = 'Installed packages per keyword',
x_label = 'Keyword', y_label = 'Number of Packages',
x_ticklabels = x_ticklabels, y_values = y_values)
return render.keyword(keyword_data, keyword_plot)
def __GET(self, top):
"""
Get category
"""
p_query = db.query('SELECT COUNT(DISTINCT UUID) AS HOST_COUNT, \
COUNT(DISTINCT CAT) AS C_COUNT, \
COUNT(DISTINCT CAT, PKG) AS CP_COUNT, \
COUNT(DISTINCT CAT, PKG, VER) AS CPV_COUNT\
FROM INSTALLED_PACKAGES RIGHT OUTER JOIN PACKAGES\
ON INSTALLED_PACKAGES.PKEY = PACKAGES.PKEY')
p_tuple = p_query[0]
p_data = {
'HOST_COUNT':p_tuple['HOST_COUNT'],
'C_COUNT':p_tuple['C_COUNT'],
'CP_COUNT':p_tuple['CP_COUNT'],
'CPV_COUNT':p_tuple['CPV_COUNT'],
'TOP_C':self.__top(top)
}
if helpers.is_json_request():
return helpers.serialize(p_data)
else:
return render.package(p_data)
def GET(self):
self.args = web.input(cat='any', pkg='any', ver='any', repo='any')
try:
self.min_hosts = int(web.input(min_hosts=-1).min_hosts)
except ValueError:
self.min_hosts = -1
try:
self.max_hosts = int(web.input(max_hosts=-1).max_hosts)
except ValueError:
self.max_hosts = -1
where = self._build_where()
having = self._build_having()
query = self._build_query(where, having)
search_tuples = db.query(query, vars={
'cat':self.args.cat,
'pkg':self.args.pkg,
'ver':self.args.ver,
'repo':self.args.repo,
'min_hosts':self.min_hosts,
'max_hosts':self.max_hosts})
if helpers.is_json_request():
search_list = list()
for tuple in search_tuples:
search_list.append({
'CAT': tuple['CAT'],
'PKG': tuple['PKG'],
'VER': tuple['VER'],
'REPO': tuple['REPO'],
'HOSTS': tuple['HOSTS']
})
return helpers.serialize(search_list)
else:
return render.search(search_tuples)
def GET(self, *args):
if len(args) == 0:
form = host_form()
return render.host_input(form)
str_uuid = args[0]
if not helpers.is_uuid(str_uuid):
return config.notfound()
uuid = helpers.uuidbin(str_uuid)
hosts = db.select('HOSTS', vars={'uuid':uuid}, where='UUID=$uuid', what='UUID')
if len(hosts) == 0:
return config.notfound()
host_data = dict()
host_data['UUID'] = str_uuid
env = db.select('ENV', vars={'uuid':uuid}, where="UUID=$uuid")
e = env[0]
for var in ['PLATFORM', 'LASTSYNC', 'PROFILE', 'ARCH', 'CHOST', 'CFLAGS', 'CXXFLAGS', 'FFLAGS', 'LDFLAGS', 'MAKEOPTS', 'SYNC']:
host_data[var] = e[var]
host_data['FEATURES'] = list()
features = db.query('SELECT FEATURE\
FROM HOST_FEATURES NATURAL JOIN FEATURES\
WHERE UUID=$uuid', vars={'uuid':uuid})
for f in features:
host_data['FEATURES'].append(f['FEATURE'])
host_data['ACCEPT_KEYWORDS'] = list()
keywords = db.query('SELECT KEYWORD\
FROM GLOBAL_KEYWORDS NATURAL JOIN KEYWORDS\
WHERE UUID=$uuid', vars={'uuid':uuid})
for k in keywords:
host_data['ACCEPT_KEYWORDS'].append(k['KEYWORD'])
host_data['USE'] = list()
useflags = db.query('SELECT USEFLAG\
FROM GLOBAL_USEFLAGS NATURAL JOIN USEFLAGS\
WHERE UUID=$uuid', vars={'uuid':uuid})
for u in useflags:
host_data['USE'].append(u['USEFLAG'])
host_data['LANG'] = list()
lang = db.query('SELECT LANG\
FROM HOST_LANG NATURAL JOIN LANG\
WHERE UUID=$uuid', vars={'uuid':uuid})
for l in lang:
host_data['LANG'].append(l['LANG'])
host_data['GENTOO_MIRRORS'] = list()
mirrors = db.query('SELECT MIRROR\
FROM HOST_MIRRORS NATURAL JOIN GENTOO_MIRRORS\
WHERE UUID=$uuid', vars={'uuid':uuid})
for m in mirrors:
host_data['GENTOO_MIRRORS'].append(m['MIRROR'])
host_data['PACKAGES'] = dict()
packages = db.query('SELECT CAT, PKG, VER\
FROM INSTALLED_PACKAGES NATURAL JOIN PACKAGES\
WHERE UUID=$uuid ORDER BY CAT, PKG, VER', vars={'uuid':uuid})
for p in packages:
cpv = p['CAT'] + '/' + p['PKG'] + '-' + p['VER']
host_data['PACKAGES'][cpv] = dict()
if helpers.is_json_request():
return helpers.serialize(host_data)
else:
return render.host(host_data)
