cumulus-aws 0.11.1

data/lib/vpc/models/AclEntryConfig.rb

@@ -0,0 +1,150 @@
+require "conf/Configuration"
+require "vpc/models/AclEntryDiff"
+require "ec2/IPProtocolMapping"
+
+module Cumulus
+  module VPC
+
+    # Public: An object representing configuration for a VPC Network ACL Entry
+    class AclEntryConfig
+      attr_reader :rule
+      attr_reader :protocol
+      attr_reader :action
+      attr_reader :cidr_block
+      attr_reader :ports
+      attr_reader :icmp_type
+      attr_reader :icmp_code
+
+      # Public: Constructor
+      #
+      # json - a hash containing the JSON configuration for the entry
+      def initialize(json = nil)
+        if !json.nil?
+          @rule = json["rule"]
+          @protocol = json["protocol"]
+          @action = json["action"]
+          @cidr_block = json["cidr-block"]
+          @ports = json["ports"]
+          @icmp_type = json["icmp-type"]
+          @icmp_code = json["icmp-code"]
+        end
+      end
+
+      def to_hash
+        {
+          "rule" => @rule,
+          "protocol" => @protocol,
+          "action" => @action,
+          "cidr-block" => @cidr_block,
+          "ports" => @ports,
+          "icmp-type" => @icmp_type,
+          "icmp-code" => @icmp_code,
+        }.reject { |k, v| v.nil? }
+      end
+
+      def populate!(aws)
+        @rule = aws.rule_number
+        @protocol = EC2::IPProtocolMapping.keyword(aws.protocol)
+        @action = aws.rule_action
+        @cidr_block = aws.cidr_block
+
+        aws_from_port = aws.port_range.from if aws.port_range
+        aws_to_port = aws.port_range.to if aws.port_range
+
+        if aws_from_port
+          if aws_from_port == aws_to_port
+            @ports = aws_from_port.to_i
+          else
+            @ports = "#{aws_from_port}-#{aws_to_port}"
+          end
+        end
+
+        aws_icmp_type = aws.icmp_type_code.type if aws.icmp_type_code
+        if aws_icmp_type
+          @icmp_type = aws_icmp_type
+        end
+
+        aws_icmp_code = aws.icmp_type_code.code if aws.icmp_type_code
+        if aws_icmp_code
+          @icmp_code = aws_icmp_code
+        end
+
+        self
+      end
+
+      # Public: expands the ports string into a from and to port
+      #
+      # Returns the from port and to port as Integer
+      def expand_ports
+        # Get the local port values as integers
+        local_from_port = nil
+        local_to_port = nil
+
+        if @ports.is_a? String
+          parts = @ports.split("-").map(&:strip)
+          local_from_port = parts[0].to_i
+          local_to_port = parts[1].to_i
+        elsif @ports.is_a? Integer
+          local_from_port = port
+          local_to_port = port
+        end
+
+        return local_from_port, local_to_port
+      end
+
+      # Public: creates a string representation of the entry
+      # for printing in the console. Not in JSON format
+      def pretty_string
+        [
+          "Rule:\t\t#{rule}",
+          "Protocol:\t#{protocol}",
+          "Action:\t\t#{action}",
+          "CIDR Block:\t#{cidr_block}",
+          if ports then "Ports:\t\t#{ports}" end,
+          if icmp_type then "ICMP Type:\t#{icmp_type}" end,
+          if icmp_code then "ICMP Code:\t#{icmp_code}" end,
+        ].reject(&:nil?).join("\n")
+      end
+
+      # Public: Produce an array of differences between this local configuration and the
+      # configuration in AWS
+      #
+      # aws - the AWS resource populated in an AclEntryConfig
+      #
+      # Returns an array of the AclEntryDiffs that were found
+      def diff(aws)
+        diffs = []
+
+        if @protocol.downcase != aws.protocol.downcase
+          diffs << AclEntryDiff.new(AclEntryChange::PROTOCOL, aws.protocol, @protocol)
+        end
+
+        if @action != aws.action
+          diffs << AclEntryDiff.new(AclEntryChange::ACTION, aws.action, @action)
+        end
+
+        if @cidr_block != aws.cidr_block
+          diffs << AclEntryDiff.new(AclEntryChange::CIDR, aws.cidr_block, @cidr_block)
+        end
+
+        local_from_port, local_to_port = expand_ports
+        aws_from_port, aws_to_port = aws.expand_ports
+
+        if local_from_port != aws_from_port or local_to_port != aws_to_port
+          diffs << AclEntryDiff.new(AclEntryChange::PORTS, aws.ports, @ports)
+        end
+
+        if @icmp_type != aws.icmp_type
+          diffs << AclEntryDiff.new(AclEntryChange::ICMP_TYPE, aws.icmp_type, @icmp_type)
+        end
+
+        if @icmp_code != aws.icmp_code
+          diffs << AclEntryDiff.new(AclEntryChange::ICMP_CODE, aws.icmp_code, @icmp_code)
+        end
+
+        diffs
+      end
+
+    end
+  end
+end

