terrafying 0.0.0

data/lib/terrafying/dynamodb/named_lock.rb

@@ -0,0 +1,126 @@
+require 'terrafying/dynamodb'
+require 'terrafying/dynamodb/config'
+
+module Terrafying
+  module DynamoDb
+    class NamedLock
+      def initialize(table_name, name)
+        @table_name = table_name
+        @name = name
+        @client = Terrafying::DynamoDb.client
+      end
+
+      def status
+        @client.ensure_table(table) do
+          resp = @client.get_item({
+            table_name: @table_name,
+            key: {
+              "name" => @name,
+            },
+            consistent_read: true,
+          })
+          if resp.item
+            return {
+              status: :locked,
+              locked_at: resp.item["locked_at"],
+              metadata: resp.item["metadata"]
+            }
+          else
+            return {
+              status: :unlocked
+            }
+          end
+        end
+      end
+      
+      def acquire
+        @client.ensure_table(table) do
+          begin
+            lock_id = SecureRandom.uuid
+            @client.update_item(acquire_request(lock_id))
+            return lock_id
+          rescue ::Aws::DynamoDB::Errors::ConditionalCheckFailedException
+            raise "Unable to acquire lock: #{status.inspect}" # TODO
+          end
+        end
+      end
+
+      def steal
+        @client.ensure_table(table) do
+          begin
+            lock_id = SecureRandom.uuid
+            req = acquire_request(lock_id)
+            req.delete(:condition_expression)
+            @client.update_item(req)
+            return lock_id
+          rescue ::Aws::DynamoDB::Errors::ConditionalCheckFailedException
+            raise "Unable to steal lock: #{status.inspect}" # TODO
+          end
+        end
+      end
+      
+      def release(lock_id)
+        @client.ensure_table(table) do
+          begin
+            @client.delete_item({
+              table_name: @table_name,
+              key: {
+                "name" => @name,
+              },
+              return_values: "NONE",
+              condition_expression: "lock_id = :lock_id",
+              expression_attribute_values: {
+                ":lock_id" => lock_id,
+              },
+            })
+            nil
+          rescue ::Aws::DynamoDB::Errors::ConditionalCheckFailedException
+            raise "Unable to release lock: #{status.inspect}" # TODO
+          end
+        end
+      end
+
+      private
+      def acquire_request(lock_id)
+        {
+          table_name: @table_name,
+          key: {
+            "name" => @name,
+          },
+          return_values: "NONE",
+          update_expression: "SET lock_id = :lock_id, locked_at = :locked_at, metadata = :metadata",
+          condition_expression: "attribute_not_exists(lock_id)",
+          expression_attribute_values: {
+            ":lock_id" => lock_id,
+            ":locked_at" => Time.now.to_s,
+            ":metadata" => {
+              "owner" => "#{`git config user.name`.chomp} (#{`git config user.email`.chomp})",
+            },
+          },
+        }
+      end
+      
+      def table
+        {
+          table_name: @table_name,
+          attribute_definitions: [
+            {
+              attribute_name: "name",
+              attribute_type: "S",
+            },
+          ],
+          key_schema: [
+            {
+              attribute_name: "name",
+              key_type: "HASH",
+            },
+          ],
+          provisioned_throughput: {
+            read_capacity_units: 1,
+            write_capacity_units: 1,
+          }
+        }
+      end
+    end
+  end
+end

data/lib/terrafying/dynamodb/state.rb

