terrafying-components 1.11.15 → 1.11.16

data/lib/terrafying/components/instanceprofile.rb

@@ -1,13 +1,11 @@
+# frozen_string_literal: true
 
 module Terrafying
-
   module Components
-
     class InstanceProfile < Terrafying::Context
-
       attr_reader :id, :resource_name, :role_arn, :role_resource
 
-      def self.create(name, options={})
+      def self.create(name, options = {})
         InstanceProfile.new.create name, options
       end
 
@@ -15,39 +13,35 @@ module Terrafying
         InstanceProfile.new.find name
       end
 
-      def initialize()
+      def initialize
         super
       end
 
-      def find(name)
+      def find(_name)
         raise 'unimplemented'
       end
 
-      def create(name, options={})
+      def create(name, options = {})
         options = {
-          statements: [],
+          statements: []
         }.merge(options)
 
-        resource :aws_iam_role, name, {
-                   name: name,
-                   assume_role_policy: JSON.pretty_generate(
+        resource :aws_iam_role, name,
+                 name: name,
+                 assume_role_policy: JSON.pretty_generate(
+                   Version: '2012-10-17',
+                   Statement: [
                      {
-                       Version: "2012-10-17",
-                       Statement: [
-                         {
-                           Effect: "Allow",
-                           Principal: { "Service": "ec2.amazonaws.com"},
-                           Action: "sts:AssumeRole"
-                         }
-                       ]
+                       Effect: 'Allow',
+                       Principal: { "Service": 'ec2.amazonaws.com' },
+                       Action: 'sts:AssumeRole'
                      }
-                   )
-                 }
+                   ]
+                 )
 
-        @id = resource :aws_iam_instance_profile, name, {
-                         name: name,
-                         role: output_of(:aws_iam_role, name, :name),
-                       }
+        @id = resource :aws_iam_instance_profile, name,
+                       name: name,
+                       role: output_of(:aws_iam_role, name, :name)
         @name = name
         @resource_name = "aws_iam_instance_profile.#{name}"
 
@@ -55,25 +49,25 @@ module Terrafying
         @role_resource = "aws_iam_role.#{name}"
 
         @statements = [
-                         {
-                           Sid: "Stmt1442396947000",
-                           Effect: "Allow",
-                           Action: [
-                             "iam:GetGroup",
-                             "iam:GetSSHPublicKey",
-                             "iam:GetUser",
-                             "iam:ListSSHPublicKeys"
-                           ],
-                           Resource: [
-                             "arn:aws:iam::*"
-                           ]
-                         }
+          {
+            Sid: 'Stmt1442396947000',
+            Effect: 'Allow',
+            Action: [
+              'iam:GetGroup',
+              'iam:GetSSHPublicKey',
+              'iam:GetUser',
+              'iam:ListSSHPublicKeys'
+            ],
+            Resource: [
+              'arn:aws:iam::*'
+            ]
+          }
         ].push(*options[:statements])
 
         @policy_config = {
           name: @name,
           policy: policy,
-          role: output_of(:aws_iam_role, @name, :name),
+          role: output_of(:aws_iam_role, @name, :name)
         }
 
         resource :aws_iam_role_policy, @name, @policy_config
@@ -83,10 +77,8 @@ module Terrafying
 
       def policy
         JSON.pretty_generate(
-          {
-            Version: "2012-10-17",
-            Statement: @statements,
-          }
+          Version: '2012-10-17',
+          Statement: @statements
         )
       end
 
@@ -94,7 +86,6 @@ module Terrafying
         @statements << statement
         @policy_config[:policy] = policy
       end
-
     end
   end
 end

data/lib/terrafying/components/letsencrypt.rb

@@ -6,12 +6,11 @@ require 'open-uri'
 module Terrafying
   module Components
     class LetsEncrypt < Terrafying::Context
-
       attr_reader :name, :source
 
       include CA
 
-      def self.create(name, bucket, options={})
+      def self.create(name, bucket, options = {})
         LetsEncrypt.new.create name, bucket, options
       end
 
@@ -33,13 +32,13 @@ module Terrafying
         }
       end
 
-      def create(name, bucket, options={})
+      def create(name, bucket, options = {})
         options = {
-          prefix: "",
+          prefix: '',
           provider: :staging,
-          email_address: "cloud@uswitch.com",
+          email_address: 'cloud@uswitch.com',
           public_certificate: false,
-          curve: "P384",
+          curve: 'P384'
         }.merge(options)
 
         @name = name
@@ -49,24 +48,21 @@ module Terrafying
 
         provider :tls, {}
 