data/lib/vpc/models/AclEntryDiff.rb

@@ -0,0 +1,54 @@
+require "common/models/Diff"
+require "util/Colors"
+
+module Cumulus
+  module VPC
+    # Public: The types of changes that can be made to an acl entry
+    module AclEntryChange
+      include Common::DiffChange
+
+      PROTOCOL = Common::DiffChange.next_change_id
+      ACTION = Common::DiffChange.next_change_id
+      CIDR = Common::DiffChange.next_change_id
+      PORTS = Common::DiffChange.next_change_id
+      ICMP_TYPE = Common::DiffChange.next_change_id
+      ICMP_CODE = Common::DiffChange.next_change_id
+    end
+
+    # Public: Represents a single difference between local configuration and AWS configuration
+    class AclEntryDiff < Common::Diff
+      include AclEntryChange
+
+      def asset_type
+        "Network Acl Entry"
+      end
+
+      def aws_name
+        @aws.rule_number
+      end
+
+      def diff_string
+        resource = case @type
+        when PROTOCOL
+          "Protocol"
+        when ACTION
+          "Action"
+        when CIDR
+          "CIDR Block"
+        when PORTS
+          "Ports"
+        when ICMP_TYPE
+          "ICMP Type"
+        when ICMP_CODE
+          "ICMP Code"
+        end
+
+        [
+          "#{resource}:",
+          Colors.aws_changes("\tAWS - #{aws}"),
+          Colors.local_changes("\tLocal - #{local}"),
+        ].join("\n")
+      end
+    end
+  end
+end

data/lib/vpc/models/DhcpConfig.rb

