cumulus-aws 0.11.1

data/lib/s3/models/NotificationConfig.rb

@@ -0,0 +1,157 @@
+require "lambda/Lambda"
+require "s3/models/NotificationDiff"
+require "sns/SNS"
+require "sqs/SQS"
+
+module Cumulus
+  module S3
+    class NotificationConfig
+      attr_reader :name
+      attr_reader :prefix
+      attr_reader :suffix
+      attr_reader :target
+      attr_reader :triggers
+      attr_reader :type
+
+      # Public: Constructor
+      #
+      # json - a hash representing the JSON configuration. Expects to be passed
+      #        an object from the "notifications" array of S3 bucket configuration.
+      def initialize(json = nil)
+        if json
+          @name = json["name"]
+          @prefix = json["prefix"]
+          @suffix = json["suffix"]
+          @target = json["target"]
+          @triggers = (json["triggers"] || []).map { |t| "s3:#{t}" }
+          @type = json["type"]
+        end
+      end
+
+      # Public: Populate this NotificationConfig with the values in an AWS configuration
+      # of events.
+      #
+      # aws - the aws object to populate from
+      def populate!(aws)
+        @name = aws.id
+        @prefix = aws.filter.key.filter_rules.find { |r| r.name.downcase == "prefix" }.value rescue nil
+        @suffix = aws.filter.key.filter_rules.find { |r| r.name.downcase == "suffix" }.value rescue nil
+        @triggers = aws.events
+        if aws.respond_to? "queue_arn"
+          @type = "sqs"
+          @target = aws.queue_arn[(aws.queue_arn.rindex(":") + 1)..-1]
+        elsif aws.respond_to? "lambda_function_arn"
+          @type = "lambda"
+          @target = aws.lambda_function_arn[(aws.lambda_function_arn.rindex(":") + 1)..-1]
+        else
+          @type = "sns"
+          @target = aws.topic_arn[(aws.topic_arn.rindex(":") + 1)..-1]
+        end
+      end
+
+      # Public: Produce an AWS compatible hash for this NotificationConfig.
+      #
+      # Returns the hash.
+      def to_aws
+        if @type == "sns"
+          topic_arn = SNS.get_aws(@target)
+        elsif @type == "sqs"
+          queue_arn = SQS.get_arn(@target)
+        elsif @type == "lambda"
+          lambda_function_arn = Lambda.get_aws(@target).function_arn
+        end
+        {
+          id: @name,
+          events: @triggers,
+          topic_arn: topic_arn,
+          queue_arn: queue_arn,
+          lambda_function_arn: lambda_function_arn,
+          filter: {
+            key: {
+              filter_rules: [
+                if @prefix then {
+                  name: "prefix",
+                  value: @prefix
+                } end,
+                if @suffix then {
+                  name: "suffix",
+                  value: @suffix
+                } end
+              ].reject { |e| e.nil? }
+            }.reject { |k, v| v.nil? or v.empty? }
+          }.reject { |k, v| v.nil? or v.empty? }
+        }.reject { |k, v| v.nil? or v.empty? }
+      end
+
+      # Public: Produce an AWS compatible hash for this NotificationConfig.
+      #
+      # Returns the hash
+      def to_h
+        {
+          name: @name,
+          triggers: @triggers.map { |t| t[3..-1] }, # substring off the "s3:"
+          prefix: @prefix,
+          suffix: @suffix,
+          type: @type,
+          target: @target,
+        }.reject { |k, v| v.nil? }
+      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 NotificationDiffs that were found
+      def diff(aws)
+        diffs = []
+
+        if @prefix != aws.prefix
+          diffs << NotificationDiff.new(NotificationChange::PREFIX, aws, self)
+        end
+        if @suffix != aws.suffix
+          diffs << NotificationDiff.new(NotificationChange::SUFFIX, aws, self)
+        end
+        if @triggers.sort != aws.triggers.sort
+          diffs << NotificationDiff.new(NotificationChange::TRIGGERS, aws, self)
+        end
+        if @type != aws.type
+          diffs << NotificationDiff.new(NotificationChange::TYPE, aws, self)
+        end
+        if @target != aws.target
+          diffs << NotificationDiff.new(NotificationChange::TARGET, aws, self)
+        end
+
+        diffs
+      end
+
+      # Public: Check NotificationConfig equality with other objects.
+      #
+      # other - the other object to check
+      #
+      # Returns whether this NotificationConfig is equal to `other`
+      def ==(other)
+        if !other.is_a? NotificationConfig or
+            @name != other.name or
+            @prefix != other.prefix or
+            @suffix != other.suffix or
+            @target != other.target or
+            @triggers.sort != other.triggers.sort or
+            @type != other.type
+          false
+        else
+          true
+        end
+      end
+
+      # Public: Check if this NotificationConfig is not equal to the other object
+      #
+      # other - the other object to check
+      #
+      # Returns whether this NotificationConfig is not equal to `other`
+      def !=(other)
+        !(self == other)
+      end
+    end
+  end
+end

data/lib/s3/models/NotificationDiff.rb

