cumulus-aws 0.11.1

data/lib/vpc/models/RouteTableDiff.rb

@@ -0,0 +1,101 @@
+require "common/models/Diff"
+require "common/models/TagsDiff"
+require "common/models/ListChange"
+require "vpc/models/RouteDiff"
+require "util/Colors"
+
+module Cumulus
+  module VPC
+    # Public: The types of changes that can be made to a route table
+    module RouteTableChange
+      include Common::DiffChange
+
+      ROUTES = Common::DiffChange.next_change_id
+      VGWS = Common::DiffChange.next_change_id
+      TAGS = Common::DiffChange.next_change_id
+    end
+
+    # Public: Represents a single difference between local configuration and AWS configuration
+    class RouteTableDiff < Common::Diff
+      include RouteTableChange
+      include Common::TagsDiff
+
+      def self.routes(aws, local)
+        aws_cidr_routes = Hash[aws.map { |route| [route.destination_cidr_block, route] }]
+        local_cidr_routes = Hash[local.map { |route| [route.dest_cidr, route] }]
+
+        added = local_cidr_routes.reject { |k, v| aws_cidr_routes.has_key? k }
+        removed = aws_cidr_routes.reject { |k, v| local_cidr_routes.has_key? k }
+        modified = local_cidr_routes.select { |k, v| aws_cidr_routes.has_key? k }
+
+        added_diffs = Hash[added.map { |cidr, route| [cidr, RouteDiff.added(route)] }]
+        removed_diffs = Hash[removed.map { |cidr, route| [cidr, RouteDiff.unmanaged(route)] }]
+        modified_diffs = Hash[modified.map do |cidr, route|
+          aws_route = aws_cidr_routes[cidr]
+          route_diffs = route.diff(aws_route)
+          if !route_diffs.empty?
+            [cidr, RouteDiff.modified(aws_route, route, route_diffs)]
+          end
+        end.reject { |v| v.nil? }]
+
+        if !added_diffs.empty? or !removed_diffs.empty? or !modified_diffs.empty?
+          diff = RouteTableDiff.new(ROUTES, aws, local)
+          diff.changes = Common::ListChange.new(added_diffs, removed_diffs, modified_diffs)
+          diff
+        end
+      end
+
+      def self.propagate_vgws(aws, local)
+        changes = Common::ListChange.simple_list_diff(aws, local)
+        if changes
+          diff = RouteTableDiff.new(VGWS, aws, local)
+          diff.changes = changes
+          diff
+        end
+      end
+
+      def local_tags
+        @local
+      end
+
+      def aws_tags
+        @aws
+      end
+
+      def asset_type
+        "Route Table"
+      end
+
+      def aws_name
+        @aws.name
+      end
+
+      def diff_string
+        case @type
+        when ROUTES
+          [
+            "Routes:",
+            @changes.removed.map { |s, _| Colors.unmanaged("\t#{s} will be deleted") },
+            @changes.added.map { |s, _| Colors.added("\t#{s} will be created") },
+            @changes.modified.map do |cidr, diff|
+              [
+                "\t#{cidr}:",
+                diff.changes.map do |diff|
+                  diff.to_s.lines.map { |l| "\t\t#{l}".chomp("\n") }
+                end
+              ]
+            end
+          ].flatten.join("\n")
+        when VGWS
+          [
+            "Propagate VGWs:",
+            @changes.removed.map { |s, _| Colors.unmanaged("\t#{s}") },
+            @changes.added.map { |s, _| Colors.added("\t#{s}") },
+          ].flatten.join("\n")
+        when TAGS
+          tags_diff_string
+        end
+      end
+    end
+  end
+end

data/lib/vpc/models/SubnetConfig.rb