-        resource :tls_private_key, "#{@name}-account", {
-                   algorithm: "ECDSA",
-                   ecdsa_curve: options[:curve],
-                 }
+        resource :tls_private_key, "#{@name}-account",
+                 algorithm: 'ECDSA',
+                 ecdsa_curve: options[:curve]
 
-        resource :acme_registration, "#{@name}-reg", {
-          provider: @acme_provider[:ref],
-          account_key_pem: output_of(:tls_private_key, "#{@name}-account", "private_key_pem"),
-          email_address: options[:email_address],
-        }
+        resource :acme_registration, "#{@name}-reg",
+                 provider: @acme_provider[:ref],
+                 account_key_pem: output_of(:tls_private_key, "#{@name}-account", 'private_key_pem'),
+                 email_address: options[:email_address]
 
         @account_key = output_of(:acme_registration, "#{@name}-reg", 'account_key_pem')
 
-        resource :aws_s3_bucket_object, "#{@name}-account", {
-          bucket: @bucket,
-          key: File.join('', @prefix, @name, "account.key"),
-          content: @account_key,
-        }
+        resource :aws_s3_bucket_object, "#{@name}-account",
+                 bucket: @bucket,
+                 key: File.join('', @prefix, @name, 'account.key'),
+                 content: @account_key
 
         @ca_cert_acl = options[:public_certificate] ? 'public-read' : 'private'
 
@@ -74,77 +70,70 @@ module Terrafying
           @ca_cert = cert.read
         end
 
-        resource :aws_s3_bucket_object, object_name(@name, :cert), {
-          bucket: @bucket,
-          key: object_key(@name, :cert),
-          content: @ca_cert,
-          acl: @ca_cert_acl
-        }
+        resource :aws_s3_bucket_object, object_name(@name, :cert),
+                 bucket: @bucket,
+                 key: object_key(@name, :cert),
+                 content: @ca_cert,
+                 acl: @ca_cert_acl
 
         @source = object_url(@name, :cert)
 
         self
       end
 
