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 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 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 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 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 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(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_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_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):
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 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 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 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_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():
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_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_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_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 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 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 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 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 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 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 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 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 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 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 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 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 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_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 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 update_xen_nodes(xen_list):
for item in xen_list:
node = Session.query(Node).filter(
Node.hostname == item.hostname).first()
if not node:
node = Node()
node.hostname = item.hostname
node.memory = item.mem
node.xen_instance = item.id
node.location = item.location
node.rack = item.rack
node.rack_u = item.rack_u
Session.add(node)
Session.commit()
return True
def update_xen_nodes(xen_list):
for item in xen_list:
node = Session.query(Node).filter(
Node.hostname == item.hostname).first()
if not node:
node = Node()
node.hostname = item.hostname
node.memory = item.mem
node.xen_instance = item.id
node.location = item.location
node.rack = item.rack
node.rack_u = item.rack_u
Session.add(node)
Session.commit()
return True
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 createcomment(self, pool):
if 'comment' in request.params and\
'user_id' in request.params:
if request.params['comment']:
lbcomment = LBPoolComments()
lbcomment.comment =request.params['comment']
if request.params['user_id']:
lbcomment.user_id = request.params['user_id']
Session.add(lbcomment)
Session.commit()
else:
session['flash'] = 'Creating comment failed'
session.save()
return redirect(url(
controller='loadbalancer', action='show',
pool=c.request.params['pool']))
def createcomment(self, pool):
if 'comment' in request.params and\
'user_id' in request.params:
if request.params['comment']:
lbcomment = LBPoolComments()
lbcomment.comment = request.params['comment']
if request.params['user_id']:
lbcomment.user_id = request.params['user_id']
Session.add(lbcomment)
Session.commit()
else:
session['flash'] = 'Creating comment failed'
session.save()
return redirect(
url(controller='loadbalancer',
action='show',
pool=c.request.params['pool']))
def disable(self, id, backup_id):
node_backup = Session.query(NodeDatabaseBackup).filter(
NodeDatabaseBackup.id == backup_id).first()
node_backup.enabled = False
Session.add(node_backup)
Session.commit()
c.backup_server = node_backup.server.hostname
c.backup_type = node_backup.backup_type.name
c.backup_storage = node_backup.storage.hostname
c.backup_directory = node_backup.directory
if session['active_user']:
c.user = session['active_user']['username']
send_email(render('/email/backups/disable.mako'),
'Disabled backup: %s' % c.backup_server,
email_from='admin@yourdomain',
email_to=['email_user@yourdomain'])
return {"success": True}
def disable(self, id, backup_id):
node_backup = Session.query(NodeDatabaseBackup).filter(
NodeDatabaseBackup.id == backup_id).first()
node_backup.enabled = False
Session.add(node_backup)
Session.commit()
c.backup_server = node_backup.server.hostname
c.backup_type = node_backup.backup_type.name
c.backup_storage = node_backup.storage.hostname
c.backup_directory = node_backup.directory
if session['active_user']:
c.user = session['active_user']['username']
send_email(
render('/email/backups/disable.mako'),
'Disabled backup: %s' % c.backup_server,
email_from='admin@yourdomain',
email_to=['email_user@yourdomain'])
return {"success": True}
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 node_insert_db(node_data):
schema, data = node_data
# Setup schema to match attributes
for i, key in enumerate(schema):
for word, replacement in node_replacements:
if key == word:
schema[i] = replacement
break
else:
schema[i] = None
for item in data:
node = Node()
zipped = zip(schema, item)
for key, value in zipped:
if key:
node.__setattr__(key, value)
Session.add(node)
Session.commit()
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 update_disks(self, diskinfo):
if self.disks:
current_serials = [d.serial_no for d in self.disks]
new_serials = [d['serial_no'] for d in diskinfo['disks']]
diff_serials = list(set(new_serials) - set(current_serials))
remove_serials = [ serial for serial in current_serials \
if serial not in new_serials ]
for s in remove_serials:
for rd in self.disks:
if rd.serial_no == s:
self.disks.remove(rd)
Session.delete(rd)
for s in diff_serials:
for disk in diskinfo['disks']:
if disk['serial_no'] == s:
new_disk = Disk()
new_disk.serial_no = disk['serial_no']
new_disk.capacity = disk['capacity']
new_disk.type = disk['type']
new_disk.controller_slot = disk['controller_slot']
new_disk.controller_id = DiskController\
.grab_controller(disk['controller'])
Session.add(new_disk)
self.disks.append(new_disk)
else:
self.disks = []
for disk in diskinfo['disks']:
new_disk = Disk()
new_disk.serial_no = disk['serial_no']
new_disk.capacity = disk['capacity']
new_disk.type = disk['type']
new_disk.controller_slot = disk['controller_slot']
new_disk.controller_id = DiskController\
.grab_controller(disk['controller'])
Session.add(new_disk)
self.disks.append(new_disk)
Session.add(self)
Session.commit()
def update_disks(self, diskinfo):
if self.disks:
current_serials = [d.serial_no for d in self.disks]
new_serials = [d["serial_no"] for d in diskinfo["disks"]]
diff_serials = list(set(new_serials) - set(current_serials))
remove_serials = [serial for serial in current_serials if serial not in new_serials]
for s in remove_serials:
for rd in self.disks:
if rd.serial_no == s:
self.disks.remove(rd)
Session.delete(rd)
for s in diff_serials:
for disk in diskinfo["disks"]:
if disk["serial_no"] == s:
new_disk = Disk()
new_disk.serial_no = disk["serial_no"]
new_disk.capacity = disk["capacity"]
new_disk.type = disk["type"]
new_disk.controller_slot = disk["controller_slot"]
new_disk.controller_id = DiskController.grab_controller(disk["controller"])
Session.add(new_disk)
self.disks.append(new_disk)
else:
self.disks = []
for disk in diskinfo["disks"]:
new_disk = Disk()
new_disk.serial_no = disk["serial_no"]
new_disk.capacity = disk["capacity"]
new_disk.type = disk["type"]
new_disk.controller_slot = disk["controller_slot"]
new_disk.controller_id = DiskController.grab_controller(disk["controller"])
Session.add(new_disk)
self.disks.append(new_disk)
Session.add(self)
Session.commit()
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 setup_app(command, conf, vars):
"""Place any commands to setup nodetraq here"""
# Don't reload the app if it was loaded under the testing environment
if not pylons.test.pylonsapp:
load_environment(conf.global_conf, conf.local_conf)
# Create the tables if they don't already exist
Base.metadata.create_all(bind=Session.bind)
# Use the below only if you're not using declarative.
# metadata.create_all(bind=Session.bind)
# Setup the Activity Types
a_type = ActivityType()
a_type.name = 'node'
a_type.action = 'add'
Session.add(a_type)
a_type = ActivityType()
a_type.name = 'node'
a_type.action = 'remove'
Session.add(a_type)
a_type = ActivityType()
a_type.name = 'node'
a_type.action = 'update'
Session.add(a_type)
a_type = ActivityType()
a_type.name = 'group'
a_type.action = 'add'
Session.add(a_type)
a_type = ActivityType()
a_type.name = 'group'
a_type.action = 'remove'
Session.add(a_type)
a_type = ActivityType()
a_type.name = 'group'
a_type.action = 'update'
Session.add(a_type)
a_type = ActivityType()
a_type.name = 'inventory'
a_type.action = 'add'
Session.add(a_type)
a_type = ActivityType()
a_type.name = 'inventory'
a_type.action = 'remove'
Session.add(a_type)
a_type = ActivityType()
a_type.name = 'inventory'
a_type.action = 'update'
Session.add(a_type)
a_type = ActivityType()
a_type.name = 'loadbalancer'
a_type.action = 'add'
Session.add(a_type)
a_type = ActivityType()
a_type.name = 'loadbalancer'
a_type.action = 'remove'
Session.add(a_type)
a_type = ActivityType()
a_type.name = 'loadbalancer'
a_type.action = 'update'
Session.add(a_type)
a_type = ActivityType()
a_type.name = 'nagios'
a_type.action = 'enable'
Session.add(a_type)
a_type = ActivityType()
a_type.name = 'puppet'
a_type.action = 'enable'
Session.add(a_type)
a_type = ActivityType()
a_type.name = 'puppet'
a_type.action = 'disable'
Session.add(a_type)
a_type = ActivityType()
a_type.name = 'user'
a_type.action = 'create'
Session.add(a_type)
a_type = ActivityType()
a_type.name = 'user'
a_type.action = 'update'
Session.add(a_type)
# Setup Flags
flag = Flag()
flag.name = 'setup'
flag.description = ''
Session.add(flag)
flag = Flag()
flag.name = 'hardware'
flag.description = ''
Session.add(flag)
flag = Flag()
flag.name = 'maintenance'
flag.description = ''
Session.add(flag)
flag = Flag()
flag.name = 'rebooting'
flag.description = ''
Session.add(flag)
flag = Flag()
flag.name = 'examining'
Session.add(flag)
Session.commit()
backup = BackupType()
backup.name = 'xtrabackup'
Session.add(backup)
Session.commit()
backup = BackupType()
backup.name = 'one-off-backup'
Session.add(backup)
Session.commit()
def check_user(username, password):
usernameDN = 'uid='+username+','+_baseDN
ldap.set_option(ldap.OPT_X_TLS_REQUIRE_CERT, False)
l = ldap.initialize(_ldap_server)
dh = DirectoryHelper(
directoryCN, directoryPassword, directoryDomain)
try:
l.simple_bind_s(usernameDN, password)
filter = 'uid=*'+username+'*'
retrieve_attributes = ['mail']
base_result = l.result(l.search(
_baseDN, ldap.SCOPE_SUBTREE,
filter, retrieve_attributes))
mail = None
if base_result[0]:
if base_result[1]:
if base_result[1][0][1].has_key('mail'):
mail = base_result[1][0][1]['mail'][0]
# Check if the user exists
user = Session.query(User).filter(
User.name == username).first()
if not user:
user = User()
user.name = username
if mail:
user.email = mail
else:
user.email = username + '@yourdomain'
Session.add(user)
Session.commit()
elif user.email != mail:
if mail:
user.email = mail
Session.add(user)
Session.commit()
elif user.email != username + '@yourdomain':
user.email = username + '@yourdomain'
Session.add(user)
Session.commit()
# Get user groups
userDN = dh.findUser(username)
userGroups = dh.getUserGroups(username)
user_level = 100
if 'eng' in userGroups:
user_level = 30
if 'itops2' in userGroups:
user_level = 10
if 'ops' in userGroups:
user_level = 0
return (username, user.id, user_level)
else:
return (False,)
except ldap.LDAPError, e:
print e
return False, e
def create_group(name):
group = Group()
group.name = name
Session.add(group)
Session.commit()
return group