@@ -0,0 +1,113 @@
+require "conf/Configuration"
+require "vpc/loader/Loader"
+require "vpc/models/SubnetDiff"
+require "ec2/EC2"
+
+require "json"
+
+module Cumulus
+  module VPC
+
+    # Public: An object representing configuration for a Subnet
+    class SubnetConfig
+      attr_reader :name
+      attr_reader :cidr_block
+      attr_reader :map_public_ip
+      attr_accessor :route_table
+      attr_accessor :network_acl
+      attr_reader :availability_zone
+      attr_reader :tags
+
+      # Public: Constructor
+      #
+      # json - a hash containing the JSON configuration for the subnet
+      def initialize(name, json = nil)
+        @name = name
+        if !json.nil?
+          @cidr_block = json["cidr-block"]
+          @map_public_ip = json["map-public-ip"] || false
+          @route_table = json["route-table"]
+          @network_acl = json["network-acl"]
+          @availability_zone = json["availability-zone"]
+          @tags = json["tags"] || {}
+        end
+      end
+
+      def to_hash
+        {
+          "cidr-block" => @cidr_block,
+          "map-public-ip" => @map_public_ip,
+          "route-table" => @route_table,
+          "network-acl" => @network_acl,
+          "availability-zone" => @availability_zone,
+          "tags" => @tags,
+        }
+      end
+
+      # Public: Populate a config object with AWS configuration
+      #
+      # aws - the AWS configuration for the subnet
+      # route_table_map - an optional mapping of route table ids to names
+      # network_acl_map - an optional mapping of network acl ids to names
+      def populate!(aws, route_table_map = {}, network_acl_map = {})
+        @cidr_block = aws.cidr_block
+        @map_public_ip = aws.map_public_ip_on_launch
+
+        subnet_rt = EC2::subnet_route_tables[aws.subnet_id]
+        @route_table = if subnet_rt then route_table_map[subnet_rt.route_table_id] || subnet_rt.route_table_id end
+
+        subnet_acl = EC2::subnet_network_acls[aws.subnet_id]
+        @network_acl = network_acl_map[subnet_acl.network_acl_id] || subnet_acl.network_acl_id
+
+        @availability_zone = aws.availability_zone
+        @tags = Hash[aws.tags.map { |tag| [tag.key, tag.value] }]
+
+        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 SubnetDiffs that were found
+      def diff(aws)
+        diffs = []
+
+        if @cidr_block != aws.cidr_block
+          diffs << SubnetDiff.new(SubnetChange::CIDR, aws.cidr_block, @cidr_block)
+        end
+
+        if @map_public_ip != aws.map_public_ip_on_launch
+          diffs << SubnetDiff.new(SubnetChange::PUBLIC, aws.map_public_ip_on_launch, @map_public_ip)
+        end
+
+        # For route table try to get the AWS name or default to id
+        aws_subnet_rt = EC2::subnet_route_tables[aws.subnet_id]
+        aws_rt_name = if aws_subnet_rt then aws_subnet_rt.name || aws_subnet_rt.route_table_id end
+        if @route_table != aws_rt_name
+          diffs << SubnetDiff.new(SubnetChange::ROUTE_TABLE, aws_rt_name, @route_table)
+        end
+
+        # For network acl try to get the AWS name or default to its id
+        aws_subnet_net_acl = EC2::subnet_network_acls[aws.subnet_id]
+        aws_net_acl_name = aws_subnet_net_acl.name || aws_subnet_net_acl.network_acl_id
+        if @network_acl != aws_net_acl_name
+          diffs << SubnetDiff.new(SubnetChange::NETWORK_ACL, aws_net_acl_name, @network_acl)
+        end
+
+        if @availability_zone != aws.availability_zone
+          diffs << SubnetDiff.new(SubnetChange::AZ, aws.availability_zone, @availability_zone)
+        end
+
+        aws_tags = Hash[aws.tags.map { |tag| [tag.key, tag.value] }]
+        if @tags != aws_tags
+          diffs << SubnetDiff.new(SubnetChange::TAGS, aws_tags, @tags)
+        end
+
+        diffs
+      end
+
+    end
+  end
+end

data/lib/vpc/models/SubnetDiff.rb

