cumulus-aws 0.11.1

data/lib/ec2/models/EbsGroupConfig.rb

@@ -0,0 +1,133 @@
+require "conf/Configuration"
+require "ec2/models/EbsGroupDiff"
+
+require "json"
+
+module Cumulus
+  module EC2
+
+    VolumeGroup = Struct.new(:size, :type, :iops, :count, :encrypted, :kms_key) do
+      def to_hash
+        {
+          "size" => self.size,
+          "type" => self.type,
+          "iops" => self.iops,
+          "count" => self.count,
+          "encrypted" => self.encrypted,
+          "kms-key" => self.kms_key
+        }.reject { |k, v| v.nil? }
+      end
+
+      def description
+        [
+          "#{self.size}GiB",
+          "#{self.type}",
+          if self.type == "io1" then "#{self.iops} IOPS" end,
+          if self.encrypted then "encrypted" else "unencrypted" end,
+          if self.kms_key then "KMS #{self.kms_key}" end,
+        ].reject(&:nil?).join("/")
+      end
+
+      def hash_key
+        "#{self.size}|#{self.type}|#{self.iops}|#{self.encrypted}|#{self.kms_key}"
+      end
+    end
+
+    # Public: An object representing configuration for a group of EBS volumes
+    class EbsGroupConfig
+      attr_reader :name
+      attr_reader :volume_groups
+      attr_reader :availability_zone
+
+      # Public: Constructor
+      #
+      # json - a hash containing the JSON configuration for the group
+      def initialize(name, json = nil)
+        @name = name
+        if !json.nil?
+          @availability_zone = json["availability-zone"]
+          @volume_groups = (json["volumes"] || []).map do |vg_json|
+            VolumeGroup.new(
+              vg_json["size"],
+              vg_json["type"],
+              if vg_json["type"] == "io1" then vg_json["iops"] end,
+              vg_json["count"],
+              vg_json["encrypted"] || false,
+              if vg_json["encrypted"] then vg_json["kms-key"] end
+            )
+          end
+        end
+      end
+
+      def to_hash
+        {
+          "availability-zone" => @availability_zone,
+          "volumes" => @volume_groups.map(&:to_hash),
+        }
+      end
+
+      # Public: Populate a config object with AWS configuration
+      #
+      # aws - the ebs volumes in the group. All volumes should be in the same AZ
+      def populate!(aws)
+        # Group the aws volumes by size, type, iops, encryped, kms-key
+        vol_groups = aws.group_by { |vol| "#{vol.size}|#{vol.volume_type}|#{vol.iops}|#{vol.encrypted}|#{vol.kms_key_id}" }
+
+        @volume_groups = vol_groups.map do |_, vols|
+          VolumeGroup.new(
+            vols.first.size,
+            vols.first.volume_type,
+            if vols.first.volume_type == "io1" then vols.first.iops end,
+            vols.length,
+            vols.first.encrypted,
+            vols.first.kms_key_id
+          )
+        end
+
+        # Get the AZ of the first volume
+        @availability_zone = aws.first.availability_zone
+
+        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 EbsGroupDiffs that were found
+      def diff(aws)
+        diffs = []
+
+        if @availability_zone != aws.availability_zone
+          diffs << EbsGroupDiff.new(EbsGroupChange::AZ, aws.availability_zone, @availability_zone)
+        end
+
+        # Group the aws and local versions by hash_key
+        aws_grouped = Hash[aws.volume_groups.map { |vg| [vg.hash_key, vg] }]
+        local_grouped = Hash[@volume_groups.map { |vg| [vg.hash_key, vg] }]
+
+        # added
+        local_grouped.reject { |key, vg| aws_grouped.has_key? key }.each do |key, vg|
+          diffs << EbsGroupDiff.new(EbsGroupChange::VG_ADDED, nil, vg)
+        end
+
+        # removed
+        aws_grouped.reject { |key, vg| local_grouped.has_key? key }.each do |key, vg|
+          diffs << EbsGroupDiff.new(EbsGroupChange::VG_REMOVED, vg, nil)
+        end
+
+        # count is different
+        local_grouped.select { |key, vg| aws_grouped.has_key? key }.each do |key, local_vg|
+          aws_vg = aws_grouped[key]
+          if local_vg.count != aws_vg.count
+            diffs << EbsGroupDiff.new(EbsGroupDiff::VG_COUNT, aws_vg, local_vg)
+          end
+        end
+
+        diffs.sort_by { |diff| diff.type }
+      end
+
+    end
+  end
+end

