awshark 1.0.0

data/lib/awshark/rds/check_reservations.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module Awshark
+  module Rds
+    class CheckReservations
+      attr_reader :instances, :reservations
+
+      def initialize(instances:, reservations:)
+        @instances = instances
+        @reservations = reservations
+      end
+
+      def type_permutations
+        type_permutations_hash = {}
+
+        (reservations + instances).each do |instance|
+          key = "#{instance.type}+#{instance.multi_az}"
+          type_permutations_hash[key] = {
+            type: instance.type,
+            multi_az: instance.multi_az
+          }
+        end
+
+        type_permutations_hash.values
+      end
+
+      def check
+        type_permutations.map do |permutation|
+          type = permutation[:type]
+          multi_az = permutation[:multi_az]
+
+          instance_count = count_instances(type, multi_az)
+          reserved_count = count_reservations(type, multi_az)
+
+          OpenStruct.new(
+            type: type,
+            multi_az: multi_az,
+            instance_count: instance_count,
+            reserved_count: reserved_count
+          )
+        end
+      end
+
+      def count_instances(type, multi_az)
+        instances.select do |i|
+          i.type == type && i.multi_az == multi_az
+        end.size
+      end
+
+      def count_reservations(type, multi_az)
+        reservation = reservations.detect do |r|
+          r.type == type && r.multi_az == multi_az
+        end
+
+        reservation ? reservation.count : 0
+      end
+    end
+  end
+end

data/lib/awshark/rds/manager.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+# TODO: also work for DB clusters
+
+module Awshark
+  module Rds
+    class Manager
+      def instances
+        return @instances if defined?(@instances)
+
+        @instances = []
+        response = client.describe_db_instances
+
+        response[:db_instances].each do |instance|
+          @instances << OpenStruct.new(
+            name: instance[:db_instance_identifier],
+            type: instance[:db_instance_class],
+            state: instance[:db_instance_status],
+            multi_az: instance[:multi_az],
+            engine: instance[:engine],
+            engine_version: instance[:engine_version],
+            encrypted: instance[:storage_encrypted],
+            storage_type: instance[:storage_type]
+          )
+        end
+
+        @instances
+      end
+
+      def reservations
+        return @reservations if defined?(@reservations)
+
+        response = client.describe_reserved_db_instances
+
+        @reservations = response[:reserved_db_instances].map do |instance|
+          OpenStruct.new(
+            count: instance[:db_instance_count],
+            type: instance[:db_instance_class],
+            multi_az: instance[:multi_az],
+            state: instance[:state],
+            offering_type: instance[:offering_type]
+          )
+        end
+        @reservations.select! { |ri| ri[:state] == 'active' }
+
+        @reservations
+      end
+
+      def check_reservations
+        CheckReservations.new(instances: instances, reservations: reservations).check
+      end
+
+      private
+
+      def client
+        @client ||= Aws::RDS::Client.new(
+          region: Aws.config[:region] || 'eu-central-1'
+        )
+      end
+    end
+  end
+end

data/lib/awshark/s3/artifact.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Awshark
+  module S3
+    class Artifact
+      attr_reader :key
+
+      def initialize(key)
+        @key = key
+      end
+
+      def cache_control
+        return "public, max-age=#{1.year.to_i}, s-maxage=#{1.year.to_i}" if fingerprint?
+
+        'public, max-age=0, s-maxage=120, must-revalidate'
+      end
+
+      def fingerprint?
+        return false if key.blank?
+
+        basename.match(/\.([0-9a-f]{20}|[0-9a-f]{32})\./).present?
+      end
+
+      def content_type
+        mime = MiniMime.lookup_by_filename(basename)
+        if mime
+          mime.content_type
+        else
+          'application/octet-stream'
+        end
+      end
+
+      def basename
+        ::File.basename(key)
+      end
+    end
+  end
+end

