Address PR feedback

Author: volkangurel

aws_lambda_builders/actions.py

@@ -92,16 +92,10 @@ class CopySourceAction(BaseAction):
 
     PURPOSE = Purpose.COPY_SOURCE
 
-    def __init__(self, source_dir, dest_dir, only=None, excludes=None):
+    def __init__(self, source_dir, dest_dir, excludes=None):
         self.source_dir = source_dir
         self.dest_dir = dest_dir
-        self.only = only
         self.excludes = excludes or []
 
     def execute(self):
-        if self.only:
-            def ignore(source, names):
-                return [name for name in names if name not in self.only]
-        else:
-            ignore = shutil.ignore_patterns(*self.excludes)
-        copytree(self.source_dir, self.dest_dir, ignore=ignore)
+        copytree(self.source_dir, self.dest_dir, ignore=shutil.ignore_patterns(*self.excludes))

aws_lambda_builders/workflows/go_modules/DESIGN.md

@@ -17,16 +17,13 @@ builds a static binary using standard go tools.
 
 ```python
 def build(self, source_dir_path, artifacts_dir_path, executable_name):
-    """Builds a go project into an artifact directory.
+    """Builds a go project onto an output path.
 
     :type source_dir_path: str
     :param source_dir_path: Directory with the source files.
 
-    :type artifacts_dir_path: str
-    :param artifacts_dir_path: Directory to write dependencies into.
-
-    :type executable_name: str
-    :param executable_name: Name of the executable to create from the build.
+    :type output_path: str
+    :param output_path: Filename to write the executable output to.
 ```
 
 ### Implementation

aws_lambda_builders/workflows/go_modules/actions.py

@@ -12,18 +12,16 @@ class GoModulesBuildAction(BaseAction):
     DESCRIPTION = "Building Go package with Go Modules"
     PURPOSE = Purpose.RESOLVE_DEPENDENCIES
 
-    def __init__(self, source_dir, artifacts_dir, executable_name, builder):
+    def __init__(self, source_dir, output_path, builder):
         self.source_dir = source_dir
-        self.artifacts_dir = artifacts_dir
-        self.executable_name = executable_name
+        self.output_path = output_path
         self.builder = builder
 
     def execute(self):
         try:
             self.builder.build(
                 self.source_dir,
-                self.artifacts_dir,
-                self.executable_name
+                self.output_path,
             )
         except BuilderError as ex:
             raise ActionFailedError(str(ex))

aws_lambda_builders/workflows/go_modules/builder.py

@@ -15,31 +15,32 @@ def __init__(self, **kwargs):
 
 
 class GoModulesBuilder(object):
-    def __init__(self, osutils):
+    def __init__(self, osutils, runtime_path):
         """Initialize a GoModulesBuilder.
 
         :type osutils: :class:`lambda_builders.utils.OSUtils`
         :param osutils: A class used for all interactions with the
             outside OS.
+
+        :type runtime_path: str
+        :param runtime_path: The path to the go runtime.
         """
         self.osutils = osutils
+        self.runtime_path = runtime_path
 
-    def build(self, source_dir_path, artifacts_dir_path, executable_name):
-        """Builds a go project into an artifact directory.
+    def build(self, source_dir_path, output_path):
+        """Builds a go project onto an output path.
 
         :type source_dir_path: str
         :param source_dir_path: Directory with the source files.
 
-        :type artifacts_dir_path: str
-        :param artifacts_dir_path: Directory to write dependencies into.
-
-        :type executable_name: str
-        :param executable_name: Name of the executable to create from the build.
+        :type output_path: str
+        :param output_path: Filename to write the executable output to.
         """
         env = {}
         env.update(self.osutils.environ)
         env.update({"GOOS": "linux", "GOARCH": "amd64"})
-        cmd = ["go", "build", "-o", self.osutils.joinpath(artifacts_dir_path, executable_name), source_dir_path]
+        cmd = [self.runtime_path, "build", "-o", output_path, source_dir_path]
 
         p = self.osutils.popen(
             cmd,

aws_lambda_builders/workflows/go_modules/path_resolver.py

@@ -0,0 +1,25 @@
+"""
+Go Path Resolver that looks for the executable by runtime first, before proceeding to 'go' in PATH.
+"""
+import whichcraft
+
+
+class GoPathResolver(object):
+
+    def __init__(self, runtime, which=None):
+        self.language = "go"
+        self.runtime = runtime
+        self.executables = [self.language]
+        self.which = which or whichcraft.which
+
+    def _which(self):
+        for executable in self.executables:
+            path = self.which(executable)
+            if path:
+                return path
+        raise ValueError("Path resolution for runtime: {} of language: "
+                         "{} was not successful".format(self.runtime, self.language))
+
+    @property
+    def exec_path(self):
+        return self._which()

aws_lambda_builders/workflows/go_modules/utils.py

@@ -13,14 +13,11 @@ class OSUtils(object):
     """
     @property
     def environ(self):
