cumulus-aws 0.11.1

data/lib/vpc/models/EndpointDiff.rb

@@ -0,0 +1,69 @@
+require "common/models/Diff"
+require "common/models/ListChange"
+require "util/Colors"
+
+require "json"
+
+module Cumulus
+  module VPC
+    # Public: The types of changes that can be made to the endpoint
+    module EndpointChange
+      include Common::DiffChange
+
+      POLICY = Common::DiffChange.next_change_id
+      ROUTE_TABLES = Common::DiffChange.next_change_id
+    end
+
+    # Public: Represents a single difference between local configuration and AWS configuration
+    class EndpointDiff < Common::Diff
+      include EndpointChange
+
+      def self.route_tables(aws, local)
+        changes = Common::ListChange.simple_list_diff(aws, local)
+        if changes
+          diff = EndpointDiff.new(ROUTE_TABLES, aws, local)
+          diff.changes = changes
+          diff
+        end
+      end
+
+      def self.policy(aws, local)
+        if aws != local
+          diff = EndpointDiff.new(POLICY, aws, local)
+          diff
+        end
+      end
+
+      def asset_type
+        "Endpoint"
+      end
+
+      def aws_name
+        @aws.service_name
+      end
+
+      def diff_string
+        case @type
+        when POLICY
+          [
+            "Policy Statement:",
+            Colors.unmanaged([
+              "\tRemoving:",
+              JSON.pretty_generate(aws).lines.map { |l| "\t\t#{l}".chomp("\n") }
+            ].join("\n")),
+            Colors.added([
+              "\tAdding:",
+              JSON.pretty_generate(local).lines.map { |l| "\t\t#{l}".chomp("\n") }
+            ].join("\n"))
+          ].join("\n")
+        when ROUTE_TABLES
+          [
+            "Route Tables:",
+            @changes.removed.map { |d| Colors.unmanaged("\t#{d}") },
+            @changes.added.map { |d| Colors.added("\t#{d}") },
+          ].flatten.join("\n")
+        end
+      end
+    end
+  end
+end

data/lib/vpc/models/NetworkAclConfig.rb

@@ -0,0 +1,87 @@
+require "conf/Configuration"
+require "vpc/models/AclEntryConfig"
+require "ec2/EC2"
+
+require "json"
+
+module Cumulus
+  module VPC
+
+    # Public: An object representing configuration for a VPC Network ACL
+    class NetworkAclConfig
+      attr_reader :inbound
+      attr_reader :outbound
+      attr_reader :tags
+      attr_reader :name
+
+      # Public: Constructor
+      #
+      # name - the name of the network acl config
+      # json - a hash containing the JSON configuration for the Network ACL
+      def initialize(name, json = nil)
+        @name = name
+        if !json.nil?
+          @inbound = (json["inbound"] || []).map { |entry| AclEntryConfig.new(entry) }
+          @outbound = (json["outbound"] || []).map { |entry| AclEntryConfig.new(entry) }
+          @tags = json["tags"] || {}
+        end
+      end
+
+      def to_hash
+        {
+          "inbound" => @inbound.map(&:to_hash),
+          "outbound" => @outbound.map(&:to_hash),
+          "tags" => @tags
+        }.reject { |k, v| v.nil? }
+      end
+
+      def populate!(aws)
+        @inbound = aws.diffable_entries.select { |entry| !entry.egress }
+                      .map { |entry| AclEntryConfig.new().populate!(entry) }
+                      .sort_by!(&:rule)
+        @outbound = aws.diffable_entries.select { |entry| entry.egress }
+                      .map { |entry| AclEntryConfig.new().populate!(entry) }
+                      .sort_by!(&:rule)
+        @tags = Hash[aws.tags.map { |tag| [tag.key, tag.value] }]
+
+        # If there is not a name then add a name tag using the given name
+        if !@tags["Name"]
+          puts "Network ACL #{aws.network_acl_id} does not have a Name defined. Cumulus will use #{name} as the name when migrated."
+          @tags["Name"] = @name
+        end
+
+        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 NetworkAclDiffs that were found
+      def diff(aws)
+        diffs = []
+
+        aws_inbound = aws.diffable_entries.select { |entry| !entry.egress }
+        inbound_diff = NetworkAclDiff.entries(NetworkAclChange::INBOUND, aws_inbound, @inbound)
+        if inbound_diff
+          diffs << inbound_diff
+        end
+
+        aws_outbound = aws.diffable_entries.select { |entry| entry.egress }
+        outbound_diff = NetworkAclDiff.entries(NetworkAclChange::OUTBOUND, aws_outbound, @outbound)
+        if outbound_diff
+          diffs << outbound_diff
+        end
+
+        aws_tags = Hash[aws.tags.map { |tag| [tag.key, tag.value] }]
+        if @tags != aws_tags
+          diffs << NetworkAclDiff.new(NetworkAclChange::TAGS, aws_tags, @tags)
+        end
+
+        diffs
+      end
+
+    end
+  end
+end

