awspec-api_gateway_extended 1.2.3

data/lib/awspec/type/secretsmanager.rb

@@ -0,0 +1,14 @@
+module Awspec::Type
+  class Secretsmanager < ResourceBase
+    aws_resource Aws::SecretsManager
+    tags_allowed
+
+    def resource_via_client
+      @resource_via_client ||= find_secret(@display_name)
+    end
+
+    def id
+      @id ||= resource_via_client.name if resource_via_client
+    end
+  end
+end

data/lib/awspec/type/security_group.rb

@@ -0,0 +1,148 @@
+module Awspec::Type
+  class SecurityGroup < ResourceBase
+    aws_resource Aws::EC2::SecurityGroup
+    tags_allowed
+
+    def resource_via_client
+      @resource_via_client ||= find_security_group(@display_name)
+    end
+
+    def id
+      @id ||= resource_via_client.group_id if resource_via_client
+    end
+
+    def opened?(port = nil, protocol = nil, cidr = nil)
+      return inbound_opened?(port, protocol, cidr) if @inbound
+      outbound_opened?(port, protocol, cidr)
+    end
+
+    def opened_only?(port = nil, protocol = nil, cidr = nil)
+      return inbound_opened_only?(port, protocol, cidr) if @inbound
+      outbound_opened_only?(port, protocol, cidr)
+    end
+
+    def inbound_opened?(port = nil, protocol = nil, cidr = nil)
+      resource_via_client.ip_permissions.find do |permission|
+        cidr_opened?(permission, cidr) && protocol_opened?(permission, protocol) && port_opened?(permission, port)
+      end
+    end
+
+    def inbound_opened_only?(port = nil, protocol = nil, cidr = nil)
+      permissions = resource_via_client.ip_permissions.select do |permission|
+        protocol_opened?(permission, protocol) && port_opened?(permission, port)
+      end
+      cidrs = []
+      permissions.each do |permission|
+        permission.ip_ranges.select { |ip_range| cidrs.push(ip_range.cidr_ip) }
+      end
+      cidrs == Array(cidr)
+    end
+
+    def outbound_opened?(port = nil, protocol = nil, cidr = nil)
+      resource_via_client.ip_permissions_egress.find do |permission|
+        cidr_opened?(permission, cidr) && protocol_opened?(permission, protocol) && port_opened?(permission, port)
+      end
+    end
+
+    def outbound_opened_only?(port = nil, protocol = nil, cidr = nil)
+      permissions = resource_via_client.ip_permissions_egress.select do |permission|
+        protocol_opened?(permission, protocol) && port_opened?(permission, port)
+      end
+      cidrs = []
+      permissions.each do |permission|
+        permission.ip_ranges.select { |ip_range| cidrs.push(ip_range.cidr_ip) }
+      end
+      cidrs == Array(cidr)
+    end
+
+    def inbound
+      @inbound = true
+      self
+    end
+
+    def outbound
+      @inbound = false
+      self
+    end
+
+    def ip_permissions_count
+      resource_via_client.ip_permissions.count
+    end
+    alias_method :inbound_permissions_count, :ip_permissions_count
+
+    def ip_permissions_egress_count
+      resource_via_client.ip_permissions_egress.count
+    end
+    alias_method :outbound_permissions_count, :ip_permissions_egress_count
+
+    def inbound_rule_count
+      resource_via_client.ip_permissions.reduce(0) do |sum, permission|
+        sum += permission.ip_ranges.count + permission.user_id_group_pairs.count
+      end
+    end
+
+    def outbound_rule_count
+      resource_via_client.ip_permissions_egress.reduce(0) do |sum, permission|
+        sum += permission.ip_ranges.count + permission.user_id_group_pairs.count
+      end
+    end
+
+    private
+
+    def cidr_opened?(permission, cidr)
+      return true unless cidr
+      ret = permission.prefix_list_ids.select do |prefix_list_id|
+        prefix_list_id.prefix_list_id == cidr
+      end
+      return true if ret.count > 0
+      ret = permission.ip_ranges.select do |ip_range|
+        # if the cidr is an IP address then do a true CIDR match
+        if cidr =~ /^\d+\.\d+\.\d+\.\d+/
+          net = IPAddress::IPv4.new(ip_range.cidr_ip)
+          net.include?(IPAddress::IPv4.new(cidr))
+        else
+          ip_range.cidr_ip == cidr
+        end
+      end
+      return true if ret.count > 0
+      ret = permission.user_id_group_pairs.select do |sg|
+        # Compare the sg group_name if the remote group is in another account.
+        # find_security_group call doesn't return info on a remote security group.
+        if !sg.user_id.nil? && (sg.user_id != resource_via_client.owner_id)
+          next (sg.group_name == cidr) || (sg.group_id == cidr)
+        end
+        next true if sg.group_id == cidr
+        sg2 = find_security_group(sg.group_id)
+        next false if sg2.nil?
+        next true if sg2.group_name == cidr
+        sg2.tags.find do |tag|
+          tag.key == 'Name' && tag.value == cidr
+        end
+      end
+      ret.count > 0
+    end
+
+    def protocol_opened?(permission, protocol)
+      return true unless protocol
+      return false if protocol == 'all' && permission.ip_protocol != '-1'
+      return true if permission.ip_protocol == '-1'
+      permission.ip_protocol == protocol
+    end
+
+    def port_opened?(permission, port)
+      return true unless port
+      return true unless permission.from_port
+      return true unless permission.to_port
+      port_between?(port, permission.from_port, permission.to_port)
+    end
+
+    def port_between?(port, from_port, to_port)
+      if port.is_a?(String) && port.include?('-')
+        f, t = port.split('-')
+        from_port == f.to_i && to_port == t.to_i
+      else
+        port.between?(from_port, to_port)
+      end
+    end
+  end
+end