@@ -0,0 +1,92 @@
+require 'digest'
+require 'terrafying/dynamodb/config'
+
+module Terrafying
+  module DynamoDb
+    class StateStore
+      def initialize(scope, opts = {})
+        @scope = scope
+        @client = Terrafying::DynamoDb.client
+        @table_name = Terrafying::DynamoDb.config.state_table
+      end
+      
+      def get
+        @client.ensure_table(table) do
+          resp = @client.query({
+            table_name: @table_name,
+            limit: 1,
+            key_conditions: {
+              "scope" => {
+                attribute_value_list: [@scope],
+                comparison_operator: "EQ",
+              }
+            },
+            scan_index_forward: false,
+          })
+          case resp.items.count
+          when 0 then return nil
+          when 1 then return resp.items.first["state"]
+          else raise 'More than one item found when retrieving state. This is a bug and should never happen.' if resp.items.count != 1
+          end
+        end
+      end
+
+      def put(state)
+        @client.ensure_table(table) do
+          sha256 = Digest::SHA256.hexdigest(state)
+          json = JSON.parse(state)
+          @client.update_item({
+            table_name: @table_name,
+            key: {
+              "scope" => @scope,
+              "serial" => json["serial"].to_i,
+            },
+            return_values: "NONE",
+            update_expression: "SET sha256 = :sha256, #state = :state",
+            condition_expression: "attribute_not_exists(serial) OR sha256 = :sha256",
+            expression_attribute_names: {
+              "#state" => "state",
+            },
+            expression_attribute_values: {
+              ":sha256" => sha256,
+              ":state" => state,
+            }
+          })
+        end
+      end
+      
+      def table
+        {
+          table_name: @table_name,
+          attribute_definitions: [
+            {
+              attribute_name: "scope",
+              attribute_type: "S",
+            },
+            {
+              attribute_name: "serial",
+              attribute_type: "N",
+            }
+          ],
+          key_schema: [
+            {
+              attribute_name: "scope",
+              key_type: "HASH",
+            },
+            {
+              attribute_name: "serial",
+              key_type: "RANGE",
+            },
+            
+          ],
+          provisioned_throughput: {
+            read_capacity_units: 1,
+            write_capacity_units: 1,
+          }
+        }
+      end
+    end
+  end
+end
+
+

data/lib/terrafying/dynamodb.rb

@@ -0,0 +1,31 @@
+require 'aws-sdk'
+require 'json'
+require 'securerandom'
+
+# oh rubby
+class ::Aws::DynamoDB::Client
+  def ensure_table(table_spec, &block)
+    retried = false
+    begin
+      yield block
+    rescue ::Aws::DynamoDB::Errors::ResourceNotFoundException => e
+      if not retried
+        create_table(table_spec)
+        retry
+      else
+        raise e
+      end
+    end
+  end
+end
+
+module Terrafying
+  module DynamoDb
+    def self.client
+      @@client ||= ::Aws::DynamoDB::Client.new({
+        region: Terrafying::Context::REGION,
+        #endpoint: 'http://localhost:8000',
+      })
+    end
+  end
+end

data/lib/terrafying/generator.rb

@@ -0,0 +1,166 @@
+require 'json'
+require 'base64'
+require 'erb'
+require 'ostruct'
+require 'deep_merge'
+require 'terrafying/aws'
+
+module Terrafying
+
+  class Ref
+
+    def initialize(var)
+      @var = var
+    end
+
+    def downcase
+      Ref.new("lower(#{@var})")
+    end
+
+    def strip
+      Ref.new("trimspace(#{@var})")
+    end
+
+    def to_s
+      "${#{@var}}"
+    end
+
+    def to_str
+      self.to_s
+    end
+
+    def <=>(other)
+      self.to_s <=> other.to_s
+    end
+
+    def ==(other)
+      self.to_s == other.to_s
+    end
+
+  end
+
+  class Context
+
+    REGION = ENV.fetch("AWS_REGION", "eu-west-1")
+
+    PROVIDER_DEFAULTS = {
+      aws: { region: REGION }
+    }
+
+    attr_reader :output
+
+    def initialize
+      @output = {
+        "resource" => {}
+      }
+      @children = []
+    end
+
+    def aws
+      @@aws ||= Terrafying::Aws::Ops.new REGION
+    end
+
+    def provider(name, spec)
+      @output["provider"] ||= {}
+      @output["provider"][name] = spec
+    end
+
+    def data(type, name, spec)
+      @output["data"] ||= {}
+      @output["data"][type.to_s] ||= {}
+      @output["data"][type.to_s][name.to_s] = spec
+      id_of(type, name)
+    end
+
+    def resource(type, name, attributes)
+      @output["resource"][type.to_s] ||= {}
+      @output["resource"][type.to_s][name.to_s] = attributes
+      id_of(type, name)
+    end
+
+    def template(relative_path, params = {})
+      dir = caller_locations[0].path
+      filename = File.join(File.dirname(dir), relative_path)
+      erb = ERB.new(IO.read(filename))
+      erb.filename = filename
+      erb.result(OpenStruct.new(params).instance_eval { binding })
+    end
+
+    def output_with_children
+      @children.inject(@output) { |out, c| out.deep_merge(c.output_with_children) }
+    end
+
+    def id_of(type,name)
+      output_of(type, name, "id")
+    end
+
+    def output_of(type, name, value)
+      Ref.new("#{type}.#{name}.#{value}")
+    end
+
+    def pretty_generate
+      JSON.pretty_generate(output_with_children)
+    end
+
+    def resource_names
+      out = output_with_children
+      ret = []
+      for type in out["resource"].keys
+        for id in out["resource"][type].keys
+          ret << "#{type}.#{id}"
+        end
+      end
+      ret
+    end
+
+    def resources
+      out = output_with_children
+      ret = []
+      for type in out["resource"].keys
+        for id in out["resource"][type].keys
+          ret << "${#{type}.#{id}.id}"
+        end
+      end
+      ret
+    end
+
+    def add!(*c)
+      @children.push(*c)
+      c[0]
+    end
+
+    def tf_safe(str)
+      str.gsub(/[\.\s\/\?]/, "-")
+    end
+
+  end
+
+  class RootContext < Context
+
+    def initialize
+      super
+
+      output["provider"] = PROVIDER_DEFAULTS
+    end
+
+    def backend(name, spec)
+      @output["terraform"] = {
+        backend: {
+          name => spec,
+        },
+      }
+    end
+
+    def generate(&block)
+      instance_eval(&block)
+    end
+
+    def method_missing(fn, *args)
+      resource(fn, args.shift.to_s, args.first)
+    end
+
+  end
+
+  Generator = RootContext.new
+
+end

