miasma-terraform 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 5c46a5855cfe72db0105261f00f0f48e36916aaa
+  data.tar.gz: 5fb33600986aa116c94a7ab1b7eb17abee71912a
+SHA512:
+  metadata.gz: ee7697f996ecf4816f33c43fc26ab203db407347cd82a7725d4ed26368eca99ae9b894f69de6a41fc41137635400d39ab4ac4c98258641467530e3eb0ac60029
+  data.tar.gz: ee293821c6ae291fdcfe35a7cd391fa90d8c7b1e0a8cd24899a7a7633a01fb9943d20beca18767f513d857da17047821601889a031bd469842e970538d9f9398

data/CHANGELOG.md

@@ -0,0 +1,2 @@
+# v0.1.0
+* Initial release

data/LICENSE

@@ -0,0 +1,13 @@
+   Copyright 2017 Chris Roberts
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+     http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

data/README.md

@@ -0,0 +1,88 @@
+# Miasma Terraform
+
+Terraform API plugin for the miasma cloud library
+
+## Supported credential attributes:
+
+Supported attributes used in the credentials section of API
+configurations:
+
+```ruby
+Miasma.api(
+  :type => :orchestration,
+  :provider => :terraform,
+  :credentials => {
+    ...
+  }
+)
+```
+
+### Common attributes
+
+* `terraform_driver` - Interface to use (`atlas`, `boule`, `local`)
+
+### Atlas attributes
+
+_NOTE: Atlas support not yet available_
+
+```ruby
+Miasma.api(
+  :type => :orchestration,
+  :provider => :terraform,
+  :credentials => {
+    :terraform_driver => :atlas
+    ...
+  }
+)
+```
+
+* `terraform_atlas_endpoint` - Atlas URL
+* `terraform_atlas_token` - Atlas token
+
+### Boule attributes
+
+```ruby
+Miasma.api(
+  :type => :orchestration,
+  :provider => :terraform,
+  :credentials => {
+    :terraform_driver => :boule
+    ...
+  }
+)
+```
+
+* `terraform_boule_endpoint` - Boule URL
+
+### Local attributes
+
+```ruby
+Miasma.api(
+  :type => :orchestration,
+  :provider => :terraform,
+  :credentials => {
+    :terraform_driver => :local
+    ...
+  }
+)
+```
+
+* `terraform_local_directory` - Path to store stack data
+* `terraform_local_scrub_destroyed` - Delete stack data directory on destroy
+
+## Current support matrix
+
+|Model         |Create|Read|Update|Delete|
+|--------------|------|----|------|------|
+|AutoScale     |      |    |      |      |
+|BlockStorage  |      |    |      |      |
+|Compute       |      |    |      |      |
+|DNS           |      |    |      |      |
+|LoadBalancer  |      |    |      |      |
+|Network       |      |    |      |      |
+|Orchestration |  X   | X  |  X   |  X   |
+|Queues        |      |    |      |      |
+|Storage       |      |    |      |      |
+
+## Info
+* Repository: https://github.com/miasma-rb/miasma-terraform

data/lib/miasma-terraform.rb

@@ -0,0 +1,3 @@
+require 'miasma'
+require 'miasma-terraform/version'
+require 'miasma-terraform/stack'

data/lib/miasma-terraform/stack.rb

