terragov 0.3.3 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 81263feff3c924e10abd2ee9970eb7f0b8c38a8b
-  data.tar.gz: caa6a769b206bd259ed0cb6ad9402226ee140f53
+  metadata.gz: 04caa8ed8dd4cc7302986169259c013f0e3f478b
+  data.tar.gz: e1542e895f76d7de847d4c1b72ffb07001f7bb6b
 SHA512:
-  metadata.gz: cc20df3bc78578f2f72661ee803affded61c966394262753c7d2026c78cc0e9119287b6fb66f7d26de1f80b6a10c5ace7081fba0c8e3a082e8c7121313362367
-  data.tar.gz: 7d4cbadd5f067d840dc14de3a92305735346fefb13aad4ae7980cc3549ed613be0f85298097c12b6b5ef81149070bbd260cdaaed503914c0451eb4bd169c937f
+  metadata.gz: 1629715b97ee6ed0a9b3d4dcc4305804387dc1b9c7b367f5cf847a8843a0f9269de6fd38b3c6195ff6252d2b1523da7f00e66ca5b828133ad523e3b3bbc077a3
+  data.tar.gz: 2bd326f14b744b6fc2cb07c2f5b531efebf198756d4459fc307a562a03bf7d2a697b4332e1cb85f57e1ac035dc9f943e6c83ed68a63ccf2bcc91f995a6f68162

data/CHANGELOG.md

@@ -1,3 +1,11 @@
+## 0.4.0 (2018-02-07)
+
+ - Added end to end tests
+ - Added further tests to Terraform class
+ - Code tidy
+ - Changed "dryrun" flag to "test"
+ - Broke out logic to separate Config class
+
 ## 0.3.3 (2018-01-30)
 
  - Allow full hierachy use of data across all environments

data/README.md

@@ -85,7 +85,7 @@ These may be set in the same way as described above, with the same precedence, b
 Argument | Description
 --- | ---
 `verbose` | Be more noisy
-`dryrun` | CLI option is `--dry-run`, but config file and env var is `dryrun` and `TERRAGOV_DRYRUN` respectively
+`test` | Output commands, but do not run anything. Useful for tests.
 `skip_git_check` | Do not compare branches between the repo and data directories
 
 ## Deployment

data/lib/terragov.rb

@@ -1,4 +1,5 @@
 require 'terragov/buildpaths'
+require 'terragov/config.rb'
 require 'terragov/cleaner'
 require 'terragov/cli'
 require 'terragov/git'

data/lib/terragov/buildpaths.rb

@@ -48,11 +48,7 @@ module Terragov
     end
 
     def data_validation(path)
-      if File.exist?(path)
-        true
-      else
-        false
-      end
+      File.exist?(path)
     end
 
     def data_paths(options = {})
@@ -86,7 +82,7 @@ module Terragov
         paths.each do |path|
           puts path
         end
-        return false
+        false
       end
     end
 
@@ -101,7 +97,6 @@ module Terragov
       $full_vars = []
       data_paths(options).each do |path|
         if data_validation(path)
-          # TODO: write sops class
           if path == paths[:secret_project_data] || path == paths[:secret_common_project_data]
             $full_vars << "-var-file <(sops -d #{path})"
           else

data/lib/terragov/cli.rb

@@ -6,6 +6,7 @@ require_relative 'terraform'
 require_relative 'cleaner'
 require_relative 'version'
 require_relative 'git'
+require_relative 'config'
 
 module Terragov
   class Cli
@@ -16,157 +17,45 @@ module Terragov
       program :version, Terragov::VERSION
       program :description, 'Wrapper for GOV.UK Terraform deployments.'
 
+      # Project should be loaded independently, unless used in deployment mode
+      global_option('-p', '--project STRING', String, 'Name of the project') do |project|
+        $project = project || ENV['TERRAGOV_PROJECT']
+      end
+
       global_option('-c', '--config-file FILE', 'Specify a config file. Has less precedence than environment variables, which in turn have less precedence than CLI options') do |config_file|