data/lib/ec2/models/EbsGroupDiff.rb

@@ -0,0 +1,48 @@
+require "common/models/Diff"
+require "util/Colors"
+
+require 'json'
+
+module Cumulus
+  module EC2
+    # Public: The types of changes that can be made to an EBS volume group
+    module EbsGroupChange
+      include Common::DiffChange
+
+      AZ = Common::DiffChange.next_change_id
+      VG_ADDED = Common::DiffChange.next_change_id
+      VG_REMOVED = Common::DiffChange.next_change_id
+      VG_COUNT = Common::DiffChange.next_change_id
+    end
+
+    # Public: Represents a single difference between local configuration and AWS configuration
+    class EbsGroupDiff < Common::Diff
+      include EbsGroupChange
+
+      def asset_type
+        "EBS Volume Group"
+      end
+
+      def aws_name
+        @aws.name
+      end
+
+      def diff_string
+        case @type
+        when AZ
+          [
+            "Availability Zone:",
+            Colors.aws_changes("\tAWS - #{aws}"),
+            Colors.local_changes("\tLocal - #{local}"),
+          ].join("\n")
+        when VG_ADDED
+          Colors.added("Volume Group Added: #{local.count} x #{local.description}")
+        when VG_REMOVED
+          Colors.unmanaged("Volume Group Unmanaged: #{aws.count} x #{aws.description}")
+        when VG_COUNT
+          Colors.local_changes("Count changed from #{aws.count} to #{local.count}: #{local.description}")
+        end
+      end
+    end
+  end
+end

data/lib/ec2/models/InstanceConfig.rb