data/lib/awshark/s3/bucket.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module Awshark
+  module S3
+    class Bucket
+      attr_reader :name, :creation_date, :region
+
+      def initialize(attributes)
+        @name = attributes.name
+        @creation_date = attributes.creation_date
+        @region = attributes.region
+
+        # fixes S3 quirks
+        @region = 'eu-west-1' if @region == 'EU'
+      end
+
+      def byte_size
+        metric_value(metric_name: 'BucketSizeBytes', storage_type: 'StandardStorage')
+      end
+
+      def number_of_objects
+        metric_value(metric_name: 'NumberOfObjects', storage_type: 'AllStorageTypes')
+      end
+
+      private
+
+      def cloudwatch
+        @cloudwatch ||= Aws::CloudWatch::Client.new(region: region)
+      end
+
+      def metric_value(metric_name:, storage_type:)
+        return 0 unless region.present?
+
+        response = cloudwatch.get_metric_statistics(
+          namespace: 'AWS/S3',
+          metric_name: metric_name,
+          dimensions: [
+            {
+              name: 'BucketName',
+              value: name
+            },
+            {
+              name: 'StorageType',
+              value: storage_type
+            }
+          ],
+          start_time: Time.now - 7.days,
+          end_time: Time.now,
+          period: 86_400,
+          statistics: ['Average']
+        )
+        return 0 if response.datapoints.empty?
+
+        sorted_datapoints = response.datapoints.sort_by(&:timestamp)
+        sorted_datapoints.last.average
+      end
+    end
+  end
+end

data/lib/awshark/s3/manager.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module Awshark
+  module S3
+    class Manager
+      def list_buckets
+        response = client.list_buckets
+        response.buckets.map do |bucket|
+          attributes = OpenStruct.new(bucket.to_hash)
+          location = client.get_bucket_location(bucket: bucket.name)
+          attributes.region = location.location_constraint
+          Awshark::S3::Bucket.new(attributes)
+        end
+      end
+
+      def list_objects(bucket:, prefix: nil)
+        objects = []
+        response = client.list_objects_v2(bucket: bucket, prefix: prefix)
+        objects.concat(response.contents)
+
+        while response.next_continuation_token
+          response = client.list_objects_v2(
+            bucket: bucket,
+            prefix: prefix,
+            continuation_token: response.next_continuation_token
+          )
+          objects.concat(response.contents)
+        end
+
+        objects.select { |o| o.size.positive? }
+      end
+
+      def update_object_metadata(bucket, key, options = {})
+        raise ArgumentError, 'meta=acl:STRING is missing' if options[:acl].blank?
+
+        object = client.get_object(bucket: bucket, key: key)
+        metadata = object.metadata.merge(options[:metadata] || {})
+        artifact = Artifact.new(key)
+
+        # copy object in place to update metadata
+        client.copy_object(
+          acl: options[:acl] || 'private',
+          bucket: bucket,
+          copy_source: "/#{bucket}/#{key}",
+          key: key,
+          cache_control: options[:cache_control] || object.cache_control,
+          content_type: artifact.content_type,
+          metadata: metadata.stringify_keys,
+          metadata_directive: 'REPLACE',
+          server_side_encryption: 'AES256'
+        )
+      end
+
+      private
+
+      def client
+        @client ||= Aws::S3::Client.new(
+          region: Aws.config[:region] || 'eu-central-1',
+          signature_version: 'v4'
+        )
+      end
+    end
+  end
+end

data/lib/awshark/subcommands/class_options.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Awshark
+  module Subcommands
+    module ClassOptions
+      def process_class_options
+        command = current_command_chain.last
+        cli_options = options.merge(parent_options || {}).symbolize_keys
+
+        if cli_options[:help]
+          respond_to?(command) ? help(command) : help
+          exit(0)
+        end
+
+        setup_aws_credentials(options)
+      end
+
+      private
+
+      def setup_aws_credentials(options)
+        profile_resolver = ProfileResolver.new(options)
+
+        ::Aws.config[:region] = profile_resolver.region
+        ::Aws.config[:credentials] = profile_resolver.credentials
+      end
+    end
+  end
+end