data/lib/vpc/models/NetworkAclDiff.rb

@@ -0,0 +1,116 @@
+require "common/models/Diff"
+require "common/models/ListChange"
+require "common/models/TagsDiff"
+require "vpc/models/AclEntryDiff"
+require "util/Colors"
+
+require "json"
+
+module Cumulus
+  module VPC
+    # Public: The types of changes that can be made to the network acl
+    module NetworkAclChange
+      include Common::DiffChange
+
+      INBOUND = Common::DiffChange.next_change_id
+      OUTBOUND = Common::DiffChange.next_change_id
+      TAGS = Common::DiffChange.next_change_id
+    end
+
+    # Public: Represents a single difference between local configuration and AWS configuration
+    class NetworkAclDiff < Common::Diff
+      include NetworkAclChange
+      include Common::TagsDiff
+
+      def self.entries(type, aws, local)
+        aws_rule_entries = Hash[aws.map do |entry|
+          aws_entry = AclEntryConfig.new
+          aws_entry.populate!(entry)
+          [entry.rule_number, aws_entry]
+        end]
+        local_rule_entries = Hash[local.map { |entry| [entry.rule, entry] }]
+
+        added_diffs = Hash[local_rule_entries.reject { |rule, entry| aws_rule_entries.has_key? rule }.map do |rule, local_entry|
+          [rule, AclEntryDiff.added(local_entry)]
+        end]
+        removed_diffs = Hash[aws_rule_entries.reject { |rule, entry| local_rule_entries.has_key? rule }.map do |rule, aws_entry|
+          [rule, AclEntryDiff.unmanaged(aws_entry)]
+        end]
+
+        modified_diffs = Hash[local_rule_entries.select { |rule, entry| aws_rule_entries.has_key? rule }.map do |rule, local_entry|
+          aws_entry = aws_rule_entries[rule]
+          entry_diffs = local_entry.diff(aws_entry)
+          if !entry_diffs.empty?
+            [rule, AclEntryDiff.modified(aws_entry, local_entry, entry_diffs)]
+          end
+        end.reject { |v| v.nil? }]
+
+        if !added_diffs.empty? or !removed_diffs.empty? or !modified_diffs.empty?
+          diff = NetworkAclDiff.new(type, aws, local)
+          diff.changes = Common::ListChange.new(added_diffs, removed_diffs, modified_diffs)
+          diff
+        end
+      end
+
+      def local_tags
+        @local
+      end
+
+      def aws_tags
+        @aws
+      end
+
+      def asset_type
+        "Network Acl"
+      end
+
+      def aws_name
+        @aws.name || @aws.network_acl_id
+      end
+
+      def diff_string
+        case @type
+        when INBOUND
+          [
+            "Inbound Rules:",
+            entries_diff_string
+          ].flatten.join("\n")
+        when OUTBOUND
+          [
+            "Outbound Rules:",
+            entries_diff_string
+          ].flatten.join("\n")
+        when TAGS
+          tags_diff_string
+        end
+      end
+
+      private
+
+      def entries_diff_string
+        [
+          [
+            "\tThese rules will be deleted:",
+            @changes.removed.map do |rule, removed_diff|
+              Colors.unmanaged(removed_diff.aws.pretty_string.lines.map { |l| "\t\t#{l}".chomp("\n") }.join("\n"))
+            end.flatten.join("\n\t\t\t---\n")
+          ].reject { @changes.removed.empty? },
+          [
+            "\tThese rules will be created:",
+            @changes.added.map do |rule, added_diff|
+              Colors.added(added_diff.local.pretty_string.lines.map { |l| "\t\t#{l}".chomp("\n") }.join("\n"))
+            end.flatten.join("\n\t\t\t---\n")
+          ].reject { @changes.added.empty? },
+          @changes.modified.map do |rule, modified_diff|
+            [
+              "\tRule #{rule} was modified:",
+              modified_diff.changes.map do |diff|
+                diff.to_s.lines.map { |l| "\t\t#{l}".chomp("\n") }
+              end
+            ]
+          end
+        ].flatten.join("\n")
+      end
+    end
+  end
+end

