x/compass-core
Code Issues Proposed changes

Passing user variable as kwarg.

Browse Source 
Change-Id: Idc8f995715c032b4a57a763e336ac512afce3c81
This commit is contained in:
Lei Lei 2015-01-30 23:24:14 -08:00
parent dcf7292e79
commit 913b04b7f9
30 changed files with 1425 additions and 1366 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
bin/clean_installers.py
View File

@ -61,7 +61,7 @@ def clean_installers():
if package_installer
]
user = user_api.get_user_object(setting.COMPASS_ADMIN_EMAIL)
adapters = adapter_api.list_adapters(user)
adapters = adapter_api.list_adapters(user=user)
filtered_os_installers = {}
filtered_package_installers = {}
for adapter in adapters:

4
bin/delete_clusters.py
View File

@ -56,13 +56,13 @@ def delete_clusters():
if clusternames:
list_cluster_args['name'] = clusternames
clusters = cluster_api.list_clusters(
user, **list_cluster_args
user=user, **list_cluster_args
)
delete_underlying_host = flags.OPTIONS.delete_hosts
for cluster in clusters:
cluster_id = cluster['id']
cluster_api.del_cluster(
user, cluster_id, True, False, delete_underlying_host
cluster_id, True, False, delete_underlying_host, user=user
)

4
bin/manage_db.py
View File

@ -148,7 +148,7 @@ def set_switch_machines():
switch_mapping = {}
for switch in switches:
added_switch = switch_api.add_switch(
user, False, **switch
False, user=user, **switch
)
switch_mapping[switch['ip']] = added_switch['id']
for switch_ip, machines in switch_machines.items():
@ -158,7 +158,7 @@ def set_switch_machines():
switch_id = switch_mapping[switch_ip]
for machine in machines:
switch_api.add_switch_machine(
user, switch_id, False, **machine
switch_id, False, user=user, **machine
)

2
bin/poll_switch.py
View File

