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
