feat: Path Resolver and Validator

- BaseWorkflow provides super simple resolver and a No-op validator
- Each Workflow can bring its own path resolver and validator.
- workflow's run method is decorated to check for validaton of the
  language executable path.

Author: sriram-mv

aws_lambda_builders/builder.py

@@ -7,7 +7,6 @@
 import logging
 
 from aws_lambda_builders.registry import get_workflow, DEFAULT_REGISTRY
-from aws_lambda_builders.validate import RuntimeValidator
 from aws_lambda_builders.workflow import Capability
 
 LOG = logging.getLogger(__name__)
@@ -91,8 +90,6 @@ def build(self, source_dir, artifacts_dir, scratch_dir, manifest_path,
         :param options:
             Optional dictionary of options ot pass to build action. **Not supported**.
         """
-        if runtime:
-            self._validate_runtime(runtime)
 
         if not os.path.exists(scratch_dir):
             os.makedirs(scratch_dir)
@@ -107,16 +104,5 @@ def build(self, source_dir, artifacts_dir, scratch_dir, manifest_path,
 
         return workflow.run()
 
-    def _validate_runtime(self, runtime):
-        """
-        validate runtime and local runtime version to make sure they match
-
-        :type runtime: str
-        :param runtime:
-            String matching a lambda runtime eg: python3.6
-        """
-        RuntimeValidator.validate_runtime(required_language=self.capability.language,
-                                          required_runtime=runtime)
-
     def _clear_workflows(self):
         DEFAULT_REGISTRY.clear()

aws_lambda_builders/path_resolver.py

@@ -0,0 +1,15 @@
+"""
+Basic Path Resolver that just looks for the language in the path.
+"""
+
+from whichcraft import which
+
+
+class PathResolver(object):
+
+    def __init__(self, runtime):
+        self.runtime = runtime
+
+    @property
+    def path(self):
+        return which(self.runtime)

aws_lambda_builders/validate.py

@@ -0,0 +1,16 @@
+"""
+No-op validator that does not validate the runtime_path for a specified language.
+"""
+
+import logging
+
+LOG = logging.getLogger(__name__)
+
+
+class RuntimeValidator(object):
+
+    def __init__(self, runtime_path):
+        self.runtime_path = runtime_path
+
+    def validate_runtime(self):
+        pass

aws_lambda_builders/validator.py

@@ -1,13 +1,15 @@
 """
 Implementation of a base workflow
 """
-
+import functools
 import os
 import logging
 
 from collections import namedtuple
 import six
 
+from aws_lambda_builders.path_resolver import PathResolver
+from aws_lambda_builders.validator import RuntimeValidator
 from aws_lambda_builders.registry import DEFAULT_REGISTRY
 from aws_lambda_builders.exceptions import WorkflowFailedError, WorkflowUnknownError
 from aws_lambda_builders.actions import ActionFailedError
@@ -22,6 +24,22 @@
 Capability = namedtuple('Capability', ["language", "dependency_manager", "application_framework"])
 
 
+# TODO: Move sanitize out to its own class.
+def sanitize(func):
+    """
+    sanitize the executable path of the runtime specified by validating it.
+    :param func: Workflow's run method is sanitized
+    """
+
+    @functools.wraps(func)
+    def wrapper(*args, **kwargs):
+        # NOTE: we need to access workflow object to get the validator.
+        validator = args[0].get_validator()
+        validator.validate_runtime()
+        func(*args, **kwargs)
+    return wrapper
+
+
 class _WorkflowMetaClass(type):
     """
     A metaclass that maintains the registry of loaded builders
@@ -138,6 +156,19 @@ def is_supported(self):
 
         return True
 
+    def get_executable(self):
+        """
+        Non specialized path resolver that just returns the first executable for the runtime on the path.
+        """
+        return PathResolver(runtime=self.runtime).path
+
+    def get_validator(self):
+        """
+        No-op validator that does not validate the runtime_path.
+        """
+        return RuntimeValidator(runtime_path=self.get_executable())
+
+    @sanitize
     def run(self):
         """
         Actually perform the build by executing registered actions.

aws_lambda_builders/workflow.py

@@ -1 +1,2 @@
 six~=1.11
+whichcraft~=0.5.2

requirements/base.txt

@@ -115,17 +115,16 @@ def test_with_mocks(self, scratch_dir_exists, get_workflow_mock, importlib_mock,
 
         get_workflow_mock.return_value = workflow_cls
 
-        with patch.object(LambdaBuilder, "_validate_runtime"):
-            builder = LambdaBuilder(self.lang, self.lang_framework, self.app_framework, supported_workflows=[])
-
-            builder.build("source_dir", "artifacts_dir", "scratch_dir", "manifest_path",
-                          runtime="runtime", optimizations="optimizations", options="options")
-
-            workflow_cls.assert_called_with("source_dir", "artifacts_dir", "scratch_dir", "manifest_path",
-                                            runtime="runtime", optimizations="optimizations", options="options")
-            workflow_instance.run.assert_called_once()
-            os_mock.path.exists.assert_called_once_with("scratch_dir")
-            if scratch_dir_exists:
-                os_mock.makedirs.not_called()
-            else:
-                os_mock.makedirs.assert_called_once_with("scratch_dir")
+        builder = LambdaBuilder(self.lang, self.lang_framework, self.app_framework, supported_workflows=[])
+
+        builder.build("source_dir", "artifacts_dir", "scratch_dir", "manifest_path",
+                      runtime="runtime", optimizations="optimizations", options="options")
+
+        workflow_cls.assert_called_with("source_dir", "artifacts_dir", "scratch_dir", "manifest_path",
+                                        runtime="runtime", optimizations="optimizations", options="options")
+        workflow_instance.run.assert_called_once()
+        os_mock.path.exists.assert_called_once_with("scratch_dir")
+        if scratch_dir_exists:
+            os_mock.makedirs.not_called()
+        else:
+            os_mock.makedirs.assert_called_once_with("scratch_dir")