dh-proteus 0.1.3

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "proteus"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/proteus

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+
+require 'proteus'
+
+Proteus::App.start(ARGV)

data/bin/proteus_testing

@@ -0,0 +1,8 @@
+#!/usr/bin/env ruby
+
+$LOAD_PATH.unshift File.join(File.dirname(__FILE__), '..', 'lib')
+
+require 'pry'
+require 'proteus'
+
+Proteus::App.start(ARGV)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/build.sh

@@ -0,0 +1,28 @@
+#!/bin/bash
+
+set -eo pipefail
+
+AWS_PROFILE=logistics-production
+BUCKET=production-eu-gems
+NEXUS_REPOSITORY=https://nexus.usehurrier.com/repository/proteus/
+VERSION=$(ruby lib/proteus/version.rb)
+
+
+if ! gem list --local | grep nexus; then
+  echo Please install the nexus gem in order to push to the gem repository: \"gem install nexus\"
+  exit 1
+fi
+
+echo Building version $VERSION
+
+mkdir -p ./release/gems
+
+rake build
+
+cp ./pkg/*.gem ./release/gems/
+
+gem generate_index --directory ./release/
+
+aws --profile $AWS_PROFILE s3 sync ./release s3://$BUCKET
+
+gem nexus release/gems/dh-proteus-$VERSION.gem --url $NEXUS_REPOSITORY

data/dh-proteus.gemspec

@@ -0,0 +1,50 @@
+
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "proteus/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "dh-proteus"
+  spec.version       = Proteus::VERSION
+  spec.authors       = ["Simon Albrecht"]
+  spec.email         = ["simon.albrecht@deliveryhero.com"]
+
+  spec.summary       = %q{Proteus is a Terraform wrapper application.}
+  #spec.description   = %q{Write a longer description or delete this line.}
+  spec.homepage      = "https://github.com/deliveryhero/proteus"
+
+  # 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"] = "https://rubygems.org"
+
+    spec.metadata["homepage_uri"] = spec.homepage
+    spec.metadata["source_code_uri"] = "https://github.com/deliveryhero/proteus"
+    spec.metadata["changelog_uri"] = "https://github.com/deliveryhero/proteus/CHANGELOG"
+  else
+    raise "RubyGems 2.0 or newer is required to protect against " \
+      "public gem pushes."
+  end
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  spec.bindir        = "bin"
+  spec.executables   = ['proteus']
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 2.0"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.0"
+  spec.add_development_dependency "pry"
+
+  spec.add_runtime_dependency 'activesupport', '~> 5.1.1'
+  spec.add_runtime_dependency 'thor', '~> 0.20.0'
+  spec.add_runtime_dependency 'erubis', '~> 2.7.0'
+  spec.add_runtime_dependency 'hcl-checker', '~> 1.0.5'
+  spec.add_runtime_dependency 'aws-sdk-rds', '~> 1.11.0'
+  spec.add_runtime_dependency 'aws-sdk-route53', '~> 1.7.0'
+  spec.add_runtime_dependency 'aws-sdk-elasticsearchservice', '~> 1.4.0'
+end

data/lib/core_ext/hash.rb

@@ -0,0 +1,14 @@
+class ::Hash
+  def deep_merge(second)
+    merger = proc do |_, v1, v2|
+      if v1.is_a?(Hash) && v2.is_a?(Hash)
+        v1.merge(v2, &merger)
+      elsif v1.is_a?(Array) && v2.is_a?(Array)
+        v1 | v2
+      else
+        [:undefined, nil, :nil].include?(v2) ? v1 : v2
+      end
+    end
+    merge(second.to_h, &merger)
+  end
+end

data/lib/proteus.rb

@@ -0,0 +1,9 @@
+require "proteus/version"
+require 'erubis'
+require 'thor'
+require 'active_support/core_ext/hash'
+require 'core_ext/hash'
+require 'proteus/validators/base_validator'
+require 'proteus/helpers'
+require 'proteus/config/config'
+require 'proteus/app'

data/lib/proteus/app.rb

@@ -0,0 +1,86 @@
+require 'proteus/common'
+require 'proteus/generate'
+require 'proteus/init'
+require 'proteus/global_commands/validate'
+require 'proteus/context_management/context'
+require 'proteus/context_management/helpers'
+require 'proteus/templates/template_binding'
+require 'proteus/templates/partial'
+
+module Proteus
+
+  class Context < Thor; end
+
+  class App < Thor
+    extend Proteus::Helpers
+    extend Proteus::Helpers::StringHelpers
+    extend Proteus::ContextManagement::Helpers
+
+    class_option :dryrun, type: :boolean, default: false, aliases: '-d'
+    class_option :verbose, type: :boolean, default: false, aliases: '-v'
+
+    contexts.each do |context|
+
+      if context.name != 'default'
+
+        # generate class for subcommand within contexts subcommand
+        context_subcommand_class = Class.new(Thor)
+        context_subcommand_class_name = camel_case(context.name)
+        Object.const_set(context_subcommand_class_name, context_subcommand_class)
+
+        Proteus::Context.class_eval do
+          desc "#{context.name} SUBCOMMAND", "Manage the #{context.name} context."
+          subcommand(context.name, const_get(context_subcommand_class_name))
+        end
+      end
+
+      mod_name = Object.const_set("Module#{camel_case(context.name)}", Module.new)
+
+      context.environments.each do |environment|
+        class_name = camel_case(environment)
+
+        klass = Class.new(Proteus::Common)
+
+        mod_name.const_set(class_name, klass)
+
+        klass.class_eval do
+          include Config
+          @context = context.name
+          @environment = environment
+
+          def self.context
+            @context
+          end
+
+          def self.environment
+            @environment
+          end
+        end
+
+        if context.name == 'default'
+          # attach subcommands for the standard environments directly
+          # eg.:
+          # ./proteus production_eu SUBCOMMAND
+          desc "#{environment} SUBCOMMAND", "Manage the #{environment} environment in context default"
+          subcommand(environment, mod_name.const_get(class_name))
+        else
+          const_get(context_subcommand_class_name).class_eval do
+            desc "#{environment} SUBCOMMAND", "Manage the #{environment} environment in context #{context.name}"
+            subcommand(environment, mod_name.const_get(class_name))
+          end
+        end
+      end
+    end
+
+    desc 'generate SUBCOMMAND', 'Generators for modules and environments'
+    subcommand('generate', Proteus::Generate)
+
+    desc 'context SUBCOMMAND', 'Context subcommands'
+    subcommand('context', Context)
+
+    desc 'init', 'Initializes a new proteus root directory in the current working directory'
+    subcommand('init', Proteus::Init)
+
+    include Proteus::GlobalCommands::Validate
+  end
+end

data/lib/proteus/backend/backend.rb

@@ -0,0 +1,41 @@
+require 'proteus/helpers/path_helpers'
+
+module Proteus
+  module Backend
+    class Backend
+      include Proteus::Helpers::PathHelpers
+      include Thor::Shell
+
+      def initialize(config:, context:, environment:)
+        @config = config
+        @context = context
+        @environment = environment
+      end
+
+      def render
+        File.open(File.join(context_path(@context), 'backend.tf'), 'w') do |file|
+          file.write(Erubis::Eruby.new(template).result(binding))
+        end
+      rescue StandardError => e
+        say 'Error rendering backend config.', :magenta
+        say e.message, :magenta
+        exit 1
+      end
+
+      protected
+
+      def template
+        <<~TEMPLATE
+          terraform {
+            backend "s3" {
+              bucket  = "<%= @config[:backend][:bucket][:name] %>"
+              key     = "<%= @config[:backend][:key_prefix] %>#{@context}-#{@environment}.tfstate"
+              region  = "<%= @config[:backend][:bucket][:region] %>"
+              profile = "<%= @config[:backend][:bucket][:profile]%>"
+            }
+          }
+        TEMPLATE
+      end
+    end
+  end
+end

data/lib/proteus/commands/apply.rb

@@ -0,0 +1,53 @@
+module Proteus
+  module Commands
+    module Apply
+      def self.included(thor_class)
+        thor_class.class_eval do
+
+          desc 'apply', 'Applies the current terraform code'
+          long_desc <<-LONGDESC
+            Applies the current terraform code
+
+            With --limit option, Terraform will only apply changes for the the specified resources
+          LONGDESC
+          option :limit, type: :array, aliases: "-l", required: false, default: nil
+          def apply
+            init(verbose: parent_options[:verbose])
+
+            confirm question: "Do you really want to run 'terraform apply' on environment '#{environment}' in context '#{context}'?", color: :on_red, exit_code: 0 do
+
+
+              if !options[:dryrun]
+                slack_notification(
+                    context:  context,
+                    environment: environment,
+                    message: 'is running terraform apply. Wait for it.'
+                  )
+              end
+
+              apply_command = <<~APPLY_COMMAND
+                cd #{context_path(context)} && \
+                terraform apply \
+                -input=true \
+                -refresh=true \
+                #{limit(options[:limit])} \
+                #{plan_file(context, environment)}
+              APPLY_COMMAND
+
+              syscall apply_command.squeeze(' '), dryrun: dryrun
+
+              if !options[:dryrun]
+                slack_notification(
+                    context: context,
+                    environment: environment,
+                    message: 'applied a new version of me!'
+                  )
+              end
+            end
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/proteus/commands/clean.rb

@@ -0,0 +1,22 @@
+require 'proteus/modules/manager'
+
+module Proteus
+  module Commands
+    module Clean
+      def self.included(thor_class)
+        thor_class.class_eval do |klass|
+
+          desc "clean", "Deletes rendered module manifests"
+          long_desc <<-LONGDESC
+            Deletes rendered module manifests without running Terraform
+          LONGDESC
+          def clean
+            module_manager = Proteus::Modules::Manager.new(context: context, environment: environment)
+            module_manager.clean
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/proteus/commands/destroy.rb

@@ -0,0 +1,51 @@
+module Proteus
+  module Commands
+    module Destroy
+      def self.included(thor_class)
+        thor_class.class_eval do
+
+          desc "destroy", "Destroys AWS resources."
+          long_desc <<-LONGDESC
+            Destroys AWS resources.
+
+            With --limit option, Terraform will only destroy the specified resources
+            If --limit does not get passed as an argument, terraform will destroy all of the AWS assets in the state.
+          LONGDESC
+          option :limit, type: :array, aliases: "-l", required: false
+          def destroy
+            init(verbose: parent_options[:verbose])
+
+            destroy_command = <<~DESTROY_COMMAND
+              cd #{context_path(context)} && \
+              terraform destroy \
+              -var-file=#{var_file(context, environment)} \
+              #{aws_profile} \
+              ##{limit(options[:limit])}
+            DESTROY_COMMAND
+
+            plan_destroy_command = <<~PLAN_DESTROY_COMMAND
+              cd #{context_path(context)} && \
+              terraform plan \
+              -destroy \
+              -out=#{plan_file(context, environment)} \
+              -var-file=#{var_file(context, environment)} \
+              #{aws_profile} \
+              ##{limit(options[:limit])}
+            PLAN_DESTROY_COMMAND
+
+
+            if dryrun
+              puts destroy_command.squeeze(' ')
+            else
+              syscall plan_destroy_command.squeeze(' ')
+              confirm question: "Do you really want to run 'terraform destroy' on environment '#{environment}'?", color: :on_red, exit_code: 0 do
+                exec destroy_command.squeeze(' ')
+              end
+            end
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/proteus/commands/graph.rb

@@ -0,0 +1,22 @@
+module Proteus
+  module Commands
+    module Graph
+      def self.included(thor_class)
+        thor_class.class_eval do
+
+          desc "graph", "Creates a graph showing the resources and their relations."
+          def graph
+            say "Generating graph. This might take a while"
+            graph_command = <<~GRAPH_COMMAND
+              cd #{context_path(context)} \
+              && terraform graph -draw-cycles -module-depth=1 | dot -Tpng > graph.png \
+              && open graph.png
+            GRAPH_COMMAND
+            `#{graph_command}`
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/proteus/commands/import.rb

@@ -0,0 +1,75 @@
+module Proteus
+  module Commands
+    module Import
+      def self.included(thor_class)
+        thor_class.class_eval do
+
+          desc "import", "Imports an existing resource into the terraform state"
+          long_desc <<-LONGDESC
+            Imports existing resources into the terraform state
+
+            --address Terraform internal address of the resource
+
+            --bulk Enables bulk import mode
+
+            --resource The resource to import into the terraform state
+
+            --resources_file File containing resource addresses and identifiers
+          LONGDESC
+          option :address, type: :string, aliases: "-a", default: nil
+          option :bulk, type: :boolean, aliases: "-b", required: false, default: false
+          option :resource, type: :string, aliases: "-r", default: nil
+          option :resources_file, type: :string, aliases: "-f", required: false, default: nil
+          def import
+            if options[:bulk]
+              if !options[:resources_file]
+                say "Supply a file containing resource identifiers and Terraform addresses for bulk operations", :red
+                exit 1
+              end
+            else
+              if !(options[:address] || !options[:resource])
+                say "You need to supply a resource address and a resource.", :red
+                exit 1
+              end
+            end
+
+            init(verbose: parent_options[:verbose])
+
+            confirm question: "Do you really want to run 'terraform import' in context '(#{context}, #{environment})'?", color: :on_red, exit_code: 0 do
+
+              import_command = <<~IMPORT_COMMAND
+                cd #{context_path(context)} && \
+                terraform import \
+                -var-file=#{var_file(context, environment)} \
+                #{aws_profile} \
+                %{address} \
+                %{resource}
+              IMPORT_COMMAND
+
+              if options[:bulk]
+                if File.file?(options[:resources_file])
+                  File.open(options[:resources_file], "r") do |file|
+                    resource_count = File.foreach(file).inject(0) {|count, line| count + 1}
+                    index = 1
+                    file.each_line do |line|
+                      say "Processing resource #{index}/#{resource_count}", :green
+                      resource = line.chomp.split(" = ")
+                      syscall (import_command % { address: resource[0], resource: resource[1] }).squeeze(' ')
+                      index += 1
+                    end
+                  end
+                else
+                  say "File #{options[:resources_file]} does not exist.", :red
+                  exit 1
+                end
+              else
+                syscall (import_command % { address: options[:address], resource: options[:resource] })
+              end
+            end
+          end
+
+        end
+      end
+    end
+  end
+end