@@ -0,0 +1,579 @@
+require 'open3'
+require 'stringio'
+require 'fileutils'
+require 'tempfile'
+
+module MiasmaTerraform
+  class Stack
+
+    @@running_actions = []
+
+    # Register action to be cleaned up at exit
+    #
+    # @param action [Action]
+    # @return [NilClass]
+    def self.register_action(action)
+      unless(@@running_actions.include?(action))
+        @@running_actions.push(action)
+      end
+      nil
+    end
+
+    # Deregister action from at exit cleanup
+    #
+    # @param action [Action]
+    # @return [NilClass]
+    def self.deregister_action(action)
+      @@running_actions.delete(action)
+      nil
+    end
+
+    # Wait for all actions to complete
+    def self.cleanup_actions!
+      @@running_actions.map(&:complete!)
+      nil
+    end
+
+    # @return [Array<String>]
+    def self.list(container)
+      if(container.to_s.empty?)
+        raise ArgumentError.new 'Container directory must be set!'
+      end
+      if(File.directory?(container))
+        Dir.new(container).map do |entry|
+          next if entry.start_with?('.')
+          entry if File.directory?(File.join(container, entry))
+        end.compact
+      else
+        []
+      end
+    end
+
+    class Error < StandardError
+      class Busy < Error; end
+      class NotFound < Error; end
+      class CommandFailed < Error; end
+      class ValidateError < Error; end
+    end
+
+    REQUIRED_ATTRIBUTES = [:name, :container]
+
+    class Action
+      attr_reader :stdin, :waiter, :command, :options
+
+      # Create a new action to run
+      #
+      # @param command [String]
+      # @param opts [Hash]
+      # @return [self]
+      def initialize(command, opts={})
+        @command = command.dup.freeze
+        @options = opts.to_smash
+        @io_callbacks = []
+        @complete_callbacks = []
+        @start_callbacks = []
+        @cached_output = Smash.new(
+          :stdout => StringIO.new(''),
+          :stderr => StringIO.new('')
+        )
+        if(@options.delete(:auto_start))
+          start!
+        end
+      end
+
+      # Start the process
+      def start!
+        opts = Hash[@options.map{|k,v| [k.to_sym,v]}]
+        MiasmaTerraform::Stack.register_action(self)
+        @stdin, @stdout, @stderr, @waiter = Open3.popen3(@command, **opts)
+        @start_callbacks.each do |callback|
+          callback.call(self)
+        end
+        unless(@io_callbacks.empty? && @complete_callbacks.empty?)
+          manage_process!
+        end
+        true
+      end
+
+      # Wait for the process to complete
+      #
+      # @return [Process::Status]
+      def complete!
+        start! unless waiter
+        if(@process_manager)
+          @process_manager.join
+        end
+        result = waiter.value
+        MiasmaTerraform::Stack.deregister_action(self)
+        result
+      end
+
+      # @return [IO] stderr stream
+      def stderr
+        if(@stderr == :managed_io)
+          @cached_output[:stderr]
+        else
+          @stderr
+        end
+      end
+
+      # @return [IO] stdout stream
+      def stdout
+        if(@stdout == :managed_io)
+          @cached_output[:stdout]
+        else
+          @stdout
+        end
+      end
+
+      # Register a block to be run when process output
+      # is received
+      #
+      # @yieldparam line [String] output line
+      # @yieldparam type [Symbol] output type (:stdout or :stderr)
+      def on_io(&block)
+        @io_callbacks << block
+        self
+      end
+
+      # Register a block to be run when a process completes
+      #
+      # @yieldparam result [Process::Status]
+      # @yieldparam self [Action]
+      def on_complete(&block)
+        @complete_callbacks << block
+        self
+      end
+
+      # Register a block to be run when a process starts
+      #
+      # @yieldparam self [Action]
+      def on_start(&block)
+        @start_callbacks << block
+        self
+      end
+
+      protected
+
+      # Start reader thread for handling managed process output
+      def manage_process!
+        unless(@process_manager)
+          unless(@io_callbacks.empty?)
+            io_stdout = @stdout
+            io_stderr = @stderr
+            @stdout = @stderr = :managed_io
+          end
+          @process_manager = Thread.new do
+            if(io_stdout && io_stderr)
+              while(waiter.alive?)
+                IO.select([io_stdout, io_stderr])
+                [io_stdout, io_stderr].each do |io|
+                  begin
+                    content = io.read_nonblock(102400)
+                    type = io == io_stdout ? :stdout : :stderr
+                    @cached_output[type] << content
+                    content = content.split("\n")
+                    @io_callbacks.each do |callback|
+                      content.each do |line|
+                        callback.call(line, type)
+                      end
+                    end
+                  rescue IO::WaitReadable, EOFError
+                    # ignore
+                  end
+                end
+              end
+            end
+            result = waiter.value
+            @complete_callbacks.each do |callback|
+              callback.call(result, self)
+            end
+            MiasmaTerraform::Stack.deregister_action(self)
+            result
+          end
+        end
+      end
+    end
+
+    attr_reader :actions
+    attr_reader :directory
+    attr_reader :container
+    attr_reader :name
+    attr_reader :bin
+    attr_reader :scrub_destroyed
+
+    def initialize(opts={})
+      @options = opts.to_smash
+      init!
+      @actions = []
+      @name = @options[:name]
+      @container = @options[:container]
+      @scrub_destroyed = @options.fetch(:scrub_destroyed, false)
+      @directory = File.join(container, name)
+      @bin = @options.fetch(:bin, 'terraform')
+    end
+
+    # @return [TrueClass, FalseClass] stack currently exists
+    def exists?
+      File.directory?(directory)
+    end
+
+    # @return [TrueClass, FalseClass] stack is currently active
+    def active?
+      actions.any? do |action|
+        action.waiter.alive?
+      end
+    end
+
+    # Save the TF stack
+    def save(opts={})
+      save_opts = opts.to_smash
+      type = exists? ? "update" : "create"
+      lock_stack
+      write_file(tf_path, save_opts[:template].to_json)
+      write_file(tfvars_path, save_opts[:parameters].to_json)
+      action = run_action('apply')
+      store_events(action)
+      action.on_start do |_|
+        update_info do |info|
+          info["state"] = "#{type}_in_progress"
+          info
+        end
+      end
+      action.on_complete do |status, this_action|
+        update_info do |info|
+          if(type == "create")
+            info["created_at"] = (Time.now.to_f * 1000).floor
+          end
+          info["updated_at"] = (Time.now.to_f * 1000).floor
+          info["state"] = status.success? ? "#{type}_complete" : "#{type}_failed"
+          info
+        end
+        unlock_stack
+      end
+      action.start!
+      true
+    end
+
+    # @return [Array<Hash>] resource list
+    def resources
+      must_exist do
+        if(has_state?)
+          action = run_action('state list', :auto_start)
+          # wait for action to complete
+          action.complete!
+          successful_action(action) do
+            resource_lines = action.stdout.read.split("\n").find_all do |line|
+              line.match(/^[^\s]/)
+            end
+            resource_lines.map do |line|
+              parts = line.split('.')
+              resource_info = Smash.new(
+                :type => parts[0],
+                :name => parts[1],
+                :status => 'UPDATE_COMPLETE'
+              )
+              action = run_action("state show #{line}", :auto_start)
+              action.complete!
+              successful_action(action) do
+                info = Smash.new
+                action.stdout.read.split("\n").each do |line|
+                  parts = line.split('=').map(&:strip)
+                  next if parts.size != 2
+                  info[parts[0]] = parts[1]
+                end
+                resource_info[:physical_id] = info[:id] if info[:id]
+              end
+              resource_info
+            end
+          end
+        else
+          []
+        end
+      end
+    end
+
+    # @return [Array<Hash>] events list
+    def events
+      must_exist do
+        load_info.fetch(:events, []).map do |item|
+          new_item = item.dup
+          parts = item[:resource_name].to_s.split('.')
+          new_item[:resource_name] = parts[1]
+          new_item[:resource_type] = parts[0]
+          new_item
+        end
+      end
+    end
+
+    # @return [Hash] stack outputs
+    def outputs
+      must_exist do
+        if(has_state?)
+          action = run_action('output -json', :auto_start)
+          action.complete!
+          successful_action(action) do
+            result = JSON.parse(action.stdout.read).to_smash.map do |key, info|
+              [key, info[:value]]
+            end
+            Smash[result]
+          end
+        else
+          Smash.new
+        end
+      end
+    end
+
+    # @return [String] current stack template
+    def template
+      must_exist do
+        if(File.exists?(tf_path))
+          File.read(tf_path)
+        else
+          "{}"
+        end
+      end
+    end
+
+    # @return [Hash] stack information
+    def info
+      must_exist do
+        stack_data = load_info
+        Smash.new(
+          :id => name,
+          :name => name,
+          :state => stack_data[:state].to_s,
+          :status => stack_data[:state].to_s.upcase,
+          :updated_time => stack_data[:updated_at],
+          :creation_time => stack_data[:created_at],
+          :outputs => outputs
+        )
+      end
+    end
+
+    def validate(template)
+      errors = []
+      root_path = Dir.mktmpdir('miasma-')
+      template_path = File.join(root_path, 'main.tf')
+      File.write(template_path, template)
+      action = run_action('validate')
+      action.options[:chdir] = root_path
+      action.on_io do |line, type|
+        if(line.start_with?('*'))
+          errors << line
+        end
+      end.on_complete do |_|
+        FileUtils.rm_rf(root_path)
+      end
+      action.complete!
+      errors
+    end
+
+    # @return [TrueClass] destroy this stack
+    def destroy!
+      must_exist do
+        lock_stack
+        action = run_action('destroy -force')
+        action.on_start do |_|
+          update_info do |info|
+            info[:state] = "delete_in_progress"
+            info
+          end
+        end
+        action.on_complete do |*_|
+          unlock_stack
+        end
+        action.on_complete do |result, _|
+          unless(result.success?)
+            update_info do |info|
+              info[:state] = "delete_failed"
+              info
+            end
+          else
+            update_info do |info|
+              info[:state] = "delete_complete"
+              info
+            end
+            FileUtils.rm_rf(directory) if scrub_destroyed
+          end
+        end
+        action.start!
+      end
+      true
+    end
+
+    protected
+
+    # Start running a terraform process
+    def run_action(cmd, auto_start=false)
+      action = Action.new("#{bin} #{cmd} -no-color", :chdir => directory)
+      action.on_start do |this_action|
+        actions << this_action
+      end
+      action.on_complete do |_, this_action|
+        actions.delete(this_action)
+      end
+      action.start! if auto_start
+      action
+    end
+
+    # Validate stack exists before running block
+    def must_exist(lock=false)
+      if(exists?)
+        if(lock)
+          lock_stack do
+            yield
+          end
+        else
+          yield
+        end
+      else
+        raise Error::NotFound.new "Stack does not exist `#{name}`"
+      end
+    end
+
+    # Lock stack and run block
+    def lock_stack
+      FileUtils.mkdir_p(directory)
+      @lock_file = File.open(lock_path, File::RDWR|File::CREAT)
+      if(@lock_file.flock(File::LOCK_EX | File::LOCK_NB))
+        if(block_given?)
+          result = yield
+          @lock_file.flock(File::LOCK_UN)
+          @lock_file = nil
+          result
+        else
+          true
+        end
+      else
+        raise Error::Busy.new "Failed to aquire process lock for `#{name}`. Stack busy."
+      end
+    end
+
+    # Unlock stack
+    def unlock_stack
+      if(@lock_file)
+        @lock_file.flock(File::LOCK_UN)
+        @lock_file = nil
+        true
+      else
+        false
+      end
+    end
+
+    # @return [String] path to template file
+    def tf_path
+      File.join(directory, 'main.tf')
+    end
+
+    # @return [String] path to variables file
+    def tfvars_path
+      File.join(directory, 'terraform.tfvars')
+    end
+
+    # @return [String] path to internal info file
+    def info_path
+      File.join(directory, '.info.json')
+    end
+
+    # @return [String] path to state file
+    def tfstate_path
+      File.join(directory, 'terraform.tfstate')
+    end
+
+    # @return [TrueClass, FalseClass] stack has state
+    def has_state?
+      File.exists?(tfstate_path)
+    end
+
+    # @return [String] path to lock file
+    def lock_path
+      File.join(directory, '.lck')
+    end
+
+    # @return [Smash] stack info
+    def load_info
+      if(File.exists?(info_path))
+        result = JSON.parse(File.read(info_path)).to_smash
+      else
+        result = Smash.new
+      end
+      result[:created_at] = (Time.now.to_f * 1000).floor unless result[:created_at]
+      result[:state] = 'unknown' unless result[:state]
+      result
+    end
+
+    # @return [TrueClass]
+    def update_info
+      result = yield(load_info)
+      write_file(info_path, result.to_json)
+      true
+    end
+
+    # Raise exception if action was not completed successfully
+    def successful_action(action)
+      status = action.complete!
+      unless(status.success?)
+        raise Error::CommandFailed.new "Command failed `#{action.command}` - #{action.stderr.read}"
+      else
+        yield
+      end
+    end
+
+    # Store stack events generated by action
+    #
+    # @param action [Action]
+    def store_events(action)
+      action.on_io do |line, type|
+        result = line.match(/^(\*\s+)?(?<name>[^\s]+): (?<status>.+)$/)
+        if(result)
+          resource_name = result["name"]
+          resource_status = result["status"]
+          event = Smash.new(
+            :timestamp => (Time.now.to_f * 1000).floor,
+            :resource_name => resource_name,
+            :resource_status => resource_status,
+            :id => SecureRandom.uuid
+          )
+          update_info do |info|
+            info[:events] ||= []
+            info[:events].unshift(event)
+            info
+          end
+        end
+      end
+    end
+
+    # Validate initialization
+    def init!
+      missing_attrs = REQUIRED_ATTRIBUTES.find_all do |key|
+        !@options[key]
+      end
+      unless(missing_attrs.empty?)
+        raise ArgumentError.new("Missing required attributes: #{missing_attrs.sort}")
+      end
+      # TODO: Add tf bin check
+    end
+
+    # File write helper that proxies via temporary file
+    # to prevent corrupted writes on unexpected interrupt
+    #
+    # @param path [String] path to file
+    # @param contents [String] contents of file
+    # @return [TrueClass]
+    def write_file(path, contents=nil)
+      tmp_file = Tempfile.new('miasma')
+      yield(tmp_file) if block_given?
+      tmp_file.print(contents.to_s) if contents
+      tmp_file.close
+      FileUtils.mv(tmp_file.path, path)
+      true
+    end
+
+  end
+end
+
+# TODO: Don't be lazy and remove this setting
+Thread.abort_on_exception = true
+
+Kernel.at_exit{ MiasmaTerraform::Stack.cleanup_actions! }

