awspec-api_gateway_extended 1.2.3

data/lib/awspec/type/rds_account_attributes.rb

@@ -0,0 +1,7 @@
+module Awspec::Type
+  class RdsAccountAttributes < AccountAttributeBase
+    def resource_via_client
+      @resource_via_client ||= find_rds_account_attributes
+    end
+  end
+end

data/lib/awspec/type/rds_db_cluster_parameter_group.rb

@@ -0,0 +1,21 @@
+module Awspec::Type
+  class RdsDbClusterParameterGroup < ResourceBase
+    def resource_via_client
+      return @resource_via_client if @resource_via_client
+      @resource_via_client ||= select_all_rds_db_cluster_parameters(@display_name)
+    end
+
+    def id
+      @id ||= @display_name unless resource_via_client.empty?
+    end
+
+    def method_missing(name)
+      param_name = name.to_s
+      if resource_via_client.include?(param_name)
+        resource_via_client[param_name].to_s
+      else
+        super
+      end
+    end
+  end
+end

data/lib/awspec/type/rds_db_parameter_group.rb

@@ -0,0 +1,21 @@
+module Awspec::Type
+  class RdsDbParameterGroup < ResourceBase
+    def resource_via_client
+      return @resource_via_client if @resource_via_client
+      @resource_via_client ||= select_all_rds_db_parameters(@display_name)
+    end
+
+    def id
+      @id ||= @display_name unless resource_via_client.empty?
+    end
+
+    def method_missing(name)
+      param_name = name.to_s
+      if resource_via_client.include?(param_name)
+        resource_via_client[param_name].to_s
+      else
+        super
+      end
+    end
+  end
+end

data/lib/awspec/type/redshift.rb

@@ -0,0 +1,88 @@
+module Awspec::Type
+  class Redshift < ResourceBase
+    def resource_via_client
+      @resource_via_client ||= find_redshift_cluster_identifier(@display_name)
+    end
+
+    def id
+      @id ||= resource_via_client.cluster_identifier if resource_via_client
+    end
+
+    STATES = %w(
+      available cancelling-resize creating deleting
+      final-snapshot hardware-failure incompatible-hsm
+      incompatible-network incompatible-parameters incompatible-restore
+      modifying rebooting renaming resizing rotating-keys
+      storage-full updating-hsm
+    )
+
+    STATES.each do |state|
+      define_method state.tr('-', '_') + '?' do
+        resource_via_client.cluster_status == state
+      end
+    end
+
+    def has_security_group?(sg_id)
+      return true if has_vpc_security_group_id?(sg_id)
+      return true if has_vpc_security_group_name?(sg_id)
+      return true if has_vpc_security_group_tag_name?(sg_id)
+      return true if has_cluster_security_group_name?(sg_id)
+    end
+
+    def has_cluster_parameter_group?(name, parameter_apply_status = nil)
+      pgs = resource_via_client.cluster_parameter_groups
+      pgs.find do |pg|
+        if parameter_apply_status.nil?
+          pg.parameter_group_name == name
+        else
+          pg.parameter_group_name == name && \
+            pg.parameter_apply_status == parameter_apply_status
+        end
+      end
+    end
+
+    def has_tag?(tag_key, tag_value)
+      resource_via_client.tags do |tag|
+        tag.key == tag_key && tag.value == tag_value
+      end
+    end
+
+    private
+
+    def has_vpc_security_group_id?(sg_id)
+      sgs = resource_via_client.vpc_security_groups
+      sgs.find do |sg|
+        sg.vpc_security_group_id == sg_id
+      end
+    end
+
+    def has_vpc_security_group_name?(sg_id)
+      sgs = resource_via_client.vpc_security_groups
+      res = ec2_client.describe_security_groups({
+                                                  filters: [{ name: 'group-name', values: [sg_id] }]
+                                                })
+      return false unless res.security_groups.count == 1
+      sgs.find do |sg|
+        sg.vpc_security_group_id == res.security_groups.first.group_id
+      end
+    end
+
+    def has_vpc_security_group_tag_name?(sg_id)
+      sgs = resource_via_client.vpc_security_groups
+      res = ec2_client.describe_security_groups({
+                                                  filters: [{ name: 'tag:Name', values: [sg_id] }]
+                                                })
+      return false unless res.security_groups.count == 1
+      sgs.find do |sg|
+        sg.vpc_security_group_id == res.security_groups.first.group_id
+      end
+    end
+
+    def has_cluster_security_group_name?(sg_id)
+      sgs = resource_via_client.cluster_security_groups
+      sgs.find do |sg|
+        sg.cluster_security_group_name == sg_id
+      end
+    end
+  end
+end

data/lib/awspec/type/redshift_cluster_parameter_group.rb

@@ -0,0 +1,20 @@
+module Awspec::Type
+  class RedshiftClusterParameterGroup < ResourceBase
+    def resource_via_client
+      @resource_via_client ||= select_all_redshift_cluster_parameters(@display_name)
+    end
+
+    def id
+      @id ||= @display_name unless resource_via_client.empty?
+    end
+
+    def method_missing(name)
+      param_name = name.to_s
+      if resource_via_client.include?(param_name)
+        resource_via_client[param_name].to_s
+      else
+        super
+      end
+    end
+  end
+end

