def load_policy(self, model):
'''
implementing add Interface for casbin \n
load all policy rules from mongodb \n
'''
for line in self._collection.find():
if 'ptype' not in line:
continue
rule = CasbinRule(line['ptype'])
if 'v0' in line:
rule.v0 = line['v0']
if 'v1' in line:
rule.v1 = line['v1']
if 'v2' in line:
rule.v2 = line['v2']
if 'v3' in line:
rule.v3 = line['v3']
if 'v4' in line:
rule.v4 = line['v4']
if 'v5' in line:
rule.v5 = line['v5']
persist.load_policy_line(str(rule), model)
def load_policy(self, model):
"""loads all policy rules from the storage."""
bucket = self.get_bucket()
query = N1QLQuery(
r"SELECT meta().id, ptype, `values` FROM %s WHERE meta().id "
r'LIKE "casbin_rule%%"' % self._bucket_name)
query.consistency = STATEMENT_PLUS
try:
for line in bucket.n1ql_query(query):
try:
rule = CasbinRule(ptype=line["ptype"],
values=line["values"])
except KeyError as err:
self.logger.error(
"skipping policy: %s not formatted properly and has no: %s"
% (line["id"], err))
continue
else:
persist.load_policy_line(str(rule), model)
except (CouchbaseNetworkError, CouchbaseTransientError):
# refresh stale connection
bucket = self.get_bucket(refresh_conn=True)
for line in bucket.n1ql_query(query):
try:
rule = CasbinRule(ptype=line["ptype"],
values=line["values"])
except KeyError as err:
self.logger.error(
"skipping policy: %s not formatted properly and has no: %s"
% (line["id"], err))
continue
else:
persist.load_policy_line(str(rule), model)
def _load_policy_file(self, model):
log.log_print("********* _load_policy_file **********")
with open(self._file_path, "rb") as file:
line = file.readline()
while line:
persist.load_policy_line(line.decode().strip(), model)
line = file.readline()
def load_policy(self, model):
'''
implementing add Interface for casbin \n
load all policy rules from mongodb \n
'''
lines = CasbinRule.objects()
for line in lines:
persist.load_policy_line(str(line), model)
def load_policy(self, model):
"""Load all policy rules from the storage."""
rules = self.__get_all_rules()
for _rule in rules:
_rule.pop('id', None)
rule = ', '.join(_rule.values())
self.logger.info('Adapter_Rule: %s', str(rule))
persist.load_policy_line(str(rule), model)
def load_policy(self, model):
"""loads all policy rules from the storage."""
for db in self.adapter_models:
for qs in db.objects.all():
for item in qs.adapter():
values = list(item.values())
# print(values)
persist.load_policy_line(', '.join(values), model)
def load_policy(self, model):
"""loads all policy rules from the storage."""
for db in self.adapter_models:
for qs in db.objects.all():
values = [x for x in qs.adapter().values() if x]
# print(type(db), model)
# print(values)
persist.load_policy_line(', '.join(values), model)
def load_policy(self, model):
"""loads all policy rules from the storage."""
self._commit(
) # Commit transaction, so you can see the insert/update/delete from other transaction when use multi processes(eg. Nginx reverse proxy)
lines = self._session.query(self._db_class).all()
for line in lines:
persist.load_policy_line(str(line), model)
self._commit()
def load_policy(self, model):
"""
loads all policy rules from the storage
"""
with self.app.app_context():
lines = Permission.query.all()
for line in lines:
persist.load_policy_line(str(line), model)
def load_filtered_policy(self, model, filter) -> None:
"""loads all policy rules from the storage."""
query = self._session.query(self._db_class)
filters = self.filter_query(query, filter)
filters = filters.all()
for line in filters:
persist.load_policy_line(str(line), model)
self._filtered = True
def load_policy(self, model):
"""
Loads the Policy stored in Redis to our Pycasbin Instance.
"""
# read policy list from Redis
policies = self.r.lrange(self.lkey, 0, -1)
assert len(policies) > 0
# load policies to our enforcer.(pycasbin)
for policy in policies:
persist.load_policy_line(policy.decode('utf-8'), model)
logger.debug(f"Loaded Policy in {self.lkey} from Redis to Enforcer")
def load_policy(self, model):
"""Implementing add Interface for casbin. Load all policy rules from mongodb
Args:
model (CasbinRule): CasbinRule object
"""
for line in self._collection.find():
if 'ptype' not in line:
continue
rule = CasbinRule(line['ptype'])
for key, value in line.items():
setattr(rule, key, value)
persist.load_policy_line(str(rule), model)
def load_policy(self, model):
"""load all policies from database"""
response = self.dynamodb.scan(TableName=self.table_name)
for i in response['Items']:
persist.load_policy_line(self.get_line_from_item(i), model)
while 'LastEvaluatedKey' in response:
response = self.dynamodb.scan(
TableName=self.table_name,
ExclusiveStartKey=response['LastEvaluatedKey'])
for i in response['Items']:
persist.load_policy_line(self.get_line_from_item(i), model)
# To forcefully break the loop when testing
if "LastEvaluatedKey" in response and response["LastEvaluatedKey"] == "from_pytest":
break
def load_filtered_policy(self, model, filter) -> None:
"""loads all policy rules from the storage."""
self._filtered = True
query = self._session.query(self._db_class)
filters = []
for p in filter.P:
filters.append(
and_(self._db_class.ptype == "p",
*self.__build_rule_filter(p)))
for g in filter.G:
filters.append(
and_(self._db_class.ptype == "g",
*self.__build_rule_filter(g)))
query = query.filter(or_(*filters))
for line in query.all():
persist.load_policy_line(str(line), model)
def load_filtered_policy(self, model, filter) -> None:
"""loads all policy rules from the storage."""
self._commit(
) # Commit transaction, so you can see the insert/update/delete from other transaction when use multi processes(eg. Nginx reverse proxy)
self._filtered = True
query = self._session.query(self._db_class)
filters = []
for p in filter.P:
filters.append(
and_(self._db_class.ptype == "p",
*self.__build_rule_filter(p)))
for g in filter.G:
filters.append(
and_(self._db_class.ptype == "g",
*self.__build_rule_filter(g)))
query = query.filter(or_(*filters))
for line in query.all():
persist.load_policy_line(str(line), model)
self._commit()
def load_policy(self, model):
"""loads all policy rules from the storage."""
lines = CasbinRule.objects.all()
for line in lines:
persist.load_policy_line(str(line), model)
def load_policy(self, model):
"""loads all policy rules from the storage."""
count = CasbinRule.select().count()
for i in range(1, 1 + count):
line = CasbinRule.get(i)
persist.load_policy_line(str(line), model)
def load_policy(self, model):
"""loads all policy rules from the storage."""
for cr in self.adapter_model.objects.all():
values = [x for x in cr.serializer().values() if x]
# 'p, xiaoming, /api/v1/user/info, GET'
persist.load_policy_line(', '.join(values), model)
def load_policy(self, model):
"""loads all policy rules from the storage."""
lines = self._session.query(CasbinRule).all()
for line in lines:
persist.load_policy_line(str(line), model)
def _load_policy(self, model):
line = self._fd.readline()
while line:
persist.load_policy_line(line.decode().strip(), model)
line = self._fd.readline()
def load_policy(self, model):
"""loads all policy rules from the storage."""
lines = self._session.query(self._db_class).all()
for line in lines:
persist.load_policy_line(str(line), model)
self._commit()
