terrafying 0.0.1 → 1.1.4

data/lib/terrafying/dynamodb/named_lock.rb

@@ -1,126 +0,0 @@
-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

@@ -1,92 +0,0 @@
-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

@@ -1,31 +0,0 @@
-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

@@ -1,166 +0,0 @@
-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

@@ -1,25 +0,0 @@
-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

@@ -1,51 +0,0 @@
-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

@@ -1,32 +0,0 @@
-
-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

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