terrafying-components 1.11.15 → 1.11.16

data/lib/terrafying/components/service.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 
 require 'digest'
 require 'hash/merge_with_arrays'
@@ -16,16 +17,13 @@ require 'terrafying/components/staticset'
 require 'terrafying/components/usable'
 
 module Terrafying
-
   module Components
-
     class Service < Terrafying::Context
-
       attr_reader :name, :zone, :domain_names, :ports, :instance_profile, :load_balancer, :instance_set
 
       include Usable
 
-      def self.create_in(vpc, name, options={})
+      def self.create_in(vpc, name, options = {})
         Service.new.create_in vpc, name, options
       end
 
@@ -33,18 +31,18 @@ module Terrafying
         Service.new.find_in vpc, name
       end
 
-      def initialize()
+      def initialize
         super
       end
 
-      def find_in(vpc, name)
+      def find_in(_vpc, _name)
         raise 'unimplemented'
       end
 
-      def create_in(vpc, name, options={})
+      def create_in(vpc, name, options = {})
         options = {
-          ami: aws.ami("base-image-24b8d5fb", owners=["136393635417"]),
-          instance_type: "t2.micro",
+          ami: aws.ami('base-image-24b8d5fb', owners = ['136393635417']),
+          instance_type: 't2.micro',
           ports: [],
           instances: [{}],
           zone: vpc.zone,
@@ -60,7 +58,7 @@ module Terrafying
           startup_grace_period: 300,
           depends_on: [],
           audit_role: "arn:aws:iam::#{aws.account_id}:role/auditd_logging",
-          metrics_ports: [],
+          metrics_ports: []
         }.merge(options)
 
         unless options[:audit_role].nil?
@@ -68,15 +66,15 @@ module Terrafying
           options = options.merge_with_arrays_merged(fluentd_conf)
         end
 
-        if ! options.has_key? :user_data
+        unless options.key? :user_data
           options[:user_data] = Ignition.generate(options)
         end
 
-        if ! options.has_key?(:loadbalancer_subnets)
+        unless options.key?(:loadbalancer_subnets)
           options[:loadbalancer_subnets] = options[:subnets]
         end
 
-        unless options[:instances].is_a?(Hash) or options[:instances].is_a?(Array)
+        unless options[:instances].is_a?(Hash) || options[:instances].is_a?(Array)
           raise 'Unknown instances option, should be hash or array'
         end
 
@@ -85,21 +83,21 @@ module Terrafying
         @name = ident
         @zone = options[:zone]
         @ports = enrich_ports(options[:ports])
-        @domain_names = [ options[:zone].qualify(name) ]
+        @domain_names = [options[:zone].qualify(name)]
 
-        depends_on = options[:depends_on] + options[:keypairs].map{ |kp| kp[:resources] }.flatten.compact
+        depends_on = options[:depends_on] + options[:keypairs].map { |kp| kp[:resources] }.flatten.compact
         if options.key? :instance_profile
           @instance_profile = options[:instance_profile]
         else
           iam_statements = options[:iam_policy_statements] + options[:keypairs].map { |kp| kp[:iam_statement] }.compact
-          @instance_profile = add! InstanceProfile.create(ident, { statements: iam_statements })
+          @instance_profile = add! InstanceProfile.create(ident, statements: iam_statements)
         end
 
-        tags = options[:tags].merge({ service_name: name })
+        tags = options[:tags].merge(service_name: name)
 
         set = options[:instances].is_a?(Hash) ? DynamicSet : StaticSet
 
-        if options.has_key?(:loadbalancer) # explicitly requested or rejected a loadbalancer
+        if options.key?(:loadbalancer) # explicitly requested or rejected a loadbalancer
           wants_load_balancer = options[:loadbalancer]
         else
           # by default we want one if we are an ASG with exposed ports
@@ -109,11 +107,11 @@ module Terrafying
         instance_set_options = {
           instance_profile: @instance_profile,
           depends_on: depends_on,
-          tags: tags,
+          tags: tags
         }
 
-        if wants_load_balancer && @ports.any? { |p| p.has_key?(:health_check) }
-          instance_set_options[:health_check] = { type: "ELB", grace_period: options[:startup_grace_period] }
+        if wants_load_balancer && @ports.any? { |p| p.key?(:health_check) }
+          instance_set_options[:health_check] = { type: 'ELB', grace_period: options[:startup_grace_period] }
         end
 
         @instance_set = add! set.create_in(vpc, name, options.merge(instance_set_options))