data/lib/terrafying/lock.rb

@@ -0,0 +1,25 @@
+require 'terrafying/dynamodb/named_lock'
+
+module Terrafying
+  module Locks
+    class NoOpLock
+      def acquire
+        ""
+      end
+      def steal
+        ""
+      end
+      def release(lock_id)
+      end
+    end
+
+    def self.noop
+      NoOpLock.new
+    end
+
+    def self.dynamodb(scope)
+      Terrafying::DynamoDb::NamedLock.new(Terrafying::DynamoDb.config.lock_table, scope)
+    end
+
+  end
+end

data/lib/terrafying/state.rb

@@ -0,0 +1,51 @@
+require 'terrafying/dynamodb/state'
+
+module Terrafying
+  module State
+
+    STATE_FILENAME = "terraform.tfstate"
+
+    def self.store(config)
+      if LocalStateStore.has_local_state?(config)
+        local(config)
+      else
+        remote(config)
+      end
+    end
+
+    def self.local(config)
+      LocalStateStore.new(config.path)
+    end
+
+    def self.remote(config)
+      Terrafying::DynamoDb::StateStore.new(config.scope)
+    end
+    
+    class LocalStateStore
+      def initialize(path)
+        @path = LocalStateStore.state_path(path)
+      end
+
+      def get
+        IO.read(@path)
+      end
+
+      def put(state)
+        IO.write(@path, state)
+      end
+
+      def delete
+        File.delete(@path)
+      end
+
+      def self.has_local_state?(config)
+        File.exists?(state_path(config.path))
+      end
+      
+      private
+      def self.state_path(path)
+        File.join(File.dirname(path), STATE_FILENAME)
+      end
+    end
+  end
+end

data/lib/terrafying/util.rb

@@ -0,0 +1,32 @@
+
+require 'yaml'
+
+def data_url_from_string(str)
+  b64_contents = Base64.strict_encode64(str)
+  return "data:;base64,#{b64_contents}"
+end
+
+module Terrafying
+
+  module Util
+
+    def self.to_ignition(yaml)
+      config = YAML.load(yaml)
+
+      if config.has_key? "storage" and config["storage"].has_key? "files"
+        files = config["storage"]["files"]
+        config["storage"]["files"] = files.each { |file|
+          if file["contents"].is_a? String
+            file["contents"] = {
+              source: data_url_from_string(file["contents"]),
+            }
+          end
+        }
+      end
+
+      JSON.pretty_generate(config)
+    end
+
+  end
+
+end

data/lib/terrafying/version.rb

@@ -0,0 +1,4 @@
+module Terrafying
+  VERSION = "0.0.0" # will be inserted by Drone
+  CLI_VERSION = "0.11.3"
+end