-        $config_file = config_file
+        $config_file = config_file || ENV['TERRAGOV_CONFIG_FILE']
       end
 
       global_option('-d', '--data-dir DIRECTORY', String, 'Location of the data directory') do |data_dir|
-        $data_dir = data_dir
+       @data_dir_cli ||= data_dir
       end
 
       global_option('-e', '--environment STRING', String, 'Select environment') do |environment|
-        $environment = environment
-      end
-
-      global_option('-p', '--project STRING', String, 'Name of the project') do |project|
-        $project = project
+        @environment_cli = environment || false
       end
 
       global_option('-r', '--repo-dir DIRECTORY', String, 'Location of the main terraform repository') do |repo_dir|
-        $repo_dir = repo_dir
+        @repo_dir_cli = repo_dir || false
       end
 
       global_option('-s', '--stack STRING', String, 'Name of the stack') do |stack|
-        $stack = stack
+        @stack_cli = stack || false
       end
 
       global_option('--extra STRING', String, 'Any additional arguments to pass in the following format: --extra \\\\-target resource.foo.') do |extra|
-        $extra = extra
+        @extra = extra || nil
       end
 
       global_option('--verbose', 'Verbose mode') do |verbose|
-        $verbose = verbose
+        @verbose = verbose || false
       end
 
-      global_option('--dry-run', 'Dry run mode', 'Output the commands to run, but do not run them') do |dryrun|
-        $dryrun = dryrun
+      global_option('--test', 'Dry run mode', 'Output the commands to run, but do not run them') do |test|
+        @test = test || false
       end
 
       global_option('--skip-git-check', 'Skip git check', 'Do not check the status of git repositories') do |skip_git_check|
-        $skip_git_check = skip_git_check
-      end
-    end
-
-    def data_dir
-      $data_dir ? $data_dir : false
-    end
-
-    def environment
-      $environment ? $environment : false
-    end
-
-    def project
-      $project ? $project : false
-    end
-
-    def repo_dir
-      $repo_dir ? $repo_dir : false
-    end
-
-    def stack
-      $stack ? $stack : false
-    end
-
-    def extra
-      return $extra if $extra
-    end
-
-    def verbose
-      true ? $verbose : false
-    end
-
-    def dryrun
-      true ? $dryrun : false
-    end
-
-    def skip_git_check
-      true ? $skip_git_check : false
-    end
-
-    def load_config_file
-      if $config_file || ENV['TERRAGOV_CONFIG_FILE']
-        file = $config_file || ENV['TERRAGOV_CONFIG_FILE']
-        YAML.load_file(File.expand_path(file))
-      end
-    end
-
-    def config_file_default
-      if load_config_file['default'].nil?
-        return nil
-      else
-        return load_config_file['default']
-      end
-    end
-
-    def config_file_specific_project(project_name)
-      load_config_file[project_name]
-    end
-
-    def config_file(option)
-      # This has to be loaded in seperately to avoid any cyclic dependencies
-      project_name = $project || ENV['TERRAGOV_PROJECT']
-
-      if project_name.nil?
-        if config_file_default.nil?
-          return nil
-        else
-          return config_file_default[option]
-        end
-      else
-        project_config = config_file_specific_project(project_name)
-        if project_config.nil? or project_config[option].nil?
-          return config_file_default[option]
-        else
-          return project_config[option]
-        end
-      end
-    end
-
-    def config(option, file = false, required = true)
-      env_var = "TERRAGOV_#{option.upcase}"
-      error_message = "Must set #{option}. Use --help for details."
-
-      # Load from CLI option
-      if public_send(option)
-        if file
-          return File.expand_path(public_send(option))
-        else
-          return public_send(option)
-        end
-
-      # Load from environment variable
-      elsif ENV[env_var]
-        if file
-          return File.expand_path(ENV[env_var])
-        else
-          return ENV[env_var]
-        end
-
-      # Load from config file
-      elsif !load_config_file.nil?
-        if config_file(option).nil?
-          abort(error_message) if required
-          return false
-        else
-          if file
-            return File.expand_path(config_file(option))
-          else
-            return config_file(option)
-          end
-        end
-      else
-        abort(error_message) if required
-        return false
+        @skip_git_check = skip_git_check || false
       end
     end
 