@ -62,7 +62,7 @@ def pollswitches(switch_ips):
poll_switches = []
all_switches = dict([
(switch['ip'], switch['credentials'])
for switch in switch_api.list_switches(user)
for switch in switch_api.list_switches(user=user)
])
if switch_ips:
poll_switches = dict([

10
compass/actions/poll_switch.py
View File

@ -128,7 +128,7 @@ def poll_switch(poller_email, ip_addr, credentials,
switch_dict, machine_dicts = _poll_switch(
ip_addr, credentials, req_obj=req_obj, oper=oper
)
switches = switch_api.list_switches(poller, ip_int=ip_int)
switches = switch_api.list_switches(ip_int=ip_int, user=poller)
if not switches:
logging.error('no switch found for %s', ip_addr)
return
@ -137,6 +137,10 @@ def poll_switch(poller_email, ip_addr, credentials,
for machine_dict in machine_dicts:
logging.debug('add machine: %s', machine_dict)
switch_api.add_switch_machine(
poller, switch['id'], False, **machine_dict
switch['id'], False, user=poller, **machine_dict
)
switch_api.update_switch(
switch['id'],
user=poller,
**switch_dict
)
switch_api.update_switch(poller, switch['id'], **switch_dict)

31
compass/actions/update_progress.py
View File

@ -55,7 +55,7 @@ def update_progress():
logging.info('update installing progress')
user = user_api.get_user_object(setting.COMPASS_ADMIN_EMAIL)
hosts = host_api.list_hosts(user)
hosts = host_api.list_hosts(user=user)
host_mapping = {}
for host in hosts:
if 'id' not in host:
@ -74,13 +74,13 @@ def update_progress():
'%s is not in host %s', host_dirname, host
)
continue
host_state = host_api.get_host_state(user, host_id)
host_state = host_api.get_host_state(host_id, user=user)
if 'state' not in host_state:
logging.error('state is not in host state %s', host_state)
continue
if host_state['state'] == 'INSTALLING':
host_log_histories = host_api.get_host_log_histories(
user, host_id
host_id, user=user
)
host_log_history_mapping = {}
for host_log_history in host_log_histories:
@ -101,7 +101,7 @@ def update_progress():
'ignore host state %s since it is not in installing',
host_state
)
adapters = adapter_api.list_adapters(user)
adapters = adapter_api.list_adapters(user=user)
adapter_mapping = {}
for adapter in adapters:
if 'id' not in adapter:
@ -116,7 +116,7 @@ def update_progress():
continue
adapter_id = adapter['id']
adapter_mapping[adapter_id] = adapter
clusters = cluster_api.list_clusters(user)
clusters = cluster_api.list_clusters(user=user)
cluster_mapping = {}
for cluster in clusters:
if 'id' not in cluster:
@ -129,12 +129,15 @@ def update_progress():
cluster
)
continue
cluster_state = cluster_api.get_cluster_state(user, cluster_id)
cluster_state = cluster_api.get_cluster_state(
cluster_id,
user=user
)
if 'state' not in cluster_state:
logging.error('state not in cluster state %s', cluster_state)
continue
cluster_mapping[cluster_id] = (cluster, cluster_state)
clusterhosts = cluster_api.list_clusterhosts(user)
clusterhosts = cluster_api.list_clusterhosts(user=user)
clusterhost_mapping = {}
for clusterhost in clusterhosts:
if 'clusterhost_id' not in clusterhost:
@ -194,7 +197,7 @@ def update_progress():
package_installer = adapter['package_installer']
clusterhost['package_installer'] = package_installer
clusterhost_state = cluster_api.get_clusterhost_self_state(
user, clusterhost_id
clusterhost_id, user=user
)
if 'state' not in clusterhost_state:
logging.error(
@ -205,7 +208,7 @@ def update_progress():
if clusterhost_state['state'] == 'INSTALLING':
clusterhost_log_histories = (
cluster_api.get_clusterhost_log_histories(
user, clusterhost_id
clusterhost_id, user=user
)
)
clusterhost_log_history_mapping = {}
@ -236,7 +239,7 @@ def update_progress():
host_mapping.items()
):
host_api.update_host_state(
user, host_id,
host_id, user=user,
percentage=host_state.get('percentage', 0),
message=host_state.get('message', ''),
severity=host_state.get('severity', 'INFO')
@ -245,7 +248,7 @@ def update_progress():
host_log_history_mapping.items()
):
host_api.add_host_log_history(
user, host_id, filename=filename,
host_id, filename=filename, user=user,
position=host_log_history.get('position', 0),
percentage=host_log_history.get('percentage', 0),
partial_line=host_log_history.get('partial_line', ''),
@ -264,7 +267,7 @@ def update_progress():
clusterhost_mapping.items()
):
cluster_api.update_clusterhost_state(
user, clusterhost_id,
clusterhost_id, user=user,
percentage=clusterhost_state.get('percentage', 0),
message=clusterhost_state.get('message', ''),
severity=clusterhost_state.get('severity', 'INFO')
@ -273,7 +276,7 @@ def update_progress():
clusterhost_log_history_mapping.items()
):
cluster_api.add_clusterhost_log_history(
user, clusterhost_id, filename=filename,
clusterhost_id, user=user, filename=filename,
position=clusterhost_log_history.get('position', 0),
percentage=clusterhost_log_history.get('percentage', 0),
partial_line=clusterhost_log_history.get(
@ -290,5 +293,5 @@ def update_progress():
cluster_mapping)
for cluster_id, (cluster, cluster_state) in cluster_mapping.items():
cluster_api.update_cluster_state(
user, cluster_id
cluster_id, user=user
)

48
compass/actions/util.py
View File

@ -94,8 +94,8 @@ class ActionHelper(object):
}
To view a complete output, please refer to backend doc.
"""
adapter_info = adapter_db.get_adapter(user, adapter_id)
metadata = cluster_db.get_cluster_metadata(user, cluster_id)
adapter_info = adapter_db.get_adapter(adapter_id, user=user)
metadata = cluster_db.get_cluster_metadata(cluster_id, user=user)
adapter_info.update({const.METADATA: metadata})
for flavor_info in adapter_info[const.FLAVORS]:
@ -128,7 +128,7 @@ class ActionHelper(object):
"owner": "xxx"
}
"""
cluster_info = cluster_db.get_cluster(user, cluster_id)
cluster_info = cluster_db.get_cluster(cluster_id, user=user)
# convert roles retrieved from db into a list of role names
roles_info = cluster_info.setdefault(
@ -137,11 +137,11 @@ class ActionHelper(object):
ActionHelper._get_role_names(roles_info)
# get cluster config info
cluster_config = cluster_db.get_cluster_config(user, cluster_id)
cluster_config = cluster_db.get_cluster_config(cluster_id, user=user)
cluster_info.update(cluster_config)
deploy_config = cluster_db.get_cluster_deployed_config(user,
cluster_id)
deploy_config = cluster_db.get_cluster_deployed_config(cluster_id,
user=user)
cluster_info.update(deploy_config)
return cluster_info
@ -179,7 +179,7 @@ class ActionHelper(object):
"""
hosts_info = {}
for host_id in hosts_id_list:
info = cluster_db.get_cluster_host(user, cluster_id, host_id)
info = cluster_db.get_cluster_host(cluster_id, host_id, user=user)
logging.debug("checking on info %r %r" % (host_id, info))
info[const.ROLES] = ActionHelper._get_role_names(info[const.ROLES])
@ -187,9 +187,9 @@ class ActionHelper(object):
# TODO(grace): Is following line necessary??
info.setdefault(const.ROLES, [])
config = cluster_db.get_cluster_host_config(user,
cluster_id,
host_id)
config = cluster_db.get_cluster_host_config(cluster_id,
host_id,
user=user)
info.update(config)
networks = info[const.NETWORKS]
@ -220,26 +220,34 @@ class ActionHelper(object):
cluster_id = cluster_config[const.ID]
del cluster_config[const.ID]
cluster_db.update_cluster_deployed_config(user, cluster_id,
cluster_db.update_cluster_deployed_config(cluster_id, user=user,
**cluster_config)
hosts_id_list = deployed_config[const.HOSTS].keys()
for host_id in hosts_id_list:
config = deployed_config[const.HOSTS][host_id]
cluster_db.update_cluster_host_deployed_config(user,
cluster_id,
cluster_db.update_cluster_host_deployed_config(cluster_id,
host_id,
user=user,
**config)
@staticmethod
def update_state(cluster_id, host_id_list, user):
# update all clusterhosts state
for host_id in host_id_list:
cluster_db.update_cluster_host_state(user, cluster_id, host_id,
state='INSTALLING')
cluster_db.update_cluster_host_state(
cluster_id,
host_id,
user=user,
state='INSTALLING'
)
# update cluster state
cluster_db.update_cluster_state(user, cluster_id, state='INSTALLING')
cluster_db.update_cluster_state(
cluster_id,
user=user,
state='INSTALLING'
)
@staticmethod
def delete_cluster(
@ -251,7 +259,7 @@ class ActionHelper(object):
user, host_id, True, True
)
cluster_db.del_cluster(
user, cluster_id, True, True
cluster_id, True, True, user=user
)
@staticmethod
@ -260,16 +268,16 @@ class ActionHelper(object):
):
if delete_underlying_host:
host_db.del_host(
user, host_id, True, True
host_id, True, True, user=user
)
cluster_db.del_cluster_host(
user, cluster_id, host_id, True, True
cluster_id, host_id, True, True, user=user
)
@staticmethod
def delete_host(host_id, user):
host_db.del_host(
user, host_id, True, True
host_id, True, True, user=user
)
@staticmethod

261
compass/api/api.py
View File

File diff suppressed because it is too large Load Diff

4
compass/db/api/adapter_holder.py
View File

@ -95,7 +95,7 @@ def _filter_adapters(adapter_config, filter_name, filter_value):
roles=RESP_ROLES_FIELDS,
flavors=RESP_FLAVORS_FIELDS
)
def list_adapters(lister, session=None, **filters):
def list_adapters(user=None, session=None, **filters):
"""list adapters."""
if not ADAPTER_MAPPING:
load_adapters_internal(session)
@ -125,6 +125,6 @@ def get_adapter_internal(session, adapter_id):
roles=RESP_ROLES_FIELDS,
flavors=RESP_FLAVORS_FIELDS
)
def get_adapter(getter, adapter_id, session=None, **kwargs):
def get_adapter(adapter_id, user=None, session=None, **kwargs):
"""get adapter."""
return get_adapter_internal(session, adapter_id)

234
compass/db/api/cluster.py
View File

@ -154,7 +154,7 @@ UPDATED_CLUSTERHOST_LOG_FIELDS = [
permission.PERMISSION_LIST_CLUSTERS
)
@utils.wrap_to_dict(RESP_FIELDS)
def list_clusters(lister, session=None, **filters):
def list_clusters(user=None, session=None, **filters):
"""List clusters."""
return utils.list_db_objects(
session, models.Cluster, **filters
@ -168,8 +168,8 @@ def list_clusters(lister, session=None, **filters):
)
@utils.wrap_to_dict(RESP_FIELDS)
def get_cluster(
getter, cluster_id,
exception_when_missing=True, session=None, **kwargs
cluster_id, exception_when_missing=True,
user=None, session=None, **kwargs
):
"""Get cluster info."""
return utils.get_db_object(
@ -243,14 +243,13 @@ def is_cluster_editable(
)
@utils.wrap_to_dict(RESP_FIELDS)
def add_cluster(
creator,
exception_when_existing=True,
name=None, session=None, **kwargs
name=None, user=None, session=None, **kwargs
):
"""Create a cluster."""
return utils.add_db_object(
session, models.Cluster, exception_when_existing,
name, creator_id=creator.id,
name, creator_id=user.id,
**kwargs
)
@ -265,13 +264,13 @@ def add_cluster(
permission.PERMISSION_ADD_CLUSTER
)
@utils.wrap_to_dict(RESP_FIELDS)
def update_cluster(updater, cluster_id, session=None, **kwargs):
def update_cluster(cluster_id, user=None, session=None, **kwargs):
"""Update a cluster."""
cluster = utils.get_db_object(
session, models.Cluster, id=cluster_id
)
is_cluster_editable(
session, cluster, updater,
session, cluster, user,
reinstall_distributed_system_set=(
kwargs.get('reinstall_distributed_system', False)
)
@ -301,9 +300,8 @@ def update_cluster(updater, cluster_id, session=None, **kwargs):
hosts=RESP_CLUSTERHOST_FIELDS
)
def del_cluster(
deleter, cluster_id,
force=False, from_database_only=False,
delete_underlying_host=False, session=None, **kwargs
cluster_id, force=False, from_database_only=False,
delete_underlying_host=False, user=None, session=None, **kwargs
):
"""Delete a cluster."""
cluster = utils.get_db_object(
@ -325,7 +323,7 @@ def del_cluster(
cluster.state.state = 'ERROR'
is_cluster_editable(
session, cluster, deleter,
session, cluster, user,
reinstall_distributed_system_set=True
)
@ -333,7 +331,7 @@ def del_cluster(
from compass.db.api import host as host_api
host = clusterhost.host
host_api.is_host_editable(
session, host, deleter, reinstall_os_set=True
session, host, user, reinstall_os_set=True
)
if host.state.state == 'UNINITIALIZED' or from_database_only:
utils.del_db_object(
@ -353,7 +351,7 @@ def del_cluster(
celery_client.celery.send_task(
'compass.tasks.delete_cluster',
(
deleter.email, cluster_id,
user.email, cluster_id,
[clusterhost.host_id for clusterhost in clusterhosts],
delete_underlying_host
)
@ -371,7 +369,7 @@ def del_cluster(
permission.PERMISSION_LIST_CLUSTER_CONFIG
)
@utils.wrap_to_dict(RESP_CONFIG_FIELDS)
def get_cluster_config(getter, cluster_id, session=None, **kwargs):
def get_cluster_config(cluster_id, user=None, session=None, **kwargs):
"""Get cluster config."""
return utils.get_db_object(
session, models.Cluster, id=cluster_id
@ -384,7 +382,7 @@ def get_cluster_config(getter, cluster_id, session=None, **kwargs):
permission.PERMISSION_LIST_CLUSTER_CONFIG
)
@utils.wrap_to_dict(RESP_DEPLOYED_CONFIG_FIELDS)
def get_cluster_deployed_config(getter, cluster_id, session=None, **kwargs):
def get_cluster_deployed_config(cluster_id, user=None, session=None, **kwargs):
"""Get cluster deployed config."""
return utils.get_db_object(
session, models.Cluster, id=cluster_id
@ -397,7 +395,7 @@ def get_cluster_deployed_config(getter, cluster_id, session=None, **kwargs):
permission.PERMISSION_LIST_METADATAS
)
@utils.wrap_to_dict(RESP_METADATA_FIELDS)
def get_cluster_metadata(getter, cluster_id, session=None, **kwargs):
def get_cluster_metadata(cluster_id, user=None, session=None, **kwargs):
"""Get cluster metadata."""
cluster = utils.get_db_object(
session, models.Cluster, id=cluster_id
@ -419,9 +417,9 @@ def get_cluster_metadata(getter, cluster_id, session=None, **kwargs):
@utils.wrap_to_dict(RESP_CONFIG_FIELDS)
def _update_cluster_config(session, updater, cluster, **kwargs):
def _update_cluster_config(session, user, cluster, **kwargs):
"""Update a cluster config."""
is_cluster_editable(session, cluster, updater)
is_cluster_editable(session, cluster, user)
return utils.update_db_object(
session, cluster, **kwargs
)
@ -441,13 +439,13 @@ def _update_cluster_config(session, updater, cluster, **kwargs):
)
@utils.wrap_to_dict(RESP_DEPLOYED_CONFIG_FIELDS)
def update_cluster_deployed_config(
updater, cluster_id, session=None, **kwargs
cluster_id, user=None, session=None, **kwargs
):
"""Update cluster deployed config."""
cluster = utils.get_db_object(
session, models.Cluster, id=cluster_id
)
is_cluster_editable(session, cluster, updater)
is_cluster_editable(session, cluster, user)
is_cluster_validated(session, cluster)
return utils.update_db_object(
session, cluster, **kwargs
@ -466,7 +464,7 @@ def update_cluster_deployed_config(
@user_api.check_user_permission_in_session(
permission.PERMISSION_ADD_CLUSTER_CONFIG
)
def update_cluster_config(updater, cluster_id, session=None, **kwargs):
def update_cluster_config(cluster_id, user=None, session=None, **kwargs):
"""Update cluster config."""
cluster = utils.get_db_object(
session, models.Cluster, id=cluster_id
@ -490,7 +488,7 @@ def update_cluster_config(updater, cluster_id, session=None, **kwargs):
cluster, **in_kwargs
):
return _update_cluster_config(
session, updater, cluster, **in_kwargs
session, user, cluster, **in_kwargs
)
return update_config_internal(
@ -510,7 +508,7 @@ def update_cluster_config(updater, cluster_id, session=None, **kwargs):
@user_api.check_user_permission_in_session(
permission.PERMISSION_ADD_CLUSTER_CONFIG
)
def patch_cluster_config(updater, cluster_id, session=None, **kwargs):
def patch_cluster_config(cluster_id, user=None, session=None, **kwargs):
"""patch cluster config."""
cluster = utils.get_db_object(
session, models.Cluster, id=cluster_id
@ -532,7 +530,7 @@ def patch_cluster_config(updater, cluster_id, session=None, **kwargs):
)
def update_config_internal(cluster, **in_kwargs):
return _update_cluster_config(
session, updater, cluster, **in_kwargs
session, user, cluster, **in_kwargs
)
return update_config_internal(
@ -546,12 +544,12 @@ def patch_cluster_config(updater, cluster_id, session=None, **kwargs):
permission.PERMISSION_DEL_CLUSTER_CONFIG
)
@utils.wrap_to_dict(RESP_CONFIG_FIELDS)
def del_cluster_config(deleter, cluster_id, session=None):
def del_cluster_config(cluster_id, user=None, session=None):
"""Delete a cluster config."""
cluster = utils.get_db_object(
session, models.Cluster, id=cluster_id
)
is_cluster_editable(session, cluster, deleter)
is_cluster_editable(session, cluster, user)
return utils.update_db_object(
session, cluster, os_config={},
package_config={}, config_validated=False
@ -672,7 +670,7 @@ def _set_clusterhosts(session, cluster, machines):
permission.PERMISSION_LIST_CLUSTERHOSTS
)
@utils.wrap_to_dict(RESP_CLUSTERHOST_FIELDS)
def list_cluster_hosts(lister, cluster_id, session=None, **filters):
def list_cluster_hosts(cluster_id, user=None, session=None, **filters):
"""Get cluster host info."""
return utils.list_db_objects(
session, models.ClusterHost, cluster_id=cluster_id,
@ -686,7 +684,7 @@ def list_cluster_hosts(lister, cluster_id, session=None, **filters):
permission.PERMISSION_LIST_CLUSTERHOSTS
)
@utils.wrap_to_dict(RESP_CLUSTERHOST_FIELDS)
def list_clusterhosts(lister, session=None, **filters):
def list_clusterhosts(user=None, session=None, **filters):
"""Get cluster host info."""
return utils.list_db_objects(
session, models.ClusterHost, **filters
@ -700,8 +698,8 @@ def list_clusterhosts(lister, session=None, **filters):
)
@utils.wrap_to_dict(RESP_CLUSTERHOST_FIELDS)
def get_cluster_host(
getter, cluster_id, host_id,
exception_when_missing=True, session=None, **kwargs
cluster_id, host_id, exception_when_missing=True,
user=None, session=None, **kwargs
):
"""Get clusterhost info."""
return utils.get_db_object(
@ -718,8 +716,8 @@ def get_cluster_host(
)
@utils.wrap_to_dict(RESP_CLUSTERHOST_FIELDS)
def get_clusterhost(
getter, clusterhost_id,
exception_when_missing=True, session=None, **kwargs
clusterhost_id, exception_when_missing=True,
user=None, session=None, **kwargs
):
"""Get clusterhost info."""
return utils.get_db_object(
@ -735,14 +733,14 @@ def get_clusterhost(
)
@utils.wrap_to_dict(RESP_CLUSTERHOST_FIELDS)
def add_cluster_host(
creator, cluster_id,
exception_when_existing=True, session=None, **kwargs
cluster_id, exception_when_existing=True,
user=None, session=None, **kwargs
):
"""Add cluster host."""
cluster = utils.get_db_object(
session, models.Cluster, id=cluster_id
)
is_cluster_editable(session, cluster, creator)
is_cluster_editable(session, cluster, user)
return add_clusterhost_internal(
session, cluster, exception_when_existing,
**kwargs
@ -750,7 +748,7 @@ def add_cluster_host(
@utils.wrap_to_dict(RESP_CLUSTERHOST_FIELDS)
def _update_clusterhost(session, updater, clusterhost, **kwargs):
def _update_clusterhost(session, user, clusterhost, **kwargs):
clusterhost_dict = {}
host_dict = {}
for key, value in kwargs.items():
@ -824,7 +822,7 @@ def _update_clusterhost(session, updater, clusterhost, **kwargs):
session, clusterhost, **in_kwargs
)
is_cluster_editable(session, clusterhost.cluster, updater)
is_cluster_editable(session, clusterhost.cluster, user)
return update_internal(
clusterhost, **kwargs
)
@ -839,14 +837,14 @@ def _update_clusterhost(session, updater, clusterhost, **kwargs):
permission.PERMISSION_UPDATE_CLUSTER_HOSTS
)
def update_cluster_host(
updater, cluster_id, host_id,
cluster_id, host_id, user=None,
session=None, **kwargs
):
"""Update cluster host."""
clusterhost = utils.get_db_object(
session, models.ClusterHost, cluster_id=cluster_id, host_id=host_id
)
return _update_clusterhost(session, updater, clusterhost, **kwargs)
return _update_clusterhost(session, user, clusterhost, **kwargs)
@utils.supported_filters(
@ -858,14 +856,14 @@ def update_cluster_host(
permission.PERMISSION_UPDATE_CLUSTER_HOSTS
)
def update_clusterhost(
updater, clusterhost_id,
clusterhost_id, user=None,
session=None, **kwargs
):
"""Update cluster host."""
clusterhost = utils.get_db_object(
session, models.ClusterHost, clusterhost_id=clusterhost_id
)
return _update_clusterhost(session, updater, clusterhost, **kwargs)
return _update_clusterhost(session, user, clusterhost, **kwargs)
@utils.replace_filters(
@ -880,14 +878,14 @@ def update_clusterhost(
permission.PERMISSION_UPDATE_CLUSTER_HOSTS
)
def patch_cluster_host(
updater, cluster_id, host_id, session=None,
**kwargs
cluster_id, host_id, user=None,
session=None, **kwargs
):
"""Update cluster host."""
clusterhost = utils.get_db_object(
session, models.ClusterHost, cluster_id=cluster_id, host_id=host_id
)
return _update_clusterhost(session, updater, clusterhost, **kwargs)
return _update_clusterhost(session, user, clusterhost, **kwargs)
@utils.replace_filters(
@ -902,14 +900,14 @@ def patch_cluster_host(
permission.PERMISSION_UPDATE_CLUSTER_HOSTS
)
def patch_clusterhost(
updater, clusterhost_id, session=None,
clusterhost_id, user=None, session=None,
**kwargs
):
"""Update cluster host."""
clusterhost = utils.get_db_object(
session, models.ClusterHost, clusterhost_id=clusterhost_id
)
return _update_clusterhost(session, updater, clusterhost, **kwargs)
return _update_clusterhost(session, user, clusterhost, **kwargs)
@utils.supported_filters([])
@ -922,9 +920,9 @@ def patch_clusterhost(
host=RESP_CLUSTERHOST_FIELDS
)
def del_cluster_host(
deleter, cluster_id, host_id,
cluster_id, host_id,
force=False, from_database_only=False,
delete_underlying_host=False,
delete_underlying_host=False, user=None,
session=None, **kwargs
):
"""Delete cluster host."""
@ -936,7 +934,7 @@ def del_cluster_host(
clusterhost.state.state = 'ERROR'
if not force:
is_cluster_editable(
session, clusterhost.cluster, deleter,
session, clusterhost.cluster, user,
reinstall_distributed_system_set=True
)
else:
@ -949,7 +947,7 @@ def del_cluster_host(
host.state.state = 'ERROR'
import compass.db.api.host as host_api
host_api.is_host_editable(
session, host, deleter,
session, host, user,
reinstall_os_set=True
)
if host.state.state == 'UNINITIALIZED' or from_database_only:
@ -970,7 +968,7 @@ def del_cluster_host(
celery_client.celery.send_task(
'compass.tasks.delete_cluster_host',
(
deleter.email, cluster_id, host_id,
user.email, cluster_id, host_id,
delete_underlying_host
)
)
@ -990,9 +988,9 @@ def del_cluster_host(
host=RESP_CLUSTERHOST_FIELDS
)
def del_clusterhost(
deleter, clusterhost_id,
clusterhost_id,
force=False, from_database_only=False,
delete_underlying_host=False,
delete_underlying_host=False, user=None,
session=None, **kwargs
):
"""Delete cluster host."""
@ -1004,7 +1002,7 @@ def del_clusterhost(
clusterhost.state.state = 'ERROR'
if not force:
is_cluster_editable(
session, clusterhost.cluster, deleter,
session, clusterhost.cluster, user,
reinstall_distributed_system_set=True
)
if delete_underlying_host:
@ -1013,7 +1011,7 @@ def del_clusterhost(
host.state.state = 'ERROR'
import compass.db.api.host as host_api
host_api.is_host_editable(
session, host, deleter,
session, host, user,
reinstall_os_set=True
)
if host.state.state == 'UNINITIALIZED' or from_database_only:
@ -1034,7 +1032,7 @@ def del_clusterhost(
celery_client.celery.send_task(
'compass.tasks.delete_cluster_host',
(
deleter.email, clusterhost.cluster_id,
user.email, clusterhost.cluster_id,
clusterhost.host_id,
delete_underlying_host
)
@ -1052,8 +1050,8 @@ def del_clusterhost(
)
@utils.wrap_to_dict(RESP_CLUSTERHOST_CONFIG_FIELDS)
def get_cluster_host_config(
getter, cluster_id,
host_id, session=None, **kwargs
cluster_id, host_id, user=None,
session=None, **kwargs
):
"""Get clusterhost config."""
return utils.get_db_object(
@ -1069,7 +1067,7 @@ def get_cluster_host_config(
)
@utils.wrap_to_dict(RESP_CLUSTERHOST_DEPLOYED_CONFIG_FIELDS)
def get_cluster_host_deployed_config(
getter, cluster_id, host_id, session=None, **kwargs
cluster_id, host_id, user=None, session=None, **kwargs
):
"""Get clusterhost deployed config."""
return utils.get_db_object(
@ -1084,7 +1082,7 @@ def get_cluster_host_deployed_config(
permission.PERMISSION_LIST_CLUSTERHOST_CONFIG
)
@utils.wrap_to_dict(RESP_CLUSTERHOST_CONFIG_FIELDS)
def get_clusterhost_config(getter, clusterhost_id, session=None, **kwargs):
def get_clusterhost_config(clusterhost_id, user=None, session=None, **kwargs):
"""Get clusterhost config."""
return utils.get_db_object(
session, models.ClusterHost, clusterhost_id=clusterhost_id
@ -1098,7 +1096,7 @@ def get_clusterhost_config(getter, clusterhost_id, session=None, **kwargs):
)
@utils.wrap_to_dict(RESP_CLUSTERHOST_DEPLOYED_CONFIG_FIELDS)
def get_clusterhost_deployed_config(
getter, clusterhost_id,
clusterhost_id, user=None,
session=None, **kwargs
):
"""Get clusterhost deployed config."""
@ -1108,11 +1106,11 @@ def get_clusterhost_deployed_config(
@utils.wrap_to_dict(RESP_CLUSTERHOST_CONFIG_FIELDS)
def _update_clusterhost_config(session, updater, clusterhost, **kwargs):
def _update_clusterhost_config(session, user, clusterhost, **kwargs):
from compass.db.api import host as host_api
ignore_keys = []
if not host_api.is_host_editable(
session, clusterhost.host, updater,
session, clusterhost.host, user,
exception_when_not_editable=False
):
ignore_keys.append('put_os_config')
@ -1124,7 +1122,7 @@ def _update_clusterhost_config(session, updater, clusterhost, **kwargs):
def package_config_validates(package_config):
cluster = clusterhost.cluster
is_cluster_editable(session, cluster, updater)
is_cluster_editable(session, cluster, user)
metadata_api.validate_package_config(
session, package_config, cluster.adapter_id
)
@ -1149,12 +1147,12 @@ def _update_clusterhost_config(session, updater, clusterhost, **kwargs):
@utils.wrap_to_dict(RESP_CLUSTERHOST_DEPLOYED_CONFIG_FIELDS)
def _update_clusterhost_deployed_config(
session, updater, clusterhost, **kwargs
session, user, clusterhost, **kwargs
):
from compass.db.api import host as host_api
ignore_keys = []
if not host_api.is_host_editable(
session, clusterhost.host, updater,
session, clusterhost.host, user,
exception_when_not_editable=False
):
ignore_keys.append('deployed_os_config')
@ -1165,7 +1163,7 @@ def _update_clusterhost_deployed_config(
def package_config_validates(package_config):
cluster = clusterhost.cluster
is_cluster_editable(session, cluster, updater)
is_cluster_editable(session, cluster, user)
is_clusterhost_validated(session, clusterhost)
@utils.supported_filters(
@ -1195,7 +1193,7 @@ def _update_clusterhost_deployed_config(
permission.PERMISSION_ADD_CLUSTERHOST_CONFIG
)
def update_cluster_host_config(
updater, cluster_id, host_id, session=None, **kwargs
cluster_id, host_id, user=None, session=None, **kwargs
):
"""Update clusterhost config."""
clusterhost = utils.get_db_object(
@ -1203,7 +1201,7 @@ def update_cluster_host_config(
cluster_id=cluster_id, host_id=host_id
)
return _update_clusterhost_config(
session, updater, clusterhost, **kwargs
session, user, clusterhost, **kwargs
)
@ -1216,7 +1214,7 @@ def update_cluster_host_config(
permission.PERMISSION_ADD_CLUSTERHOST_CONFIG
)
def update_cluster_host_deployed_config(
updater, cluster_id, host_id, session=None, **kwargs
cluster_id, host_id, user=None, session=None, **kwargs
):
"""Update clusterhost deployed config."""
clusterhost = utils.get_db_object(
@ -1224,7 +1222,7 @@ def update_cluster_host_deployed_config(
cluster_id=cluster_id, host_id=host_id
)
return _update_clusterhost_deployed_config(
session, updater, clusterhost, **kwargs
session, user, clusterhost, **kwargs
)
@ -1237,14 +1235,14 @@ def update_cluster_host_deployed_config(
permission.PERMISSION_ADD_CLUSTERHOST_CONFIG
)
def update_clusterhost_config(
updater, clusterhost_id, session=None, **kwargs
clusterhost_id, user=None, session=None, **kwargs
):
"""Update clusterhost config."""
clusterhost = utils.get_db_object(
session, models.ClusterHost, clusterhost_id=clusterhost_id
)
return _update_clusterhost_config(
session, updater, clusterhost, **kwargs
session, user, clusterhost, **kwargs
)
@ -1257,23 +1255,23 @@ def update_clusterhost_config(
permission.PERMISSION_ADD_CLUSTERHOST_CONFIG
)
def update_clusterhost_deployed_config(
updater, clusterhost_id, session=None, **kwargs
clusterhost_id, user=None, session=None, **kwargs
):
"""Update clusterhost deployed config."""
clusterhost = utils.get_db_object(
session, models.ClusterHost, clusterhost_id=clusterhost_id
)
return _update_clusterhost_deployed_config(
session, updater, clusterhost, **kwargs
session, user, clusterhost, **kwargs
)
@utils.wrap_to_dict(RESP_CLUSTERHOST_CONFIG_FIELDS)
def _patch_clusterhost_config(session, updater, clusterhost, **kwargs):
def _patch_clusterhost_config(session, user, clusterhost, **kwargs):
from compass.db.api import host as host_api
ignore_keys = []
if not host_api.is_host_editable(
session, clusterhost.host, updater,
session, clusterhost.host, user,
exception_when_not_editable=False
):
ignore_keys.append('patched_os_config')
@ -1284,7 +1282,7 @@ def _patch_clusterhost_config(session, updater, clusterhost, **kwargs):
def package_config_validates(package_config):
cluster = clusterhost.cluster
is_cluster_editable(session, cluster, updater)
is_cluster_editable(session, cluster, user)
metadata_api.validate_package_config(
session, package_config, cluster.adapter_id
)
@ -1316,7 +1314,7 @@ def _patch_clusterhost_config(session, updater, clusterhost, **kwargs):
permission.PERMISSION_ADD_CLUSTERHOST_CONFIG
)
def patch_cluster_host_config(
updater, cluster_id, host_id, session=None, **kwargs
cluster_id, host_id, user=None, session=None, **kwargs
):
"""patch clusterhost config."""
clusterhost = utils.get_db_object(
@ -1324,7 +1322,7 @@ def patch_cluster_host_config(
cluster_id=cluster_id, host_id=host_id
)
return _patch_clusterhost_config(
session, updater, clusterhost, **kwargs
session, user, clusterhost, **kwargs
)
@ -1337,31 +1335,31 @@ def patch_cluster_host_config(
permission.PERMISSION_ADD_CLUSTERHOST_CONFIG
)
def patch_clusterhost_config(
updater, clusterhost_id, session=None, **kwargs
clusterhost_id, user=None, session=None, **kwargs
):
"""patch clusterhost config."""
clusterhost = utils.get_db_object(
session, models.ClusterHost, clusterhost_id=clusterhost_id
)
return _patch_clusterhost_config(
session, updater, clusterhost, **kwargs
session, user, clusterhost, **kwargs
)
@utils.wrap_to_dict(RESP_CLUSTERHOST_CONFIG_FIELDS)
def _delete_clusterhost_config(
session, deleter, clusterhost
session, user, clusterhost
):
from compass.db.api import host as host_api
ignore_keys = []
if not host_api.is_host_editable(
session, clusterhost.host, deleter,
session, clusterhost.host, user,
exception_when_not_editable=False
):
ignore_keys.append('os_config')
def package_config_validates(package_config):
is_cluster_editable(session, clusterhost.cluster, deleter)
is_cluster_editable(session, clusterhost.cluster, user)
@utils.supported_filters(
optional_support_keys=['os_config', 'package_config'],
@ -1388,7 +1386,7 @@ def _delete_clusterhost_config(
permission.PERMISSION_DEL_CLUSTERHOST_CONFIG
)
def delete_cluster_host_config(
deleter, cluster_id, host_id, session=None
cluster_id, host_id, user=None, session=None
):
"""Delete a clusterhost config."""
clusterhost = utils.get_db_object(
@ -1396,7 +1394,7 @@ def delete_cluster_host_config(
cluster_id=cluster_id, host_id=host_id
)
return _delete_clusterhost_config(
session, deleter, clusterhost
session, user, clusterhost
)
@ -1406,13 +1404,13 @@ def delete_cluster_host_config(
permission.PERMISSION_DEL_CLUSTERHOST_CONFIG
)
@utils.wrap_to_dict(RESP_CLUSTERHOST_CONFIG_FIELDS)
def delete_clusterhost_config(deleter, clusterhost_id, session=None):
def delete_clusterhost_config(clusterhost_id, user=None, session=None):
"""Delet a clusterhost config."""
clusterhost = utils.get_db_object(
session, models.ClusterHost, clusterhost_id=clusterhost_id
)
return _delete_clusterhost_config(
session, deleter, clusterhost
session, user, clusterhost
)
@ -1428,14 +1426,14 @@ def delete_clusterhost_config(deleter, clusterhost_id, session=None):
hosts=RESP_CLUSTERHOST_FIELDS
)
def update_cluster_hosts(
updater, cluster_id, add_hosts={}, set_hosts=None,
remove_hosts={}, session=None
cluster_id, add_hosts={}, set_hosts=None,
remove_hosts={}, user=None, session=None
):
"""Update cluster hosts."""
cluster = utils.get_db_object(
session, models.Cluster, id=cluster_id
)
is_cluster_editable(session, cluster, updater)
is_cluster_editable(session, cluster, user)
if remove_hosts:
_remove_clusterhosts(session, cluster, **remove_hosts)
if add_hosts:
@ -1514,13 +1512,13 @@ def validate_cluster(session, cluster):
cluster=RESP_CONFIG_FIELDS,
hosts=RESP_CLUSTERHOST_CONFIG_FIELDS
)
def review_cluster(reviewer, cluster_id, review={}, session=None, **kwargs):
def review_cluster(cluster_id, review={}, user=None, session=None, **kwargs):
"""review cluster."""
from compass.db.api import host as host_api
cluster = utils.get_db_object(
session, models.Cluster, id=cluster_id
)
is_cluster_editable(session, cluster, reviewer)
is_cluster_editable(session, cluster, user)
host_ids = review.get('hosts', [])
clusterhost_ids = review.get('clusterhosts', [])
clusterhosts = []
@ -1542,7 +1540,7 @@ def review_cluster(reviewer, cluster_id, review={}, session=None, **kwargs):
for clusterhost in clusterhosts:
host = clusterhost.host
if not host_api.is_host_editable(
session, host, reviewer, False
session, host, user, False
):
logging.info(
'ignore update host %s config '
@ -1616,7 +1614,7 @@ def review_cluster(reviewer, cluster_id, review={}, session=None, **kwargs):
hosts=RESP_CLUSTERHOST_FIELDS
)
def deploy_cluster(
deployer, cluster_id, deploy={}, session=None, **kwargs
cluster_id, deploy={}, user=None, session=None, **kwargs
):
"""deploy cluster."""
from compass.db.api import host as host_api
@ -1633,13 +1631,13 @@ def deploy_cluster(
clusterhost.host_id in host_ids
):
clusterhosts.append(clusterhost)
is_cluster_editable(session, cluster, deployer)
is_cluster_editable(session, cluster, user)
is_cluster_validated(session, cluster)
utils.update_db_object(session, cluster.state, state='INITIALIZED')
for clusterhost in clusterhosts:
host = clusterhost.host
if host_api.is_host_editable(
session, host, deployer,
session, host, user,
exception_when_not_editable=False
):
host_api.is_host_validated(
@ -1655,7 +1653,7 @@ def deploy_cluster(
celery_client.celery.send_task(
'compass.tasks.deploy_cluster',
(
deployer.email, cluster_id,
user.email, cluster_id,
[clusterhost.host_id for clusterhost in clusterhosts]
)
)
@ -1672,7 +1670,7 @@ def deploy_cluster(
permission.PERMISSION_GET_CLUSTER_STATE
)
@utils.wrap_to_dict(RESP_STATE_FIELDS)
def get_cluster_state(getter, cluster_id, session=None, **kwargs):
def get_cluster_state(cluster_id, user=None, session=None, **kwargs):
"""Get cluster state info."""
return utils.get_db_object(
session, models.Cluster, id=cluster_id
@ -1686,7 +1684,7 @@ def get_cluster_state(getter, cluster_id, session=None, **kwargs):
)
@utils.wrap_to_dict(RESP_CLUSTERHOST_STATE_FIELDS)
def get_cluster_host_state(
getter, cluster_id, host_id, session=None, **kwargs
cluster_id, host_id, user=None, session=None, **kwargs
):
"""Get clusterhost state info."""
return utils.get_db_object(
@ -1702,7 +1700,7 @@ def get_cluster_host_state(
)
@utils.wrap_to_dict(RESP_CLUSTERHOST_STATE_FIELDS)
def get_cluster_host_self_state(
getter, cluster_id, host_id, session=None, **kwargs
cluster_id, host_id, user=None, session=None, **kwargs
):
"""Get clusterhost state info."""
clusterhost = utils.get_db_object(
@ -1722,7 +1720,7 @@ def get_cluster_host_self_state(
)
@utils.wrap_to_dict(RESP_CLUSTERHOST_STATE_FIELDS)
def get_clusterhost_state(
getter, clusterhost_id, session=None, **kwargs
clusterhost_id, user=None, session=None, **kwargs
):
"""Get clusterhost state info."""
return utils.get_db_object(
@ -1738,7 +1736,7 @@ def get_clusterhost_state(
)
@utils.wrap_to_dict(RESP_CLUSTERHOST_STATE_FIELDS)
def get_clusterhost_self_state(
getter, clusterhost_id, session=None, **kwargs
clusterhost_id, user=None, session=None, **kwargs
):
"""Get clusterhost state info."""
return utils.get_db_object(
@ -1757,7 +1755,7 @@ def get_clusterhost_self_state(
)
@utils.wrap_to_dict(RESP_CLUSTERHOST_STATE_FIELDS)
def update_cluster_host_state(
updater, cluster_id, host_id, session=None, **kwargs
cluster_id, host_id, user=None, session=None, **kwargs
):
"""Update a clusterhost state."""
clusterhost = utils.get_db_object(
@ -1778,7 +1776,7 @@ def update_cluster_host_state(
)
@utils.wrap_to_dict(RESP_CLUSTERHOST_STATE_FIELDS)
def update_clusterhost_state(
updater, clusterhost_id, session=None, **kwargs
clusterhost_id, user=None, session=None, **kwargs
):
"""Update a clusterhost state."""
clusterhost = utils.get_db_object(
@ -1799,7 +1797,7 @@ def update_clusterhost_state(
)
@utils.wrap_to_dict(RESP_STATE_FIELDS)
def update_cluster_state(
updater, cluster_id, session=None, **kwargs
cluster_id, user=None, session=None, **kwargs
):
"""Update a cluster state."""
cluster = utils.get_db_object(
@ -1813,7 +1811,7 @@ def update_cluster_state(
@database.run_in_session()
@utils.wrap_to_dict(RESP_CLUSTERHOST_LOG_FIELDS)
def get_cluster_host_log_histories(
getter, cluster_id, host_id, session=None, **kwargs
cluster_id, host_id, user=None, session=None, **kwargs
):
"""Get clusterhost log history."""
return utils.list_db_objects(
@ -1826,7 +1824,7 @@ def get_cluster_host_log_histories(
@database.run_in_session()
@utils.wrap_to_dict(RESP_CLUSTERHOST_LOG_FIELDS)
def get_clusterhost_log_histories(
getter, clusterhost_id,
clusterhost_id, user=None,
session=None, **kwargs
):
"""Get clusterhost log history."""
@ -1839,7 +1837,7 @@ def get_clusterhost_log_histories(
@database.run_in_session()
@utils.wrap_to_dict(RESP_CLUSTERHOST_LOG_FIELDS)
def get_cluster_host_log_history(
getter, cluster_id, host_id, filename, session=None, **kwargs
cluster_id, host_id, filename, user=None, session=None, **kwargs
):
"""Get clusterhost log history."""
return utils.get_db_object(
@ -1852,7 +1850,7 @@ def get_cluster_host_log_history(
@database.run_in_session()
@utils.wrap_to_dict(RESP_CLUSTERHOST_LOG_FIELDS)
def get_clusterhost_log_history(
getter, clusterhost_id, filename, session=None, **kwargs
clusterhost_id, filename, user=None, session=None, **kwargs
):
"""Get host log history."""
return utils.get_db_object(
@ -1868,7 +1866,7 @@ def get_clusterhost_log_history(
@database.run_in_session()
@utils.wrap_to_dict(RESP_CLUSTERHOST_LOG_FIELDS)
def update_cluster_host_log_history(
updater, cluster_id, host_id, filename, session=None, **kwargs
cluster_id, host_id, filename, user=None, session=None, **kwargs
):
"""Update a host log history."""
cluster_host_log_history = utils.get_db_object(
@ -1885,7 +1883,7 @@ def update_cluster_host_log_history(
@database.run_in_session()
@utils.wrap_to_dict(RESP_CLUSTERHOST_LOG_FIELDS)
def update_clusterhost_log_history(
updater, clusterhost_id, filename, session=None, **kwargs
clusterhost_id, filename, user=None, session=None, **kwargs
):
"""Update a host log history."""
clusterhost_log_history = utils.get_db_object(
@ -1903,8 +1901,8 @@ def update_clusterhost_log_history(
@database.run_in_session()
@utils.wrap_to_dict(RESP_CLUSTERHOST_LOG_FIELDS)
def add_clusterhost_log_history(
creator, clusterhost_id, exception_when_existing=False,
filename=None, session=None, **kwargs
clusterhost_id, exception_when_existing=False,
filename=None, user=None, session=None, **kwargs
):
"""add a host log history."""
return utils.add_db_object(
@ -1921,8 +1919,8 @@ def add_clusterhost_log_history(
@database.run_in_session()
@utils.wrap_to_dict(RESP_CLUSTERHOST_LOG_FIELDS)
def add_cluster_host_log_history(
creator, cluster_id, host_id, exception_when_existing=False,
filename=None, session=None, **kwargs
cluster_id, host_id, exception_when_existing=False,
filename=None, user=None, session=None, **kwargs
):
"""add a host log history."""
clusterhost = utils.get_db_object(

4
compass/db/api/database.py
View File

@ -149,9 +149,7 @@ def run_in_session():
def decorator(func):
@functools.wraps(func)
def wrapper(*args, **kwargs):
if args is not () and 'session' in str(args[-1]):
return func(*args, **kwargs)
elif 'session' in kwargs.keys():
if 'session' in kwargs.keys():
return func(*args, **kwargs)
else:
with session() as my_session:

126
compass/db/api/host.py
View File

@ -107,7 +107,7 @@ UPDATED_LOG_FIELDS = [
permission.PERMISSION_LIST_HOSTS
)
@utils.wrap_to_dict(RESP_FIELDS)
def list_hosts(lister, session=None, **filters):
def list_hosts(user=None, session=None, **filters):
"""List hosts."""
return utils.list_db_objects(
session, models.Host, **filters
@ -128,7 +128,7 @@ def list_hosts(lister, session=None, **filters):
os_id=utils.general_filter_callback
)
@utils.wrap_to_dict(RESP_FIELDS)
def list_machines_or_hosts(lister, session=None, **filters):
def list_machines_or_hosts(user=None, session=None, **filters):
"""List hosts."""
machines = utils.list_db_objects(
session, models.Machine, **filters
@ -150,8 +150,8 @@ def list_machines_or_hosts(lister, session=None, **filters):
)
@utils.wrap_to_dict(RESP_FIELDS)
def get_host(
getter, host_id,
exception_when_missing=True, session=None, **kwargs
host_id, exception_when_missing=True,
user=None, session=None, **kwargs
):
"""get host info."""
return utils.get_db_object(
@ -167,8 +167,8 @@ def get_host(
)
@utils.wrap_to_dict(RESP_FIELDS)
def get_machine_or_host(
getter, host_id,
exception_when_missing=True, session=None, **kwargs
host_id, exception_when_missing=True,
user=None, session=None, **kwargs
):
"""get host info."""
machine = utils.get_db_object(
@ -190,7 +190,7 @@ def get_machine_or_host(
permission.PERMISSION_LIST_HOST_CLUSTERS
)
@utils.wrap_to_dict(RESP_CLUSTER_FIELDS)
def get_host_clusters(getter, host_id, session=None, **kwargs):
def get_host_clusters(host_id, user=None, session=None, **kwargs):
"""get host clusters."""
host = utils.get_db_object(
session, models.Host, id=host_id
@ -276,13 +276,13 @@ def validate_host(session, host):
)
@utils.input_validates(name=utils.check_name)
@utils.wrap_to_dict(RESP_FIELDS)
def _update_host(session, updater, host_id, **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, updater,
session, host, user,
reinstall_os_set=kwargs.get('reinstall_os', False)
)
if 'name' in kwargs:
@ -303,19 +303,19 @@ def _update_host(session, updater, host_id, **kwargs):
@user_api.check_user_permission_in_session(
permission.PERMISSION_UPDATE_HOST
)
def update_host(updater, host_id, session=None, **kwargs):
def update_host(host_id, user=None, session=None, **kwargs):
"""Update a host."""
return _update_host(session, updater, host_id=host_id, **kwargs)
return _update_host(session, user, host_id=host_id, **kwargs)
@database.run_in_session()
@user_api.check_user_permission_in_session(
permission.PERMISSION_UPDATE_HOST
)
def update_hosts(updater, data=[], session=None):
def update_hosts(data=[], user=None, session=None):
hosts = []
for host_data in data:
hosts.append(_update_host(session, updater, **host_data))
hosts.append(_update_host(session, user, **host_data))
return hosts
@ -329,8 +329,8 @@ def update_hosts(updater, data=[], session=None):
host=RESP_FIELDS
)
def del_host(
deleter, host_id,
force=False, from_database_only=False, session=None, **kwargs
host_id, force=False, from_database_only=False,
user=None, session=None, **kwargs
):
"""Delete a host."""
from compass.db.api import cluster as cluster_api
@ -340,7 +340,7 @@ def del_host(
if host.state.state != 'UNINITIALIZED' and force:
host.state.state = 'ERROR'
is_host_editable(
session, host, deleter,
session, host, user,
reinstall_os_set=True
)
cluster_ids = []
@ -348,7 +348,7 @@ def del_host(
if clusterhost.state.state != 'UNINITIALIZED' and force:
clusterhost.state.state = 'ERROR'
cluster_api.is_cluster_editable(
session, clusterhost.cluster, deleter,
session, clusterhost.cluster, user,
reinstall_distributed_system_set=True
)
cluster_ids.append(clusterhost.cluster_id)
@ -363,7 +363,7 @@ def del_host(
celery_client.celery.send_task(
'compass.tasks.delete_host',
(
deleter.email, host_id, cluster_ids
user.email, host_id, cluster_ids
)
)
return {
@ -378,7 +378,7 @@ def del_host(
permission.PERMISSION_LIST_HOST_CONFIG
)
@utils.wrap_to_dict(RESP_CONFIG_FIELDS)
def get_host_config(getter, host_id, session=None, **kwargs):
def get_host_config(host_id, user=None, session=None, **kwargs):
"""Get host config."""
return utils.get_db_object(
session, models.Host, id=host_id
@ -391,7 +391,7 @@ def get_host_config(getter, host_id, session=None, **kwargs):
permission.PERMISSION_LIST_HOST_CONFIG
)
@utils.wrap_to_dict(RESP_DEPLOYED_CONFIG_FIELDS)
def get_host_deployed_config(getter, host_id, session=None, **kwargs):
def get_host_deployed_config(host_id, user=None, session=None, **kwargs):
"""Get host deployed config."""
return utils.get_db_object(
session, models.Host, id=host_id
@ -410,20 +410,20 @@ def get_host_deployed_config(getter, host_id, session=None, **kwargs):
permission.PERMISSION_ADD_HOST_CONFIG
)
@utils.wrap_to_dict(RESP_CONFIG_FIELDS)
def update_host_deployed_config(updater, host_id, session=None, **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, updater)
is_host_editable(session, host, user)
is_host_validated(session, host)
return utils.update_db_object(session, host, **kwargs)
@utils.wrap_to_dict(RESP_CONFIG_FIELDS)
def _update_host_config(session, updater, host, **kwargs):
def _update_host_config(session, user, host, **kwargs):
"""Update host config."""
is_host_editable(session, host, updater)
is_host_editable(session, host, user)
return utils.update_db_object(session, host, **kwargs)
@ -438,7 +438,7 @@ def _update_host_config(session, updater, host, **kwargs):
@user_api.check_user_permission_in_session(
permission.PERMISSION_ADD_HOST_CONFIG
)
def update_host_config(updater, host_id, session=None, **kwargs):
def update_host_config(host_id, user=None, session=None, **kwargs):
host = utils.get_db_object(
session, models.Host, id=host_id
)
@ -453,7 +453,7 @@ def update_host_config(updater, host_id, session=None, **kwargs):
)
def update_config_internal(host, **in_kwargs):
return _update_host_config(
session, updater, host, **kwargs
session, user, host, **kwargs
)
return update_config_internal(
@ -472,7 +472,7 @@ def update_host_config(updater, host_id, session=None, **kwargs):
@user_api.check_user_permission_in_session(
permission.PERMISSION_ADD_HOST_CONFIG
)
def patch_host_config(updater, host_id, session=None, **kwargs):
def patch_host_config(host_id, user=None, session=None, **kwargs):
host = utils.get_db_object(
session, models.Host, id=host_id
)
@ -487,7 +487,7 @@ def patch_host_config(updater, host_id, session=None, **kwargs):
)
def patch_config_internal(host, **in_kwargs):
return _update_host_config(
session, updater, host, **in_kwargs
session, user, host, **in_kwargs
)
return patch_config_internal(
@ -501,12 +501,12 @@ def patch_host_config(updater, host_id, session=None, **kwargs):
permission.PERMISSION_DEL_HOST_CONFIG
)
@utils.wrap_to_dict(RESP_CONFIG_FIELDS)
def del_host_config(deleter, host_id, session=None):
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, deleter)
is_host_editable(session, host, user)
return utils.update_db_object(
session, host, os_config={}, config_validated=False
)
@ -520,7 +520,7 @@ def del_host_config(deleter, host_id, session=None):
permission.PERMISSION_LIST_HOST_NETWORKS
)
@utils.wrap_to_dict(RESP_NETWORK_FIELDS)
def list_host_networks(lister, host_id, session=None, **filters):
def list_host_networks(host_id, user=None, session=None, **filters):
"""Get host networks."""
return utils.list_db_objects(
session, models.HostNetwork,
@ -536,7 +536,7 @@ def list_host_networks(lister, host_id, session=None, **filters):
permission.PERMISSION_LIST_HOST_NETWORKS
)
@utils.wrap_to_dict(RESP_NETWORK_FIELDS)
def list_hostnetworks(lister, session=None, **filters):
def list_hostnetworks(user=None, session=None, **filters):
"""Get host networks."""
return utils.list_db_objects(
session, models.HostNetwork, **filters
@ -550,8 +550,8 @@ def list_hostnetworks(lister, session=None, **filters):
)
@utils.wrap_to_dict(RESP_NETWORK_FIELDS)
def get_host_network(
getter, host_id,
host_network_id, session=None, **kwargs
host_id, host_network_id,
user=None, session=None, **kwargs
):
"""Get host network."""
host_network = utils.get_db_object(
@ -573,7 +573,7 @@ def get_host_network(
permission.PERMISSION_LIST_HOST_NETWORKS
)
@utils.wrap_to_dict(RESP_NETWORK_FIELDS)
def get_hostnetwork(getter, host_network_id, session=None, **kwargs):
def get_hostnetwork(host_network_id, user=None, session=None, **kwargs):
"""Get host network."""
return utils.get_db_object(
session, models.HostNetwork,
@ -591,7 +591,7 @@ def get_hostnetwork(getter, host_network_id, session=None, **kwargs):
)
@utils.wrap_to_dict(RESP_NETWORK_FIELDS)
def _add_host_network(
session, creator, host_id, exception_when_existing=True,
session, user, host_id, exception_when_existing=True,
interface=None, ip=None, **kwargs
):
host = utils.get_db_object(
@ -613,7 +613,7 @@ def _add_host_network(
ip, host_network.id
)
)
is_host_editable(session, host, creator)
is_host_editable(session, host, user)
return utils.add_db_object(
session, models.HostNetwork,
exception_when_existing,
@ -626,13 +626,12 @@ def _add_host_network(
permission.PERMISSION_ADD_HOST_NETWORK
)
def add_host_network(
creator, host_id,
exception_when_existing=True,
interface=None, session=None, **kwargs
host_id, exception_when_existing=True,
interface=None, user=None, session=None, **kwargs
):
"""Create a host network."""
return _add_host_network(
session, creator, host_id, exception_when_existing,
session, user, host_id, exception_when_existing,
interface=interface, **kwargs
)
@ -642,9 +641,8 @@ def add_host_network(
permission.PERMISSION_ADD_HOST_NETWORK
)
def add_host_networks(
creator,
exception_when_existing=False,
data=[], session=None
data=[], user=None, session=None
):
"""Create host networks."""
hosts = []
@ -657,7 +655,7 @@ def add_host_networks(
for network in networks:
try:
host_networks.append(_add_host_network(
session, creator, host_id, exception_when_existing,
session, user, host_id, exception_when_existing,
**network
))
except exception.DatabaseException as error:
@ -677,7 +675,7 @@ def add_host_networks(
@utils.wrap_to_dict(RESP_NETWORK_FIELDS)
def _update_host_network(
session, updater, host_network, **kwargs
session, user, host_network, **kwargs
):
if 'interface' in kwargs:
interface = kwargs['interface']
@ -708,7 +706,7 @@ def _update_host_network(
ip, host_network_by_ip.id
)
)
is_host_editable(session, host_network.host, updater)
is_host_editable(session, host_network.host, user)
return utils.update_db_object(session, host_network, **kwargs)
@ -724,7 +722,7 @@ def _update_host_network(
permission.PERMISSION_ADD_HOST_NETWORK
)
def update_host_network(
updater, host_id, host_network_id, session=None, **kwargs
host_id, host_network_id, user=None, session=None, **kwargs
):
"""Update a host network."""
host_network = utils.get_db_object(
@ -738,7 +736,7 @@ def update_host_network(
)
)
return _update_host_network(
session, updater, host_network, **kwargs
session, user, host_network, **kwargs
)
@ -753,13 +751,13 @@ def update_host_network(
@user_api.check_user_permission_in_session(
permission.PERMISSION_ADD_HOST_NETWORK
)
def update_hostnetwork(updater, host_network_id, session=None, **kwargs):
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, updater, host_network, **kwargs
session, user, host_network, **kwargs
)
@ -770,7 +768,7 @@ def update_hostnetwork(updater, host_network_id, session=None, **kwargs):
)
@utils.wrap_to_dict(RESP_NETWORK_FIELDS)
def del_host_network(
deleter, host_id, host_network_id,
host_id, host_network_id, user=None,
session=None, **kwargs
):
"""Delete a host network."""
@ -784,7 +782,7 @@ def del_host_network(
host_id, host_network_id
)
)
is_host_editable(session, host_network.host, deleter)
is_host_editable(session, host_network.host, user)
return utils.del_db_object(session, host_network)
@ -794,12 +792,12 @@ def del_host_network(
permission.PERMISSION_DEL_HOST_NETWORK
)
@utils.wrap_to_dict(RESP_NETWORK_FIELDS)
def del_hostnetwork(deleter, host_network_id, session=None, **kwargs):
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, deleter)
is_host_editable(session, host_network.host, user)
return utils.del_db_object(session, host_network)
@ -809,7 +807,7 @@ def del_hostnetwork(deleter, host_network_id, session=None, **kwargs):
permission.PERMISSION_GET_HOST_STATE
)
@utils.wrap_to_dict(RESP_STATE_FIELDS)
def get_host_state(getter, host_id, session=None, **kwargs):
def get_host_state(host_id, user=None, session=None, **kwargs):
"""Get host state info."""
return utils.get_db_object(
session, models.Host, id=host_id
@ -825,7 +823,7 @@ def get_host_state(getter, host_id, session=None, **kwargs):
permission.PERMISSION_UPDATE_HOST_STATE
)
@utils.wrap_to_dict(RESP_STATE_FIELDS)
def update_host_state(updater, host_id, session=None, **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
@ -837,7 +835,7 @@ def update_host_state(updater, host_id, session=None, **kwargs):
@utils.supported_filters([])
@database.run_in_session()
@utils.wrap_to_dict(RESP_LOG_FIELDS)
def get_host_log_histories(getter, host_id, session=None, **kwargs):
def get_host_log_histories(host_id, user=None, session=None, **kwargs):
"""Get host log history."""
return utils.list_db_objects(
session, models.HostLogHistory, id=host_id
@ -847,7 +845,7 @@ def get_host_log_histories(getter, host_id, session=None, **kwargs):
@utils.supported_filters([])
@database.run_in_session()
@utils.wrap_to_dict(RESP_LOG_FIELDS)
def get_host_log_history(getter, host_id, filename, session=None, **kwargs):
def get_host_log_history(host_id, filename, user=None, session=None, **kwargs):
"""Get host log history."""
return utils.get_db_object(
session, models.HostLogHistory, id=host_id, filename=filename
@ -861,7 +859,7 @@ def get_host_log_history(getter, host_id, filename, session=None, **kwargs):
@database.run_in_session()
@utils.wrap_to_dict(RESP_LOG_FIELDS)
def update_host_log_history(
updater, host_id, filename,
host_id, filename, user=None,
session=None, **kwargs
):
"""Update a host log history."""
@ -879,8 +877,8 @@ def update_host_log_history(
@database.run_in_session()
@utils.wrap_to_dict(RESP_LOG_FIELDS)
def add_host_log_history(
creator, host_id, exception_when_existing=False,
filename=None, session=None, **kwargs
host_id, exception_when_existing=False,
filename=None, user=None, session=None, **kwargs
):
"""add a host log history."""
return utils.add_db_object(
@ -899,7 +897,7 @@ def add_host_log_history(
host=RESP_CONFIG_FIELDS
)
def poweron_host(
deployer, host_id, poweron={}, session=None, **kwargs
host_id, poweron={}, user=None, session=None, **kwargs
):
"""power on host."""
from compass.tasks import client as celery_client
@ -927,7 +925,7 @@ def poweron_host(
host=RESP_CONFIG_FIELDS
)
def poweroff_host(
deployer, host_id, poweroff={}, session=None, **kwargs
host_id, poweroff={}, user=None, session=None, **kwargs
):
"""power off host."""
from compass.tasks import client as celery_client
@ -955,7 +953,7 @@ def poweroff_host(
host=RESP_CONFIG_FIELDS
)
def reset_host(
deployer, host_id, reset={}, session=None, **kwargs
host_id, reset={}, user=None, session=None, **kwargs
):
"""reset host."""
from compass.tasks import client as celery_client

28
compass/db/api/machine.py
View File

@ -50,9 +50,8 @@ RESP_DEPLOY_FIELDS = [
)
@utils.wrap_to_dict(RESP_FIELDS)
def get_machine(
getter, machine_id,
exception_when_missing=True, session=None,
**kwargs
machine_id, exception_when_missing=True,
user=None, session=None, **kwargs
):
"""get field dict of a machine."""
return utils.get_db_object(
@ -73,7 +72,7 @@ def get_machine(
location=utils.general_filter_callback
)
@utils.wrap_to_dict(RESP_FIELDS)
def list_machines(lister, session=None, **filters):
def list_machines(user=None, session=None, **filters):
"""List machines."""
return utils.list_db_objects(
session, models.Machine, **filters
@ -81,7 +80,7 @@ def list_machines(lister, session=None, **filters):
@utils.wrap_to_dict(RESP_FIELDS)
def _update_machine(session, updater, machine_id, **kwargs):
def _update_machine(session, 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)
@ -96,9 +95,9 @@ def _update_machine(session, updater, machine_id, **kwargs):
@user_api.check_user_permission_in_session(
permission.PERMISSION_ADD_MACHINE
)
def update_machine(updater, machine_id, session=None, **kwargs):
def update_machine(machine_id, user=None, session=None, **kwargs):
return _update_machine(
session, updater, machine_id, **kwargs
session, machine_id, **kwargs
)
@ -113,9 +112,12 @@ def update_machine(updater, machine_id, session=None, **kwargs):
)
@database.run_in_session()
@utils.output_validates(ipmi_credentials=utils.check_ipmi_credentials)
def patch_machine(updater, machine_id, session=None, **kwargs):
@user_api.check_user_permission_in_session(
permission.PERMISSION_ADD_MACHINE
)
def patch_machine(machine_id, user=None, session=None, **kwargs):
return _update_machine(
session, updater, machine_id, **kwargs
session, machine_id, **kwargs
)
@ -125,7 +127,7 @@ def patch_machine(updater, machine_id, session=None, **kwargs):
permission.PERMISSION_DEL_MACHINE
)
@utils.wrap_to_dict(RESP_FIELDS)
def del_machine(deleter, machine_id, session=None, **kwargs):
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:
@ -148,7 +150,7 @@ def del_machine(deleter, machine_id, session=None, **kwargs):
machine=RESP_FIELDS
)
def poweron_machine(
deployer, machine_id, poweron={}, session=None, **kwargs
machine_id, poweron={}, user=None, session=None, **kwargs
):
"""power on machine."""
from compass.tasks import client as celery_client
@ -175,7 +177,7 @@ def poweron_machine(
machine=RESP_FIELDS
)
def poweroff_machine(
deployer, machine_id, poweroff={}, session=None, **kwargs
machine_id, poweroff={}, user=None, session=None, **kwargs
):
"""power off machine."""
from compass.tasks import client as celery_client
@ -202,7 +204,7 @@ def poweroff_machine(
machine=RESP_FIELDS
)
def reset_machine(
deployer, machine_id, reset={}, session=None, **kwargs
machine_id, reset={}, user=None, session=None, **kwargs
):
"""reset machine."""
from compass.tasks import client as celery_client

14
compass/db/api/network.py
View File

@ -51,7 +51,7 @@ def _check_subnet(subnet):
permission.PERMISSION_LIST_SUBNETS
)
@utils.wrap_to_dict(RESP_FIELDS)
def list_subnets(lister, session=None, **filters):
def list_subnets(user=None, session=None, **filters):
"""List subnets."""
return utils.list_db_objects(
session, models.Subnet, **filters
@ -65,8 +65,8 @@ def list_subnets(lister, session=None, **filters):
)
@utils.wrap_to_dict(RESP_FIELDS)
def get_subnet(
getter, subnet_id,
exception_when_missing=True, session=None, **kwargs
subnet_id, exception_when_missing=True,
user=None, session=None, **kwargs
):
"""Get subnet info."""
return utils.get_db_object(
@ -86,8 +86,8 @@ def get_subnet(
)
@utils.wrap_to_dict(RESP_FIELDS)
def add_subnet(
creator, exception_when_existing=True,
subnet=None, session=None, **kwargs
exception_when_existing=True, subnet=None,
user=None, session=None, **kwargs
):
"""Create a subnet."""
return utils.add_db_object(
@ -106,7 +106,7 @@ def add_subnet(
permission.PERMISSION_ADD_SUBNET
)
@utils.wrap_to_dict(RESP_FIELDS)
def update_subnet(updater, subnet_id, session=None, **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
@ -120,7 +120,7 @@ def update_subnet(updater, subnet_id, session=None, **kwargs):
permission.PERMISSION_DEL_SUBNET
)
@utils.wrap_to_dict(RESP_FIELDS)
def del_subnet(deleter, subnet_id, session=None, **kwargs):
def del_subnet(subnet_id, user=None, session=None, **kwargs):
"""Delete a subnet."""
subnet = utils.get_db_object(
session, models.Subnet, id=subnet_id

6
compass/db/api/permission.py
View File

@ -300,7 +300,7 @@ def list_permissions_internal(session, **filters):
@database.run_in_session()
@user_api.check_user_permission_in_session(PERMISSION_LIST_PERMISSIONS)
@utils.wrap_to_dict(RESP_FIELDS)
def list_permissions(lister, session=None, **filters):
def list_permissions(user=None, session=None, **filters):
"""list permissions."""
return utils.list_db_objects(
session, models.Permission, **filters
@ -312,8 +312,8 @@ def list_permissions(lister, session=None, **filters):
@user_api.check_user_permission_in_session(PERMISSION_LIST_PERMISSIONS)
@utils.wrap_to_dict(RESP_FIELDS)
def get_permission(
getter, permission_id,
exception_when_missing=True, session=None, **kwargs
permission_id, exception_when_missing=True,
user=None, session=None, **kwargs
):
"""get permissions."""
return utils.get_db_object(

91
compass/db/api/switch.py
View File

@ -140,8 +140,8 @@ def get_switch_internal(
)
@utils.wrap_to_dict(RESP_FIELDS)
def get_switch(
getter, switch_id,
exception_when_missing=True, session=None, **kwargs
switch_id, exception_when_missing=True,
user=None, session=None, **kwargs
):
"""get field dict of a switch."""
return utils.get_db_object(
@ -156,7 +156,7 @@ def get_switch(
permission.PERMISSION_LIST_SWITCHES
)
@utils.wrap_to_dict(RESP_FIELDS)
def list_switches(lister, session=None, **filters):
def list_switches(user=None, session=None, **filters):
"""List switches."""
switches = utils.list_db_objects(
session, models.Switch, **filters
@ -176,7 +176,7 @@ def list_switches(lister, session=None, **filters):
permission.PERMISSION_DEL_SWITCH
)
@utils.wrap_to_dict(RESP_FIELDS)
def del_switch(deleter, switch_id, session=None, **kwargs):
def del_switch(switch_id, user=None, session=None, **kwargs):
"""Delete a switch."""
switch = utils.get_db_object(session, models.Switch, id=switch_id)
default_switch_ip_int = long(netaddr.IPAddress(setting.DEFAULT_SWITCH_IP))
@ -212,8 +212,8 @@ def del_switch(deleter, switch_id, session=None, **kwargs):
)
@utils.wrap_to_dict(RESP_FIELDS)
def add_switch(
creator, exception_when_existing=True,
ip=None, session=None, **kwargs
exception_when_existing=True, ip=None,
user=None, session=None, **kwargs
):
"""Create a switch."""
ip_int = long(netaddr.IPAddress(ip))
@ -231,7 +231,7 @@ def update_switch_internal(session, switch, **kwargs):
@utils.wrap_to_dict(RESP_FIELDS)
def _update_switch(session, updater, switch_id, **kwargs):
def _update_switch(session, switch_id, **kwargs):
"""Update a switch."""
switch = utils.get_db_object(
session, models.Switch, id=switch_id
@ -254,9 +254,9 @@ def _update_switch(session, updater, switch_id, **kwargs):
@user_api.check_user_permission_in_session(
permission.PERMISSION_ADD_SWITCH
)
def update_switch(updater, switch_id, session=None, **kwargs):
def update_switch(switch_id, user=None, session=None, **kwargs):
"""Update fields of a switch."""
return _update_switch(session, updater, switch_id, **kwargs)
return _update_switch(session, switch_id, **kwargs)
@utils.replace_filters(
@ -274,9 +274,12 @@ def update_switch(updater, switch_id, session=None, **kwargs):
@utils.output_validates(
credentials=utils.check_switch_credentials
)
def patch_switch(updater, switch_id, session=None, **kwargs):
@user_api.check_user_permission_in_session(
permission.PERMISSION_ADD_SWITCH
)
def patch_switch(switch_id, user=None, session=None, **kwargs):
"""Patch fields of a switch."""
return _update_switch(session, updater, switch_id, **kwargs)
return _update_switch(session, switch_id, **kwargs)
@utils.supported_filters(optional_support_keys=SUPPORTED_FILTER_FIELDS)
@ -285,7 +288,7 @@ def patch_switch(updater, switch_id, session=None, **kwargs):
permission.PERMISSION_LIST_SWITCH_FILTERS
)
@utils.wrap_to_dict(RESP_FILTERS_FIELDS)
def list_switch_filters(lister, session=None, **filters):
def list_switch_filters(user=None, session=None, **filters):
"""List switch filters."""
return utils.list_db_objects(
session, models.Switch, **filters
@ -299,7 +302,7 @@ def list_switch_filters(lister, session=None, **filters):
)
@utils.wrap_to_dict(RESP_FILTERS_FIELDS)
def get_switch_filters(
getter, switch_id, session=None, **kwargs
switch_id, user=None, session=None, **kwargs
):
"""get switch filter."""
return utils.get_db_object(
@ -320,7 +323,7 @@ def get_switch_filters(
permission.PERMISSION_UPDATE_SWITCH_FILTERS
)
@utils.wrap_to_dict(RESP_FILTERS_FIELDS)
def update_switch_filters(updater, switch_id, session=None, **kwargs):
def update_switch_filters(switch_id, user=None, session=None, **kwargs):
"""Update a switch filter."""
switch = utils.get_db_object(session, models.Switch, id=switch_id)
return utils.update_db_object(session, switch, **kwargs)
@ -339,7 +342,7 @@ def update_switch_filters(updater, switch_id, session=None, **kwargs):
permission.PERMISSION_UPDATE_SWITCH_FILTERS
)
@utils.wrap_to_dict(RESP_FILTERS_FIELDS)
def patch_switch_filter(updater, switch_id, session=None, **kwargs):
def patch_switch_filter(switch_id, user=None, session=None, **kwargs):
"""Patch a switch filter."""
switch = utils.get_db_object(session, models.Switch, id=switch_id)
return utils.update_db_object(session, switch, **kwargs)
@ -405,7 +408,7 @@ def _filter_vlans(vlan_filter, obj):
location=utils.general_filter_callback
)
@utils.wrap_to_dict(RESP_MACHINES_FIELDS)
def _filter_switch_machines(session, user, switch_machines):
def _filter_switch_machines(session, switch_machines):
return [
switch_machine for switch_machine in switch_machines
if not switch_machine.filtered
@ -424,7 +427,7 @@ def _filter_switch_machines(session, user, switch_machines):
RESP_MACHINES_HOSTS_FIELDS,
clusters=RESP_CLUSTER_FIELDS
)
def _filter_switch_machines_hosts(session, user, switch_machines):
def _filter_switch_machines_hosts(session, switch_machines):
filtered_switch_machines = [
switch_machine for switch_machine in switch_machines
if not switch_machine.filtered
@ -451,12 +454,12 @@ def _filter_switch_machines_hosts(session, user, switch_machines):
@user_api.check_user_permission_in_session(
permission.PERMISSION_LIST_SWITCH_MACHINES
)
def list_switch_machines(getter, switch_id, session=None, **filters):
def list_switch_machines(switch_id, user=None, session=None, **filters):
"""Get switch machines."""
switch_machines = get_switch_machines_internal(
session, switch_id=switch_id, **filters
)
return _filter_switch_machines(session, getter, switch_machines)
return _filter_switch_machines(session, switch_machines)
@utils.replace_filters(
@ -469,13 +472,13 @@ def list_switch_machines(getter, switch_id, session=None, **filters):
@user_api.check_user_permission_in_session(
permission.PERMISSION_LIST_SWITCH_MACHINES
)
def list_switchmachines(lister, session=None, **filters):
def list_switchmachines(user=None, session=None, **filters):
"""List switch machines."""
switch_machines = get_switch_machines_internal(
session, **filters
)
return _filter_switch_machines(
session, lister, switch_machines
session, switch_machines
)
@ -486,13 +489,13 @@ def list_switchmachines(lister, session=None, **filters):
@user_api.check_user_permission_in_session(
permission.PERMISSION_LIST_SWITCH_MACHINES
)
def list_switch_machines_hosts(getter, switch_id, session=None, **filters):
def list_switch_machines_hosts(switch_id, user=None, session=None, **filters):
"""Get switch machines hosts."""
switch_machines = get_switch_machines_internal(
session, switch_id=switch_id, **filters
)
return _filter_switch_machines_hosts(
session, getter, switch_machines
session, switch_machines
)
@ -506,7 +509,7 @@ def list_switch_machines_hosts(getter, switch_id, session=None, **filters):
@user_api.check_user_permission_in_session(
permission.PERMISSION_LIST_SWITCH_MACHINES
)
def list_switchmachines_hosts(lister, session=None, **filters):
def list_switchmachines_hosts(user=None, session=None, **filters):
"""List switch machines hosts."""
switch_machines = get_switch_machines_internal(
session, **filters
@ -518,7 +521,7 @@ def list_switchmachines_hosts(lister, session=None, **filters):
switch_machine for switch_machine in switch_machines
]
return _filter_switch_machines_hosts(
session, lister, filtered_switch_machines
session, filtered_switch_machines
)
@ -534,9 +537,8 @@ def list_switchmachines_hosts(lister, session=None, **filters):
)
@utils.wrap_to_dict(RESP_MACHINES_FIELDS)
def add_switch_machine(
creator, switch_id,
exception_when_existing=True,
mac=None, session=None, **kwargs
switch_id, exception_when_existing=True,
mac=None, user=None, session=None, **kwargs
):
"""Add switch machine."""
switch = utils.get_db_object(
@ -566,13 +568,13 @@ def add_switch_machine(
permission.PERMISSION_UPDATE_SWITCH_MACHINES
)
@utils.wrap_to_dict(RESP_ACTION_FIELDS)
def poll_switch_machines(poller, switch_id, session=None, **kwargs):
def poll_switch_machines(switch_id, user=None, session=None, **kwargs):
"""poll switch machines."""
from compass.tasks import client as celery_client
switch = utils.get_db_object(session, models.Switch, id=switch_id)
celery_client.celery.send_task(
'compass.tasks.pollswitch',
(poller.email, switch.ip, switch.credentials)
(user.email, switch.ip, switch.credentials)
)
return {
'status': 'action %s sent' % kwargs,
@ -588,8 +590,8 @@ def poll_switch_machines(poller, switch_id, session=None, **kwargs):
)
@utils.wrap_to_dict(RESP_MACHINES_FIELDS)
def get_switch_machine(
getter, switch_id, machine_id,
exception_when_missing=True, session=None, **kwargs
switch_id, machine_id, exception_when_missing=True,
user=None, session=None, **kwargs
):
"""get field dict of a switch machine."""
return utils.get_db_object(
@ -606,9 +608,8 @@ def get_switch_machine(
)
@utils.wrap_to_dict(RESP_MACHINES_FIELDS)
def get_switchmachine(
getter, switch_machine_id,
exception_when_missing=True, session=None,
**kwargs
switch_machine_id, exception_when_missing=True,
user=None, session=None, **kwargs
):
"""get field dict of a switch machine."""
return utils.get_db_object(
@ -648,7 +649,7 @@ def update_switch_machine_internal(
)
@utils.wrap_to_dict(RESP_MACHINES_FIELDS)
def update_switch_machine(
updater, switch_id, machine_id,
switch_id, machine_id, user=None,
session=None, **kwargs
):
"""Update switch machine."""
@ -672,7 +673,7 @@ def update_switch_machine(
permission.PERMISSION_ADD_SWITCH_MACHINE
)
@utils.wrap_to_dict(RESP_MACHINES_FIELDS)
def update_switchmachine(updater, switch_machine_id, session=None, **kwargs):
def update_switchmachine(switch_machine_id, user=None, session=None, **kwargs):
"""Update switch machine."""
switch_machine = utils.get_db_object(
session, models.SwitchMachine,
@ -701,7 +702,7 @@ def update_switchmachine(updater, switch_machine_id, session=None, **kwargs):
)
@utils.wrap_to_dict(RESP_MACHINES_FIELDS)
def patch_switch_machine(
updater, switch_id, machine_id,
switch_id, machine_id, user=None,
session=None, **kwargs
):
"""Patch switch machine."""
@ -731,7 +732,7 @@ def patch_switch_machine(
permission.PERMISSION_ADD_SWITCH_MACHINE
)
@utils.wrap_to_dict(RESP_MACHINES_FIELDS)
def patch_switchmachine(updater, switch_machine_id, session=None, **kwargs):
def patch_switchmachine(switch_machine_id, user=None, session=None, **kwargs):
"""Patch switch machine."""
switch_machine = utils.get_db_object(
session, models.SwitchMachine,
@ -749,7 +750,10 @@ def patch_switchmachine(updater, switch_machine_id, session=None, **kwargs):
permission.PERMISSION_DEL_SWITCH_MACHINE
)
@utils.wrap_to_dict(RESP_MACHINES_FIELDS)
def del_switch_machine(deleter, switch_id, machine_id, session=None, **kwargs):
def del_switch_machine(
switch_id, machine_id, user=None,
session=None, **kwargs
):
"""Delete switch machine by switch id and machine id."""
switch_machine = utils.get_db_object(
session, models.SwitchMachine,
@ -777,7 +781,7 @@ def del_switch_machine(deleter, switch_id, machine_id, session=None, **kwargs):
permission.PERMISSION_DEL_SWITCH_MACHINE
)
@utils.wrap_to_dict(RESP_MACHINES_FIELDS)
def del_switchmachine(deleter, switch_machine_id, session=None, **kwargs):
def del_switchmachine(switch_machine_id, user=None, session=None, **kwargs):
"""Delete switch machine by switch_machine_id."""
switch_machine = utils.get_db_object(
session, models.SwitchMachine,
@ -847,9 +851,8 @@ def _set_machines(session, switch, machines):
)
@utils.wrap_to_dict(RESP_MACHINES_FIELDS)
def update_switch_machines(
updater, switch_id,
add_machines=[], remove_machines=[],
set_machines=None, session=None, **kwargs
switch_id, add_machines=[], remove_machines=[],
set_machines=None, user=None, session=None, **kwargs
):
"""update switch machines."""
switch = utils.get_db_object(

73
compass/db/api/user.py
View File

@ -101,13 +101,14 @@ def _check_user_permission(session, user, permission):
def check_user_permission_in_session(permission):
def decorator(func):
@functools.wraps(func)
def wrapper(user, *args, **kwargs):
if 'session' in kwargs.keys():
def wrapper(*args, **kwargs):
if 'user' in kwargs.keys() and 'session' in kwargs.keys():
session = kwargs['session']
else:
session = args[-1]
user = kwargs['user']
_check_user_permission(session, user, permission)
return func(user, *args, **kwargs)
return func(*args, **kwargs)
else:
return func(*args, **kwargs)
return wrapper
return decorator
@ -115,14 +116,18 @@ def check_user_permission_in_session(permission):
def check_user_admin():
def decorator(func):
@functools.wraps(func)
def wrapper(user, *args, **kwargs):
def wrapper(*args, **kwargs):
if 'user' in kwargs.keys():
user = kwargs['user']
if not user.is_admin:
raise exception.Forbidden(
'User %s is not admin.' % (
user.email
)
)
return func(user, *args, **kwargs)
return func(*args, **kwargs)
else:
return func(*args, **kwargs)
return wrapper
return decorator
@ -130,14 +135,18 @@ def check_user_admin():
def check_user_admin_or_owner():
def decorator(func):
@functools.wraps(func)
def wrapper(user, user_id, *args, **kwargs):
def wrapper(user_id, *args, **kwargs):
if 'user' in kwargs.keys():
user = kwargs['user']
if not user.is_admin and user.id != user_id:
raise exception.Forbidden(
'User %s is not admin or the owner of user id %s.' % (
user.email, user_id
)
)
return func(user, user_id, *args, **kwargs)
return func(user_id, *args, **kwargs)
else:
return func(user_id, *args, **kwargs)
return wrapper
return decorator
@ -266,7 +275,7 @@ def get_user_object_from_token(token, session=None):
@database.run_in_session()
@utils.wrap_to_dict(RESP_TOKEN_FIELDS)
def record_user_token(
user, token, expire_timestamp, session=None
token, expire_timestamp, user=None, session=None
):
"""record user token in database."""
user_token = utils.get_db_object(
@ -289,7 +298,7 @@ def record_user_token(
@utils.supported_filters()
@database.run_in_session()
@utils.wrap_to_dict(RESP_TOKEN_FIELDS)
def clean_user_token(user, token, session=None):
def clean_user_token(token, user=None, session=None):
"""clean user token in database."""
return utils.del_db_objects(
session, models.UserToken,
@ -302,8 +311,8 @@ def clean_user_token(user, token, session=None):
@database.run_in_session()
@utils.wrap_to_dict(RESP_FIELDS)
def get_user(
getter, user_id,
exception_when_missing=True, session=None, **kwargs
user_id, exception_when_missing=True,
user=None, session=None, **kwargs
):
"""get field dict of a user."""
return utils.get_db_object(
@ -315,12 +324,12 @@ def get_user(
@database.run_in_session()
@utils.wrap_to_dict(RESP_FIELDS)
def get_current_user(
getter,
exception_when_missing=True, session=None, **kwargs
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=getter.id
session, models.User, exception_when_missing, id=user.id
)
@ -330,7 +339,7 @@ def get_current_user(
@check_user_admin()
@database.run_in_session()
@utils.wrap_to_dict(RESP_FIELDS)
def list_users(lister, session=None, **filters):
def list_users(user=None, session=None, **filters):
"""List fields of all users by some fields."""
return utils.list_db_objects(
session, models.User, **filters
@ -347,8 +356,7 @@ def list_users(lister, session=None, **filters):
@database.run_in_session()
@utils.wrap_to_dict(RESP_FIELDS)
def add_user(
creator,
exception_when_existing=True,
exception_when_existing=True, user=None,
session=None, **kwargs
):
"""Create a user and return created user object."""
@ -361,7 +369,7 @@ def add_user(
@check_user_admin()
@database.run_in_session()
@utils.wrap_to_dict(RESP_FIELDS)
def del_user(deleter, user_id, session=None, **kwargs):
def del_user(user_id, user=None, session=None, **kwargs):
"""delete a user and return the deleted user object."""
user = utils.get_db_object(session, models.User, id=user_id)
return utils.del_db_object(session, user)
@ -374,22 +382,22 @@ def del_user(deleter, user_id, session=None, **kwargs):
@utils.input_validates(email=_check_email)
@database.run_in_session()
@utils.wrap_to_dict(RESP_FIELDS)
def update_user(updater, user_id, session=None, **kwargs):
def update_user(user_id, user=None, session=None, **kwargs):
"""Update a user and return the updated user object."""
user = utils.get_db_object(
session, models.User, id=user_id
)
allowed_fields = set()
if updater.is_admin:
if user.is_admin:
allowed_fields |= set(ADMIN_UPDATED_FIELDS)
if updater.id == user_id:
if user.id == 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.' % (
updater.email, user.email, unsupported_fields
user.email, user.email, unsupported_fields
)
)
return utils.update_db_object(session, user, **kwargs)
@ -399,7 +407,7 @@ def update_user(updater, user_id, session=None, **kwargs):
@check_user_admin_or_owner()
@database.run_in_session()
@utils.wrap_to_dict(PERMISSION_RESP_FIELDS)
def get_permissions(lister, user_id, session=None, **kwargs):
def get_permissions(user_id, user=None, session=None, **kwargs):
"""List permissions of a user."""
return utils.list_db_objects(
session, models.UserPermission, user_id=user_id, **kwargs
@ -411,8 +419,8 @@ def get_permissions(lister, user_id, session=None, **kwargs):
@database.run_in_session()
@utils.wrap_to_dict(PERMISSION_RESP_FIELDS)
def get_permission(
getter, user_id, permission_id,
exception_when_missing=True, session=None, **kwargs
user_id, permission_id, exception_when_missing=True,
user=None, session=None, **kwargs
):
"""Get a specific user permission."""
return utils.get_db_object(
@ -427,7 +435,7 @@ def get_permission(
@check_user_admin_or_owner()
@database.run_in_session()
@utils.wrap_to_dict(PERMISSION_RESP_FIELDS)
def del_permission(deleter, user_id, permission_id, session=None, **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,
@ -445,8 +453,8 @@ def del_permission(deleter, user_id, permission_id, session=None, **kwargs):
@database.run_in_session()
@utils.wrap_to_dict(PERMISSION_RESP_FIELDS)
def add_permission(
creator, user_id,
exception_when_missing=True, permission_id=None, session=None
user_id, exception_when_missing=True,
permission_id=None, user=None, session=None
):
"""Add an user permission."""
return utils.add_db_object(
@ -471,9 +479,8 @@ def _get_permission_filters(permission_ids):
@database.run_in_session()
@utils.wrap_to_dict(PERMISSION_RESP_FIELDS)
def update_permissions(
updater, user_id,
add_permissions=[], remove_permissions=[],
set_permissions=None, session=None, **kwargs
user_id, add_permissions=[], remove_permissions=[],
set_permissions=None, user=None, session=None, **kwargs
):
"""update user permissions."""
user = utils.get_db_object(session, models.User, id=user_id)

10
compass/db/api/user_log.py
View File

@ -24,7 +24,7 @@ from compass.db import models
SUPPORTED_FIELDS = ['user_email', 'timestamp']
USER_SUPPORTED_FIELDS = ['timestamp']
RESP_FIELDS = ['user_id', 'logs', 'timestamp']
RESP_FIELDS = ['user_id', 'action', 'timestamp']
@database.run_in_session()
@ -39,7 +39,7 @@ def log_user_action(user_id, action, session=None):
@user_api.check_user_admin_or_owner()
@database.run_in_session()
@utils.wrap_to_dict(RESP_FIELDS)
def list_user_actions(lister, user_id, session=None, **filters):
def list_user_actions(user_id, user=None, session=None, **filters):
"""list user actions."""
return utils.list_db_objects(
session, models.UserLog, order_by=['timestamp'],
@ -51,7 +51,7 @@ def list_user_actions(lister, user_id, session=None, **filters):
@user_api.check_user_admin()
@database.run_in_session()
@utils.wrap_to_dict(RESP_FIELDS)
def list_actions(lister, session=None, **filters):
def list_actions(user=None, session=None, **filters):
"""list actions."""
return utils.list_db_objects(
session, models.UserLog, order_by=['timestamp'], **filters
@ -62,7 +62,7 @@ def list_actions(lister, session=None, **filters):
@user_api.check_user_admin_or_owner()
@database.run_in_session()
@utils.wrap_to_dict(RESP_FIELDS)
def del_user_actions(deleter, user_id, session=None, **filters):
def del_user_actions(user_id, user=None, session=None, **filters):
"""delete user actions."""
return utils.del_db_objects(
session, models.UserLog, user_id=user_id, **filters
@ -73,7 +73,7 @@ def del_user_actions(deleter, user_id, session=None, **filters):
@user_api.check_user_admin()
@database.run_in_session()
@utils.wrap_to_dict(RESP_FIELDS)
def del_actions(deleter, session=None, **filters):
def del_actions(user=None, session=None, **filters):
"""delete actions."""
return utils.del_db_objects(
session, models.UserLog, **filters

60
compass/tests/actions/update_progress/test_update_progress.py
View File

@ -85,7 +85,7 @@ class TestProgressCalculator(unittest2.TestCase):
self.cluster_id = None
# get adapter information
list_adapters = adapter.list_adapters(self.user_object)
list_adapters = adapter.list_adapters(user=self.user_object)
for adptr in list_adapters:
if ('package_installer' in adptr.keys() and
adptr['flavors'] != [] and
@ -102,13 +102,13 @@ class TestProgressCalculator(unittest2.TestCase):
#add cluster
cluster.add_cluster(
self.user_object,
adapter_id=self.adapter_id,
os_id=self.os_id,
flavor_id=self.flavor_id,
name='test_cluster'
name='test_cluster',
user=self.user_object,
)
list_clusters = cluster.list_clusters(self.user_object)
list_clusters = cluster.list_clusters(user=self.user_object)
for list_cluster in list_clusters:
if list_cluster['name'] == 'test_cluster':
self.cluster_id = list_cluster['id']
@ -118,51 +118,51 @@ class TestProgressCalculator(unittest2.TestCase):
#add switch
switch.add_switch(
self.user_object,
ip=SWITCH_IP
ip=SWITCH_IP,
user=self.user_object,
)
list_switches = switch.list_switches(self.user_object)
list_switches = switch.list_switches(user=self.user_object)
for list_switch in list_switches:
self.switch_id = list_switch['id']
switch.add_switch_machine(
self.user_object,
self.switch_id,
user=self.user_object,
mac=MACHINE_MAC,
port='1'
)
#get machine information
list_machines = machine.list_machines(self.user_object)
list_machines = machine.list_machines(user=self.user_object)
for list_machine in list_machines:
self.machine_id = list_machine['id']
#add cluster host
cluster.add_cluster_host(
self.user_object,
self.cluster_id,
user=self.user_object,
machine_id=self.machine_id,
name='test_clusterhost'
)
list_clusterhosts = cluster.list_clusterhosts(self.user_object)
list_clusterhosts = cluster.list_clusterhosts(user=self.user_object)
for list_clusterhost in list_clusterhosts:
self.host_id = list_clusterhost['host_id']
self.clusterhost_id = list_clusterhost['clusterhost_id']
#add subnet
network.add_subnet(
self.user_object,
subnet=SUBNET
subnet=SUBNET,
user=self.user_object,
)
list_subnets = network.list_subnets(
self.user_object
user=self.user_object
)
for list_subnet in list_subnets:
self.subnet_id = list_subnet['id']
#add host network
host.add_host_network(
self.user_object,
self.host_id,
user=self.user_object,
interface='eth0',
ip=HOST_IP,
subnet_id=self.subnet_id,
@ -171,32 +171,32 @@ class TestProgressCalculator(unittest2.TestCase):
#get clusterhost
list_clusterhosts = cluster.list_clusterhosts(
self.user_object
user=self.user_object
)
for list_clusterhost in list_clusterhosts:
self.clusterhost_id = list_clusterhost['id']
#update host state
self.list_hosts = host.list_hosts(self.user_object)
self.list_hosts = host.list_hosts(user=self.user_object)
for list_host in self.list_hosts:
self.host_id = list_host['id']
self.host_state = host.update_host_state(
self.user_object,
self.host_id,
user=self.user_object,
state='INSTALLING'
)
#update cluster state
cluster.update_cluster_state(
self.user_object,
self.cluster_id,
user=self.user_object,
state='INSTALLING'
)
#update clusterhost state
cluster.update_clusterhost_state(
self.user_object,
self.clusterhost_id,
user=self.user_object,
state='INSTALLING'
)
@ -433,8 +433,8 @@ class TestProgressCalculator(unittest2.TestCase):
self._file_generator('check_point_1')
update_progress.update_progress()
clusterhost_state = cluster.get_clusterhost_state(
self.user_object,
self.clusterhost_id
self.clusterhost_id,
user=self.user_object,
)
self.assertAlmostEqual(
clusterhost_state['percentage'],
@ -446,8 +446,8 @@ class TestProgressCalculator(unittest2.TestCase):
self._file_generator('check_point_2')
update_progress.update_progress()
clusterhost_state = cluster.get_clusterhost_state(
self.user_object,
self.clusterhost_id
self.clusterhost_id,
user=self.user_object,
)
self.assertAlmostEqual(
clusterhost_state['percentage'],
@ -459,8 +459,8 @@ class TestProgressCalculator(unittest2.TestCase):
self._file_generator('check_point_3')
update_progress.update_progress()
clusterhost_state = cluster.get_clusterhost_state(
self.user_object,
self.clusterhost_id
self.clusterhost_id,
user=self.user_object,
)
self.assertAlmostEqual(
clusterhost_state['percentage'],
@ -472,8 +472,8 @@ class TestProgressCalculator(unittest2.TestCase):
self._file_generator('check_point_4')
update_progress.update_progress()
clusterhost_state = cluster.get_clusterhost_state(
self.user_object,
self.clusterhost_id
self.clusterhost_id,
user=self.user_object,
)
self.assertAlmostEqual(
clusterhost_state['percentage'],
@ -485,8 +485,8 @@ class TestProgressCalculator(unittest2.TestCase):
self._file_generator('check_point_5')
update_progress.update_progress()
clusterhost_state = cluster.get_clusterhost_state(
self.user_object,
self.clusterhost_id
self.clusterhost_id,
user=self.user_object,
)
self.assertEqual(
clusterhost_state['percentage'],

5
compass/tests/api/test_api.py
View File

@ -375,9 +375,9 @@ class TestClusterAPI(ApiTestCase):
)
)
cluster_api.update_cluster_state(
self.user_object,
1,
state='INSTALLING'
state='INSTALLING',
user=self.user_object,
)
url = '/clusters/1'
return_value = self.delete(url)
@ -577,7 +577,6 @@ class TestSwitchAPI(ApiTestCase):
url = '/switches'
return_value = self.get(url)
resp = json.loads(return_value.get_data())
print 'list switches: %s' % resp
count = len(resp)
self.assertEqual(count, 2)
self.assertEqual(return_value.status_code, 200)

2
compass/tests/api/test_health_check_api.py
View File

@ -154,7 +154,7 @@ class TestHealthCheckAPI(ApiTestCase):
# Cluster has been deployed successfully.
user = models.User.query.filter_by(email='admin@huawei.com').first()
cluster_db.update_cluster_state(
user, self.cluster_id, state='SUCCESSFUL'
self.cluster_id, user=user, state='SUCCESSFUL'
)
return_value = self.test_client.post(url, data=request_data)
self.assertEqual(202, return_value.status_code)

8
compass/tests/db/api/test_adapter_holder.py
View File

@ -73,7 +73,7 @@ class AdapterTestCase(unittest2.TestCase):
with database.session() as session:
adapter_api.add_adapters_internal(session)
adapter.load_adapters()
self.adapter_object = adapter.list_adapters(self.user_object)
self.adapter_object = adapter.list_adapters(user=self.user_object)
for adapter_obj in self.adapter_object:
if adapter_obj['name'] == 'openstack_icehouse':
self.adapter_id = adapter_obj['id']
@ -97,7 +97,7 @@ class TestListAdapters(AdapterTestCase):
def test_list_adapters(self):
adapters = adapter.list_adapters(
self.user_object
user=self.user_object
)
result = []
for item in adapters:
@ -124,8 +124,8 @@ class TestGetAdapter(AdapterTestCase):
def test_get_adapter(self):
get_adapter = adapter.get_adapter(
self.user_object,
self.adapter_id
self.adapter_id,
user=self.user_object,
)
name = None
for k, v in get_adapter.items():

608
compass/tests/db/api/test_cluster.py
View File

File diff suppressed because it is too large Load Diff

396
compass/tests/db/api/test_host.py
View File

File diff suppressed because it is too large Load Diff

50
compass/tests/db/api/test_machine.py
View File

@ -45,16 +45,17 @@ class TestGetMachine(BaseTest):
def test_get_machine(self):
switch.add_switch_machine(
self.user_object,
1,
mac='28:6e:d4:46:c4:25',
port='1'
port='1',
user=self.user_object,
)
get_machine = machine.get_machine(
self.user_object,
1
1,
user=self.user_object,
)
self.assertIsNotNone(get_machine)
self.assertEqual(get_machine['mac'], '28:6e:d4:46:c4:25')
class TestListMachines(BaseTest):
@ -68,13 +69,14 @@ class TestListMachines(BaseTest):
def test_list_machines(self):
switch.add_switch_machine(
self.user_object,
1,
mac='28:6e:d4:46:c4:25',
port='1'
port='1',
user=self.user_object,
)
list_machine = machine.list_machines(self.user_object)
self.assertIsNotNone(list_machine)
self.assertEqual(list_machine[0]['mac'], '28:6e:d4:46:c4:25')
class TestUpdateMachine(BaseTest):
@ -88,20 +90,26 @@ class TestUpdateMachine(BaseTest):
def test_update_machine(self):
switch.add_switch_machine(
self.user_object,
1,
mac='28:6e:d4:46:c4:25',
port='1'
port='1',
user=self.user_object,
)
machine.update_machine(
self.user_object,
1,
tag='test'
tag='test',
user=self.user_object,
)
update_machine = machine.list_machines(self.user_object)
expected = {'tag': 'test'}
expected = {
'id': 1,
'mac': '28:6e:d4:46:c4:25',
'tag': 'test',
'switch_ip': '0.0.0.0',
'port': '1'
}
self.assertTrue(
item in update_machine[0].items() for item in expected.items()
all(item in update_machine[0].items() for item in expected.items())
)
@ -116,20 +124,20 @@ class TestPatchMachine(BaseTest):
def test_patch_machine(self):
switch.add_switch_machine(
self.user_object,
1,
mac='28:6e:d4:46:c4:25',
port='1'
port='1',
user=self.user_object,
)
machine.patch_machine(
self.user_object,
1,
user=self.user_object,
tag={'patched_tag': 'test'}
)
patch_machine = machine.list_machines(self.user_object)
expected = {'patched_tag': 'test'}
expected = {'tag': {'patched_tag': 'test'}}
self.assertTrue(
item in patch_machine[0].items() for item in expected.items()
all(item in patch_machine[0].items() for item in expected.items())
)
@ -144,14 +152,14 @@ class TestDelMachine(BaseTest):
def test_del_machine(self):
switch.add_switch_machine(
self.user_object,
1,
mac='28:6e:d4:46:c4:25',
port='1'
port='1',
user=self.user_object,
)
machine.del_machine(
self.user_object,
1
1,
user=self.user_object,
)
del_machine = machine.list_machines(self.user_object)
self.assertEqual([], del_machine)

88
compass/tests/db/api/test_network.py
View File

@ -46,15 +46,19 @@ class TestListSubnets(BaseTest):
def test_list_subnets(self):
network.add_subnet(
self.user_object,
subnet='10.145.89.0/24'
subnet='10.145.89.0/24',
user=self.user_object,
)
list_subnet = network.list_subnets(
self.user_object
user=self.user_object
)
expected = '10.145.89.0/24'
expected = {
'subnet': '10.145.89.0/24',
'id': 1,
'name': '10.145.89.0/24'
}
self.assertTrue(
item in list_subnet[0].items() for item in expected
all(item in list_subnet[0].items() for item in expected.items())
)
@ -69,12 +73,12 @@ class TestGetSubnet(BaseTest):
def test_get_subnet(self):
network.add_subnet(
self.user_object,
subnet='10.145.89.0/24'
subnet='10.145.89.0/24',
user=self.user_object,
)
get_subnet = network.get_subnet(
self.user_object,
1
1,
user=self.user_object,
)
self.assertEqual(
'10.145.89.0/24',
@ -83,8 +87,8 @@ class TestGetSubnet(BaseTest):
def tset_get_subnet_no_exist(self):
get_subnet_no_exist = network.get_subnet(
self.user_object,
2
2,
user=self.user_object,
)
self.assertEqual([], get_subnet_no_exist)
@ -100,11 +104,11 @@ class TestAddSubnet(BaseTest):
def test_add_subnet(self):
network.add_subnet(
self.user_object,
subnet='10.145.89.0/24'
subnet='10.145.89.0/24',
user=self.user_object,
)
add_subnets = network.list_subnets(
self.user_object
user=self.user_object
)
expected = '10.145.89.0/24'
for add_subnet in add_subnets:
@ -112,12 +116,12 @@ class TestAddSubnet(BaseTest):
def test_add_subnet_position(self):
network.add_subnet(
self.user_object,
True,
'10.145.89.0/23'
'10.145.89.0/23',
user=self.user_object,
)
add_subnets = network.list_subnets(
self.user_object
user=self.user_object
)
expected = '10.145.89.0/23'
for add_subnet in add_subnets:
@ -128,30 +132,16 @@ class TestAddSubnet(BaseTest):
network.add_subnet(
self.user_object,
subnet='10.145.89.0/22',
user=self.user_object,
session=session
)
add_subnets = network.list_subnets(
self.user_object
user=self.user_object
)
expected = '10.145.89.0/22'
for add_subnet in add_subnets:
self.assertEqual(expected, add_subnet['subnet'])
def test_add_subnet_position_session(self):
with database.session() as session:
network.add_subnet(
self.user_object,
True,
'10.145.89.0/21',
session
)
add_subnets = network.list_subnets(
self.user_object
)
expected = '10.145.89.0/21'
for add_subnet in add_subnets:
self.assertEqual(expected, add_subnet['subnet'])
class TestUpdateSubnet(BaseTest):
"""Test update subnet."""
@ -164,28 +154,32 @@ class TestUpdateSubnet(BaseTest):
def test_update_subnet(self):
network.add_subnet(
self.user_object,
subnet='10.145.89.0/24'
subnet='10.145.89.0/24',
user=self.user_object,
)
network.update_subnet(
self.user_object,
1,
user=self.user_object,
subnet='192.168.100.0/24'
)
update_subnet = network.list_subnets(
self.user_object
user=self.user_object
)
expected = '192.168.100.0/24'
expected = {
'subnet': '192.168.100.0/24',
'id': 1,
'name': '192.168.100.0/24'
}
self.assertTrue(
item in update_subnet[0].items() for item in expected
all(item in update_subnet[0].items() for item in expected.items())
)
def test_update_subnet_no_exist(self):
self.assertRaises(
exception.DatabaseException,
network.update_subnet,
self.user_object,
2
2,
user=self.user_object,
)
@ -200,15 +194,15 @@ class TestDelSubnet(BaseTest):
def test_del_subnet(self):
network.add_subnet(
self.user_object,
user=self.user_object,
subnet='10.145.89.0/24'
)
network.del_subnet(
self.user_object,
1
1,
user=self.user_object,
)
del_subnet = network.list_subnets(
self.user_object
user=self.user_object
)
self.assertEqual([], del_subnet)
@ -216,8 +210,8 @@ class TestDelSubnet(BaseTest):
self.assertRaises(
exception.RecordNotExists,
network.del_subnet,
self.user_object,
2
2,
user=self.user_object,
)

6
compass/tests/db/api/test_permission.py
View File

@ -44,7 +44,7 @@ class TestListPermissions(BaseTest):
super(TestListPermissions, self).tearDown()
def test_list_permissions(self):
permissions = permission.list_permissions(self.user_object)
permissions = permission.list_permissions(user=self.user_object)
self.assertIsNotNone(permissions)
self.assertEqual(54, len(permissions))
@ -59,7 +59,9 @@ class TestGetPermission(BaseTest):
super(TestGetPermission, self).tearDown()
def test_get_permission(self):
get_permission = permission.get_permission(self.user_object, 1)
get_permission = permission.get_permission(
1,
user=self.user_object)
self.assertIsNotNone(get_permission)
expected = {
'alias': 'list permissions',

433
compass/tests/db/api/test_switch.py
View File

@ -46,10 +46,11 @@ class TestGetSwitch(BaseTest):
def test_get_switch(self):
get_switch = switch.get_switch(
self.user_object,
1
1,
user=self.user_object,
)
self.assertIsNotNone(get_switch)
self.assertEqual(get_switch['ip'], '0.0.0.0')
class TestAddSwitch(BaseTest):
@ -63,43 +64,31 @@ class TestAddSwitch(BaseTest):
def test_add_switch(self):
add_switch = switch.add_switch(
self.user_object,
ip='2887583784',
user=self.user_object,
)
expected = '172.29.8.40'
self.assertEqual(expected, add_switch['ip'])
def test_add_switch_position_args(self):
add_switch = switch.add_switch(
self.user_object,
True,
'2887583784',
user=self.user_object,
)
print add_switch
expected = '172.29.8.40'
self.assertEqual(expected, add_switch['ip'])
def test_add_switch_session(self):
with database.session() as session:
add_switch = switch.add_switch(
self.user_object,
ip='2887583784',
user=self.user_object,
session=session
)
expected = '172.29.8.40'
self.assertEqual(expected, add_switch['ip'])
def test_add_switch_position_args_session(self):
with database.session() as session:
add_switch = switch.add_switch(
self.user_object,
True,
'2887583784',
session
)
expected = '172.29.8.40'
self.assertEqual(expected, add_switch['ip'])
class TestListSwitches(BaseTest):
"""Test list switch."""
@ -112,38 +101,39 @@ class TestListSwitches(BaseTest):
def test_list_switches_ip_int_invalid(self):
switch.add_switch(
self.user_object,
ip='2887583784'
ip='2887583784',
user=self.user_object,
)
list_switches = switch.list_switches(
self.user_object,
ip_int='test'
ip_int='test',
user=self.user_object,
)
self.assertEqual(list_switches, [])
def test_list_switches_with_ip_int(self):
switch.add_switch(
self.user_object,
ip='2887583784'
ip='2887583784',
user=self.user_object,
)
list_switches = switch.list_switches(
self.user_object,
ip_int='2887583784'
)
expected = '2887583784'
self.assertTrue(
item in expected.items() for item in list_switches[0].items()
ip_int='2887583784',
user=self.user_object,
)
expected = '172.29.8.40'
self.assertIsNotNone(list_switches)
self.assertEqual(expected, list_switches[0]['ip'])
def test_list_switches(self):
switch.add_switch(
self.user_object,
ip='2887583784'
ip='2887583784',
user=self.user_object,
)
list_switches = switch.list_switches(
self.user_object
user=self.user_object
)
expected = '172.29.8.40'
self.assertIsNotNone(list_switches)
self.assertEqual(expected, list_switches[0]['ip'])
class TestDelSwitch(BaseTest):
@ -157,11 +147,11 @@ class TestDelSwitch(BaseTest):
def test_del_switch(self):
switch.del_switch(
self.user_object,
1
1,
user=self.user_object,
)
del_switch = switch.list_switches(
self.user_object
user=self.user_object
)
self.assertEqual([], del_switch)
@ -177,13 +167,13 @@ class TestUpdateSwitch(BaseTest):
def test_update_switch(self):
switch.update_switch(
self.user_object,
1,
user=self.user_object,
vendor='test_update'
)
update_switch = switch.get_switch(
self.user_object,
1
1,
user=self.user_object,
)
expected = 'test_update'
self.assertEqual(expected, update_switch['vendor'])
@ -200,23 +190,24 @@ class TestPatchSwitch(BaseTest):
def test_patch_switch(self):
switch.patch_switch(
self.user_object,
1,
user=self.user_object,
patched_credentials={
'version': '2c',
'community': 'public'
}
)
patch_switch = switch.get_switch(
self.user_object,
1
1,
user=self.user_object,
)
expected = {
'credentials': {
'version': '2c',
'community': 'public'
'community': 'public'}
}
self.assertTrue(
item in expected.items() for item in patch_switch.items()
all(item in patch_switch.items() for item in expected.items())
)
@ -231,9 +222,17 @@ class TestListSwitchFilters(BaseTest):
def test_list_switch_filters(self):
list_switch_filters = switch.list_switch_filters(
self.user_object
user=self.user_object
)
expected = {
'ip': '0.0.0.0',
'id': 1,
'filters': 'allow ports all',
}
self.assertIsNotNone(list_switch_filters)
self.assertTrue(
all(item in list_switch_filters[0].items()
for item in expected.items()))
class TestGetSwitchFilters(BaseTest):
@ -247,10 +246,18 @@ class TestGetSwitchFilters(BaseTest):
def test_get_swtich_filters(self):
get_switch_filter = switch.get_switch_filters(
self.user_object,
1
1,
user=self.user_object,
)
expected = {
'ip': '0.0.0.0',
'id': 1,
'filters': 'allow ports all',
}
self.assertIsNotNone(get_switch_filter)
self.assertTrue(
all(item in get_switch_filter.items()
for item in expected.items()))
class TestUpdateSwitchFilters(BaseTest):
@ -264,8 +271,8 @@ class TestUpdateSwitchFilters(BaseTest):
def test_update_switch_filters(self):
switch.update_switch_filters(
self.user_object,
1,
user=self.user_object,
filters=[
{
'filter_type': 'allow'
@ -273,15 +280,15 @@ class TestUpdateSwitchFilters(BaseTest):
]
)
update_switch_filters = switch.get_switch_filters(
self.user_object,
1
1,
user=self.user_object,
)
expected = {
'filter_type': 'allow'
'filters': 'allow'
}
self.assertTrue(
item in update_switch_filters[0].items()
for item in expected.items()
all(item in update_switch_filters.items()
for item in expected.items())
)
@ -295,9 +302,13 @@ class TestPatchSwitchFilter(BaseTest):
super(TestPatchSwitchFilter, self).tearDown()
def test_patch_switch_filter(self):
switch.add_switch(
ip='2887583784',
user=self.user_object,
)
switch.patch_switch_filter(
self.user_object,
1,
2,
user=self.user_object,
patched_filters=[
{
'filter_type': 'allow'
@ -305,14 +316,15 @@ class TestPatchSwitchFilter(BaseTest):
]
)
patch_switch_filter = switch.get_switch_filters(
self.user_object,
1
2,
user=self.user_object,
)
expected = {
'filter_type': 'allow'
'filters': 'allow'
}
self.assertTrue(
item in patch_switch_filter[0].items() for item in expected.items()
all(item in patch_switch_filter.items()
for item in expected.items())
)
@ -327,21 +339,21 @@ class TestAddSwitchMachine(BaseTest):
def test_add_switch_machine(self):
add_switch_machine = switch.add_switch_machine(
self.user_object,
1,
mac='28:6e:d4:46:c4:25',
port='1'
port='1',
user=self.user_object,
)
expected = '28:6e:d4:46:c4:25'
self.assertEqual(expected, add_switch_machine['mac'])
def test_add_switch_machine_position_args(self):
add_switch_machine = switch.add_switch_machine(
self.user_object,
1,
True,
'28:6e:d4:46:c4:25',
port='1'
port='1',
user=self.user_object,
)
expected = '28:6e:d4:46:c4:25'
self.assertEqual(expected, add_switch_machine['mac'])
@ -349,28 +361,15 @@ class TestAddSwitchMachine(BaseTest):
def test_add_switch_machine_session(self):
with database.session() as session:
add_switch_machine = switch.add_switch_machine(
self.user_object,
1,
mac='28:6e:d4:46:c4:25',
user=self.user_object,
session=session,
port='1'
)
expected = '28:6e:d4:46:c4:25'
self.assertEqual(expected, add_switch_machine['mac'])
def test_add_switch_machine_position_args_session(self):
with database.session() as session:
add_switch_machine = switch.add_switch_machine(
self.user_object,
1,
True,
'28:6e:d4:46:c4:25',
session,
port='1'
)
expected = '28:6e:d4:46:c4:25'
self.assertEqual(expected, add_switch_machine['mac'])
class TestListSwitchMachines(BaseTest):
"""Test get switch machines."""
@ -383,20 +382,32 @@ class TestListSwitchMachines(BaseTest):
def test_list_switch_machines(self):
switch.add_switch(
self.user_object,
ip='2887583784'
ip='2887583784',
user=self.user_object,
)
switch.add_switch_machine(
self.user_object,
2,
mac='28:6e:d4:46:c4:25',
port='1'
port='1',
user=self.user_object,
)
list_switch_machines = switch.list_switch_machines(
self.user_object,
2
2,
user=self.user_object,
)
expected = {
'switch_id': 2,
'id': 1,
'mac': '28:6e:d4:46:c4:25',
'switch_ip': '172.29.8.40',
'machine_id': 1,
'port': '1',
'switch_machine_id': 1
}
self.assertIsNotNone(list_switch_machines)
self.assertTrue(
all(item in list_switch_machines[0].items()
for item in expected.items()))
class TestListSwitchmachines(BaseTest):
@ -410,54 +421,59 @@ class TestListSwitchmachines(BaseTest):
def test_list_switch_machines_with_ip_int(self):
switch.add_switch(
self.user_object,
ip='2887583784'
ip='2887583784',
user=self.user_object,
)
switch.add_switch_machine(
self.user_object,
2,
mac='28:6e:d4:46:c4:25',
port='1'
port='1',
user=self.user_object,
)
list_switch_machines = switch.list_switchmachines(
self.user_object,
switch_ip_int='2887583784'
switch_ip_int='2887583784',
user=self.user_object,
)
expected = '172.29.8.40'
self.assertTrue(expected for item in list_switch_machines[0].items())
expected = {'switch_ip': '172.29.8.40'}
self.assertTrue(
all(item in list_switch_machines[0].items()
for item in expected.items()))
def test_list_switch_machines_ip_invalid(self):
switch.add_switch(
self.user_object,
ip='2887583784'
ip='2887583784',
user=self.user_object,
)
switch.add_switch_machine(
self.user_object,
2,
mac='28:6e:d4:46:c4:25',
port='1'
port='1',
user=self.user_object,
)
list_switch_machines = switch.list_switchmachines(
self.user_object,
switch_ip_int='test'
switch_ip_int='test',
user=self.user_object,
)
self.assertEqual(list_switch_machines, [])
def test_list_switch_machines_without_ip(self):
switch.add_switch(
self.user_object,
ip='2887583784'
ip='2887583784',
user=self.user_object,
)
switch.add_switch_machine(
self.user_object,
2,
mac='28:6e:d4:46:c4:25',
port='1'
port='1',
user=self.user_object,
)
list_switch_machines = switch.list_switchmachines(
self.user_object
user=self.user_object
)
self.assertIsNotNone(list_switch_machines)
expected = {'switch_ip': '172.29.8.40'}
self.assertTrue(
all(item in list_switch_machines[0].items()
for item in expected.items()))
class TestListSwitchMachinesHosts(BaseTest):
@ -471,20 +487,31 @@ class TestListSwitchMachinesHosts(BaseTest):
def test_list_hosts(self):
switch.add_switch(
self.user_object,
ip='2887583784'
ip='2887583784',
user=self.user_object,
)
switch.add_switch_machine(
self.user_object,
2,
mac='28:6e:d4:46:c4:25',
port='1'
port='1',
user=self.user_object,
)
list_hosts = switch.list_switch_machines_hosts(
self.user_object,
2
2,
user=self.user_object,
)
self.assertIsNotNone(list_hosts)
expected = {
'switch_id': 2,
'id': 1,
'mac': '28:6e:d4:46:c4:25',
'switch_ip': '172.29.8.40',
'machine_id': 1,
'port': '1',
'switch_machine_id': 1
}
self.assertTrue(
all(item in list_hosts[0].items()
for item in expected.items()))
class TestListSwitchmachinesHosts(BaseTest):
@ -498,53 +525,59 @@ class TestListSwitchmachinesHosts(BaseTest):
def test_list_hosts_with_ip_int(self):
switch.add_switch(
self.user_object,
ip='2887583784'
ip='2887583784',
user=self.user_object,
)
switch.add_switch_machine(
self.user_object,
2,
mac='28:6e:d4:46:c4:25',
port='1'
port='1',
user=self.user_object,
)
list_hosts = switch.list_switchmachines_hosts(
self.user_object,
switch_ip_int='2887583784'
switch_ip_int='2887583784',
user=self.user_object,
)
expected = '172.29.8.40'
self.assertTrue(expected for item in list_hosts[0].items())
expected = {'switch_ip': '172.29.8.40'}
self.assertTrue(
all(item in list_hosts[0].items()
for item in expected.items()))
def test_list_hosts_ip_invalid(self):
switch.add_switch(
self.user_object,
ip='2887583784'
ip='2887583784',
user=self.user_object,
)
switch.add_switch_machine(
self.user_object,
2,
mac='28:6e:d4:46:c4:25',
port='1'
port='1',
user=self.user_object,
)
list_hosts = switch.list_switchmachines_hosts(
self.user_object,
switch_ip_int='test'
switch_ip_int='test',
user=self.user_object,
)
self.assertEqual(list_hosts, [])
def test_list_hosts_without_ip(self):
switch.add_switch(
self.user_object,
ip='2887583784'
ip='2887583784',
user=self.user_object,
)
switch.add_switch_machine(
self.user_object,
2,
mac='28:6e:d4:46:c4:25',
port='1'
port='1',
user=self.user_object,
)
list_hosts = switch.list_switchmachines_hosts(
self.user_object
user=self.user_object
)
expected = {'switch_ip': '172.29.8.40'}
self.assertTrue(
all(item in list_hosts[0].items()
for item in expected.items()))
self.assertIsNotNone(list_hosts)
@ -559,21 +592,22 @@ class TestGetSwitchMachine(BaseTest):
def test_get_switch_machine(self):
switch.add_switch(
self.user_object,
ip='2887583784'
ip='2887583784',
user=self.user_object,
)
switch.add_switch_machine(
self.user_object,
2,
mac='28:6e:d4:46:c4:25',
port='1'
port='1',
user=self.user_object,
)
get_switch_machine = switch.get_switch_machine(
self.user_object,
2,
1
1,
user=self.user_object,
)
self.assertIsNotNone(get_switch_machine)
self.assertEqual(get_switch_machine['mac'], '28:6e:d4:46:c4:25')
class TestGetSwitchmachine(BaseTest):
@ -587,16 +621,17 @@ class TestGetSwitchmachine(BaseTest):
def test_get_switchmachine(self):
switch.add_switch_machine(
self.user_object,
1,
mac='28:6e:d4:46:c4:25',
port='1'
port='1',
user=self.user_object,
)
get_switchmachine = switch.get_switchmachine(
self.user_object,
1
1,
user=self.user_object,
)
self.assertIsNotNone(get_switchmachine)
self.assertEqual(get_switchmachine['mac'], '28:6e:d4:46:c4:25')
class TestUpdateSwitchMachine(BaseTest):
@ -610,24 +645,34 @@ class TestUpdateSwitchMachine(BaseTest):
def test_update_switch_machine(self):
switch.add_switch_machine(
self.user_object,
1,
mac='28:6e:d4:46:c4:25',
port='1'
port='1',
user=self.user_object,
)
switch.update_switch_machine(
self.user_object,
1,
1,
tag='test_tag'
tag='test_tag',
user=self.user_object,
)
update_switch_machine = switch.list_switch_machines(
self.user_object,
1
1,
user=self.user_object,
)
expected = {'tag': 'test_tag'}
expected = {
'switch_id': 1,
'id': 1,
'mac': '28:6e:d4:46:c4:25',
'tag': 'test_tag',
'switch_ip': '0.0.0.0',
'machine_id': 1,
'port': '1',
'switch_machine_id': 1
}
self.assertTrue(
item in update_switch_machine[0].items for item in expected.items()
all(item in update_switch_machine[0].items()
for item in expected.items())
)
@ -642,23 +687,32 @@ class TestUpdateSwitchmachine(BaseTest):
def test_update_switchmachine(self):
switch.add_switch_machine(
self.user_object,
1,
mac='28:6e:d4:46:c4:25',
port='1'
port='1',
user=self.user_object,
)
switch.update_switchmachine(
self.user_object,
1,
location='test_location'
location='test_location',
user=self.user_object,
)
update_switchmachine = switch.list_switchmachines(
self.user_object,
user=self.user_object,
)
expected = {'location': 'test_location'}
expected = {
'switch_id': 1,
'id': 1,
'mac': '28:6e:d4:46:c4:25',
'location': 'test_location',
'switch_ip': '0.0.0.0',
'machine_id': 1,
'port': '1',
'switch_machine_id': 1
}
self.assertTrue(
item in update_switchmachine[0].items()
for item in expected.items()
all(item in update_switchmachine[0].items()
for item in expected.items())
)
@ -673,27 +727,29 @@ class TestPatchSwitchMachine(BaseTest):
def test_pathc_switch_machine(self):
switch.add_switch_machine(
self.user_object,
1,
mac='28:6e:d4:46:c4:25',
port='1'
port='1',
user=self.user_object,
)
switch.patch_switch_machine(
self.user_object,
1,
1,
user=self.user_object,
patched_tag={
'patched_tag': 'test_patched_tag'
}
)
switch_patch_switch_machine = switch.list_switch_machines(
self.user_object,
1
1,
user=self.user_object,
)
expected = {'patched_tag': 'test_patched_tag'}
expected = {'tag': {
'patched_tag': 'test_patched_tag'}
}
self.assertTrue(
item in switch_patch_switch_machine[0].items()
for item in expected.items()
all(item in switch_patch_switch_machine[0].items()
for item in expected.items())
)
@ -708,24 +764,27 @@ class TestPatchSwitchmachine(BaseTest):
def test_patch_switchmachine(self):
switch.add_switch_machine(
self.user_object,
1,
mac='28:6e:d4:46:c4:25',
port='1'
port='1',
user=self.user_object,
)
switch.patch_switchmachine(
self.user_object,
1,
user=self.user_object,
patched_location={
'patched_location': 'test_location'
}
)
patch_switchmachine = switch.list_switchmachines(
self.user_object
user=self.user_object
)
expected = {'patched_location': 'test_location'}
expected = {'location': {
'patched_location': 'test_location'}
}
self.assertTrue(
item in patch_switchmachine[0].items() for item in expected.items()
all(item in patch_switchmachine[0].items()
for item in expected.items())
)
@ -740,19 +799,19 @@ class TestDelSwitchMachine(BaseTest):
def test_del_switch_machine(self):
switch.add_switch_machine(
self.user_object,
1,
mac='28:6e:d4:46:c4:25',
port='1'
port='1',
user=self.user_object,
)
switch.del_switch_machine(
self.user_object,
1,
1
1,
user=self.user_object,
)
del_switch_machine = switch.list_switch_machines(
self.user_object,
1
1,
user=self.user_object,
)
self.assertEqual([], del_switch_machine)
@ -768,17 +827,17 @@ class TestDelSwitchmachine(BaseTest):
def test_switchmachine(self):
switch.add_switch_machine(
self.user_object,
1,
mac='28:6e:d4:46:c4:25',
port='1'
port='1',
user=self.user_object,
)
switch.del_switchmachine(
self.user_object,
1
1,
user=self.user_object,
)
del_switchmachine = switch.list_switchmachines(
self.user_object
user=self.user_object
)
self.assertEqual([], del_switchmachine)
@ -794,23 +853,23 @@ class TestUpdateSwitchMachines(BaseTest):
def test_update_switch_machines_remove(self):
switch.add_switch(
self.user_object,
ip='2887583784'
ip='2887583784',
user=self.user_object,
)
switch.add_switch_machine(
self.user_object,
2,
mac='28:6e:d4:46:c4:25',
port='1'
port='1',
user=self.user_object,
)
switch.update_switch_machines(
self.user_object,
2,
remove_machines=1
remove_machines=1,
user=self.user_object,
)
update_remove = switch.list_switch_machines(
self.user_object,
2
2,
user=self.user_object,
)
self.assertEqual([], update_remove)

118
compass/tests/db/api/test_user.py
View File

@ -75,22 +75,25 @@ class TestGetRecordCleanToken(BaseTest):
def test_record_user_token(self):
token = user_api.record_user_token(
self.user_object,
'test_token',
datetime.datetime.now() + datetime.timedelta(seconds=10000)
datetime.datetime.now() + datetime.timedelta(seconds=10000),
user=self.user_object,
)
self.assertIsNotNone(token)
self.assertEqual(token['token'], 'test_token')
def test_clean_user_token(self):
token = user_api.clean_user_token(self.user_object, 'test_token')
token = user_api.clean_user_token(
'test_token',
user=self.user_object,
)
self.assertEqual([], token)
def test_get_user_object_from_token(self):
token = user_api.record_user_token(
self.user_object,
'test_token',
datetime.datetime.now() + datetime.timedelta(seconds=10000)
datetime.datetime.now() + datetime.timedelta(seconds=10000),
user=self.user_object,
)
self.assertIsNotNone(token)
@ -112,9 +115,12 @@ class TestGetUser(BaseTest):
super(TestGetUser, self).tearDown()
def test_get_user(self):
user = user_api.get_user(self.user_object, self.user_object.id)
self.assertIsNotNone(user)
self.assertEqual(user['email'], setting.COMPASS_ADMIN_EMAIL)
get_user = user_api.get_user(
self.user_object.id,
user=self.user_object
)
self.assertIsNotNone(get_user)
self.assertEqual(get_user['email'], setting.COMPASS_ADMIN_EMAIL)
class TestGetCurrentUser(BaseTest):
@ -128,7 +134,7 @@ class TestGetCurrentUser(BaseTest):
def test_get_current_user(self):
current_user = user_api.get_current_user(
self.user_object
user=self.user_object
)
self.assertIsNotNone(current_user)
self.assertEqual(current_user['email'], setting.COMPASS_ADMIN_EMAIL)
@ -140,7 +146,7 @@ class TestListUsers(BaseTest):
def setUp(self):
super(TestListUsers, self).setUp()
user_api.add_user(
self.user_object,
user=self.user_object,
email='test@huawei.com',
password='test'
)
@ -149,11 +155,13 @@ class TestListUsers(BaseTest):
super(TestListUsers, self).tearDown()
def test_list_users(self):
user = user_api.list_users(self.user_object)
self.assertIsNotNone(user)
list_users = user_api.list_users(
user=self.user_object
)
self.assertIsNotNone(list_users)
result = []
for item in user:
result.append(item['email'])
for list_user in list_users:
result.append(list_user['email'])
expects = ['test@huawei.com', setting.COMPASS_ADMIN_EMAIL]
for expect in expects:
self.assertIn(expect, result)
@ -170,18 +178,18 @@ class TestAddUser(BaseTest):
def test_add_user(self):
user_objs = user_api.add_user(
self.user_object,
email='test@abc.com',
password='password'
password='password',
user=self.user_object,
)
self.assertEqual('test@abc.com', user_objs['email'])
def test_add_user_session(self):
with database.session() as session:
user_objs = user_api.add_user(
self.user_object,
email='test@abc.com',
password='password',
user=self.user_object,
session=session
)
self.assertEqual('test@abc.com', user_objs['email'])
@ -197,8 +205,11 @@ class TestDelUser(BaseTest):
super(TestDelUser, self).tearDown()
def test_del_user(self):
user_api.del_user(self.user_object, self.user_object.id)
del_user = user_api.list_users(self.user_object)
user_api.del_user(
self.user_object.id,
user=self.user_object,
)
del_user = user_api.list_users(user=self.user_object)
self.assertEqual([], del_user)
@ -213,8 +224,8 @@ class TestUpdateUser(BaseTest):
def test_update_admin(self):
user_objs = user_api.update_user(
self.user_object,
self.user_object.id,
user=self.user_object,
email=setting.COMPASS_ADMIN_EMAIL,
firstname='a',
lastname='b',
@ -228,7 +239,7 @@ class TestUpdateUser(BaseTest):
def test_not_admin(self):
user_api.add_user(
self.user_object,
user=self.user_object,
email='dummy@abc.com',
password='dummy',
is_admin=False
@ -237,8 +248,8 @@ class TestUpdateUser(BaseTest):
self.assertRaises(
exception.Forbidden,
user_api.update_user,
user_object,
2,
user=user_object,
is_admin=False
)
@ -254,8 +265,8 @@ class TestGetPermissions(BaseTest):
def test_get_permissions(self):
user_permissions = user_api.get_permissions(
self.user_object,
self.user_object.id
self.user_object.id,
user=self.user_object,
)
self.assertIsNotNone(user_permissions)
result = []
@ -275,9 +286,9 @@ class TestGetPermission(BaseTest):
def test_get_permission(self):
user_permission = user_api.get_permission(
self.user_object,
self.user_object.id,
1,
user=self.user_object,
)
self.assertEqual(user_permission['name'], 'list_permissions')
@ -294,13 +305,13 @@ class TestAddDelUserPermission(BaseTest):
def test_add_permission(self):
user_api.add_permission(
self.user_object,
self.user_object.id,
user=self.user_object,
permission_id=2
)
permissions = user_api.get_permissions(
self.user_object,
self.user_object.id
self.user_object.id,
user=self.user_object,
)
result = None
for permission in permissions:
@ -310,14 +321,14 @@ class TestAddDelUserPermission(BaseTest):
def test_add_permission_position(self):
user_api.add_permission(
self.user_object,
self.user_object.id,
True,
2
2,
user=self.user_object,
)
permissions = user_api.get_permissions(
self.user_object,
self.user_object.id
self.user_object.id,
user=self.user_object,
)
result = None
for permission in permissions:
@ -328,33 +339,14 @@ class TestAddDelUserPermission(BaseTest):
def test_add_permission_session(self):
with database.session() as session:
user_api.add_permission(
self.user_object,
self.user_object.id,
user=self.user_object,
permission_id=2,
session=session
)
permissions = user_api.get_permissions(
self.user_object,
self.user_object.id
)
result = None
for permission in permissions:
if permission['id'] == 2:
result = permission['name']
self.assertEqual(result, 'list_switches')
def test_add_permission_position_session(self):
with database.session() as session:
user_api.add_permission(
self.user_object,
self.user_object.id,
True,
2,
session
)
permissions = user_api.get_permissions(
self.user_object,
self.user_object.id
user=self.user_object,
)
result = None
for permission in permissions:
@ -364,13 +356,13 @@ class TestAddDelUserPermission(BaseTest):
def test_del_permission(self):
user_api.del_permission(
self.user_object,
self.user_object.id,
1
1,
user=self.user_object,
)
del_user = user_api.get_permissions(
self.user_object,
self.user_object.id
self.user_object.id,
user=self.user_object,
)
self.assertEqual([], del_user)
@ -386,25 +378,25 @@ class TestUpdatePermissions(BaseTest):
def test_remove_permissions(self):
user_api.update_permissions(
self.user_object,
self.user_object.id,
user=self.user_object,
remove_permissions=1
)
del_user_permission = user_api.get_permissions(
self.user_object,
self.user_object.id
self.user_object.id,
user=self.user_object,
)
self.assertEqual([], del_user_permission)
def test_add_permissions(self):
user_api.update_permissions(
self.user_object,
self.user_object.id,
user=self.user_object,
add_permissions=2
)
permissions = user_api.get_permissions(
self.user_object,
self.user_object.id
self.user_object.id,
user=self.user_object,
)
result = None
for permission in permissions:

43
compass/tests/db/api/test_user_log.py
View File

@ -46,16 +46,19 @@ class TestListUserActions(BaseTest):
def test_list_user_actions(self):
user_log.log_user_action(
self.user_object.id,
action='/testaction'
action='/users/login'
)
user_action = user_log.list_user_actions(
self.user_object,
self.user_object.id
)
self.assertEqual(
1,
user_action[0]['user_id']
self.user_object.id,
user=self.user_object
)
expected = {
'action': '/users/login',
'user_id': 1
}
self.assertTrue(
all(item in user_action[0].items()
for item in expected.items()))
def test_list_none_user_actions(self):
user_log.log_user_action(
@ -63,8 +66,8 @@ class TestListUserActions(BaseTest):
action='/testaction'
)
user_action = user_log.list_user_actions(
self.user_object,
2
2,
user=self.user_object
)
self.assertEqual([], user_action)
@ -83,8 +86,16 @@ class TestListActions(BaseTest):
self.user_object.id,
action='/testaction'
)
action = user_log.list_actions(self.user_object)
action = user_log.list_actions(user=self.user_object)
self.assertIsNotNone(action)
expected = {
'action': '/testaction',
'user_id': 1
}
print action
self.assertTrue(
all(item in action[0].items()
for item in expected.items()))
class TestDelUserActions(BaseTest):
@ -102,12 +113,12 @@ class TestDelUserActions(BaseTest):
action='/testaction'
)
user_log.del_user_actions(
self.user_object,
self.user_object.id
self.user_object.id,
user=self.user_object
)
del_user_action = user_log.list_user_actions(
self.user_object,
self.user_object.id
self.user_object.id,
user=self.user_object
)
self.assertEqual([], del_user_action)
@ -127,10 +138,10 @@ class TestDelActions(BaseTest):
action='/testaction'
)
user_log.del_actions(
self.user_object
user=self.user_object
)
del_action = user_log.list_actions(
self.user_object
user=self.user_object
)
self.assertEqual([], del_action)