@@ -0,0 +1,100 @@
+require "conf/Configuration"
+require "vpc/models/DhcpDiff"
+
+require "json"
+
+module Cumulus
+  module VPC
+
+    # Public: An object representing configuration for a VPC's dhcp options
+    class DhcpConfig
+      attr_reader :domain_name_servers
+      attr_reader :domain_name
+      attr_reader :ntp_servers
+      attr_reader :netbios_name_servers
+      attr_reader :netbios_node_type
+
+      require "aws_extensions/ec2/DhcpOptions"
+      Aws::EC2::Types::DhcpOptions.send(:include, AwsExtensions::EC2::DhcpOptions)
+
+      # Public: Constructor
+      #
+      # json - a hash containing the JSON configuration for the dhcp options
+      def initialize(json = nil)
+        if !json.nil?
+          @domain_name_servers = json["domain-name-servers"] || []
+          @domain_name = json["domain-name"]
+          @ntp_servers = json["ntp-servers"] || []
+          @netbios_name_servers = json["netbios-name-servers"] || []
+          @netbios_node_type = json["netbios-node-type"]
+        end
+      end
+
+      def to_hash
+        {
+          "domain-name-servers" => @domain_name_servers.sort,
+          "domain-name" => @domain_name,
+          "ntp-servers" => @ntp_servers.sort,
+          "netbios-name-servers" => @netbios_name_servers.sort,
+          "netbios-node-type" => @netbios_node_type,
+        }.reject { |k, v| v.nil? or v.empty? }
+      end
+
+      def to_aws
+        to_hash.map do |key, value|
+          {
+            key: key,
+            values: [value].flatten
+          }
+        end
+      end
+
+      def populate!(aws)
+        @domain_name_servers = aws.domain_name_servers
+        @domain_name = aws.domain_name
+        @ntp_servers = aws.ntp_servers
+        @netbios_name_servers = aws.netbios_name_servers
+        @netbios_node_type = aws.netbios_node_type
+
+        self
+      end
+
+      # Public: Produce an array of differences between this local configuration and the
+      # configuration in AWS
+      #
+      # aws - the AWS resource
+      #
+      # Returns an array of the DhcpDiffs that were found
+      def diff(aws)
+        diffs = []
+
+        aws_domain_name_servers = (aws.domain_name_servers || []).sort
+        if @domain_name_servers.sort != aws_domain_name_servers
+          domain_servers_diff = DhcpDiff.domain_servers(aws_domain_name_servers, @domain_name_servers)
+          diffs << domain_servers_diff if domain_servers_diff
+        end
+
+        if @domain_name != aws.domain_name
+          diffs << DhcpDiff.new(DhcpChange::DOMAIN_NAME, aws.domain_name, @domain_name)
+        end
+
+        if @ntp_servers.sort != aws.ntp_servers.sort
+          ntp_diff = DhcpDiff.ntp_servers(aws.ntp_servers, @ntp_servers)
+          diffs << ntp_diff if ntp_diff
+        end
+
+        if @netbios_name_servers.sort != aws.netbios_name_servers.sort
+          netbios_diff = DhcpDiff.netbios_servers(aws.netbios_name_servers, @netbios_name_servers)
+          diffs << netbios_diff if netbios_diff
+        end
+
+        if @netbios_node_type != aws.netbios_node_type
+          diffs << DhcpDiff.new(DhcpChange::NETBIOS_NODE, aws.netbios_node_type, @netbios_node_type)
+        end
+
+        diffs
+      end
+
+    end
+  end
+end

data/lib/vpc/models/DhcpDiff.rb

