def put(self, agent_id):
username = self.get_current_user()
customer_name = get_current_customer_name(username)
uri = self.request.uri
method = self.request.method
try:
logger.info(self.request.body)
oper_id = self.arguments.get('operation_id')
data = self.arguments.get('data')
apps_to_delete = self.arguments.get('apps_to_delete', [])
apps_to_add = self.arguments.get('apps_to_add', [])
error = self.arguments.get('error', None)
reboot_required = self.arguments.get('reboot_required')
app_id = self.arguments.get('app_id')
success = self.arguments.get('success')
results = (AddAppResults(username, uri, method, agent_id, app_id,
oper_id, reboot_required, success, data,
apps_to_delete, apps_to_add, error))
results_data = results.install_os_apps(data)
self.set_status(results_data['http_status'])
self.set_header('Content-Type', 'application/json')
self.write(dumps(results_data, indent=4))
send_notifications(username, customer_name, oper_id, agent_id)
except Exception as e:
results = (GenericResults(username, uri, method).something_broke(
agent_id, 'uninstall_os_apps results', e))
logger.exception(results)
self.set_status(results['http_status'])
self.set_header('Content-Type', 'application/json')
self.write(dumps(results, indent=4))
def get(self):
username = self.get_current_user().encode('utf-8')
customer_name = get_current_customer_name(username)
uri = self.request.uri
method = self.request.method
try:
results = (
customer_apps_by_type_count(
username, customer_name,
uri, method
)
)
self.set_status(results['http_status'])
self.set_header('Content-Type', 'application/json')
self.write(json.dumps(results, indent=4))
except Exception as e:
results = (
GenericResults(
username, uri, method
).something_broke('widget handler', 'widgets', e)
)
logger.exception(results)
self.set_status(results['http_status'])
self.set_header('Content-Type', 'application/json')
self.write(json.dumps(results, indent=4))
def get(self):
username = self.get_current_user()
customer_name = get_current_customer_name(username)
uri = self.request.uri
method = self.request.method
try:
results = None
os_code = self.get_argument('os_code', None)
tag_id = self.get_argument('tag_id', None)
results = systems_cpu_details(username=username,
customer_name=customer_name,
tag_id=tag_id,
os_code=os_code,
uri=uri,
method=method)
self.set_status(results['http_status'])
self.set_header('Content-Type', 'application/json')
self.write(json.dumps(results, indent=4))
except Exception as e:
results = (GenericResults(username, uri, method).something_broke(
'no stats', '', e))
logger.exception(e)
self.set_status(results['http_status'])
self.set_header('Content-Type', 'application/json')
self.write(json.dumps(results, indent=4))
def get(self, tag_id):
username = self.get_current_user().encode('utf-8')
customer_name = get_current_customer_name(username)
uri = self.request.uri
method = self.request.method
try:
count = self.get_argument('limit', 3)
results = (
tag_stats_by_os(
username, customer_name,
uri, method, tag_id, count
)
)
self.set_status(results['http_status'])
self.set_header('Content-Type', 'application/json')
self.write(json.dumps(results, indent=4))
except Exception as e:
results = (
GenericResults(
username, uri, method
).something_broke('customer os stats', 'os stats', e)
)
logger.exception(results)
self.set_status(results['http_status'])
self.set_header('Content-Type', 'application/json')
self.write(json.dumps(results, indent=4))
def get(self, tag_id):
username = self.get_current_user().encode('utf-8')
customer_name = get_current_customer_name(username)
uri = self.request.uri
method = self.request.method
try:
results = (
get_severity_bar_chart_stats_for_tag(
username, customer_name,
uri, method, tag_id
)
)
self.set_status(results['http_status'])
self.set_header('Content-Type', 'application/json')
self.write(json.dumps(results, indent=4))
except Exception as e:
results = (
GenericResults(
username, uri, method
).something_broke('tag severity stats', 'sev stats', e)
)
logger.exception(results)
self.set_status(results['http_status'])
self.set_header('Content-Type', 'application/json')
self.write(json.dumps(results, indent=4))
def get(self, tag_id):
username = self.get_current_user().encode('utf-8')
customer_name = get_current_customer_name(username)
uri = self.request.uri
method = self.request.method
try:
status = self.get_argument('status', 'available')
start_date = self.get_argument('start_date', None)
end_date = self.get_argument('end_date', None)
if start_date:
start_date = int(start_date)
if end_date:
end_date = int(end_date)
results = (
get_os_apps_history_for_tag(
username, customer_name,
uri, method, tag_id, status,
start_date, end_date
)
)
self.set_status(results['http_status'])
self.set_header('Content-Type', 'application/json')
self.write(json.dumps(results, indent=4))
except Exception as e:
results = (
GenericResults(
username, uri, method
).something_broke('customer os stats', 'os stats', e)
)
logger.exception(results)
self.set_status(results['http_status'])
self.set_header('Content-Type', 'application/json')
self.write(json.dumps(results, indent=4))
def add_tags_to_agent(self, tag_id, agent_id, conn=None):
try:
tag_for_agent_exists = list(
r.table(TagsPerAgentCollection).get_all(
[agent_id, tag_id],
index=TagsPerAgentIndexes.AgentIdAndTagId).run(conn))
tag_info = r.table(TagsCollection).get(tag_id).run(conn)
tag_name = tag_info[TagsKey.TagName]
if not tag_for_agent_exists:
agent_info = (
r.table(AgentsCollection).get(agent_id).run(conn))
if agent_info:
tag_agent_info = ({
TagsPerAgentKey.AgentId: agent_id,
TagsPerAgentKey.TagId: tag_id,
})
add_agent_to_tag = (r.table(TagsPerAgentCollection).insert(
tag_agent_info).run(conn))
if 'inserted' in add_agent_to_tag:
status = (GenericResults(self.username, self.uri,
self.method).object_updated(
tag_id, 'tag_id',
tag_agent_info))
logger.info(status['message'])
else:
status = (GenericResults(self.username, self.uri,
self.method).object_exists(
tag_id, 'tag'))
logger.warn(status['message'])
except Exception as e:
status = (GenericResults(self.username, self.uri,
self.method).something_broke(
tag_id, 'adding tag to agent', e))
logger.exception(e)
return (status)
def post(self, tag_id):
username = self.get_current_user()
customer_name = get_current_customer_name(username)
uri = self.request.uri
method = self.request.method
try:
reboot = self.arguments.get('reboot', None)
shutdown = self.arguments.get('shutdown', None)
apps_refresh = self.arguments.get('apps_refresh', None)
operation = (
StoreOperation(
username, customer_name, uri, method
)
)
if reboot:
results = (
operation.reboot(tag_id)
)
elif shutdown:
results = (
operation.shutdown(tag_id)
)
elif apps_refresh:
results = (
operation.apps_refresh(tag_id)
)
else:
results = (
GenericResults(
username, uri, method
).incorrect_arguments()
)
self.set_status(results['http_status'])
self.set_header('Content-Type', 'application/json')
self.write(json.dumps(results, indent=4))
except Exception as e:
results = (
GenericResults(
username, uri, method
).something_broke(tag_id, '', e)
)
logger.exception(e)
self.set_status(results['http_status'])
self.set_header('Content-Type', 'application/json')
self.write(json.dumps(results, indent=4))
def tag_stats_by_os(username, customer_name,
uri, method, tag_id,
count=3, conn=None):
try:
stats = (
r
.table(TagsPerAgentCollection, use_outdated=True)
.get_all(tag_id, index=TagsPerAgentIndexes.TagId)
.pluck(TagsPerAgentKey.AgentId)
.eq_join(
lambda x: [
AVAILABLE,
x[AppsPerAgentKey.AgentId]
],
r.table(AppsPerAgentCollection),
index=AppsPerAgentIndexes.StatusAndAgentId
)
.zip()
.eq_join(AgentKey.AgentId, r.table(AgentsCollection))
.zip()
.pluck(APP_ID, AgentKey.OsString)
.distinct()
.group_by(AgentKey.OsString, r.count)
.order_by(r.desc('reduction'))
.limit(count)
.run(conn)
)
data = []
if stats:
data = app_stats_by_os(stats)
results = (
GenericResults(
username, uri, method
).information_retrieved(data, count)
)
except Exception as e:
results = (
GenericResults(
username, uri, method
).something_broke('tag widget stats', 'widget', e)
)
logger.exception(results)
return(results)
def get_all_agents(self, conn=None):
try:
count = (
r
.table(AgentsCollection)
.get_all(self.customer_name, index=AgentKey.CustomerName)
.count()
.run(conn)
)
data = list(
r
.table(AgentsCollection)
.get_all(self.customer_name, index=AgentKey.CustomerName)
.order_by(AgentKey.ComputerName)
.pluck(self.keys_to_pluck)
.order_by(self.sort(self.sort_key))
.skip(self.offset)
.limit(self.count)
.run(conn)
)
if data:
for agent in data:
agent[BASIC_RV_STATS] = (
get_all_app_stats_by_agentid(
self.username, self.customer_name,
self.uri, self.method, agent[AgentKey.AgentId]
)['data']
)
status = (
GenericResults(
self.username, self.uri, self.method
).information_retrieved(data, count)
)
logger.info(status['message'])
except Exception as e:
status = (
GenericResults(
self.username, self.uri, self.method
).something_broke('get_all_agents', 'agent', e)
)
return(status)
def filter_by_status(self, pkg_status, conn=None):
try:
agent = get_agent_info(self.agent_id)
if agent:
if pkg_status in ValidPackageStatuses:
base = (r.table(
self.CurrentAppsPerAgentCollection,
use_outdated=True).get_all(
[pkg_status, self.agent_id],
index=self.CurrentAppsPerAgentIndexes.
StatusAndAgentId).eq_join(
self.CurrentAppsPerAgentKey.AppId,
r.table(self.CurrentAppsCollection)).zip())
if self.show_hidden == NO:
base = base.filter({self.CurrentAppsKey.Hidden: NO})
packages = list(
base.map(self.map_hash).order_by(
self.sort(self.sort_key)).skip(self.offset).limit(
self.count).run(conn))
pkg_count = (base.count().run(conn))
return_status = (GenericResults(
self.username, self.uri,
self.method).information_retrieved(
packages, pkg_count))
else:
return_status = (PackageResults(
self.username, self.uri,
self.method).invalid_status(self.agent_id, pkg_status))
else:
return_status = (GenericResults(self.username, self.uri,
self.method).invalid_id(
self.agent_id, 'agents'))
except Exception as e:
return_status = (GenericResults(
self.username, self.uri,
self.method).something_broke("Package Searching went haywire",
'os_updates', e))
logger.exception(e)
return (return_status)
def get(self, agent_id):
username = self.get_current_user().encode('utf-8')
customer_name = get_current_customer_name(username)
query = self.get_argument('query', None)
count = int(self.get_argument('count', 30))
offset = int(self.get_argument('offset', 0))
status = self.get_argument('status', 'installed')
severity = self.get_argument('severity', None)
sort = self.get_argument('sort', 'asc')
sort_by = self.get_argument('sort_by', CustomAppsKey.Name)
hidden = self.get_argument('hidden', 'false')
if hidden == 'false':
hidden = NO
else:
hidden = YES
uri = self.request.uri
method = self.request.method
patches = (RetrieveCustomAppsByAgentId(username,
customer_name,
agent_id,
uri,
method,
count,
offset,
sort,
sort_by,
show_hidden=hidden))
if not query and not severity and status:
results = patches.filter_by_status(status)
elif not query and status and severity:
results = patches.filter_by_status_and_sev(status, severity)
elif severity and not query and not status:
results = patches.filter_by_severity(severity)
elif severity and status and query:
results = (patches.filter_by_status_and_query_by_name_and_sev(
query, status, severity))
elif status and query:
results = (patches.filter_by_status_and_query_by_name(
query, status))
elif severity and query:
results = (patches.filter_by_sev_and_query_by_name(
query, severity))
elif query and not severity and not status:
results = patches.query_by_name(query)
else:
results = (GenericResults(username, uri,
method).incorrect_arguments())
self.set_status(results['http_status'])
self.set_header('Content-Type', 'application/json')
self.write(json.dumps(results, indent=4))
def post(self, app_id):
username = self.get_current_user().encode('utf-8')
customer_name = get_current_customer_name(username)
uri = self.request.uri
method = self.request.method
try:
severity = self.arguments.get('severity').capitalize()
if severity in ValidRvSeverities:
sev_data = (
{
AppsKey.RvSeverity: severity
}
)
update_os_app(
app_id, sev_data
)
results = (
GenericResults(
username, uri, method
).object_updated(app_id, 'app severity', [sev_data])
)
self.set_status(results['http_status'])
self.set_header('Content-Type', 'application/json')
self.write(json.dumps(results, indent=4))
else:
results = (
PackageResults(
username, uri, method
).invalid_severity(severity)
)
self.set_status(results['http_status'])
self.set_header('Content-Type', 'application/json')
self.write(json.dumps(results, indent=4))
except Exception as e:
results = (
GenericResults(
username, uri, method
).something_broke(app_id, 'update_severity', e)
)
logger.exception(e)
self.set_status(results['http_status'])
self.set_header('Content-Type', 'application/json')
self.write(json.dumps(results, indent=4))
def get_by_app_id(self, stats=False, conn=None):
"""
"""
try:
pkg = list(
r
.table(self.CurrentAppsCollection, use_outdated=True)
.get_all(self.app_id, index=self.CurrentAppsIndexes.AppId)
.map(self.map_hash)
.run(conn)
)
if pkg:
pkg[0][self.CurrentAppsKey.FileData] = get_file_data(self.app_id)
if stats:
pkg[0]['agent_stats'] = (
get_all_stats_by_appid(
self.username, self.customer_name,
self.uri, self.method, self.app_id,
table=self.CurrentAppsPerAgentCollection
)['data']
)
status = (
GenericResults(
self.username, self.uri, self.method
).information_retrieved(pkg[0], 1)
)
else:
status = (
GenericResults(
self.username, self.uri, self.method
).invalid_id(self.app_id, 'package')
)
except Exception as e:
status = (
GenericResults(
self.username, self.uri, self.method
).something_broke(self.app_id, 'package', e)
)
logger.exception(e)
return(status)
def customer_stats_by_os(username, customer_name,
uri, method, count=3, conn=None):
try:
stats = (
r
.table(AppsPerAgentCollection, use_outdated=True)
.get_all(
[AVAILABLE, customer_name],
index=AppsPerAgentIndexes.StatusAndCustomer
)
.eq_join(AgentKey.AgentId, r.table(AgentsCollection))
.map(
{
AppsKey.AppId: r.row['left'][AppsKey.AppId],
AgentKey.OsString: r.row['right'][AgentKey.OsString]
}
)
.pluck(AppsKey.AppId, AgentKey.OsString)
.distinct()
.group_by(AgentKey.OsString, r.count)
.order_by(r.desc('reduction'))
.limit(count)
.run(conn)
)
data = []
if stats:
data = app_stats_by_os(stats)
results = (
GenericResults(
username, uri, method
).information_retrieved(data, count)
)
except Exception as e:
results = (
GenericResults(
username, uri, method
).something_broke('widget stats', 'widget', e)
)
logger.exception(results)
return(results)
def query_by_name(self, name, conn=None):
try:
tag = tag_exists(self.tag_id)
if tag:
base = (r.table(
TagsPerAgentCollection, use_outdated=True
).get_all(self.tag_id, index=TagsPerAgentIndexes.TagId).pluck(
TagsPerAgentKey.AgentId).eq_join(
self.CurrentAppsPerAgentIndexes.AgentId,
r.table(self.CurrentAppsPerAgentCollection),
index=self.CurrentAppsPerAgentIndexes.AgentId).eq_join(
lambda y: y['right'][self.CurrentAppsKey.AppId],
r.table(self.CurrentAppsCollection)).map(
self.map_hash))
if self.show_hidden == NO:
base = base.filter({self.CurrentAppsKey.Hidden: NO})
packages = list(
base.filter(lambda x: x[self.CurrentAppsKey.Name].match(
"(?i)" + name)).distinct().order_by(
self.sort(self.sort_key)).skip(self.offset).limit(
self.count).run(conn))
pkg_count = (
base.filter(lambda x: x[self.CurrentAppsKey.Name].match(
"(?i)" + name)).distinct().count().run(conn))
return_status = (GenericResults(
self.username, self.uri,
self.method).information_retrieved(packages, pkg_count))
else:
return_status = (GenericResults(self.username, self.uri,
self.method).invalid_id(
self.tag_id, 'tags'))
except Exception as e:
return_status = (GenericResults(
self.username, self.uri,
self.method).something_broke("Package Searching went haywire",
'os_updates', e))
logger.exception(e)
return (return_status)
def move_packages(username, customer_name, uri, method,
name=None, path=None, size=None, md5=None,
uuid=None, conn=None):
files_stored = list()
PKG_DIR = None
FILE_PATH = None
if name and uuid and path and size and md5:
PKG_DIR = TMP_DIR + uuid + '/'
FILE_PATH = PKG_DIR + name
if not os.path.exists(PKG_DIR):
try:
os.mkdir(PKG_DIR)
except Exception as e:
logger.error(e)
try:
shutil.move(path, FILE_PATH)
files_stored.append(
{
'uuid': uuid,
'name': name,
'size': int(size),
'md5': md5,
'file_path': FILE_PATH
}
)
results = (
GenericResults(
username, uri, method
).file_uploaded(name, files_stored)
)
except Exception as e:
results = (
GenericResults(
username, uri, method
).file_failed_to_upload(name, e)
)
logger.error(e)
return(results)
def get_all_stats_by_appid(username,
customer_name,
uri,
method,
app_id,
conn=None):
data = []
try:
apps = (r.table(CustomAppsPerAgentCollection).get_all(
[app_id, customer_name],
index=CustomAppsPerAgentIndexes.AppIdAndCustomer).group_by(
CustomAppsPerAgentKey.Status, r.count).run(conn))
if apps:
for i in apps:
new_data = i['reduction']
new_data = ({
CustomAppsPerAgentKey.Status:
i['group'][CustomAppsPerAgentKey.Status],
COUNT:
i['reduction'],
NAME:
i['group'][CustomAppsPerAgentKey.Status].capitalize()
})
data.append(new_data)
statuses = map(lambda x: x['status'], data)
difference = set(ValidPackageStatuses).difference(statuses)
if len(difference) > 0:
for status in difference:
status = {COUNT: 0, STATUS: status, NAME: status.capitalize()}
data.append(status)
results = (GenericResults(username, uri, method).information_retrieved(
data, len(data)))
logger.info(results)
except Exception as e:
results = (GenericResults(username, uri, method).something_broke(
'getting_pkg_stats', 'updates', e))
logger.info(results)
return (results)
def add_agent_to_install_operation(self,
agent_id,
operation_id,
applications,
conn=None):
try:
(r.table(OperationsPerAgentCollection).insert({
OperationPerAgentKey.AgentId:
agent_id,
OperationPerAgentKey.OperationId:
operation_id,
OperationPerAgentKey.CustomerName:
self.customer_name,
OperationPerAgentKey.Status:
PENDINGPICKUP,
OperationPerAgentKey.PickedUpTime:
r.epoch_time(0.0),
OperationPerAgentKey.CompletedTime:
r.epoch_time(0.0),
OperationPerAgentKey.AppsTotalCount:
len(applications),
OperationPerAgentKey.AppsPendingCount:
len(applications),
OperationPerAgentKey.AppsFailedCount:
self.INIT_COUNT,
OperationPerAgentKey.AppsCompletedCount:
self.INIT_COUNT,
OperationPerAgentKey.Errors:
None
}).run(conn))
for app in applications:
(r.table(OperationsPerAppCollection).insert({
OperationPerAppKey.AgentId:
agent_id,
OperationPerAppKey.OperationId:
operation_id,
OperationPerAppKey.CustomerName:
self.customer_name,
OperationPerAppKey.Results:
OperationCodes.ResultsPending,
OperationPerAppKey.ResultsReceivedTime:
r.epoch_time(0.0),
OperationPerAppKey.AppId:
app[OperationPerAppKey.AppId],
OperationPerAppKey.AppName:
app[OperationPerAppKey.AppName],
OperationPerAppKey.Errors:
None
}).run(conn))
except Exception as e:
results = (GenericResults(self.username, self.uri,
self.method).something_broke(
operation_id,
'add agent to install operation', e))
logger.exception(results)
def get_all(self, conn=None):
try:
count = (r.table(TagsCollection).get_all(
self.customer_name,
index=TagsIndexes.CustomerName).count().run(conn))
data = list(
r.table(TagsCollection).get_all(
self.customer_name,
index=TagsIndexes.CustomerName).order_by(
self.sort(self.sort_key)).skip(self.qoffset).limit(
self.qcount).run(conn))
if data:
for tag in xrange(len(data)):
data[tag][BASIC_RV_STATS] = (get_all_avail_stats_by_tagid(
self.username, self.customer_name, self.uri,
self.method, data[tag][TagsKey.TagId])['data'])
agents_in_tag = list(
r.table(TagsPerAgentCollection).get_all(
data[tag][TagsPerAgentKey.TagId],
index=TagsPerAgentIndexes.TagId).eq_join(
TagsPerAgentKey.AgentId,
r.table(AgentsCollection)).zip().pluck(
TagsPerAgentKey.AgentId,
AgentKey.ComputerName,
AgentKey.DisplayName).run(conn))
data[tag]['agents'] = agents_in_tag
status = (GenericResults(self.username, self.uri,
self.method).information_retrieved(
data, count))
logger.info(status['message'])
except Exception as e:
status = (GenericResults(self.username, self.uri,
self.method).something_broke(
'get_all_tags', 'tags', e))
logger.exception(status['message'])
return (status)
def get(self):
username = self.get_current_user()
customer_name = get_current_customer_name(username)
uri = self.request.uri
method = self.request.method
data = {"uuid": gen_uuid()}
results = (GenericResults(username, uri,
method).information_retrieved(data, 0))
self.set_header('Content-Type', 'application/json')
self.write(json.dumps(results, indent=4))
def create_tag(self, tag_name, prod_level='Production', conn=None):
tag_id = None
ninsert = {
TagsKey.TagName: tag_name,
TagsKey.CustomerName: self.customer_name,
TagsKey.ProductionLevel: prod_level,
}
try:
tag_exists = list(
r.table(TagsCollection).get_all(
[self.customer_name, tag_name],
index=TagsIndexes.TagNameAndCustomer).pluck(
TagsKey.TagId).run(conn))
if len(tag_exists) == 0:
inserted = (r.table(TagsCollection).insert(ninsert).run(conn))
if 'inserted' in inserted:
tag_id = inserted['generated_keys'][0]
data = {
TagsKey.TagId: tag_id,
TagsKey.TagName: tag_name,
}
status = (GenericResults(self.username, self.uri,
self.method).object_created(
tag_id, tag_name, data))
logger.info(status['message'])
else:
status = (GenericResults(self.username, self.uri,
self.method).object_exists(
tag_id, tag_name))
logger.warn(status['message'])
except Exception as e:
status = (GenericResults(self.username, self.uri,
self.method).something_broke(
tag_name, 'while creating a tag', e))
logger.exception(e)
return (status)
def put(self, app_id):
username = self.get_current_user().encode('utf-8')
customer_name = get_current_customer_name(username)
uri = self.request.uri
method = self.request.method
try:
agent_ids = self.arguments.get('agent_ids')
epoch_time = self.arguments.get('time', None)
label = self.arguments.get('label', None)
restart = self.arguments.get('restart', 'none')
cpu_throttle = self.arguments.get('cpu_throttle', 'normal')
net_throttle = self.arguments.get('net_throttle', 0)
if not epoch_time and not label and app_id:
operation = (StoreOperation(username, customer_name, uri,
method))
results = (operation.install_custom_apps([app_id],
cpu_throttle,
net_throttle,
restart,
agentids=agent_ids))
self.set_status(results['http_status'])
self.set_header('Content-Type', 'application/json')
self.write(json.dumps(results, indent=4))
elif epoch_time and label and agent_ids:
date_time = datetime.fromtimestamp(int(epoch_time))
sched = self.application.scheduler
job = ({
'cpu_throttle': cpu_throttle,
'net_throttle': net_throttle,
'pkg_type': 'custom_apps',
'restart': restart,
'app_ids': [app_id]
})
add_install_job = (schedule_once(sched,
customer_name,
username,
agent_ids=agent_ids,
operation='install',
name=label,
date=date_time,
uri=uri,
method=method,
job_extra=job))
result = add_install_job
self.set_header('Content-Type', 'application/json')
self.write(json.dumps(result))
except Exception as e:
results = (GenericResults(username, uri, method).something_broke(
app_id, 'install_custom_apps', e))
logger.exception(e)
self.set_status(results['http_status'])
self.set_header('Content-Type', 'application/json')
self.write(json.dumps(results, indent=4))
def get(self):
username = self.get_current_user().encode('utf-8')
uri = self.request.uri
method = self.request.method
try:
data = get_production_levels()
results = (GenericResults(username, uri,
method).information_retrieved(
data, len(data)))
self.set_status(results['http_status'])
self.set_header('Content-Type', 'application/json')
self.write(json.dumps(results, indent=4))
except Exception as e:
results = (GenericResults(username, uri, method).something_broke(
'Get OS Codes', 'Agent', e))
logger.exception(e)
self.set_status(results['http_status'])
self.set_header('Content-Type', 'application/json')
self.write(json.dumps(results, indent=4))
def get_all_mouseys(username, uri, method, customer_name=None):
conn = db_connect()
try:
if not customer_name:
data = list(r.table(RelayServersCollection).run(conn))
else:
data = list(
r.table(RelayServersCollection).filter(lambda x: x[
RelayServers.Customers].contains(customer_name)).run(conn))
status = (GenericResults(username, uri, method).information_retrieved(
data, len(data)))
except Exception as e:
status = (GenericResults(username, uri, method).something_broke(
'retreiving Relay Servers', 'RelayServers', e))
conn.close()
return (status)
def filter_by_status_and_query_by_name(self, name, pkg_status, conn=None):
try:
if pkg_status in ValidPackageStatuses:
base = (r.table(self.CurrentAppsPerAgentCollection).get_all(
pkg_status,
index=self.CurrentAppsPerAgentIndexes.Status).eq_join(
self.CurrentAppsPerAgentKey.AppId,
r.table(self.CurrentAppsCollection)).map(
self.joined_map_hash))
if self.show_hidden == NO:
base = base.filter({self.CurrentAppsKey.Hidden: NO})
packages = list(
base.filter(lambda x: x[self.CurrentAppsKey.Name].match(
"(?i)" + name)).distinct().order_by(
self.sort(self.sort_key)).skip(self.offset).limit(
self.count).run(conn))
pkg_count = (base.filter(lambda x: x[
self.CurrentAppsKey.Name].match("(?i)" + name)).pluck(
self.CurrentAppsKey.AppId).count().run(conn))
return_status = (GenericResults(
self.username, self.uri,
self.method).information_retrieved(packages, pkg_count))
else:
return_status = (PackageResults(
self.username, self.uri,
self.method).invalid_global_status(pkg_status))
except Exception as e:
return_status = (GenericResults(
self.username, self.uri,
self.method).something_broke("Package Searching went haywire",
'os_updates', e))
logger.exception(e)
return (return_status)
def get_tag(self, tag_id, conn=None):
try:
tag_info = (r.table(TagsCollection).get(tag_id).run(conn))
if tag_info:
agents_in_tag = list(
r.table(TagsPerAgentCollection).get_all(
tag_id, index=TagsPerAgentIndexes.TagId).eq_join(
TagsPerAgentKey.AgentId,
r.table(AgentsCollection)).zip().pluck(
TagsPerAgentKey.AgentId, AgentKey.ComputerName,
AgentKey.DisplayName).run(conn))
tag_info[BASIC_RV_STATS] = (get_all_app_stats_by_tagid(
self.username, self.customer_name, self.uri, self.method,
tag_id)['data'])
tag_info['agents'] = agents_in_tag
status = (GenericResults(self.username, self.uri,
self.method).information_retrieved(
tag_info, 1))
logger.info(status['message'])
else:
status = (GenericResults(self.username, self.uri,
self.method).invalid_id(
tag_id, 'tag_id'))
logger.info(status['message'])
except Exception as e:
status = (GenericResults(self.username, self.uri,
self.method).something_broke(
tag_id, 'tags', e))
logger.exception(status['message'])
return (status)
def get_severity_bar_chart_stats_for_customer(username, customer_name,
uri, method, conn=None):
try:
sevs = (
r
.table(AppsPerAgentCollection, use_outdated=True)
.get_all(
[AVAILABLE, customer_name],
index=AppsPerAgentIndexes.StatusAndCustomer
)
.pluck(AppsKey.AppId)
.distinct()
.eq_join(AppsKey.AppId, r.table(AppsCollection))
.map(
{
AppsKey.AppId: r.row['right'][AppsKey.AppId],
AppsKey.RvSeverity: r.row['right'][AppsKey.RvSeverity]
}
)
.group_by(AppsKey.RvSeverity, r.count)
.order_by(r.asc('group'))
.run(conn)
)
data = app_stats_by_severity(sevs)
results = (
GenericResults(
username, uri, method
).information_retrieved(data, len(ValidRvSeverities))
)
except Exception as e:
results = (
GenericResults(
username, uri, method
).something_broke('widget severity stats', 'widget', e)
)
logger.exception(results)
return(results)
def post(self):
username = self.get_current_user()
customer_name = get_current_customer_name(username)
uri = self.request.uri
method = self.request.method
try:
result = None
sched = self.application.scheduler
operation = self.arguments.get('operation', None)
pkg_type = self.arguments.get('pkg_type', None)
jobname = self.arguments.get('jobname')
severity = self.arguments.get('severity')
node_ids = self.arguments.get('nodes', None)
tag_ids = self.arguments.get('tags', None)
all_agents = self.arguments.get('all_agents', False)
all_tags = self.arguments.get('all_tags', False)
every = self.arguments.get('every')
custom = self.arguments.get('custom')
epoch_time = self.arguments.get('epoch_time')
datetime = datetime.fromtimestamp(epoch_time)
results = (add_custom_recurrent(
sched,
agent_ids=node_ids,
all_agents=all_agents,
all_tags=all_tags,
tag_ids=tag_ids,
severity=severity,
pkg_type=pkg_type,
operation=operation,
name=jobname,
every=every,
custom=custom,
frequency=frequency,
date=datetime,
customer_name=customer_name,
username=username,
uri=uri,
method=method,
))
self.set_status(results['http_status'])
self.set_header('Content-Type', 'application/json')
self.write(json.dumps(results, indent=4))
except Exception as e:
results = (GenericResults(username, uri, method).something_broke(
'add custom recurrent schedule', '', e))
logger.exception(e)
self.set_status(results['http_status'])
self.set_header('Content-Type', 'application/json')
self.write(json.dumps(results, indent=4))
def get_tags(self, uri=None, method=None, conn=None):
try:
tags = get_tags_by_agent_id(agent_id=self.agent_id)
if tags:
for i in range(len(tags)):
name = tags[i].pop('tag_name')
tags[i]['name'] = name
tag_id = tags[i].pop('tag_id')
tags[i]['id'] = tag_id
status = (GenericResults(self.username, uri,
method).information_retrieved(tags, 1))
logger.info(status['message'])
except Exception as e:
status = (GenericResults(self.username, uri,
method).something_broke(
self.agent_id, 'agent', e))
logger.error(status['message'])
return (status)