yle_tf 0.1.0

data/vendor/middleware/LICENSE

@@ -0,0 +1,23 @@
+Copyright (c) 2012 Mitchell Hashimoto
+Copyright (c) 2017 Teemu Matilainen
+
+MIT License
+
+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/vendor/middleware/builder.rb

@@ -0,0 +1,149 @@
+require_relative 'runner'
+
+module Middleware
+  # This provides a DSL for building up a stack of middlewares.
+  #
+  # This code is based heavily off of `Rack::Builder` and
+  # `ActionDispatch::MiddlewareStack` in Rack and Rails, respectively.
+  #
+  # # Usage
+  #
+  # Building a middleware stack is very easy:
+  #
+  #     app = Middleware::Builder.new do
+  #       use A
+  #       use B
+  #     end
+  #
+  #     # Call the middleware
+  #     app.call(7)
+  #
+  class Builder
+    # Initializes the builder. An optional block can be passed which
+    # will be evaluated in the context of the instance.
+    #
+    # Example:
+    #
+    #     Builder.new do
+    #       use A
+    #       use B
+    #     end
+    #
+    # @param [Hash] opts Options hash
+    # @option opts [Class] :runner_class The class to wrap the middleware stack
+    #   in which knows how to run them.
+    # @yield [] Evaluated in this instance which allows you to use methods
+    #   like {#use} and such.
+    def initialize(opts=nil, &block)
+      opts ||= {}
+      @runner_class = opts[:runner_class] || Runner
+      instance_eval(&block) if block_given?
+    end
+
+    # Returns a mergeable version of the builder. If `use` is called with
+    # the return value of this method, then the stack will merge, instead
+    # of being treated as a separate single middleware.
+    def flatten
+      lambda do |env|
+        self.call(env)
+      end
+    end
+
+    # Adds a middleware class to the middleware stack. Any additional
+    # args and a block, if given, are saved and passed to the initializer
+    # of the middleware.
+    #
+    # @param [Class] middleware The middleware class
+    def use(middleware, *args, &block)
+      if middleware.kind_of?(Builder)
+        # Merge in the other builder's stack into our own
+        self.stack.concat(middleware.stack)
+      else
+        self.stack << [middleware, args, block]
+      end
+
+      self
+    end
+
+    # Inserts a middleware at the given index or directly before the
+    # given middleware object.
+    def insert(index, middleware, *args, &block)
+      index = self.index(index) unless index.is_a?(Integer)
+      raise "no such middleware to insert before: #{index.inspect}" unless index
+
+      if middleware.kind_of?(Builder)
+        middleware.stack.reverse.each do |stack_item|
+          stack.insert(index, stack_item)
+        end
+      else
+        stack.insert(index, [middleware, args, block])
+      end
+    end
+
+    alias_method :insert_before, :insert
+
+    # Inserts a middleware after the given index or middleware object.
+    def insert_after(index, middleware, *args, &block)
+      index = self.index(index) unless index.is_a?(Integer)
+      raise "no such middleware to insert after: #{index.inspect}" unless index
+      insert(index + 1, middleware, *args, &block)
+    end
+
+    # Replaces the given middlware object or index with the new
+    # middleware.
+    def replace(index, middleware, *args, &block)
+      if index.is_a?(Integer)
+        delete(index)
+        insert(index, middleware, *args, &block)
+      else
+        insert_before(index, middleware, *args, &block)
+        delete(index)
+      end
+    end
+
+    # Deletes the given middleware object or index
+    def delete(index)
+      index = self.index(index) unless index.is_a?(Integer)
+      stack.delete_at(index)
+    end
+
+    # Runs the builder stack with the given environment.
+    def call(env=nil)
+      to_app.call(env)
+    end
+
+    # Returns truish if the given middleware object exists in the stack.
+    def include?(object)
+      index(object)
+    end
+
+    protected
+
+    # Returns the numeric index for the given middleware object.
+    #
+    # @param [Object] object The item to find the index for
+    # @return [Integer]
+    def index(object)
+      stack.each_with_index do |item, i|
+        return i if item[0] == object
+      end
+
+      nil
+    end
+
+    # Returns the current stack of middlewares. You probably won't
+    # need to use this directly, and it's recommended that you don't.
+    #
+    # @return [Array]
+    def stack
+      @stack ||= []
+    end
+
+    # Converts the builder stack to a runnable action sequence.
+    #
+    # @return [Object] A callable object
+    def to_app
+      @runner_class.new(stack.dup)
+    end
+  end
+end