@@ -125,37 +123,33 @@ module Terrafying
 
         if wants_load_balancer
           @load_balancer = add! LoadBalancer.create_in(
-                                  vpc, name, options.merge(
-                                    {
-                                      subnets: options[:loadbalancer_subnets],
-                                      tags: tags,
-                                    }
-                                  ),
-                                )
+            vpc, name, options.merge(
+                         subnets: options[:loadbalancer_subnets],
+                         tags: tags
+                       )
+          )
 
           @load_balancer.attach(@instance_set)
 
-          if @load_balancer.type == "application"
+          if @load_balancer.type == 'application'
             @security_group = @load_balancer.security_group
             @egress_security_group = @instance_set.security_group
           end
 
           vpc.zone.add_alias_in(self, name, @load_balancer.alias_config)
         elsif set == StaticSet
-          vpc.zone.add_record_in(self, name, @instance_set.instances.map { |i| i.ip_address })
-          @instance_set.instances.each { |i|
+          vpc.zone.add_record_in(self, name, @instance_set.instances.map(&:ip_address))
+          @instance_set.instances.each do |i|
             @domain_names << vpc.zone.qualify(i.name)
             vpc.zone.add_record_in(self, i.name, [i.ip_address])
-          }
+          end
         end
 
         if set == DynamicSet && options[:rolling_update] == :signal
           @instance_profile.add_statement!(
-            {
-              Effect: "Allow",
-              Action: [ "cloudformation:SignalResource" ],
-              Resource: [ @instance_set.stack ],
-            }
+            Effect: 'Allow',
+            Action: ['cloudformation:SignalResource'],
+            Resource: [@instance_set.stack]
           )
         end
 
@@ -166,26 +160,22 @@ module Terrafying
         prom = Prometheus.find_in(vpc: vpc)
         ports.each do |port|
           sg_rule_ident = Digest::SHA256.hexdigest("#{vpc.name}-#{port}-#{security_group}-#{prom.security_group}")
-          resource :aws_security_group_rule, sg_rule_ident, {
-            security_group_id: security_group,
-            type: 'ingress',
-            from_port: port,
-            to_port: port,
-            protocol: 'tcp',
-            source_security_group_id: prom.security_group
-          }
+          resource :aws_security_group_rule, sg_rule_ident,
+                   security_group_id: security_group,
+                   type: 'ingress',
+                   from_port: port,
+                   to_port: port,
+                   protocol: 'tcp',
+                   source_security_group_id: prom.security_group
         end
       end
 
       def with_endpoint_service(options = {})
         add! EndpointService.create_for(@load_balancer, @name, {
-                                          fqdn: @domain_names[0],
-                                          zone: @zone,
-                                        }.merge(options))
+          fqdn: @domain_names[0],
+          zone: @zone
+        }.merge(options))
       end
-
     end
-
   end
-
 end

data/lib/terrafying/components/staticset.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 
 require 'xxhash'
 
@@ -7,16 +8,13 @@ require 'terrafying/components/usable'
 require_relative './ports'
 
 module Terrafying
-
   module Components
-
     class StaticSet < Terrafying::Context
-
       attr_reader :name, :instances
 
       include Usable
 
-      def self.create_in(vpc, name, options={})
+      def self.create_in(vpc, name, options = {})
         StaticSet.new.create_in vpc, name, options
       end
 
@@ -24,11 +22,11 @@ module Terrafying
         StaticSet.new.find_in vpc, name
       end
 
-      def initialize()
+      def initialize
         super
       end
 
-      def find_in(vpc, name)
+      def find_in(_vpc, name)
         @name = name
 
         raise 'unimplemented'
@@ -36,21 +34,21 @@ module Terrafying
         self
       end
 
-      def create_in(vpc, name, options={})
+      def create_in(vpc, name, options = {})
         options = {
           public: false,
-          ami: aws.ami("base-image-24b8d5fb", owners=["136393635417"]),
-          instance_type: "t2.micro",
+          ami: aws.ami('base-image-24b8d5fb', owners = ['136393635417']),
+          instance_type: 't2.micro',
           subnets: vpc.subnets.fetch(:private, []),
           ports: [],
           instances: [{}],
           instance_profile: nil,
           security_groups: [],
-          user_data: "",
+          user_data: '',
           tags: {},
           ssh_group: vpc.ssh_group,
           depends_on: [],
-          volumes: [],
+          volumes: []
         }.merge(options)
 
         ident = "#{tf_safe(vpc.name)}-#{name}"
