def _update_host_network(
session, updater, host_network, **kwargs
):
if 'interface' in kwargs:
interface = kwargs['interface']
host_network_by_interface = utils.get_db_object(
session, models.HostNetwork, False,
host_id=host_network.host_id,
interface=interface
)
if (
host_network_by_interface and
host_network_by_interface.id != host_network.id
):
raise exception.InvalidParameter(
'interface %s exists in host network %s' % (
interface, host_network_by_interface.id
)
)
if 'ip' in kwargs:
ip = kwargs['ip']
ip_int = long(netaddr.IPAddress(ip))
host_network_by_ip = utils.get_db_object(
session, models.HostNetwork, False,
ip_int=ip_int
)
if host_network_by_ip and host_network_by_ip.id != host_network.id:
raise exception.InvalidParameter(
'ip %s exist in host network %s' % (
ip, host_network_by_ip.id
)
)
is_host_editable(session, host_network.host, updater)
return utils.update_db_object(session, host_network, **kwargs)
def _add_host_network(
session, creator, host_id, exception_when_existing=True,
interface=None, ip=None, **kwargs
):
host = utils.get_db_object(
session, models.Host, id=host_id
)
ip_int = long(netaddr.IPAddress(ip))
host_network = utils.get_db_object(
session, models.HostNetwork, False,
ip_int=ip_int
)
if (
host_network and not (
host_network.host_id == host_id and
host_network.interface == interface
)
):
raise exception.InvalidParameter(
'ip %s exists in host network %s' % (
ip, host_network.id
)
)
is_host_editable(session, host, creator)
return utils.add_db_object(
session, models.HostNetwork,
exception_when_existing,
host_id, interface, ip=ip, **kwargs
)
def add_os_adapters_internal(session):
parents = {}
configs = util.load_configs(setting.OS_ADAPTER_DIR)
with session.begin(subtransactions=True):
for config in configs:
if 'OS' in config:
os = utils.get_db_object(
session, models.OperatingSystem,
name=config['OS']
)
else:
os = None
if 'INSTALLER' in config:
installer = utils.get_db_object(
session, models.OSInstaller,
name=config['INSTALLER']
)
else:
installer = None
object = utils.add_db_object(
session, models.OSAdapter,
True, config['NAME'], os=os, installer=installer
)
parents[config['NAME']] = (object, config.get('PARENT', None))
for name, (object, parent_name) in parents.items():
if parent_name:
parent, _ = parents[parent_name]
else:
parent = None
utils.update_db_object(
session, object, parent=parent
)
_complement_os_adapters(session)
def add_flavors_internal(session, exception_when_existing=True):
configs = util.load_configs(setting.ADAPTER_FLAVOR_DIR)
for config in configs:
logging.info('add config %s to flavor', config)
adapter = utils.get_db_object(
session, models.Adapter,
name=config['ADAPTER_NAME']
)
for flavor_dict in config['FLAVORS']:
flavor = utils.add_db_object(
session, models.AdapterFlavor,
exception_when_existing, flavor_dict['flavor'], adapter.id,
display_name=flavor_dict.get('display_name', None),
template=flavor_dict.get('template', None)
)
role_names = flavor_dict.get('roles', [])
for role_name in role_names:
role = utils.get_db_object(
session, models.AdapterRole,
name=role_name, adapter_id=adapter.id
)
utils.add_db_object(
session, models.AdapterFlavorRole,
exception_when_existing, flavor.id, role.id
)
utils.update_db_object(
session, flavor,
patched_ordered_flavor_roles=[role_name]
)
def test_get_none_with_flag_on(self):
with self.assertRaises(exception.RecordNotExists):
with database.session() as session:
utils.get_db_object(
session,
models.Permission,
name='dummy'
)
def del_machine(machine_id, user=None, session=None, **kwargs):
"""Delete a machine."""
machine = utils.get_db_object(session, models.Machine, id=machine_id)
if machine.host:
host = machine.host
raise exception.NotAcceptable("machine %s has host %s on it" % (machine.mac, host.name))
return utils.del_db_object(session, machine)
def get_switch_filters(
session, getter, switch_id, **kwargs
):
"""get switch filter."""
return utils.get_db_object(
session, models.Switch, id=switch_id
)
def get_switch_filters(
switch_id, user=None, session=None, **kwargs
):
"""get switch filter."""
return utils.get_db_object(
session, models.Switch, id=switch_id
)
def get_subnet(getter, subnet_id, **kwargs):
"""Get subnet info."""
with database.session() as session:
user_api.check_user_permission_internal(
session, getter, permission.PERMISSION_LIST_NETWORKS)
return utils.get_db_object(session, models.Network, id=subnet_id
).to_dict()
def start_check_cluster_health(user, cluster_id, send_report_url,
session=None, check_health={}):
"""Start to check cluster health."""
cluster_state = utils.get_db_object(
session, models.Cluster, True, id=cluster_id
).state_dict()
if cluster_state['state'] != 'SUCCESSFUL':
logging.debug("state is %s" % cluster_state['state'])
err_msg = "Healthcheck starts only after cluster finished deployment!"
raise exception.Forbidden(err_msg)
reports = utils.list_db_objects(
session, models.HealthCheckReport,
cluster_id=cluster_id, state='verifying'
)
if reports:
err_msg = 'Healthcheck in progress, please wait for it to complete!'
raise exception.Forbidden(err_msg)
# Clear all preivous report
utils.del_db_objects(
session, models.HealthCheckReport, cluster_id=cluster_id
)
from compass.tasks import client as celery_client
celery_client.celery.send_task(
'compass.tasks.cluster_health',
(cluster_id, send_report_url, user.email)
)
return {
"cluster_id": cluster_id,
"status": "start to check cluster health."
}
def _add_metadata(
session, field_model, metadata_model, name, config,
parent=None, adapter=None
):
metadata = config.get('_self', {})
if 'field' in metadata:
field = utils.get_db_object(
session, field_model, field=metadata['field']
)
else:
field = None
object = utils.add_db_object(
session, metadata_model, True,
name, adapter=adapter, parent=parent, field=field,
display_name=metadata.get('display_name', name),
description=metadata.get('description', None),
is_required=metadata.get('is_required', False),
required_in_whole_config=metadata.get('required_in_whole_config', False),
mapping_to=metadata.get('mapping_to', None),
validator=metadata.get('validator', None),
js_validator=metadata.get('js_validator', None),
default_value=metadata.get('default_value', None),
options=metadata.get('options', []),
required_in_options=metadata.get('required_in_options', False)
)
for key, value in config.items():
if key not in '_self':
_add_metadata(
session, field_model, metadata_model, key, value,
parent=object, adapter=adapter,
)
return object
def _get_host(host_id, session=None, **kwargs):
"""Get host by id."""
if isinstance(host_id, (int, long)):
return utils.get_db_object(session, models.Host, id=host_id, **kwargs)
else:
raise exception.InvalidParameter(
'host id %s type is not int compatible' % host_id)
def _get_switch_by_ip(switch_ip, session=None, **kwargs):
"""Get switch by switch ip."""
switch_ip_int = long(netaddr.IPAddress(switch_ip))
return utils.get_db_object(session,
models.Switch,
ip_int=switch_ip_int,
**kwargs)
def del_host(session, deleter, host_id, **kwargs):
"""Delete a host."""
from compass.db.api import cluster as cluster_api
from compass.tasks import client as celery_client
host = utils.get_db_object(
session, models.Host, id=host_id
)
is_host_editable(
session, host, deleter,
reinstall_os_set=True
)
cluster_ids = []
for clusterhost in host.clusterhosts:
cluster_api.is_cluster_editable(
session, clusterhost.cluster, deleter,
reinstall_distributed_system_set=True
)
cluster_ids.append(clusterhost.cluster_id)
celery_client.celery.send_task(
'compass.tasks.delete_host',
(
deleter.email, host_id, cluster_ids
)
)
return {
'status': 'delete action sent',
'host': host,
}
def _get_host_log_history(host_id, filename, session=None, **kwargs):
host = _get_host(host_id, session=session)
return utils.get_db_object(session,
models.HostLogHistory,
id=host.id,
filename=filename,
**kwargs)
def add_switches(
exception_when_existing=False,
data=[], user=None, session=None
):
"""Create switches."""
switches = []
fail_switches = []
for switch_data in data:
switch_ip = long(netaddr.IPAddress(switch_data['ip']))
switch_object = utils.get_db_object(
session, models.Switch, False,
ip_int=switch_ip
)
if switch_object:
logging.error('ip %s exists in switch %s' % (
switch_ip, switch_object.id
))
fail_switches.append(switch_data)
else:
switch_data.pop('ip')
switches.append(
add_switch_internal(
session, switch_ip, exception_when_existing,
**switch_data
)
)
return {
'switches': switches,
'fail_switches': fail_switches
}
def test_update_db_obj_none_exist(self):
with self.assertRaises(exception.DatabaseException):
with database.session() as session:
db_obj = utils.get_db_object(session,
models.Permission,
id=1000)
utils.update_db_object(session, db_obj, name='dummy')
def update_host_state(host_id, user=None, session=None, **kwargs):
"""Update a host state."""
host = utils.get_db_object(
session, models.Host, id=host_id
)
utils.update_db_object(session, host.state, **kwargs)
return host.state_dict()
def test_get_none_with_flag_off(self):
with database.session() as session:
dummy = utils.get_db_object(session,
models.Permission,
False,
name='dummy')
self.assertEqual(None, dummy)
def del_hostnetwork(host_network_id, user=None, session=None, **kwargs):
"""Delete a host network."""
host_network = utils.get_db_object(
session, models.HostNetwork, id=host_network_id
)
is_host_editable(session, host_network.host, user)
return utils.del_db_object(session, host_network)
def del_switchmachine(session, deleter, switch_machine_id, **kwargs):
"""Delete switch machines."""
switch_machine = utils.get_db_object(
session, models.SwitchMachine,
switch_machine_id=switch_machine_id
)
return utils.del_db_object(session, switch_machine)
def reset_machine(machine_id, reset={}, user=None, session=None, **kwargs):
"""reset machine."""
from compass.tasks import client as celery_client
machine = utils.get_db_object(session, models.Machine, id=machine_id)
celery_client.celery.send_task("compass.tasks.reset_machine", (machine_id,))
return {"status": "reset %s action sent" % machine.mac, "machine": machine}
def test_update_db_object(self):
with database.session() as session:
db_obj = utils.get_db_object(session, models.Permission, id=1)
updated_obj = utils.update_db_object(session,
db_obj,
alias='updated')
self.assertEqual('updated', updated_obj.alias)
def _get_switch_by_ip(switch_ip, session=None, **kwargs):
"""Get switch by switch ip."""
switch_ip_int = long(netaddr.IPAddress(switch_ip))
return utils.get_db_object(
session, models.Switch,
ip_int=switch_ip_int, **kwargs
)
def del_permission(user_id, permission_id, user=None, session=None, **kwargs):
"""Delete a specific user permission."""
user_permission = utils.get_db_object(
session, models.UserPermission,
user_id=user_id, permission_id=permission_id,
**kwargs
)
return utils.del_db_object(session, user_permission)
def update_hostnetwork(host_network_id, user=None, session=None, **kwargs):
"""Update a host network."""
host_network = utils.get_db_object(
session, models.HostNetwork, id=host_network_id
)
return _update_host_network(
session, user, host_network, **kwargs
)
def update_machine(updater, machine_id, **kwargs):
"""Update a machine."""
with database.session() as session:
user_api.check_user_permission_internal(
session, updater, permission.PERMISSION_UPDATE_MACHINE)
machine = utils.get_db_object(session, models.Machine, id=machine_id)
utils.update_db_object(session, machine, **kwargs)
return machine.to_dict()
def get_cluster(getter, cluster_id, **kwargs):
"""Get subnet info."""
with database.session() as session:
user_api.check_user_permission_internal(
session, getter, permission.PERMISSION_LIST_CLUSTERS)
return utils.get_db_object(
session, models.Cluster, id=cluster_id
).to_dict()
def del_machine(deleter, machine_id, **kwargs):
"""Delete a machine."""
with database.session() as session:
user_api.check_user_permission_internal(
session, deleter, permission.PERMISSION_DEL_MACHINE)
machine = utils.get_db_object(session, models.Switch, id=machine_id)
utils.del_db_object(session, machine)
return machine.to_dict()
def get_machine(getter, machine_id, **kwargs):
"""get field dict of a machine."""
with database.session() as session:
user_api.check_user_permission_internal(
session, getter, permission.PERMISSION_LIST_MACHINES)
return utils.get_db_object(
session, models.Machine, True, id=machine_id
).to_dict()
def get_current_user(
exception_when_missing=True, user=None,
session=None, **kwargs
):
"""get field dict of a user."""
return utils.get_db_object(
session, models.User, exception_when_missing, id=user.id
)
def get_user_object(email, session=None, **kwargs):
"""get user and convert to UserWrapper object."""
user = utils.get_db_object(session, models.User, False, email=email)
if not user:
raise exception.Unauthorized('%s unauthorized' % email)
user_dict = user.to_dict()
user_dict.update(kwargs)
return UserWrapper(**user_dict)
def _get_hostnetwork_by_ip(
ip, session=None, **kwargs
):
ip_int = long(netaddr.IPAddress(ip))
return utils.get_db_object(
session, models.HostNetwork,
ip_int=ip_int, **kwargs
)
def test_get_alias(self):
with database.session() as session:
machines = utils.get_db_object(session,
models.Permission,
name='list_machines')
expected = 'list machines'
self.assertEqual(expected, machines.alias)
self.assertEqual(expected, machines.description)
def _get_permission(permission_id, session=None, **kwargs):
"""Get permission object by the unique key of Permission table."""
if isinstance(permission_id, (int, long)):
return utils.get_db_object(
session, models.Permission, id=permission_id, **kwargs)
raise exception.InvalidParameter(
'permission id %s type is not int compatible' % permission_id
)
def test_del_db_object(self):
with self.assertRaises(exception.RecordNotExists):
with database.session() as session:
db_obj = utils.get_db_object(
session,
models.Permission,
id=1
)
utils.del_db_object(
session,
db_obj
)
utils.get_db_object(
session,
models.Permission,
id=1
)
def update_host_deployed_config(host_id, user=None, session=None, **kwargs):
"""Update host deployed config."""
host = utils.get_db_object(
session, models.Host, id=host_id
)
is_host_editable(session, host, user)
is_host_validated(session, host)
return utils.update_db_object(session, host, **kwargs)
def get_user(
session, getter, user_id,
exception_when_missing=True, **kwargs
):
"""get field dict of a user."""
return utils.get_db_object(
session, models.User, exception_when_missing, id=user_id
)
def _get_machine(machine_id, session=None, **kwargs):
"""Get machine by id."""
if isinstance(machine_id, (int, long)):
return utils.get_db_object(session,
models.Machine,
id=machine_id,
**kwargs)
raise exception.InvalidParameter(
'machine id %s type is not int compatible' % machine_id)
def _get_subnet(subnet_id, session=None, **kwargs):
"""Get subnet by subnet id."""
if isinstance(subnet_id, (int, long)):
return utils.get_db_object(session,
models.Subnet,
id=subnet_id,
**kwargs)
raise exception.InvalidParameter(
'subnet id %s type is not int compatible' % subnet_id)
def _get_switch_machine(switch_id, machine_id, session=None, **kwargs):
"""Get switch machine by switch id and machine id."""
switch = _get_switch(switch_id, session=session)
from compass.db.api import machine as machine_api
machine = machine_api.get_machine_internal(machine_id, session=session)
return utils.get_db_object(
session, models.SwitchMachine,
switch_id=switch.id, machine_id=machine.id, **kwargs
)
def _get_switch(switch_id, session=None, **kwargs):
"""Get Switch object switch id."""
if isinstance(switch_id, (int, long)):
return utils.get_db_object(session,
models.Switch,
id=switch_id,
**kwargs)
raise exception.InvalidParameter(
'switch id %s type is not int compatible' % switch_id)
def _get_permission(permission_id, session=None, **kwargs):
"""Get permission object by the unique key of Permission table."""
if isinstance(permission_id, (int, long)):
return utils.get_db_object(session,
models.Permission,
id=permission_id,
**kwargs)
raise exception.InvalidParameter(
'permission id %s type is not int compatible' % permission_id)
def _get_switchmachine(switch_machine_id, session=None, **kwargs):
"""Get switch machine by switch_machine_id."""
if not isinstance(switch_machine_id, (int, long)):
raise exception.InvalidParameter(
'switch machine id %s type is not int compatible' %
(switch_machine_id))
return utils.get_db_object(session,
models.SwitchMachine,
switch_machine_id=switch_machine_id,
**kwargs)
def _get_permission(user_id, permission_id, session=None, **kwargs):
"""Get user permission by user id and permission id."""
user = _get_user(user_id, session=session)
from compass.db.api import permission as permission_api
permission = permission_api.get_permission_internal(permission_id,
session=session)
return utils.get_db_object(session,
models.UserPermission,
user_id=user.id,
permission_id=permission.id,
**kwargs)
def _check_user_permission(user, permission, session=None):
"""Check user has permission."""
if not user:
logging.info('empty user means the call is from internal')
return
if user.is_admin:
return
user_permission = utils.get_db_object(session,
models.UserPermission,
False,
user_id=user.id,
name=permission.name)
if not user_permission:
raise exception.Forbidden('user %s does not have permission %s' %
(user.email, permission.name))
def record_user_token(token, expire_timestamp, user=None, session=None):
"""record user token in database."""
user_token = utils.get_db_object(session,
models.UserToken,
False,
user_id=user.id,
token=token)
if not user_token:
return utils.add_db_object(session,
models.UserToken,
True,
token,
user_id=user.id,
expire_timestamp=expire_timestamp)
elif expire_timestamp > user_token.expire_timestamp:
return utils.update_db_object(session,
user_token,
expire_timestamp=expire_timestamp)
return user_token
def get_user_object_from_token(token, session=None):
"""Get user from token and convert to UserWrapper object.
::note:
get_user_object_from_token may be called in session.
"""
expire_timestamp = {'ge': datetime.datetime.now()}
user_token = utils.get_db_object(session,
models.UserToken,
False,
token=token,
expire_timestamp=expire_timestamp)
if not user_token:
raise exception.Unauthorized('invalid user token: %s' % token)
user_dict = _get_user(user_token.user_id, session=session).to_dict()
user_dict['token'] = token
expire_timestamp = user_token.expire_timestamp
user_dict['expire_timestamp'] = expire_timestamp
return UserWrapper(**user_dict)
def _get_user(user_id, session=None, **kwargs):
"""Get user object by user id."""
if isinstance(user_id, (int, long)):
return utils.get_db_object(session, models.User, id=user_id, **kwargs)
raise exception.InvalidParameter('user id %s type is not int compatible' %
user_id)
def test_get_none_with_flag_on(self):
with self.assertRaises(exception.RecordNotExists):
with database.session() as session:
utils.get_db_object(session, models.Permission, name='dummy')
def _get_report(cluster_id, name, session=None):
cluster = cluster_api.get_cluster_internal(cluster_id, session=session)
return utils.get_db_object(
session, models.HealthCheckReport, cluster_id=cluster.id, name=name
)
def test_del_db_object(self):
with self.assertRaises(exception.RecordNotExists):
with database.session() as session:
db_obj = utils.get_db_object(session, models.Permission, id=1)
utils.del_db_object(session, db_obj)
utils.get_db_object(session, models.Permission, id=1)