-        return os.environ
+        return os.environ.copy()
 
     def joinpath(self, *args):
         return os.path.join(*args)
 
-    def basename(self, *args):
-        return os.path.basename(*args)
-
     def popen(self, command, stdout=None, stderr=None, env=None, cwd=None):
         p = subprocess.Popen(command, stdout=stdout, stderr=stderr, env=env, cwd=cwd)
         return p

aws_lambda_builders/workflows/go_modules/validator.py

@@ -0,0 +1,57 @@
+"""
+Go Runtime Validation
+"""
+
+import logging
+import os
+import subprocess
+
+from aws_lambda_builders.exceptions import MisMatchRuntimeError
+
+LOG = logging.getLogger(__name__)
+
+
+class GoRuntimeValidator(object):
+    SUPPORTED_RUNTIMES = {
+        "go1.x"
+    }
+
+    def __init__(self, runtime, runtime_path):
+        self.language = "go"
+        self.runtime = runtime
+        self.runtime_path = runtime_path
+
+    def has_runtime(self):
+        """
+        Checks if the runtime is supported.
+        :param string runtime: Runtime to check
+        :return bool: True, if the runtime is supported.
+        """
+        return self.runtime in self.SUPPORTED_RUNTIMES
+
+    def validate_runtime(self):
+        """
+        Checks if the language supplied matches the required lambda runtime
+        :param string runtime_path: runtime to check eg: /usr/bin/go
+        :raises MisMatchRuntimeError: Version mismatch of the language vs the required runtime
+        """
+        if not self.has_runtime():
+            LOG.warning("'%s' runtime is not "
+                        "a supported runtime", self.runtime_path)
+            return
+
+        expected_major_version = self.runtime.replace(self.language, "").split('.')[0]
+
+        p = subprocess.Popen([self.runtime_path, "version"],
+                             cwd=os.getcwd(),
+                             stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+        out, _ = p.communicate()
+
+        mismatched = p.returncode != 0 \
+            or len(out.split()) < 3 \
+            or out.split()[2].replace(self.language, "").split('.')[0] != expected_major_version
+        if mismatched:
+            raise MisMatchRuntimeError(language=self.language,
+                                       found_runtime=self.runtime_path,
+                                       required_runtime=self.runtime,
+                                       runtime_path=self.runtime_path)

aws_lambda_builders/workflows/go_modules/workflow.py

@@ -2,10 +2,11 @@
 Go Modules Workflow
 """
 from aws_lambda_builders.workflow import BaseWorkflow, Capability
-from aws_lambda_builders.actions import CopySourceAction
 
 from .actions import GoModulesBuildAction
 from .builder import GoModulesBuilder
+from .path_resolver import GoPathResolver
+from .validator import GoRuntimeValidator
 from .utils import OSUtils
 
 
@@ -37,9 +38,18 @@ def __init__(self,
         if osutils is None:
             osutils = OSUtils()
 
-        executable_name = osutils.basename(source_dir)
-        builder = GoModulesBuilder(osutils)
+        options = kwargs.get("options") or {}
+        handler = options.get("handler", None)
+
+        output_path = osutils.joinpath(artifacts_dir, handler)
+
+        builder = GoModulesBuilder(osutils, runtime_path=self.get_executable())
         self.actions = [
-            GoModulesBuildAction(source_dir, artifacts_dir, executable_name, builder),
-            CopySourceAction(source_dir, artifacts_dir, only=[executable_name]),
+            GoModulesBuildAction(source_dir, output_path, builder),
         ]
+
+    def get_executable(self):
+        return GoPathResolver(runtime=self.runtime).exec_path
+
+    def get_validator(self):
+        return GoRuntimeValidator(runtime=self.runtime, runtime_path=self.get_executable())

requirements/base.txt

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

tests/functional/workflows/go_modules/test_go_utils.py

@@ -19,10 +19,6 @@ def test_joinpath_joins_path_components(self):
         result = self.osutils.joinpath('a', 'b', 'c')
         self.assertEqual(result, os.path.join('a', 'b', 'c'))
 
-    def test_basename_returns_path_basename(self):
-        result = self.osutils.basename(os.path.dirname(__file__))
-        self.assertEqual(result, 'go_modules')
-
     def test_popen_runs_a_process_and_returns_outcome(self):
         cwd_py = os.path.join(os.path.dirname(__file__), '..', '..', 'testdata', 'cwd.py')
         p = self.osutils.popen([sys.executable, cwd_py],