@@ -58,12 +56,11 @@ module Terrafying
         @name = ident
         @ports = enrich_ports(options[:ports])
 
-        @security_group = resource :aws_security_group, ident, {
-          name: "staticset-#{ident}",
-          description: "Describe the ingress and egress of the static set #{ident}",
-          tags: options[:tags],
-          vpc_id: vpc.id,
-        }
+        @security_group = resource :aws_security_group, ident,
+                                   name: "staticset-#{ident}",
+                                   description: "Describe the ingress and egress of the static set #{ident}",
+                                   tags: options[:tags],
+                                   vpc_id: vpc.id
 
         default_egress_rule(ident, @security_group)
 
@@ -73,49 +70,47 @@ module Terrafying
           instance_ident = "#{name}-#{i}"
 
           instance = add! Instance.create_in(
-                               vpc, instance_ident, options.merge(
-                                 {
-                                   subnets: options[:subnets],
-                                   security_groups: [@security_group] + options[:security_groups],
-                                   depends_on: options[:depends_on],
-                                   instance_profile: options[:instance_profile],
-                                   tags: {
-                                     staticset_name: ident,
-                                   }.merge(options[:tags])
-                                 }.merge(config)
-                               )
-                             )
-
-          options[:volumes].each.with_index { |volume, vol_i|
+            vpc, instance_ident, options.merge(
+                                   {
+                                     subnets: options[:subnets],
+                                     security_groups: [@security_group] + options[:security_groups],
+                                     depends_on: options[:depends_on],
+                                     instance_profile: options[:instance_profile],
+                                     tags: {
+                                       staticset_name: ident
+                                     }.merge(options[:tags])
+                                   }.merge(config)
+                                 )
+          )
+
+          options[:volumes].each.with_index do |volume, vol_i|
             volume_for("#{instance_ident}-#{vol_i}", instance, volume, options[:tags])
-          }
+          end
 
           instance
         end
 
-        @ports.each { |port|
-          resource :aws_security_group_rule, "#{@name}-to-self-#{port[:name]}", {
-                     security_group_id: @security_group,
-                     type: "ingress",
-                     from_port: from_port(port[:upstream_port]),
-                     to_port: to_port(port[:upstream_port]),
-                     protocol: port[:type],
-                     self: true,
-                   }
-        }
+        @ports.each do |port|
+          resource :aws_security_group_rule, "#{@name}-to-self-#{port[:name]}",
+                   security_group_id: @security_group,
+                   type: 'ingress',
+                   from_port: from_port(port[:upstream_port]),
+                   to_port: to_port(port[:upstream_port]),
+                   protocol: port[:type],
+                   self: true
+        end
 
         self
       end
 
       def default_egress_rule(ident, security_group)
-        resource :aws_security_group_rule, "#{ident}-default-egress", {
-          security_group_id: security_group,
-          type: 'egress',
-          from_port: 0,
-          to_port: 0,
-          protocol: -1,
-          cidr_blocks: ['0.0.0.0/0'],
-        }
+        resource :aws_security_group_rule, "#{ident}-default-egress",
+                 security_group_id: security_group,
+                 type: 'egress',
+                 from_port: 0,
+                 to_port: 0,
+                 protocol: -1,
+                 cidr_blocks: ['0.0.0.0/0']
       end
 
       def volume_for(name, instance, volume, tags)
@@ -123,7 +118,7 @@ module Terrafying
           availability_zone: instance.subnet.az,
           size: volume[:size],
           type: volume[:type] || 'gp2',