data/lib/vpc/models/RouteConfig.rb

@@ -0,0 +1,82 @@
+require "conf/Configuration"
+require "vpc/loader/Loader"
+require "ec2/EC2"
+
+require "json"
+
+module Cumulus
+  module VPC
+
+    # Public: An object representing configuration for a VPC route table route
+    class RouteConfig
+      attr_reader :dest_cidr
+      attr_reader :gateway_id
+      attr_reader :instance_id
+      attr_reader :network_interface_id
+      attr_reader :vpc_peering_connection_id
+      attr_reader :nat_gateway_id
+
+      # Public: Constructor
+      #
+      # json - a hash containing the JSON configuration for the route table route
+      def initialize(json = nil)
+        if !json.nil?
+          @dest_cidr = json["dest-cidr"]
+          @gateway_id = json["gateway-id"]
+          @network_interface_id = json["network-interface-id"]
+          @vpc_peering_connection_id = json["vpc-peering-connection-id"]
+          @nat_gateway_id = json["nat-gateway-id"]
+        end
+      end
+
+      def to_hash
+        {
+          "dest-cidr" => @dest_cidr,
+          "gateway-id" => @gateway_id,
+          "network-interface-id" => @network_interface_id,
+          "vpc-peering-connection-id" => @vpc_peering_connection_id,
+          "nat-gateway-id" => @nat_gateway_id,
+        }.reject { |k, v| v.nil? }
+      end
+
+      def populate!(aws)
+        @dest_cidr = aws.destination_cidr_block
+        @gateway_id = aws.gateway_id
+        @network_interface_id = aws.network_interface_id
+        @vpc_peering_connection_id = aws.vpc_peering_connection_id
+        @nat_gateway_id = aws.nat_gateway_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 RouteDiffs that were found
+      def diff(aws)
+        diffs = []
+
+        if @gateway_id != aws.gateway_id
+          diffs << RouteDiff.new(RouteChange::GATEWAY, aws.gateway_id, @gateway_id)
+        end
+
+        if @network_interface_id != aws.network_interface_id
+          diffs << RouteDiff.new(RouteChange::NETWORK, aws.network_interface_id, @network_interface_id)
+        end
+
+        if @vpc_peering_connection_id != aws.vpc_peering_connection_id
+          diffs << RouteDiff.new(RouteChange::VPC_PEERING, aws.vpc_peering_connection_id, @vpc_peering_connection_id)
+        end
+
+        if @nat_gateway_id != aws.nat_gateway_id
+          diffs << RouteDiff.new(RouteChange::NAT_GATEWAY, aws.nat_gateway_id, @nat_gateway_id)
+        end
+
+        diffs
+      end
+
+    end
+  end
+end

data/lib/vpc/models/RouteDiff.rb

