def _get_multimachine_stats(owner, metric, start='', stop='', step='',
uuids=None):
if not uuids:
uuids = [machine.id for machine in Machine.objects(
cloud__in=Cloud.objects(owner=owner, deleted=None),
monitoring__hasmonitoring=True
)]
if not uuids:
raise NotFoundError("No machine has monitoring enabled.")
try:
data = get_multi_uuid(uuids, metric, start=start, stop=stop,
interval_str=step)
except Exception as exc:
log.error("Error getting %s: %r", metric, exc)
raise ServiceUnavailableError()
ret = {}
for item in data:
target = item['target'].split('.')
if len(target) > 1:
uuid = target[1]
else:
uuid = target[0]
item['name'] = uuid
ret[uuid] = item
return ret
def disassociate_key(request):
"""
Disassociate a key from a machine
Disassociates a key from a machine. If host is set it will also attempt to
actually remove it from the machine.
READ permission required on cloud.
DISASSOCIATE_KEY permission required on machine.
---
key:
in: path
required: true
type: string
machine:
in: path
required: true
type: string
"""
key_id = request.matchdict['key']
cloud_id = request.matchdict.get('cloud')
auth_context = auth_context_from_request(request)
if cloud_id:
# this is depracated, keep it for backwards compatibility
machine_id = request.matchdict['machine']
try:
Cloud.objects.get(owner=auth_context.owner,
id=cloud_id,
deleted=None)
except Cloud.DoesNotExist:
raise NotFoundError('Cloud does not exist')
auth_context.check_perm("cloud", "read", cloud_id)
try:
machine = Machine.objects.get(cloud=cloud_id,
machine_id=machine_id,
state__ne='terminated')
except Machine.DoesNotExist:
raise NotFoundError("Machine %s doesn't exist" % machine_id)
else:
machine_uuid = request.matchdict['machine']
try:
machine = Machine.objects.get(id=machine_uuid,
state__ne='terminated')
except Machine.DoesNotExist:
raise NotFoundError("Machine %s doesn't exist" % machine_uuid)
cloud_id = machine.cloud.id
auth_context.check_perm("cloud", "read", cloud_id)
auth_context.check_perm("machine", "disassociate_key", machine.id)
key = Key.objects.get(owner=auth_context.owner, id=key_id, deleted=None)
key.ctl.disassociate(machine)
clouds = Cloud.objects(owner=auth_context.owner, deleted=None)
machines = Machine.objects(cloud__in=clouds,
key_associations__keypair__exact=key)
assoc_machines = transform_key_machine_associations(machines, key)
return assoc_machines
def add_key(request):
"""
Tags: keys
---
Adds key.
ADD permission required on key.
---
name:
description: The key's name
required: true
type: string
priv:
description: The private key
required: true
type: string
certificate:
description: The signed public key, when using signed ssh keys
type: string
"""
params = params_from_request(request)
key_name = params.pop('name', None)
private_key = params.get('priv', None)
certificate = params.get('certificate', None)
auth_context = auth_context_from_request(request)
key_tags = auth_context.check_perm("key", "add", None)
if not key_name:
raise BadRequestError("Key name is not provided")
if not private_key:
raise RequiredParameterMissingError("Private key is not provided")
if certificate:
key = SignedSSHKey.add(auth_context.owner, key_name, **params)
else:
key = SSHKey.add(auth_context.owner, key_name, **params)
# Set ownership.
key.assign_to(auth_context.user)
if key_tags:
add_tags_to_resource(auth_context.owner, key, key_tags.items())
# since its a new key machines fields should be an empty list
clouds = Cloud.objects(owner=auth_context.owner, deleted=None)
machines = Machine.objects(cloud__in=clouds,
key_associations__keypair__exact=key)
assoc_machines = transform_key_machine_associations(machines, key)
return {
'id': key.id,
'name': key.name,
'machines': assoc_machines,
'isDefault': key.default
}
def add_cloud_v_2(owner, title, provider, params):
"""Add cloud to owner"""
# FIXME: Some of these should be explicit arguments, others shouldn't exist
fail_on_error = params.pop('fail_on_error',
params.pop('remove_on_error', True))
params.pop('title', None)
params.pop('provider', None)
# Find proper Cloud subclass.
if not provider:
raise RequiredParameterMissingError("provider")
log.info("Adding new cloud in provider '%s'", provider)
if provider not in cloud_models.CLOUDS:
raise BadRequestError("Invalid provider '%s'." % provider)
cloud_cls = cloud_models.CLOUDS[provider] # Class of Cloud model.
# Add the cloud.
cloud = cloud_cls.add(owner, title, fail_on_error=fail_on_error,
fail_on_invalid_params=False, **params)
ret = {
'cloud_id': cloud.id,
'errors': getattr(cloud,
'errors', []), # just an attribute, not a field
}
log.info("Cloud with id '%s' added succesfully.", cloud.id)
c_count = Cloud.objects(owner=owner, deleted=None).count()
if owner.clouds_count != c_count:
owner.clouds_count = c_count
owner.save()
cloud.polling_interval = 1800 # 30 min * 60 sec/min
cloud.save()
# TODO: remove below, most probably doesn't make any difference?
ListMachinesPollingSchedule.add(cloud=cloud)
ListLocationsPollingSchedule.add(cloud=cloud)
ListSizesPollingSchedule.add(cloud=cloud)
ListImagesPollingSchedule.add(cloud=cloud)
return ret
def list_clouds(self):
if config.ACTIVATE_POLLER:
self.update_poller()
self.send('list_clouds', filter_list_clouds(self.auth_context))
clouds = Cloud.objects(owner=self.owner, enabled=True, deleted=None)
log.info(clouds)
periodic_tasks = []
if not config.ACTIVATE_POLLER:
periodic_tasks.append(('list_machines', tasks.ListMachines()))
else:
for cloud in clouds:
after = datetime.datetime.utcnow() - datetime.timedelta(days=1)
machines = Machine.objects(cloud=cloud, missing_since=None,
last_seen__gt=after)
machines = filter_list_machines(
self.auth_context, cloud_id=cloud.id,
machines=[machine.as_dict() for machine in machines]
)
if machines:
log.info("Emitting list_machines from poller's cache.")
self.send('list_machines',
{'cloud_id': cloud.id, 'machines': machines})
periodic_tasks.extend([('list_images', tasks.ListImages()),
('list_sizes', tasks.ListSizes()),
('list_networks', tasks.ListNetworks()),
('list_zones', tasks.ListZones()),
('list_locations', tasks.ListLocations()),
('list_projects', tasks.ListProjects())])
for key, task in periodic_tasks:
for cloud in clouds:
cached = task.smart_delay(self.owner.id, cloud.id)
if cached is not None:
log.info("Emitting %s from cache", key)
if key == 'list_machines':
cached['machines'] = filter_list_machines(
self.auth_context, **cached
)
if cached['machines'] is None:
continue
self.send(key, cached)
def trigger_location_polling_schedules():
clouds = Cloud.objects(deleted=None)
print
print 'Creating and storing in database ListLocationsPollingSchedules'
print
failed = 0
for cloud in clouds:
try:
schedule = ListLocationsPollingSchedule.add(cloud)
schedule.set_default_interval(60 * 60 * 24)
schedule.save()
except Exception as exc:
print 'Error: %s' % exc
traceback.print_exc()
failed += 1
continue
print ' ****** Failures: %d *********' % failed