def create(self):
p = ['_hostname', 'logical',
'management_ip', 'type',
'serial_number', 'part_number',
'mac_address', 'parent']
try:
data = json.loads(request.params.items()[0][0])['data']
except:
return {'success': False}
network_device = NetworkDevice()
count = 0
for param in p:
if param in data:
if param == 'parent':
if not data[param]:
network_device.parent = None
continue
else:
network_device.parent = Session.query(
NetworkDevice).filter(
NetworkDevice.id == int(
data[param])).first()
continue
setattr(network_device,
param, data[param])
count += 1
if count:
Session.add(network_device)
Session.commit()
return {'success': True}
return {'success': False}
def rrd_file(self, id):
response.content_type = 'text/plain'
if id.isdigit():
graph_data = Session.query(Graph)\
.filter(Graph.id == int(id)).first()
else:
graph_data = Session.query(Graph)\
.filter(Graph.name == id).first()
c.graph = graph_data.filename[1:]
hostnames = [n.hostname for n in graph_data.get_hosts()]
c.datasource = generate_rrd_sequence_map(
hostnames, graph_data.get_rrds())
c.title = graph_data.name
if len(c.datasource) == 2:
c.colors = ['Lime', 'Red']
c.brmod = 2
else:
c.colors = ['Lime', 'Teal', 'Maroon']
c.brmod = 3
return render('/graphs/graph.mako')
def destroy_comment(self, id, commentid):
comment = Session.query(NodeComment)\
.filter(NodeComment.id == commentid).first()
Session.delete(comment)
Session.commit()
return redirect(url(
controller='nodes', action='show', id=id))
def update_groups():
for node in Session.query(Node)\
.filter(Node.model_name != None).all():
# create the group if it doesn't exist
group = Session.query(Group)\
.filter(Group.name == generate_groupname(node.model_name)).first()
if not group:
group = create_group(generate_groupname(node.model_name))
# add that computer to the group
if not group in node.groups:
node.groups.append(group)
Session.add(node)
Session.commit()
# Remove rack groups that a node is no longer a part of
# found_groups = [g for g in node.groups\
# if re.search(regex, g.name) and g != group]
# for bad_group in found_groups:
# node.groups.remove(bad_group)
Session.add(node)
Session.commit()
def update_groups():
regex = '^r\d{3}$'
for node in Session.query(Node).all():
rack_name = 'r%s' % node.rack
# create the group if it doesn't exist
group = Session.query(Group)\
.filter(Group.name == rack_name).first()
if not group:
group = create_group(rack_name)
# add that computer to the group
node.groups.append(group)
Session.add(node)
Session.commit()
# Remove rack groups that a node is no longer a part of
found_groups = [g for g in node.groups\
if re.search(regex, g.name) and g != group]
for bad_group in found_groups:
node.groups.remove(bad_group)
Session.add(node)
Session.commit()
def update_groups():
regex = '^r\d{3}$'
for node in Session.query(Node).all():
rack_name = 'r%s' % node.rack
# create the group if it doesn't exist
group = Session.query(Group)\
.filter(Group.name == rack_name).first()
if not group:
group = create_group(rack_name)
# add that computer to the group
node.groups.append(group)
Session.add(node)
Session.commit()
# Remove rack groups that a node is no longer a part of
found_groups = [g for g in node.groups\
if re.search(regex, g.name) and g != group]
for bad_group in found_groups:
node.groups.remove(bad_group)
Session.add(node)
Session.commit()
def create(self):
graph_title = ''
rrds = []
group = None
for k,v in request.params.iteritems():
if k == 'rrd_type':
rrds.append(v)
elif k == 'graph_title':
graph_title = v
elif k == 'group_select':
group = Session.query(Group)\
.filter(Group.name == v).first()
else:
pass
graph = Graph()
graph.name = graph_title
graph.filename = 'g%s' % time()
graph.rrd_types = ','.join(rrds)
graph.group = group
if not graph.name or not graph.rrd_types or not graph.group:
session['flash'] = "Failed to created graph"
session.save()
return redirect(url(
controller='graphs', action='index'))
Session.add(graph)
Session.commit()
session['flash'] = "Successfully created %s" % graph.name
session.save()
grab_new_drraw(graph)
generate_index()
return redirect(url(
controller='graphs', action='index'))
def create(self):
p = [
'_hostname', 'logical', 'management_ip', 'type', 'serial_number',
'part_number', 'mac_address', 'parent'
]
try:
data = json.loads(request.params.items()[0][0])['data']
except:
return {'success': False}
network_device = NetworkDevice()
count = 0
for param in p:
if param in data:
if param == 'parent':
if not data[param]:
network_device.parent = None
continue
else:
network_device.parent = Session.query(
NetworkDevice).filter(
NetworkDevice.id == int(data[param])).first()
continue
setattr(network_device, param, data[param])
count += 1
if count:
Session.add(network_device)
Session.commit()
return {'success': True}
return {'success': False}
def enable_host_svc(self):
id_list = []
hostname_list = []
for k,v in request.params.iteritems():
if k == 'ids[]':
id_list.append(int(v))
if k == 'hostname':
hostname_list.append(v)
if id_list:
nodes = Session.query(Node.hostname).filter(
Node.id.in_(id_list)).all()
for node in nodes:
enable_host_service_notifications(node[0])
session['flash'] = 'Enabled host services successfully'
session.save()
return str({'success': True})
elif hostname_list:
nodes = Session.query(Node.hostname).filter(
Node.hostname.in_(hostname_list)).all()
for node in nodes:
enable_host_service_notifications(node[0])
session['flash'] = 'Enabled host services successfully'
session.save()
return str({'success': True})
else:
session['flash'] = 'Enable host services failed'
session.save()
return str({'success': False})
def enablehost(self, format=None):
valid = False
response.content_type = "application/json"
ids = None
ips = None
data = {}
ports = []
if 'ids[]' in request.params:
ids = [v for k, v in request.params.items() if 'ids[]' in k]
elif 'ips[]' in request.params:
ips = [v for k, v in request.params.items() if 'ips[]' in k]
if 'pool' in request.params:
pool = request.params['pool']
if 'ports[]' in request.params:
ports = [v for k,v in request.params.items()\
if 'ports[]' in k]
if ips or ids:
valid = True
if not valid:
session['flash'] = 'No ids were sent'
session.save()
if format == 'json':
return '{"success": false}'
else:
return redirect(url(controller='loadbalancer', action='index'))
lb = LoadBalancer(ip='your_lb_ip')
if ids:
data['hosts'] = [
Session.query(Node.hostname)\
.filter(Node.id == id)\
.first()[0] for id in ids ]
members = [
':'.join([Session.query(Node.primary_ip)\
.filter(Node.id == id)\
.first()[0], ports[i]])\
for i,id in enumerate(ids)]
elif ips:
data['hosts'] = [
Session.query(Node.hostname)\
.filter(or_(Node.primary_ip == ip,
Node.secondary_ip == ip))\
.first()[0] for ip in ips ]
members = [':'.join([ip, ports[i]])\
for i,ip in enumerate(ips)]
lb.enable_members(pool, members)
data['pool'] = pool
data['type'] = 'enable'
ae = ActivityEngine(Session, session['active_user']['user_id'])
status = ae.update('loadbalancer', None, data)
session['flash'] = status
session.save()
if format == 'json':
return '{"success": true}'
else:
return redirect(url(controller='loadbalancer', action='index'))
def destroy_studio(self, id):
studio = Session.query(Studio).filter(Studio.id == id).first()
Session.delete(studio)
Session.commit()
session['flash'] = "Success"
session.save()
return {'success': True}
def destroy_game(self, id):
game = Session.query(Game).filter(Game.id == id).first()
Session.delete(game)
Session.commit()
session['flash'] = "Success"
session.save()
return {'success': True}
def destroy_studio(self, id):
studio = Session.query(Studio).filter(Studio.id == id).first()
Session.delete(studio)
Session.commit()
session['flash'] = "Success"
session.save()
return {'success': True}
def destroy_game(self, id):
game = Session.query(Game).filter(Game.id == id).first()
Session.delete(game)
Session.commit()
session['flash'] = "Success"
session.save()
return {'success': True}
def disablehost(self, format=None):
valid = False
response.content_type = "application/json"
ids = None
ips = None
data = {}
if 'ids[]' in request.params:
ids = [v for k,v in request.params.items() if 'ids[]' in k]
elif 'ips[]' in request.params:
ips = [v for k,v in reuqest.params.items() if 'ips[]' in k]
if 'pool' in request.params:
pool = request.params['pool']
if 'ports[]' in request.params:
ports = [v for k,v in request.params.items()\
if 'ports[]' in k]
if ids or ips:
valid = True
if not valid:
session['flash'] = 'No ids were sent'
session.save()
if format == 'json':
return '{"success": false}'
else:
return redirect(url(
controller='loadbalancer', action='index'))
lb = LoadBalancer(ip='your_lb_ip')
if ids:
data['hosts'] = [ q[0] for q in\
Session.query(Node.hostname)\
.filter(Node.id.in_(ids)).all() ]
members = [
':'.join([Session.query(Node.primary_ip)\
.filter(Node.id == id)\
.first()[0], ports[i]])\
for i,id in enumerate(ids)]
elif ips:
data['hosts'] = [q[0] for q in Session.query(Node.hostname)\
.filter(or_(Node.primary_ip.in_(ips),
Node.secondary_ip.in_(ips)))\
.all() ]
members = [
':'.join([ip, ports[i]]) for i,ip in enumerate(ips)]
lb.disable_members(pool, members)
data['type'] = 'disable'
data['pool'] = pool
ae = ActivityEngine(
Session, session['active_user']['user_id'])
status = ae.update('loadbalancer', None, data)
session['flash'] = status
if format == 'json':
return '{"success": true}'
else:
return redirect(url(
controller='loadbalancer', action='index'))
def __call__(self, environ, start_response):
"""Invoke the Controller"""
# WSGIController.__call__ dispatches to the Controller method
# the request is routed to. This routing information is
# available in environ['pylons.routes_dict']
try:
return WSGIController.__call__(self, environ, start_response)
finally:
Session.remove()
def destroy(self, id, backup_id):
dbbackup = Session.query(NodeDatabaseBackup)\
.filter(NodeDatabaseBackup.id == backup_id).first()
Session.delete(dbbackup)
Session.commit()
session['flash'] = "Successfully destroyed dbbackup"
session.save()
return redirect(url(controller='dbbackups', action='index', id=id))
def __call__(self, environ, start_response):
"""Invoke the Controller"""
# WSGIController.__call__ dispatches to the Controller method
# the request is routed to. This routing information is
# available in environ['pylons.routes_dict']
try:
return WSGIController.__call__(self, environ, start_response)
finally:
Session.remove()
def destroy(self, id, backup_id):
dbbackup = Session.query(NodeDatabaseBackup)\
.filter(NodeDatabaseBackup.id == backup_id).first()
Session.delete(dbbackup)
Session.commit()
session['flash'] = "Successfully destroyed dbbackup"
session.save()
return redirect(url(controller='dbbackups', action='index', id=id))
def update_comment(self, id, commentid):
comment = Session.query(NodeComment)\
.filter(NodeComment.id == commentid).first()
if 'description' in request.params:
comment.description = request.params['description']
Session.add(comment)
Session.commit()
c.node_id = id
return redirect(url(controller='nodes', action='show', id=id))
def show(self, id, format='html'):
id = unicode(id)
if id.isdigit():
c.group = Session.query(Group).filter(Group.id == int(id)).first()
else:
c.group = Session.query(Group).filter(Group.name == id).first()
c.group_list = [g[0] for g in Session.query(Group.name)]
c.title = 'Nodetraq - Group - %s' % c.group.name
c.selected_page = 'groups'
c.subpage = 'show'
c.header = 'Groups : %s' % c.group.name
c.page = int(request.params['page'])\
if 'page' in request.params else 1
c.current_page_count = (c.page - 1) * 25
c.node_count = len(c.group.nodes)
c.filters = [{'name': 'group', 'label': 'Group', 'type': 'text'}]
c.link_append = None
is_sorted = False
if 'sort' in request.params:
sortkey, sortorder = request.params['sort'].split(':')
is_sorted = True
c.sort_order = sortorder
else:
c.sort_order = None
if is_sorted:
if sortorder == 'asc':
c.nodes = c.group.nodes\
[c.current_page_count:c.current_page_count+25]
c.nodes = sorted(c.nodes,
key=attrgetter(sortkey),
reverse=False)
else:
c.nodes = c.group.nodes\
[c.current_page_count:c.current_page_count+25]
c.nodes = sorted(c.nodes,
key=attrgetter(sortkey),
reverse=True)
else:
c.nodes = c.group.nodes[c.current_page_count:c.current_page_count +
25]
c.all_groups, c.tag_sizes = self.get_tag_info()
c.total_pages = (c.node_count + 25 - 1) / 25
c.request_url = request.environ.get('PATH_INFO')
if request.environ.get('QUERY_STRING'):
c.request_url += '?' + request.environ['QUERY_STRING']
if format == 'html':
return render('/nodes/list.mako')
elif format == 'json':
return c.group.__json__()
elif format == 'xml':
return c.group.__xml__()
def update_comment(self, id, commentid):
comment = Session.query(NodeComment)\
.filter(NodeComment.id == commentid).first()
if 'description' in request.params:
comment.description = request.params['description']
Session.add(comment)
Session.commit()
c.node_id = id
return redirect(url(
controller='nodes', action='show', id=id))
def update_groups():
for node in Session.query(Node)\
.filter(Node.hostname.startswith('sv')).all():
# create the group if it doesn't exist
group = Session.query(Group)\
.filter(Group.name == 'idle').first()
if not group:
group = create_group('idle')
# add that computer to the group
node.groups = []
node.groups.append(group)
Session.add(node)
Session.commit()
for group in Session.query(Group)\
.filter(Group.name == 'idle')\
.all():
if group:
for node in group.nodes:
if not node.hostname.startswith('sv'):
group.nodes.remove(node)
Session.commit()
def update_vms():
xen_group = Session.query(Group)\
.filter(Group.name == 'xen-dom0').first()
vm_group = Session.query(Group)\
.filter(Group.name == 'vm').first()
vm_hosts = xen_group.nodes
update_xen_nodes(get_xen_list(xen_group))
for node in Session.query(Node).all():
if node.xen_instance:
if not vm_group in node.groups:
node.groups.append(vm_group)
for host in vm_hosts:
vm_instances = Session.query(Node)\
.filter(and_(Node.rack == host.rack,
Node.rack_u == host.rack_u,
)).all()
vm_instances = [v for v in vm_instances if v not in vm_hosts]
for node in vm_instances:
n = Session.query(Node).filter(
Node.hostname == node.hostname).first()
n.service_tag = host.service_tag
n.drac_ip = None
Session.add(n)
Session.commit()
def update_vms():
xen_group = Session.query(Group)\
.filter(Group.name == 'xen-dom0').first()
vm_group = Session.query(Group)\
.filter(Group.name == 'vm').first()
vm_hosts = xen_group.nodes
update_xen_nodes(get_xen_list(xen_group))
for node in Session.query(Node).all():
if node.xen_instance:
if not vm_group in node.groups:
node.groups.append(vm_group)
for host in vm_hosts:
vm_instances = Session.query(Node)\
.filter(and_(Node.rack == host.rack,
Node.rack_u == host.rack_u,
)).all()
vm_instances = [v for v in vm_instances if v not in vm_hosts]
for node in vm_instances:
n = Session.query(Node).filter(
Node.hostname == node.hostname).first()
n.service_tag = host.service_tag
n.drac_ip = None
Session.add(n)
Session.commit()
def edit(self, id):
id = unicode(id)
if id.isdigit():
c.group = Session.query(Group).filter(Group.id == id).first()
else:
c.group = Session.query(Group).filter(Group.name == id).first()
c.title = 'Nodetraq - Edit group %s' % c.group.name
c.selected_page = 'groups'
c.subpage = 'edit'
return render('/groups/edit.mako')
def edit(self, id):
id = unicode(id)
if id.isdigit():
c.group = Session.query(Group).filter(Group.id == id).first()
else:
c.group = Session.query(Group).filter(Group.name == id).first()
c.title = 'Nodetraq - Edit group %s' % c.group.name
c.selected_page = 'groups'
c.subpage = 'edit'
return render('/groups/edit.mako')
def new_studio(self):
params = json.loads(request.params.iteritems().next()[0])
studio = Studio()
studio.name = params['name']
if 'description' in params:
studio.description = params['description']
Session.add(studio)
Session.commit()
session['flash'] = "Success"
session.save()
return {'success': True}
def update_studio(self, id):
studio = Session.query(Studio).filter(Studio.id == id).first()
studio.name = request.params['name']
if 'description' in request.params:
studio.description = request.params['description']
Session.add(studio)
Session.commit()
session['flash'] = "Success"
session.save()
return {'success': True}
def update_studio(self, id):
studio = Session.query(Studio).filter(Studio.id == id).first()
studio.name = request.params['name']
if 'description' in request.params:
studio.description = request.params['description']
Session.add(studio)
Session.commit()
session['flash'] = "Success"
session.save()
return {'success': True}
def new_studio(self):
params = json.loads(request.params.iteritems().next()[0])
studio = Studio()
studio.name = params['name']
if 'description' in params:
studio.description = params['description']
Session.add(studio)
Session.commit()
session['flash'] = "Success"
session.save()
return {'success': True}
def show(self, id, format='html'):
id = unicode(id)
if id.isdigit():
c.group = Session.query(Group).filter(Group.id == int(id)).first()
else:
c.group = Session.query(Group).filter(Group.name == id).first()
c.group_list = [g[0] for g in Session.query(Group.name)]
c.title = 'Nodetraq - Group - %s' % c.group.name
c.selected_page = 'groups'
c.subpage = 'show'
c.header = 'Groups : %s' % c.group.name
c.page = int(request.params['page'])\
if 'page' in request.params else 1
c.current_page_count = (c.page-1) * 25
c.node_count = len(c.group.nodes)
c.filters = [
{ 'name': 'group', 'label': 'Group', 'type': 'text' }
]
c.link_append = None
is_sorted = False
if 'sort' in request.params:
sortkey, sortorder = request.params['sort'].split(':')
is_sorted = True
c.sort_order = sortorder
else:
c.sort_order = None
if is_sorted:
if sortorder == 'asc':
c.nodes = c.group.nodes\
[c.current_page_count:c.current_page_count+25]
c.nodes = sorted(c.nodes, key=attrgetter(sortkey), reverse=False)
else:
c.nodes = c.group.nodes\
[c.current_page_count:c.current_page_count+25]
c.nodes = sorted(c.nodes, key=attrgetter(sortkey), reverse=True)
else:
c.nodes = c.group.nodes[c.current_page_count:c.current_page_count+25]
c.all_groups, c.tag_sizes = self.get_tag_info()
c.total_pages = (c.node_count+25-1)/25
c.request_url = request.environ.get('PATH_INFO')
if request.environ.get('QUERY_STRING'):
c.request_url += '?' + request.environ['QUERY_STRING']
if format == 'html':
return render('/nodes/list.mako')
elif format == 'json':
return c.group.__json__()
elif format == 'xml':
return c.group.__xml__()
def edit(self, id):
c.title = 'Nodetraq - New Network Device'
c.selected_page = 'network'
c.subpage = 'edit'
c.network_device = Session.query(NetworkDevice).filter(
NetworkDevice.id == id).first()
c.parents = [('','')]
for parent in [
(d.id, d.hostname) for d in \
Session.query(NetworkDevice).filter(
NetworkDevice.logical == False).all()]:
c.parents.append(parent)
return render('/network/edit.mako')
def create_comment(self):
content = None
node = None
if 'comment' in request.params:
content = request.params['comment']
if not content:
return redirect(url(controller='nodes', action='show', id=id))
if 'node' in request.params:
id = request.params['node']
node = Session.query(Node)\
.filter(Node.id == id).first()
if node:
if not node.comments:
node.comments = []
comment = NodeComment()
comment.node_id = id
user = Session.query(User).filter(
User.id == session['active_user']['user_id']).first()
comment.user_id = session['active_user']['user_id']
comment.description = content
node.comments.append(comment)
Session.add(node)
Session.add(comment)
Session.commit()
return redirect(url(controller='nodes', action='show', id=id))
def grab_controller(cls, controller_name):
if not controller_name:
return None
controller = Session.query(cls).filter(cls.name == controller_name).first()
if controller:
return controller.id
else:
c = cls()
c.name = controller_name
Session.add(c)
Session.commit()
return c.id
def create_comment(self):
content = None
node = None
if 'comment' in request.params:
content = request.params['comment']
if not content:
return redirect(
url(controller='nodes', action='show', id=id))
if 'node' in request.params:
id = request.params['node']
node = Session.query(Node)\
.filter(Node.id == id).first()
if node:
if not node.comments:
node.comments = []
comment = NodeComment()
comment.node_id = id
user = Session.query(User).filter(
User.id == session['active_user']['user_id']).first()
comment.user_id = session['active_user']['user_id']
comment.description = content
node.comments.append(comment)
Session.add(node)
Session.add(comment)
Session.commit()
return redirect(url(controller='nodes', action='show', id=id))
def edit(self, id):
c.title = 'Nodetraq - New Network Device'
c.selected_page = 'network'
c.subpage = 'edit'
c.network_device = Session.query(NetworkDevice).filter(
NetworkDevice.id == id).first()
c.parents = [('', '')]
for parent in [
(d.id, d.hostname) for d in \
Session.query(NetworkDevice).filter(
NetworkDevice.logical == False).all()]:
c.parents.append(parent)
return render('/network/edit.mako')
def edit(self, id, backup_id):
c.title = 'Nodetraq - dbbackups'
c.selected_page = 'nodes'
c.subpage = 'dbbackups'
c.header = 'Nodes : Db backups'
c.node_id = id
c.node_backup = Session.query(NodeDatabaseBackup).filter(
NodeDatabaseBackup.id == backup_id).first()
c.backup_id = backup_id
c.backup_type_list = [(t.id, t.name) for t in
Session.query(BackupType).all()]
return render('/nodes/dbbackups/edit.mako')
def edit(self, id, backup_id):
c.title = 'Nodetraq - dbbackups'
c.selected_page = 'nodes'
c.subpage = 'dbbackups'
c.header = 'Nodes : Db backups'
c.node_id = id
c.node_backup = Session.query(NodeDatabaseBackup).filter(
NodeDatabaseBackup.id == backup_id).first()
c.backup_id = backup_id
c.backup_type_list = [(t.id, t.name)
for t in Session.query(BackupType).all()]
return render('/nodes/dbbackups/edit.mako')
def create(self, id):
node = Session.query(Node).filter(Node.id == id).first()
if not node.vhosts:
node.vhosts = []
vhost = NodeVhost()
vhost.node = node
vhost.hostname = request.params['hostname']
vhost.comment = request.params['comment']
node.vhosts.append(vhost)
Session.add(node)
Session.commit()
return redirect(url(controller='vhosts', action='index', id=id))
def new_game(self):
game = Game()
params = json.loads(request.params.iteritems().next()[0])
game.name = params['name']
if 'description' in params:
game.description = params['description']
if 'studio' in params:
game.studio = Session.query(Studio).filter(
Studio.id == params['studio']).first()
Session.add(game)
Session.commit()
session['flash'] = "Success"
session.save()
return {'success': True}
def create(self, id):
node = Session.query(Node).filter(Node.id == id).first()
if not node.vhosts:
node.vhosts = []
vhost = NodeVhost()
vhost.node = node
vhost.hostname = request.params['hostname']
vhost.comment = request.params['comment']
node.vhosts.append(vhost)
Session.add(node)
Session.commit()
return redirect(url(controller='vhosts', action='index', id=id))
def new_game(self):
game = Game()
params = json.loads(request.params.iteritems().next()[0])
game.name = params['name']
if 'description' in params:
game.description = params['description']
if 'studio' in params:
game.studio = Session.query(Studio).filter(
Studio.id == params['studio']).first()
Session.add(game)
Session.commit()
session['flash'] = "Success"
session.save()
return {'success': True}
def getid(self):
response.content_type = "text/plain"
for key, value in request.params.iteritems():
return str(Session.query(Node)\
.filter(getattr(Node, key) == \
value)\
.first().id)
def updatebyname(self, name, format='html'):
id = Session.query(Node).filter(Node.hostname == name).first()
if id:
id = id.id
else:
return 'Host: %s is not in nodetraq' % name
ignore = ['Submit', 'username']
params = [
(p, request.params[p]) for p in request.params \
if p not in ignore]
data = {}
for key, value in params:
if value:
if key == 'cpu_speed' and not value:
continue
data[key] = value
activity_engine = ActivityEngine(Session,
session['active_user']['user_id'])
status = activity_engine.update('node', id, data)
if format == 'html':
session['flash'] = status
session.save()
return redirect(url(controller='nodes', action='show', id=id))
elif format == 'json':
request.content_type = 'application/json'
return status
def show_game(self, id):
c.game = Session.query(Game).filter(Game.id == id).first()
c.title = "Nodetraq -- Game: %s" % c.game.name
c.header = c.game.name
c.selected_page = "nodes"
c.subpage = "show_game"
c.groups = [
{'name': 'PE-1950', 'nodes': []},
{'name': 'PE-2950', 'nodes': []},
{'name': 'PE-R410', 'nodes': []},
{'name': 'PE-R610', 'nodes': []},
{'name': 'PE-R710', 'nodes': []},
{'name': 'vm', 'nodes': []},
{'name': 'unknown', 'nodes': []}
]
group_list = lambda groups: [g.name for g in groups]
for node in c.game.nodes:
grouped = False
for group in c.groups:
if group['name'] in group_list(node.groups):
group['nodes'].append(node)
grouped = True
if not grouped:
c.groups[len(c.groups)-1]['nodes'].append(node)
return render('/nodes/games/show.mako')
def show_dbbackups(self):
c.title = "Nodetraq -- Show Database Backups"
c.selected_page = "nodes"
c.subpage = "database"
sort = None
c.dbbackups = Session.query(NodeDatabaseBackup).all()
if not 'sort' in request.params:
sort = 'server'
else:
sort = request.params['sort']
if sort == 'server':
c.dbbackups = sorted(c.dbbackups,
key=lambda backup: backup.server.hostname)
elif sort == 'storage':
c.dbbackups = sorted(c.dbbackups,
key=lambda backup: backup.storage.hostname)
elif sort == 'directory':
c.dbbackups = sorted(c.dbbackups,
key=lambda backup: backup.directory)
elif sort == 'enabled':
c.dbbackups = sorted(c.dbbackups,
key=lambda backup: backup.enabled)
c.sort = sort
return render('/nodes/show_dbbackups.mako')
def clear_flags(self):
response.content_type = 'application/json'
ids = None
if 'ids[]' in request.params:
ids = [v for k,v in request.params.items()\
if 'ids[]' in k]
for node_id in ids:
node = Session.query(Node).filter(Node.id == node_id).first()
for count in xrange(len(node.flags)):
del (node.flags[0])
Session.add(node)
Session.commit()
session['flash'] = 'Flags were cleared'
session.save()
return '{"success": true}'
def show_dbbackups(self):
c.title = "Nodetraq -- Show Database Backups"
c.selected_page = "nodes"
c.subpage = "database"
sort = None
c.dbbackups = Session.query(NodeDatabaseBackup).all()
if not 'sort' in request.params:
sort = 'server'
else:
sort = request.params['sort']
if sort == 'server':
c.dbbackups = sorted(
c.dbbackups, key=lambda backup: backup.server.hostname)
elif sort == 'storage':
c.dbbackups = sorted(
c.dbbackups, key=lambda backup: backup.storage.hostname)
elif sort == 'directory':
c.dbbackups = sorted(
c.dbbackups, key=lambda backup: backup.directory)
elif sort == 'enabled':
c.dbbackups = sorted(
c.dbbackups, key=lambda backup: backup.enabled)
c.sort = sort
return render('/nodes/show_dbbackups.mako')
def edit_studio(self, id):
c.studio = Session.query(Studio).filter(Studio.id == id).first()
c.title = "Nodetraq -- Edit Studio"
c.header = c.studio.name
c.selected_page = "nodes"
c.subpage = "edit_studio"
return render('/nodes/studios/edit.mako')
def edit_studio(self, id):
c.studio = Session.query(Studio).filter(Studio.id == id).first()
c.title = "Nodetraq -- Edit Studio"
c.header = c.studio.name
c.selected_page = "nodes"
c.subpage = "edit_studio"
return render('/nodes/studios/edit.mako')
def export_node(json_list):
#for node in json_list:
for id in id_list:
node_list.append(Session.query(Node).filter(Node.id == id).first())
if node_list:
keys = [v for v in dir(node_list[0]) if not v.startswith('_')]
keys = [v for v in keys if not v in ignore_list]
else:
return
csv = []
csv.append(','.join(keys))
for node in node_list:
items = []
for key in keys:
attribute = node.__getattribute__(key)
if attribute == None:
items.append('')
else:
items.append(attribute)
csv.append(','.join(items))
return csv
def add(self):
c.group = Session.query(Group).filter(Group.id == id).first()
c.title = 'Nodetraq - Group - Add'
c.selected_page = 'groups'
c.subpage = 'add'
return render('/groups/add.mako')
def updatebyname(self, name, format='html'):
id = Session.query(Node).filter(Node.hostname == name).first()
if id:
id = id.id
else:
return 'Host: %s is not in nodetraq' % name
ignore = ['Submit',
'username']
params = [
(p, request.params[p]) for p in request.params \
if p not in ignore]
data = {}
for key, value in params:
if value:
if key == 'cpu_speed' and not value:
continue
data[key] = value
activity_engine = ActivityEngine(Session,
session['active_user']['user_id'])
status = activity_engine.update('node', id, data)
if format =='html':
session['flash'] = status
session.save()
return redirect(url(controller='nodes', action='show', id=id))
elif format == 'json':
request.content_type = 'application/json'
return status
def namelist(self, format='mako'):
c.nodes = Session.query(Node.hostname).all()
if format == 'json':
response.content_type = 'application/json'
elif format == 'xml':
response.content_type = 'application/xml'
return render('/nodes/namelist/list.' + format)
