flows: implement planner, start new executor

passbook/flows/planner.py

@@ -0,0 +1,66 @@
+"""Flows Planner"""
+from dataclasses import dataclass, field
+from time import time
+from typing import List, Tuple
+
+from django.http import HttpRequest
+from structlog import get_logger
+
+from passbook.flows.exceptions import FlowNonApplicableError
+from passbook.flows.models import Factor, Flow
+from passbook.policies.engine import PolicyEngine
+
+LOGGER = get_logger()
+
+
+@dataclass
+class FlowPlan:
+    """This data-class is the output of a FlowPlanner. It holds a flat list
+    of all Factors that should be run."""
+
+    factors: List[Factor] = field(default_factory=list)
+
+    def next(self) -> Factor:
+        """Return next pending factor from the bottom of the list"""
+        factor_cls = self.factors.pop(0)
+        return factor_cls
+
+
+class FlowPlanner:
+    """Execute all policies to plan out a flat list of all Factors
+    that should be applied."""
+
+    flow: Flow
+
+    def __init__(self, flow: Flow):
+        self.flow = flow
+
+    def _check_flow_root_policies(self, request: HttpRequest) -> Tuple[bool, List[str]]:
+        engine = PolicyEngine(self.flow.policies.all(), request.user, request)
+        engine.build()
+        return engine.result
+
+    def plan(self, request: HttpRequest) -> FlowPlan:
+        """Check each of the flows' policies, check policies for each factor with PolicyBinding
+        and return ordered list"""
+        LOGGER.debug("Starting planning process", flow=self.flow)
+        start_time = time()
+        plan = FlowPlan()
+        # First off, check the flow's direct policy bindings
+        # to make sure the user even has access to the flow
+        root_passing, root_passing_messages = self._check_flow_root_policies(request)
+        if not root_passing:
+            raise FlowNonApplicableError(root_passing_messages)
+        # Check Flow policies
+        for factor in self.flow.factors.order_by("order").select_subclasses():
+            engine = PolicyEngine(factor.policies.all(), request.user, request)
+            engine.build()
+            passing, _ = engine.result
+            if passing:
+                LOGGER.debug("Factor passing", factor=factor)
+                plan.factors.append(factor)
+        end_time = time()
+        LOGGER.debug(
+            "Finished planning", flow=self.flow, duration_s=end_time - start_time
+        )
+        return plan