terrafying 1.7.4 → 1.7.5

data/lib/terrafying/cli.rb

@@ -1,70 +1,72 @@
+# frozen_string_literal: true
+
 require 'thor'
 
 module Terrafying
   class Cli < Thor
-    class_option :lock_timeout, :type => :string, :default => nil
-    class_option :no_lock, :type => :boolean, :default => false
-    class_option :keep, :type => :boolean, :default => false
-    class_option :target, :type => :string, :default => nil
-    class_option :scope, :type => :string, :default => nil
-    class_option :dynamodb, :type => :boolean, :default => true
+    class_option :lock_timeout, type: :string, default: nil
+    class_option :no_lock, type: :boolean, default: false
+    class_option :keep, type: :boolean, default: false
+    class_option :target, type: :string, default: nil
+    class_option :scope, type: :string, default: nil
+    class_option :dynamodb, type: :boolean, default: true
 
-    desc "list PATH", "List resources defined"
+    desc 'list PATH', 'List resources defined'
     def list(path)
       puts "Defined resources:\n\n"
       Config.new(path, options).list.each do |name|
-        puts "#{name}"
+        puts name.to_s
       end
     end
 
-    desc "plan PATH", "Show execution plan"
+    desc 'plan PATH', 'Show execution plan'
     def plan(path)
       exit Config.new(path, options).plan
     end
 
-    desc "graph PATH", "Show execution graph"
+    desc 'graph PATH', 'Show execution graph'
     def graph(path)
       exit Config.new(path, options).graph
     end
 
-    desc "validate PATH", "Validate the generated Terraform"
+    desc 'validate PATH', 'Validate the generated Terraform'
     def validate(path)
       exit Config.new(path, options).validate
     end
 
-    desc "apply PATH", "Apply changes to resources"
-    option :force, :aliases => ['f'], :type => :boolean, :desc => "Forcefully remove any pending locks"
+    desc 'apply PATH', 'Apply changes to resources'
+    option :force, aliases: ['f'], type: :boolean, desc: 'Forcefully remove any pending locks'
     def apply(path)
       exit Config.new(path, options).apply
     end
 
-    desc "destroy PATH", "Destroy resources"
-    option :force, :aliases => ['f'], :type => :boolean, :desc => "Forcefully remove any pending locks"
+    desc 'destroy PATH', 'Destroy resources'
+    option :force, aliases: ['f'], type: :boolean, desc: 'Forcefully remove any pending locks'
     def destroy(path)
       exit Config.new(path, options).destroy
     end
 
-    desc "json PATH", "Show terraform JSON"
+    desc 'json PATH', 'Show terraform JSON'
     def json(path)
       puts(Config.new(path, options).json)
     end
 
-    desc "show-state PATH", "Show state"
+    desc 'show-state PATH', 'Show state'
     def show_state(path)
       puts(Config.new(path, options).show_state)
     end
 
-    desc "use-remote-state PATH", "Migrate to using remote state storage"
+    desc 'use-remote-state PATH', 'Migrate to using remote state storage'
     def use_remote_state(path)
       puts(Config.new(path, options).use_remote_state)
     end
 
-    desc "use-local-state PATH", "Migrate to using local state storage"
+    desc 'use-local-state PATH', 'Migrate to using local state storage'
     def use_local_state(path)
       puts(Config.new(path, options).use_local_state)
     end
 
-    desc "import PATH ADDR ID", "Import existing infrastructure into your Terraform state"
+    desc 'import PATH ADDR ID', 'Import existing infrastructure into your Terraform state'
     def import(path, addr, id)
       exit Config.new(path, options).import(addr, id)
     end

data/lib/terrafying/dynamodb/config.rb

@@ -1,17 +1,19 @@
+# frozen_string_literal: true
+
 module Terrafying
   module DynamoDb
     class Config
       attr_accessor :state_table, :lock_table
-      
+
       def initialize
-        @state_table = "terrafying-state"
-        @lock_table = "terrafying-state-lock"
+        @state_table = 'terrafying-state'
+        @lock_table = 'terrafying-state-lock'
       end
     end
-    
+
     def config
       @config ||= Config.new
     end
     module_function :config
   end
-end
+end

data/lib/terrafying/dynamodb/named_lock.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'terrafying/dynamodb'
 require 'terrafying/dynamodb/config'
 
@@ -12,18 +14,18 @@ module Terrafying
 
       def status
         @client.ensure_table(table) do