data/lib/awspec/type/ses_identity.rb

@@ -0,0 +1,70 @@
+module Awspec::Type
+  class SesIdentity < ResourceBase
+    def resource_via_client
+      @resource_via_client ||= find_ses_identity(@display_name)
+    end
+
+    def id
+      @id ||= resource_via_client if resource_via_client
+    end
+
+    def has_identity_policy?(name)
+      res = ses_client.list_identity_policies({
+                                                identity: id
+                                              })
+      res.policy_names.find do |policy_name|
+        policy_name == name
+      end
+    end
+
+    # dkim_attributes
+    dkim_attributes = %w(
+      dkim_enabled dkim_verification_status
+    )
+
+    dkim_attributes.each do |attribute|
+      define_method attribute do
+        res = ses_client.get_identity_dkim_attributes({
+                                                        identities: [id]
+                                                      })
+        res.dkim_attributes[id][attribute.to_sym]
+      end
+    end
+
+    def has_dkim_tokens?(token)
+      res = ses_client.get_identity_dkim_attributes({
+                                                      identities: [id]
+                                                    })
+      res.dkim_attributes[id][:tokens].include?(token)
+    end
+
+    # notification_attributes
+    notification_attributes = %w(
+      bounce_topic complaint_topic delivery_topic
+      forwarding_enabled
+    )
+
+    notification_attributes.each do |attribute|
+      define_method attribute do
+        res = ses_client.get_identity_notification_attributes({
+                                                                identities: [id]
+                                                              })
+        res.notification_attributes[id][attribute.to_sym]
+      end
+    end
+
+    # verification_attributes
+    verification_attributes = %w(
+      verification_status verification_token
+    )
+
+    verification_attributes.each do |attribute|
+      define_method attribute do
+        res = ses_client.get_identity_verification_attributes({
+                                                                identities: [id]
+                                                              })
+        res.verification_attributes[id][attribute.to_sym]
+      end
+    end
+  end
+end

data/lib/awspec/type/ses_send_quota.rb

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

data/lib/awspec/type/sns_topic.rb

@@ -0,0 +1,50 @@
+module Awspec::Type
+  class SnsTopic < ResourceBase
+    def initialize(topic_arn)
+      super
+      @topic_arn = topic_arn
+      # lazy instantiation
+      @subscriptions = nil
+    end
+
+    def subscriptions
+      fetch_subscriptions
+      @subscriptions.keys
+    end
+
+    def resource_via_client
+      @resource_via_client ||= find_sns_topic(@topic_arn)
+    end
+
+    def id
+      # A SNS Topic doesn't have an ID...
+      @id ||= resource_via_client.topic_arn if resource_via_client
+    end
+
+    def has_subscription?(subscribed_arn)
+      fetch_subscriptions
+      @subscriptions.key?(subscribed_arn.to_sym)
+    end
+
+    def subscribed(subscribed_arn)
+      subs_key = subscribed_arn.to_sym
+      fetch_subscriptions
+      raise "'#{subscribed_arn}' is not a valid subscription ARN" unless @subscriptions.key?(subs_key)
+      @subscriptions[subs_key]
+    end
+
+    def method_missing(method_name)
+      check_existence
+      # delegates the method invocation to Awspec::Helper::Finder::SnsTopic::SnsTopic class
+      @resource_via_client.send method_name
+    end
+
+    private
+
+    def fetch_subscriptions
+      @subscriptions = find_sns_topic_subs(@topic_arn) if @subscriptions.nil?
+      raise Awspec::NoExistingResource.new(self.class, @display_name) if @subscriptions.nil?
+      @subscriptions
+    end
+  end
+end

data/lib/awspec/type/sqs.rb