data/vendor/middleware/runner.rb

@@ -0,0 +1,69 @@
+module Middleware
+  # This is a basic runner for middleware stacks. This runner does
+  # the default expected behavior of running the middleware stacks
+  # in order, then reversing the order.
+  class Runner
+    # A middleware which does nothing
+    EMPTY_MIDDLEWARE = lambda { |env| }
+
+    # Build a new middleware runner with the given middleware
+    # stack.
+    #
+    # Note: This class usually doesn't need to be used directly.
+    # Instead, take a look at using the {Builder} class, which is
+    # a much friendlier way to build up a middleware stack.
+    #
+    # @param [Array] stack An array of the middleware to run.
+    def initialize(stack)
+      # We need to take the stack of middleware and initialize them
+      # all so they call the proper next middleware.
+      @kickoff = build_call_chain(stack)
+    end
+
+    # Run the middleware stack with the given state bag.
+    #
+    # @param [Object] env The state to pass into as the initial
+    #   environment data. This is usual a hash of some sort.
+    def call(env)
+      # We just call the kickoff middleware, which is responsible
+      # for properly calling the next middleware, and so on and so
+      # forth.
+      @kickoff.call(env)
+    end
+
+    protected
+
+    # This takes a stack of middlewares and initializes them in a way
+    # that each middleware properly calls the next middleware.
+    def build_call_chain(stack)
+      # We need to instantiate the middleware stack in reverse
+      # order so that each middleware can have a reference to
+      # the next middleware it has to call. The final middleware
+      # is always the empty middleware, which does nothing but return.
+      stack.reverse.inject(EMPTY_MIDDLEWARE) do |next_middleware, current_middleware|
+        # Unpack the actual item
+        klass, args, block = current_middleware
+
+        # Default the arguments to an empty array. Otherwise in Ruby 1.8
+        # a `nil` args will actually pass `nil` into the class. Not what
+        # we want!
+        args ||= []
+
+        if klass.is_a?(Class)
+          # If the klass actually is a class, then instantiate it with
+          # the app and any other arguments given.
+          klass.new(next_middleware, *args, &block)
+        elsif klass.respond_to?(:call)
+          # Make it a lambda which calls the item then forwards up
+          # the chain.
+          lambda do |env|
+            klass.call(env)
+            next_middleware.call(env)
+          end
+        else
+          raise "Invalid middleware, doesn't respond to `call`: #{action.inspect}"
+        end
+      end
+    end
+  end
+end

data/yle_tf.gemspec

@@ -0,0 +1,37 @@
+# coding: utf-8
+
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'yle_tf/version'
+
+Gem::Specification.new do |spec|
+  spec.name        = 'yle_tf'
+  spec.version     = YleTf::VERSION
+  spec.summary     = 'Tooling for Terraform'
+  spec.description = 'Tooling for Terraform to support environments, hooks, etc.'
+  spec.homepage    = 'https://github.com/Yleisradio/yle_tf'
+  spec.license     = 'MIT'
+
+  spec.authors = [
+    'Yleisradio',
+    'Teemu Matilainen',
+    'Antti Forsell',
+  ]
+  spec.email = [
+    'devops@yle.fi',
+    'teemu.matilainen@iki.fi',
+    'antti.forsell@iki.fi',
+  ]
+
+  spec.files = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+
+  spec.bindir        = 'bin'
+  spec.executables   = ['tf']
+  spec.require_paths = ['lib']
+
+  spec.add_development_dependency 'bundler', '~> 1.13'
+  spec.add_development_dependency 'rake', '~> 12.0'
+  spec.add_development_dependency 'rspec', '~> 3.5'
+end