@@ -0,0 +1,62 @@
+require "common/models/Diff"
+require "common/models/ListChange"
+require "util/Colors"
+
+module Cumulus
+  module S3
+    # Public: The types of changes that can be made to an S3 Notification
+    module NotificationChange
+      include Common::DiffChange
+
+      PREFIX = Common::DiffChange.next_change_id
+      SUFFIX = Common::DiffChange.next_change_id
+      TRIGGERS = Common::DiffChange.next_change_id
+      TYPE = Common::DiffChange.next_change_id
+      TARGET = Common::DiffChange.next_change_id
+    end
+
+    # Public: Represents a single difference between local configuration and AWS
+    # S3 Notification configuration
+    class NotificationDiff < Common::Diff
+      include NotificationChange
+
+      def initialize(type, aws = nil, local = nil)
+        super(type, aws, local)
+
+        if aws and local
+          @triggers = Common::ListChange.new(
+            local.triggers - aws.triggers,
+            aws.triggers - local.triggers
+          )
+        end
+      end
+
+      def asset_type
+        "Notification"
+      end
+
+      def aws_name
+        @aws.name
+      end
+
+      def diff_string
+        case @type
+        when PREFIX
+          "Prefix: AWS - #{Colors.aws_changes(@aws.prefix)}, Local - #{Colors.local_changes(@local.prefix)}"
+        when SUFFIX
+          "Suffix: AWS - #{Colors.aws_changes(@aws.suffix)}, Local - #{Colors.local_changes(@local.suffix)}"
+        when TRIGGERS
+          [
+            "Triggers:",
+            @triggers.removed.map { |t| Colors.removed("\t#{t}") },
+            @triggers.added.map { |t| Colors.added("\t#{t}") },
+          ].flatten.join("\n")
+        when TYPE
+          "Type: AWS - #{Colors.aws_changes(@aws.type)}, Local - #{Colors.local_changes(@local.type)}"
+        when TARGET
+          "Target: AWS - #{Colors.aws_changes(@aws.target)}, Local - #{Colors.local_changes(@local.target)}"
+        end
+      end
+    end
+  end
+end

data/lib/s3/models/ReplicationConfig.rb

@@ -0,0 +1,133 @@
+require "s3/models/ReplicationDiff"
+require "iam/IAM"
+require "util/Colors"
+
+module Cumulus
+  module S3
+    class ReplicationConfig
+      attr_reader :destination
+      attr_reader :iam_role
+      attr_reader :prefixes
+
+      # Public: Constructor
+      #
+      # json - a hash representing the JSON configuration. Expects to be passed
+      # the "replication" node of S3 bucket configuration.
+      def initialize(json = nil)
+        if json
+          @destination = json["destination"]
+          @iam_role = json["iam-role"]
+          @prefixes = json["prefixes"] || []
+        end
+      end
+
+      # Public: Produce an AWS hash representing this ReplicationConfig
+      #
+      # Returns the hash
+      def to_aws
+        role_arn = IAM.get_role_arn(@iam_role)
+        if role_arn.nil?
+          puts Colors.red("No IAM role named #{name}")
+          exit
+        end
+
+        {
+          role: role_arn,
+          rules: if @prefixes.empty?
+            [{
+              prefix: "",
+              status: "Enabled",
+              destination: {
+                bucket: "arn:aws:s3:::#{@destination}"
+              }
+            }]
+          else
+            @prefixes.map do |prefix|
+              {
+                prefix: prefix,
+                status: "Enabled",
+                destination: {
+                  bucket: "arn:aws:s3:::#{@destination}"
+                }
+              }
+            end
+          end
+        }
+      end
+
+      # Public: Converts this ReplicationConfig to a hash that matches Cumulus
+      # configuration.
+      #
+      # Returns the hash
+      def to_h
+        {
+          "iam-role" => @iam_role,
+          "prefixes" => if !@prefixes.empty? then @prefixes end,
+          "destination" => @destination,
+        }.reject { |k, v| v.nil? }
+      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 ReplicationDiff that were found
+      def diff(aws)
+        diffs = []
+
+        if @destination != aws.destination
+          diffs << ReplicationDiff.new(ReplicationChange::DESTINATION, aws, self)
+        end
+        if @iam_role != aws.iam_role
+          diffs << ReplicationDiff.new(ReplicationChange::ROLE, aws, self)
+        end
+        if @prefixes.sort != aws.prefixes
+          diffs << ReplicationDiff.new(ReplicationChange::PREFIX, aws, self)
+        end
+
+        diffs
+      end
+
+      # Public: Populate this ReplicationConfig with the values in an AWS
+      # replication configuration.
+      #
+      # aws - the aws object to populate from
+      def populate!(aws)
+        @destination = aws.rules[0].destination.bucket
+        @destination = @destination[(@destination.rindex(":") + 1)..-1]
+        @iam_role = aws.role[(aws.role.rindex("/") + 1)..-1]
+        @prefixes = aws.rules.map(&:prefix)
+
+        if @prefixes.size == 1 and @prefixes[0] == ""
+          @prefixes = []
+        end
+      end
+
+      # Public: Check ReplicationConfig equality with other objects.
+      #
+      # other - the other object to check
+      #
+      # Returns whether this ReplicationConfig is equal to `other`
+      def ==(other)
+        if !other.is_a? ReplicationConfig or
+            @destination != other.destination or
+            @iam_role != other.iam_role or
+            @prefixes.sort != other.prefix.sort
+          false
+        else
+          true
+        end
+      end
+
+      # Public: Check if this ReplicationConfig is not equal to the other object
+      #
+      # other - the other object to check
+      #
+      # Returns whether this ReplicationConfig is not equal to `other`
+      def !=(other)
+        !(self == other)
+      end
+    end
+  end
+end