@@ -0,0 +1,78 @@
+require "common/models/Diff"
+require "common/models/TagsDiff"
+require "util/Colors"
+
+module Cumulus
+  module VPC
+    # Public: The types of changes that can be made to a subnet
+    module SubnetChange
+      include Common::DiffChange
+
+      CIDR = Common::DiffChange.next_change_id
+      PUBLIC = Common::DiffChange.next_change_id
+      ROUTE_TABLE = Common::DiffChange.next_change_id
+      NETWORK_ACL = Common::DiffChange.next_change_id
+      AZ = Common::DiffChange.next_change_id
+      TAGS = Common::DiffChange.next_change_id
+    end
+
+    # Public: Represents a single difference between local configuration and AWS configuration
+    class SubnetDiff < Common::Diff
+      include SubnetChange
+      include Common::TagsDiff
+
+      def local_tags
+        @local
+      end
+
+      def aws_tags
+        @aws
+      end
+
+      def asset_type
+        "Subnet"
+      end
+
+      def aws_name
+        @aws.name
+      end
+
+      def diff_string
+        case @type
+        when CIDR
+          [
+            "CIDR Block:",
+            Colors.aws_changes("\tAWS - #{aws}"),
+            Colors.local_changes("\tLocal - #{local}"),
+          ].join("\n")
+        when PUBLIC
+          [
+            "Map Public Ip:",
+            Colors.aws_changes("\tAWS - #{aws}"),
+            Colors.local_changes("\tLocal - #{local}"),
+          ].join("\n")
+        when ROUTE_TABLE
+          [
+            "Route Table:",
+            Colors.aws_changes("\tAWS - #{aws}"),
+            Colors.local_changes("\tLocal - #{local}"),
+          ].join("\n")
+        when NETWORK_ACL
+          [
+            "Network ACL:",
+            Colors.aws_changes("\tAWS - #{aws}"),
+            Colors.local_changes("\tLocal - #{local}"),
+          ].join("\n")
+        when AZ
+          [
+            "Availability Zone:",
+            Colors.aws_changes("\tAWS - #{aws}"),
+            Colors.local_changes("\tLocal - #{local}"),
+          ].join("\n")
+        when TAGS
+          tags_diff_string
+        end
+      end
+    end
+  end
+end

data/lib/vpc/models/VpcConfig.rb