metadata

@@ -0,0 +1,160 @@
+--- !ruby/object:Gem::Specification
+name: yle_tf
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Yleisradio
+- Teemu Matilainen
+- Antti Forsell
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-08-29 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.13'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.13'
+- !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'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.5'
+description: Tooling for Terraform to support environments, hooks, etc.
+email:
+- devops@yle.fi
+- teemu.matilainen@iki.fi
+- antti.forsell@iki.fi
+executables:
+- tf
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".rubocop.yml"
+- ".travis.yml"
+- CHANGELOG.md
+- CODE_OF_CONDUCT.md
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/tf
+- examples/envs/prod.tfvars
+- examples/envs/test.tfvars
+- examples/main.tf
+- examples/tf.yaml
+- examples/tf_hooks/pre/get_current_hash.sh
+- examples/variables.tf
+- lib/yle_tf.rb
+- lib/yle_tf/action.rb
+- lib/yle_tf/action/builder.rb
+- lib/yle_tf/action/command.rb
+- lib/yle_tf/action/copy_root_module.rb
+- lib/yle_tf/action/generate_vars_file.rb
+- lib/yle_tf/action/load_config.rb
+- lib/yle_tf/action/terraform_init.rb
+- lib/yle_tf/action/tf_hooks.rb
+- lib/yle_tf/action/tmpdir.rb
+- lib/yle_tf/action/verify_terraform_version.rb
+- lib/yle_tf/action/verify_tf_env.rb
+- lib/yle_tf/backend_config.rb
+- lib/yle_tf/cli.rb
+- lib/yle_tf/config.rb
+- lib/yle_tf/config/defaults.rb
+- lib/yle_tf/config/erb.rb
+- lib/yle_tf/config/file.rb
+- lib/yle_tf/config/loader.rb
+- lib/yle_tf/error.rb
+- lib/yle_tf/logger.rb
+- lib/yle_tf/plugin.rb
+- lib/yle_tf/plugin/action_hook.rb
+- lib/yle_tf/plugin/loader.rb
+- lib/yle_tf/plugin/manager.rb
+- lib/yle_tf/system.rb
+- lib/yle_tf/tf_hook.rb
+- lib/yle_tf/tf_hook/runner.rb
+- lib/yle_tf/vars_file.rb
+- lib/yle_tf/version.rb
+- lib/yle_tf/version_requirement.rb
+- lib/yle_tf_plugins/backends/file/command.rb
+- lib/yle_tf_plugins/backends/file/config.rb
+- lib/yle_tf_plugins/backends/file/plugin.rb
+- lib/yle_tf_plugins/backends/s3/command.rb
+- lib/yle_tf_plugins/backends/s3/plugin.rb
+- lib/yle_tf_plugins/commands/__default/command.rb
+- lib/yle_tf_plugins/commands/__default/plugin.rb
+- lib/yle_tf_plugins/commands/_config/command.rb
+- lib/yle_tf_plugins/commands/_config/plugin.rb
+- lib/yle_tf_plugins/commands/_shell/command.rb
+- lib/yle_tf_plugins/commands/_shell/plugin.rb
+- lib/yle_tf_plugins/commands/help/command.rb
+- lib/yle_tf_plugins/commands/help/plugin.rb
+- lib/yle_tf_plugins/commands/version/command.rb
+- lib/yle_tf_plugins/commands/version/plugin.rb
+- vendor/hash_deep_merge.rb
+- vendor/logger_level_patch.rb
+- vendor/middleware/LICENSE
+- vendor/middleware/builder.rb
+- vendor/middleware/runner.rb
+- yle_tf.gemspec
+homepage: https://github.com/Yleisradio/yle_tf
+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.11
+signing_key: 
+specification_version: 4
+summary: Tooling for Terraform
+test_files: []