data/lib/miasma-terraform/version.rb

@@ -0,0 +1,4 @@
+module MiasmaTerraform
+  # Current library version
+  VERSION = Gem::Version.new('0.1.0')
+end

data/lib/miasma/contrib/terraform.rb

@@ -0,0 +1,52 @@
+require 'miasma'
+require 'miasma-terraform'
+
+module Miasma
+  module Contrib
+
+    # Terraform API core helper
+    class TerraformApiCore
+
+      # Common API methods
+      module ApiCommon
+
+        # Set attributes into model
+        #
+        # @param klass [Class]
+        def self.included(klass)
+          klass.class_eval do
+            attribute :terraform_driver, String, :required => true,
+                      :allowed_values => ['atlas', 'boule', 'local'], :default => 'local',
+                      :coerce => lambda{|v| v.to_s }
+            # Attributes required for Atlas driver
+            attribute :terraform_atlas_endpoint, String
+            attribute :terraform_atlas_token, String
+            # Attributes required for Boule driver
+            attribute :terraform_boule_endpoint, String
+            # Attributes required for local driver
+            attribute :terraform_local_directory, String
+            attribute :terraform_local_scrub_destroyed, [TrueClass, FalseClass], :default => false
+          end
+        end
+
+        def custom_setup(creds)
+          begin
+            driver_module = Miasma::Models::Orchestration::Terraform.const_get(
+              Bogo::Utility.camel(creds[:terraform_driver].to_s)
+            )
+            extend driver_module
+          rescue NameError
+            raise NotImplementedError.new "Requested driver not implemented `#{creds[:terraform_driver]}`"
+          end
+        end
+
+        def endpoint
+          terraform_boule_endpoint
+        end
+      end
+
+    end
+  end
+
+  Models::Orchestration.autoload :Terraform, 'miasma/contrib/terraform/orchestration'
+end

