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],

tests/integration/workflows/go_modules/test_go.py

@@ -21,6 +21,7 @@ def setUp(self):
         self.builder = LambdaBuilder(language="go",
                                      dependency_manager="modules",
                                      application_framework=None)
+        self.runtime = "go1.x"
 
     def tearDown(self):
         shutil.rmtree(self.artifacts_dir)
@@ -29,24 +30,30 @@ def tearDown(self):
     def test_builds_project_without_dependencies(self):
         source_dir = os.path.join(self.TEST_DATA_FOLDER, "no-deps")
         self.builder.build(source_dir, self.artifacts_dir, self.scratch_dir,
-                           os.path.join(source_dir, "go.mod"))
-        expected_files = {"no-deps"}
+                           os.path.join(source_dir, "go.mod"),
+                           runtime=self.runtime,
+                           options={"handler": "no-deps-main"})
+        expected_files = {"no-deps-main"}
         output_files = set(os.listdir(self.artifacts_dir))
         print(output_files)
         self.assertEquals(expected_files, output_files)
 
     def test_builds_project_with_dependencies(self):
         source_dir = os.path.join(self.TEST_DATA_FOLDER, "with-deps")
         self.builder.build(source_dir, self.artifacts_dir, self.scratch_dir,
-                           os.path.join(source_dir, "go.mod"))
-        expected_files = {"with-deps"}
+                           os.path.join(source_dir, "go.mod"),
+                           runtime=self.runtime,
+                           options={"handler": "with-deps-main"})
+        expected_files = {"with-deps-main"}
         output_files = set(os.listdir(self.artifacts_dir))
         self.assertEquals(expected_files, output_files)
 
     def test_fails_if_modules_cannot_resolve_dependencies(self):
         source_dir = os.path.join(self.TEST_DATA_FOLDER, "broken-deps")
         with self.assertRaises(WorkflowFailedError) as ctx:
             self.builder.build(source_dir, self.artifacts_dir, self.scratch_dir,
-                               os.path.join(source_dir, "go.mod"))
+                               os.path.join(source_dir, "go.mod"),
+                               runtime=self.runtime,
+                               options={"handler": "failed"})
         self.assertIn("GoModulesBuilder:Build - Builder Failed: ",
                       str(ctx.exception))

tests/unit/workflows/go_modules/test_actions.py

@@ -10,15 +10,15 @@ class TestGoModulesBuildAction(TestCase):
     @patch("aws_lambda_builders.workflows.go_modules.builder.GoModulesBuilder")
     def test_runs_bundle_install(self, BuilderMock):
         builder = BuilderMock.return_value
-        action = GoModulesBuildAction("source_dir", "artifacts_dir", "executable_name", builder)
+        action = GoModulesBuildAction("source_dir", "output_path", builder)
         action.execute()
-        builder.build.assert_called_with("source_dir", "artifacts_dir", "executable_name")
+        builder.build.assert_called_with("source_dir", "output_path")
 
     @patch("aws_lambda_builders.workflows.go_modules.builder.GoModulesBuilder")
     def test_raises_action_failed_on_failure(self, BuilderMock):
         builder = BuilderMock.return_value
         builder.build.side_effect = BuilderError(message="Fail")
-        action = GoModulesBuildAction("source_dir", "artifacts_dir", "executable_name", builder)
+        action = GoModulesBuildAction("source_dir", "output_path", builder)
         with self.assertRaises(ActionFailedError) as raised:
             action.execute()
         self.assertEqual(raised.exception.args[0], "Builder Failed: Fail")

tests/unit/workflows/go_modules/test_builder.py

@@ -14,23 +14,22 @@ def communicate(self):
         return self.out, self.err
 
 
-class TestSubprocessBundler(TestCase):
+class TestGoBuilder(TestCase):
 
     @patch("aws_lambda_builders.workflows.go_modules.utils.OSUtils")
     def setUp(self, OSUtilMock):
         self.osutils = OSUtilMock.return_value
         self.osutils.pipe = 'PIPE'
         self.popen = FakePopen()
         self.osutils.popen.side_effect = [self.popen]
-        self.under_test = GoModulesBuilder(self.osutils)
+        self.under_test = GoModulesBuilder(self.osutils, "go")
 
     def test_run_executes_bundler_on_nixes(self):
         self.osutils.is_windows.side_effect = [False]
-        self.under_test = GoModulesBuilder(self.osutils)
-        self.under_test.build("source_dir", "artifacts_dir", "executable_name")
+        self.under_test = GoModulesBuilder(self.osutils, "go")
+        self.under_test.build("source_dir", "output_path")
         self.osutils.popen.assert_called_with(
-            ["go", "build", "-o",
-             self.osutils.joinpath("artifacts_dir", "executable_name"), "source_dir"],
+            ["go", "build", "-o", "output_path", "source_dir"],
             cwd="source_dir",
             env={'GOOS': 'linux', 'GOARCH': 'amd64'},
             stderr='PIPE',
@@ -39,12 +38,12 @@ def test_run_executes_bundler_on_nixes(self):
 
     def test_returns_popen_out_decoded_if_retcode_is_0(self):
         self.popen.out = b'some encoded text\n\n'
-        result = self.under_test.build("source_dir", "artifacts_dir", "executable_name")
+        result = self.under_test.build("source_dir", "output_path")
         self.assertEqual(result, 'some encoded text')
 
     def test_raises_BuilderError_with_err_text_if_retcode_is_not_0(self):
         self.popen.returncode = 1
         self.popen.err = b'some error text\n\n'
         with self.assertRaises(BuilderError) as raised:
-            self.under_test.build("source_dir", "artifacts_dir", "executable_name")
+            self.under_test.build("source_dir", "output_path")
         self.assertEqual(raised.exception.args[0], "Builder Failed: some error text")

tests/unit/workflows/go_modules/test_path_resolver.py

@@ -0,0 +1,28 @@
+import os
+from unittest import TestCase
+
+import mock
+
+from aws_lambda_builders.workflows.go_modules.path_resolver import GoPathResolver
+
+
+class TestPythonPathResolver(TestCase):
+
+    def setUp(self):
+        self.path_resolver = GoPathResolver(runtime="go1.x")
+
+    def test_inits(self):
+        self.assertEquals(self.path_resolver.language, "go")
+        self.assertEquals(self.path_resolver.runtime, "go1.x")
+        self.assertEquals(self.path_resolver.executables,
+                          [self.path_resolver.language])
+
+    def test_which_fails(self):
+        path_resolver = GoPathResolver(runtime="go1.x", which=lambda x: None)
+        with self.assertRaises(ValueError):
+            path_resolver._which()
+
+    def test_which_success_immediate(self):
+        with mock.patch.object(self.path_resolver, '_which') as which_mock:
+            which_mock.return_value = os.getcwd()
+            self.assertEquals(self.path_resolver.exec_path, os.getcwd())