class RightManager(object): def __init__(self): self.right_cls = Right self._levels = SortedDict() self._categories = SortedDict() self._rights = SortedDict() def register_level(self, key, title, description=""): self._levels[key] = RightLevel(self, key, title, description) def register_category(self, key, title, description=""): self._categories[key] = RightCategory(self, key, title, description) def register(self, key, title, description="", category="", level=""): self._rights[key]=Right(self, key, title, description=description, category=category, level=level) def get_category(self, category_key): return self._categories.get(category_key, None) def get_level(self, level_key): return self._levels.get(level_key, None) def get_right(self, key): return self._rights.get(key) def get_rights(self): return [self.get_right(key) for key in self._rights.keys()] def get_rights_dict(self): return [self.get_right(key).to_dict() for key in self._rights.keys()]
def get_data(self): instances = [] try: instances = api.nova.server_list(self.request, all_tenants=True) except: exceptions.handle(self.request, _('Unable to retrieve instance list.')) if instances: # Gather our flavors to correlate against IDs try: flavors = api.nova.flavor_list(self.request) except: flavors = [] msg = _('Unable to retrieve instance size information.') exceptions.handle(self.request, msg) # Gather our tenants to correlate against IDs try: tenants = api.keystone.tenant_list(self.request, admin=True) except: tenants = [] msg = _('Unable to retrieve instance tenant information.') exceptions.handle(self.request, msg) full_flavors = SortedDict([(f.id, f) for f in flavors]) tenant_dict = SortedDict([(t.id, t) for t in tenants]) for inst in instances: inst.full_flavor = full_flavors.get(inst.flavor["id"], None) tenant = tenant_dict.get(inst.tenant_id, None) inst.tenant_name = getattr(tenant, "name", None) return instances
def fields_for_form(self, form, fields=None, exclude=None, field_callback=None): field_list = [] ignored = [] for name, f in form.base_fields.items(): if fields is not None and not name in fields: continue if exclude and name in exclude: continue if field_callback is None: formfield = self.get_field_class(f)() formfield.set_name(name) formfield.set_source(f) elif not callable(field_callback): raise TypeError('formfield_callback must be a function or callable') else: formfield = field_callback(name, f) if formfield: field_list.append((name, formfield)) else: ignored.append(name) field_dict = SortedDict(field_list) if fields: field_dict = SortedDict( [(f, field_dict.get(f)) for f in fields if ((not exclude) or (exclude and f not in exclude)) and (f not in ignored)] ) return field_dict
def get_data(self): # Gather our volumes try: volumes = api.volume_list(self.request) except: volumes = [] exceptions.handle(self.request, _('Unable to retrieve volume list.')) try: instance_list = api.server_list(self.request) except: instance_list = [] exceptions.handle(self.request, _("Unable to retrieve volume/instance " "attachment information")) instances = SortedDict([(inst.id, inst) for inst in instance_list]) for volume in volumes: # It is possible to create a volume with no name through the # EC2 API, use the ID in those cases. if not volume.display_name: volume.display_name = volume.id for att in volume.attachments: server_id = att.get('server_id', None) att['instance'] = instances.get(server_id, None) return volumes
class AppDirectoriesFinder(BaseFinder): """ A static files finder that looks in the directory of each app as specified in the source_dir attribute of the given storage class. """ storage_class = AppStaticStorage def __init__(self, apps=None, *args, **kwargs): # The list of apps that are handled self.apps = [] # Mapping of app module paths to storage instances self.storages = SortedDict() if apps is None: apps = settings.INSTALLED_APPS for app in apps: app_storage = self.storage_class(app) if os.path.isdir(app_storage.location): self.storages[app] = app_storage if app not in self.apps: self.apps.append(app) super(AppDirectoriesFinder, self).__init__(*args, **kwargs) def list(self, ignore_patterns): """ List all files in all app storages. """ for storage in six.itervalues(self.storages): if storage.exists(''): # check if storage location exists for path in utils.get_files(storage, ignore_patterns): yield path, storage def find(self, path, all=False): """ Looks for files in the app directories. """ matches = [] for app in self.apps: match = self.find_in_app(app, path) if match: if not all: return match matches.append(match) return matches def find_in_app(self, app, path): """ Find a requested static file in an app's static locations. """ storage = self.storages.get(app, None) if storage: if storage.prefix: prefix = '%s%s' % (storage.prefix, os.sep) if not path.startswith(prefix): return None path = path[len(prefix):] # only try to find a file if the source dir actually exists if storage.exists(path): matched_path = storage.path(path) if matched_path: return matched_path
def fields_for_document(document, fields=None, exclude=None, formfield_callback=None): """ Returns a ``SortedDict`` containing form fields for the given model. ``fields`` is an optional list of field names. If provided, only the named fields will be included in the returned fields. ``exclude`` is an optional list of field names. If provided, the named fields will be excluded from the returned fields, even if they are listed in the ``fields`` argument. """ field_list = [] structure = document.structure for field_name, field_type in structure.items(): if fields and not field_name in fields: continue if exclude and field_name in exclude: continue form_field = None if formfield_callback: form_field = formfield_callback(document, field_name) if not form_field: form_field = formfield_for_document_field(document, field_name) if form_field: field_list.append((field_name, form_field)) field_dict = SortedDict(field_list) if fields: field_dict = SortedDict([(f, field_dict.get(f)) for f in fields if (not exclude) or (exclude and f not in exclude)]) return field_dict
def get_volume_types_data(self): try: volume_types = cinder.volume_type_list_with_qos_associations(self.request) except Exception: volume_types = [] exceptions.handle(self.request, _("Unable to retrieve volume types")) # Gather volume type encryption information try: vol_type_enc_list = cinder.volume_encryption_type_list(self.request) except Exception: vol_type_enc_list = [] msg = _("Unable to retrieve volume type encryption information.") exceptions.handle(self.request, msg) vol_type_enc_dict = SortedDict([(e.volume_type_id, e) for e in vol_type_enc_list]) for volume_type in volume_types: vol_type_enc = vol_type_enc_dict.get(volume_type.id, None) if vol_type_enc is not None: volume_type.encryption = vol_type_enc volume_type.encryption.name = volume_type.name else: volume_type.encryption = None return volume_types
def fields_for_app(app, fields, exclude, owner_class): """ Returns a ``SortedDict`` containing form fields for the given model. ``fields`` is an optional list of field names. If provided, only the named fields will be included in the returned fields. ``exclude`` is an optional list of field names. If provided, the named fields will be excluded from the returned fields, even if they are listed in the ``fields`` argument. """ field_list = [] try: _app = __import__(app, globals(), locals(), ['prefs']) app_prefs = _app.prefs except: pass else: default_prefs = getattr(app_prefs, 'for_system', {}) if owner_class is not None: default_prefs.update(getattr(app_prefs, 'for_owner', {}).get(owner_class, {})) for name, field in default_prefs.items(): if fields and not name in fields: continue if exclude and name in exclude: continue if field: field_list.append((name, field)) field_dict = SortedDict(field_list) if fields: field_dict = SortedDict([(f, field_dict.get(f)) for f in fields if (not exclude) or (exclude and f not in exclude)]) return field_dict
def fields_for_document(document, fields=None, exclude=None, widgets=None, labels=None, formfield_callback=DocumentFormField()): field_list = [] ignored = [] #TODO editable for f in document._fields.values(): if fields and not f.db_field in fields: continue if exclude and f.db_field in exclude: continue if widgets and f.db_field in widgets: kwargs = {'widget': widgets[f.db_field]} else: kwargs = {} # hack for labels if labels and f.db_field in labels: kwargs['label'] = labels[f.db_field] formfield = formfield_callback(f, **kwargs) if formfield: field_list.append((f.db_field, formfield)) else: ignored.append(f.db_field) field_dict = SortedDict(field_list) #why do this if fields: field_dict = SortedDict( [(f, field_dict.get(f)) for f in fields if ((not exclude) or (exclude and f not in exclude)) and (f not in ignored)] ) return field_dict
def list_targets(self): tenant_id = self.request.user.tenant_id ports = port_list(self.request, tenant_id=tenant_id) servers, has_more = nova.server_list(self.request) server_dict = SortedDict([(s.id, s.name) for s in servers]) reachable_subnets = self._get_reachable_subnets(ports) if is_service_enabled(self.request, config_name='enable_lb', ext_name='lbaas'): # Also get the loadbalancer VIPs vip_dict = {v['port_id']: v['name'] for v in self.client.list_vips().get('vips', [])} else: vip_dict = {} targets = [] for p in ports: # Remove network ports from Floating IP targets if p.device_owner.startswith('network:'): continue port_id = p.id server_name = server_dict.get(p.device_id) or vip_dict.get(port_id) for ip in p.fixed_ips: if ip['subnet_id'] not in reachable_subnets: continue target = {'name': '%s: %s' % (server_name, ip['ip_address']), 'id': '%s_%s' % (port_id, ip['ip_address']), 'instance_id': p.device_id} targets.append(FloatingIpTarget(target)) return targets
def fields_for_model(self, model, fields=None, exclude=None, field_callback=None, need_readonly=True): field_list = [] ignored = [] opts = model._meta for f in opts.fields + opts.many_to_many: if not f.editable and not need_readonly: continue if fields is not None and not f.name in fields: continue if exclude and f.name in exclude: continue if field_callback is None: formfield = self.get_field_class(f)() formfield.set_name(f.name) formfield.set_source(f) elif not callable(field_callback): raise TypeError('formfield_callback must be a function or callable') else: formfield = field_callback(f.name, f) if formfield: field_list.append((f.name, formfield)) else: ignored.append(f.name) field_dict = SortedDict(field_list) if fields: field_dict = SortedDict( [(f, field_dict.get(f)) for f in fields if ((not exclude) or (exclude and f not in exclude)) and (f not in ignored)] ) return field_dict
def list_targets(self): tenant_id = self.request.user.tenant_id ports = port_list(self.request, tenant_id=tenant_id) servers, has_more = nova.server_list(self.request) server_dict = SortedDict([(s.id, s.name) for s in servers]) reachable_subnets = self._get_reachable_subnets(ports) if is_service_enabled(self.request, config_name="enable_lb", ext_name="lbaas"): # Also get the loadbalancer VIPs vip_dict = {v["port_id"]: v["name"] for v in self.client.list_vips().get("vips", [])} else: vip_dict = {} targets = [] for p in ports: # Remove network ports from Floating IP targets if p.device_owner.startswith("network:"): continue port_id = p.id server_name = server_dict.get(p.device_id) or vip_dict.get(port_id) for ip in p.fixed_ips: if ip["subnet_id"] not in reachable_subnets: continue target = { "name": "%s: %s" % (server_name, ip["ip_address"]), "id": "%s_%s" % (port_id, ip["ip_address"]), "instance_id": p.device_id, } targets.append(FloatingIpTarget(target)) return targets
def admin_reorder(context, token): """ Called in admin/base_site.html template override and applies custom ordering of apps/models defined by settings.ADMIN_REORDER """ # sort key function - use index of item in order if exists, otherwise item sort = lambda order, item: (order.index(item), "") if item in order else ( len(order), item) if "app_list" in context: # sort the app list order = SortedDict(settings.ADMIN_REORDER) context["app_list"].sort(key=lambda app: sort(order.keys(), app["app_url"].strip("/").split("/")[-1])) for i, app in enumerate(context["app_list"]): # sort the model list for each app app_name = app["app_url"].strip("/").split("/")[-1] if not app_name: app_name = app["name"].lower() model_order = [m.lower() for m in order.get(app_name, [])] context["app_list"][i]["models"].sort(key=lambda model: sort(model_order, model["admin_url"].strip("/").split("/")[-1])) while len(context["app_list"][i]["models"]) > len(model_order): pos = len(context["app_list"][i]["models"]) - 1 del context["app_list"][i]["models"][pos] return ""
def cleanup_email_addresses(request, addresses): """ Takes a list of EmailAddress instances and cleans it up, making sure only valid ones remain, without multiple primaries etc. Order is important: e.g. if multiple primary e-mail addresses exist, the first one encountered will be kept as primary. """ from .models import EmailAddress adapter = get_adapter() # Let's group by `email` e2a = SortedDict() # maps email to EmailAddress primary_addresses = [] verified_addresses = [] primary_verified_addresses = [] for address in addresses: # Pick up only valid ones... email = valid_email_or_none(address.email) if not email: continue # ... and non-conflicting ones... if (app_settings.UNIQUE_EMAIL and EmailAddress.objects .filter(email__iexact=email) .exists()): continue a = e2a.get(email.lower()) if a: a.primary = a.primary or address.primary a.verified = a.verified or address.verified else: a = address a.verified = a.verified or adapter.is_email_verified(request, a.email) e2a[email.lower()] = a if a.primary: primary_addresses.append(a) if a.verified: primary_verified_addresses.append(a) if a.verified: verified_addresses.append(a) # Now that we got things sorted out, let's assign a primary if primary_verified_addresses: primary_address = primary_verified_addresses[0] elif verified_addresses: # Pick any verified as primary primary_address = verified_addresses[0] elif primary_addresses: # Okay, let's pick primary then, even if unverified primary_address = primary_addresses[0] elif e2a: # Pick the first primary_address = e2a.keys()[0] else: # Empty primary_address = None # There can only be one primary for a in e2a.values(): a.primary = primary_address.email.lower() == a.email.lower() return list(e2a.values()), primary_address
def columns_for_model(model, columns=None, exclude=None): """ Returns a ``SortedDict`` containing form columns for the given model. ``columns`` is an optional list of field names. If provided, only the named model fields will be included in the returned column list. ``exclude`` is an optional list of field names. If provided, the named model fields will be excluded from the returned list of columns, even if they are listed in the ``fields`` argument. """ field_list = [] opts = model._meta for f in opts.fields + opts.many_to_many: if (columns and not f.name in columns) or \ (exclude and f.name in exclude): continue column = Column(verbose_name=f.verbose_name) # TODO: chose correct column type, with right options if column: field_list.append((f.name, column)) field_dict = SortedDict(field_list) if columns: field_dict = SortedDict( [(c, field_dict.get(c)) for c in columns if ((not exclude) or (exclude and c not in exclude))] ) return field_dict
def get_floating_ips_odd(request, tenant_id, floating_ip): """ :param request:request object,tenant_id, floating_ip :return:view<'virtual_address_manage/floatingIpsIndex_ip.html'>::list of floatingip """ float_ip = [] floating_pool = {} floating_ips = None try: if None != switch_tenants(request , tenant_id): float_ip = api.tenant_floating_ip_list(request) floating_pools = api.network.floating_ip_pools_list(request) floating_pool = SortedDict([(pool.id , pool.name) for pool in floating_pools]) for floating in float_ip: if floating.ip == floating_ip: floating_ips = floating break if floating_pool: floating_ips._apidict['pool'] = floating_pool.get(floating_ips.pool, get_text("invalid ip pool")) except Unauthorized: raise except Exception , exe: LOG.exception("ClientException in floating ip index,the error is %s" % exe.message)
def get_volumes_data(self): # Gather our volumes try: volumes = api.volume_list(self.request) instances = SortedDict([(inst.id, inst) for inst in self._get_instances()]) for volume in volumes: # Truncate the description for proper display. if len(getattr(volume, 'display_description', '')) > 33: truncated_string = volume.display_description[:30].strip() # Remove non-word, and underscore characters, from the end # of the string before we add the ellepsis. truncated_string = re.sub(ur'[^\w\s]+$', '', truncated_string) volume.display_description = truncated_string + u'...' for att in volume.attachments: server_id = att.get('server_id', None) att['instance'] = instances.get(server_id, None) except: volumes = [] exceptions.handle(self.request, _('Unable to retrieve volume list.')) return volumes
def fields_for_model(model, fields=None, exclude=None, widgets=None, formfield_callback=lambda f, **kwargs: f.formfield(**kwargs)): """ Returns a ``SortedDict`` containing form fields for the given model. ``fields`` is an optional list of field names. If provided, only the named fields will be included in the returned fields. ``exclude`` is an optional list of field names. If provided, the named fields will be excluded from the returned fields, even if they are listed in the ``fields`` argument. """ field_list = [] opts = model._meta for f in opts.fields + opts.many_to_many: if not f.editable: continue if fields and not f.name in fields: continue if exclude and f.name in exclude: continue if widgets and f.name in widgets: kwargs = {'widget': widgets[f.name]} else: kwargs = {} formfield = formfield_callback(f, **kwargs) if formfield: field_list.append((f.name, formfield)) field_dict = SortedDict(field_list) if fields: field_dict = SortedDict([(f, field_dict.get(f)) for f in fields if (not exclude) or (exclude and f not in exclude)]) return field_dict
def get_ms_id_from_image_names(manuscripts, folios): ''' Returns (ret, suggested_shelfmark) ret = the id of the itempart which matches the most the given images suggested_shelfmark = a suggested shelfmark The matching is based on similarity of the name (shelfmark) and locus ''' ret = None # a term is part of the search pattern if its frequency is above the threshold threshold = 0.75 # find a pattern among the image paths pattern = SortedDict() folio_count = len(folios) for folio in folios: im_path = folio.iipimage.name # remove the extension im_path = re.sub(ur'\.[^.]{2,4}$', '', im_path) # only keep the image file name and the parent folder parts = im_path.split('/') for i in range(max(0, len(parts) - 2), len(parts)): part = parts[i] for term in re.findall(ur'[^\W_]+', part): pattern[term] = pattern.get(term, 0) + 1
def process_log_entries(logs): ''' Processes and regroups a list of log entries so they can be rendered and passed to the D3 library to render a chart ''' reps = [] entry_log = SortedDict() chart_data = [] max_weight = {} # Group by date for entry in logs: if entry.reps not in reps: reps.append(entry.reps) if not entry_log.get(entry.date): entry_log[entry.date] = [] entry_log[entry.date].append(entry) # Find the maximum weight per date per repetition. # If on a day there are several entries with the same number of # repetitions, but different weights, only the entry with the # higher weight is shown in the chart if not max_weight.get(entry.date): max_weight[entry.date] = {entry.reps: entry.weight} if not max_weight[entry.date].get(entry.reps): max_weight[entry.date][entry.reps] = entry.weight if entry.weight > max_weight[entry.date][entry.reps]: max_weight[entry.date][entry.reps] = entry.weight # Group by repetitions reps_list = {} for entry in logs: temp = {'date': '%s' % entry.date, 'id': 'workout-log-%s' % entry.id} # Only unique date, rep and weight combinations if reps_list.get('{0}-{1}-{2}'.format(entry.date, entry.reps, entry.weight)): continue else: reps_list['{0}-{1}-{2}'.format(entry.date, entry.reps, entry.weight)] = True # Only add if weight is the maximum for the day if entry.weight != max_weight[entry.date][entry.reps]: continue for rep in reps: if entry.reps == rep: temp[rep] = entry.weight else: # Mark entries without data, this is later filtered out by D3. # We use the string 'n.a' instead of 0 to differentiate actual exercises # where no weight was used. temp[rep] = 'n.a' chart_data.append(temp) return entry_log, json.dumps(chart_data, cls=DecimalJsonEncoder)
def fields_for_model(instance, fields=None, exclude=None, formfield_callback=None): """ Returns a "SortedDict" containing form fields for the given fom_object. ``fields`` is an optional list of field names. If provided, only the named fields will be included in the returned fields. ``exclude`` is an optional list of field names. If provided, the named fields will be excluded from the returned fields, even if they are listed in the ``fields`` argument. """ field_list = [] ignored = [] for f in instance.ordered_fields: if fields and not f in fields: continue if exclude and not f in exclude: continue formfield = formfield_for_model_field(instance, f) if formfield: field_list.append((f, formfield)) field_dict = SortedDict(field_list) if fields: field_dict = SortedDict( [(f, field_dict.get(f)) for f in fields if ((not exclude) or (exclude and f not in exclude))] ) return field_dict
def _policy_list(request, expand_rule, **kwargs): policies = neutronclient(request).list_firewall_policies(**kwargs).get("firewall_policies") if expand_rule: rules = _rule_list(request, expand_policy=False) rule_dict = SortedDict((rule.id, rule) for rule in rules) for p in policies: p["rules"] = [rule_dict.get(rule) for rule in p["firewall_rules"]] return [Policy(p) for p in policies]
def _rule_list(request, expand_policy, **kwargs): rules = neutronclient(request).list_firewall_rules(**kwargs).get("firewall_rules") if expand_policy: policies = _policy_list(request, expand_rule=False) policy_dict = SortedDict((p.id, p) for p in policies) for rule in rules: rule["policy"] = policy_dict.get(rule["firewall_policy_id"]) return [Rule(r) for r in rules]
def _member_list(request, expand_pool, **kwargs): members = neutronclient(request).list_members(**kwargs).get('members') if expand_pool: pools = _pool_list(request) pool_dict = SortedDict((p.id, p) for p in pools) for m in members: m['pool_name'] = pool_dict.get(m['pool_id']).name_or_id return [Member(m) for m in members]
def _firewall_list(request, expand_policy, **kwargs): firewalls = neutronclient(request).list_firewalls(**kwargs).get("firewalls") if expand_policy: policies = _policy_list(request, expand_rule=False) policy_dict = SortedDict((p.id, p) for p in policies) for fw in firewalls: fw["policy"] = policy_dict.get(fw["firewall_policy_id"]) return [Firewall(f) for f in firewalls]
def _get_servers(request): servers = [] image_dict = SortedDict([(img["id"], img)for img in get_images(request)]) zone_dict = SortedDict([(zone.id, zone.name) for zone in get_zones(request)]) gateway_dict = SortedDict([(g.hostname, g.vext_ip) for g in api.proxy.gateway_list(request)]) for server in api.proxy.server_list(request): image = image_dict.get(server.image_id, {}) if zone_dict.has_key(server.zone_id): server.zone_id = zone_dict[server.zone_id] firewall = [(gateway_dict.get(f.hostname), f.gateway_port) for f in api.proxy.firewall_get(request, server.id)] servers.append(server_format(request, server, image, firewall)) return servers
def get_data(self): instances = [] marker = self.request.GET.get( project_tables.AdminInstancesTable._meta.pagination_param, None) try: instances, self._more = api.nova.server_list( self.request, search_opts={'marker': marker, 'paginate': True}, all_tenants=True) except Exception: self._more = False exceptions.handle(self.request, _('Unable to retrieve instance list.')) if instances: try: api.network.servers_update_addresses(self.request, instances) except Exception: exceptions.handle( self.request, message=_('Unable to retrieve IP addresses from Neutron.'), ignore=True) # Gather our flavors to correlate against IDs try: flavors = api.nova.flavor_list(self.request) except Exception: # If fails to retrieve flavor list, creates an empty list. flavors = [] # Gather our tenants to correlate against IDs try: tenants, has_more = api.keystone.tenant_list(self.request) except Exception: tenants = [] msg = _('Unable to retrieve instance project information.') exceptions.handle(self.request, msg) full_flavors = SortedDict([(f.id, f) for f in flavors]) tenant_dict = SortedDict([(t.id, t) for t in tenants]) # Loop through instances to get flavor and tenant info. for inst in instances: flavor_id = inst.flavor["id"] try: if flavor_id in full_flavors: inst.full_flavor = full_flavors[flavor_id] else: # If the flavor_id is not in full_flavors list, # gets it via nova api. inst.full_flavor = api.nova.flavor_get( self.request, flavor_id) except Exception: msg = _('Unable to retrieve instance size information.') exceptions.handle(self.request, msg) tenant = tenant_dict.get(inst.tenant_id, None) inst.tenant_name = getattr(tenant, "name", None) return instances
class AppLayerFinder(BaseFinder): storage_class = LayerStaticStorage def __init__(self, apps=None, *args, **kwargs): layers = getattr(settings, "LAYERS", {}) self.apps = [] self.storages = SortedDict() if apps is None: apps = settings.INSTALLED_APPS for app in apps: for layer in layers.keys(): app_storage = self.storage_class(app, layer) if os.path.isdir(app_storage.location): if app not in self.apps: self.apps.append(app) if app not in self.storages: self.storages[app] = {} self.storages[app][layer] = app_storage super(AppLayerFinder, self).__init__(*args, **kwargs) def find(self, path, all=False, layer=None): """ Looks for files in the app directories. """ matches = [] for app in self.apps: match = self.find_in_app(app, path, layer) if match: if not all: return match matches.append(match) return matches def find_in_app(self, app, path, layer=None): layer = layer or get_active_layer(get_current_request()) storage = self.storages.get(app, {}).get(layer, None) if storage: if layer: if storage.exists(path): matched_path = storage.path(path) if matched_path: return matched_path def list(self, ignore_patterns, layer=None): """ List all files in all app storages. """ if not layer: return for storage in self.storages.itervalues(): layer_storage = storage.get(layer, None) if layer_storage and layer_storage.exists(''): for path in utils.get_files(layer_storage, ignore_patterns): yield path, layer_storage
def fields_for_document(document, fields=None, exclude=None, widgets=None, \ formfield_callback=None, field_generator=MongoDefaultFormFieldGenerator): """ Returns a ``SortedDict`` containing form fields for the given model. ``fields`` is an optional list of field names. If provided, only the named fields will be included in the returned fields. ``exclude`` is an optional list of field names. If provided, the named fields will be excluded from the returned fields, even if they are listed in the ``fields`` argument. """ field_list = [] ignored = [] if isinstance(field_generator, type): field_generator = field_generator() # This is actually a bad way to sort the fields, but the fields keep the order # they were defined on he document (at least with cPython) and I can't see # any other way for now. Oh, yeah, it works because we sort on the memory address # and hope that the earlier fields have a lower address. sorted_fields = sorted(list(document._fields.values()), key=lambda field: field.__hash__()) for f in sorted_fields: if isinstance(f, ObjectIdField): continue if isinstance(f, ListField) and not (hasattr(f.field,'choices') or isinstance(f.field, ReferenceField)): continue if fields is not None and not f.name in fields: continue if exclude and f.name in exclude: continue if widgets and f.name in widgets: kwargs = {'widget': widgets[f.name]} else: kwargs = {} if formfield_callback is None: formfield = field_generator.generate(f, **kwargs) elif not isinstance(formfield_callback, Callable): raise TypeError('formfield_callback must be a function or callable') else: formfield = formfield_callback(f, **kwargs) if formfield: field_list.append((f.name, formfield)) else: ignored.append(f.name) field_dict = SortedDict(field_list) if fields: field_dict = SortedDict( [(f, field_dict.get(f)) for f in fields if ((not exclude) or (exclude and f not in exclude)) and (f not in ignored)] ) return field_dict
def network_list(request, **params): LOG.debug("network_list(): params=%s" % (params)) networks = neutronclient(request).list_networks(**params).get('networks') # Get subnet list to expand subnet info in network list. subnets = subnet_list(request) subnet_dict = SortedDict([(s['id'], s) for s in subnets]) # Expand subnet list from subnet_id to values. for n in networks: n['subnets'] = [subnet_dict.get(s) for s in n.get('subnets', [])] return [Network(n) for n in networks]
def correlate_tenants(request, instances): # Gather our tenants to correlate against IDs try: tenants = api.keystone.tenant_list(request, admin=True) except: tenants = [] msg = _('Unable to retrieve instance tenant information.') exceptions.handle(request, msg) tenant_dict = SortedDict([(t.id, t) for t in tenants]) for inst in instances: tenant = tenant_dict.get(inst.tenant_id, None) inst._apiresource._info['tenant'] = tenant._info inst.tenant = tenant
def correlate_users(request, instances): # Gather our users to correlate against IDs try: users = api.keystone.user_list(request) except: users = [] msg = _('Unable to retrieve instance user information.') exceptions.handle(request, msg) user_dict = SortedDict([(u.id, u) for u in users]) for inst in instances: user = user_dict.get(inst.user_id, None) inst._apiresource._info['user'] = user._info inst.user = user
def _policy_get(request, policy_id, expand_rule): policy = neutronclient(request).show_firewall_policy( policy_id).get('firewall_policy') if expand_rule: policy_rules = policy['firewall_rules'] if policy_rules: rules = _rule_list(request, expand_policy=False, firewall_policy_id=policy_id) rule_dict = SortedDict((rule.id, rule) for rule in rules) policy['rules'] = [rule_dict.get(rule) for rule in policy_rules] else: policy['rules'] = [] return Policy(policy)
def fields_for_model(model, fields=None, exclude=None, widgets=None, formfield_callback=None, localized_fields=None): """ Returns a ``SortedDict`` containing form fields for the given model. ``fields`` is an optional list of field names. If provided, only the named fields will be included in the returned fields. ``exclude`` is an optional list of field names. If provided, the named fields will be excluded from the returned fields, even if they are listed in the ``fields`` argument. ``widgets`` is a dictionary of model field names mapped to a widget ``formfield_callback`` is a callable that takes a model field and returns a form field. """ field_list = [] ignored = [] opts = model._meta for f in sorted(opts.concrete_fields + opts.many_to_many): if not f.editable: continue if fields is not None and not f.name in fields: continue if exclude and f.name in exclude: continue kwargs = {} if widgets and f.name in widgets: kwargs['widget'] = widgets[f.name] if localized_fields == ALL_FIELDS or (localized_fields and f.name in localized_fields): kwargs['localize'] = True if formfield_callback is None: formfield = f.formfield(**kwargs) elif not callable(formfield_callback): raise TypeError('formfield_callback must be a function or callable') else: formfield = formfield_callback(f, **kwargs) if formfield: field_list.append((f.name, formfield)) else: ignored.append(f.name) field_dict = SortedDict(field_list) if fields: field_dict = SortedDict( [(f, field_dict.get(f)) for f in fields if ((not exclude) or (exclude and f not in exclude)) and (f not in ignored)] ) return field_dict
def fields_for_model(model, fields=None, exclude=None, widgets=None, formfield_callback=None): opts = model._meta if not getattr(opts, "enable_composite", False): return original_fields_for_model(model, fields=fields, exclude=fields, widgets=fields, formfield_callback=fields) # todo: maybe is possible don't rewrite all function field_list = [] ignored = [] # hack added composite_foreignkeys_fields for f in sorted(opts.fields + opts.many_to_many + opts.composite_special_fields): if not f.editable: continue if fields is not None and not f.name in fields: continue if exclude and f.name in exclude: continue if widgets and f.name in widgets: kwargs = {'widget': widgets[f.name]} else: kwargs = {} if formfield_callback is None: formfield = f.formfield(**kwargs) elif not callable(formfield_callback): raise TypeError( 'formfield_callback must be a function or callable') else: formfield = formfield_callback(f, **kwargs) if formfield: field_list.append((f.name, formfield)) else: ignored.append(f.name) field_dict = SortedDict(field_list) if fields: field_dict = SortedDict([ (f, field_dict.get(f)) for f in fields if ((not exclude) or (exclude and f not in exclude)) and ( f not in ignored) ]) return field_dict
def process_log_entries(self, logs): ''' Processes and regroups a list of log entries so they can be rendered and passed to the D3 library to render a chart ''' reps = [] entry_log = SortedDict() chart_data = [] max_weight = {} # Group by date for entry in logs: if entry.reps not in reps: reps.append(entry.reps) if not entry_log.get(entry.date): entry_log[entry.date] = [] entry_log[entry.date].append(entry) # Find the maximum weight per date per repetition. # If on a day there are several entries with the same number of # repetitions, but different weights, only the entry with the # higher weight is shown in the chart if not max_weight.get(entry.date): max_weight[entry.date] = {entry.reps: entry.weight} if not max_weight[entry.date].get(entry.reps): max_weight[entry.date][entry.reps] = entry.weight if entry.weight > max_weight[entry.date][entry.reps]: max_weight[entry.date][entry.reps] = entry.weight # Group by repetitions for entry in logs: temp = { 'date': '%s' % entry.date, 'id': 'workout-log-%s' % entry.id } for rep in reps: if entry.reps == rep: # Only add if entry is the maximum for the day if entry.weight == max_weight[entry.date][entry.reps]: temp[rep] = entry.weight else: temp[rep] = 0 chart_data.append(temp) return (entry_log, json.dumps(chart_data, cls=DecimalJsonEncoder))
def correlate_flavors(request, instances): # Gather our flavors to correlate against IDs try: flavors = api.nova.flavor_list(request) except: flavors = [] msg = _('Unable to retrieve instance size information.') exceptions.handle(request, msg) flavors_dict = SortedDict([(f.id, f) for f in flavors]) for inst in instances: flavor = flavors_dict.get(inst.flavor["id"], None) inst._apiresource._info['flavor'] = flavor._info inst.flavor = flavor
def _pool_list(request, expand_subnet=False, expand_vip=False, **kwargs): pools = neutronclient(request).list_pools(**kwargs).get('pools') if expand_subnet: subnets = neutron.subnet_list(request) subnet_dict = SortedDict((s.id, s) for s in subnets) for p in pools: subnet = subnet_dict.get(p['subnet_id']) p['subnet_name'] = subnet.cidr if subnet else None if expand_vip: vips = vip_list(request) vip_dict = SortedDict((v.id, v) for v in vips) for p in pools: p['vip'] = _get_vip(request, p, vip_dict) return [Pool(p) for p in pools]
def _ipsecsiteconnection_list(request, expand_ikepolicies=False, expand_ipsecpolicies=False, expand_vpnservices=False, **kwargs): ipsecsiteconnections = neutronclient(request).list_ipsec_site_connections( **kwargs).get('ipsec_site_connections') if expand_ikepolicies: ikepolicies = _ikepolicy_list(request, **kwargs) policy_dict = SortedDict((p.id, p) for p in ikepolicies) for c in ipsecsiteconnections: c['ikepolicy_name'] = policy_dict.get(c['ikepolicy_id']).name_or_id if expand_ipsecpolicies: ipsecpolicies = _ipsecpolicy_list(request, **kwargs) policy_dict = SortedDict((p.id, p) for p in ipsecpolicies) for c in ipsecsiteconnections: c['ipsecpolicy_name'] = policy_dict.get(c['ipsecpolicy_id'] ).name_or_id if expand_vpnservices: vpnservices = _vpnservice_list(request, **kwargs) service_dict = SortedDict((s.id, s) for s in vpnservices) for c in ipsecsiteconnections: c['vpnservice_name'] = service_dict.get(c['vpnservice_id'] ).name_or_id return [IPSecSiteConnection(v) for v in ipsecsiteconnections]
def get_data(self): instances = [] marker = self.request.GET.get( project_tables.AdminInstancesTable._meta.pagination_param, None) try: instances, self._more = api.nova.server_list(self.request, search_opts={ 'marker': marker, 'paginate': True }, all_tenants=True) except Exception: self._more = False exceptions.handle(self.request, _('Unable to retrieve instance list.')) if instances: # Gather our flavors to correlate against IDs try: flavors = api.nova.flavor_list(self.request) except Exception: # If fails to retrieve flavor list, creates an empty list. flavors = [] # Gather our tenants to correlate against IDs try: tenants, has_more = api.keystone.tenant_list(self.request) except Exception: tenants = [] msg = _('Unable to retrieve instance project information.') exceptions.handle(self.request, msg) full_flavors = SortedDict([(f.id, f) for f in flavors]) tenant_dict = SortedDict([(t.id, t) for t in tenants]) # Loop through instances to get flavor and tenant info. for inst in instances: flavor_id = inst.flavor["id"] try: if flavor_id in full_flavors: inst.full_flavor = full_flavors[flavor_id] else: # If the flavor_id is not in full_flavors list, # gets it via nova api. inst.full_flavor = api.nova.flavor_get( self.request, flavor_id) except Exception: msg = _('Unable to retrieve instance size information.') exceptions.handle(self.request, msg) tenant = tenant_dict.get(inst.tenant_id, None) inst.tenant_name = getattr(tenant, "name", None) return instances
def fields_for_model(model, fields=None, exclude=None, widgets=None, formfield_callback=None): """ Returns a ``SortedDict`` containing form fields for the given model. ``fields`` is an optional list of field names. If provided, only the named fields will be included in the returned fields. ``exclude`` is an optional list of field names. If provided, the named fields will be excluded from the returned fields, even if they are listed in the ``fields`` argument. """ field_list = [] ignored = [] opts = model._meta for f in opts.fields + opts.many_to_many: if not f.editable: continue if fields and not f.name in fields: continue if exclude and f.name in exclude: continue if widgets and f.name in widgets: kwargs = {'widget': widgets[f.name]} else: kwargs = {} if formfield_callback is None: formfield = f.formfield(**kwargs) elif not callable(formfield_callback): raise TypeError( 'formfield_callback must be a function or callable') else: formfield = formfield_callback(f, **kwargs) if formfield: field_list.append((f.name, formfield)) else: ignored.append(f.name) field_dict = SortedDict(field_list) if fields: field_dict = SortedDict([ (f, field_dict.get(f)) for f in fields if ((not exclude) or (exclude and f not in exclude)) and ( f not in ignored) ]) return field_dict
def _vpnservice_list(request, expand_subnet=False, expand_router=False, expand_conns=False, **kwargs): vpnservices = neutronclient(request).list_vpnservices( **kwargs).get('vpnservices') if expand_subnet: subnets = neutron.subnet_list(request) subnet_dict = SortedDict((s.id, s) for s in subnets) for s in vpnservices: s['subnet_name'] = subnet_dict.get(s['subnet_id']).cidr if expand_router: routers = neutron.router_list(request) router_dict = SortedDict((r.id, r) for r in routers) for s in vpnservices: s['router_name'] = router_dict.get(s['router_id']).name_or_id if expand_conns: ipsecsiteconns = _ipsecsiteconnection_list(request, **kwargs) for s in vpnservices: s['ipsecsiteconns'] = [ c.id for c in ipsecsiteconns if c.vpnservice_id == s['id'] ] return [VPNService(v) for v in vpnservices]
def get_data(self, request, volume_id): volume = cinder.volume_get(request, volume_id) try: tenants, has_more = api.keystone.tenant_list(request) except Exception: tenants = [] msg = _('Unable to retrieve volume project information.') exceptions.handle(request, msg) tenant_dict = SortedDict([(t.id, t) for t in tenants]) tenant_id = getattr(volume, "os-vol-tenant-attr:tenant_id", None) tenant = tenant_dict.get(tenant_id, None) volume.tenant_name = getattr(tenant, "name", None) return volume
def list_targets(self): ports = port_list(self.request) servers, has_more = nova.server_list(self.request) server_dict = SortedDict([(s.id, s.name) for s in servers]) targets = [] for p in ports: # Remove network ports from Floating IP targets if p.device_owner.startswith('network:'): continue port_id = p.id server_name = server_dict.get(p.device_id) for ip in p.fixed_ips: target = {'name': '%s: %s' % (server_name, ip['ip_address']), 'id': '%s_%s' % (port_id, ip['ip_address'])} targets.append(FloatingIpTarget(target)) return targets
def get_data(self, request, snapshot_id): snapshot = cinder.volume_snapshot_get(request, snapshot_id) snapshot._volume = cinder.volume_get(request, snapshot.volume_id) try: tenants, has_more = api.keystone.tenant_list(request) except Exception: tenants = [] msg = _('Unable to retrieve volume project information.') tenant_dict = SortedDict([(t.id, t) for t in tenants]) tenant_id = getattr(snapshot, "os-extended-snapshot-attributes:project_id", None) tenant = tenant_dict.get(tenant_id, None) snapshot.tenant_name = getattr(tenant, "name", None) return snapshot
def faceted_filters(self): url = QueryURLObject(self.url) filter_mapping = SortedDict( (filter_['slug'], filter_) for filter_ in self.serialized_filters) filter_groups = SortedDict() for slug, facet in self.facet_counts().items(): # if not isinstance(facet, dict): # # let's just blankly ignore any non-filter or non-query filters # continue filter_ = filter_mapping.get(slug, None) if filter_ is None: filter_name = slug group_name = None group_slug = None else: # Let's check if we can get the name from the gettext catalog filter_name = _(filter_['name']) group_name = _(filter_['group']['name']) group_slug = filter_['group']['slug'] filter_groups.setdefault( (group_name, group_slug, filter_['group']['order']), []).append( Filter(url=url, page=self.current_page, name=filter_name, slug=slug, count=facet['count'], active=slug in self.selected_filters, group_name=group_name, group_slug=group_slug)) # return a sorted list of filters here grouped_filters = [] for group_options, filters in filter_groups.items(): group_name, group_slug, group_order = group_options sorted_filters = sorted(filters, key=attrgetter('name')) grouped_filters.append( FilterGroup(name=group_name, slug=group_slug, order=group_order, options=sorted_filters)) return sorted(grouped_filters, key=attrgetter('order'), reverse=True)
def filters_for_model(model, fields=None, exclude=None, filter_for_field=None): field_list = [] opts = model._meta for f in sorted(opts.fields + opts.many_to_many): if fields is not None and f.name not in fields: continue if exclude is not None and f.name in exclude: continue filter_ = filter_for_field(f, f.name) if filter_: field_list.append((f.name, filter_)) field_dict = SortedDict(field_list) if fields: field_dict = SortedDict([ (f, field_dict.get(f)) for f in fields if (not exclude) or (exclude and f not in exclude) ]) return field_dict
def group(queryset, expression): ''' Similar to regroup, but without restrict respect order Usage: {% group people 'gender' as grouped %} ''' key = attrgetter(expression) group = SortedDict() for item in queryset: try: k = key(item) except AttributeError: k = None group[k] = group.get(k, []) + [item] return group
def list(self, all_tenants=False, **search_opts): if not all_tenants: tenant_id = self.request.user.tenant_id # In Neutron, list_floatingips returns Floating IPs from # all tenants when the API is called with admin role, so # we need to filter them with tenant_id. search_opts['tenant_id'] = tenant_id port_search_opts = {'tenant_id': tenant_id} else: port_search_opts = {} fips = self.client.list_floatingips(**search_opts) fips = fips.get('floatingips') # Get port list to add instance_id to floating IP list # instance_id is stored in device_id attribute ports = port_list(self.request, **port_search_opts) port_dict = SortedDict([(p['id'], p) for p in ports]) for fip in fips: self._set_instance_info(fip, port_dict.get(fip['port_id'])) return [FloatingIp(fip) for fip in fips]
def ensure_attachment_server(request, volumes): instances, has_more = api.nova.server_list( request, search_opts=None, all_tenants=request.GET.get('all_tenants', False), ) instance_dict = SortedDict([(i.id, i) for i in instances]) for item in volumes: if not item['attachments']: continue for i, atmt in enumerate(item['attachments']): instance = instance_dict.get(atmt.get('server_id'), None) if instance: instance_name = {'instance_name': instance.name} item['attachments'][i].update(instance_name) if item.get('name') == '': item.update({'name': instance.name}) return volumes
def _get_servers(request): try: instances, has_more = api.nova.server_list(request) except Exception: instances = [] exceptions.handle(request, _('Unable to retrieve instances.')) servers = [] if instances: try: images, more, prev = api.glance.image_list_detailed(request) except Exception: images = [] exceptions.handle(request, ignore=True) try: gateways = api.daolicloud.gateway_list(request) except Exception: gateways = [] exceptions.handle(request, ignore=True) image_map = SortedDict([(str(image.id), image) for image in images]) gateway_map = SortedDict([(gateway.hostname, gateway.vext_ip) for gateway in gateways]) for instance in instances: if hasattr(instance, 'image'): if isinstance(instance.image, dict): if instance.image.get('id') in image_map: instance.image = image_map[instance.image['id']] instance.full_firewalls = [firewall.to_dict() for firewall in api.daolicloud.firewall_get(request, instance.id)] for firewall in instance.full_firewalls: firewall['gateway_ip'] = gateway_map.get(firewall['hostname']) servers.append(server_format(request, instance)) return servers
def get_data(self): instances = [] try: instances = api.nova.server_list(self.request, all_tenants=True) except: exceptions.handle(self.request, _('Unable to retrieve instance list.')) if instances: # Gather our flavors to correlate against IDs try: flavors = api.nova.flavor_list(self.request) except: # If fails to retrieve flavor list, creates an empty list. flavors = [] # Gather our tenants to correlate against IDs try: tenants = api.keystone.tenant_list(self.request, admin=True) except: tenants = [] msg = _('Unable to retrieve instance tenant information.') exceptions.handle(self.request, msg) full_flavors = SortedDict([(f.id, f) for f in flavors]) tenant_dict = SortedDict([(t.id, t) for t in tenants]) # Loop through instances to get flavor and tenant info. for inst in instances: flavor_id = inst.flavor["id"] try: if flavor_id in full_flavors: inst.full_flavor = full_flavors[flavor_id] else: # If the flavor_id is not in full_flavors list, # gets it via nova api. inst.full_flavor = api.nova.flavor_get( self.request, flavor_id) except: msg = _('Unable to retrieve instance size information.') exceptions.handle(self.request, msg) tenant = tenant_dict.get(inst.tenant_id, None) inst.tenant_name = getattr(tenant, "name", None) return instances
def get_volumes_total(self): self._prev = False volumes = self._get_volumes() instances = self._get_instances() self._set_attachments_string(volumes, instances) try: tenants, has_more = keystone.tenant_list(self.request) except Exception: tenants = [] msg = _('Unable to retrieve volume project information.') exceptions.handle(self.request, msg) tenant_dict = SortedDict([(t.id, t) for t in tenants]) for volume in volumes: tenant_id = getattr(volume, "os-vol-tenant-attr:tenant_id", None) tenant = tenant_dict.get(tenant_id, None) volume.tenant_name = getattr(tenant, "name", None) return volumes
def get_volumes_data(self): volumes = self._get_volumes(search_opts={'all_tenants': True}) instances = self._get_instances(search_opts={'all_tenants': True}) self._set_attachments_string(volumes, instances) # Gather our tenants to correlate against IDs try: tenants, has_more = keystone.tenant_list(self.request) except Exception: tenants = [] msg = _('Unable to retrieve volume project information.') exceptions.handle(self.request, msg) tenant_dict = SortedDict([(t.id, t) for t in tenants]) for volume in volumes: tenant_id = getattr(volume, "os-vol-tenant-attr:tenant_id", None) tenant = tenant_dict.get(tenant_id, None) volume.tenant_name = getattr(tenant, "name", None) return volumes
def player_list(request): '''角色信息排序 ''' page_size = 100 page_num = int(request.REQUEST.get("page_num", "1")) is_block = int(request.REQUEST.get("block", 0)) group_id = int(request.REQUEST.get("group_id", 0)) server_id = int(request.REQUEST.get("server_id", "0")) sort_keys = [ x for x in request.REQUEST.get('sort_keys', '').split(',') if x ] #排序key顺勋 country_code = int(request.REQUEST.get('nat', '-1') or -1) total_record = 0 ths = ["pi", "pn", "plv", "vip", "nat", "of", "pc", "olt"] _sort_condition = [] condition_map = SortedDict([(t, PLAYER_INFO_MAP.get(t, {}).get('name', '')) for t in ths]) condition_country = {"nat": country_code} if country_code != -999 else {} for k in sort_keys: if condition_map.get(k, ''): _v = request.POST.get(k, '') _sort_condition.append((k, int(_v))) if server_id: try: server = Server.objects.get(id=server_id) db_name, mongo_conn = server.get_mongo_conn() total_record = mongo_conn[db_name].tk.player.find( condition_country).count() if page_num < 1: page_num = 1 offset = (page_num - 1) * page_size if not _sort_condition: _sort_condition = [("olt", -1)] #默认最后登录时间 _list = mongo_conn[db_name].tk.player.find(condition_country).sort( _sort_condition).skip(offset).limit(page_size) player_list = player_list_handle(ths, _list) mongo_conn.close() except Exception, e: traceback.print_exc() err_msg = str(e)
def get_floating_ips_list(request, tenant_id): """ :param request:request object,tenant_id :return:view<'virtual_address_manage/floatingIpsIndex.html'>::list of floatingIp """ args = {} floating_ips = [] floating_pool = {} floatingips = [] try: if None != switch_tenants(request, tenant_id): floating_ips = api.network.tenant_floating_ip_list(request) floating_pools = api.network.floating_ip_pools_list(request) floating_pool = SortedDict([(pool.id, pool.name) for pool in floating_pools]) for floating_ip in floating_ips: if tenant_id == floating_ip.tenant_id: floating_ip._apidict['pool'] = floating_pool.get( floating_ip.pool, get_text("invalid ip pool")) floatingips.append(floating_ip) instances = [] tenant_quota = api.nova.nova_tenant_quota_get(request, tenant_id) for item in tenant_quota: if item.name == "floating_ips": ip_num = item.limit servers = api.server_list(request) for server in servers: # to be removed when nova can support unique names server_name = server.name if any(s.id != server.id and s.name == server.name for s in servers): # duplicate instance name server_name = "%s [%s]" % (server.name, server.id) instances.append((server.id, server_name)) except Unauthorized: raise except Exception, exe: LOG.exception("ClientException in floating ip index,the error is %s " % exe.message)
def get_inline_instances(self, request, obj=None): inline_instances = [] if obj and obj.pk: variables = get_variables_from_template(obj.template.path).items() types = SortedDict() for label, variable in variables: model_class = variable['type'] initial_field_values = variable['initial_field_values'] types[model_class] = types.get(model_class, 0) # can't use defaultdict :( types[model_class] += 1 model_class.objects.get_or_create( text_ng=obj, label=label, defaults=initial_field_values) for model_class in types.keys(): inline = self.get_inline_for_model(model_class) inline.max_num = types[model_class] inline_instance = inline(self.model, self.admin_site) inline_instances.append(inline_instance) return inline_instances
def get(request, instance_id): instance = api.nova.server_get(request, instance_id) try: gateways = api.daolicloud.gateway_list(request) except Exception: gateways = [] exceptions.handle(request, ignore=True) instance.image = api.glance.image_get(request, instance.image['id']) gateway_map = SortedDict([(gateway.hostname, gateway.vext_ip) for gateway in gateways]) instance.full_firewalls = [firewall.to_dict() for firewall in api.daolicloud.firewall_get(request, instance.id)] for firewall in instance.full_firewalls: firewall['gateway_ip'] = gateway_map.get(firewall['hostname']) return HttpResponse(json.dumps(server_format(request, instance)), content_type='application/json')
def list_targets(self): tenant_id = self.request.user.tenant_id ports = port_list(self.request, tenant_id=tenant_id) servers, has_more = nova.server_list(self.request) server_dict = SortedDict([(s.id, s.name) for s in servers]) reachable_subnets = self._get_reachable_subnets(ports) targets = [] for p in ports: # Remove network ports from Floating IP targets if p.device_owner.startswith('network:'): continue port_id = p.id server_name = server_dict.get(p.device_id) for ip in p.fixed_ips: if ip['subnet_id'] not in reachable_subnets: continue target = {'name': '%s: %s' % (server_name, ip['ip_address']), 'id': '%s_%s' % (port_id, ip['ip_address']), 'instance_id': p.device_id} targets.append(FloatingIpTarget(target)) return targets
def get_data(self): tenants = api.keystone.tenant_list(self.request) tenants_dict = SortedDict([t.name, t] for t in tenants) admin_tenant = tenants_dict.get("admin", None) users_list = api.keystone.user_list(self.request, admin_tenant.id) if self.request.user.username != "admin": users_list = [ user for user in users_list if user.id == self.request.user.id ] result = [] for user in users_list: user = { "id": user.id, "name": user.name, } result.append(user) LOG.info("Users list is %s" % str(result)) return result