data/lib/miasma/contrib/terraform/orchestration.rb

@@ -0,0 +1,441 @@
+require 'miasma'
+
+module Miasma
+  module Models
+    class Orchestration
+      class Terraform < Orchestration
+
+        include Miasma::Contrib::TerraformApiCore::ApiCommon
+
+        module Local
+
+          # Generate wrapper stack
+          def terraform_stack(stack)
+            if(terraform_local_directory.to_s.empty?)
+              raise ArgumentError.new 'Attribute `terraform_local_directory` must be set for local mode usage'
+            end
+            tf_stack = memoize(stack.name, :direct) do
+              MiasmaTerraform::Stack.new(
+                :name => stack.name,
+                :container => terraform_local_directory,
+                :scrub_destroyed => terraform_local_scrub_destroyed
+              )
+            end
+            if(block_given?)
+              begin
+                yield(tf_stack)
+              rescue MiasmaTerraform::Stack::Error::NotFound
+                raise Miasma::Error::ApiError::RequestError.new(
+                  "Failed to locate stack `#{stack.name}`",
+                  :response => OpenStruct.new(:code => 404)
+                )
+              end
+            else
+              tf_stack
+            end
+          end
+
+          # Save the stack
+          #
+          # @param stack [Models::Orchestration::Stack]
+          # @return [Models::Orchestration::Stack]
+          def stack_save(stack)
+            tf_stack = nil
+            begin
+              tf_stack = terraform_stack(stack) do |tf|
+                tf.info
+                tf
+              end
+            rescue Miasma::Error::ApiError::RequestError
+              if(stack.persisted?)
+                raise
+              else
+                tf_stack = nil
+              end
+            end
+            if(!stack.persisted? && tf_stack)
+              raise Miasma::Error::ApiError::RequestError.new(
+                "Stack already exists `#{stack.name}`",
+                :response => OpenStruct.new(:code => 405)
+              )
+            end
+            tf_stack = terraform_stack(stack) unless tf_stack
+            tf_stack.save(
+              :template => stack.template,
+              :parameters => stack.parameters || {}
+            )
+            stack.id = stack.name
+            stack.valid_state
+          end
+
+          # Reload the stack data from the API
+          #
+          # @param stack [Models::Orchestration::Stack]
+          # @return [Models::Orchestration::Stack]
+          def stack_reload(stack)
+            if(stack.persisted?)
+              terraform_stack(stack) do |tf_stack|
+                s = tf_stack.info
+                stack.load_data(
+                  :id => s[:id],
+                  :created => s[:creation_time].to_s.empty? ? nil : Time.at(s[:creation_time].to_i / 1000.0),
+                  :description => s[:description],
+                  :name => s[:name],
+                  :state => s[:status].downcase.to_sym,
+                  :status => s[:status],
+                  :status_reason => s[:stack_status_reason],
+                  :updated => s[:updated_time].to_s.empty? ? nil : Time.at(s[:updated_time].to_i / 1000.0),
+                  :outputs => s[:outputs].map{|k,v| {:key => k, :value => v}}
+                ).valid_state
+              end
+            end
+            stack
+          end
+
+          # Delete the stack
+          #
+          # @param stack [Models::Orchestration::Stack]
+          # @return [TrueClass, FalseClass]
+          def stack_destroy(stack)
+            if(stack.persisted?)
+              terraform_stack(stack).destroy!
+              true
+            else
+              false
+            end
+          end
+
+          # Fetch stack template
+          #
+          # @param stack [Stack]
+          # @return [Smash] stack template
+          def stack_template_load(stack)
+            if(stack.persisted?)
+              JSON.load(terraform_stack(stack).template).to_smash
+            else
+              Smash.new
+            end
+          end
+
+          # Validate stack template
+          #
+          # @param stack [Stack]
+          # @return [NilClass, String] nil if valid, string error message if invalid
+          def stack_template_validate(stack)
+            begin
+              terraform_stack(stack).validate(stack.template)
+              nil
+            rescue MiasmaTerraform::Error::Validation => e
+              MultiJson.load(e.response.body.to_s).to_smash.get(:error, :message)
+            end
+          end
+
+          # Return all stacks
+          #
+          # @param options [Hash] filter
+          # @return [Array<Models::Orchestration::Stack>]
+          # @todo check if we need any mappings on state set
+          def stack_all(options={})
+            MiasmaTerraform::Stack.list(terraform_local_directory).map do |stack_name|
+              s = terraform_stack(Stack.new(self, :name => stack_name)).info
+              Stack.new(
+                self,
+                :id => s[:id],
+                :created => s[:creation_time].to_s.empty? ? nil : Time.at(s[:creation_time].to_i / 1000.0),
+                :description => s[:description],
+                :name => s[:name],
+                :state => s[:status].downcase.to_sym,
+                :status => s[:status],
+                :status_reason => s[:stack_status_reason],
+                :updated => s[:updated_time].to_s.empty? ? nil : Time.at(s[:updated_time].to_i / 1000.0)
+              ).valid_state
+            end
+          end
+
+          # Return all resources for stack
+          #
+          # @param stack [Models::Orchestration::Stack]
+          # @return [Array<Models::Orchestration::Stack::Resource>]
+          def resource_all(stack)
+            terraform_stack(stack) do |tf_stack|
+              tf_stack.resources.map do |resource|
+                Stack::Resource.new(
+                  stack,
+                  :id => resource[:physical_id],
+                  :name => resource[:name],
+                  :type => resource[:type],
+                  :logical_id => resource[:name],
+                  :state => resource[:status].downcase.to_sym,
+                  :status => resource[:status],
+                  :status_reason => resource[:resource_status_reason],
+                  :updated => resource[:updated_time].to_s.empty? ? Time.now : Time.parse(resource[:updated_time])
+                ).valid_state
+              end
+            end
+          end
+
+          # Reload the stack resource data from the API
+          #
+          # @param resource [Models::Orchestration::Stack::Resource]
+          # @return [Models::Orchestration::Resource]
+          def resource_reload(resource)
+            resource.stack.resources.reload
+            resource.stack.resources.get(resource.id)
+          end
+
+          # Return all events for stack
+          #
+          # @param stack [Models::Orchestration::Stack]
+          # @return [Array<Models::Orchestration::Stack::Event>]
+          def event_all(stack, marker = nil)
+            params = marker ? {:marker => marker} : {}
+            terraform_stack(stack) do |tf_stack|
+              tf_stack.events.map do |event|
+                Stack::Event.new(
+                  stack,
+                  :id => event[:id],
+                  :resource_id => event[:physical_resource_id],
+                  :resource_name => event[:resource_name],
+                  :resource_logical_id => event[:resource_name],
+                  :resource_state => event[:resource_status].downcase.to_sym,
+                  :resource_status => event[:resource_status],
+                  :resource_status_reason => event[:resource_status_reason],
+                  :time => Time.at(event[:timestamp] / 1000.0)
+                ).valid_state
+              end
+            end
+          end
+
+          # Return all new events for event collection
+          #
+          # @param events [Models::Orchestration::Stack::Events]
+          # @return [Array<Models::Orchestration::Stack::Event>]
+          def event_all_new(events)
+            event_all(events.stack, events.all.first.id)
+          end
+
+          # Reload the stack event data from the API
+          #
+          # @param resource [Models::Orchestration::Stack::Event]
+          # @return [Models::Orchestration::Event]
+          def event_reload(event)
+            event.stack.events.reload
+            event.stack.events.get(event.id)
+          end
+        end
+
+        module Boule
+          # Save the stack
+          #
+          # @param stack [Models::Orchestration::Stack]
+          # @return [Models::Orchestration::Stack]
+          def stack_save(stack)
+            if(stack.persisted?)
+              stack.load_data(stack.attributes)
+              result = request(
+                :method => :put,
+                :path => "/terraform/stack/#{stack.name}",
+                :json => {
+                  :template => MultiJson.dump(stack.template),
+                  :parameters => stack.parameters || {}
+                }
+              )
+              stack.valid_state
+            else
+              stack.load_data(stack.attributes)
+              result = request(
+                :method => :post,
+                :path => "/terraform/stack/#{stack.name}",
+                :json => {
+                  :template => MultiJson.dump(stack.template),
+                  :parameters => stack.parameters || {}
+                }
+              )
+              stack.id = result.get(:body, :stack, :id)
+              stack.valid_state
+            end
+          end
+
+          # Reload the stack data from the API
+          #
+          # @param stack [Models::Orchestration::Stack]
+          # @return [Models::Orchestration::Stack]
+          def stack_reload(stack)
+            if(stack.persisted?)
+              result = request(
+                :method => :get,
+                :path => "/terraform/stack/#{stack.name}"
+              )
+              s = result.get(:body, :stack)
+              stack.load_data(
+                :id => s[:id],
+                :created => s[:creation_time].to_s.empty? ? nil : Time.at(s[:creation_time].to_i / 1000.0),
+                :description => s[:description],
+                :name => s[:name],
+                :state => s[:status].downcase.to_sym,
+                :status => s[:status],
+                :status_reason => s[:stack_status_reason],
+                :updated => s[:updated_time].to_s.empty? ? nil : Time.at(s[:updated_time].to_i / 1000.0),
+                :outputs => s[:outputs].map{|k,v| {:key => k, :value => v}}
+              ).valid_state
+            end
+            stack
+          end
+
+          # Delete the stack
+          #
+          # @param stack [Models::Orchestration::Stack]
+          # @return [TrueClass, FalseClass]
+          def stack_destroy(stack)
+            if(stack.persisted?)
+              request(
+                :method => :delete,
+                :path => "/terraform/stack/#{stack.name}"
+              )
+              true
+            else
+              false
+            end
+          end
+
+          # Fetch stack template
+          #
+          # @param stack [Stack]
+          # @return [Smash] stack template
+          def stack_template_load(stack)
+            if(stack.persisted?)
+              result = request(
+                :method => :get,
+                :path => "/terraform/template/#{stack.name}"
+              )
+              result.fetch(:body, Smash.new)
+            else
+              Smash.new
+            end
+          end
+
+          # Validate stack template
+          #
+          # @param stack [Stack]
+          # @return [NilClass, String] nil if valid, string error message if invalid
+          def stack_template_validate(stack)
+            begin
+              result = request(
+                :method => :post,
+                :path => '/terraform/validate',
+                :json => Smash.new(
+                  :template => stack.template
+                )
+              )
+              nil
+            rescue Error::ApiError::RequestError => e
+              MultiJson.load(e.response.body.to_s).to_smash.get(:error, :message)
+            end
+          end
+
+          # Return all stacks
+          #
+          # @param options [Hash] filter
+          # @return [Array<Models::Orchestration::Stack>]
+          # @todo check if we need any mappings on state set
+          def stack_all(options={})
+            result = request(
+              :method => :get,
+              :path => '/terraform/stacks'
+            )
+            result.fetch(:body, :stacks, []).map do |s|
+              Stack.new(
+                self,
+                :id => s[:id],
+                :created => s[:creation_time].to_s.empty? ? nil : Time.at(s[:creation_time].to_i / 1000.0),
+                :description => s[:description],
+                :name => s[:name],
+                :state => s[:status].downcase.to_sym,
+                :status => s[:status],
+                :status_reason => s[:stack_status_reason],
+                :updated => s[:updated_time].to_s.empty? ? nil : Time.at(s[:updated_time].to_i / 1000.0)
+              ).valid_state
+            end
+          end
+
+          # Return all resources for stack
+          #
+          # @param stack [Models::Orchestration::Stack]
+          # @return [Array<Models::Orchestration::Stack::Resource>]
+          def resource_all(stack)
+            result = request(
+              :method => :get,
+              :path => "/terraform/resources/#{stack.name}"
+            )
+            result.fetch(:body, :resources, []).map do |resource|
+              Stack::Resource.new(
+                stack,
+                :id => resource[:physical_id],
+                :name => resource[:name],
+                :type => resource[:type],
+                :logical_id => resource[:name],
+                :state => resource[:status].downcase.to_sym,
+                :status => resource[:status],
+                :status_reason => resource[:resource_status_reason],
+                :updated => resource[:updated_time].to_s.empty? ? Time.now : Time.parse(resource[:updated_time])
+              ).valid_state
+            end
+          end
+
+          # Reload the stack resource data from the API
+          #
+          # @param resource [Models::Orchestration::Stack::Resource]
+          # @return [Models::Orchestration::Resource]
+          def resource_reload(resource)
+            resource.stack.resources.reload
+            resource.stack.resources.get(resource.id)
+          end
+
+          # Return all events for stack
+          #
+          # @param stack [Models::Orchestration::Stack]
+          # @return [Array<Models::Orchestration::Stack::Event>]
+          def event_all(stack, marker = nil)
+            params = marker ? {:marker => marker} : {}
+            result = request(
+              :path => "/terraform/events/#{stack.name}",
+              :method => :get,
+              :params => params
+            )
+            result.fetch(:body, :events, []).map do |event|
+              Stack::Event.new(
+                stack,
+                :id => event[:id],
+                :resource_id => event[:physical_resource_id],
+                :resource_name => event[:resource_name],
+                :resource_logical_id => event[:resource_name],
+                :resource_state => event[:resource_status].downcase.to_sym,
+                :resource_status => event[:resource_status],
+                :resource_status_reason => event[:resource_status_reason],
+                :time => Time.at(event[:timestamp] / 1000.0)
+              ).valid_state
+            end
+          end
+
+          # Return all new events for event collection
+          #
+          # @param events [Models::Orchestration::Stack::Events]
+          # @return [Array<Models::Orchestration::Stack::Event>]
+          def event_all_new(events)
+            event_all(events.stack, events.all.first.id)
+          end
+
+          # Reload the stack event data from the API
+          #
+          # @param resource [Models::Orchestration::Stack::Event]
+          # @return [Models::Orchestration::Event]
+          def event_reload(event)
+            event.stack.events.reload
+            event.stack.events.get(event.id)
+          end
+        end
+
+      end
+    end
+  end
+end

