capistrano-terraform 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 233beb5261914e15999372e9e910378d04729118
+  data.tar.gz: 4402e39655b48ad886f8831f00400a3c0349d691
+SHA512:
+  metadata.gz: 65c2e03330f18da9299a8393c588c6757642ecadbedc2fee5386069f555555ee9cbbb1bdcb4ffbae2a1e51e2bb780cac77aeff8fe40bb281d58866a0d2d0e431
+  data.tar.gz: 9a8f156c5c6eab3e7220eac45e2da8d14370ec4968670e11bd8bb18f4d7c378cbde00433ae3f959c8a9f8ff71e0392d4c6ddfad2d9d86fe9eccfc553c83c7b26

data/.rubocop.yml

@@ -0,0 +1,68 @@
+AllCops:
+  TargetRubyVersion: 2.4
+
+Style/FrozenStringLiteralComment:
+  Enabled: true
+
+Style/StringLiterals:
+  EnforcedStyle: single_quotes
+  # Exclude:
+  #   - 'db/schema.rb'
+  #   - 'db/migrate/*.rb'
+
+Style/RedundantReturn:
+  Enabled: false
+Style/HashSyntax:
+  Enabled: false
+Style/UnneededPercentQ:
+  Enabled: false
+Style/GuardClause:
+  Enabled: false
+Style/IfUnlessModifier:
+  Enabled: false
+Style/UnlessElse:
+  Enabled: false
+Style/SymbolArray:
+  Enabled: false
+Style/Documentation:
+  Enabled: false
+Style/ConditionalAssignment:
+  Enabled: false
+Style/ClassVars:
+  Enabled: false
+Style/TrailingCommaInHashLiteral:
+  EnforcedStyleForMultiline: consistent_comma
+Style/TrailingCommaInArrayLiteral:
+  EnforcedStyleForMultiline: comma
+Style/ExpandPathArguments:
+  Enabled: false
+
+Layout/EmptyLinesAroundBlockBody:
+  Enabled: false
+Layout/SpaceBeforeBlockBraces:
+  Enabled: false
+Layout/SpaceInsideBlockBraces:
+  Enabled: false
+Layout/EmptyLinesAroundModuleBody:
+  Enabled: false
+Layout/EmptyLinesAroundClassBody:
+  Enabled: false
+Layout/EmptyLines:
+  Enabled: false
+
+Metrics/PerceivedComplexity:
+  Enabled: false
+Metrics/CyclomaticComplexity:
+  Enabled: false
+Metrics/BlockLength:
+  Enabled: false
+Metrics/AbcSize:
+  Enabled: false
+Metrics/LineLength:
+  Enabled: false
+  Max: 160
+Metrics/MethodLength:
+  Enabled: false
+
+Bundler/OrderedGems:
+  Enabled: false

data/CHANGELOG.md

