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 _update_machine_if_necessary(
machine, session=None, **kwargs
):
"""Update machine is there is something to update."""
utils.update_db_object(
session, machine, **kwargs
)
def _update_machine_if_necessary(
machine, session=None, **kwargs
):
"""Update machine is there is something to update."""
utils.update_db_object(
session, machine, **kwargs
)
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_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 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 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 delete_cluster_config(updater, cluster_id):
"""Update a cluster config."""
with database.session() as session:
user_api.check_user_permission_internal(
session, updater, permission.PERMISSION_DEL_CLUSTER)
cluster = utils.get_db_object(
session, models.Cluster, id=cluster_id
)
utils.update_db_object(
session, cluster, os_config={}, package_config={}
)
return cluster.to_dict()
def patch_machine(updater, machine_id, **kwargs):
"""Update a switch."""
with database.session() as session:
user_api.check_user_permission_internal(
session, updater, permission.PERMISSION_UDPATE_MACHINE)
machine = utils.get_db_object(session, models.Machine, id=machine_id)
utils.update_db_object(session, machine, **kwargs)
machine_dict = machine.to_dict()
utils.validates(
[], {'ipmi_credentials': _check_ipmi_credentials},
**machine_dict
)
return machine_dict
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 del_host_config(host_id, user=None, session=None):
"""delete a host config."""
host = _get_host(host_id, session=session)
check_host_editable(host, user=user)
return utils.update_db_object(
session, host, os_config={}, config_validated=False
)
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 _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 _update_host(host_id, session=None, user=None, **kwargs):
"""Update a host internal."""
host = _get_host(host_id, session=session)
check_host_editable(host,
user=user,
check_in_installing=kwargs.get('reinstall_os', False))
return utils.update_db_object(session, host, **kwargs)
def update_report(cluster_id, name, session=None, **kwargs):
"""Update health check report."""
report = _get_report(cluster_id, name, session=session)
if report.state == 'finished':
err_msg = 'Report cannot be updated if state is in "finished"'
raise exception.Forbidden(err_msg)
return utils.update_db_object(session, report, **kwargs)
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 update_report(cluster_id, name, session=None, **kwargs):
"""Update health check report."""
report = _get_report(cluster_id, name, session=session)
if report.state == 'finished':
err_msg = 'Report cannot be updated if state is in "finished"'
raise exception.Forbidden(err_msg)
return utils.update_db_object(session, report, **kwargs)
def _update_host_network(
host_network, session=None, user=None, **kwargs
):
"""Update host network."""
check_host_editable(host_network.host, user=user)
subnet = network.get_subnet_internal(host_network.subnet_id, session=session)
check_ip_available(subnet, ip)
return utils.update_db_object(session, host_network, **kwargs)
def _add_system(session, model, configs):
parents = {}
for config in configs:
object = utils.add_db_object(
session, model,
True, config['NAME'],
deployable=config.get('DEPLOYABLE', False)
)
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)
def update_host_log_history(
host_id, filename, user=None,
session=None, **kwargs
):
"""Update a host log history."""
host_log_history = utils.get_db_object(
session, models.HostLogHistory, id=host_id, filename=filename
)
return utils.update_db_object(session, host_log_history, **kwargs)
def del_host_config(host_id, user=None, session=None):
"""delete a host config."""
host = utils.get_db_object(
session, models.Host, id=host_id
)
is_host_editable(session, host, user)
return utils.update_db_object(
session, host, os_config={}, config_validated=False
)
def update_switch_machine_internal(
session, switch_machine, switch_machines_fields, **kwargs
):
"""Update switch machine internal."""
switch_machine_dict = {}
machine_dict = {}
for key, value in kwargs.items():
if key in switch_machines_fields:
switch_machine_dict[key] = value
else:
machine_dict[key] = value
if machine_dict:
utils.update_db_object(
session, switch_machine.machine, **machine_dict
)
return utils.update_db_object(
session, switch_machine, **switch_machine_dict
)
def update_host_log_history(
host_id, filename, user=None,
session=None, **kwargs
):
"""Update a host log history."""
host_log_history = _get_host_log_history(
host_id, filename, session=session
)
return utils.update_db_object(session, host_log_history, **kwargs)
def _update_host(host_id, session=None, user=None, **kwargs):
"""Update a host internal."""
host = _get_host(host_id, session=session)
if host.state.state == "SUCCESSFUL" and not host.reinstall_os:
logging.info("ignoring successful host: %s", host_id)
return {}
check_host_editable(host,
user=user,
check_in_installing=kwargs.get('reinstall_os', False))
return utils.update_db_object(session, host, **kwargs)
def _update_host(session, user, host_id, **kwargs):
"""Update a host internal."""
host = utils.get_db_object(
session, models.Host, id=host_id
)
is_host_editable(
session, host, user,
reinstall_os_set=kwargs.get('reinstall_os', False)
)
return utils.update_db_object(session, host, **kwargs)
def update_cluster_config(updater, cluster_id, **kwargs):
"""Update a cluster config."""
with database.session() as session:
user_api.check_user_permission_internal(
session, updater, permission.PERMISSION_ADD_CLUSTER)
cluster = utils.get_db_object(
session, models.Cluster, id=cluster_id
)
utils.update_db_object(session, cluster, **kwargs)
os_config = cluster.os_config
if os_config:
metadata_api.validate_os_config(
os_config, cluster.adapter_id
)
package_config = cluster.package_config
if package_config:
metadata_api.validate_package_config(
package_config, cluster.adapter_id
)
return cluster.to_dict()
def _update_host(host_id, session=None, user=None, **kwargs):
"""Update a host internal."""
host = _get_host(host_id, session=session)
if host.state.state == "SUCCESSFUL" and not host.reinstall_os:
logging.info("ignoring successful host: %s", host_id)
return {}
check_host_editable(
host, user=user,
check_in_installing=kwargs.get('reinstall_os', False)
)
return utils.update_db_object(session, host, **kwargs)
def _add_system(session, model, configs, exception_when_existing=True):
parents = {}
for config in configs:
logging.info(
'add config %s to %s',
config, model
)
object = utils.add_db_object(
session, model,
exception_when_existing, config['NAME'],
deployable=config.get('DEPLOYABLE', False)
)
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)
def update_host_state_internal(host_id,
from_database_only=False,
user=None,
session=None,
**kwargs):
"""Update a host state.
This function is called when host os is installed.
If from_database_only, the state is updated in database.
Otherwise a celery task sent to os installer and package installer
to do some future actions.
"""
# TODO(xicheng): should be merged into update_host_state
host = _get_host(host_id, session=session)
if 'ready' in kwargs and kwargs['ready'] and not host.state.ready:
ready_triggered = True
else:
ready_triggered = False
clusterhosts_ready = {}
clusters_os_ready = {}
if ready_triggered:
for clusterhost in host.clusterhosts:
cluster = clusterhost.cluster
if cluster.flavor_name:
clusterhosts_ready[cluster.id] = False
else:
clusterhosts_ready[cluster.id] = True
all_os_ready = True
for clusterhost_in_cluster in cluster.clusterhosts:
host_in_cluster = clusterhost_in_cluster.host
if host_in_cluster.id == host.id:
continue
if not host_in_cluster.state.ready:
all_os_ready = False
clusters_os_ready[cluster.id] = all_os_ready
logging.debug('host %s ready: %s', host_id, ready_triggered)
logging.debug("clusterhosts_ready is: %s", clusterhosts_ready)
logging.debug("clusters_os_ready is %s", clusters_os_ready)
if not ready_triggered or from_database_only:
logging.debug('%s state is set to %s', host.name, kwargs)
utils.update_db_object(session, host.state, **kwargs)
if not host.state.ready:
for clusterhost in host.clusterhosts:
utils.update_db_object(session, clusterhost.state, ready=False)
utils.update_db_object(session,
clusterhost.cluster.state,
ready=False)
status = '%s state is updated' % host.name
else:
from compass.tasks import client as celery_client
celery_client.celery.send_task(
'compass.tasks.os_installed',
(host.id, clusterhosts_ready, clusters_os_ready))
status = '%s: clusterhosts ready %s clusters os ready %s' % (
host.name, clusterhosts_ready, clusters_os_ready)
logging.info('action status: %s', status)
return {'status': status, 'host': host.state}
def add_package_adapters_internal(session):
parents = {}
configs = util.load_configs(setting.PACKAGE_ADAPTER_DIR)
with session.begin(subtransactions=True):
for config in configs:
if 'DISTRIBUTED_SYSTEM' in config:
distributed_system = utils.get_db_object(
session, models.DistributedSystem,
name=config['DISTRIBUTED_SYSTEM']
)
else:
distributed_system = None
if 'INSTALLER' in config:
installer = utils.get_db_object(
session, models.PackageInstaller,
name=config['INSTALLER']
)
else:
installer = None
object = utils.add_db_object(
session, models.PackageAdapter,
True,
config['NAME'],
distributed_system=distributed_system,
installer=installer,
support_os_patterns=config.get('SUPPORT_OS_PATTERNS', [])
)
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_distributed_system_adapters(session)
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 update_user(user_id, user=None, session=None, **kwargs):
"""Update a user and return the updated user object."""
update_user = _get_user(
user_id,
session=session,
)
allowed_fields = set()
if user.is_admin:
allowed_fields |= set(ADMIN_UPDATED_FIELDS)
if user.id == update_user.id:
allowed_fields |= set(SELF_UPDATED_FIELDS)
unsupported_fields = set(kwargs) - allowed_fields
if unsupported_fields:
# The user is not allowed to update a user.
raise exception.Forbidden(
'User %s has no permission to update user %s fields %s.' %
(user.email, user.email, unsupported_fields))
return utils.update_db_object(session, update_user, **kwargs)
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 update_user(user_id, user=None, session=None, **kwargs):
"""Update a user and return the updated user object."""
update_user = _get_user(
user_id, session=session,
)
allowed_fields = set()
if user.is_admin:
allowed_fields |= set(ADMIN_UPDATED_FIELDS)
if user.id == update_user.id:
allowed_fields |= set(SELF_UPDATED_FIELDS)
unsupported_fields = set(kwargs) - allowed_fields
if unsupported_fields:
# The user is not allowed to update a user.
raise exception.Forbidden(
'User %s has no permission to update user %s fields %s.' % (
user.email, user.email, unsupported_fields
)
)
return utils.update_db_object(session, update_user, **kwargs)
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 _update_host(session, updater, host_id, **kwargs):
"""Update a host internal."""
host = utils.get_db_object(
session, models.Host, id=host_id
)
is_host_editable(
session, host, updater,
reinstall_os_set=kwargs.get('reinstall_os', False)
)
if 'name' in kwargs:
hostname = kwargs['name']
host_by_name = utils.get_db_object(
session, models.Host, False, name=hostname
)
if host_by_name and host_by_name.id != host.id:
raise exception.InvalidParameter(
'hostname %s is already exists in host %s' % (
hostname, host_by_name.id
)
)
return utils.update_db_object(session, host, **kwargs)
def _update_machine(machine_id, session=None, **kwargs):
"""Update a machine."""
machine = _get_machine(machine_id, session=session)
return utils.update_db_object(session, machine, **kwargs)
def update_host_state(host_id, user=None, session=None, **kwargs):
"""Update a host state."""
host = _get_host(host_id, session=session)
utils.update_db_object(session, host.state, **kwargs)
return host.state
def _update_host_network(host_network, session=None, user=None, **kwargs):
"""Update host network."""
check_host_editable(host_network.host, user=user)
return utils.update_db_object(session, host_network, **kwargs)
def _update_host_config(host, session=None, user=None, **kwargs):
"""Update host config."""
check_host_editable(host, user=user)
return utils.update_db_object(session, host, **kwargs)
def update_host_deployed_config(host_id, user=None, session=None, **kwargs):
"""Update host deployed config."""
host = _get_host(host_id, session=session)
check_host_editable(host, user=user)
check_host_validated(host)
return utils.update_db_object(session, host, **kwargs)
def update_switch_filters(switch_id, user=None, session=None, **kwargs):
"""Update filters of a switch."""
switch = _get_switch(switch_id, session=session)
return utils.update_db_object(session, switch, **kwargs)
def add_adapters_internal(session, exception_when_existing=True):
parents = {}
configs = util.load_configs(setting.ADAPTER_DIR)
for config in configs:
logging.info('add config %s to adapter', config)
if 'DISTRIBUTED_SYSTEM' in config:
distributed_system = utils.get_db_object(
session, models.DistributedSystem,
name=config['DISTRIBUTED_SYSTEM']
)
else:
distributed_system = None
if 'OS_INSTALLER' in config:
os_installer = utils.get_db_object(
session, models.OSInstaller,
alias=config['OS_INSTALLER']
)
else:
os_installer = None
if 'PACKAGE_INSTALLER' in config:
package_installer = utils.get_db_object(
session, models.PackageInstaller,
alias=config['PACKAGE_INSTALLER']
)
else:
package_installer = None
adapter = utils.add_db_object(
session, models.Adapter,
exception_when_existing,
config['NAME'],
display_name=config.get('DISPLAY_NAME', None),
distributed_system=distributed_system,
os_installer=os_installer,
package_installer=package_installer,
deployable=config.get('DEPLOYABLE', False)
)
supported_os_patterns = [
re.compile(supported_os_pattern)
for supported_os_pattern in config.get('SUPPORTED_OS_PATTERNS', [])
]
oses = utils.list_db_objects(
session, models.OperatingSystem
)
for os in oses:
if not os.deployable:
continue
os_name = os.name
for supported_os_pattern in supported_os_patterns:
if supported_os_pattern.match(os_name):
utils.add_db_object(
session, models.AdapterOS,
exception_when_existing,
os.id, adapter.id
)
break
parents[config['NAME']] = (adapter, config.get('PARENT', None))
for name, (adapter, parent_name) in parents.items():
if parent_name:
parent, _ = parents[parent_name]
else:
parent = None
utils.update_db_object(session, adapter, parent=parent)
def patch_switch_filter(switch_id, user=None, session=None, **kwargs):
"""Patch filters to a switch."""
switch = _get_switch(switch_id, session=session)
return utils.update_db_object(session, switch, **kwargs)
def update_subnet(subnet_id, user=None, session=None, **kwargs):
"""Update a subnet."""
subnet = _get_subnet(subnet_id, session=session)
return utils.update_db_object(session, subnet, **kwargs)
def _update_machine(session, updater, machine_id, **kwargs):
"""Update a machine."""
machine = utils.get_db_object(session, models.Machine, id=machine_id)
return utils.update_db_object(session, machine, **kwargs)
)
return network.to_dict()
@utils.wrap_to_dict(RESP_FIELDS)
@utils.input_validates(subnet=_check_network)
@utils.supported_filters(UPDATED_FIELDS)
def update_subnet(updater, subnet_id, **kwargs):
"""Update a subnet."""
with database.session() as session:
user_api.check_user_permission_internal(
session, updater, permission.PERMISSION_ADD_NETWORK)
network = utils.get_db_object(
session, models.Network, id=subnet_id
)
utils.update_db_object(session, network, **kwargs)
return network.to_dict()
@utils.wrap_to_dict(RESP_FIELDS)
@utils.supported_filters([])
def del_network(deleter, subnet_id, **kwargs):
"""Delete a subnet."""
with database.session() as session:
user_api.check_user_permission_internal(
session, deleter, permission.PERMISSION_DEL_NETWORK)
network = utils.get_db_object(
session, models.Network, id=subnet_id
)
utils.del_db_object(session, network)
return network.to_dict()
def _update_switch_machine_only(switch_machine, session=None, **kwargs):
"""Update switch machine."""
return utils.update_db_object(session, switch_machine, **kwargs)
def update_subnet(subnet_id, user=None, session=None, **kwargs):
"""Update a subnet."""
subnet = utils.get_db_object(
session, models.Subnet, id=subnet_id
)
return utils.update_db_object(session, subnet, **kwargs)
def _update_switch(switch_id, session=None, **kwargs):
"""Update a switch."""
switch = _get_switch(switch_id, session=session)
return utils.update_db_object(session, switch, **kwargs)