policies/*: remove Policy.negate, order, timeout (#39)

policies: rewrite engine to use PolicyBinding for order/negate/timeout
policies: rewrite engine to use PolicyResult instead of tuple

passbook/policies/engine.py

@@ -1,14 +1,14 @@
 """passbook policy engine"""
 from multiprocessing import Pipe, set_start_method
 from multiprocessing.connection import Connection
-from typing import List, Optional, Tuple
+from typing import List, Optional
 
 from django.core.cache import cache
 from django.http import HttpRequest
 from structlog import get_logger
 
 from passbook.core.models import User
-from passbook.policies.models import Policy
+from passbook.policies.models import Policy, PolicyBinding, PolicyBindingModel
 from passbook.policies.process import PolicyProcess, cache_key
 from passbook.policies.types import PolicyRequest, PolicyResult
 
@@ -24,12 +24,14 @@ class PolicyProcessInfo:
     process: PolicyProcess
     connection: Connection
     result: Optional[PolicyResult]
-    policy: Policy
+    binding: PolicyBinding
 
-    def __init__(self, process: PolicyProcess, connection: Connection, policy: Policy):
+    def __init__(
+        self, process: PolicyProcess, connection: Connection, binding: PolicyBinding
+    ):
         self.process = process
         self.connection = connection
-        self.policy = policy
+        self.binding = binding
         self.result = None
 
 
@@ -37,54 +39,64 @@ class PolicyEngine:
     """Orchestrate policy checking, launch tasks and return result"""
 
     use_cache: bool = True
-    policies: List[Policy] = []
     request: PolicyRequest
 
+    __pbm: PolicyBindingModel
     __cached_policies: List[PolicyResult]
     __processes: List[PolicyProcessInfo]
 
-    def __init__(self, policies, user: User, request: HttpRequest = None):
-        self.policies = policies
+    def __init__(
+        self, pbm: PolicyBindingModel, user: User, request: HttpRequest = None
+    ):
+        if not isinstance(pbm, PolicyBindingModel):
+            raise ValueError(f"{pbm} is not instance of PolicyBindingModel")
+        self.__pbm = pbm
         self.request = PolicyRequest(user)
         if request:
             self.request.http_request = request
         self.__cached_policies = []
         self.__processes = []
 
-    def _select_subclasses(self) -> List[Policy]:
+    def _iter_bindings(self) -> List[PolicyBinding]:
         """Make sure all Policies are their respective classes"""
-        return (
-            Policy.objects.filter(pk__in=[x.pk for x in self.policies])
-            .select_subclasses()
-            .order_by("order")
+        return PolicyBinding.objects.filter(target=self.__pbm, enabled=True).order_by(
+            "order"
         )
 
+    def _check_policy_type(self, policy: Policy):
+        """Check policy type, make sure it's not the root class as that has no logic implemented"""
+        # policy_type = type(policy)
+        if policy.__class__ == Policy:
+            raise TypeError(f"Policy '{policy}' is root type")
+
     def build(self) -> "PolicyEngine":
         """Build task group"""
-        for policy in self._select_subclasses():
-            cached_policy = cache.get(cache_key(policy, self.request.user), None)
+        for binding in self._iter_bindings():
+            self._check_policy_type(binding.policy)
+            policy = binding.policy
+            cached_policy = cache.get(cache_key(binding, self.request.user), None)
             if cached_policy and self.use_cache:
                 LOGGER.debug("P_ENG: Taking result from cache", policy=policy)
                 self.__cached_policies.append(cached_policy)
                 continue
             LOGGER.debug("P_ENG: Evaluating policy", policy=policy)
             our_end, task_end = Pipe(False)
-            task = PolicyProcess(policy, self.request, task_end)
+            task = PolicyProcess(binding, self.request, task_end)
             LOGGER.debug("P_ENG: Starting Process", policy=policy)
             task.start()
             self.__processes.append(
-                PolicyProcessInfo(process=task, connection=our_end, policy=policy)
+                PolicyProcessInfo(process=task, connection=our_end, binding=binding)
             )
         # If all policies are cached, we have an empty list here.
         for proc_info in self.__processes:
-            proc_info.process.join(proc_info.policy.timeout)
+            proc_info.process.join(proc_info.binding.timeout)
             # Only call .recv() if no result is saved, otherwise we just deadlock here
             if not proc_info.result:
                 proc_info.result = proc_info.connection.recv()
         return self
 
     @property
-    def result(self) -> Tuple[bool, List[str]]:
+    def result(self) -> PolicyResult:
         """Get policy-checking result"""
         messages: List[str] = []
         process_results: List[PolicyResult] = [
@@ -95,10 +107,10 @@ class PolicyEngine:
             if result.messages:
                 messages += result.messages
             if not result.passing:
-                return False, messages
-        return True, messages
+                return PolicyResult(False, *messages)
+        return PolicyResult(True, *messages)
 
     @property
     def passing(self) -> bool:
         """Only get true/false if user passes"""
-        return self.result[0]
+        return self.result.passing