covalence 0.0.1 → 0.7.9.rc1

data/lib/covalence/core/state_stores/atlas.rb

@@ -0,0 +1,157 @@
+require 'json'
+require 'rest-client'
+
+module Covalence
+  module Atlas
+    AtlasTokenMissing = Class.new(StandardError)
+
+    # Default base URL for Atlas.
+    URL = "https://atlas.hashicorp.com"
+
+    def self.reset_cache()
+      @cache = Hash.new{|h,k| h[k] = Hash.new{|h,k| h[k] = Hash.new{|h,k| h[k] = Hash.new}}}
+    end
+
+    reset_cache
+
+    def self.get_artifact(slug, version, key, metadata: {})
+      ensure_atlas_token_set
+
+      @cache[slug][version][key][metadata] ||= begin
+        # Create and execute HTTP request
+        request = "#{URL}/api/v1/artifacts/#{slug}/search"
+
+        params = {}
+        params[:version] = version
+        if !metadata.empty?
+          i = 1
+          metadata.map do |k,v|
+            params["metadata.#{i}.key"] = k
+            params["metadata.#{i}.value"] = v
+            i += 1
+          end
+        end
+
+        headers = {:'X-Atlas-Token' => ENV['ATLAS_TOKEN']}
+        headers = headers.merge({:params => params})
+
+        begin
+          response = RestClient.get request, headers
+        rescue RestClient::ExceptionWithResponse => err
+          fail "Unable to retrieve ID for artifact '#{slug}': " + err.message
+        end
+
+        # Parse JSON response
+        parsed = JSON.parse(response)
+        latest = parsed["versions"].select {|version| version['metadata'].keys.include? "#{key}" }.first
+
+        # Return ID for the region specified
+        if latest != nil
+          latest["metadata"]["#{key}"]
+        else
+          fail "Requested key '#{key}' not found"
+        end
+      end
+    end
+
+    def self.get_output(name, stack)
+      ensure_atlas_token_set
+
+      @cache[stack][name][0][0] || begin
+        # Create and execute HTTP request
+        request = "#{URL}/api/v1/terraform/state/#{stack}"
+        headers = {:'X-Atlas-Token' => ENV['ATLAS_TOKEN']}
+
+        begin
+          response = RestClient.get request, headers
+        rescue RestClient::ExceptionWithResponse => err
+          fail "Unable to retrieve output '#{name}' from stack '#{stack}': " + err.message
+        end
+
+        # Parse JSON response
+        parsed = JSON.parse(response)
+        outputs = parsed.fetch("modules")[0].fetch("outputs")
+
+        # Populate the cache for subsequent calls
+        outputs.keys.each do |key|
+          @cache[stack][key][0][0] = outputs.fetch(key)
+        end
+
+        # Check outputs for requested key and return
+        if outputs.has_key?(name)
+          @cache[stack][name][0][0]
+        else
+          fail("Requested output '#{name}' not found")
+        end
+      end
+    end
+
+    def self.get_state_store(params, workspace_enabled=false)
+      raise "State store parameters must be a Hash" unless params.is_a?(Hash)
+      raise "Missing 'name' store parameter" unless params.has_key? 'name'
+
+      config = <<-CONF
+terraform {
+  backend "atlas" {
+    name = "#{params['name']}"
+  }
+}
+CONF
+
+      return config
+    end
+
+    def self.ensure_atlas_token_set
+      raise AtlasTokenMissing.new("Missing ATLAS_TOKEN environment variable") unless ENV.key? 'ATLAS_TOKEN'
+    end
+
+    # Return module capabilities
+    # TODO: maybe a state_store mixin later
+    #def self.has_key_read?
+      #return true
+    #end
+
+    #def self.has_key_write?
+      #return false
+    #end
+
+    #def self.has_state_read?
+      #return true
+    #end
+
+    def self.has_state_store?
+      return true
+    end
+
+    # Key lookups
+    def self.lookup(type, params)
+      raise "Lookup parameters must be a Hash" unless params.is_a?(Hash)
+
+      case
+      when type == 'artifact'
+        required_params = [
+          'slug',
+          'version',
+          'key',
+        ]
+        required_params.each do |param|
+          raise "Missing '#{param}' lookup parameter" unless params.has_key?(param)
+        end
+        metadata = {}
+        metadata = params['metadata'] unless !params['metadata']
+        self.get_artifact(params['slug'],params['version'],params['key'], metadata: metadata)
+      when type == 'state'
+        required_params = [
+          'key',
+          'stack'
+        ]
+        required_params.each do |param|
+          raise "Missing '#{param}' lookup parameter" unless params.has_key?(param)
+        end
+        self.get_output(params['key'],params['stack'])
+      else
+        raise "Atlas module does not support the '#{type}' lookup type"
+      end
+    end
+  end
+end