data/lib/awspec/type/resource_base.rb

@@ -0,0 +1,24 @@
+module Awspec::Type
+  class ResourceBase < Base
+    attr_reader :id, :resource_via_client
+
+    def initialize(display_name = nil)
+      @display_name = display_name
+      @id = nil
+    end
+
+    def exists?
+      id
+    end
+
+    def id
+      raise 'this method must be override!'
+    end
+
+    def self.aws_resource(resource)
+      define_method :resource do
+        @resource ||= Awspec::ResourceReader.new(resource.new(id))
+      end
+    end
+  end
+end

data/lib/awspec/type/route53_hosted_zone.rb

@@ -0,0 +1,65 @@
+module Awspec::Type
+  class Route53HostedZone < ResourceBase
+    def resource_via_client
+      @resource_via_client ||= find_hosted_zone(@display_name)
+    end
+
+    def id
+      @id ||= resource_via_client.id if resource_via_client
+    end
+
+    def resource_via_client_record_sets
+      @resource_via_client_record_sets ||= select_record_sets_by_hosted_zone_id(id)
+    end
+
+    def has_record_set?(name, type, value, options = {})
+      name = name.gsub(/\*/, '\\\052') # wildcard support
+
+      record_sets = resource_via_client_record_sets.select { |record| record.name == name }
+      return false if record_sets.empty?
+
+      # Check if the given record is registered regardless of type and value
+      return true if type.nil? && value.nil? && options.nil?
+
+      record_sets.select! { |record_set| record_set.type.casecmp(type) == 0 }
+      return !record_sets.empty? if value.nil? && options.nil? || value.nil? && options.empty?
+
+      return match_failover_record(record_sets, name, value, options) if options[:record_type]
+
+      record_sets.each do |record_set|
+        return match_record(record_set, name, value, options) unless record_set.resource_records.empty?
+        return match_alias_record(record_set, name, options)
+      end
+    end
+
+    private
+
+    def match_failover_record(record_sets, name, value, options)
+      record_sets.select! { |record_set| record_set.failover == options[:record_type] }
+      return false if record_sets.empty?
+      record_sets.each do |record_set|
+        return match_alias_record(record_set, name, options) if value.nil?
+        return match_record(record_set, name, value, options)
+      end
+    end
+
+    def match_record(record_set, name, value, options)
+      sorted = record_set.resource_records.map { |r| r.value }.sort.join("\n")
+
+      if !options.empty? && options[:ttl]
+        return (record_set.name == name && \
+          value.split("\n").sort.join("\n") == sorted && \
+          record_set.ttl == options[:ttl])
+      end
+
+      record_set.name == name && \
+        value.split("\n").sort.join("\n") == sorted
+    end
+
+    def match_alias_record(record_set, name, options)
+      record_set.name == name && \
+      record_set.alias_target.dns_name == options[:alias_dns_name] && \
+      record_set.alias_target.hosted_zone_id == options[:alias_hosted_zone_id]
+    end
+  end
+end

data/lib/awspec/type/route_table.rb

@@ -0,0 +1,84 @@
+module Awspec::Type
+  class RouteTable < ResourceBase
+    aws_resource Aws::EC2::RouteTable
+    tags_allowed
+
+    def resource_via_client
+      @resource_via_client ||= find_route_table(@display_name)
+    end
+
+    def id
+      @id ||= resource_via_client.route_table_id if resource_via_client
+    end
+
+    def has_route?(destination,
+                   gateway_id = nil,
+                   instance_id = nil,
+                   vpc_peering_connection_id = nil,
+                   nat_gateway_id = nil)
+      resource_via_client.routes.find do |route|
+        if destination
+          next false unless [route.destination_cidr_block, route.destination_prefix_list_id].include?(destination)
+        end
+        next target_gateway?(route, gateway_id) if gateway_id
+        next target_instance?(route, instance_id) if instance_id
+        next target_vpc_peering_connection?(route, vpc_peering_connection_id) if vpc_peering_connection_id
+        next target_nat?(route, nat_gateway_id) if nat_gateway_id
+      end
+    end
+
+    def has_subnet?(subnet_id)
+      subnet = find_subnet(subnet_id)
+      return false unless subnet
+      resource_via_client.associations.find do |a|
+        a.subnet_id == subnet.subnet_id
+      end
+    end
+
+    def route_count
+      resource_via_client.routes.count
+    end
+
+    private
+
+    def target_gateway?(route, gateway_id)
+      # * gateway
+      return true if route.gateway_id == gateway_id
+      # internet gateway
+      igw = find_internet_gateway(gateway_id)
+      return true if igw && igw.internet_gateway_id == route.gateway_id
+      # vpn gateway
+      vgw = find_vpn_gateway(gateway_id)
+      return true if vgw && vgw.vpn_gateway_id == route.gateway_id
+      # customer gateway
+      cgw = find_customer_gateway(gateway_id)
+      return true if cgw && cgw.customer_gateway_id == route.gateway_id
+      # nat gateway
+      nat = find_nat_gateway(gateway_id)
+      return true if nat.nat_gateway_id == route.nat_gateway_id
+      false
+    end
+
+    def target_instance?(route, instance_id)
+      # instance
+      return true if route.instance_id == instance_id
+      instance = find_ec2(instance_id)
+      return true if instance && instance.instance_id == route.instance_id
+      false
+    end
+
+    def target_nat?(route, nat_gateway_id)
+      # nat
+      nat = find_nat_gateway(nat_gateway_id)
+      nat.nat_gateway_id == route.nat_gateway_id
+    end
+
+    def target_vpc_peering_connection?(route, vpc_peering_connection_id)
+      # vpc_peering_connection_id
+      return true if route.vpc_peering_connection_id == vpc_peering_connection_id
+      connection = find_vpc_peering_connection(vpc_peering_connection_id)
+      return true if connection && connection.vpc_peering_connection_id == route.vpc_peering_connection_id
+      false
+    end
+  end
+end