data/miasma-terraform.gemspec

@@ -0,0 +1,16 @@
+$LOAD_PATH.unshift File.expand_path(File.dirname(__FILE__)) + '/lib/'
+require 'miasma-terraform/version'
+Gem::Specification.new do |s|
+  s.name = 'miasma-terraform'
+  s.version = MiasmaTerraform::VERSION.version
+  s.summary = 'Smoggy Terraform API'
+  s.author = 'Chris Roberts'
+  s.email = 'code@chrisroberts.org'
+  s.homepage = 'https://github.com/miasma-rb/miasma-terraform'
+  s.description = 'Smoggy Terraform API'
+  s.license = 'Apache 2.0'
+  s.require_path = 'lib'
+  s.add_development_dependency 'pry'
+  s.add_development_dependency 'minitest'
+  s.files = Dir['lib/**/*'] + %w(miasma-terraform.gemspec README.md CHANGELOG.md LICENSE)
+end

metadata

@@ -0,0 +1,80 @@
+--- !ruby/object:Gem::Specification
+name: miasma-terraform
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Chris Roberts
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-01-08 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Smoggy Terraform API
+email: code@chrisroberts.org
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE
+- README.md
+- lib/miasma-terraform.rb
+- lib/miasma-terraform/stack.rb
+- lib/miasma-terraform/version.rb
+- lib/miasma/contrib/terraform.rb
+- lib/miasma/contrib/terraform/orchestration.rb
+- miasma-terraform.gemspec
+homepage: https://github.com/miasma-rb/miasma-terraform
+licenses:
+- Apache 2.0
+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.4.8
+signing_key: 
+specification_version: 4
+summary: Smoggy Terraform API
+test_files: []