@@ -0,0 +1,173 @@
+require "conf/Configuration"
+require "vpc/loader/Loader"
+require "vpc/models/DhcpConfig"
+require "vpc/models/RouteTableConfig"
+require "vpc/models/EndpointConfig"
+require "vpc/models/NetworkAclConfig"
+require "vpc/models/VpcDiff"
+require "ec2/EC2"
+
+require "json"
+
+module Cumulus
+  module VPC
+
+    # Public: An object representing configuration for a VPC
+    class VpcConfig
+      attr_reader :name
+      attr_reader :cidr_block
+      attr_reader :tenancy
+      attr_reader :subnets
+      attr_reader :dhcp
+      attr_reader :route_tables
+      attr_reader :endpoints
+      attr_reader :address_associations
+      attr_reader :network_acls
+      attr_reader :tags
+
+      # Public: Constructor
+      #
+      # json - a hash containing the JSON configuration for the VPC
+      def initialize(name, json = nil)
+        @name = name
+        if !json.nil?
+          @cidr_block = json["cidr-block"]
+          @tenancy = json["tenancy"]
+          @dhcp = if json["dhcp"] then DhcpConfig.new(json["dhcp"]) end
+          @route_tables = json["route-tables"] || []
+          @endpoints = (json["endpoints"] || []).map { |endpoint| EndpointConfig.new(endpoint) }
+          @address_associations = json["address-associations"] || {}
+          @network_acls = json["network-acls"] || []
+          @subnets = json["subnets"] || []
+          @tags = json["tags"] || {}
+        end
+      end
+
+      def to_hash
+        {
+          "cidr-block" => @cidr_block,
+          "tenancy" => @tenancy,
+          "dhcp" => if @dhcp then @dhcp.to_hash end,
+          "route-tables" => @route_tables,
+          "endpoints" => @endpoints.map(&:to_hash),
+          "address-associations" => @address_associations,
+          "network-acls" => @network_acls,
+          "subnets" => @subnets,
+          "tags" => @tags,
+        }
+      end
+
+      # Public: Populate a config object with AWS configuration
+      #
+      # aws - the AWS configuration for the subnet
+      # route_table_map - an optional mapping of route table ids to names
+      # subnet_map - an optional mapping of subnet ids to names
+      # network_acl_map - an optional mapping of network acl ids to names
+      def populate!(aws, route_table_map = {}, subnet_map = {}, network_acl_map = {})
+        @cidr_block = aws.cidr_block
+        @tenancy = aws.instance_tenancy
+
+        if aws.dhcp_options_id != "default"
+          aws_dhcp = EC2::id_dhcp_options[aws.dhcp_options_id]
+          @dhcp = DhcpConfig.new().populate!(aws_dhcp)
+        end
+
+        aws_rts = EC2::vpc_route_tables[aws.vpc_id]
+        rt_names = aws_rts.map { |rt| route_table_map[rt.route_table_id] || rt.route_table_id }
+        @route_tables = rt_names.sort
+
+        aws_endpoints = EC2::vpc_endpoints[aws.vpc_id]
+        @endpoints = aws_endpoints.map { |endpoint| EndpointConfig.new().populate!(endpoint, route_table_map) }
+
+        aws_addresses = EC2::vpc_addresses[aws.vpc_id]
+        @address_associations = Hash[aws_addresses.map do |addr|
+          network_interface = EC2::id_network_interfaces[addr.network_interface_id]
+          [addr.public_ip, network_interface.name || addr.network_interface_id]
+        end]
+
+        aws_network_acls = EC2::vpc_network_acls[aws.vpc_id]
+        cumulus_network_acls = aws_network_acls.map { |acl| network_acl_map[acl.network_acl_id] || acl.network_acl_id }
+        @network_acls = cumulus_network_acls.sort
+
+        aws_subnets = EC2::vpc_subnets[aws.vpc_id]
+        subnet_names = aws_subnets.map { |subnet| subnet_map[subnet.subnet_id] || subnet.subnet_id }
+        @subnets = subnet_names.sort
+
+        @tags = Hash[aws.tags.map { |tag| [tag.key, tag.value] }]
+
+        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 VpcDiffs that were found
+      def diff(aws)
+        diffs = []
+
+        if @cidr_block != aws.cidr_block
+          diffs << VpcDiff.new(VpcChange::CIDR, aws.cidr_block, @cidr_block)
+        end
+
+        if @tenancy != aws.instance_tenancy
+          diffs << VpcDiff.new(VpcChange::TENANCY, aws.instance_tenancy, @tenancy)
+        end
+
+        # Get the actual DHCP Options from AWS from the id
+        aws_dhcp_options = EC2::id_dhcp_options[aws.dhcp_options_id]
+        dhcp_diff = VpcDiff.dhcp(aws_dhcp_options, @dhcp)
+        if dhcp_diff
+          diffs << dhcp_diff
+        end
+
+        # Load the actual route table configs to diff them
+        local_route_tables = @route_tables.map { |rt_name| Loader.route_table(rt_name) }
+        aws_route_tables = EC2::vpc_route_tables[aws.vpc_id]
+        route_table_diff = VpcDiff.route_tables(aws_route_tables, local_route_tables)
+        if route_table_diff
+          diffs << route_table_diff
+        end
+
+        # Load the vpc endpoints
+        aws_endpoints = EC2::vpc_endpoints[aws.vpc_id]
+        endpoints_diff = VpcDiff.endpoints(aws_endpoints, @endpoints)
+        if endpoints_diff
+          diffs << endpoints_diff
+        end
+
+        aws_associations = EC2::vpc_addresses[aws.vpc_id]
+        association_diff = VpcDiff.address_associations(aws_associations, @address_associations)
+        if association_diff
+          diffs << association_diff
+        end
+
+        # Inbound and outbound network acls
+        local_network_acls = @network_acls.map { |acl_name| Loader.network_acl(acl_name) }
+        aws_network_acls = EC2::vpc_network_acls[aws.vpc_id]
+        network_acl_diff = VpcDiff.network_acls(aws_network_acls, local_network_acls)
+        if network_acl_diff
+          diffs << network_acl_diff
+        end
+
+        # Load the local subnets from config, and the aws version of their subnets
+        local_subnets = @subnets.map { |subnet_name| Loader.subnet(subnet_name) }
+        aws_subnets = EC2::vpc_subnets[aws.vpc_id]
+        subnets_diff = VpcDiff.subnets(aws_subnets, local_subnets)
+        if subnets_diff
+          diffs << subnets_diff
+        end
+
+        # Tags
+        aws_tags = Hash[aws.tags.map { |tag| [tag.key, tag.value] }]
+        if @tags != aws_tags
+          diffs << VpcDiff.new(VpcChange::TAGS, aws_tags, @tags)
+        end
+
+        diffs
+      end
+
+    end
+  end
+end