@@ -0,0 +1,37 @@
+module Awspec::Type
+  class Sqs < ResourceBase
+    def resource_via_client
+      return @resource_via_client if @resource_via_client
+      queue_url = id
+      attributes = {}
+      res = sqs_client.get_queue_attributes({
+                                              queue_url: queue_url,
+                                              attribute_names: ['All']
+                                            })
+      res.attributes.each do |key, value|
+        attributes[key.underscore] = value
+      end
+      attributes['queue_url'] = queue_url
+      @resource_via_client ||= attributes
+    end
+
+    def id
+      @id ||= find_queue(@display_name)
+    end
+
+    def method_missing(name)
+      param_name = name.to_s
+      if resource_via_client.include?(param_name)
+        resource_via_client[param_name]
+      else
+        super
+      end
+    end
+
+    def has_tag?(tag_key, tag_value)
+      @tag_set ||= find_tags_for_queue(@id)
+      return nil if @tag_set[tag_key] != tag_value
+      true
+    end
+  end
+end

data/lib/awspec/type/ssm_parameter.rb

@@ -0,0 +1,26 @@
+module Awspec::Type
+  class SsmParameter < ResourceBase
+    def initialize(name)
+      super
+      @display_name = name
+    end
+
+    def resource_via_client
+      @resource_via_client ||= find_ssm_parameter(@display_name)
+    end
+
+    def id
+      @id ||= @display_name if resource_via_client
+    end
+
+    def encrypted?
+      resource_via_client.type.eql? 'SecureString'
+    end
+
+    def has_tag?(key, value)
+      tag = find_parameter_tag(id, key)
+      return nil if tag.value != value
+      tag
+    end
+  end
+end

data/lib/awspec/type/subnet.rb

@@ -0,0 +1,39 @@
+module Awspec::Type
+  class Subnet < ResourceBase
+    aws_resource Aws::EC2::Subnet
+    tags_allowed
+
+    def resource_via_client
+      @resource_via_client ||= find_subnet(@display_name)
+    end
+
+    def id
+      @id ||= resource_via_client.subnet_id if resource_via_client
+    end
+
+    def associated_to?(route_table_id)
+      res = ec2_client.describe_route_tables({
+                                               filters:
+                                               [
+                                                 {
+                                                   name: 'association.subnet-id',
+                                                   values: [id]
+                                                 }
+                                               ]
+                                             })
+      return false if res[:route_tables].empty?
+      associated_route_table = res[:route_tables].first
+      associated_route_table.route_table_id == route_table_id || associated_route_table.tag_name == route_table_id
+    end
+
+    STATES = %w(
+      available pending
+    )
+
+    STATES.each do |state|
+      define_method state + '?' do
+        resource_via_client.state == state
+      end
+    end
+  end
+end

data/lib/awspec/type/vpc.rb

@@ -0,0 +1,66 @@
+module Awspec::Type
+  class Vpc < ResourceBase
+    aws_resource Aws::EC2::Vpc
+    tags_allowed
+
+    def resource_via_client
+      @resource_via_client ||= find_vpc(@display_name)
+    end
+
+    def id
+      @id ||= resource_via_client.vpc_id if resource_via_client
+    end
+
+    STATES = %w(
+      available pending
+    )
+
+    STATES.each do |state|
+      define_method state + '?' do
+        resource_via_client.state == state
+      end
+    end
+
+    def has_route_table?(table_id)
+      route_table = find_route_table(table_id)
+      return false unless route_table
+      route_table.vpc_id == id
+    end
+
+    def has_network_acl?(table_id)
+      n = find_network_acl(table_id)
+      return false unless n
+      n.vpc_id == id
+    end
+
+    def connected_to_vpc?(vpc_id, accepter_or_requester = nil)
+      connections = select_vpc_peering_connection_by_vpc_id(vpc_id, 'active')
+      return connections.single_resource(vpc_id) unless accepter_or_requester
+
+      if accepter_or_requester == 'accepter'
+        connections.select do |conn|
+          conn.accepter_vpc_info.vpc_id == @id
+        end.single_resource(vpc_id)
+      elsif accepter_or_requester == 'requester'
+        connections.select do |conn|
+          conn.requester_vpc_info.vpc_id == @id
+        end.single_resource(vpc_id)
+      end
+    end
+
+    def has_vpc_peering_connection?(vpc_peering_connection_id, accepter_or_requester = nil)
+      connection = find_vpc_peering_connection(vpc_peering_connection_id)
+      res = if accepter_or_requester == 'accepter'
+              connection.accepter_vpc_info.vpc_id == @id
+            elsif accepter_or_requester == 'requester'
+              connection.requester_vpc_info.vpc_id == @id
+            else
+              connection
+            end
+    end
+
+    def has_vpc_attribute?(vpc_attribute)
+      find_vpc_attribute(resource_via_client.vpc_id, vpc_attribute)
+    end
+  end
+end