def show_tenant(): """ List VMs for the project """ c = clients.user_clients(flask.g.tenant_id) servers = c.compute.servers.list(detailed=True) vms_data = [s._info for s in servers] vms_data = sorted(vms_data, key=lambda x: x['name']) p = pagination.Pagination(vms_data) data = p.slice(vms_data) user_id2name = {} uuid_regex = re.compile( r'[a-f0-9]{8}-?[a-f0-9]{4}-?[a-f0-9]{4}-?[a-f0-9]{4}-?[a-f0-9]{12}') for x in data: user_id = x['user_id'] try: x['user_id'] = user_id2name[user_id] pass except KeyError: if user_id.isdigit() or uuid_regex.match(user_id): try: user = clients.admin_clients().keystone.users.get(user_id) user_id2name[user_id] = user.name x['user_id'] = user.name except: pass return { 'vms': data, 'pagination': p, 'title': 'Virtual Machines', 'subtitle': 'List of virtual machines' }
def index(): try: notifications = utils.notifications_api_call("/parameter") except HttpException as ex: notifications = [] item_list = utils.notifications_api_call("/item") item_by_key = dict(((item["key_"], item) for item in item_list)) for notif in notifications: notification_normalize(notif) try: notif["name"] = item_by_key[notif["key_"]]["name"] except KeyError: notif["name"] = notif["key_"] notifications = sorted(notifications, key=lambda n: (n["is_email"], n["name"])) p = pagination.Pagination(len(notifications)) offset = p.limit_offset() notifications = notifications[offset[0]:offset[1]] return { 'objects': notifications, 'pagination': p, 'delete_form': forms.DeleteForm(), 'title': bp.name.replace('global_', '').replace('_', ' ').capitalize(), 'subtitle': 'List of notifications' }
def index(): """List users. TODO(apugachev): find way to count users without fetching all users. This would allow to use marker and limit to fetch one page only. """ identity_admin = clients.admin_clients().identity_admin users = sorted(identity_admin.users.list(limit=1000000), key=lambda x: x.name) p = pagination.Pagination(users) data = p.slice(users) potential_admins = set([ user.id for user in (identity_admin.users.list(clients.get_systenant_id())) ]) for user in data: # TODO(apugachev) modify to work with form.DeleteUser form = forms.DeleteUserForm() form.user_id.data = user.id user.delete_form = form if user.id in potential_admins: for role in (identity_admin.roles.roles_for_user(user.id)): if clients.role_tenant_is_admin(role): user.is_global_admin = True break return { 'pagination': p, 'data': data, 'title': bp.name.replace('global_', '').replace('_', ' ').capitalize(), 'subtitle': 'List of users' }
def list_users(): """ List users. """ users = flask.g.tenant.list_users() p = pagination.Pagination(users) return { 'pagination': p, 'objects': p.slice(users), 'title': 'Users', 'subtitle': 'List of users' }
def index(): """List security groups. """ security_groups = (clients.user_clients( flask.g.tenant_id).compute.security_groups.list()) p = pagination.Pagination(security_groups) data = p.slice(security_groups) return { 'security_groups': data, 'pagination': p, 'delete_form': forms.DeleteForm(), 'title': bp.name.replace('global_', '').replace('_', ' ').capitalize(), 'subtitle': 'List of existing security groups' }
def index(): total_count = flask.g.store.execute( 'SELECT count(*) from email_masks').get_one()[0] p = pagination.Pagination(total_count) rows = flask.g.store.execute( 'SELECT * from email_masks ORDER BY email_mask LIMIT ?, ?', p.limit_offset()).get_all() objects = map(lambda row: dict(zip(('id', 'email_mask'), row)), rows) return { 'pagination': p, 'objects': objects, 'delete_form': forms.DeleteForm(), 'title': bp.name.replace('global_', '').replace('_', ' ').capitalize(), 'subtitle': 'Invitation domains list' }
def index(): """List projects. List only enabled, sort by name. """ tenants = utils.get_visible_tenants() ordered = sorted(tenants, key=lambda x: x.name) pagina = pagination.Pagination(ordered) delete_form = forms.DeleteForm() return { 'objects': pagina.slice(ordered), 'pagination': pagina, 'delete_form': delete_form, 'title': bp.name.replace('global_', '').replace('_', ' ').capitalize(), 'subtitle': 'List of projects' }
def index(): try: networks = clients.admin_clients().compute.networks.list() except HttpException as ex: networks = [] tenants = clients.admin_clients().identity_admin.tenants.list() tenants = dict(((t.id, t.name) for t in tenants)) p = pagination.Pagination(len(networks)) offset = p.limit_offset() networks = [net._info for net in networks[offset[0]:offset[1]]] for net in networks: net["label"] = tenants.get(net["project_id"], net["label"]) return { 'objects': networks, 'pagination': p, 'delete_form': forms.DeleteForm(), 'title': bp.name.replace('global_', '').replace('_', ' ').capitalize(), 'subtitle': 'List of networks' }
def index(): """List images. Admin (global visibility level) should see only images from systenant. Project members should see images for projects only. """ images = get_images_list() if not hasattr(flask.g, 'tenant_id'): images = filter(lambda x: getattr(x, 'is_public', False), images) p = pagination.Pagination(images) data = p.slice(images) return { 'images': data, 'pagination': p, 'delete_form': forms.DeleteForm(), 'title': bp.name.replace('global_', '').replace('_', ' ').capitalize(), 'subtitle': 'List of existing images' }
def list_vms(): ''' List all virtual machines in the cloud. ''' # not in visible tenants, but in all tenants tenants = dict( [(x.id, x) for x in clients.admin_clients().keystone.tenants.list()]) class ProjectNameColumn(dataset.StrColumn): def __call__(self, x): try: tenant = tenants[x.tenant_id] except KeyError: return '[deleted] %s' % x.tenant_id else: return tenant.name default_columns = ['id', 'name', 'project_name', 'ram'] #creating and adjusting columns vector, columns ordering columns = dataset.ColumnKeeper({ 'id': dataset.StrColumn('id', 'ID'), 'name': dataset.StrColumn('name', 'Name'), 'user_id': dataset.StrColumn('user_id', 'User'), 'tenant_id': dataset.StrColumn('tenant_id', 'Project ID'), 'project_name': ProjectNameColumn( 'project_name', 'Project Name'), 'ram': dataset.IntColumn('ram', 'RAM'), 'vcpus': dataset.IntColumn('vcpus', 'Number of CPUs') }, default_columns) if 'columns' in flask.request.args: columns.adjust( [x for x in flask.request.args['columns'].split(',') if x]) if 'asc' in flask.request.args or 'desc' in flask.request.args: columns.order( flask.request.args.getlist('asc'), flask.request.args.getlist('desc')) if 'groupby' in flask.request.args: columns.adjust_groupby(flask.request.args['groupby']) vms = clients.admin_clients().nova.servers.list(search_opts={ 'all_tenants': 1}) flavors = dict( [(x.id, x) for x in clients.admin_clients().nova.flavors.list()]) for server in vms: try: flavor = flavors[server.flavor['id']] except KeyError: flavor = clients.admin_clients().nova.flavors.get(server.flavor[ 'id']) flavors[server.flavor['id']] = flavor server.ram = flavor.ram server.vcpus = flavor.vcpus current_dataset = dataset.DataSet(vms, columns) if 'export' in flask.request.args: try: export = exporter.Exporter( flask.request.args['export'], current_dataset.data, columns, 'vms') except KeyError: d = flask.request.args.copy() d.pop('export') query = urllib.urlencode(datastructures.iter_multi_items(d)) url = flask.request.path + '?' + query return flask.redirect(url) response = export() else: p = pagination.Pagination(current_dataset.data) visible_data = p.slice(current_dataset.data) response = dict( pagination=p, columns=columns, data=visible_data) if 'project_name' in columns.current_names: response['distinct_projects_names'] = sorted( current_dataset.get_distinct_values("project_name")) response.update({ 'title': 'Virtual Machines', 'subtitle': 'List of virtual machines' }) return response