@@ -175,66 +64,84 @@ module Terragov
 
       # Always load the project name first
       unless deployment
-        cmd_hash = { 'project' => config('project') }
+        cmd_hash = { 'project' => $project }
       end
 
+      config = Terragov::Config.new
+
+      data_dir = config.lookup({
+        name: 'data_dir',
+        cli: @data_dir_cli,
+        file: true,
+      })
+      environment = config.lookup({
+        name: 'environment',
+        cli: @environment_cli,
+      })
+      repo_dir = config.lookup({
+        name: 'repo_dir',
+        cli: @repo_dir_cli,
+        file: true,
+      })
+      stack = config.lookup({
+        name: 'stack',
+        cli: @stack_cli,
+      })
+
+      #require 'pry'; binding.pry
+
       cmd_hash.merge({
-        'environment' => config('environment'),
-        'data_dir'    => config('data_dir', true),
-        'stack'       => config('stack'),
-        'repo_dir'    => config('repo_dir', true),
-        'extra'       => extra
+        'environment' => environment,
+        'data_dir'    => data_dir,
+        'stack'       => stack,
+        'repo_dir'    => repo_dir,
+        'extra'       => @extra,
       })
     end
 
     def git_compare_repo_and_data(skip = false)
-      git_helper = Terragov::Git.new
-      # FIXME: this is confusing as we want to check the repository git status from
-      # the root, but the "data" directory is one level down in the repository
-      repo_dir_root = cmd_options['repo_dir']
-      data_dir_root = File.expand_path(File.join(cmd_options['data_dir'], '../'))
-
-      repo_dir_branch = git_helper.branch_name(repo_dir_root)
-      data_dir_branch = git_helper.branch_name(data_dir_root)
-
-      branches = {
-        'repo_dir' => repo_dir_branch,
-        'data_dir' => data_dir_branch
-      }
-
       unless skip
+        git_helper = Terragov::Git.new
+        # FIXME: this is confusing as we want to check the repository git status from
+        # the root, but the "data" directory is one level down in the repository
+        repo_dir_root = cmd_options['repo_dir']
+        data_dir_root = File.expand_path(File.join(cmd_options['data_dir'], '../'))
+
+        branches = {
+          'repo_dir' => git_helper.branch_name(repo_dir_root),
+          'data_dir' => git_helper.branch_name(data_dir_root),
+        }
+
         branches.each do |name, branch|
           unless branch =~ /^master$/
             exit unless HighLine.agree("#{name} not on 'master' branch, continue on branch '#{branch}'?")
           end
         end
-
-        unless git_helper.compare_branch(repo_dir_root, data_dir_root)
-          puts "Warning: repo_dir(#{repo_dir_branch}) and data_dir(#{data_dir_branch}) on different branches"
-          exit unless HighLine.agree('Do you wish to continue?')
-        end
       end
     end
 
-    def run_terraform_cmd(cmd, opt = nil, deployment = false)
+    def run_terraform_cmd(cmd, deployment = false)
+      # Create a hash based on method above
       paths = Terragov::BuildPaths.new.base(cmd_options)
-      varfiles = Terragov::BuildPaths.new.build_command(cmd_options)
-      backend  = paths[:backend_file]
-      project_dir = paths[:project_dir]
 
