cumulus-aws 0.11.1

data/lib/autoscaling/models/AlarmConfig.rb

@@ -0,0 +1,165 @@
+require "autoscaling/models/AlarmDiff"
+
+module Cumulus
+  module AutoScaling
+    # Public: A class that encapsulates data about configuration for an autoscaling
+    # Cloudwatch alarm.
+    #
+    # The action to be taken is inferred to be activating the policy that contains
+    # the alarm. As such, we don't keep arrays of actions to take when various alarm
+    # states are triggered. We just apply the action (activating the policy) to the
+    # states contained in the `action_states` array. Valid values are "alarm", "ok",
+    # and "insufficient-data".
+    class AlarmConfig
+      attr_reader :action_states
+      attr_reader :actions_enabled
+      attr_reader :comparison
+      attr_reader :description
+      attr_reader :dimensions
+      attr_reader :evaluation_periods
+      attr_reader :metric
+      attr_reader :name
+      attr_reader :namespace
+      attr_reader :period
+      attr_reader :statistic
+      attr_reader :threshold
+      attr_reader :unit
+
+      # Public: Constructor
+      #
+      # json - a hash containing the JSON configuration for the alarm
+      def initialize(json = nil)
+        if !json.nil?
+          @action_states = json["action-states"]
+          @actions_enabled = json["actions-enabled"]
+          @comparison = json["comparison"]
+          @description = json["description"]
+          @dimensions = json["dimensions"]
+          @evaluation_periods = json["evaluation-periods"]
+          @metric = json["metric"]
+          @name = json["name"]
+          @namespace = json["namespace"]
+          @period = json["period-seconds"]
+          @statistic = json["statistic"]
+          @threshold = json["threshold"]
+          @unit = json["unit"]
+        end
+      end
+
+      # Public: Get the configuration as a hash
+      #
+      # Returns the hash
+      def hash
+        {
+          "name" => @name,
+          "action-states" => @action_states,
+          "actions-enabled" => @actions_enabled,
+          "comparison" => @comparison,
+          "description" => @description,
+          "dimensions" => @dimensions,
+          "evaluation-periods" => @evaluation_periods,
+          "metric" => @metric,
+          "namespace" => @namespace,
+          "period-seconds" => @period,
+          "statistic" => @statistic,
+          "threshold" => @threshold,
+          "unit" => @unit
+        }.reject { |k, v| v.nil? }
+      end
+
+      # Public: Populate the AlarmConfig from an existing AWS cloudwatch alarm
+      #
+      # policy_arn - the arn of the policy the alarm should be attached to
+      # resource   - the aws resource to populate from
+      def populate(policy_arn, resource)
+        action_states = []
+        if resource.ok_actions.include?(policy_arn) then action_states << "ok" end
+        if resource.alarm_actions.include?(policy_arn) then action_states << "alarm" end
+        if resource.insufficient_data_actions.include?(policy_arn) then action_states << "insufficient-data" end
+
+        @action_states = action_states
+        @actions_enabled = resource.actions_enabled
+        @comparison = resource.comparison_operator
+        @description = resource.alarm_description
+        @dimensions = Hash[resource.dimensions.map { |d| [d.name, d.value] }]
+        @evaluation_periods = resource.evaluation_periods
+        @metric = resource.metric_name
+        @name = resource.alarm_name
+        @namespace = resource.namespace
+        @period = resource.period
+        @statistic = resource.statistic
+        @threshold = resource.threshold
+        @unit = resource.unit
+      end
+
+      # Public: Produce the differences between this local configuration and the
+      # configuration in AWS
+      #
+      # aws        - the alarm in AWS
+      # policy_arn - the policy arn is the action this alarm should take
+      #
+      # Returns an array of AlarmDiff objects representing the differences
+      def diff(aws, policy_arn)
+        diffs = []
+
+        if @description != aws.alarm_description
+          diffs << AlarmDiff.new(AlarmChange::DESCRIPTION, aws, self)
+        end
+        if @actions_enabled != aws.actions_enabled
+          diffs << AlarmDiff.new(AlarmChange::ENABLED, aws, self)
+        end
+        if @comparison != aws.comparison_operator
+          diffs << AlarmDiff.new(AlarmChange::COMPARISON, aws, self)
+        end
+        if @evaluation_periods != aws.evaluation_periods
+          diffs << AlarmDiff.new(AlarmChange::EVALUATION, aws, self)
+        end
+        if @metric != aws.metric_name
+          diffs << AlarmDiff.new(AlarmChange::METRIC, aws, self)
+        end
+        if @namespace != aws.namespace
+          diffs << AlarmDiff.new(AlarmChange::NAMESPACE, aws, self)
+        end
+        if @period != aws.period
+          diffs << AlarmDiff.new(AlarmChange::PERIOD, aws, self)
+        end
+        if @statistic != aws.statistic
+          diffs << AlarmDiff.new(AlarmChange::STATISTIC, aws, self)
+        end
+        if @threshold != aws.threshold
+          diffs << AlarmDiff.new(AlarmChange::THRESHOLD, aws, self)
+        end
+        if @unit != aws.unit
+          diffs << AlarmDiff.new(AlarmChange::UNIT, aws, self)
+        end
+        aws_dimensions = Hash[aws.dimensions.map { |d| [d.name, d.value] }]
+        if @dimensions != aws_dimensions
+          diffs << AlarmDiff.new(AlarmChange::DIMENSIONS, aws, self)
+        end
+
+        ["ok", "alarm", "insufficient-data"].each do |state|
+          case state
+          when "ok"
+            actions = aws.ok_actions
+            change_type = AlarmChange::OK
+          when "alarm"
+            actions = aws.alarm_actions
+            change_type = AlarmChange::ALARM
+          when "insufficient-data"
+            actions = aws.insufficient_data_actions
+            change_type = AlarmChange::INSUFFICIENT
+          end
+
+          if (!@action_states.include?(state) and actions.size != 0) or
+            (@action_states.include?(state) and (actions.size != 1 or actions[0] != policy_arn))
+            diff = AlarmDiff.new(change_type, aws, self)
+            diff.policy_arn = policy_arn
+            diffs << diff
+          end
+        end
+
+        diffs
+      end
+    end
+  end
+end