-          encrypted:  volume[:encrypted] || false,
+          encrypted: volume[:encrypted] || false,
           kms_key_id: volume[:kms_key_id],
           tags: {
             Name: name
@@ -132,27 +127,22 @@ module Terrafying
 
         volume_id = resource :aws_ebs_volume, name, vol_opts
 
-        resource :aws_volume_attachment, name, {
-          device_name: volume[:device],
-          volume_id:   volume_id,
-          instance_id: instance.id,
-          force_detach: true
-        }
+        resource :aws_volume_attachment, name,
+                 device_name: volume[:device],
+                 volume_id: volume_id,
+                 instance_id: instance.id,
+                 force_detach: true
       end
 
       def attach_load_balancer(load_balancer)
-        @instances.product(load_balancer.targets).each.with_index { |(instance, target), i|
-          resource :aws_lb_target_group_attachment, "#{load_balancer.name}-#{@name}-#{i}", {
-                     target_group_arn: target.target_group,
-                     target_id: instance.id,
-                   }
-        }
-
-        self.used_by(load_balancer) if load_balancer.type == "application"
-      end
+        @instances.product(load_balancer.targets).each.with_index do |(instance, target), i|
+          resource :aws_lb_target_group_attachment, "#{load_balancer.name}-#{@name}-#{i}",
+                   target_group_arn: target.target_group,
+                   target_id: instance.id
+        end
 
+        used_by(load_balancer) if load_balancer.type == 'application'
+      end
     end
-
   end
-
 end

data/lib/terrafying/components/subnet.rb

@@ -1,19 +1,17 @@
+# frozen_string_literal: true
 
 require 'netaddr'
 
 require 'terrafying/generator'
 
 module Terrafying
-
   module Components
-
     CIDR_PADDING = 5
 
     class Subnet < Terrafying::Context
-
       attr_reader :id, :cidr, :az, :public, :route_table
 
-      def self.create_in(vpc, name, az, cidr, options={})
+      def self.create_in(vpc, name, az, cidr, options = {})
         Subnet.new.create_in vpc, name, az, cidr, options
       end
 
@@ -21,7 +19,7 @@ module Terrafying
         Subnet.new.find(id)
       end
 
-      def initialize()
+      def initialize
         super
       end
 
@@ -34,39 +32,35 @@ module Terrafying
 
         begin
           route_table = aws.route_table_for_subnet(id)
-        rescue
+        rescue StandardError
           # fallback to main route table if ones not explicitly associated
           route_table = aws.route_table_for_vpc(subnet.vpc_id)
         end
 
         @route_table = route_table.route_table_id
-        @public = route_table.routes.select { |r| r.destination_cidr_block == "0.0.0.0/0" }.first.gateway_id != nil
+        @public = route_table.routes.select { |r| r.destination_cidr_block == '0.0.0.0/0' }.first.gateway_id != nil
 
         self
       end
 
-      def create_in(vpc, name, az, cidr, options={})
+      def create_in(vpc, name, az, cidr, options = {})
         options = {
-          tags: {},
+          tags: {}
         }.merge(options)
 
         ident = "#{tf_safe(vpc.name)}-#{name}-#{az}"
 
         @cidr = cidr
         @az = az
-        @id = resource :aws_subnet, ident, {
-                         vpc_id: vpc.id,
-                         cidr_block: cidr,
-                         availability_zone: az,
-                         tags: { Name: ident }.merge(options[:tags]),
-                       }
-
-        @route_table = resource :aws_route_table, ident, {
-                                  vpc_id: vpc.id,
-                                  tags: { Name: ident }.merge(options[:tags]),
-                                }
-
+        @id = resource :aws_subnet, ident,
+                       vpc_id: vpc.id,
+                       cidr_block: cidr,
+                       availability_zone: az,
+                       tags: { Name: ident }.merge(options[:tags])
 
+        @route_table = resource :aws_route_table, ident,
+                                vpc_id: vpc.id,
+                                tags: { Name: ident }.merge(options[:tags])
 
         if options[:nat_gateway]
           gateway = { nat_gateway_id: options[:nat_gateway] }
@@ -81,15 +75,14 @@ module Terrafying
 
         if gateway
           resource :aws_route, "#{ident}-default", {
-                     route_table_id: @route_table,
-                     destination_cidr_block: "0.0.0.0/0",
-                   }.merge(gateway)
+            route_table_id: @route_table,
+            destination_cidr_block: '0.0.0.0/0'
+          }.merge(gateway)
         end
 
-        resource :aws_route_table_association, ident, {
-                   subnet_id: @id,
-                   route_table_id: @route_table,
-                 }
+        resource :aws_route_table_association, ident,
+                 subnet_id: @id,
+                 route_table_id: @route_table
 
         self
       end
@@ -97,9 +90,6 @@ module Terrafying
       def ip_addresses
         NetAddr::CIDR.create(@cidr).enumerate.drop(CIDR_PADDING)
       end
-
     end
-
   end
-
 end