@@ -0,0 +1,20 @@
+# capistrano-terraform 1.x Changelog
+
+All notable changes to this project will be documented in this file, in reverse chronological order.
+
+**capistrano-terraform strives to follow [SemVer](http://semver.org)**, similar to the Ruby on Rails project. For a `X.Y.Z` release:
+
+* `Z` indicates bug fixes only; no breaking changes and no new features, except as necessary for security fixes.
+* `Y` is bumped when we add new features. Occasionally a `Y` release may include small breaking changes. We will notify via CHANGELOG entries and/or deprecation notices if there are breaking changes.
+* `X` is incremented for significant breaking changes. This is reserved for special occasions, like a complete rewrite.
+
+**capistrano-terraform has no current release cadence. That stuff is for adults!** At the moment, this project is a one-man-show. I release stuff when I damn well please, when it pleases me the most. If you don't like that, speak up and become a contributor. If you do that, we can change this line in this file to something less antagonistic.
+
+### I'm not dedicating any real time here just yet
+Until this project becomes more meaningfully maintained, the following update notes will be updated as deemed fit and/or by chance of my mind recognizing documentation significance. If you include this code in your project, your crap may break whenever I happenstantially push things that also makes my own crap break. I'll probably be working to fix it soon'ish, but also maybe I'll spend the weekend eating tacos and sleeping instead. The risk is all yours.
+
+
+# Update notes
+
+## [`1.0.0`] (2018-07-16)
+First public release.

data/Gemfile

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in capistrano-docker-build.gemspec
+gemspec
+
+# gem 'byebug'
+gem 'rspec'
+gem 'rspec-core'
+gem 'pry'

data/Gemfile.lock

@@ -0,0 +1,59 @@
+PATH
+  remote: .
+  specs:
+    capistrano-terraform (0.1.0)
+      capistrano (>= 3.11)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    airbrussh (1.3.0)
+      sshkit (>= 1.6.1, != 1.7.0)
+    capistrano (3.11.0)
+      airbrussh (>= 1.0.0)
+      i18n
+      rake (>= 10.0.0)
+      sshkit (>= 1.9.0)
+    coderay (1.1.2)
+    concurrent-ruby (1.0.5)
+    diff-lcs (1.3)
+    i18n (1.0.1)
+      concurrent-ruby (~> 1.0)
+    method_source (0.9.0)
+    net-scp (1.2.1)
+      net-ssh (>= 2.6.5)
+    net-ssh (5.0.2)
+    pry (0.11.3)
+      coderay (~> 1.1.0)
+      method_source (~> 0.9.0)
+    rake (12.0.0)
+    rspec (3.7.0)
+      rspec-core (~> 3.7.0)
+      rspec-expectations (~> 3.7.0)
+      rspec-mocks (~> 3.7.0)
+    rspec-core (3.7.1)
+      rspec-support (~> 3.7.0)
+    rspec-expectations (3.7.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.7.0)
+    rspec-mocks (3.7.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.7.0)
+    rspec-support (3.7.1)
+    sshkit (1.16.1)
+      net-scp (>= 1.1.2)
+      net-ssh (>= 2.8.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.14)
+  capistrano-terraform!
+  pry
+  rake (~> 12.0)
+  rspec
+  rspec-core
+
+BUNDLED WITH
+   1.14.5

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2018 Eric Shorkey
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,179 @@
+# capistrano-terraform
+
+Run Terraform tasks as part of your Capistrano v3 deployments; or just plain use Capistrano v3 to run your Terraform, even if you don't deploy your code with Capistrano.
+
+```sh
+cap production terraform:deploy # run all registered terraform deployment tasks
+```
+
+This plugin also hooks into the default `cap <environment> deploy` flow as a build action. See [Usage](#usage) for more details.
+
+Hence this also works:
+```sh
+cap production deploy # run all app deployment tasks, and terraform is going to run in there somewhere based on your configs
+```
+
+
+----
+
+## Installation
+
+Add these lines to your application's Gemfile:
+
+```ruby
+gem 'capistrano', '~> 3.11' # capistrano at least version 3.11
+gem 'capistrano-terraform', '~> 1.0' # the meaty bits of this plugin - 1.X to ensure you always have the best available
+```
+
+And then execute:
+
+```sh
+$ bundle
+```
+
+Or install it yourself as:
+
+```sh
+$ gem install capistrano-terraform
+```
+
+----
+
+## Usage
+
+### Configure your project
+
+#### Require in Capfile:
+```ruby
+require 'capistrano/terraform'
+```
+
+#### Optionally define a Terraform host in deploy.rb or the appropriate deploy/stage.rb:
+```ruby
+role :terraform,  %w{localhost} # role syntax, this one making localhost the terraform agent
+# --  or... --
+server 'my.build.server', roles: %w{terraform} # server syntax, declaring a remote server
+```
+
+If no `:terraform` host/role is defined, all Terraform actions will be ran directly from the host currently running `cap` according to the contents of the current working project directory (some use-cases make this desirable, for example some automated CI/CD pipelines work better this way). A maximum of one `:terraform` host can be defined.
+
+> **Note**: Setting the `:terraform` host/role to `localhost` is *not* the same as leaving it undefined (or set to nil). If the `:terraform` role is defined, the full code checkout process is expected to take place prior to terraform actions.
+
+> _Note: There is currently no embedded mechanism to ensure the declared terraform host/role (or the localhost if none defined) has the necessary permissions to perform the desired terraform actions against the IAAS service provider. It's entirely up to you to preemptively set up any necessary AWS keys, SSH keys, environment variables, etc, to enable the worker to perform the desired terraform actions. For AWS, I've found it easiest to simply set up the aws-cli environment variables/tokens on the host prior to running `cap`. Discussions/proposals around this are welcome as github issues._
+
+#### Optionally define the Terraform root directory:
+```ruby
+set :terraform_root, "infra"
+```
+This is the sub-directory from which all `capistrano/terraform` related files/references will be evaluated from. If left undefined, it will be assumed to be the project root directory (ie: where `Capfile` is defined)
+
+#### Declare global Terraform variables, variable files, etc
+
+```ruby
+append :terraform_var_file, 'common.tfvars'
+```
+
+#### Declare your Terraform project directories and their specific configurations:
+The minimum terraform step definition includes a name. The path (relative to `:terraform_root`) is actually optional. For example:
+```ruby
+terraform :my_terraform_action, path: 'directory/path'
+```
+
+If no `:path` option is provided, the `:terraform_root` is the assumed directory.
+
+No checking is performed to ensure that declared terraform project directories are unique by path, only the first parameter for the `terraform` DSL method (ie, the name) is used to determine uniqueness.
+
+All future references to the same terraform action (by name) are additive. This allows you to declare basic Terraform options within the `deploy.rb` config file, and then add/replace options specific to a particular deployment stage within that stage specific `deploy/stagename.rb` config file.
+
+This plugin automatically hooks the normal [Capistrano deploy flow](https://capistranorb.com/documentation/getting-started/flow/) around the _publish_ stage. The default timing is to run terraforms _before_ `deploy:publishing`. However, through a configuration option, terraforms can be selectively performed _after_ `deploy:published` instead.
+
+To select the after publish timing, simply add the `after_publish: true` option setting to individual `terraform` declaration:
+```ruby
+terraform :my_terraform_action, path: 'directory/path', after_publish: true
+```
+
+To opt-out of the deploy flow for all of `capistrano/terraform`, add this line to your `config/deploy.rb` or to a specific `config/deploy/<stage>.rb` file:
+```ruby
+set :terraform_deploy, false
+```
+
+To opt-out of the deploy flow for an individual terraform declaration, simply add `deploy: false` to the declaration options:
+```ruby
+terraform :my_terraform, path: 'directory/path', deploy: false
+```
+Individually excluding a terraform from deploys via `deploy: false` also removes it from the `cap <stage> terraform:deploy` flow.
+
+Any terraform actions/project-directories that are excluded from the deploy flow are still available to run individually via `cap terraform:my_terraform:deploy` (or their related tasks).
+
+
+### Run a deploy:
+
+For a normal full deploy:
+```ruby
+cap <stage> deploy # the default hooks will run terraform actions at the appropriate times
+```
+
+For independent terraform runs:
+```ruby
+cap <stage> terraform:deploy # runs both the before and after publish tasks, hooks in that order, without attempting to publishing code -- if you're running this within a CI pipeline (like Circle or CodeShip) this is probably what you want for simple terraform-first style projects
+```
+
+#### Getting a little more granular...
+
+You should also notice there are a number of granular cap tasks automatically defined around your terraform projects/directories, allowing you to run only what you want, when you want.
+
+> Beware: All granular `cap <stage> terraform:X` tasks will still honor the `:terraform` server role, if one is defined. Something to be aware of...
+
+For example, to selectively run before and after publish deploy stages (without involving the code/app deploy bits):
+- `cap <stage> terraform:deploy_before`
+- `cap <stage> terraform:deploy_after`
+
+Additionally, every `terraform` declaration within the cap deploy configs generates a number of individually addressable cap tasks that can be ran independently:
+- `cap <stage> terraform:<name>:init` # just terraform init
+- `cap <stage> terraform:<name>:plan` # just terraform plan
+- `cap <stage> terraform:<name>:apply` # just terraform apply
+- `cap <stage> terraform:<name>:deploy` # terraform init -> plan -> apply
+- ???
+- `cap <stage> terraform:<name>:destroy` # just terraform apply
+- `cap <stage> terraform:<name>:clean`   # delete any left over plan files and cleans up the .terraform temporary directory
+
+
+To view all the cap tasks (and their descriptions) that are readily runnable for your project, based on the current config files, run `cap -T` to generate the full list.
+
+
+
+### Configurable options:
+
+Global
+
+terraform DSL method
+
+
+
+
+
+
+
+
+
+
+## Why?
+
+Because.
+
+One day I literally put "`capistrano terraform`" into Google and surprisingly didn't find any projects that already directly addressed running Terraform from Capistrano. So here we are.
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/eshork/capistrano-terraform
+
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/capistrano-terraform.gemspec

@@ -0,0 +1,41 @@
+# coding: utf-8
+# frozen_string_literal: true
+
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+Gem::Specification.new do |spec|
+  spec.name          = 'capistrano-terraform'
+  spec.version       = '0.1.0'
+  spec.authors       = ['Eric Shorkey']
+  spec.email         = ['eric.shorkey@gmail.com']
+  spec.summary       = 'Terraform plugin for Capistrano'
+  spec.description   = 'Run Terraform tasks as part of your Capistrano v3 deployments,' \
+                       ' or just simply use Capistrano to manage your Terraform.' \
+                       ' Multi-stage -- run your Terraform from a pre or post release hook (or a little of both).' \
+                       ' Runs directly from localhost or a remote build/deploy host.'
+  spec.homepage      = 'https://github.com/eshork/capistrano-terraform'
+  spec.license       = 'MIT'
+
+  # Prevent pushing this gem to RubyGems.org. To allow pushes either set the 'allowed_push_host'
+  # to allow pushing to a single host or delete this section to allow pushing to any host.
+  # if spec.respond_to?(:metadata)
+  #   spec.metadata['allowed_push_host'] = "TODO: Set to 'http://mygemserver.com'"
+  # else
+  #   raise 'RubyGems 2.0 or newer is required to protect against public gem pushes.'
+  # end
+
+  # spec.files = `git ls-files -z`.split("\x0").reject do |f|
+  #   f.match(%r{^(test|spec|features)/})
+  # end
+
+  spec.files = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+
+  spec.add_dependency 'capistrano', '>= 3.11'
+
+  spec.add_development_dependency 'bundler', '~> 1.14'
+  spec.add_development_dependency 'rake', '~> 12.0'
+  # spec.add_development_dependency 'rspec', '~> 3.0'
+end

data/lib/capistrano-terraform.rb

@@ -0,0 +1 @@
+# an empty .rb file for bundler to auto-require

data/lib/capistrano/tasks/terraform.rake

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+set :terraform_plan_opts, ['-input=false']
+set :terraform_init_opts, ['-input=false']
+set :terraform_apply_opts, nil
+
+namespace :terraform do
+  desc 'initialize all terraform directories'
+  task :init do
+    ::Capistrano::Terraforms.all.each_pair do |terraform_id, terraform_obj|
+      invoke "terraform:#{terraform_id}:init" if terraform_obj.deploy?
+    end
+  end
+
+  desc 'plan all terraform directories'
+  task :plan do
+    ::Capistrano::Terraforms.all.each_pair do |terraform_id, terraform_obj|
+      invoke "terraform:#{terraform_id}:plan" if terraform_obj.deploy?
+    end
+  end
+
+  desc 'apply all planned terraform directories'
+  task :apply do
+    ::Capistrano::Terraforms.all.each_pair do |terraform_id, terraform_obj|
+      invoke "terraform:#{terraform_id}:apply" if terraform_obj.deploy?
+    end
+  end
+
+  desc 'clean all terraform directories'
+  task :clean do
+    ::Capistrano::Terraforms.all.each_pair do |terraform_id, terraform_obj|
+      invoke "terraform:#{terraform_id}:clean" if terraform_obj.deploy?
+    end
+  end
+
+  # desc 'clear all terraform initializations'
+  # task :distclean
+
+  # desc 'list all terraform directories'
+  # task :list
+
+end

data/lib/capistrano/tasks/terraform_doctor.rake

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+# Add ourself to the standard 'cap <stage> doctor' invocation
+task doctor: 'doctor:terraform'
+
+# alias common misusage
+task 'terraform:doctor' => 'doctor:terraform'
+
+namespace :doctor do
+  desc 'Display the effective terraform configuration'
+  task :terraform do
+    Capistrano::Doctor::TerraformDoctor.new.call
+  end
+end

data/lib/capistrano/tasks/terraform_hooks.rake

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+# add the build->push process onto the end of the deploy:published stack
+# after 'deploy:published', 'docker:capdeploy_hook'
+
+# push the no_release auto-cull to the very front of the task stack
+# before 'deploy:starting', 'docker:trim_release_roles'

data/lib/capistrano/terraform.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+# include some special sauce
+require_relative 'terraform/terraforms.rb'
+require_relative 'terraform/terraform.rb'
+
+# include our DSL updates
+require_relative 'terraform/dsl.rb'
+
+# include standard tasks and cap flow hooks
+require_relative 'terraform/tasks'
+require_relative 'terraform/hooks'
+require_relative 'terraform/doctor'

data/lib/capistrano/terraform/doctor.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+require_relative 'doctor/terraform_doctor'
+
+load File.expand_path('../../tasks/terraform_doctor.rake', __FILE__)

data/lib/capistrano/terraform/doctor/terraform_doctor.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require 'capistrano/doctor/output_helpers'
+
+module Capistrano
+  module Doctor
+    class TerraformDoctor
+      include Capistrano::Doctor::OutputHelpers
+
+      def call
+        title('Terraform Globals')
+        tf_globals = [
+          { var: :terraform_root, resolver: ->{ ::Capistrano::Terraforms.root } },
+          { var: :terraform_deploy, resolver: ->{ ::Capistrano::Terraforms.deploy } },
+          { var: :terraform_var, resolver: ->{ ::Capistrano::Terraforms.vars } },
+          { var: :terraform_var_file, resolver: ->{ ::Capistrano::Terraforms.var_files } },
+          { var: :terraform_target, resolver: ->{ ::Capistrano::Terraforms.targets } },
+        ]
+
+        table(tf_globals) do |tf_global, row|
+          vname = tf_global[:var]
+          vvalue = nil
+          if tf_global[:resolver]
+            vvalue = tf_global[:resolver].call
+          end
+
+          row << ":#{vname}"
+          row << 'nil' if vvalue.nil?
+          if vvalue.is_a?(String)
+            row << "\"#{vvalue}\""
+          else
+            row << vvalue
+          end
+        end
+        puts
+
+        all_terrforms = ::Capistrano::Terraforms.all
+        title("Terraform Paths/Projects (#{all_terrforms.size})")
+        table(all_terrforms) do |terraform, row|
+          row << terraform[0].to_s
+          row << terraform[1].to_s
+        end
+        puts
+      end
+
+    end
+  end
+end

data/lib/capistrano/terraform/dsl.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+# Augments the standard Capistrano DSL with terraform specific methods
+
+module Capistrano
+  module DSL
+    module Env
+      def terraform(terraform_id, params = {})
+        _terraform_upsert(terraform_id, params)
+      end
+
+      private
+
+      def _terraform_upsert(terraform_id, params)
+        return ::Capistrano::Terraforms.upsert(terraform_id, params)
+      end
+
+    end
+  end
+end

data/lib/capistrano/terraform/hooks.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+load File.expand_path('../../tasks/terraform_hooks.rake', __FILE__)

data/lib/capistrano/terraform/tasks.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+load File.expand_path('../../tasks/terraform.rake', __FILE__)

data/lib/capistrano/terraform/terraform.rb

@@ -0,0 +1,277 @@
+# frozen_string_literal: true
+
+module Capistrano
+  class Terraform
+
+    def initialize(params = {})
+      @path = nil
+      @var = nil
+      @var_file = nil
+      @target = nil
+      @after_publish = nil
+      @deploy = nil
+      @backend_config = nil
+      update(params)
+    end
+
+    def update(params = {})
+      # handle path updates
+      @path = params[:path] if params.key?(:path)
+
+      # handle var_file upserts
+      if params.key?(:var_file)
+        @var_file ||= []
+        @var_file.push(params[:var_file])
+        @var_file.flatten!
+      end
+      @var_file = nil if @var_file == []
+
+      # handle var upserts
+      if params.key?(:var)
+        @var ||= []
+        @var.push(params[:var])
+        @var&.flatten!&.uniq!
+      end
+      @var = nil if @var == []
+
+      # handle target upserts
+      if params.key?(:target)
+        @target ||= []
+        @target.push(params[:target])
+        @target&.flatten!&.uniq!
+      end
+      @target = nil if @target == []
+
+      # handle after_publish upserts
+      if params.key?(:after_publish)
+        @after_publish = params[:after_publish]
+      end
+      @after_publish = nil unless @after_publish == true
+
+      # handle deploy upserts
+      if params.key?(:deploy)
+        @deploy = params[:deploy]
+      end
+      @deploy = nil unless @deploy == false
+
+      # handle backend_config upserts
+      if params.key?(:backend_config)
+        @backend_config ||= []
+        @backend_config.push(params[:backend_config])
+        @backend_config&.flatten!&.uniq!
+      end
+      @backend_config = nil if @backend_config == []
+    end
+
+    def to_hash
+      return {
+        path: @path,
+        var: @var,
+        var_file: @var_file,
+        target: @target,
+        backend_config: @backend_config,
+        after_publish: @after_publish,
+        deploy: @deploy,
+      }.compact
+    end
+
+    def to_s
+      return to_hash
+    end
+
+    def deploy?
+      return @deploy != false
+    end
+
+    def targets
+      targets_ary = []
+      Terraforms.targets.each do |t|
+        targets_ary << t
+      end
+      @target&.each do |t|
+        targets_ary << t
+      end
+      return targets_ary.uniq
+    end
+
+    def plan_outfile
+      # fetch :terraform_plan_outfile, 'tf.plan'
+      'tf.plan'
+    end
+
+    def run_path
+      return Terraforms.root_path.join(@path) if @path
+      return Terraforms.root_path
+    end
+
+    def init_cmd_line
+      cmd_ary = [Terraforms.terraform_cmd, :init]
+      cmd_ary << fetch(:terraform_init_opts, [])
+      cmd_ary << '-reconfigure' # always reconfigure to preserve states across stages
+
+      root_relative = Terraforms.root_path.relative_path_from(run_path)
+      fetch(:terraform_backend_config, []).uniq.each do |bec|
+        if bec.include?('=')
+          cmd_ary << "-backend-config='#{bec}'"
+        else
+          cmd_ary << "-backend-config='#{root_relative.join(bec)}'"
+        end
+      end
+
+      @backend_config&.each do |bec|
+        cmd_ary << "-backend-config='#{bec}'"
+      end
+
+      return cmd_ary.flatten
+    end
+
+    def plan_cmd_line
+      cmd_ary = [Terraforms.terraform_cmd, :plan]
+      cmd_ary << fetch(:terraform_plan_opts, [])
+      cmd_ary << "-out='#{plan_outfile}'"
+
+      root_relative = Terraforms.root_path.relative_path_from(run_path)
+
+      fetch(:terraform_var_file, []).uniq.each do |tf_var_file|
+        cmd_ary << "-var-file='#{root_relative.join(tf_var_file)}'"
+      end
+
+      fetch(:terraform_var, []).uniq.each do |tf_var|
+        cmd_ary << "-var='#{tf_var}'"
+      end
+
+      @var_file&.each do |var_file|
+        cmd_ary << "-var-file='#{var_file}'"
+      end
+
+      @var&.each do |var|
+        cmd_ary << "-var='#{var}'"
+      end
+
+      targets.each do |target|
+        cmd_ary << "-target='#{target}'"
+      end
+
+      return cmd_ary.flatten
+    end
+
+    def apply_cmd_line
+      cmd_ary = [Terraforms.terraform_cmd, :apply]
+      cmd_ary << fetch(:terraform_apply_opts, [])
+      cmd_ary << "'#{plan_outfile}'"
+      return cmd_ary.flatten
+    end
+
+    def create_tasks(terraform_id)
+      create_init_task(terraform_id)
+      create_plan_task(terraform_id)
+      create_clean_task(terraform_id)
+      create_apply_task(terraform_id)
+    end
+
+    def create_init_task(terraform_id)
+      task = Rake::Task.define_task "terraform:#{terraform_id}:init" do
+        terraform_obj = Terraforms.find(terraform_id)
+        terraform_cmd = terraform_obj.init_cmd_line
+
+        if roles(:terraform).first
+          on roles(:terraform).first do |_terraform_remote|
+            info "Running terraform:#{terraform_id}:init..."
+            within terraform_obj.run_path do
+              execute :pwd
+              raise 'nyi'
+            end
+          end
+        else
+          run_locally do
+            info "Running terraform:#{terraform_id}:init..."
+            within terraform_obj.run_path do
+              execute :pwd
+              execute(*terraform_cmd)
+            end
+          end
+        end
+      end
+      task.comment = "initialize specific terraform: #{terraform_id}"
+    end
+
+    def create_plan_task(terraform_id)
+      task = Rake::Task.define_task "terraform:#{terraform_id}:plan" do
+        terraform_obj = Terraforms.find(terraform_id)
+        terraform_cmd = terraform_obj.plan_cmd_line
+
+        if roles(:terraform).first
+          on roles(:terraform).first do |_terraform_remote|
+            info "Running terraform:#{terraform_id}:plan..."
+            within terraform_obj.run_path do
+              execute :pwd
+              execute(*terraform_cmd)
+            end
+          end
+        else
+          run_locally do
+            info "Running terraform:#{terraform_id}:plan..."
+            within terraform_obj.run_path do
+              execute :pwd
+              execute(*terraform_cmd)
+            end
+          end
+        end
+      end
+      task.comment = "plan specific terraform: #{terraform_id}"
+    end
+
+    def create_apply_task(terraform_id)
+      task = Rake::Task.define_task "terraform:#{terraform_id}:apply" do
+        terraform_obj = Terraforms.find(terraform_id)
+        terraform_cmd = terraform_obj.apply_cmd_line
+
+        if roles(:terraform).first
+          on roles(:terraform).first do |_terraform_remote|
+            info "Running terraform:#{terraform_id}:apply..."
+            within terraform_obj.run_path do
+              execute :pwd
+              execute(*terraform_cmd)
+            end
+          end
+        else
+          run_locally do
+            info "Running terraform:#{terraform_id}:apply..."
+            within terraform_obj.run_path do
+              execute :pwd
+              execute(*terraform_cmd)
+            end
+          end
+        end
+      end
+      task.comment = "apply specific terraform: #{terraform_id}"
+    end
+
+    def create_clean_task(terraform_id)
+      task = Rake::Task.define_task "terraform:#{terraform_id}:clean" do
+        terraform_obj = Terraforms.find(terraform_id)
+        terraform_cmd = [:rm, '-rf', '.terraform', plan_outfile]
+
+        if roles(:terraform).first
+          on roles(:terraform).first do |_terraform_remote|
+            info "Cleaning terraform:#{terraform_id}..."
+            within terraform_obj.run_path do
+              execute :pwd
+              execute(*terraform_cmd)
+            end
+          end
+        else
+          run_locally do
+            info "Cleaning terraform:#{terraform_id}:plan..."
+            within terraform_obj.run_path do
+              execute :pwd
+              execute(*terraform_cmd)
+            end
+          end
+        end
+      end
+      task.comment = "clean specific terraform: #{terraform_id}"
+    end
+
+  end
+end

data/lib/capistrano/terraform/terraforms.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require_relative 'terraform.rb'
+
+module Capistrano
+  class Terraforms
+
+    def self.terraform_cmd
+      fetch(:terraform_cmd, :terraform)
+    end
+
+    def self.root
+      fetch :terraform_root, nil
+    end
+
+    def self.vars
+      fetch :terraform_var, []
+    end
+
+    def self.var_files
+      fetch(:terraform_var_file, []).uniq
+    end
+
+    def self.targets
+      [fetch(:terraform_target, [])].flatten.uniq
+    end
+
+    def self.deploy
+      fetch :terraform_deploy, true
+    end
+
+    def self.root_path
+      if roles(:terraform).first
+        return deploy_path.join(fetch(:current_directory, 'current')).join(fetch(:terraform_root, '.'))
+      else
+        return Pathname.new(fetch(:terraform_root, '.'))
+      end
+
+      # return deploy_path.join(fetch(:current_directory, 'current')) if build_dir.nil?
+      # return Pathname.new(build_dir.strip) if build_dir.strip[0] == '/'
+      # return deploy_path.join(fetch(:current_directory, 'current'), build_dir)
+    end
+
+    def self.upsert(terraform_id, params = {})
+      @@terraforms ||= {} # auto-init class variable on usage
+      terraform_id = terraform_id.to_sym
+      if @@terraforms.key?(terraform_id)
+        @@terraforms[terraform_id].update(params)
+      else
+        @@terraforms[terraform_id] = ::Capistrano::Terraform.new(params)
+        @@terraforms[terraform_id].create_tasks(terraform_id)
+      end
+    end
+
+    def self.all
+      @@terraforms ||= {} # auto-init class variable on usage
+      return @@terraforms
+    end
+
+    def self.find(terraform_id)
+      return all[terraform_id]
+    end
+
+  end
+end

metadata

@@ -0,0 +1,110 @@
+--- !ruby/object:Gem::Specification
+name: capistrano-terraform
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Eric Shorkey
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2018-08-15 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: capistrano
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.11'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.11'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.14'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.14'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '12.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '12.0'
+description: Run Terraform tasks as part of your Capistrano v3 deployments, or just
+  simply use Capistrano to manage your Terraform. Multi-stage -- run your Terraform
+  from a pre or post release hook (or a little of both). Runs directly from localhost
+  or a remote build/deploy host.
+email:
+- eric.shorkey@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".rspec_status"
+- ".rubocop.yml"
+- CHANGELOG.md
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.md
+- Rakefile
+- capistrano-terraform.gemspec
+- lib/capistrano-terraform.rb
+- lib/capistrano/tasks/terraform.rake
+- lib/capistrano/tasks/terraform_doctor.rake
+- lib/capistrano/tasks/terraform_hooks.rake
+- lib/capistrano/terraform.rb
+- lib/capistrano/terraform/doctor.rb
+- lib/capistrano/terraform/doctor/terraform_doctor.rb
+- lib/capistrano/terraform/dsl.rb
+- lib/capistrano/terraform/hooks.rb
+- lib/capistrano/terraform/tasks.rb
+- lib/capistrano/terraform/terraform.rb
+- lib/capistrano/terraform/terraforms.rb
+homepage: https://github.com/eshork/capistrano-terraform
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.8
+signing_key: 
+specification_version: 4
+summary: Terraform plugin for Capistrano
+test_files: []