data/lib/covalence/core/state_stores/consul.rb

@@ -0,0 +1,153 @@
+require 'json'
+require 'rest-client'
+require 'base64'
+
+require_relative '../../helpers/shell_interpolation'
+
+module Covalence
+  module Consul
+
+    ##### Consul ennvironment variables #####
+    #
+    # CONSUL_HTTP_ADDR - DNS name and port of your Consul endpoint specified in the format dnsname:port.
+    #                    Defaults to the local agent HTTP listener.
+    # CONSUL_HTTP_SSL  - Specifies what protocol to use when talking to the given address, either http or https.
+    # CONSUL_HTTP_AUTH - HTTP Basic Authentication credentials to be used when communicating with Consul,
+    #                    in the format of either user or user:pass.
+    # CONSUL_HTTP_TOKEN - HTTP authentication token.
+
+    URL = ENV['CONSUL_HTTP_ADDR'] || 'localhost:8500'
+
+    def self.reset_cache()
+      @cache = Hash.new{|h,k| h[k] = Hash.new}
+    end
+
+    reset_cache
+
+    def self.get_key(name)
+
+      @cache['root'][name] ||= begin
+        # Create and execute HTTP request
+        request = "#{URL}/v1/kv/#{name}"
+
+        # Configure request headers
+        headers = {}
+        headers['X-Consul-Token'] = ENV['CONSUL_HTTP_TOKEN'] if ENV.has_key? 'CONSUL_HTTP_TOKEN'
+
+        begin
+          response = RestClient.get request, headers
+        rescue RestClient::ExceptionWithResponse => err
+          fail "Unable to retrieve key '#{name}': " + err.message
+        end
+
+        # Parse JSON response
+        begin
+          parsed = JSON.parse(response)
+          encoded = parsed.first['Value']
+        rescue JSON::ParserError => err
+          fail "No results or unable to parse response: " + err.message
+        end
+
+        # Return decoded value
+        if encoded != nil
+          Base64.decode64(encoded)
+        else
+          # TODO: not sure if this is the right failure to raise
+          fail "Requested key '#{name}' not found"
+        end
+      end
+    end
+
+    def self.get_output(name, stack)
+
+      @cache[stack][name] || begin
+        # Retrieve stack state
+        value = self.get_key(stack)
+
+        # Parse JSON
+        parsed = JSON.parse(value)
+        outputs = parsed.fetch("modules")[0].fetch("outputs")
+
+        # Populate the cache for subsequent calls
+        outputs.keys.each do |key|
+          @cache[stack][key] = outputs.fetch(key)
+        end
+
+        # Check outputs for requested key and return
+        if outputs.has_key?(name)
+          @cache[stack][name]
+        else
+          fail("Requested output '#{name}' not found")
+        end
+      end
+    end
+
+    # Return configuration for remote state store.
+    def self.get_state_store(params, workspace_enabled=false)
+      raise "State store parameters must be a Hash" unless params.is_a?(Hash)
+      required_params = [
+        'access_token',
+        'name'
+      ]
+      required_params.each do |param|
+        raise "Missing '#{param}' store parameter" unless params.has_key?(param)
+      end
+
+      config = <<-CONF
+terraform {
+  backend "consul" {
+    path = "#{params['name']}"
+CONF
+
+      params.delete('name')
+      params.each do |k,v|
+        v = Covalence::Helpers::ShellInterpolation.parse_shell(v) if v.include?("$(")
+        config += "    #{k} = \"#{v}\"\n"
+      end
+
+      config += "  }\n}\n"
+
+      return config
+    end
+
+    # Return module capabilities
+    # TODO: maybe a state_store mixin later
+    #def self.has_key_read?
+      #return true
+    #end
+
+    #def self.has_key_write?
+      #return false
+    #end
+
+    #def self.has_state_read?
+      #return true
+    #end
+
+    def self.has_state_store?
+      return true
+    end
+
+    # Key lookups
+    def self.lookup(type, params)
+      raise "Lookup parameters must be a Hash" unless params.is_a?(Hash)
+
+      case
+      when type == 'key'
+        raise "Missing 'key' lookup parameter" unless params.has_key? 'key'
+        self.get_key(params['key'])
+      when type == 'state'
+        required_params = [
+          'key',
+          'stack'
+        ]
+        required_params.each do |param|
+          raise "Missing '#{param}' lookup parameter" unless params.has_key?(param)
+        end
+        self.get_output(params['key'],params['stack'])
+      else
+        raise "Consul module does not support the '#{type}' lookup type"
+      end
+    end
+  end
+end

data/lib/covalence/core/state_stores/s3.rb

@@ -0,0 +1,147 @@
+require 'json'
+require 'aws-sdk-s3'
+
+require_relative '../../helpers/shell_interpolation'
+
+module Covalence
+  module S3
+
+    ##### AWS ennvironment variables #####
+    #
+    # AWS_ACCESS_KEY_ID – AWS access key.
+    # AWS_SECRET_ACCESS_KEY – AWS secret key. Access and secret key variables override
+    #                         credentials stored in credential and config files.
+    # AWS_REGION – AWS region. This variable overrides the default region of the in-use
+    #              profile, if set.
+
+    REGION = ENV['AWS_REGION']
+
+    class Client
+      def initialize(region: REGION)
+        @s3 = Aws::S3::Client.new(region: region)
+        self.reset_cache
+      end
+
+      def reset_cache
+        @cache = Hash.new{|h,k| h[k] = Hash.new}
+      end
+
+      def get_cache
+        @cache.to_s
+      end
+
+      def get_doc(bucket, document)
+        @cache[bucket][document] ||= begin
+          @s3.get_object(bucket: bucket, key: document).body.read
+        rescue Aws::S3::Errors::ServiceError => err
+          fail "Unable to retrieve document '#{document}' from bucket '#{bucket}': " + err.message
+        end
+      end
+
+      def get_key(bucket, document, name)
+        doc = self.get_doc(bucket, document)
+
+        # Parse JSON response
+        begin
+          parsed = JSON.parse(doc)
+        rescue JSON::ParserError => err
+          fail "No results or unable to parse document '#{document}': " + err.message
+        end
+
+        # Determine whether the document is a Terraform state file
+        tf_state = true if parsed.has_key?('modules')
+
+        # Return ID for the key specified
+        if tf_state
+          outputs = parsed.fetch('modules')[0].fetch('outputs')
+          return outputs.fetch(name)
+        end
+        return parsed.fetch(name) if parsed.has_key?(name)
+        fail "Requested key '#{name}' not found"
+      end
+    end
+
+    # Return configuration for remote state store.
+    def self.get_state_store(params, workspace_enabled=false)
+      raise "State store parameters must be a Hash" unless params.is_a?(Hash)
+      required_params = [
+        'bucket',
+        'name'
+      ]
+      required_params.each do |param|
+        raise "Missing '#{param}' store parameter" unless params.has_key?(param)
+      end
+
+      config = <<-CONF
+terraform {
+  backend "s3" {
+CONF
+
+      if !params.has_key?('key')
+        Covalence::LOGGER.debug "'key' parameter not specified. Inferring value from 'name' parameter."
+
+        if workspace_enabled
+          config += "    key = \"terraform.tfstate\"\n"
+        else
+          config += "    key = \"#{params['name']}/terraform.tfstate\"\n"
+        end
+      end
+
+      if !params.has_key?('workspace_key_prefix')
+        if workspace_enabled
+          Covalence::LOGGER.debug "'workspace_key_prefix' parameter not specified. Inferring value from 'name' parameter."
+          config += "    workspace_key_prefix = \"#{params['name']}\"\n"
+        end
+      end
+
+      params.delete('name')
+
+      params.each do |k,v|
+        v = Covalence::Helpers::ShellInterpolation.parse_shell(v) if v.to_s.include?("$(")
+        config += "    #{k} = \"#{v}\"\n"
+      end
+
+      config += "  }\n}\n"
+
+      return config
+    end
+
+    # Return module capabilities
+    # TODO: maybe a state_store mixin later
+    #def self.has_key_read?
+      #return true
+    #end
+
+    #def self.has_key_write?
+      #return false
+    #end
+
+    #def self.has_state_read?
+      #return true
+    #end
+
+    def self.has_state_store?
+      return true
+    end
+
+    # Key lookups
+    def self.lookup(type, params)
+      raise "Lookup parameters must be a Hash" unless params.is_a?(Hash)
+
+      case
+      when type == 'key' || type == 'state'
+        required_params = [
+          'bucket',
+          'document',
+          'key'
+        ]
+        required_params.each do |param|
+          raise "Missing '#{param}' lookup parameter" unless params.has_key?(param)
+        end
+        raise "Missing 'key' lookup parameter" unless params.has_key? 'key'
+        client = S3::Client.new(region: REGION)
+        client.get_key(params['bucket'],params['document'],params['key'])
+      end
+    end
+  end
+end