@@ -0,0 +1,202 @@
+require "common/models/ListChange"
+require "conf/Configuration"
+require "ec2/models/EbsGroupConfig"
+require "ec2/models/EbsGroupDiff"
+require "ec2/models/InstanceDiff"
+require "ec2/EC2"
+require "security/SecurityGroups"
+
+require "json"
+
+module Cumulus
+  module EC2
+
+    # Public: An object representing configuration for a network interface
+    class InstanceConfig
+      attr_reader :name
+      attr_reader :ebs_optimized
+      attr_reader :placement_group
+      attr_reader :profile
+      attr_reader :image
+      attr_reader :key_name
+      attr_reader :monitoring
+      attr_reader :network_interfaces
+      attr_reader :source_dest_check
+      attr_reader :private_ip_address
+      attr_reader :security_groups
+      attr_reader :subnet
+      attr_reader :tenancy
+      attr_reader :type
+      attr_reader :user_data
+      attr_reader :volume_groups
+      attr_reader :tags
+
+      # Public: Constructor
+      #
+      # json - a hash containing the JSON configuration for the group
+      def initialize(name, json = nil)
+        @name = name
+        if !json.nil?
+          @ebs_optimized = json["ebs-optimized"] || false
+          @placement_group = json["placement-group"]
+          @profile = json["profile"]
+          @image = json["image"]
+          @key_name = json["key-name"]
+          @monitoring = json["monitoring"] || false
+          @network_interfaces = json["network-interfaces"] || 0
+          @source_dest_check = json["source-dest-check"]
+          @private_ip_address = json["private-ip-address"]
+          @security_groups = json["security-groups"] || []
+          @subnet = json["subnet"]
+          @tenancy = json["tenancy"] || "default"
+          @type = json["type"]
+          @user_data = json["user-data"]
+          @volume_groups = json["volume-groups"] || []
+          @tags = json["tags"] || {}
+        end
+      end
+
+      def to_hash
+        {
+          "ebs-optimized" => @ebs_optimized,
+          "placement-group" => @placement_group,
+          "profile" => @profile,
+          "image" => @image,
+          "key-name" => @key_name,
+          "monitoring" => @monitoring,
+          "network-interfaces" => @network_interfaces,
+          "source-dest-check" => @source_dest_check,
+          "private-ip-address" => @private_ip_address,
+          "security-groups" => @security_groups,
+          "subnet" => @subnet,
+          "tenancy" => @tenancy,
+          "type" => @type,
+          "user-data" => @user_data,
+          "volume-groups" => @volume_groups,
+          "tags" => @tags,
+        }
+      end
+
+      # Public: Populate a config object with AWS configuration
+      #
+      # aws_instance - the instance from AWS
+      # user_data_file - the name of the user data script file
+      # tags - a Hash of tags for the instance
+      def populate!(aws_instance, user_data_file, tags)
+        @ebs_optimized = aws_instance.ebs_optimized
+        @placement_group = aws_instance.placement.group_name
+        if @placement_group.empty? then @placement_group = nil end
+
+        profile_arn = (aws_instance.iam_instance_profile.arn rescue nil)
+        @profile = if profile_arn then profile_arn[profile_arn.rindex("/") + 1 .. profile_arn.length] end
+
+        @image = aws_instance.image_id
+        @key_name = aws_instance.key_name
+        @monitoring = ["enabled", "pending"].include? aws_instance.monitoring.state
+        @network_interfaces = aws_instance.network_interfaces.length
+        @source_dest_check = aws_instance.source_dest_check
+        @private_ip_address = aws_instance.private_ip_address
+        @security_groups = aws_instance.security_groups.map(&:group_id).map { |id| SecurityGroups::id_security_groups[id].group_name }.sort
+        @subnet = EC2::id_subnets[aws_instance.subnet_id].name
+        @tenancy = aws_instance.placement.tenancy
+        @type = aws_instance.instance_type
+        @user_data = user_data_file
+
+        # Get the volumes for each device mapping
+        @volume_groups = aws_instance.nonroot_devices.map do |m|
+          EC2::id_ebs_volumes[m.ebs.volume_id]
+        end.map(&:group).reject(&:nil?).uniq.sort
+
+        @tags = tags
+
+        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 InterfaceDiffs that were found
+      def diff(aws)
+        diffs = []
+
+        if aws.ebs_optimized != @ebs_optimized
+          diffs << InstanceDiff.new(InstanceChange::EBS, aws.ebs_optimized, @ebs_optimized)
+        end
+
+        if aws.profile != @profile
+          diffs << InstanceDiff.new(InstanceChange::PROFILE, aws.profile, @profile)
+        end
+
+        if aws.monitoring != @monitoring
+          diffs << InstanceDiff.new(InstanceChange::MONITORING, aws.monitoring, @monitoring)
+        end
+
+        if aws.network_interfaces != @network_interfaces
+          diffs << InstanceDiff.new(InstanceChange::INTERFACES, aws.network_interfaces, @network_interfaces)
+        end
+
+        if aws.source_dest_check != @source_dest_check
+          diffs << InstanceDiff.new(InstanceChange::SDCHECK, aws.source_dest_check, @source_dest_check)
+        end
+
+        if aws.security_groups.sort != @security_groups.sort
+          changes = Common::ListChange::simple_list_diff(aws.security_groups, @security_groups)
+          diffs << InstanceDiff.new(InstanceChange::SECURITY_GROUPS, aws.security_groups, @security_groups, changes)
+        end
+
+        if aws.subnet != @subnet
+          diffs << InstanceDiff.new(InstanceChange::SUBNET, aws.subnet, @subnet)
+        end
+
+        if aws.type != @type
+          diffs << InstanceDiff.new(InstanceChange::TYPE, aws.type, @type)
+        end
+
+        if aws.tenancy != @tenancy
+          diffs << InstanceDiff.new(InstanceChange::TENANCY, aws.tenancy, @tenancy)
+        end
+
+        if aws.tags != @tags
+          diffs << InstanceDiff.new(InstanceChange::TAGS, aws.tags, @tags)
+        end
+
+        # Check for diffs in volume groups and diffs in how many volumes are attached
+
+        # Get the volumes that are attached to the instance
+        aws_instance = EC2::named_instances[aws.name]
+        attached_volumes = aws_instance.nonroot_devices.map do |m|
+          EC2::id_ebs_volumes[m.ebs.volume_id]
+        end
+        # Group by volume group, reject nil groups
+        group_volumes = attached_volumes.group_by(&:group).reject { |k, v| k.nil? }
+
+        aws_ebs_groups = Hash[group_volumes.map { |group, vols| [group, EbsGroupConfig.new(group).populate!(vols)] }]
+        local_ebs_groups = Hash[@volume_groups.map { |vg| [vg, EC2::group_ebs_volumes[vg]] }]
+
+        added_groups = Hash[local_ebs_groups.reject { |k, v| aws_ebs_groups.has_key?(k) }.map do |group_name, group_config|
+          [group_name, EbsGroupDiff.added(group_config)]
+        end]
+        removed_groups = Hash[aws_ebs_groups.reject { |k, v| aws_ebs_groups.has_key?(k) }.map do |group_name, group_config|
+          [group_name, EbsGroupDiff.unmanaged(group_config)]
+        end]
+        changed_groups = Hash[local_ebs_groups.select { |k, v| aws_ebs_groups.has_key?(k) }.map do |group_name, group_config|
+          aws_config = aws_ebs_groups[group_name]
+          group_diffs = group_config.diff(aws_config)
+          if !group_diffs.empty?
+            [group_name, EbsGroupDiff.modified(aws_config, group_config, group_diffs)]
+          end
+        end].reject { |k, v| v.nil? }
+
+        ebs_changes = Common::ListChange.new(added_groups, removed_groups, changed_groups)
+        if !ebs_changes.empty?
+          diffs << InstanceDiff.new(InstanceChange::VOLUME_GROUPS, aws_ebs_groups, local_ebs_groups, ebs_changes)
+        end
+
+        diffs
+      end
+
+    end
+  end
+end