data/lib/awshark/subcommands/cloud_formation.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+require 'aws-sdk-cloudformation'
+require 'diffy'
+require 'recursive-open-struct'
+
+require 'awshark/cloud_formation/file_loading'
+require 'awshark/cloud_formation/inferrer'
+require 'awshark/cloud_formation/manager'
+require 'awshark/cloud_formation/parameters'
+require 'awshark/cloud_formation/stack'
+require 'awshark/cloud_formation/stack_events'
+require 'awshark/cloud_formation/template'
+
+module Awshark
+  module Subcommands
+    class CloudFormation < Thor
+      include Awshark::Subcommands::ClassOptions
+
+      class_option :bucket, type: :string, desc: 'S3 bucket for template'
+      class_option :iam, type: :boolean, desc: 'Needs IAM capabilities'
+      class_option :stage, type: :string, desc: 'Stage of the configuration'
+
+      desc 'deploy', 'Updates or creates an AWS CloudFormation stack'
+      long_desc <<-LONGDESC
+        Updates or creates a CloudFormation stack on AWS.
+
+        awshark cf deploy TEMPLATE_PATH CAPABILITIES
+
+        Examples:
+
+          awshark cf deploy foo_template
+
+          awshark cf deploy iam_template IAM
+      LONGDESC
+      def deploy(template_path)
+        process_class_options
+
+        manager = create_manager(template_path)
+        print_stack_information(manager.stack)
+
+        manager.update_stack
+        sleep(2)
+        manager.tail_stack_events
+      rescue GracefulFail => e
+        puts e.message
+      end
+
+      desc 'diff', 'Show diff between local stack template and AWS CloudFormation'
+      long_desc <<-LONGDESC
+        Shows colored diff between local stack template and AWS CloudFormation
+
+        Example: `awshark cf diff TEMPLATE_PATH`
+      LONGDESC
+      def diff(template_path)
+        process_class_options
+
+        manager = create_manager(template_path)
+        print_stack_information(manager.stack)
+
+        diff = manager.diff_stack_template
+        puts diff
+      end
+
+      private
+
+      def create_manager(template_path)
+        Awshark::CloudFormation::Manager.new(template_path, options.symbolize_keys)
+      end
+
+      def print_stack_information(stack)
+        if stack.exists?
+          args = { name: stack.name, created_at: stack.creation_time }
+          printf "Stack: %-20<name>s (created at %<created_at>s)\n\n", args
+        else
+          printf "Stack: %<name>s\n\n", name: stack.name
+        end
+      end
+    end
+  end
+end

data/lib/awshark/subcommands/ec2.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require 'aws-sdk-ec2'
+
+require 'awshark/ec2/instance'
+require 'awshark/ec2/manager'
+
+module Awshark
+  module Subcommands
+    class EC2 < Thor
+      include Awshark::Subcommands::ClassOptions
+
+      desc 'list', 'List all EC2 instances'
+      long_desc <<-LONGDESC
+        List all EC2 instances in a region
+
+        Example: `awshark ec2 list STATE`
+      LONGDESC
+      def list(state = 'running')
+        process_class_options
+
+        instances = manager.public_send("#{state}_instances")
+        instances = instances.sort_by(&:name)
+
+        instances.each do |i|
+          args = { name: i.name, type: i.type, public_dns: i.public_dns_name, state: i.state }
+          printf "%-40<name>s %-12<type>s %-60<public_dns>s %<state>s\n", args
+        end
+      end
+
+      private
+
+      def manager
+        @manager ||= Awshark::EC2::Manager.new
+      end
+    end
+  end
+end

data/lib/awshark/subcommands/ecs.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require 'aws-sdk-ecr'
+
+module Awshark
+  module Subcommands
+    class Ecs < Thor
+      include Awshark::Subcommands::ClassOptions
+
+      desc 'login', 'docker login to AWS ECR'
+      long_desc <<-LONGDESC
+        Use docker login with AWS credentials to Elastic Container Registry
+
+        Example: `awshark ecs login`
+      LONGDESC
+      def login
+        response = client.get_authorization_token
+        token = Base64.decode64(response.authorization_data.first.authorization_token)
+
+        user_name = token.split(':').first
+        password = token.split(':').last
+        url = "https://#{Awshark.config.aws_account_id}.dkr.ecr.eu-central-1.amazonaws.com"
+
+        `docker login -u #{user_name} -p #{password} #{url}`
+      end
+
+      private
+
+      def client
+        @client ||= Aws::ECR::Client.new(region: region)
+      end
+
+      def region
+        Aws.config[:region] || 'eu-central-1'
+      end
+    end
+  end
+end