data/lib/autoscaling/models/AlarmDiff.rb

@@ -0,0 +1,172 @@
+require "common/models/Diff"
+require "util/Colors"
+
+module Cumulus
+  module AutoScaling
+    # Public: The types of changes that can be made to alarms
+    module AlarmChange
+      include Common::DiffChange
+
+      ALARM = Common::DiffChange::next_change_id
+      COMPARISON = Common::DiffChange::next_change_id
+      DESCRIPTION = Common::DiffChange::next_change_id
+      DIMENSIONS = Common::DiffChange::next_change_id
+      ENABLED = Common::DiffChange::next_change_id
+      EVALUATION = Common::DiffChange::next_change_id
+      INSUFFICIENT = Common::DiffChange::next_change_id
+      METRIC = Common::DiffChange::next_change_id
+      NAMESPACE = Common::DiffChange::next_change_id
+      OK = Common::DiffChange::next_change_id
+      PERIOD = Common::DiffChange::next_change_id
+      STATISTIC = Common::DiffChange::next_change_id
+      THRESHOLD = Common::DiffChange::next_change_id
+      UNIT = Common::DiffChange::next_change_id
+    end
+
+    # Public: Represents a single difference between local configuration and AWS
+    # configuration of Cloudwatch alarms
+    class AlarmDiff < Common::Diff
+      include AlarmChange
+
+      attr_accessor :policy_arn
+
+      def diff_string
+        diff_lines = [@local.name]
+
+        case @type
+        when ALARM
+          lines = ["\tAlarm actions:"]
+          lines << alarm_actions_to_remove.map { |a| "\t\t#{Colors.removed(a)}" }
+          lines << alarm_actions_to_add.map { |a| "\t\t#{Colors.added(a)}" }
+          diff_lines << lines.flatten.join("\n")
+        when COMPARISON
+          diff_lines << "\tComparison type: AWS - #{Colors.aws_changes(@aws.comparison_operator)}, Local - #{Colors.local_changes(@local.comparison)}"
+        when DESCRIPTION
+          diff_lines << [
+            "\tDescription:",
+            Colors.aws_changes("\t\tAWS - #{@aws.alarm_description}"),
+            Colors.local_changes("\t\tLocal - #{@local.description}")
+          ].join("\n")
+        when DIMENSIONS
+          lines = ["\tDimensions:"]
+          lines << dimensions_to_remove.map { |d| "\t\t#{Colors.removed(d)}" }
+          lines << dimensions_to_add.map { |d| "\t\t#{Colors.added(d)}" }
+          diff_lines << lines.flatten.join("\n")
+        when ENABLED
+          diff_lines << "\tActions enabled: AWS - #{Colors.aws_changes(@aws.actions_enabled)}, Local - #{Colors.local_changes(@local.actions_enabled)}"
+        when EVALUATION
+          diff_lines << "\tEvaluation periods: AWS - #{Colors.aws_changes(@aws.evaluation_periods)}, Local - #{Colors.local_changes(@local.evaluation_periods)}"
+        when INSUFFICIENT
+          lines = ["\tInsufficient data actions:"]
+          lines << insufficient_actions_to_remove.map { |i| "\t\t#{Colors.removed(i)}" }
+          lines << insufficient_actions_to_add.map { |i| "\t\t#{Colors.added(i)}" }
+          diff_lines << lines.flatten.join("\n")
+        when METRIC
+          diff_lines << "\tMetric: AWS - #{Colors.aws_changes(@aws.metric_name)}, Local - #{Colors.local_changes(@local.metric)}"
+        when NAMESPACE
+          diff_lines << "\tNamespace: AWS - #{Colors.aws_changes(@aws.namespace)}, Local - #{Colors.local_changes(@local.namespace)}"
+        when OK
+          lines = ["\tOk actions:"]
+          lines << ok_actions_to_remove.map { |o| "\t\t#{Colors.removed(o)}" }
+          lines << ok_actions_to_add.map { |o| "\t\t#{Colors.added(o)}" }
+          diff_lines << lines.flatten.join("\n")
+        when PERIOD
+          diff_lines << "\tPeriod seconds: AWS - #{Colors.aws_changes(@aws.period)}, Local - #{Colors.local_changes(@local.period)}"
+        when STATISTIC
+          diff_lines << "\tStatistic: AWS - #{Colors.aws_changes(@aws.statistic)}, Local - #{Colors.local_changes(@local.statistic)}"
+        when THRESHOLD
+          diff_lines << "\tThreshold: AWS - #{Colors.aws_changes(@aws.threshold)}, Local - #{Colors.local_changes(@local.threshold)}"
+        when UNIT
+          diff_lines << "\tUnit: AWS - #{Colors.aws_changes(@aws.unit)}, Local - #{Colors.local_changes(@local.unit)}"
+        end
+
+        diff_lines.flatten.join("\n")
+      end
+
+      def asset_type
+        "Alarm"
+      end
+
+      def aws_name
+        @aws.alarm_name
+      end
+
+      # Public: Get the alarm actions that will be removed
+      #
+      # Returns an array of arns to remove
+      def alarm_actions_to_remove
+        @aws.alarm_actions - local_actions("alarm")
+      end
+
+      # Public: Get the alarm actions that will be added
+      #
+      # Returns an array of arns to add
+      def alarm_actions_to_add
+        local_actions("alarm") - @aws.alarm_actions
+      end
+
+      # Public: Get the dimensions that will be removed
+      #
+      # Returns a hash of key value pairs to be removed
+      def dimensions_to_remove
+        aws_dimensions.reject { |k, v| @local.dimensions.include?(k) and @local.dimensions[k] == v }
+      end
+
+      # Public: Get the dimensions that will be added
+      #
+      # Returns a hash of key value pairs to add
+      def dimensions_to_add
+        @local.dimensions.reject { |k, v| aws_dimensions.include?(k) and aws_dimensions[k] == v }
+      end
+
+      # Public: Get the insufficient data actions that will be removed
+      #
+      # Returns an array of arns to remove
+      def insufficient_actions_to_remove
+        @aws.insufficient_data_actions - local_actions("insufficient-data")
+      end
+
+      # Public: Get the insufficient data actions that will be added
+      #
+      # Returns an array of arns to add
+      def insufficient_actions_to_add
+        local_actions("insufficient-data") - @aws.insufficient_data_actions
+      end
+
+      # Public: Get the ok actions that will be removed
+      #
+      # Returns an array of arns to remove
+      def ok_actions_to_remove
+        @aws.ok_actions - local_actions("ok")
+      end
+
+      # Public: Get the ok actions that will be added
+      #
+      # Returns an array of arns to add
+      def ok_actions_to_add
+        local_actions("ok") - @aws.ok_actions
+      end
+
+      private
+
+      # Internal: Get the actions defined locally for a particular state
+      #
+      # Returns an array of arns
+      def local_actions(state)
+        local_policies = []
+        if @local.action_states.include?(state)
+          local_policies << @policy_arn
+        end
+        local_policies
+      end
+
+      # Internal: Get the AWS dimensions in the same format as local configuration
+      #
+      # Returns a hash of key value pairs
+      def aws_dimensions
+        @aws_dimensions ||= Hash[@aws.dimensions.map { |d| [d.name, d.value] }]
+      end
+
+    end
+  end
+end