data/lib/ec2/models/InstanceDiff.rb

@@ -0,0 +1,95 @@
+require "common/models/Diff"
+require "common/models/TagsDiff"
+require "util/Colors"
+
+require 'json'
+
+module Cumulus
+  module EC2
+    # Public: The types of changes that can be made to an EBS volume group
+    module InstanceChange
+      include Common::DiffChange
+
+      EBS = Common::DiffChange.next_change_id
+      PROFILE = Common::DiffChange.next_change_id
+      MONITORING = Common::DiffChange.next_change_id
+      INTERFACES = Common::DiffChange.next_change_id
+      SDCHECK = Common::DiffChange.next_change_id
+      SECURITY_GROUPS = Common::DiffChange.next_change_id
+      SUBNET = Common::DiffChange.next_change_id
+      TYPE = Common::DiffChange.next_change_id
+      TENANCY = Common::DiffChange.next_change_id
+      VOLUME_GROUPS = Common::DiffChange.next_change_id
+      TAGS = Common::DiffChange.next_change_id
+    end
+
+    # Public: Represents a single difference between local configuration and AWS configuration
+    class InstanceDiff < Common::Diff
+      include InstanceChange
+      include Common::TagsDiff
+
+      def asset_type
+        case @type
+        when EBS then "EBS Optimized"
+        when PROFILE then "Instance Profile"
+        when MONITORING then "Monitoring"
+        when INTERFACES then "Network Interfaces"
+        when SDCHECK then "Source Dest Check"
+        when SECURITY_GROUPS then "Security Groups"
+        when SUBNET then "Subnet"
+        when TYPE then "Type"
+        when TENANCY then "Tenancy"
+        when VOLUME_GROUPS then "Volume Groups"
+        when TAGS then "Tags"
+        else
+          "EC2 Instance"
+        end
+      end
+
+      def aws_name
+        @aws.name
+      end
+
+      def local_tags
+        @local
+      end
+
+      def aws_tags
+        @aws
+      end
+
+      def diff_string
+        case @type
+        when EBS, PROFILE, MONITORING, INTERFACES, SDCHECK, SUBNET, TYPE, TENANCY
+          [
+            "#{asset_type}:",
+            Colors.aws_changes("\tAWS - #{aws}"),
+            Colors.local_changes("\tLocal - #{local}"),
+          ].join("\n")
+        when SECURITY_GROUPS
+          [
+            "#{asset_type}:",
+            @changes.removed.map { |sg| Colors.unmanaged("\t#{sg}") },
+            @changes.added.map { |sg| Colors.added("\t#{sg}") }
+          ].flatten.join("\n")
+        when VOLUME_GROUPS
+          [
+            "#{asset_type}:",
+            @changes.removed.map { |vg, _| Colors.unmanaged("\t#{vg} is attached but not managed by Cumulus") },
+            @changes.added.map { |vg, _| Colors.added("\t#{vg} will be attached to the instance") },
+            @changes.modified.map do |vg, diff|
+              [
+                "\t#{vg}:",
+                diff.changes.map do |diff|
+                  diff.to_s.lines.map { |l| "\t\t#{l}".chomp("\n") }
+                end
+              ]
+            end
+          ].flatten.join("\n")
+        when TAGS
+          tags_diff_string
+        end
+      end
+    end
+  end
+end