data/lib/s3/models/ReplicationDiff.rb

@@ -0,0 +1,60 @@
+require "common/models/Diff"
+require "common/models/ListChange"
+require "util/Colors"
+
+module Cumulus
+  module S3
+    # Public: The types of changes that can be made to S3 Replication
+    module ReplicationChange
+      include Common::DiffChange
+
+      DESTINATION = Common::DiffChange.next_change_id
+      PREFIX = Common::DiffChange.next_change_id
+      ROLE = Common::DiffChange.next_change_id
+    end
+
+    # Public: Represents a single difference between local configuration and AWS
+    # S3 Replication configuration.
+    class ReplicationDiff < Common::Diff
+      include ReplicationChange
+
+      def initialize(type, aws = nil, local = nil)
+        super(type, aws, local)
+
+        if aws and local
+          @prefixes = Common::ListChange.new(
+            local.prefixes - aws.prefixes,
+            aws.prefixes - local.prefixes
+          )
+        end
+      end
+
+      def asset_type
+        "S3 Replication"
+      end
+
+      def aws_name
+        "Configuration"
+      end
+
+      def local_name
+        "Configuration"
+      end
+
+      def diff_string
+        case @type
+        when DESTINATION
+          "Destination: AWS - #{Colors.aws_changes(@aws.destination)}, Local - #{Colors.local_changes(@local.destination)}"
+        when ROLE
+          "IAM Role: AWS - #{Colors.aws_changes(@aws.iam_role)}, Local - #{Colors.local_changes(@local.iam_role)}"
+        when PREFIX
+          [
+            "Prefixes:",
+            @prefixes.removed.map { |p| Colors.removed("\t#{p}") },
+            @prefixes.added.map { |p| Colors.added("\t#{p}") },
+          ].flatten.join("\n")
+        end
+      end
+    end
+  end
+end

data/lib/s3/models/WebsiteConfig.rb

@@ -0,0 +1,107 @@
+module Cumulus
+  module S3
+    class WebsiteConfig
+      attr_reader :error
+      attr_reader :index
+      attr_reader :redirect
+
+      # Public: Constructor
+      #
+      # json - a hash representing the JSON configuration, expects to be handed
+      #        the 'website' node of S3 configuration.
+      def initialize(json = nil)
+        if json
+          @redirect = json["redirect"]
+          @index = json["index"]
+          @error = json["error"]
+        end
+      end
+
+      # Public: Populate this WebsiteConfig with the values in an AWS WebsiteConfiguration
+      # object.
+      #
+      # aws - the aws object to populate from
+      def populate!(aws)
+        @index = aws.safe_index
+        @error = aws.safe_error
+        @redirect = aws.safe_redirection
+      end
+
+      # Public: Produce a hash that is compatible with AWS website configuration.
+      #
+      # Returns the website configuration in AWS format
+      def to_aws
+        if @index
+          {
+            error_document: {
+              key: @error
+            },
+            index_document: {
+              suffix: @index
+            },
+          }
+        else
+          {
+            redirect_all_requests_to: {
+              host_name: if @redirect and @redirect.include?("://")
+                  @redirect.split("://")[1]
+                else
+                  @redirect
+                end,
+              protocol: if @redirect and @redirect.include?("://") then @redirect.split("://")[0] end
+            }
+          }
+        end
+      end
+
+      # Public: Converts this WebsiteConfig to a hash that matches Cumulus
+      # configuration.
+      #
+      # Returns the hash
+      def to_h
+        {
+          error: @error,
+          index: @index,
+          redirect: @redirect,
+        }.reject { |k, v| v.nil? }
+      end
+
+      # Public: Check WebsiteConfig equality with other objects
+      #
+      # other - the other object to check
+      #
+      # Returns whether this WebsiteConfig is equal to `other`
+      def ==(other)
+        if !other.is_a? WebsiteConfig or
+            @redirect != other.redirect or
+            @index != other.index or
+            @error != other.error
+          false
+        else
+          true
+        end
+      end
+
+      # Public: Check if this WebsiteConfig is not equal to the other object
+      #
+      # other - the other object to check
+      #
+      # Returns whether this WebsiteConfig is not equal to `other`
+      def !=(other)
+        !(self == other)
+      end
+
+      def to_s
+        if @redirect
+          "Redirect all traffic to #{@redirect}"
+        elsif @index
+          if @error
+            "Index document: #{@index}, Error document: #{@error}"
+          else
+            "Index document: #{@index}"
+          end
+        end
+      end
+    end
+  end
+end