@@ -0,0 +1,50 @@
+require "common/models/Diff"
+require "vpc/models/RouteDiff"
+require "util/Colors"
+
+module Cumulus
+  module VPC
+    # Public: The types of changes that can be made to a route
+    module RouteChange
+      include Common::DiffChange
+
+      GATEWAY = Common::DiffChange.next_change_id
+      NETWORK = Common::DiffChange.next_change_id
+      VPC_PEERING = Common::DiffChange.next_change_id
+      NAT_GATEWAY = Common::DiffChange.next_change_id
+    end
+
+    # Public: Represents a single difference between local configuration AWS configuration
+    class RouteDiff < Common::Diff
+      include RouteChange
+
+      def asset_type
+        "Route"
+      end
+
+      def aws_name
+        @aws.destination_cidr_block
+      end
+
+      def diff_string
+        resource = case @type
+        when GATEWAY
+          "Gateway"
+        when NETWORK
+          "Network Interface"
+        when VPC_PEERING
+          "VPC Peering Connection"
+        when NAT_GATEWAY
+          "NAT Gateway"
+        end
+
+        [
+          "#{resource}:",
+          Colors.aws_changes("\tAWS - #{aws}"),
+          Colors.local_changes("\tLocal - #{local}"),
+        ].join("\n")
+
+      end
+    end
+  end
+end

data/lib/vpc/models/RouteTableConfig.rb

@@ -0,0 +1,92 @@
+require "conf/Configuration"
+require "vpc/loader/Loader"
+require "vpc/models/RouteConfig"
+require "ec2/EC2"
+
+require "json"
+
+module Cumulus
+  module VPC
+
+    # Public: An object representing configuration for a VPC route table
+    class RouteTableConfig
+      attr_reader :name
+      attr_reader :routes
+      attr_reader :propagate_vgws
+      attr_reader :tags
+
+      # Public: Constructor
+      #
+      # json - a hash containing the JSON configuration for the route table
+      def initialize(name, json = nil)
+        @name = name
+        @excludes = []
+        if !json.nil?
+          @routes = (json["routes"] || []).map { |route| RouteConfig.new(route) }
+          @propagate_vgws = json["propagate-vgws"] || []
+          @tags = json["tags"]
+          @excludes = json["exclude-cidr-blocks"] || []
+        end
+      end
+
+      def to_hash
+        {
+          "routes" => @routes.map(&:to_hash),
+          "propagate-vgws" => @propagate_vgws,
+          "tags" => @tags,
+        }.reject { |k, v| v.nil? }
+      end
+
+      def populate!(aws)
+        @routes = aws.diffable_routes.reject { |route| @excludes.include? route.destination_cidr_block }.map do |aws_route|
+          cumulus_route = RouteConfig.new
+          cumulus_route.populate!(aws_route)
+          cumulus_route
+        end
+
+        @propagate_vgws = aws.propagating_vgws.map(&:gateway_id)
+
+        @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 RouteTableDiffs that were found
+      def diff(aws)
+        diffs = []
+
+        aws_routes = aws.diffable_routes.reject { |route| @excludes.include? route.destination_cidr_block }
+        local_routes = @routes.reject { |route| @excludes.include? route.dest_cidr }
+
+        ignored_aws_routes = aws.diffable_routes.select { |route| @excludes.include? route.destination_cidr_block }.map(&:destination_cidr_block).join(", ")
+        ignored_local_routes = @routes.select { |route| @excludes.include? route.dest_cidr }.map(&:dest_cidr).join(", ")
+
+        puts "Ignoring local routes: #{ignored_local_routes}" if !ignored_local_routes.empty?
+        puts "Ignoring AWS routes: #{ignored_aws_routes}" if !ignored_aws_routes.empty?
+
+        routes_diff = RouteTableDiff.routes(aws_routes, local_routes)
+        if routes_diff
+          diffs << routes_diff
+        end
+
+        aws_vgw_ids = aws.propagating_vgws.map(&:gateway_id)
+        if @propagate_vgws.sort != aws_vgw_ids.sort
+          diffs << RouteTableDiff.propagate_vgws(aws_vgw_ids, @propagate_vgws)
+        end
+
+        aws_tags = Hash[aws.tags.map { |tag| [tag.key, tag.value] }]
+        if @tags != aws_tags
+          diffs << RouteTableDiff.new(RouteTableChange::TAGS, aws_tags, @tags)
+        end
+
+        diffs
+      end
+
+    end
+  end
+end