33
33
from nova.db.sqlalchemy.session import get_session
34
34
from nova import exception
35
35
from nova import flags
36
from nova import log as logging
36
from nova.openstack.common import log as logging
37
37
from nova.openstack.common import timeutils
38
38
from nova import utils
39
39
from sqlalchemy import and_
474
474
###################
476
def _compute_node_get(context, compute_id, session=None):
476
def compute_node_get(context, compute_id, session=None):
477
477
result = model_query(context, models.ComputeNode, session=session).\
478
478
filter_by(id=compute_id).\
494
@require_admin_context
495
def compute_node_search_by_hypervisor(context, hypervisor_match):
496
field = models.ComputeNode.hypervisor_hostname
497
return model_query(context, models.ComputeNode).\
498
options(joinedload('service')).\
499
filter(field.like('%%%s%%' % hypervisor_match)).\
494
503
def _get_host_utilization(context, host, ram_mb, disk_gb):
495
504
"""Compute the current utilization of a given host."""
496
505
instances = instance_get_all_by_host(context, host)
503
512
free_ram_mb -= instance.memory_mb
504
513
free_disk_gb -= instance.root_gb
505
514
free_disk_gb -= instance.ephemeral_gb
506
if instance.vm_state in [vm_states.BUILDING, vm_states.REBUILDING,
507
vm_states.MIGRATING, vm_states.RESIZING]:
515
if instance.task_state is not None:
509
517
return dict(free_ram_mb=free_ram_mb,
510
518
free_disk_gb=free_disk_gb,
544
552
_adjust_compute_node_values_for_utilization(context, values, session)
545
553
with session.begin(subtransactions=True):
546
compute_ref = _compute_node_get(context, compute_id, session=session)
554
compute_ref = compute_node_get(context, compute_id, session=session)
547
555
compute_ref.update(values)
548
556
compute_ref.save(session=session)
612
620
raise exception.NotFound(_("No ComputeNode for %(host)s") %
615
if free_ram_mb != None:
623
if free_ram_mb is not None:
616
624
compute_node.free_ram_mb = free_ram_mb
617
if free_disk_gb != None:
625
if free_disk_gb is not None:
618
626
compute_node.free_disk_gb = free_disk_gb
620
628
compute_node.current_workload = work
622
630
compute_node.running_vms = vms
624
632
return compute_node
1117
1125
@require_context
1118
1126
def fixed_ip_get_by_address(context, address, session=None):
1119
result = model_query(context, models.FixedIp, session=session,
1120
read_deleted=context.read_deleted).\
1127
result = model_query(context, models.FixedIp, session=session).\
1121
1128
filter_by(address=address).\
1330
1337
instance_ref = models.Instance()
1331
1338
if not values.get('uuid'):
1332
1339
values['uuid'] = str(utils.gen_uuid())
1340
instance_ref['info_cache'] = models.InstanceInfoCache()
1341
info_cache = values.pop('info_cache', None)
1342
if info_cache is not None:
1343
instance_ref['info_cache'].update(info_cache)
1344
security_groups = values.pop('security_groups', [])
1333
1345
instance_ref.update(values)
1347
def _get_sec_group_models(session, security_groups):
1349
default_group = security_group_ensure_default(context,
1351
if 'default' in security_groups:
1352
models.append(default_group)
1353
# Generate a new list, so we don't modify the original
1354
security_groups = [x for x in security_groups if x != 'default']
1356
models.extend(_security_group_get_by_names(context,
1357
session, context.project_id, security_groups))
1335
1360
session = get_session()
1336
1361
with session.begin():
1362
instance_ref.security_groups = _get_sec_group_models(session,
1337
1364
instance_ref.save(session=session)
1365
# NOTE(comstud): This forces instance_type to be loaded so it
1366
# exists in the ref when we return. Fixes lazy loading issues.
1367
instance_ref.instance_type
1339
# and creat the info_cache table entry for instance
1340
instance_info_cache_create(context, {'instance_id': instance_ref['uuid']})
1369
# create the instance uuid to ec2_id mapping entry for instance
1370
ec2_instance_create(context, instance_ref['uuid'])
1342
1372
return instance_ref
1438
1468
@require_admin_context
1439
def instance_get_all(context):
1440
return model_query(context, models.Instance).\
1441
options(joinedload('info_cache')).\
1442
options(joinedload('security_groups')).\
1443
options(joinedload('metadata')).\
1444
options(joinedload('instance_type')).\
1469
def instance_get_all(context, columns_to_join=None):
1470
if columns_to_join is None:
1471
columns_to_join = ['info_cache', 'security_groups',
1472
'metadata', 'instance_type']
1473
query = model_query(context, models.Instance)
1474
for column in columns_to_join:
1475
query = query.options(joinedload(column))
1448
1479
@require_context
1497
1528
# include or exclude both
1498
1529
if filters.pop('deleted'):
1499
1530
deleted = or_(models.Instance.deleted == True,
1500
models.Instance.vm_state == vm_states.SOFT_DELETE)
1531
models.Instance.vm_state == vm_states.SOFT_DELETED)
1501
1532
query_prefix = query_prefix.filter(deleted)
1503
1534
query_prefix = query_prefix.\
1504
1535
filter_by(deleted=False).\
1505
filter(models.Instance.vm_state != vm_states.SOFT_DELETE)
1536
filter(models.Instance.vm_state != vm_states.SOFT_DELETED)
1507
1538
if not context.is_admin:
1508
1539
# If we're not admin context, add appropriate filter..
1837
1868
# NOTE(tr3buchet): just in case someone blows away an instance's
1839
values['instance_id'] = instance_uuid
1870
values['instance_uuid'] = instance_uuid
1840
1871
info_cache = instance_info_cache_create(context, values)
1842
1873
return info_cache
2931
2961
@require_context
2932
def _ec2_volume_get_query(context, session=None, project_only=False):
2933
return model_query(context, models.VolumeIdMapping, session=session,
2934
project_only=project_only)
2962
def _ec2_volume_get_query(context, session=None):
2963
return model_query(context, models.VolumeIdMapping, session=session)
2937
2966
@require_context
2938
def _ec2_snapshot_get_query(context, session=None, project_only=False):
2939
return model_query(context, models.SnapshotIdMapping, session=session,
2940
project_only=project_only)
2967
def _ec2_snapshot_get_query(context, session=None):
2968
return model_query(context, models.SnapshotIdMapping, session=session)
2943
2971
@require_context
3027
3055
@require_context
3028
3056
def get_ec2_volume_id_by_uuid(context, volume_id, session=None):
3029
result = _ec2_volume_get_query(context,
3031
project_only=True).\
3057
result = _ec2_volume_get_query(context, session=session).\
3032
3058
filter_by(uuid=volume_id).\
3041
3067
@require_context
3042
3068
def get_volume_uuid_by_ec2_id(context, ec2_id, session=None):
3043
result = _ec2_volume_get_query(context,
3045
project_only=True).\
3069
result = _ec2_volume_get_query(context, session=session).\
3046
3070
filter_by(id=ec2_id).\
3068
3092
@require_context
3069
3093
def get_ec2_snapshot_id_by_uuid(context, snapshot_id, session=None):
3070
result = _ec2_snapshot_get_query(context,
3072
project_only=True).\
3094
result = _ec2_snapshot_get_query(context, session=session).\
3073
3095
filter_by(uuid=snapshot_id).\
3082
3104
@require_context
3083
3105
def get_snapshot_uuid_by_ec2_id(context, ec2_id, session=None):
3084
result = _ec2_snapshot_get_query(context,
3086
project_only=True).\
3106
result = _ec2_snapshot_get_query(context, session=session).\
3087
3107
filter_by(id=ec2_id).\
3332
3351
###################
3334
3353
def _security_group_get_query(context, session=None, read_deleted=None,
3335
project_only=False):
3336
return model_query(context, models.SecurityGroup, session=session,
3337
read_deleted=read_deleted, project_only=project_only).\
3338
options(joinedload_all('rules'))
3354
project_only=False, join_rules=True):
3355
query = model_query(context, models.SecurityGroup, session=session,
3356
read_deleted=read_deleted, project_only=project_only)
3358
query = query.options(joinedload_all('rules'))
3362
def _security_group_get_by_names(context, session, project_id, group_names):
3364
Get security group models for a project by a list of names.
3365
Raise SecurityGroupNotFoundForProject for a name not found.
3367
query = _security_group_get_query(context, session=session,
3368
read_deleted="no", join_rules=False).\
3369
filter_by(project_id=project_id).\
3370
filter(models.SecurityGroup.name.in_(group_names))
3371
sg_models = query.all()
3372
if len(sg_models) == len(group_names):
3374
# Find the first one missing and raise
3375
group_names_from_models = [x.name for x in sg_models]
3376
for group_name in group_names:
3377
if group_name not in group_names_from_models:
3378
raise exception.SecurityGroupNotFoundForProject(
3379
project_id=project_id, security_group_id=group_name)
3341
3383
@require_context
3361
3403
@require_context
3362
def security_group_get_by_name(context, project_id, group_name):
3363
result = _security_group_get_query(context, read_deleted="no").\
3364
filter_by(project_id=project_id).\
3365
filter_by(name=group_name).\
3366
options(joinedload_all('instances')).\
3404
def security_group_get_by_name(context, project_id, group_name,
3405
columns_to_join=None, session=None):
3407
session = get_session()
3409
query = _security_group_get_query(context, session=session,
3410
read_deleted="no", join_rules=False).\
3411
filter_by(project_id=project_id).\
3412
filter_by(name=group_name)
3414
if columns_to_join is None:
3415
columns_to_join = ['instances', 'rules']
3417
for column in columns_to_join:
3418
query = query.options(joinedload_all(column))
3420
result = query.first()
3370
3422
raise exception.SecurityGroupNotFoundForProject(
3371
3423
project_id=project_id, security_group_id=group_name)
3421
3473
@require_context
3422
def security_group_create(context, values):
3474
def security_group_create(context, values, session=None):
3423
3475
security_group_ref = models.SecurityGroup()
3424
3476
# FIXME(devcamcar): Unless I do this, rules fails with lazy load exception
3425
3477
# once save() is called. This will get cleaned up in next orm pass.
3426
3478
security_group_ref.rules
3427
3479
security_group_ref.update(values)
3428
security_group_ref.save()
3481
session = get_session()
3482
security_group_ref.save(session=session)
3429
3483
return security_group_ref
3486
def security_group_ensure_default(context, session=None):
3487
"""Ensure default security group exists for a project_id."""
3489
default_group = security_group_get_by_name(context,
3490
context.project_id, 'default',
3491
columns_to_join=[], session=session)
3492
except exception.NotFound:
3493
values = {'name': 'default',
3494
'description': 'default',
3495
'user_id': context.user_id,
3496
'project_id': context.project_id}
3497
default_group = security_group_create(context, values,
3499
return default_group
3432
3502
@require_context
3433
3503
def security_group_destroy(context, security_group_id):
3434
3504
session = get_session()
4167
4237
# System-owned metadata
4169
4239
def _instance_system_metadata_get_query(context, instance_uuid, session=None):
4170
return model_query(context, models.InstanceSystemMetadata, session=session,
4171
read_deleted="no").\
4240
return model_query(context, models.InstanceSystemMetadata,
4172
4242
filter_by(instance_uuid=instance_uuid)
5093
5163
output[row['instance_uuid']].append(data)
5172
def ec2_instance_create(context, instance_uuid, id=None):
5173
"""Create ec2 compatable instance by provided uuid"""
5174
ec2_instance_ref = models.InstanceIdMapping()
5175
ec2_instance_ref.update({'uuid': instance_uuid})
5177
ec2_instance_ref.update({'id': id})
5179
ec2_instance_ref.save()
5181
return ec2_instance_ref
5185
def get_ec2_instance_id_by_uuid(context, instance_id, session=None):
5186
result = _ec2_instance_get_query(context,
5188
filter_by(uuid=instance_id).\
5192
raise exception.InstanceNotFound(uuid=instance_id)
5198
def get_instance_uuid_by_ec2_id(context, instance_id, session=None):
5199
result = _ec2_instance_get_query(context,
5201
filter_by(id=instance_id).\
5205
raise exception.InstanceNotFound(id=instance_id)
5207
return result['uuid']
5211
def _ec2_instance_get_query(context, session=None):
5212
return model_query(context, models.InstanceIdMapping, session=session)
added
removed
nova/db/sqlalchemy/api.py
