too much stuff

Author: nir0s

packer/__init__.py

@@ -1,4 +1,5 @@
 import sh
+import os
 
 __version__ = '0.0.1'
 
@@ -18,37 +19,49 @@ def __init__(self, packerfile, exc=None, only=None, vars=None,
         :param string vars_file: Path to variables file
         :param string exec_path: Path to Packer executable
         """
-        self.packerfile = packerfile
-        self.exc = exc if exc else []
-        self.only = only if only else []
-        self.vars = vars if vars else {}
+        self.packerfile = self._validate_argtype(packerfile, str)
         self.vars_file = vars_file
+        if not os.path.isfile(self.packerfile):
+            raise OSError('packerfile not found at path: {0}'.format(
+                self.packerfile))
+        self.exc = self._validate_argtype(exc if exc else [], list)
+        self.only = self._validate_argtype(only if only else [], list)
+        self.vars = self._validate_argtype(vars if vars else {}, dict)
+        if not os.path.isfile(self.packerfile):
+            raise OSError('packerfile not found at path: {0}'.format(
+                self.packerfile))
         self.packer = sh.Command(exec_path)
 
-    def _append_base_arguments(self, cmd):
-        """Add base arguments to packer commands.
+    def _validate_argtype(self, arg, argtype):
+        if not isinstance(arg, argtype):
+            raise PackerException('{0} argument must be of type {1}'.format(
+                arg, argtype))
+        return arg
+
+    def _append_base_arguments(self, command):
+        """Appends base arguments to packer commands.
 
         -except, -only, -var and -vars-file are appeneded to almost
         all subcommands in packer. As such this can be called to add
         these flags to the subcommand.
         """
         if self.exc and self.only:
             raise PackerException('Cannot provide both "except" and "only"')
-        if self.exc:
-            cmd = cmd.bake('-except={0}'.format(self._joinc(self.exc)))
-        if self.only:
-            cmd = cmd.bake('-only={0}'.format(self._joinc(self.only)))
-        for var, value in self.vars.iteritems():
-            cmd = cmd.bake("-var '{0}={1}'".format(var, value))
+        elif self.exc:
+            command = command.bake('-except={0}'.format(self._joinc(self.exc)))
+        elif self.only:
+            command = command.bake('-only={0}'.format(self._joinc(self.only)))
+        for var, value in self.vars.items():
+            command = command.bake("-var '{0}={1}'".format(var, value))
         if self.vars_file:
-            cmd = cmd.bake('-vars-file={0}'.format(self.vars_file))
-        return cmd
+            command = command.bake('-vars-file={0}'.format(self.vars_file))
+        return command
 
     def _joinc(self, lst):
         """Returns a comma delimited string from a list"""
         return str(','.join(lst))
 
-    def _join(self, lst):
+    def _joins(self, lst):
         """Returns a space delimited string from a list"""
         return str(' '.join(lst))
 
@@ -69,35 +82,44 @@ def validate(self, syntax_only=False):
         :param bool syntax_only: Whether to validate the syntax only
         without validating the configuration itself.
         """
-        validator = self.packer.validate
+        command = self.packer.validate
         if syntax_only:
-            validator = validator.bake('-syntax-only')
-        validator = self._append_base_arguments(validator)
-        validator = validator.bake(self.packerfile)
-        validated = validator()
+            command = command.bake('-syntax-only')
+        command = self._append_base_arguments(command)
+        command = command.bake(self.packerfile)
+        return command()
+        # err.. need to return normal values with validation result
         # validated.succeeded = True if validated.exit_code == 0 else False
         # validated.failed = not validated.succeeded
-        return validated
 
     def push(self, create=True, token=False):
         """Implmenets the `packer push` function
+
+        UNTESTED!
         """
-        pusher = self.packer.push
+        command = self.packer.push
         if create:
-            pusher = pusher.bake('-create=true')
+            command = command.bake('-create=true')
         if token:
-            pusher = pusher.bake('-token={0}'.format(token))
-        pusher = pusher.bake(self.packerfile)
-        return pusher()
+            command = command.bake('-token={0}'.format(token))
+        command = command.bake(self.packerfile)
+        return command()
 
     def fix(self, to_file=None):
         """Implements the `packer fix` function
         """
-        fixer = self.packer.fix
-        fixer = fixer.bake(self.packerfile)
+        cmd = self.packer.fix
+        cmd = cmd.bake(self.packerfile)
+        result = cmd()
         if to_file:
-            fixer = fixer.bake(' > {0}'.format(to_file))
-        return fixer()
+            with open(to_file, 'w') as f:
+                f.write(result.stdout)
+        return result
+
+    def _add_opt(self, command, option):
+        if option:
+            return command.bake(option)
+        return command
 
     def build(self, parallel=True, debug=False, force=False):
         """Executes a Packer build (`packer build`)
@@ -106,16 +128,19 @@ def build(self, parallel=True, debug=False, force=False):
         :param bool debug: Run in debug mode
         :param bool force: Force artifact output even if exists
         """
-        builder = self.packer.build
-        if parallel:
-            builder = builder.bake('-parallel=true')
-        if debug:
-            builder = builder.bake('-debug')
-        if force:
-            builder = builder.bake('-force')
-        builder = self._append_base_arguments(builder)
-        builder = builder.bake(self.packerfile)
-        return builder()
+        cmd = self.packer.build
+        cmd = self._add_opt(cmd, '-parallel=true' if parallel else None)
+        cmd = self._add_opt(cmd, '-debug' if debug else None)
+        cmd = self._add_opt(cmd, '-force' if force else None)
+        # if parallel:
+        #     cmd = cmd.bake('-parallel=true')
+        # if debug:
+        #     cmd = cmd.bake('-debug')
+        # if force:
+        #     cmd = cmd.bake('-force')
+        cmd = self._append_base_arguments(cmd)
+        cmd = cmd.bake(self.packerfile)
+        return cmd()
 
     def inspect(self):
         """Inspects a Packer Templates file (`packer inspect -machine-readable`)
@@ -145,12 +170,12 @@ def inspect(self):
             }
           ]
         """
-        inspector = self.packer.inspect
-        inspector = inspector.bake('-machine-readable', self.packerfile)
-        inspected = inspector()
-        inspected.parsed_output = self._parse_inspection_output(
-            inspected.stdout)
-        return inspected
+        command = self.packer.inspect
+        command = command.bake('-machine-readable', self.packerfile)
+        result = command()
+        result.parsed_output = self._parse_inspection_output(
+            result.stdout)
+        return result
 
     def _parse_inspection_output(self, output):
         """Parses the machine-readable output `packer inspect` provides.
@@ -176,5 +201,5 @@ def _parse_inspection_output(self, output):
         return parts
 
 
-class PackerException():
+class PackerException(Exception):
     pass

packer/tests/resources/packerfile.json

@@ -1,7 +1,7 @@
 {
   "variables": {
-    "variable1": "{{user `variable1`}}",
-    "variable2": "{{user `variable2`}}",
+    "variable2": "",
+    "variable1": "",
     "aws_access_key": "{{env `AWS_ACCESS_KEY_ID`}}",
     "aws_secret_key": "{{env `AWS_ACCESS_KEY`}}",
     "aws_source_ami": "",

tester.py

@@ -10,9 +10,9 @@
 vars_file = '/x'
 
 p = packer.Packer(packerfile, exc=exc, only=only, vars=vars)
-# print(p.version())
-
-print(p.validate(syntax_only=False))
-# print(p.build())
-# result = p.inspect()
-# print result.parsed_output
+print(p.version())
+print(p.validate(syntax_only=True))
+result = p.inspect()
+print result.parsed_output
+print(p.fix('TEST.json'))
+print(p.build())