-      be_verbose = config('verbose', false, false)
-
-      do_dryrun = config('dryrun', false, false)
+      # Construct the hash to pass to the Terraform class
+      terraform_args = {
+        command: cmd,
+        vars: Terragov::BuildPaths.new.build_command(cmd_options),
+        backend: paths[:backend_file],
+        directory: paths[:project_dir],
+        test: Terragov::Config.new.lookup({name: 'test', required: false, cli: @test}),
+        verbose: Terragov::Config.new.lookup({name: 'verbose', required: false, cli: @verbose}),
+      }
 
       unless deployment
-        skip_check = config('skip_git_check', false, false)
+        skip_check = Terragov::Config.new.lookup({name: 'skip_git_check', required: false, cli: @skip_git_check})
         git_compare_repo_and_data(skip_check)
       end
 
-      puts cmd_options.to_yaml if be_verbose
+      puts cmd_options.to_yaml if terraform_args[:verbose]
 
-      cmd = "#{cmd} #{opt}" if opt
-      Terragov::Terraform.new.execute(cmd, varfiles, backend, project_dir, do_dryrun, be_verbose)
+      Terragov::Terraform.new.execute(terraform_args)
     end
 
     def run_deployment(file, group, command, force)
@@ -249,23 +156,24 @@ module Terragov
         abort("Deployment configuration must be an array of projects to run")
       end
 
-      if command == 'plan' || command == 'apply'
+      case command
+      when 'plan', 'apply'
         if force && command == 'apply'
           command = "#{command} -auto-approve"
         end
 
         deployment_config.each do |proj|
           $project = proj
-          run_terraform_cmd(command, nil, true)
+          run_terraform_cmd(command, true)
         end
-      elsif command == 'destroy'
+      when 'destroy'
         if force
           command = "#{command} -force"
         end
 
         deployment_config.reverse.each do |proj|
           $project = proj
-          run_terraform_cmd(command, nil, true)
+          run_terraform_cmd(command, true)
         end
       else
         abort("Command must be apply, plan or destroy")
@@ -327,7 +235,7 @@ module Terragov
         c.description = 'Clean your directory of any files terraform may have left lying around'
         c.option '--force', 'Force removal of files'
         c.action do |_args, options|
-          if config('verbose', false, false)
+          if Terragov::Config.new.lookup({name: 'verbose', required: false, cli: @verbose})
             puts "Selecting directory #{repo_dir}"
           end
 
@@ -336,7 +244,7 @@ module Terragov
             /terraform\.tfstate\.backup/,
           ]
 
-          path = config('repo_dir', true)
+          path = Terragov::Config.new.lookup({name: 'repo_dir', file: true})
 
           Terragov::Cleaner.new.delete(path, files_to_delete, options.force)
         end

data/lib/terragov/config.rb

@@ -0,0 +1,86 @@
+module Terragov
+  class Config
+    def project_name
+      $project || ENV['TERRAGOV_PROJECT']
+    end
+
+    def load_config_file
+      file = $config_file || ENV['TERRAGOV_CONFIG_FILE']
+      YAML.load_file(File.expand_path(file)) if file
+    end
+
+    def config_file_default
+      return nil if load_config_file['default'].nil?
+      load_config_file['default']
+    end
+
+    def config_file_specific_project(project_name)
+      load_config_file[project_name]
+    end
+
+    def config_file(option)
+      # If project name not specified in config, return default settings
+      if project_name.nil?
+        return nil if config_file_default.nil?
+        return config_file_default[option]
+      end
+
+      # If project specified, but no config found for that option return default
+      project_config = config_file_specific_project(project_name)
+      if project_config.nil? or project_config[option].nil?
+        return config_file_default[option]
+      end
+
+      # Otherwise return the value for that option
+      project_config[option]
+    end
+
+    def lookup(settings = {})
+      # Structure of hash should be:
+      #
+      # name: Name of the item to lookup
+      # cli:  Result of CLI options
+      # required: whether or not it's required (default: true)
+      # file: whether to return a file path
+
+      default = {
+        cli: false,
+        required: true,
+        file: false,
+      }
+
+      settings = default.merge(settings)
+
+      env_var = "TERRAGOV_#{settings[:name].upcase}"
+      error_message = "Must set #{settings[:name]}. Use --help for details."
+
+      # Load from CLI option
+      if settings[:cli]
+        return File.expand_path(settings[:cli]) if settings[:file]
+        return settings[:cli]
+      end
+
+      # Load from environment variable
+      if ENV[env_var]
+        return File.expand_path(ENV[env_var]) if settings[:file]
+        return ENV[env_var]
+      end
+
+      # Return error/false if config_file isn't available
+      if load_config_file.nil?
+        abort(error_message) if settings[:required]
+        return false
+      end
+
+      # Return error/false if the specific option isn't available
+      if config_file(settings[:name]).nil?
+        abort(error_message) if settings[:required]
+        return false
+      end
+
+      # Otherwise return the value from the config file
+      return File.expand_path(config_file(settings[:name])) if settings[:file]
+      config_file(settings[:name])
+    end
+  end
+end