-          resp = @client.get_item({
+          resp = @client.get_item(
             table_name: @table_name,
             key: {
-              "name" => @name,
+              'name' => @name
             },
-            consistent_read: true,
-          })
+            consistent_read: true
+          )
           if resp.item
             return {
               status: :locked,
-              locked_at: resp.item["locked_at"],
-              metadata: resp.item["metadata"]
+              locked_at: resp.item['locked_at'],
+              metadata: resp.item['metadata']
             }
           else
             return {
@@ -32,92 +34,87 @@ module Terrafying
           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
+          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
 
       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
+          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
-      
+
       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
+          @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
 
       private
+
       def acquire_request(lock_id)
         {
           table_name: @table_name,
           key: {
-            "name" => @name,
+            '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)",
+          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})",
-            },
-          },
+            ':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",
-            },
+              attribute_name: 'name',
+              attribute_type: 'S'
+            }
           ],
           key_schema: [
             {
-              attribute_name: "name",
-              key_type: "HASH",
-            },
+              attribute_name: 'name',
+              key_type: 'HASH'
+            }
           ],
           provisioned_throughput: {
             read_capacity_units: 1,
-            write_capacity_units: 1,
+            write_capacity_units: 1
           }
         }
       end

data/lib/terrafying/dynamodb/state.rb

@@ -1,31 +1,33 @@
+# frozen_string_literal: true
+
 require 'digest'
 require 'terrafying/dynamodb/config'
 
 module Terrafying
   module DynamoDb
     class StateStore
-      def initialize(scope, opts = {})
+      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({
+          resp = @client.query(
             table_name: @table_name,
             limit: 1,
             key_conditions: {
-              "scope" => {
+              'scope' => {
                 attribute_value_list: [@scope],
-                comparison_operator: "EQ",
+                comparison_operator: 'EQ'
               }
             },
-            scan_index_forward: false,
-          })
+            scan_index_forward: false
+          )
           case resp.items.count
           when 0 then return nil
-          when 1 then return resp.items.first["state"]
+          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
@@ -35,58 +37,56 @@ module Terrafying
         @client.ensure_table(table) do
           sha256 = Digest::SHA256.hexdigest(state)
           json = JSON.parse(state)
-          @client.update_item({
+          @client.update_item(
             table_name: @table_name,
             key: {
-              "scope" => @scope,
-              "serial" => json["serial"].to_i,
+              '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",
+            return_values: 'NONE',
+            update_expression: 'SET sha256 = :sha256, #state = :state',
+            condition_expression: 'attribute_not_exists(serial) OR sha256 = :sha256',
             expression_attribute_names: {
-              "#state" => "state",
+              '#state' => 'state'
             },
             expression_attribute_values: {
-              ":sha256" => sha256,
-              ":state" => state,
+              ':sha256' => sha256,
+              ':state' => state
             }
-          })
+          )
         end
       end
-      
+
       def table
         {
           table_name: @table_name,
           attribute_definitions: [
             {
-              attribute_name: "scope",
-              attribute_type: "S",
+              attribute_name: 'scope',
+              attribute_type: 'S'
             },
             {
-              attribute_name: "serial",
-              attribute_type: "N",
+              attribute_name: 'serial',
+              attribute_type: 'N'
             }
           ],
           key_schema: [
             {
-              attribute_name: "scope",
-              key_type: "HASH",
+              attribute_name: 'scope',
+              key_type: 'HASH'
             },
             {
-              attribute_name: "serial",
-              key_type: "RANGE",
-            },
-            
+              attribute_name: 'serial',
+              key_type: 'RANGE'
+            }
+
           ],
           provisioned_throughput: {
             read_capacity_units: 1,
-            write_capacity_units: 1,
+            write_capacity_units: 1
           }
         }
       end
     end
   end
 end
-
-

data/lib/terrafying/dynamodb.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'aws-sdk-dynamodb'
 require 'json'
 require 'securerandom'
@@ -9,7 +11,7 @@ class ::Aws::DynamoDB::Client
     begin
       yield block
     rescue ::Aws::DynamoDB::Errors::ResourceNotFoundException => e
-      if not retried
+      if !retried
         create_table(table_spec)
         retry
       else
@@ -22,10 +24,10 @@ end
 module Terrafying
   module DynamoDb
     def self.client
-      @@client ||= ::Aws::DynamoDB::Client.new({
-        region: Terrafying::Context::REGION,
-        #endpoint: 'http://localhost:8000',
-      })
+      @@client ||= ::Aws::DynamoDB::Client.new(
+        region: Terrafying::Context::REGION
+        # endpoint: 'http://localhost:8000',
+      )
     end
   end
 end