def add_datasource(cls, item, deleted=False):
req = cls.make_datasource_dict(item)
driver_info = cls.validate_create_datasource(req)
session = db.get_session()
try:
with session.begin(subtransactions=True):
datasource = datasources_db.add_datasource(
id_=req['id'],
name=req['name'],
driver=req['driver'],
config=req['config'],
description=req['description'],
enabled=req['enabled'],
session=session)
datasource = cls.make_datasource_dict(datasource)
cage = d6cage.d6Cage()
engine = cage.service_object('engine')
try:
engine.create_policy(datasource['name'])
except KeyError:
# FIXME(arosen): we need a better exception then
# key error being raised here
raise DatasourceNameInUse(name=req['name'])
cage.createservice(name=datasource['name'],
moduleName=driver_info['module'],
args=datasource['config'],
module_driver=True)
service = cage.service_object(req['name'])
engine.set_schema(req['name'], service.get_schema())
except db_exc.DBDuplicateEntry:
raise DatasourceNameInUse(name=req['name'])
return cls.make_datasource_dict(datasource)
def add_policy(id_,
name,
abbreviation,
description,
owner,
kind,
deleted=False,
session=None):
if session:
# IMPORTANT: if session provided, do not interrupt existing transaction
# with BEGIN which can drop db locks and change desired transaction
# boundaries for proper commit and rollback
try:
policy = Policy(id_, name, abbreviation, description, owner, kind,
deleted)
session.add(policy)
return policy
except oslo_db_exc.DBDuplicateEntry:
raise KeyError("Policy with name %s already exists" % name)
# else
session = db.get_session()
try:
with session.begin(subtransactions=True):
policy = Policy(id_, name, abbreviation, description, owner, kind,
deleted)
session.add(policy)
return policy
except oslo_db_exc.DBDuplicateEntry:
raise KeyError("Policy with name %s already exists" % name)
def get_policy(id_, session=None):
session = session or db.get_session()
try:
return session.query(LibraryPolicy).filter(
LibraryPolicy.id == id_).one()
except db_exc.NoResultFound:
raise KeyError('No policy found with policy id %s' % id_)
def get_policy_by_name(name, session=None):
session = session or db.get_session()
try:
return session.query(LibraryPolicy).filter(
LibraryPolicy.name == name).one()
except db_exc.NoResultFound:
raise KeyError('No policy found with policy name %s' % name)
def get_policy(id_, session=None):
session = session or db.get_session()
try:
return session.query(LibraryPolicy).filter(
LibraryPolicy.id == id_).one()
except db_exc.NoResultFound:
raise KeyError('No policy found with policy id %s' % id_)
def get_policy_by_name(name, session=None):
session = session or db.get_session()
try:
return session.query(LibraryPolicy).filter(
LibraryPolicy.name == name).one()
except db_exc.NoResultFound:
raise KeyError('No policy found with policy name %s' % name)
def add_policy_rule(id, policy_name, rule, comment, deleted=False,
session=None):
session = session or db.get_session()
with session.begin(subtransactions=True):
policy_rule = PolicyRule(id, policy_name, rule, comment, deleted)
session.add(policy_rule)
return policy_rule
def store_ds_table_data(ds_id, tablename, tabledata, session=None):
session = session or db.get_session()
tabledata = _json_encode_table_data(tabledata)
with session.begin(subtransactions=True):
new_row = session.merge(
DSTableData(ds_id=ds_id, tablename=tablename, tabledata=tabledata))
return new_row
def get_policy(id_, session=None, deleted=False):
session = session or db.get_session()
try:
return (session.query(Policy).filter(Policy.id == id_).filter(
Policy.deleted == is_soft_deleted(id_, deleted)).one())
except db_exc.NoResultFound:
pass
def add_policy_rule(id,
policy_name,
rule,
comment,
deleted=False,
rule_name="",
session=None):
if session:
# IMPORTANT: if session provided, do not interrupt existing transaction
# with BEGIN which can drop db locks and change desired transaction
# boundaries for proper commit and rollback
policy_rule = PolicyRule(id,
policy_name,
rule,
comment,
deleted,
rule_name=rule_name)
session.add(policy_rule)
return policy_rule
# else
session = db.get_session()
with session.begin(subtransactions=True):
policy_rule = PolicyRule(id,
policy_name,
rule,
comment,
deleted,
rule_name=rule_name)
session.add(policy_rule)
return policy_rule
def get_datasource_by_name(name, session=None, deleted=False):
session = session or db.get_session()
try:
return (session.query(Datasource).filter(
Datasource.name == name).one())
except db_exc.NoResultFound:
pass
def get_policy_by_name(name, session=None, deleted=False):
session = session or db.get_session()
try:
return (session.query(Policy).filter(Policy.name == name).filter(
Policy.deleted == is_soft_deleted(name, deleted)).one())
except db_exc.NoResultFound:
pass
def get_datasource_by_name(name, session=None):
session = session or db.get_session()
try:
return _decrypt_secret_config_fields(session.query(Datasource).
filter(Datasource.name == name).
one())
except db_exc.NoResultFound:
pass
def get_datasource_by_name(name, session=None, deleted=False):
session = session or db.get_session()
try:
return (session.query(Datasource).
filter(Datasource.name == name).
one())
except db_exc.NoResultFound:
pass
def policy_name(name_or_id, session=None):
session = session or db.get_session()
try:
ans = (session.query(Policy).filter(Policy.deleted == '').filter(
Policy.id == name_or_id).one())
except db_exc.NoResultFound:
return name_or_id
return ans.name
def get_datasource(id_, session=None):
session = session or db.get_session()
try:
return (session.query(Datasource).
filter(Datasource.id == id_).
one())
except db_exc.NoResultFound:
pass
def get_datasource_by_name(name, session=None):
session = session or db.get_session()
try:
return _decrypt_secret_config_fields(session.query(Datasource).
filter(Datasource.name == name).
one())
except db_exc.NoResultFound:
pass
def add_policy(id_, name, abbreviation, description, owner, kind,
deleted=False, session=None):
session = session or db.get_session()
with session.begin(subtransactions=True):
policy = Policy(id_, name, abbreviation, description, owner,
kind, deleted)
session.add(policy)
return policy
def add_datasource(cls, item, deleted=False, update_db=True):
req = cls.make_datasource_dict(item)
# If update_db is True, new_id will get a new value from the db.
new_id = req['id']
driver_info = cls.get_driver_info(item['driver'])
session = db.get_session()
try:
with session.begin(subtransactions=True):
LOG.debug("adding datasource %s", req['name'])
if update_db:
LOG.debug("updating db")
datasource = datasources_db.add_datasource(
id_=req['id'],
name=req['name'],
driver=req['driver'],
config=req['config'],
description=req['description'],
enabled=req['enabled'],
session=session)
new_id = datasource['id']
cls.validate_create_datasource(req)
cage = cls.dseNode or d6cage.d6Cage()
engine = cage.service_object('engine')
try:
LOG.debug("creating policy %s", req['name'])
engine.create_policy(req['name'],
kind=base.DATASOURCE_POLICY_TYPE)
except KeyError:
# FIXME(arosen): we need a better exception then
# key error being raised here
raise DatasourceNameInUse(value=req['name'])
try:
if cls.dseNode:
cls.createservice(name=req['name'],
moduleName=driver_info['module'],
args=item['config'],
module_driver=True,
type_='datasource_driver',
id_=new_id)
else:
cage.createservice(name=req['name'],
moduleName=driver_info['module'],
args=item['config'],
module_driver=True,
type_='datasource_driver',
id_=new_id)
service = cage.service_object(req['name'])
engine.set_schema(req['name'], service.get_schema())
except Exception:
engine.delete_policy(req['name'])
raise DatasourceCreationError(value=req['name'])
except db_exc.DBDuplicateEntry:
raise DatasourceNameInUse(value=req['name'])
new_item = dict(item)
new_item['id'] = new_id
return cls.make_datasource_dict(new_item)
def delete_ds_table_data(ds_id, tablename=None, session=None):
session = session or db.get_session()
if tablename is None:
return session.query(DSTableData).filter(
DSTableData.ds_id == ds_id).delete()
else:
return session.query(DSTableData).filter(
DSTableData.ds_id == ds_id,
DSTableData.tablename == tablename).delete()
def delete_policy(id_, session=None):
session = session or db.get_session()
with session.begin(subtransactions=True):
# delete all rules for that policy from database
policy = get_policy(id_, session=session)
for rule in get_policy_rules(policy.name, session=session):
delete_policy_rule(rule.id, session=session)
# delete the policy
return (session.query(Policy).filter(Policy.id == id_).soft_delete())
def delete_ds_table_data(ds_id, tablename=None, session=None):
session = session or db.get_session()
if tablename is None:
return session.query(DSTableData).filter(
DSTableData.ds_id == ds_id).delete()
else:
return session.query(DSTableData).filter(
DSTableData.ds_id == ds_id,
DSTableData.tablename == tablename).delete()
def get_policy(id_, session=None, deleted=False):
session = session or db.get_session()
try:
return (session.query(Policy).
filter(Policy.id == id_).
filter(Policy.deleted == is_soft_deleted(id_, deleted)).
one())
except db_exc.NoResultFound:
pass
def get_policy_by_name(name, session=None, deleted=False):
session = session or db.get_session()
try:
return (session.query(Policy).
filter(Policy.name == name).
filter(Policy.deleted == is_soft_deleted(name, deleted)).
one())
except db_exc.NoResultFound:
pass
def store_ds_table_data(ds_id, tablename, tabledata, session=None):
session = session or db.get_session()
tabledata = _json_encode_table_data(tabledata)
with session.begin(subtransactions=True):
new_row = session.merge(DSTableData(
ds_id=ds_id,
tablename=tablename,
tabledata=tabledata))
return new_row
def delete_datasource(self, datasource_id, update_db=True):
datasource = self.get_datasource(datasource_id)
session = db.get_session()
with session.begin(subtransactions=True):
if update_db:
result = datasources_db.delete_datasource(
datasource_id, session)
if not result:
raise DatasourceNotFound(id=datasource_id)
self.unregister_service(datasource['name'])
def get_policy_rule(id, policy_name, session=None, deleted=False):
session = session or db.get_session()
rule_query = (session.query(PolicyRule).filter(PolicyRule.id == id).filter(
PolicyRule.deleted == is_soft_deleted(id, deleted)))
if policy_name:
rule_query = (rule_query.filter(PolicyRule.policy_name == policy_name))
try:
return rule_query.one()
except db_exc.NoResultFound:
pass
def get_policy_rules(policy_name=None, session=None, deleted=False):
session = session or db.get_session()
rule_query = session.query(PolicyRule)
if not deleted:
rule_query = rule_query.filter(PolicyRule.deleted == '')
else:
rule_query = rule_query.filter(PolicyRule.deleted != '')
if policy_name:
rule_query = rule_query.filter(PolicyRule.policy_name == policy_name)
return rule_query.all()
def policy_name(name_or_id, session=None):
session = session or db.get_session()
try:
ans = (session.query(Policy).
filter(Policy.deleted == '').
filter(Policy.id == name_or_id).
one())
except db_exc.NoResultFound:
return name_or_id
return ans.name
def add_policy(id_, name, abbreviation, description, owner, kind,
deleted=False, session=None):
session = session or db.get_session()
try:
with session.begin(subtransactions=True):
policy = Policy(id_, name, abbreviation, description, owner,
kind, deleted)
session.add(policy)
return policy
except oslo_db_exc.DBDuplicateEntry:
raise KeyError("Policy with name %s already exists" % name)
def get_policy_rules(policy_name=None, session=None,
deleted=False):
session = session or db.get_session()
rule_query = session.query(PolicyRule)
if not deleted:
rule_query = rule_query.filter(PolicyRule.deleted == '')
else:
rule_query = rule_query.filter(PolicyRule.deleted != '')
if policy_name:
rule_query = rule_query.filter(PolicyRule.policy_name == policy_name)
return rule_query.all()
def delete_policy(id_, session=None):
session = session or db.get_session()
with session.begin(subtransactions=True):
# delete all rules for that policy from database
policy = get_policy(id_, session=session)
for rule in get_policy_rules(policy.name, session=session):
delete_policy_rule(rule.id, session=session)
# delete the policy
return (session.query(Policy).
filter(Policy.id == id_).
soft_delete())
def get_policy_rule(id, policy_name, session=None, deleted=False):
session = session or db.get_session()
rule_query = (session.query(PolicyRule).
filter(PolicyRule.id == id).
filter(PolicyRule.deleted == is_soft_deleted(id, deleted)))
if policy_name:
rule_query = (rule_query.
filter(PolicyRule.policy_name == policy_name))
try:
return rule_query.one()
except db_exc.NoResultFound:
pass
def add_datasource(id_, name, driver, config, description,
enabled, session=None):
session = session or db.get_session()
with session.begin(subtransactions=True):
datasource = Datasource(
id_=id_,
name=name,
driver=driver,
config=config,
description=description,
enabled=enabled)
session.add(datasource)
return datasource
def add_policy(id_,
name,
abbreviation,
description,
owner,
kind,
deleted=False,
session=None):
session = session or db.get_session()
with session.begin(subtransactions=True):
policy = Policy(id_, name, abbreviation, description, owner, kind,
deleted)
session.add(policy)
return policy
def add_policy(policy_dict, session=None):
session = session or db.get_session()
try:
with session.begin(subtransactions=True):
new_row = LibraryPolicy(name=policy_dict['name'],
abbreviation=policy_dict['abbreviation'],
description=policy_dict['description'],
kind=policy_dict['kind'],
rules=json.dumps(policy_dict['rules']))
session.add(new_row)
return new_row
except oslo_db_exc.DBDuplicateEntry:
raise KeyError("Policy with name %s already exists" %
policy_dict['name'])
def add_datasource(id_, name, driver, config, description,
enabled, session=None, secret_config_fields=None):
secret_config_fields = secret_config_fields or []
session = session or db.get_session()
with session.begin(subtransactions=True):
datasource = Datasource(
id_=id_,
name=name,
driver=driver,
config=config,
description=description,
enabled=enabled)
_encrypt_secret_config_fields(datasource, secret_config_fields)
session.add(datasource)
return datasource
def add_policy(policy_dict, session=None):
session = session or db.get_session()
try:
with session.begin(subtransactions=True):
new_row = LibraryPolicy(
name=policy_dict['name'],
abbreviation=policy_dict['abbreviation'],
description=policy_dict['description'],
kind=policy_dict['kind'],
rules=json.dumps(policy_dict['rules']))
session.add(new_row)
return new_row
except oslo_db_exc.DBDuplicateEntry:
raise KeyError(
"Policy with name %s already exists" % policy_dict['name'])
def replace_policy(id_, policy_dict, session=None):
session = session or db.get_session()
try:
with session.begin(subtransactions=True):
new_row = LibraryPolicy(id=id_,
name=policy_dict['name'],
abbreviation=policy_dict['abbreviation'],
description=policy_dict['description'],
kind=policy_dict['kind'],
rules=json.dumps(policy_dict['rules']))
session.query(LibraryPolicy).filter(
LibraryPolicy.id == id_).one().update(
new_row.to_dict(include_rules=True, json_rules=True))
return new_row
except db_exc.NoResultFound:
raise KeyError('No policy found with policy id %s' % id_)
def get_policy_rule(id, policy_name, session=None):
session = session or db.get_session()
try:
if policy_name:
return (session.query(PolicyRule).
filter_by(policy_name=policy_name).
filter_by(id=id).
filter_by(deleted=0).
one())
else:
return (session.query(PolicyRule).
filter_by(id=id).
filter_by(deleted=0).
one())
except db_exc.NoResultFound:
pass
def add_policy_rule(id,
policy_name,
rule,
comment,
deleted=False,
rule_name="",
session=None):
session = session or db.get_session()
with session.begin(subtransactions=True):
policy_rule = PolicyRule(id,
policy_name,
rule,
comment,
deleted,
rule_name=rule_name)
session.add(policy_rule)
return policy_rule
def replace_policy(id_, policy_dict, session=None):
session = session or db.get_session()
try:
with session.begin(subtransactions=True):
new_row = LibraryPolicy(
id=id_,
name=policy_dict['name'],
abbreviation=policy_dict['abbreviation'],
description=policy_dict['description'],
kind=policy_dict['kind'],
rules=json.dumps(policy_dict['rules']))
session.query(LibraryPolicy).filter(
LibraryPolicy.id == id_).one().update(
new_row.to_dict(include_rules=True, json_rules=True))
return new_row
except db_exc.NoResultFound:
raise KeyError('No policy found with policy id %s' % id_)
def delete_policy(id_, session=None):
session = session or db.get_session()
with session.begin(subtransactions=True):
# delete all rules for that policy from database
policy = get_policy_by_id(id_, session=session)
for rule in get_policy_rules(policy.name, session=session):
delete_policy_rule(rule.id, session=session)
policy_deleted = PolicyDeleted(policy)
session.add(policy_deleted)
# hard delete policy in Policy table
session.query(Policy).filter(Policy.id == id_).delete()
# soft delete policy in PolicyDeleted table
return session.query(PolicyDeleted).filter(
PolicyDeleted.id == id_).soft_delete()
def add_policy(id_,
name,
abbreviation,
description,
owner,
kind,
deleted=False,
session=None):
session = session or db.get_session()
try:
with session.begin(subtransactions=True):
policy = Policy(id_, name, abbreviation, description, owner, kind,
deleted)
session.add(policy)
return policy
except oslo_db_exc.DBDuplicateEntry:
raise KeyError("Policy with name %s already exists" % name)
def delete_policy(id_, session=None):
session = session or db.get_session()
with session.begin(subtransactions=True):
# delete all rules for that policy from database
policy = get_policy_by_id(id_, session=session)
for rule in get_policy_rules(policy.name, session=session):
delete_policy_rule(rule.id, session=session)
policy_deleted = PolicyDeleted(policy)
session.add(policy_deleted)
# hard delete policy in Policy table
session.query(Policy).filter(Policy.id == id_).delete()
# soft delete policy in PolicyDeleted table
return session.query(PolicyDeleted).filter(
PolicyDeleted.id == id_).soft_delete()
def delete_datasource(cls, datasource_id):
datasource = cls.get_datasource(datasource_id)
session = db.get_session()
with session.begin(subtransactions=True):
cage = d6cage.d6Cage()
engine = cage.service_object('engine')
try:
engine.delete_policy(datasource['name'],
disallow_dangling_refs=True)
except exception.DanglingReference as e:
raise e
except KeyError:
raise DatasourceNotFound(id=datasource_id)
result = datasources_db.delete_datasource(
datasource_id, session)
if not result:
raise DatasourceNotFound(id=datasource_id)
cage.deleteservice(datasource['name'])
def add_policy_rule(id, policy_name, rule, comment, deleted=False,
rule_name="", session=None):
if session:
# IMPORTANT: if session provided, do not interrupt existing transaction
# with BEGIN which can drop db locks and change desired transaction
# boundaries for proper commit and rollback
policy_rule = PolicyRule(id, policy_name, rule, comment,
deleted, rule_name=rule_name)
session.add(policy_rule)
return policy_rule
# else
session = db.get_session()
with session.begin(subtransactions=True):
policy_rule = PolicyRule(id, policy_name, rule, comment,
deleted, rule_name=rule_name)
session.add(policy_rule)
return policy_rule
def get_ds_table_data(ds_id, tablename=None, session=None):
session = session or db.get_session()
try:
if tablename is None:
rows = session.query(DSTableData).filter(
DSTableData.ds_id == ds_id)
return_list = []
for row in rows:
return_list.append(
{'tablename': row.tablename,
'tabledata': _json_decode_table_data(row.tabledata)})
return return_list
else:
return _json_decode_table_data(session.query(DSTableData).filter(
DSTableData.ds_id == ds_id,
DSTableData.tablename == tablename).one().tabledata)
except db_exc.NoResultFound:
pass
def get_ds_table_data(ds_id, tablename=None, session=None):
session = session or db.get_session()
try:
if tablename is None:
rows = session.query(DSTableData).filter(
DSTableData.ds_id == ds_id)
return_list = []
for row in rows:
return_list.append(
{'tablename': row.tablename,
'tabledata': _json_decode_table_data(row.tabledata)})
return return_list
else:
return _json_decode_table_data(session.query(DSTableData).filter(
DSTableData.ds_id == ds_id,
DSTableData.tablename == tablename).one().tabledata)
except db_exc.NoResultFound:
pass
def add_datasource(cls, item, deleted=False, update_db=True):
req = cls.make_datasource_dict(item)
# If update_db is True, new_id will get a new value from the db.
new_id = req['id']
driver_info = cls.get_driver_info(item['driver'])
session = db.get_session()
try:
with session.begin(subtransactions=True):
LOG.debug("adding datasource %s", req['name'])
if update_db:
LOG.debug("updating db")
datasource = datasources_db.add_datasource(
id_=req['id'],
name=req['name'],
driver=req['driver'],
config=req['config'],
description=req['description'],
enabled=req['enabled'],
session=session)
new_id = datasource['id']
cage = d6cage.d6Cage()
engine = cage.service_object('engine')
try:
LOG.debug("creating policy %s", req['name'])
engine.create_policy(req['name'])
except KeyError:
# FIXME(arosen): we need a better exception then
# key error being raised here
raise DatasourceNameInUse(name=req['name'])
cage.createservice(name=req['name'],
moduleName=driver_info['module'],
args=item['config'],
module_driver=True,
type_='datasource_driver',
id_=new_id)
service = cage.service_object(req['name'])
engine.set_schema(req['name'], service.get_schema())
except db_exc.DBDuplicateEntry:
raise DatasourceNameInUse(name=req['name'])
new_item = dict(item)
new_item['id'] = new_id
return cls.make_datasource_dict(new_item)
def delete_datasource(cls, datasource_id, update_db=True):
datasource = cls.get_datasource(datasource_id)
session = db.get_session()
with session.begin(subtransactions=True):
cage = d6cage.d6Cage()
engine = cage.service_object('engine')
try:
engine.delete_policy(datasource['name'],
disallow_dangling_refs=True)
except exception.DanglingReference as e:
raise e
except KeyError:
raise DatasourceNotFound(id=datasource_id)
if update_db:
result = datasources_db.delete_datasource(
datasource_id, session)
if not result:
raise DatasourceNotFound(id=datasource_id)
cage.deleteservice(datasource['name'])
def _check_monasca_webhook_driver(self):
"""Check existence of monasca webhook datasource"""
session = db.get_session()
result = session.execute(
"SELECT count(*) FROM datasources WHERE driver = 'monasca_webhook'"
).scalar()
if result == 0:
return upgradecheck.Result(
upgradecheck.Code.SUCCESS,
'No currently configured data source uses the Monasca Webhook '
'data source driver, which contains backward-incompatible '
'schema changes.')
else:
return upgradecheck.Result(
upgradecheck.Code.WARNING,
'There are currently {} configured data source which use the '
'Monasca Webhook data source driver. Because this version of '
'Congress includes backward-incompatible schema changes to '
'the driver, Congress policies referring to Monasca Webhook '
'data may need to be adapted to the new schema.'.format(
result))
def add_policy(id_, name, abbreviation, description, owner, kind,
deleted=False, session=None):
if session:
# IMPORTANT: if session provided, do not interrupt existing transaction
# with BEGIN which can drop db locks and change desired transaction
# boundaries for proper commit and rollback
try:
policy = Policy(id_, name, abbreviation, description, owner,
kind, deleted)
session.add(policy)
return policy
except oslo_db_exc.DBDuplicateEntry:
raise KeyError("Policy with name %s already exists" % name)
# else
session = db.get_session()
try:
with session.begin(subtransactions=True):
policy = Policy(id_, name, abbreviation, description, owner,
kind, deleted)
session.add(policy)
return policy
except oslo_db_exc.DBDuplicateEntry:
raise KeyError("Policy with name %s already exists" % name)
def add_datasource(self, item, deleted=False, update_db=True):
req = self.make_datasource_dict(item)
# If update_db is True, new_id will get a new value from the db.
new_id = req['id']
driver_info = self.get_driver_info(item['driver'])
session = db.get_session()
try:
with session.begin(subtransactions=True):
LOG.debug("adding datasource %s", req['name'])
if update_db:
LOG.debug("updating db")
datasource = datasources_db.add_datasource(
id_=req['id'],
name=req['name'],
driver=req['driver'],
config=req['config'],
description=req['description'],
enabled=req['enabled'],
session=session)
new_id = datasource['id']
self.validate_create_datasource(req)
if self.is_valid_service(req['name']):
raise DatasourceNameInUse(value=req['name'])
try:
self.create_service(
class_path=driver_info['module'],
kwargs={'name': req['name'], 'args': item['config']})
except Exception:
raise DatasourceCreationError(value=req['name'])
except db_exc.DBDuplicateEntry:
raise DatasourceNameInUse(value=req['name'])
new_item = dict(item)
new_item['id'] = new_id
return self.make_datasource_dict(new_item)
def get_policies(session=None, deleted=False):
session = session or db.get_session()
return (session.query(Policy).filter(Policy.deleted == '').all())
def delete_policy_rule(id, session=None):
"""Specify either the ID or the NAME, and that policy is deleted."""
session = session or db.get_session()
return session.query(PolicyRule).filter(PolicyRule.id == id).soft_delete()
def delete_policy(id_, session=None):
session = session or db.get_session()
return session.query(LibraryPolicy).filter(
LibraryPolicy.id == id_).delete()
def delete_policies(session=None):
session = session or db.get_session()
return session.query(LibraryPolicy).delete()
def get_policies(session=None):
session = session or db.get_session()
return (session.query(LibraryPolicy).all())
