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_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(self): id = request.params['id'] graph = Session.query(Graph)\ .filter(Graph.id == id).first() group = request.params['group_select'] graph.name = request.params['graph_title'] graph.filename = request.params['filename'] graph.group = Session.query(Group)\ .filter(Group.name == group).first() rrds = [] for k,v in request.params.iteritems(): if k == 'rrd_type': rrds.append(v) graph.rrd_types = ','.join(rrds) if not graph.name or not graph.group or not graph.rrd_types: session['flash'] = "Failed to update graph" session.save() return redirect(url( controller='graphs', action='index')) Session.add(graph) Session.commit() session['flash'] = "Successfully updated" session.save() grab_new_drraw(graph) generate_index() return redirect(url( controller='graphs', action='index'))
def update(self, id, backup_id): for k, v in request.params.iteritems(): params = json.loads(k) break storage = params['storage'] directory = params['directory'] enabled = params['enabled'] backup_type_id = params['backup_type'] node_backup = Session.query(NodeDatabaseBackup).filter( NodeDatabaseBackup.id == backup_id).first() node_backup.server = Session.query(Node)\ .filter(Node.id == id).first() node_backup.server_id = node_backup.server.id node_backup.storage = Session.query(Node)\ .filter(Node.hostname == \ storage).first() node_backup.storage_id = node_backup.storage.id node_backup.directory = directory node_backup.enabled = enabled node_backup.backup_type_id = backup_type_id if node_backup.storage and node_backup.server: Session.add(node_backup) Session.commit() else: session['flash'] = 'Storage hostname doesn\'t exist' session.save() return redirect(url(controller='dbbackups', action='index', id=id))
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 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(self, id): 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 = Session.query(NetworkDevice).filter( NetworkDevice.id == id).first() if not network_device: return {'success': False} 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 update(self, id, backup_id): for k,v in request.params.iteritems(): params = json.loads(k) break storage = params['storage'] directory = params['directory'] enabled = params['enabled'] backup_type_id = params['backup_type'] node_backup = Session.query(NodeDatabaseBackup).filter( NodeDatabaseBackup.id == backup_id).first() node_backup.server = Session.query(Node)\ .filter(Node.id == id).first() node_backup.server_id = node_backup.server.id node_backup.storage = Session.query(Node)\ .filter(Node.hostname == \ storage).first() node_backup.storage_id = node_backup.storage.id node_backup.directory = directory node_backup.enabled = enabled node_backup.backup_type_id = backup_type_id if node_backup.storage and node_backup.server: Session.add(node_backup) Session.commit() else: session['flash'] = 'Storage hostname doesn\'t exist' session.save() return redirect(url(controller='dbbackups', action='index', id=id))
def update_flags(self): response.content_type = 'application/json' ids = None if 'ids[]' in request.params: ids = [int(v) for k,v in request.params.items()\ if 'ids[]' in k] else: session['flash'] = "No ids were passed" session.save() return '{"success": false}' flags = None if 'flags[]' in request.params: flags = [v for k,v in request.params.items()\ if 'flags[]' in k] else: session['flash'] = "No flags were passed" session.save() return '{"success": false}' description = None if 'description' in request.params: description = request.params['description'] if 'user' in request.params: username = request.params['user'] else: session['flash'] = "No username was passed" session.save() return '{"success": false"}' for node_id in ids: node = Session.query(Node).filter(Node.id == node_id).first() node.flags = [] nfi = NodeFlagInfo() nfi.node = node nfi.user = Session.query(User).filter( User.name == username).first() nfi.description = description nfi.flags = Session.query(Flag)\ .filter(Flag.name.in_(flags)).all() for f in ['setup', 'hardware', 'maintenance']: if f in flags: comment = NodeComment() comment.node_id = node.id comment.user_id = nfi.user.id comment.description = description node.comments.append(comment) Session.add(node) Session.add(comment) Session.commit() break Session.add(nfi) Session.commit() session['flash'] = 'Flags were updated' session.save() return '{"success": true}'
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 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 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 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 create(self, id): node = Session.query(Node).filter(Node.id == id).first() if not node.db_backups: node.db_backups = [] node_backup = NodeDatabaseBackup() node_backup.enabled = True node_backup.server = Session.query(Node)\ .filter(Node.id == id).first() node_backup.server_id = node_backup.server.id node_backup.storage = Session.query(Node)\ .filter(Node.hostname == \ request.params['storage']).first() node_backup.storage_id = node_backup.storage.id node_backup.directory = request.params['directory'] node_backup.backup_type_id = request.params['backup_type'] if node_backup.storage and node_backup.server: Session.add(node_backup) Session.commit() node.db_backups.append(node_backup) Session.add(node) Session.commit() else: session['flash'] = 'Storage hostname doesn\'t exist' session.save() return redirect(url(controller='dbbackups', action='index', id=id))
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 bulk_update(self): for k, v in request.params.iteritems(): data = json.loads(k) # updates for update in data['updates']: try: node_backup = Session.query(NodeDatabaseBackup).filter( NodeDatabaseBackup.id == update['id']).first() node_backup.server = Session.query(Node)\ .filter(Node.hostname == update['server']).first() node_backup.server_id = node_backup.server.id node_backup.storage = Session.query(Node)\ .filter(Node.hostname == \ update['storage']).first() node_backup.storage_id = node_backup.storage.id node_backup.directory = update['directory'] node_backup.enabled = update['enabled'] if node_backup.storage and node_backup.server: Session.add(node_backup) Session.commit() except Exception as e: session['flash'] = "Error: %s" % e session.save() return {"success": False} # new backups for backup in data['new_backups']: try: node = Session.query(Node).filter( Node.hostname == backup['server']).first() if not node.db_backups: node.db_backups = [] node_backup = NodeDatabaseBackup() node_backup.enabled = backup['enabled'] node_backup.server = node node_backup.server_id = node_backup.server.id node_backup.storage = Session.query(Node)\ .filter(Node.hostname == \ backup['storage']).first() node_backup.storage_id = node_backup.storage.id node_backup.directory = backup['directory'] if node_backup.storage and node_backup.server: Session.add(node_backup) Session.commit() node.db_backups.append(node_backup) Session.add(node) Session.commit() except Exception as e: session['flash'] = "Error: %s" % e session.save() return {"success": False} session['flash'] = "Successfully updated backups!" session.save() return {"success": True}
def bulk_update(self): for k,v in request.params.iteritems(): data = json.loads(k) # updates for update in data['updates']: try: node_backup = Session.query(NodeDatabaseBackup).filter( NodeDatabaseBackup.id == update['id']).first() node_backup.server = Session.query(Node)\ .filter(Node.hostname == update['server']).first() node_backup.server_id = node_backup.server.id node_backup.storage = Session.query(Node)\ .filter(Node.hostname == \ update['storage']).first() node_backup.storage_id = node_backup.storage.id node_backup.directory = update['directory'] node_backup.enabled = update['enabled'] if node_backup.storage and node_backup.server: Session.add(node_backup) Session.commit() except Exception as e: session['flash'] = "Error: %s" % e session.save() return {"success": False} # new backups for backup in data['new_backups']: try: node = Session.query(Node).filter( Node.hostname == backup['server']).first() if not node.db_backups: node.db_backups = [] node_backup = NodeDatabaseBackup() node_backup.enabled = backup['enabled'] node_backup.server = node node_backup.server_id = node_backup.server.id node_backup.storage = Session.query(Node)\ .filter(Node.hostname == \ backup['storage']).first() node_backup.storage_id = node_backup.storage.id node_backup.directory = backup['directory'] if node_backup.storage and node_backup.server: Session.add(node_backup) Session.commit() node.db_backups.append(node_backup) Session.add(node) Session.commit() except Exception as e: session['flash'] = "Error: %s" % e session.save() return {"success": False} session['flash'] = "Successfully updated backups!" 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 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 sendbatchedit(self): response.content_type = 'application/json' user_id = int(request.params['user_id']) field = request.params['field'] info = [json.loads(d[1]) for d in request.params.items()\ if 'items[]' in d] if field == 'hostname': for item in info: data = {} data['hostname'] = item['hostname'] activity_engine = ActivityEngine(Session, user_id) status = activity_engine.update( 'node', item['node_id'], data) session['flash'] = "Success" session.save() elif field == 'groups': for item in info: node = Session.query(Node)\ .filter(Node.id == item['node_id']).first() group_list = item['groups']\ .replace(' ', '').split(',') node.groups = Session.query(Group)\ .filter(Group.name.in_(group_list)).all() Session.add(node) Session.commit() session['flash'] = "Success" session.save() elif field == 'db_backups': for item in info: backup = Session.query(NodeDatabaseBackup)\ .filter(NodeDatabaseBackup.id == item['backup_id'])\ .first() node = Session.query(Node)\ .filter(Node.id == item['node_id']).first() backup.server_id = node.id if item['data_type'] == 'storage': storage = Session.query(Node)\ .filter(Node.hostname == item['value']).first() backup.storage_id = storage.id elif item['data_type'] == 'directory': backup.directory = item['value'] Session.add(backup) Session.commit() session['flash'] = "Success" session.save() else: return '{"success": false}' return '{"success": true}'
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 sendbatchedit(self): response.content_type = 'application/json' user_id = int(request.params['user_id']) field = request.params['field'] info = [json.loads(d[1]) for d in request.params.items()\ if 'items[]' in d] if field == 'hostname': for item in info: data = {} data['hostname'] = item['hostname'] activity_engine = ActivityEngine(Session, user_id) status = activity_engine.update('node', item['node_id'], data) session['flash'] = "Success" session.save() elif field == 'groups': for item in info: node = Session.query(Node)\ .filter(Node.id == item['node_id']).first() group_list = item['groups']\ .replace(' ', '').split(',') node.groups = Session.query(Group)\ .filter(Group.name.in_(group_list)).all() Session.add(node) Session.commit() session['flash'] = "Success" session.save() elif field == 'db_backups': for item in info: backup = Session.query(NodeDatabaseBackup)\ .filter(NodeDatabaseBackup.id == item['backup_id'])\ .first() node = Session.query(Node)\ .filter(Node.id == item['node_id']).first() backup.server_id = node.id if item['data_type'] == 'storage': storage = Session.query(Node)\ .filter(Node.hostname == item['value']).first() backup.storage_id = storage.id elif item['data_type'] == 'directory': backup.directory = item['value'] Session.add(backup) Session.commit() session['flash'] = "Success" session.save() else: return '{"success": false}' 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 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): 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 delete(self, id): if id.isdigit(): graph = Session.query(Graph)\ .filter(Graph.id == int(id)).first() else: graph = Session.query(Graph)\ .filter(Graph.name == id).first() Session.delete(graph) Session.commit() session['flash'] = "Successfully deleted %s" % graph.name session.save() return redirect(url( controller='graphs', action='index'))
def update_game(self, id): game = Session.query(Game).filter(Game.id == id).first() game.name = request.params['name'] if 'description' in request.params: game.description = request.params['description'] if 'studio' in request.params: game.studio = Session.query(Studio).filter( Studio.id == int(request.params['studio'])).first() Session.add(game) Session.commit() session['flash'] = "Success" session.save() return {'success': True}
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 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 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)
def batch_update_games(self): for key in request.params: key = json.loads(key) nodes = key['ids'] game = key['game'] break nodes = Session.query(Node).filter(Node.id.in_(nodes)).all() game = Session.query(Game).filter(Game.id == game).first() for node in nodes: node.game = game Session.add(node) Session.commit() return {'success': True}
def batch_update_studios(self): for key in request.params: key = json.loads(key) nodes = key['ids'] studio = key['studio'] break nodes = Session.query(Node).filter(Node.id.in_(nodes)).all() studio = Session.query(Studio).filter(Studio.id == studio).first() for node in nodes: node.studio = studio Session.add(node) Session.commit() return {'success': True}
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 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 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 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 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 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')