-      def create_keypair_in(ctx, name, options={})
+      def create_keypair_in(ctx, name, options = {})
         options = {
           common_name: name,
-          organization: "uSwitch Limited",
+          organization: 'uSwitch Limited',
           validity_in_hours: 24 * 365,
-          allowed_uses: [
-            "nonRepudiation",
-            "digitalSignature",
-            "keyEncipherment"
+          allowed_uses: %w[
+            nonRepudiation
+            digitalSignature
+            keyEncipherment
           ],
           dns_names: [],
           ip_addresses: [],
           min_days_remaining: 21,
-          curve: "P384",
+          curve: 'P384'
         }.merge(options)
 
         key_ident = "#{@name}-#{tf_safe(name)}"
 
-        ctx.resource :tls_private_key, key_ident, {
-                       algorithm: "ECDSA",
-                       ecdsa_curve: options[:curve],
-                     }
-
-        ctx.resource :tls_cert_request, key_ident, {
-                       key_algorithm: "ECDSA",
-                       private_key_pem: output_of(:tls_private_key, key_ident, :private_key_pem),
-                       subject: {
-                         common_name: options[:common_name],
-                         organization: options[:organization],
-                       },
-                       dns_names: options[:dns_names],
-                       ip_addresses: options[:ip_addresses],
-                     }
-
-        ctx.resource :acme_certificate, key_ident, {
-                       provider: @acme_provider[:ref],
-                       account_key_pem: @account_key,
-                       min_days_remaining: options[:min_days_remaining],
-                       dns_challenge: {
-                         provider: "route53",
-                       },
-                       certificate_request_pem: output_of(:tls_cert_request, key_ident, :cert_request_pem),
-                     }
-
-        ctx.resource :aws_s3_bucket_object, "#{key_ident}-key", {
-                       bucket: @bucket,
-                       key: File.join('', @prefix, @name, name, "${sha256(tls_private_key.#{key_ident}.private_key_pem)}", "key"),
-                       content: output_of(:tls_private_key, key_ident, :private_key_pem),
-                     }
-
-        ctx.resource :aws_s3_bucket_object, "#{key_ident}-cert", {
-                       bucket: @bucket,
-                       key: File.join('', @prefix, @name, name, "${sha256(acme_certificate.#{key_ident}.certificate_pem)}", "cert"),
-                       content: output_of(:acme_certificate, key_ident, :certificate_pem).to_s + @ca_cert,
-                     }
+        ctx.resource :tls_private_key, key_ident,
+                     algorithm: 'ECDSA',
+                     ecdsa_curve: options[:curve]
+
+        ctx.resource :tls_cert_request, key_ident,
+                     key_algorithm: 'ECDSA',
+                     private_key_pem: output_of(:tls_private_key, key_ident, :private_key_pem),
+                     subject: {
+                       common_name: options[:common_name],
+                       organization: options[:organization]
+                     },
+                     dns_names: options[:dns_names],
+                     ip_addresses: options[:ip_addresses]
+
+        ctx.resource :acme_certificate, key_ident,
+                     provider: @acme_provider[:ref],
+                     account_key_pem: @account_key,
+                     min_days_remaining: options[:min_days_remaining],
+                     dns_challenge: {
+                       provider: 'route53'
+                     },
+                     certificate_request_pem: output_of(:tls_cert_request, key_ident, :cert_request_pem)
+
+        ctx.resource :aws_s3_bucket_object, "#{key_ident}-key",
+                     bucket: @bucket,
+                     key: File.join('', @prefix, @name, name, "${sha256(tls_private_key.#{key_ident}.private_key_pem)}", 'key'),
+                     content: output_of(:tls_private_key, key_ident, :private_key_pem)
+
+        ctx.resource :aws_s3_bucket_object, "#{key_ident}-cert",
+                     bucket: @bucket,
+                     key: File.join('', @prefix, @name, name, "${sha256(acme_certificate.#{key_ident}.certificate_pem)}", 'cert'),
+                     content: output_of(:acme_certificate, key_ident, :certificate_pem).to_s + @ca_cert
 
         reference_keypair(ctx, name)
       end
-
     end
   end
 end

data/lib/terrafying/components/loadbalancer.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'digest'
 require 'terrafying/components/usable'
 require 'terrafying/generator'
@@ -7,14 +9,13 @@ require_relative './ports'
 module Terrafying
   module Components
     class LoadBalancer < Terrafying::Context
-
       attr_reader :id, :name, :type, :security_group, :ports, :targets, :alias_config
 
       Struct.new('Target', :target_group, :listener, keyword_init: true)
 
       include Usable
 
-      def self.create_in(vpc, name, options={})
+      def self.create_in(vpc, name, options = {})
         LoadBalancer.new.create_in vpc, name, options
       end
 
@@ -22,23 +23,23 @@ module Terrafying
         LoadBalancer.new.find_in vpc, name
       end
 
-      def initialize()
+      def initialize
         super
       end
 
       def find_in(vpc, name)
-        @type = "network"
+        @type = 'network'
         ident = make_identifier(@type, vpc.name, name)
 
         begin
           lb = aws.lb_by_name(ident)
-        rescue
-          @type = "application"
+        rescue StandardError
+          @type = 'application'
           ident = make_identifier(@type, vpc.name, name)
 
           lb = aws.lb_by_name(ident)
 
-          @security_group = aws.security_group_by_tags({ loadbalancer_name: ident })
+          @security_group = aws.security_group_by_tags(loadbalancer_name: ident)
         end
 
         @id = lb.load_balancer_arn
@@ -46,25 +47,25 @@ module Terrafying
 
         target_groups = aws.target_groups_by_lb(@id)
 
-        @targets = target_groups.map { |tg|
+        @targets = target_groups.map do |tg|
           Struct::Target.new(
             target_group: tg.target_group_arn,
             listener: nil
           )
-        }
+        end
 
         @ports = enrich_ports(target_groups.map(&:port).sort.uniq)
 
         @alias_config = {
           name: lb.dns_name,
           zone_id: lb.canonical_hosted_zone_id,
-          evaluate_target_health: true,
+          evaluate_target_health: true
         }
 
         self
       end
 
-      def create_in(vpc, name, options={})
+      def create_in(vpc, name, options = {})
         options = {
           ports: [],
           public: false,
@@ -72,7 +73,7 @@ module Terrafying
           hex_ident: false,
           idle_timeout: nil,
           tags: {},
-          security_groups: [],
+          security_groups: []
         }.merge(options)
 
         @tags = {
@@ -82,48 +83,45 @@ module Terrafying
         @hex_ident = options[:hex_ident]
         @ports = enrich_ports(options[:ports])
 
-        l4_ports = @ports.select{ |p| is_l4_port(p) }
+        l4_ports = @ports.select { |p| is_l4_port(p) }
 
         if l4_ports.count > 0 && l4_ports.count < @ports.count
           raise 'Ports have to either be all layer 4 or 7'
         end
 
-        @type = l4_ports.count == 0 ? "application" : "network"
+        @type = l4_ports.count == 0 ? 'application' : 'network'
 
         ident = make_identifier(@type, vpc.name, name)
         @name = ident
 
         if application?
-          @security_group = resource :aws_security_group, ident, {
-                                       name: "loadbalancer-#{ident}",
-                                       description: "Describe the ingress and egress of the load balancer #{ident}",
-                                       tags: @tags.merge(
-                                         {
-                                           loadbalancer_name: ident,
-                                         }
-                                       ),
-                                       vpc_id: vpc.id,
-                                     }
+          @security_group = resource :aws_security_group, ident,
+                                     name: "loadbalancer-#{ident}",
+                                     description: "Describe the ingress and egress of the load balancer #{ident}",
+                                     tags: @tags.merge(
+                                       loadbalancer_name: ident
+                                     ),
+                                     vpc_id: vpc.id
 
           path_mtu_setup!
         end
 
         if network? && options[:security_groups].count > 0
-          warn "You cannot set security groups on a network loadbalancer, set them on the instances behind it."
+          warn 'You cannot set security groups on a network loadbalancer, set them on the instances behind it.'
         end
 
         @id = resource :aws_lb, ident, {
           name: ident,
           load_balancer_type: type,
           internal: !options[:public],
-          tags: @tags,
+          tags: @tags
         }.merge(subnets_for(options[:subnets]))
-         .merge(application? ? { security_groups: [@security_group] + options[:security_groups], idle_timeout: options[:idle_timeout], access_logs: options[:access_logs] } : {})
-         .compact
+              .merge(application? ? { security_groups: [@security_group] + options[:security_groups], idle_timeout: options[:idle_timeout], access_logs: options[:access_logs] } : {})
+              .compact
 
         @targets = []
 
-        @ports.each { |port|
+        @ports.each do |port|
           port_ident = "#{ident}-#{port[:downstream_port]}"
 
           default_action = port.key?(:action) ? port[:action] : forward_to_tg(port, port_ident, vpc)
@@ -131,19 +129,19 @@ module Terrafying
           ssl_options = alb_certs(port, port_ident)
 
           listener = resource :aws_lb_listener, port_ident, {
-                     load_balancer_arn: @id,
-                     port: port[:upstream_port],
-                     protocol: port[:type].upcase,
-                     default_action: default_action,
-                   }.merge(ssl_options)
+            load_balancer_arn: @id,
+            port: port[:upstream_port],
+            protocol: port[:type].upcase,
+            default_action: default_action
+          }.merge(ssl_options)
 
           register_target(default_action[:target_group_arn], listener) if default_action[:type] == 'forward'
-        }
+        end
 
         @alias_config = {
           name: output_of(:aws_lb, ident, :dns_name),
           zone_id: output_of(:aws_lb, ident, :zone_id),
-          evaluate_target_health: true,
+          evaluate_target_health: true
         }
         self
       end
@@ -153,8 +151,8 @@ module Terrafying
           name: port_ident,
           port: port[:downstream_port],
           protocol: port[:type].upcase,
-          vpc_id: vpc.id,
-        }.merge(port.key?(:health_check) ? { health_check: port[:health_check] }: {})
+          vpc_id: vpc.id
+        }.merge(port.key?(:health_check) ? { health_check: port[:health_check] } : {})
 
         {
           type: 'forward',
@@ -185,10 +183,9 @@ module Terrafying
       def alb_cert(cert_arn, port_ident)
         cert_ident = "#{port_ident}-#{Digest::SHA2.hexdigest(cert_arn)[0..8]}"
 
-        resource :aws_lb_listener_certificate, cert_ident, {
-          listener_arn:    "${aws_lb_listener.#{port_ident}.arn}",
-          certificate_arn: cert_arn
-        }
+        resource :aws_lb_listener_certificate, cert_ident,
+                 listener_arn: "${aws_lb_listener.#{port_ident}.arn}",
+                 certificate_arn: cert_arn
       end
 
       def application?
@@ -196,7 +193,7 @@ module Terrafying
       end
 
       def subnets_for(subnets)
-        return { subnets: subnets.map(&:id) }
+        { subnets: subnets.map(&:id) }
       end
 
       def network?
@@ -205,18 +202,21 @@ module Terrafying
 
       def attach(set)
         raise "Dont' know how to attach object to LB" unless set.respond_to?(:attach_load_balancer)
+
         set.attach_load_balancer(self)
         @security_group = set.ingress_security_group if network?
       end
 
       def autoscale(set, target_value:, disable_scale_in:)
         raise "Dont' know how to attach object to LB" unless set.respond_to?(:autoscale_on_load_balancer)
+
         set.autoscale_on_load_balancer(self, target_value: target_value, disable_scale_in: disable_scale_in)
       end
 
       def make_identifier(type, vpc_name, name)
         gen_id = "#{type}-#{tf_safe(vpc_name)}-#{name}"
         return Digest::SHA2.hexdigest(gen_id)[0..24] if @hex_ident || gen_id.size > 26
+
         gen_id[0..31]
       end
     end