def test_adds_an_in_clause_for_multiple_values(self):
self.model.cat.in_.return_value = 'fake in clause'
filters = {'cat': ['foo', 'quux']}
utils.exact_filter(self.query, self.model, filters)
self.query.filter.assert_called_once_with('fake in clause')
self.model.cat.in_.assert_called_once_with(['foo', 'quux'])
def test_adds_an_in_clause_for_multiple_values(self):
self.model.cat.in_.return_value = 'fake in clause'
filters = {'cat': ['foo', 'quux']}
utils.exact_filter(self.query, self.model, filters)
self.query.filter.assert_called_once_with('fake in clause')
self.model.cat.in_.assert_called_once_with(['foo', 'quux'])
def cluster_policy_get_all(context, cluster_id, filters=None, sort=None):
query = model_query(context, models.ClusterPolicies)
query = query.filter_by(cluster_id=cluster_id)
if filters is not None:
key_enabled = consts.CP_ENABLED
if key_enabled in filters:
filter_enabled = {key_enabled: filters[key_enabled]}
query = utils.exact_filter(query, models.ClusterPolicies,
filter_enabled)
key_type = consts.CP_POLICY_TYPE
key_name = consts.CP_POLICY_NAME
if key_type in filters and key_name in filters:
query = query.join(models.Policy).filter(
models.Policy.type == filters[key_type]
and models.Policy.name == filters[key_name])
elif key_type in filters:
query = query.join(
models.Policy).filter(models.Policy.type == filters[key_type])
elif key_name in filters:
query = query.join(
models.Policy).filter(models.Policy.name == filters[key_name])
keys, dirs = utils.get_sort_params(sort)
return sa_utils.paginate_query(query,
models.ClusterPolicies,
None,
keys,
sort_dirs=dirs).all()
def _event_filter_paginate_query(context, query, filters=None,
limit=None, marker=None, sort=None):
if filters:
query = utils.exact_filter(query, models.Event, filters)
keys, dirs = utils.get_sort_params(sort, consts.EVENT_TIMESTAMP)
if marker:
marker = model_query(context, models.Event).get(marker)
return sa_utils.paginate_query(query, models.Event, limit, keys,
marker=marker, sort_dirs=dirs).all()
def cluster_policy_get_by_type(context, cluster_id, policy_type, filters=None):
query = model_query(context, models.ClusterPolicies)
query = query.filter_by(cluster_id=cluster_id)
if filters:
query = utils.exact_filter(query, models.ClusterPolicies, filters)
query = query.join(models.Policy).filter(models.Policy.type == policy_type)
return query.all()
def cluster_policy_get_all(context, cluster_id, filters=None, sort=None):
query = model_query(context, models.ClusterPolicies)
query = query.filter_by(cluster_id=cluster_id)
if filters:
query = utils.exact_filter(query, models.ClusterPolicies, filters)
keys, dirs = utils.get_sort_params(sort)
return sa_utils.paginate_query(query, models.ClusterPolicies, None, keys,
sort_dirs=dirs).all()
def cluster_policy_get_by_type(context, cluster_id, policy_type, filters=None):
query = model_query(context, models.ClusterPolicies)
query = query.filter_by(cluster_id=cluster_id)
if filters:
query = utils.exact_filter(query, models.ClusterPolicies, filters)
query = query.join(models.Policy).filter(models.Policy.type == policy_type)
return query.all()
def cluster_get_all(context, limit=None, marker=None, sort=None, filters=None,
project_safe=True):
query = _query_cluster_get_all(context, project_safe=project_safe)
if filters:
query = utils.exact_filter(query, models.Cluster, filters)
keys, dirs = utils.get_sort_params(sort, consts.CLUSTER_INIT_AT)
if marker:
marker = model_query(context, models.Cluster).get(marker)
return sa_utils.paginate_query(query, models.Cluster, limit, keys,
marker=marker, sort_dirs=dirs).all()
def node_get_all(context, cluster_id=None, limit=None, marker=None, sort=None,
filters=None, project_safe=True):
query = _query_node_get_all(context, project_safe=project_safe,
cluster_id=cluster_id)
if filters:
query = utils.exact_filter(query, models.Node, filters)
keys, dirs = utils.get_sort_params(sort, consts.NODE_INIT_AT)
if marker:
marker = model_query(context, models.Node).get(marker)
return sa_utils.paginate_query(query, models.Node, limit, keys,
marker=marker, sort_dirs=dirs).all()
def cluster_policy_get_all(context, cluster_id, filters=None, sort=None):
query = model_query(context, models.ClusterPolicies)
query = query.filter_by(cluster_id=cluster_id)
if filters:
query = utils.exact_filter(query, models.ClusterPolicies, filters)
keys, dirs = utils.get_sort_params(sort)
return sa_utils.paginate_query(query,
models.ClusterPolicies,
None,
keys,
sort_dirs=dirs).all()
def cluster_policy_get_by_name(context, cluster_id, policy_name, filters=None):
query = model_query(context, models.ClusterPolicies)
query = query.filter_by(cluster_id=cluster_id)
key_enabled = consts.CP_ENABLED
if filters and key_enabled in filters:
filter_enabled = {key_enabled: filters[key_enabled]}
query = utils.exact_filter(query, models.ClusterPolicies,
filter_enabled)
query = query.join(models.Policy).filter(models.Policy.name == policy_name)
return query.all()
def receiver_get_all(context, limit=None, marker=None, filters=None, sort=None,
project_safe=True):
query = model_query(context, models.Receiver)
if not context.is_admin and project_safe:
query = query.filter_by(project=context.project)
if filters:
query = utils.exact_filter(query, models.Receiver, filters)
keys, dirs = utils.get_sort_params(sort, consts.RECEIVER_NAME)
if marker:
marker = model_query(context, models.Receiver).get(marker)
return sa_utils.paginate_query(query, models.Receiver, limit, keys,
marker=marker, sort_dirs=dirs).all()
def profile_get_all(context, limit=None, marker=None, sort=None, filters=None,
project_safe=True):
query = model_query(context, models.Profile)
if not context.is_admin and project_safe:
query = query.filter_by(project=context.project)
if filters:
query = utils.exact_filter(query, models.Profile, filters)
keys, dirs = utils.get_sort_params(sort, consts.PROFILE_CREATED_AT)
if marker:
marker = model_query(context, models.Profile).get(marker)
return sa_utils.paginate_query(query, models.Profile, limit, keys,
marker=marker, sort_dirs=dirs).all()
def action_get_all(context, filters=None, limit=None, marker=None, sort=None,
project_safe=True):
query = model_query(context, models.Action)
# TODO(Qiming): Enable multi-tenancy for actions
# if project_safe:
# query = query.filter_by(project=context.project)
if filters:
query = utils.exact_filter(query, models.Action, filters)
keys, dirs = utils.get_sort_params(sort, consts.ACTION_CREATED_AT)
if marker:
marker = model_query(context, models.Action).get(marker)
return sa_utils.paginate_query(query, models.Action, limit, keys,
marker=marker, sort_dirs=dirs).all()
def _event_filter_paginate_query(context,
query,
filters=None,
limit=None,
marker=None,
sort=None):
if filters:
query = utils.exact_filter(query, models.Event, filters)
keys, dirs = utils.get_sort_params(sort, consts.EVENT_TIMESTAMP)
if marker:
marker = model_query(context, models.Event).get(marker)
return sa_utils.paginate_query(query,
models.Event,
limit,
keys,
marker=marker,
sort_dirs=dirs).all()
def cluster_get_all(context,
limit=None,
marker=None,
sort=None,
filters=None,
project_safe=True):
query = _query_cluster_get_all(context, project_safe=project_safe)
if filters:
query = utils.exact_filter(query, models.Cluster, filters)
keys, dirs = utils.get_sort_params(sort, consts.CLUSTER_INIT_AT)
if marker:
marker = model_query(context, models.Cluster).get(marker)
return sa_utils.paginate_query(query,
models.Cluster,
limit,
keys,
marker=marker,
sort_dirs=dirs).all()
def receiver_get_all(context,
limit=None,
marker=None,
filters=None,
sort=None,
project_safe=True):
query = model_query(context, models.Receiver)
if not context.is_admin and project_safe:
query = query.filter_by(project=context.project)
if filters:
query = utils.exact_filter(query, models.Receiver, filters)
keys, dirs = utils.get_sort_params(sort, consts.RECEIVER_NAME)
if marker:
marker = model_query(context, models.Receiver).get(marker)
return sa_utils.paginate_query(query,
models.Receiver,
limit,
keys,
marker=marker,
sort_dirs=dirs).all()
def policy_get_all(context,
limit=None,
marker=None,
sort=None,
filters=None,
project_safe=True):
query = model_query(context, models.Policy)
if project_safe:
query = query.filter_by(project=context.project)
if filters:
query = utils.exact_filter(query, models.Policy, filters)
keys, dirs = utils.get_sort_params(sort, consts.POLICY_CREATED_AT)
if marker:
marker = model_query(context, models.Policy).get(marker)
return sa_utils.paginate_query(query,
models.Policy,
limit,
keys,
marker=marker,
sort_dirs=dirs).all()
def node_get_all(context,
cluster_id=None,
limit=None,
marker=None,
sort=None,
filters=None,
project_safe=True):
query = _query_node_get_all(context,
project_safe=project_safe,
cluster_id=cluster_id)
if filters:
query = utils.exact_filter(query, models.Node, filters)
keys, dirs = utils.get_sort_params(sort, consts.NODE_INIT_AT)
if marker:
marker = model_query(context, models.Node).get(marker)
return sa_utils.paginate_query(query,
models.Node,
limit,
keys,
marker=marker,
sort_dirs=dirs).all()
def profile_get_all(context,
limit=None,
marker=None,
sort=None,
filters=None,
project_safe=True):
query = model_query(context, models.Profile)
if not context.is_admin and project_safe:
query = query.filter_by(project=context.project)
if filters:
query = utils.exact_filter(query, models.Profile, filters)
keys, dirs = utils.get_sort_params(sort, consts.PROFILE_CREATED_AT)
if marker:
marker = model_query(context, models.Profile).get(marker)
return sa_utils.paginate_query(query,
models.Profile,
limit,
keys,
marker=marker,
sort_dirs=dirs).all()
def action_get_all(context,
filters=None,
limit=None,
marker=None,
sort=None,
project_safe=True):
query = model_query(context, models.Action)
# TODO(Qiming): Enable multi-tenancy for actions
# if project_safe:
# query = query.filter_by(project=context.project)
if filters:
query = utils.exact_filter(query, models.Action, filters)
keys, dirs = utils.get_sort_params(sort, consts.ACTION_CREATED_AT)
if marker:
marker = model_query(context, models.Action).get(marker)
return sa_utils.paginate_query(query,
models.Action,
limit,
keys,
marker=marker,
sort_dirs=dirs).all()
def test_returns_same_query_for_empty_filters(self):
filters = {}
utils.exact_filter(self.query, self.model, filters)
self.assertEqual(0, self.query.call_count)
def test_add_exact_match_clause_for_single_values(self):
filters = {'cat': 'foo'}
utils.exact_filter(self.query, self.model, filters)
self.query.filter_by.assert_called_once_with(cat='foo')
def test_returns_same_query_for_empty_filters(self):
filters = {}
utils.exact_filter(self.query, self.model, filters)
self.assertEqual(0, self.query.call_count)
def cluster_count_all(context, filters=None, project_safe=True):
query = _query_cluster_get_all(context, project_safe=project_safe)
query = utils.exact_filter(query, models.Cluster, filters)
return query.count()
def cluster_count_all(context, filters=None, project_safe=True):
query = _query_cluster_get_all(context, project_safe=project_safe)
query = utils.exact_filter(query, models.Cluster, filters)
return query.count()
def test_add_exact_match_clause_for_single_values(self):
filters = {'cat': 'foo'}
utils.exact_filter(self.query, self.model, filters)
self.query.filter_by.assert_called_once_with(cat='foo')