data/lib/awspec/type/s3_bucket.rb

@@ -0,0 +1,139 @@
+module Awspec::Type
+  class S3Bucket < ResourceBase
+    aws_resource Aws::S3::Bucket
+
+    def resource_via_client
+      @resource_via_client ||= find_bucket(@display_name)
+    end
+
+    def id
+      @id ||= @display_name if resource_via_client
+    end
+
+    def has_object?(key)
+      check_existence
+      head_object(id, key)
+    end
+
+    def has_acl_grant?(grantee:, permission:)
+      check_existence
+      @acl = find_bucket_acl(id)
+      @acl.grants.find do |grant|
+        grant.permission == permission &&
+          (grant.grantee.display_name == grantee || grant.grantee.uri == grantee || grant.grantee.id == grantee)
+      end
+    end
+
+    def acl_owner
+      check_existence
+      @acl = find_bucket_acl(id)
+      @acl.owner.display_name
+    end
+
+    def acl_grants_count
+      check_existence
+      @acl = find_bucket_acl(id)
+      @acl.grants.count
+    end
+
+    def has_cors_rule?(allowed_headers: [],
+                       allowed_methods:,
+                       allowed_origins:,
+                       expose_headers: [],
+                       max_age_seconds: nil)
+      cors_rules.any? do |rule|
+        (rule.allowed_headers - allowed_headers).empty? &&
+          (rule.allowed_methods - allowed_methods).empty? &&
+          (rule.allowed_origins - allowed_origins).empty? &&
+          (rule.expose_headers - expose_headers).empty? &&
+          rule.max_age_seconds == max_age_seconds
+      end
+    end
+
+    def cors_rules_count
+      cors_rules.count
+    end
+
+    def has_policy?(policy)
+      check_existence
+      bp = find_bucket_policy(id)
+
+      if bp
+        JSON.parse(bp.policy.read, array_class: Set) == JSON.parse(policy, array_class: Set)
+      else
+        false
+      end
+    end
+
+    def has_tag?(key, value)
+      check_existence
+      tag = find_bucket_tag(id, key)
+      return nil if tag.value != value
+      tag
+    end
+
+    def has_logging_enabled?(target_bucket: nil, target_prefix: nil)
+      check_existence
+      bl = find_bucket_logging(id)
+      le = bl ? bl.logging_enabled : nil
+
+      return false if le.nil?
+      return false if target_bucket && target_bucket != le.target_bucket
+      return false if target_prefix && target_prefix != le.target_prefix
+      true
+    end
+
+    def has_versioning_enabled?
+      check_existence
+      bv = find_bucket_versioning(id)
+      bv ? (bv.status == 'Enabled') : false
+    end
+
+    def has_lifecycle_rule?(rule)
+      check_existence
+      lc_rule = lifecycle_configuration_rules.select { |r| r[:id] == rule[:id] }
+      return false if lc_rule == []
+
+      rule.all? do |key, value|
+        lc_rule.each do |r|
+          return false if value.is_a?(String) && r[key] != value
+          if value.is_a?(Hash)
+            return false if r[key].to_h != value
+          end
+          if value.is_a?(Array)
+            return false if r[key].map(&:to_h) != value
+          end
+          true
+        end
+      end
+    end
+
+    def has_mfa_delete_enabled?
+      check_existence
+      bv = find_bucket_versioning(id)
+      bv ? (bv.mfa_delete == 'Enabled') : false
+    end
+
+    def has_server_side_encryption?(algorithm:)
+      check_existence
+      configuration = find_bucket_server_side_encryption(id)
+      return false unless configuration
+
+      sse_algorithm = configuration.rules[0].apply_server_side_encryption_by_default.sse_algorithm
+      sse_algorithm ? (sse_algorithm == algorithm) : false
+    end
+
+    private
+
+    def cors_rules
+      check_existence
+      @cors ||= find_bucket_cors(id)
+      @cors ? @cors.cors_rules : []
+    end
+
+    def lifecycle_configuration_rules
+      blc = find_bucket_lifecycle_configuration(id)
+      blc ? blc.rules : []
+    end
+  end
+end