@@ -0,0 +1,90 @@
+require "common/models/Diff"
+require "common/models/ListChange"
+require "util/Colors"
+
+module Cumulus
+  module VPC
+    # Public: The types of changes that can be made to the dhcp configuration
+    module DhcpChange
+      include Common::DiffChange
+
+      DOMAIN_SERVERS = Common::DiffChange.next_change_id
+      DOMAIN_NAME = Common::DiffChange.next_change_id
+      NTP_SERVERS = Common::DiffChange.next_change_id
+      NETBIOS_SERVERS = Common::DiffChange.next_change_id
+      NETBIOS_NODE = Common::DiffChange.next_change_id
+    end
+
+    # Public: Represents a single difference between local configuration and
+    # an AWS Load Balancer.
+    class DhcpDiff < Common::Diff
+      include DhcpChange
+
+      def self.domain_servers(aws, local)
+        changes = Common::ListChange.simple_list_diff(aws, local)
+        if changes
+          diff = DhcpDiff.new(DOMAIN_SERVERS, aws, local)
+          diff.changes = changes
+          diff
+        end
+      end
+
+      def self.ntp_servers(aws, local)
+        changes = Common::ListChange.simple_list_diff(aws, local)
+        if changes
+          diff = DhcpDiff.new(NTP_SERVERS, aws, local)
+          diff.changes = changes
+          diff
+        end
+      end
+
+      def self.netbios_servers(aws, local)
+        changes = Common::ListChange.simple_list_diff(aws, local)
+        if changes
+          diff = DhcpDiff.new(NETBIOS_SERVERS, aws, local, servers_diff)
+          diff.changes = changes
+          diff
+        end
+      end
+
+      def asset_type
+        "DHCP Options"
+      end
+
+      def diff_string
+        case @type
+        when DOMAIN_SERVERS
+          [
+            "Domain Name Servers:",
+            @changes.removed.map { |d| Colors.unmanaged("\t#{d}") },
+            @changes.added.map { |d| Colors.added("\t#{d}") },
+          ].flatten.join("\n")
+        when DOMAIN_NAME
+          [
+            "Domain Name:",
+            Colors.aws_changes("\tAWS - #{aws}"),
+            Colors.local_changes("\tLocal - #{local}"),
+          ].join("\n")
+        when NTP_SERVERS
+          [
+            "NTP Servers:",
+            @changes.removed.map { |n| Colors.unmanaged("\t#{n}") },
+            @changes.added.map { |n| Colors.added("\t#{n}") },
+          ].flatten.join("\n")
+        when NETBIOS_SERVERS
+          [
+            "NETBIOS Name Servers:",
+            @changes.removed.map { |n| Colors.unmanaged("\t#{n}") },
+            @changes.added.map { |n| Colors.added("\t#{n}") },
+          ].flatten.join("\n")
+        when NETBIOS_NODE
+          [
+            "NETBIOS Node Type:",
+            Colors.aws_changes("\tAWS - #{aws}"),
+            Colors.local_changes("\tLocal - #{local}"),
+          ].join("\n")
+        end
+      end
+    end
+  end
+end

data/lib/vpc/models/EndpointConfig.rb

@@ -0,0 +1,76 @@
+require "conf/Configuration"
+require "vpc/loader/Loader"
+require "ec2/EC2"
+
+require "json"
+require "uri"
+
+module Cumulus
+  module VPC
+
+    # Public: An object representing configuration for a VPC endpoint
+    class EndpointConfig
+      attr_reader :service_name
+      attr_accessor :policy
+      attr_reader :route_tables
+
+      # Public: Constructor
+      #
+      # json - a hash containing the JSON configuration for the endpoint
+      def initialize(json = nil)
+        if !json.nil?
+          @service_name = json["service-name"]
+          @policy = json["policy"]
+          @route_tables = json["route-tables"] || []
+        end
+      end
+
+      def to_hash
+        {
+          "service-name" => @service_name,
+          "policy" => @policy,
+          "route-tables" => @route_tables.sort,
+        }.reject { |k, v| v.nil? }
+      end
+
+      def populate!(aws, route_table_map)
+        @service_name = aws.service_name
+        @policy = aws.parsed_policy["Version"]
+        @route_tables = aws.route_table_ids.map { |rt_id| route_table_map[rt_id] || rt_id }
+
+        self
+      end
+
+      # Public: Produce an array of differences between this local configuration and the
+      # configuration in AWS
+      #
+      # aws - the AWS resource
+      #
+      # Returns an array of the EndpointDiffs that were found
+      def diff(aws)
+        diffs = []
+
+        # policy
+        aws_policy_statements = aws.parsed_policy["Statement"]
+        local_policy_statements = Loader.policy(@policy)["Statement"]
+        policy_diff = EndpointDiff.policy(aws_policy_statements, local_policy_statements)
+
+        if policy_diff
+          diffs << policy_diff
+        end
+
+        # routes
+        aws_rts = aws.route_table_ids.map { |rt_id| EC2::id_route_tables[rt_id] }
+        aws_rt_names = aws_rts.map { |rt| rt.name || rt.route_table_id }
+
+        rt_diff = EndpointDiff.route_tables(aws_rt_names, @route_tables)
+        if rt_diff
+          diffs << rt_diff
+        end
+
+        diffs
+      end
+
+    end
+  end
+end