data/lib/terragov/terraform.rb

@@ -11,41 +11,61 @@ module Terragov
       end
     end
 
-    def execute(command, vars, backend, directory, dryrun = false, verbose = false)
+    def execute(_args = {})
+      # Schema:
+      # {
+      # command: which command to run
+      # test: set to true to output commands to run, used for testing
+      # verbose: set to true for more output
+      # directory: main repository directory
+      # backend: backend file
+      # vars: data directory
+      # }
+      default = {
+        test: false,
+        verbose: false,
+      }
+
+      args = default.merge(_args)
+
       packages = %w[terraform sops]
 
-      packages.each do |pkg|
-        package_check(pkg)
+      unless args[:test]
+        packages.each do |pkg|
+          package_check(pkg)
+        end
       end
 
-      if command == 'init'
+      if args[:command] == 'init'
         puts "Running 'init' is not required as it is applied for each command"
         exit 1
       end
 
       current_dir = Dir.pwd
 
-      Dir.chdir directory
-      init(backend, dryrun, verbose)
+      Dir.chdir args[:directory] unless args[:test]
+      init(args[:backend], args[:test], args[:verbose])
 
-      if command == 'plan'
+      if args[:command] == 'plan'
         command = 'plan -detailed-exitcode'
+      else
+        command = args[:command]
       end
 
-      full_command = "bash -c 'terraform #{command} #{vars}'"
+      full_command = "bash -c 'terraform #{command} #{args[:vars]}'"
 
-      run(full_command, dryrun, verbose)
+      run(full_command, args[:test], args[:verbose])
 
-      Dir.chdir current_dir
+      Dir.chdir current_dir unless args[:test]
     end
 
-    def init(backend_file, dryrun = false, verbose = false)
+    def init(backend_file, test = false, verbose = false)
       init_cmd = "terraform init -backend-config #{backend_file}"
-      run(init_cmd, dryrun, verbose)
+      run(init_cmd, test, verbose)
     end
 
-    def run(command, dryrun = false, verbose = false)
-      if dryrun
+    def run(command, test = false, verbose = false)
+      if test
         puts command
       else
         puts command if verbose

data/lib/terragov/version.rb

@@ -1,3 +1,3 @@
 module Terragov
-  VERSION = '0.3.3'.freeze
+  VERSION = '0.4.0'.freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: terragov
 version: !ruby/object:Gem::Version
-  version: 0.3.3
+  version: 0.4.0
 platform: ruby
 authors:
 - Laura Martin
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-01-30 00:00:00.000000000 Z
+date: 2018-02-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: commander
@@ -177,6 +177,7 @@ files:
 - lib/terragov/buildpaths.rb
 - lib/terragov/cleaner.rb
 - lib/terragov/cli.rb
+- lib/terragov/config.rb
 - lib/terragov/git.rb
 - lib/terragov/terraform.rb
 - lib/terragov/version.rb