data/lib/autoscaling/models/AutoScalingDiff.rb

@@ -0,0 +1,178 @@
+require "common/models/Diff"
+require "common/models/TagsDiff"
+require "common/models/ListChange"
+require "util/Colors"
+
+module Cumulus
+  module AutoScaling
+    # Public: The types of changes that can be made to an AutoScaling Group
+    module AutoScalingChange
+      include Common::DiffChange
+
+      MIN = Common::DiffChange::next_change_id
+      MAX = Common::DiffChange::next_change_id
+      DESIRED = Common::DiffChange::next_change_id
+      METRICS = Common::DiffChange::next_change_id
+      CHECK_TYPE = Common::DiffChange::next_change_id
+      CHECK_GRACE = Common::DiffChange::next_change_id
+      LOAD_BALANCER = Common::DiffChange::next_change_id
+      SUBNETS = Common::DiffChange::next_change_id
+      TAGS = Common::DiffChange::next_change_id
+      TERMINATION = Common::DiffChange::next_change_id
+      COOLDOWN = Common::DiffChange::next_change_id
+      LAUNCH = Common::DiffChange::next_change_id
+      SCHEDULED = Common::DiffChange::next_change_id
+      POLICY = Common::DiffChange::next_change_id
+    end
+
+    # Public: Represents a single difference between local configuration and AWS
+    # configuration of AutoScaling Groups
+    class AutoScalingDiff < Common::Diff
+      include AutoScalingChange
+      include Common::TagsDiff
+
+      attr_accessor :policy_diffs
+
+      # Public: Static method that will produce a diff that contains changes in
+      # scheduled actions
+      #
+      # aws - the array of AWS scheduled actions
+      # local - the map of scheduled action name to local configuration
+      #
+      # Returns the AutoScalingDiff
+      def AutoScalingDiff.scheduled(aws, local)
+        aws_scheduled = Hash[aws.map { |s| [s.scheduled_action_name, s] }]
+
+        removed = aws_scheduled.reject { |k, v| local.include?(k) }.map { |_, sched| ScheduledActionDiff.unmanaged(sched) }
+        added = local.reject { |k, v| aws_scheduled.include? k }.map { |_, sched| ScheduledActionDiff.added(sched) }
+        modified = local.select { |k, v| aws_scheduled.include? k }.map do |name, local_sched|
+          aws_sched = aws_scheduled[name]
+          sched_diffs = local_sched.diff(aws_sched)
+
+          if !sched_diffs.empty?
+            ScheduledActionDiff.modified(aws_sched, local_sched, sched_diffs)
+          end
+        end.reject { |v| !v }
+
+        if !removed.empty? or !added.empty? or !modified.empty?
+          diff = AutoScalingDiff.new(AutoScalingChange::SCHEDULED, aws, local)
+          diff.changes = Common::ListChange.new(added, removed, modified)
+          diff
+        end
+      end
+
+      # Public: Static method that will produce a diff that contains changes in
+      # scaling policies
+      #
+      # local        - the local configuration
+      # policy_diffs - the differences in scaling policies
+      #
+      # Returns the diff
+      def AutoScalingDiff.policies(local, policy_diffs)
+        diff = AutoScalingDiff.new(POLICY, nil, local)
+        diff.policy_diffs = policy_diffs
+        diff
+      end
+
+      def diff_string
+        case @type
+        when LAUNCH
+          "Launch configuration: AWS - #{Colors.aws_changes(@aws.launch_configuration_name)}, Local - #{Colors.local_changes(@local.launch)}"
+        when MIN
+          "Min size: AWS - #{Colors.aws_changes(@aws)}, Local - #{Colors.local_changes(@local)}"
+        when MAX
+          "Max size: AWS - #{Colors.aws_changes(@aws)}, Local - #{Colors.local_changes(@local)}"
+        when DESIRED
+          "Desired size: AWS - #{Colors.aws_changes(@aws)}, Local - #{Colors.local_changes(@local)}"
+        when METRICS
+          lines = ["Enabled Metrics:"]
+          lines << metrics_to_disable.map { |m| "\t#{Colors.removed(m)}" }
+          lines << metrics_to_enable.map { |m| "\t#{Colors.added(m)}" }
+          lines.flatten.join("\n")
+        when CHECK_TYPE
+          "Health check type: AWS - #{Colors.aws_changes(@aws.health_check_type)}, Local - #{Colors.local_changes(@local.check_type)}"
+        when CHECK_GRACE
+          "Health check grace period: AWS - #{Colors.aws_changes(@aws.health_check_grace_period)}, Local - #{Colors.local_changes(@local.check_grace)}"
+        when LOAD_BALANCER
+          lines = ["Load balancers:"]
+          lines << load_balancers_to_remove.map { |l| "\t#{Colors.removed(l)}" }
+          lines << load_balancers_to_add.map { |l| "\t#{Colors.added(l)}" }
+          lines.flatten.join("\n")
+        when SUBNETS
+          lines = ["Subnets:"]
+          lines << (@aws - @local).map { |s| s.vpc_subnet_name || s.subnet_id }.map { |s| "\t#{Colors.removed(s)}" }
+          lines << (@local - @aws).map { |s| s.vpc_subnet_name || s.subnet_id }.map { |s| "\t#{Colors.added(s)}" }
+          lines.flatten.join("\n")
+        when TAGS
+          tags_diff_string
+        when TERMINATION
+          lines = ["Termination policies:"]
+          lines << (@aws.termination_policies - @local.termination).map { |t| "\t#{Colors.removed(t)}" }
+          lines << (@local.termination - @aws.termination_policies).map { |t| "\t#{Colors.added(t)}" }
+          lines.flatten.join("\n")
+        when COOLDOWN
+          "Cooldown: AWS - #{Colors.aws_changes(@aws.default_cooldown)}, Local - #{Colors.local_changes(@local.cooldown)}"
+        when SCHEDULED
+          [
+            "Scheduled Actions:",
+            changes.removed.map { |added_diff| "\t#{added_diff}" },
+            changes.added.map { |removed_diff| "\t#{removed_diff}" },
+            changes.modified.map do |modified_diff|
+              [
+                "\t#{modified_diff.local.name}:",
+                modified_diff.changes.map do |scheduled_diff|
+                  scheduled_diff.to_s.lines.map { |l| "\t\t#{l}".chomp("\n") }
+                end
+              ]
+            end
+          ].flatten.join("\n")
+        when POLICY
+          lines = ["Scaling policies:"]
+          lines << policy_diffs.map { |d| "\t#{d}" }
+          lines.flatten.join("\n")
+        end
+      end
+
+      def asset_type
+        "Autoscaling group"
+      end
+
+      def aws_name
+        @aws.auto_scaling_group_name
+      end
+
+      # Public: Get the metrics to disable, ie. are in AWS but not in local
+      # configuration.
+      #
+      # Returns an array of metrics
+      def metrics_to_disable
+        @aws.enabled_metrics - @local.enabled_metrics
+      end
+
+      # Public: Get the metrics to enable, ie. are in local configuration, but not
+      # AWS.
+      #
+      # Returns an array of metrics
+      def metrics_to_enable
+        @local.enabled_metrics - @aws.enabled_metrics
+      end
+
+      # Public: Get the load balancers to remove, ie. are in AWS and not local
+      # configuration
+      #
+      # Returns an array of load balancer names
+      def load_balancers_to_remove
+        @aws.load_balancer_names - @local.load_balancers
+      end
+
+      # Public: Get the load balancers to add, ie. are in local configuration but
+      # not in AWS
+      #
+      # Returns an array of load balancer names
+      def load_balancers_to_add
+        @local.load_balancers - @aws.load_balancer_names
+      end
+
+    end
+  end
+end