def current_machines(cls, request_user): # Showing non-end dated, public ApplicationVersions public_set = ApplicationVersion.objects.filter( only_current(), only_current_machines_in_version(), application__private=False) if not isinstance(request_user, AnonymousUser): # NOTE: Showing 'my pms EVEN if they are end-dated. my_set = ApplicationVersion.objects.filter( Q(created_by=request_user) | Q(application__created_by=request_user) | Q(machines__instance_source__created_by=request_user)) all_group_ids = request_user.memberships.values('group__id') # FIXME: This call can be slow/hang when _large_ number of users # (100/1000s) are included. To address this: query the # *Membership table(s) directly and select values. # Showing non-end dated, shared ApplicationVersions shared_set = ApplicationVersion.objects.filter( only_current(), only_current_machines_in_version(), Q( membership=all_group_ids) | Q( machines__members__in=all_group_ids)) if request_user.is_staff: admin_set = cls.get_admin_image_versions(request_user) else: admin_set = ApplicationVersion.objects.none() else: admin_set = shared_set = my_set = ApplicationVersion.objects.none() # Make sure no dupes. all_versions = (public_set | shared_set | my_set | admin_set).distinct() return all_versions
def current_machines(cls, request_user): # Showing non-end dated, public ApplicationVersions public_set = ApplicationVersion.objects.filter( only_current(), only_current_machines_in_version(), application__private=False) if not isinstance(request_user, AnonymousUser): # NOTE: Showing 'my pms EVEN if they are end-dated. my_set = ApplicationVersion.objects.filter( Q(created_by=request_user) | Q(application__created_by=request_user) | Q(machines__instance_source__created_by=request_user)) all_group_ids = request_user.group_set.values('id') # Showing non-end dated, shared ApplicationVersions shared_set = ApplicationVersion.objects.filter( only_current(), only_current_machines_in_version(), Q(membership=all_group_ids) | Q(machines__members__in=all_group_ids)) if request_user.is_staff: admin_set = cls.get_admin_image_versions(request_user) else: admin_set = ApplicationVersion.objects.none() else: admin_set = shared_set = my_set = ApplicationVersion.objects.none() # Make sure no dupes. all_versions = (public_set | shared_set | my_set | admin_set).distinct() return all_versions
def get_queryset(self): """ Filter projects by current user """ request_user = self.request.user # Switch based on user's ClassType if isinstance(request_user, AnonymousUser): provider_ids = Provider.objects.filter(only_current(), active=True).values_list('id',flat=True) else: try: group = Group.objects.get(name=request_user.username) except Group.DoesNotExist: return Size.objects.none() provider_ids = group.identities.filter( only_current_provider(), provider__active=True).values_list('provider', flat=True) # Switch based on query if 'archived' in self.request.query_params: filtered_sizes = Size.objects.filter( provider__id__in=provider_ids) else: filtered_sizes = Size.objects.filter( only_current(), provider__id__in=provider_ids) return filtered_sizes.filter(~Q(alias='N/A'))
def current_machines(cls, request_user): # Showing non-end dated, public ApplicationVersions public_set = ApplicationVersion.objects.filter( only_current(), only_current_machines_in_version(), application__private=False) if not isinstance(request_user, AnonymousUser): # NOTE: Showing 'my pms EVEN if they are end-dated. my_set = ApplicationVersion.objects.filter( Q(created_by=request_user) | Q(application__created_by=request_user) | Q(machines__instance_source__created_by=request_user)) all_group_ids = request_user.memberships.values('group__id') # FIXME: This call can be slow/hang when _large_ number of users # (100/1000s) are included. To address this: query the # *Membership table(s) directly and select values. # Showing non-end dated, shared ApplicationVersions shared_set = ApplicationVersion.objects.filter( only_current(), only_current_machines_in_version(), Q(membership=all_group_ids) | Q(machines__members__in=all_group_ids)) if request_user.is_staff: admin_set = cls.get_admin_image_versions(request_user) else: admin_set = ApplicationVersion.objects.none() else: admin_set = shared_set = my_set = ApplicationVersion.objects.none() # Make sure no dupes. all_versions = (public_set | shared_set | my_set | admin_set).distinct() return all_versions
def main(): parser = argparse.ArgumentParser() parser.add_argument("--host", help="The OpenStack compute node to launch" " instances on.") parser.add_argument("--name", help="The OpenStack compute node to launch" " instances on.") parser.add_argument("--provider-list", action="store_true", help="List of provider names and IDs") parser.add_argument("--provider-id", type=int, help="Atmosphere provider" " to use when launching instances.") parser.add_argument( "--machine-alias", help="Atmosphere machine alias," " or list of machine_alias separated by comma," " to use when launching instances.", ) parser.add_argument( "--machine-list", action="store_true", help="Return a list of machines" " ordered by most launched instances" " that have reached active state.", ) parser.add_argument("--size", help="Atmosphere size to use when" " launching instances.") parser.add_argument("--size-list", action="store_true", help="List of size names and IDs") parser.add_argument("--skip-deploy", action="store_true", help="Don't run Atmosphere's deploy.") parser.add_argument("--count", default=1, type=int, help="Number of instances to launch.") parser.add_argument("--users", help="Atmosphere usernames to launch with, in a comma-separated-list.") args = parser.parse_args() if args.provider_list: handle_provider_list() if not args.provider_id: sys.exit(0) handle_provider(args) provider = Provider.objects.get(id=args.provider_id) if args.machine_list: print_most_used(provider) sys.exit(1) if args.size_list: print "ID\tName\tCPU\tMemory" for s in Size.objects.filter(only_current(), provider=provider).order_by("id"): print "%s\t%s\t%d\t%d" % (s.id, s.name, s.cpu, s.mem) sys.exit(0) handle_size(args, provider) try: size_id = int(args.size) query = Q(id=size_id) except ValueError: # Happens when type == str query = Q(name=args.size) size = Size.objects.get(query, only_current(), provider=provider) machines = handle_machine(args, provider) user_list = args.users.split(",") for idx, username in enumerate(user_list): try: if idx != 0: print "Sleep 30 seconds" time.sleep(30) print "Awake, ready to launch" launch_instance_for_user(args, machines, size, provider, username) except Exception as e: print "Instance launch *FAILED*: %s" % e traceback.print_exc(file=sys.stdout)
def current_machines(cls, request_user): # Showing non-end dated, public ApplicationVersions public_set = ApplicationVersion.objects.filter( only_current(), only_current_machines_in_version(), application__private=False) if not isinstance(request_user, AnonymousUser): # NOTE: Showing 'my pms EVEN if they are end-dated. my_set = ApplicationVersion.objects.filter( Q(created_by=request_user) | Q(application__created_by=request_user) | Q(machines__instance_source__created_by=request_user)) all_group_ids = request_user.group_set.values('id') # Showing non-end dated, shared ApplicationVersions shared_set = ApplicationVersion.objects.filter( only_current(), only_current_machines_in_version(), Q( membership=all_group_ids) | Q( machines__members__in=all_group_ids)) if request_user.is_staff: admin_set = cls.get_admin_image_versions(request_user) else: admin_set = ApplicationVersion.objects.none() else: admin_set = shared_set = my_set = ApplicationVersion.objects.none() # Make sure no dupes. all_versions = (public_set | shared_set | my_set | admin_set).distinct() return all_versions
def monitor_sizes_for(provider_id, print_logs=False): """ Run the set of tasks related to monitoring sizes for a provider. Optionally, provide a list of usernames to monitor While debugging, print_logs=True can be very helpful. start_date and end_date allow you to search a 'non-standard' window of time. """ from service.driver import get_admin_driver if print_logs: import logging import sys consolehandler = logging.StreamHandler(sys.stdout) consolehandler.setLevel(logging.DEBUG) celery_logger.addHandler(consolehandler) provider = Provider.objects.get(id=provider_id) admin_driver = get_admin_driver(provider) # Non-End dated sizes on this provider db_sizes = Size.objects.filter(only_current(), provider=provider) all_sizes = admin_driver.list_sizes() seen_sizes = [] for cloud_size in all_sizes: core_size = convert_esh_size(cloud_size, provider.uuid) seen_sizes.append(core_size) now_time = timezone.now() needs_end_date = [size for size in db_sizes if size not in seen_sizes] for size in needs_end_date: celery_logger.debug("End dating inactive size: %s" % size) size.end_date = now_time size.save() if print_logs: celery_logger.removeHandler(consolehandler)
def get_queryset(self): """ Filter projects by current user. """ user = self.request.user return Project.objects.filter(only_current(), owner__name=user.username)
def get_queryset(self): """ Filter providers by current user """ user = self.request.user # Anonymous access: Show ONLY the providers that are: # publically available, active, and non-end dated if (type(user) == AnonymousUser): return Provider.objects.filter( only_current(), active=True, public=True) method = self.request.method admin_qs = Provider.objects.filter(cloud_admin=user) # User modify/create/delete queryset: if method in ['DELETE', 'PUT', 'POST']: return admin_qs # User get queryset: Show *shared* + *admin* try: group = Group.objects.get(name=user.username) provider_ids = group.identities.filter( only_current_provider(), provider__active=True).values_list('provider', flat=True) shared_qs = Provider.objects.filter(id__in=provider_ids) except Group.DoesNotExist: shared_qs = Provider.objects.none() queryset = shared_qs | admin_qs return queryset
def get(self, request, project_uuid): user = request.user group = get_user_group(user.username) project = get_group_project(group, project_uuid) if not project: return Response( "Project with ID=%s does not " "exist" % project_uuid, status=status.HTTP_400_BAD_REQUEST ) instances = project.instances.filter( only_current(), provider_machine__provider__active=True ) active_provider_uuids = [ap.uuid for ap in Provider.get_active()] instances = instances.filter( pk__in=[ i.id for i in instances if i.instance.provider_uuid() in active_provider_uuids ] ) serialized_data = InstanceSerializer( instances, many=True, context={ "request": request } ).data response = Response(serialized_data) return response
def main(args): users = User.objects.filter(username__in=args.users.split(",")) try: provider = Provider.objects.get(id=args.provider_id) except Provider.DoesNotExist: print("A provider for id=%s could not be found" % args.provider_id) sys.exit(1) async_request_list = [] for user in users: identity = Identity.objects.get(created_by=user, provider=provider) user_tokens = Token.objects.filter(user=user).order_by('-issuedTime') if user_tokens.count() == 0: print("No tokens for user: "******". No instances will launch on their account.") continue latest_token = user_tokens[0] headers = { 'Authorization': 'Token ' + latest_token.key } instances = Instance.objects.filter(only_current(), created_by=user, name=args.name) for instance in instances: launch_url = settings.SERVER_URL + "/api/v1/provider/" + provider.uuid + "/identity/" + identity.uuid + "/instance/" + instance.provider_alias job = gevent.spawn(delete_instance, launch_url, headers, provider, user) async_request_list.append(job) print "Sending requests to Atmosphere..." gevent.joinall(async_request_list) print "Script finished running successfully!"
def get_available_providers(): from core.models.provider import Provider from core.query import only_current available_providers = Provider.objects.filter(only_current(), public=True, active=True).order_by('id') return available_providers
def search(cls, query, identity=None): if identity: base_apps = Application.objects.filter( # Privately owned OR public machines Q(private=True, providermachine__created_by_identity=identity) | Q(private=False, providermachine__instance_source__provider=identity.provider)) else: active_providers = Provider.get_active() base_apps = Application.objects.filter( # Public machines private=False, #Providermachine's provider is active providermachine__instance_source__provider__in=active_providers) # AND query matches on: query_match = base_apps.filter( # app tag name Q(tags__name__icontains=query) # OR app tag desc | Q(tags__description__icontains=query) # OR app name | Q(name__icontains=query) # OR app desc | Q(description__icontains=query), only_current()) return query_match.distinct()
def monitor_sizes_for(provider_id, print_logs=False): """ Run the set of tasks related to monitoring sizes for a provider. Optionally, provide a list of usernames to monitor While debugging, print_logs=True can be very helpful. start_date and end_date allow you to search a 'non-standard' window of time. """ from service.driver import get_admin_driver if print_logs: console_handler = _init_stdout_logging() provider = Provider.objects.get(id=provider_id) admin_driver = get_admin_driver(provider) # Non-End dated sizes on this provider db_sizes = Size.objects.filter(only_current(), provider=provider) all_sizes = admin_driver.list_sizes() seen_sizes = [] for cloud_size in all_sizes: core_size = convert_esh_size(cloud_size, provider.uuid) seen_sizes.append(core_size) now_time = timezone.now() needs_end_date = [size for size in db_sizes if size not in seen_sizes] for size in needs_end_date: celery_logger.debug("End dating inactive size: %s" % size) size.end_date = now_time size.save() if print_logs: _exit_stdout_logging(console_handler)
def get_queryset(self): now_time = timezone.now() return super( ActiveInstancesManager, self) .get_queryset().filter( only_current(), self._source_in_range(now_time) & self._active_provider(now_time))
def get_queryset(self): """ Filter projects by current user. """ user = self.request.user return Project.objects.filter(only_current(), owner__name=user.username)
def search(cls, query, identity=None): if identity: base_apps = Application.objects.filter( # Privately owned OR public machines Q(private=True, providermachine__created_by_identity=identity) | Q(private=False, providermachine__provider=identity.provider) ) else: active_providers = Provider.get_active() base_apps = Application.objects.filter( # Public machines private=False, #Providermachine's provider is active providermachine__provider__in=active_providers) # AND query matches on: query_match = base_apps.filter( # app tag name Q(tags__name__icontains=query) # OR app tag desc | Q(tags__description__icontains=query) # OR app name | Q(name__icontains=query) # OR app desc | Q(description__icontains=query), only_current()) return query_match.distinct()
def get_user_instances(self, atmo_user): return [InstanceSerializer( item, context={'request': self.context.get('request')}).data for item in atmo_user.instance_set.filter(only_current(), source__provider__active=True, projects=None)]
def get_user_instances(self, atmo_user): return [InstanceSerializer( item, context={'request': self.context.get('request')}).data for item in atmo_user.instance_set.filter(only_current(), source__provider__active=True, projects=None)]
def get_user_applications(self, project): return [ ApplicationSerializer(item, context={ 'request': self.context.get('request') }).data for item in project.applications.filter(only_current()) ]
def get_queryset(self): """ Filter projects by current user. """ user = self.request.user if 'archived' in self.request.QUERY_PARAMS: return Instance.objects.filter(created_by=user) return Instance.objects.filter(only_current(), created_by=user)
def get(self, request): user = request.user instances = user.instance_set.filter( only_current(), source__provider_machine__provider__active=True, projects=None ) serialized_data = InstanceSerializer(instances, many=True, context={"request": request}).data response = Response(serialized_data) return response
def get_queryset(self): """ Filter projects by current user """ user = self.request.user group = Group.objects.get(name=user.username) provider_ids = group.identities.filter(only_current_provider(), provider__active=True).values_list('provider', flat=True) return Size.objects.filter(only_current(), provider__id__in=provider_ids)
def get_available_provider(): from core.models.provider import Provider from core.query import only_current available_providers = Provider.objects.filter(only_current(), active=True).order_by('id') if not available_providers.count(): return None # Strategy, for now, is to just pick the first one. return available_providers[0]
def get(self, request): """ """ user = request.user volumes = user.volume_set().filter(only_current(), provider__active=True, projects=None) serialized_data = VolumeSerializer(volumes, many=True, context={"request":request}).data response = Response(serialized_data) return response
def get(self, request): user = request.user applications = user.application_set.filter( only_current(), projects=None) serialized_data = ApplicationSerializer( applications, many=True, context={"request": request}).data response = Response(serialized_data) return response
def get_queryset(self): """ Filter projects by current user """ request_user = self.request.user # Switch based on user's ClassType if isinstance(request_user, AnonymousUser): providers = Provider.objects.filter(only_current(), active=True) else: providers = request_user.current_providers # Switch based on query if 'archived' in self.request.query_params: filtered_sizes = Size.objects.filter(provider__in=providers) else: filtered_sizes = Size.objects.filter(only_current(), provider__in=providers) return filtered_sizes.filter(~Q(alias='N/A'))
def get(self, request): user = request.user applications = user.application_set.filter( only_current(), projects=None) serialized_data = ApplicationSerializer( applications, many=True, context={"request": request}).data response = Response(serialized_data) return response
def _current_versions(self): """ Return a list of current application versions. NOTE: Defined as: * The ApplicationVersion has not exceeded its end_date """ version_set = self.all_versions active_versions = version_set.filter(only_current()) return active_versions
def admin_apps(cls, user): """ Just give staff the ability to launch everything that isn't end-dated. """ provider_ids = user.provider_ids() admin_images = Application.objects.filter( only_current(), versions__machines__instance_source__provider__id__in=provider_ids) return admin_images
def admin_apps(cls, user): """ Just give staff the ability to launch everything that isn't end-dated. """ provider_ids = user.provider_ids() admin_images = Application.objects.filter( only_current(), versions__machines__instance_source__provider__id__in=provider_ids) return admin_images
def get_queryset(self): """ Filter projects by current user. """ user = self.request.user qs = Instance.for_user(user) if 'archived' in self.request.query_params: return qs return qs.filter(only_current())
def get_queryset(self): """ Filter projects by current user. """ user = self.request.user identity_ids = user.current_identities.values_list('id',flat=True) qs = Instance.objects.filter(created_by_identity__in=identity_ids) if 'archived' in self.request.query_params: return qs return qs.filter(only_current())
def _get_providers(username, selected_provider=None): from core.models import Provider user = AtmosphereUser.objects.get(username=username) public_providers = Provider.objects.filter(only_current(), active=True, public=True) providers = user.current_providers.filter(only_current(), active=True) if not providers: providers = public_providers else: providers |= public_providers if selected_provider and providers and selected_provider not in providers: logger.error( "The provider %s is NOT in the list of currently active providers. Account will not be created" % selected_provider) return (user, providers.none()) return (user, providers)
def get(self, request, project_uuid): user = request.user group = get_user_group(user.username) project = get_group_project(group, project_uuid) if not project: return Response("Project with ID=%s does not " "exist" % project_uuid, status=status.HTTP_400_BAD_REQUEST) volumes = project.volumes.filter(only_current(), provider__active=True) serialized_data = VolumeSerializer(volumes, many=True, context={"request": request}).data response = Response(serialized_data) return response
def _current_source_query_args(cls): now_time = timezone.now() query_args = ( # 1. Provider non-end-dated Q(provider__end_date=None) | Q(provider__end_date__gt=now_time), # 2. Source non-end-dated only_current(now_time), # 3. (Seperately) Provider is active Q(provider__active=True)) return query_args
def get(self, request): user = request.user volumes = user.volume_set()\ .filter(only_current(), provider__active=True, projects=None) serialized_data = VolumeSerializer(volumes, many=True, context={"request": request}).data response = Response(serialized_data) return response
def get_queryset(self): """ Filter projects by current user """ request_user = self.request.user # Switch based on user's ClassType if isinstance(request_user, AnonymousUser): providers = Provider.objects.filter(only_current(), active=True) else: providers = request_user.current_providers # Switch based on query if 'archived' in self.request.query_params: filtered_sizes = Size.objects.filter(provider__in=providers) else: filtered_sizes = Size.objects.filter( only_current(), provider__in=providers ) return filtered_sizes.filter(~Q(alias='N/A'))
def get_queryset(self): """ Filter projects by current user. """ user = self.request.user group_names = user.memberships.values_list('group__name', flat=True) qs = Project.objects.filter(only_current(), owner__name__in=group_names) qs = qs.select_related('owner')\ .prefetch_related('applications', 'instances', 'volumes', 'links') return qs
def _current_versions(self): """ Return a list of current application versions. NOTE: Defined as: * The ApplicationVersion has not exceeded its end_date """ version_set = self.all_versions active_versions = version_set.filter( only_current()) return active_versions
def get_queryset(self): """ Filter projects by current user. """ user = self.request.user identity_ids = user.current_identities.values_list('id',flat=True) qs = Instance.objects.filter(created_by_identity__in=identity_ids) if 'archived' in self.request.query_params: return qs return qs.filter(only_current())
def monitor_sizes_for(provider_id, print_logs=False): """ Run the set of tasks related to monitoring sizes for a provider. Optionally, provide a list of usernames to monitor While debugging, print_logs=True can be very helpful. start_date and end_date allow you to search a 'non-standard' window of time. """ from service.driver import get_admin_driver if print_logs: console_handler = _init_stdout_logging() provider = Provider.objects.get(id=provider_id) admin_driver = get_admin_driver(provider) # Non-End dated sizes on this provider db_sizes = Size.objects.filter(only_current(), provider=provider) all_sizes = admin_driver.list_sizes() seen_sizes = [] for cloud_size in all_sizes: core_size = convert_esh_size(cloud_size, provider.uuid) seen_sizes.append(core_size) now_time = timezone.now() needs_end_date = [size for size in db_sizes if size not in seen_sizes] for size in needs_end_date: celery_logger.debug("End dating inactive size: %s" % size) size.end_date = now_time size.save() # Find home for 'Unknown Size' unknown_sizes = Size.objects.filter( provider=provider, name__contains='Unknown Size' ) for size in unknown_sizes: # Lookup sizes may not show up in 'list_sizes' if size.alias == 'N/A': continue # This is a sentinal value added for a separate purpose. try: libcloud_size = admin_driver.get_size( size.alias, forced_lookup=True ) except BaseHTTPError as error: if error.code == 404: # The size may have been truly deleted continue if not libcloud_size: continue cloud_size = OSSize(libcloud_size) core_size = convert_esh_size(cloud_size, provider.uuid) if print_logs: _exit_stdout_logging(console_handler) for size in seen_sizes: size.esh = None return seen_sizes
def handle_size(args, provider): if args.size_list: print "ID\tName\tCPU\tMemory" for s in Size.objects.filter(only_current(), provider=provider).order_by('id'): print "%s\t%s\t%d\t%d" % (s.id, s.name, s.cpu, s.mem) sys.exit(0) if not args.size_id: print "Error: size-id is required. To get a list of sizes"\ " use --size-list." sys.exit(1)
def get_queryset(self): """ Filter projects by current user """ user = self.request.user group = Group.objects.get(name=user.username) provider_ids = group.identities.filter( only_current_provider(), provider__active=True).values_list('provider', flat=True) return Size.objects.filter(only_current(), provider__id__in=provider_ids)
def _current_source_query_args(cls): now_time = timezone.now() query_args = ( # 1. Provider non-end-dated Q(provider__end_date=None) | Q(provider__end_date__gt=now_time), # 2. Source non-end-dated only_current(now_time), # 3. (Seperately) Provider is active Q(provider__active=True)) return query_args
def get(self, request): user = request.user instances = user.instance_set.filter( only_current(), source__provider_machine__provider__active=True, projects=None) serialized_data = InstanceSerializer( instances, many=True, context={"request": request}).data response = Response(serialized_data) return response
def _get_providers(username, selected_provider=None): from core.models import Provider user = AtmosphereUser.objects.get(username=username) public_providers = Provider.objects.filter( only_current(), active=True, public=True ) providers = user.current_providers.filter(only_current(), active=True) if not providers: providers = public_providers else: providers |= public_providers if selected_provider and providers and selected_provider not in providers: logger.error( "The provider %s is NOT in the list of currently active providers. Account will not be created" % selected_provider ) return (user, providers.none()) return (user, providers)
def get_queryset(self): """ Filter projects by current user. """ user = self.request.user group_names = user.memberships.values_list('group__name', flat=True) qs = Project.objects.filter(only_current(), owner__name__in=group_names) qs = qs.select_related('owner')\ .prefetch_related('applications', 'instances', 'volumes', 'links') return qs
def handle_size(args, provider): if args.size_list: print "ID\tName\tCPU\tMemory" for s in Size.objects.filter(only_current(), provider=provider).order_by('id'): print "%s\t%s\t%d\t%d" % (s.id, s.name, s.cpu, s.mem) sys.exit(0) if not args.size_id: print "Error: size-id is required. To get a list of sizes"\ " use --size-list." sys.exit(1)
def get_queryset(self): """ Filter projects by current user. """ user = self.request.user qs = Instance.for_user(user) if 'archived' not in self.request.query_params: qs = qs.filter(only_current()) logger.info( "DEBUG- User %s querying for instances, available IDs are:%s" % (user, qs.values_list('id', flat=True))) return qs
def get_queryset(self): """ Filter projects by current user """ request_user = self.request.user # Switch based on user's ClassType if isinstance(request_user, AnonymousUser): provider_ids = Provider.objects.filter(only_current(), active=True).values_list('id',flat=True) else: group = Group.objects.get(name=request_user.username) provider_ids = group.identities.filter( only_current_provider(), provider__active=True).values_list('provider', flat=True) # Switch based on query if 'archived' in self.request.QUERY_PARAMS: return Size.objects.filter( provider__id__in=provider_ids) else: return Size.objects.filter( only_current(), provider__id__in=provider_ids)
def get_queryset(self): """ Filter providers by current user """ user = self.request.user # Anonymous access: Show ONLY the providers that are: # publically available, active, and non-end dated if (type(user) == AnonymousUser): return Provider.objects.filter( only_current(), active=True, public=True) providers = user.current_providers # NOTE: This does _NOT_ filter out providers that are InMaintenance. return providers
def get_queryset(self): """ Filter projects by current user. """ user = self.request.user qs = Instance.shared_with_user(user) if 'archived' not in self.request.query_params: qs = qs.filter(only_current()) # logger.info("DEBUG- User %s querying for instances, available IDs are:%s" % (user, qs.values_list('id',flat=True))) qs = qs.select_related("created_by")\ .select_related('created_by_identity')\ .select_related('source')\ .select_related('project') return qs
def get_queryset(self): """ Filter providers by current user """ user = self.request.user # Anonymous access: Show ONLY the providers that are: # publically available, active, and non-end dated if (type(user) == AnonymousUser): return Provider.objects.filter(only_current(), active=True, public=True) providers = user.current_providers # NOTE: This does _NOT_ filter out providers that are InMaintenance. return providers
def search(cls, identity, query): return ProviderMachine.objects.filter( # Privately owned OR public machines Q(application__private=True, created_by_identity=identity) | Q(application__private=False, provider=identity.provider), # AND query matches on: # app tag name OR # app tag desc OR # app name OR # app desc Q(application__tags__name__icontains=query) | Q(application__tags__description__icontains=query) | Q(application__name__icontains=query) | Q(application__description__icontains=query), only_current())
def _validate_provider(self, provider_uuid): """ Validate that this provider is 'visible' w.r.t. the current user """ request_user = self._get_request_user() # NOTE: With this validation, *ONLY* the creator of the provider can admininster accounts # To allow anyone with staff/superuser to create, replace provider_manager # provider_manager = Provider.objects provider_manager = request_user.admin_providers prov_qs = provider_manager.filter( only_current(), active=True) provider = prov_qs.filter(uuid=provider_uuid).first() if not provider: raise serializers.ValidationError( "Cannot create an account for provider with UUID %s" % provider_uuid) return provider