seiton 0.0.1

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/exe/seiton

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+
+require "seiton"
+
+Seiton::CLI.start

data/lib/seiton.rb

@@ -0,0 +1,15 @@
+require "seiton/cli"
+require "seiton/client"
+require "seiton/common"
+require "seiton/ext"
+require "seiton/ec2_check"
+require "seiton/ec2"
+require "seiton/rds_check"
+require "seiton/rds"
+require "seiton/sqs_check"
+require "seiton/sqs"
+require "seiton/version"
+
+module Seiton
+  # Your code goes here...
+end

data/lib/seiton/cli.rb

@@ -0,0 +1,88 @@
+# coding: utf-8
+require 'thor'
+require 'aws-sdk'
+require 'date'
+require 'time'
+require 'terminal-table'
+require 'logger'
+require 'erb'
+
+module Seiton
+  class CLI < Thor
+    default_command :version
+
+    desc 'version', 'Print the version number.'
+    def version
+      puts Seiton::VERSION
+    end
+
+    desc 'ami', 'Delete the EC2 AMI.'
+    option :before_datetime, type: :string, aliases: '-b', desc: 'Specify the date and time for deletion (delete resources before the specified date and time.)'
+    option :ignores, type: :array, aliases: '-i', desc: 'Specify resources to be undeleted (you can specify multiple resources).'
+    option :check, type: :boolean, aliases: '-c', desc: 'Check the resources to be deleted.'
+    def ami
+      unless options[:before_datetime] then
+        puts '--before-datetime must be specified. (--before-datetime=YYYY/MM/DD)'
+        exit 1
+      end
+      seiton = Seiton::Ec2.new
+      seiton.ec2_image(options[:check], options[:before_datetime], options[:ignores])
+    end
+
+    desc 'ec2_snapshot', 'Delete the EC2 Snapshot.'
+    option :before_datetime, type: :string, aliases: '-b', desc: 'Specify the date and time for deletion (delete resources before the specified date and time.)'
+    option :ignores, type: :array, aliases: '-i', desc: 'Specify resources to be undeleted (you can specify multiple resources).'
+    option :check, type: :boolean, aliases: '-c', desc: 'Check the resources to be deleted.'
+    def ec2_snapshot
+      unless options[:before_datetime] then
+        puts '--before-datetime must be specified. (--before-datetime=YYYY/MM/DD)'
+        exit 1
+      end
+      seiton = Seiton::Ec2.new
+      seiton.ec2_snapshots(options[:check], options[:before_datetime], options[:ignores])
+    end
+
+    desc 'instance', 'Delete the EC2 Instance.'
+    option :before_datetime, type: :string, aliases: '-b', desc: 'Specify the date and time for deletion (delete resources before the specified date and time.)'
+    option :ignores, type: :array, aliases: '-i', desc: 'Specify resources to be undeleted (you can specify multiple resources).'
+    option :check, type: :boolean, aliases: '-c', desc: 'Check the resources to be deleted.'
+    def instance
+      unless options[:before_datetime] then
+        puts '--before-datetime must be specified. (--before-datetime=YYYY/MM/DD)'
+        exit 1
+      end
+      seiton = Seiton::Ec2.new
+      seiton.ec2_instance(options[:check], options[:before_datetime], options[:ignores])
+    end
+
+    desc 'rds_snapshot', 'Delete the RDS Snapshot.'
+    option :before_datetime, type: :string, aliases: '-b', desc: 'Specify the date and time for deletion (delete resources before the specified date and time.)'
+    option :ignores, type: :array, aliases: '-i', desc: 'Specify resources to be undeleted (you can specify multiple resources).'
+    option :check, type: :boolean, aliases: '-c', desc: 'Check the resources to be deleted.'
+    def rds_snapshot
+      unless options[:before_datetime] then
+        puts '--before-datetime must be specified. (--before-datetime=YYYY/MM/DD)'
+        exit 1
+      end
+      seiton = Seiton::Rds.new
+      seiton.rds_snapshot(options[:check], options[:before_datetime], options[:ignores])
+    end
+
+    desc 'eip', 'Delete the Elastic IP.'
+    option :ignores, type: :array, aliases: '-i', desc: 'Specify resources to be undeleted (you can specify multiple resources).'
+    option :check, type: :boolean, aliases: '-c', desc: 'Check the resources to be deleted.'
+    def eip
+      seiton = Seiton::Ec2.new
+      seiton.eip(options[:check], options[:ignores])
+    end
+
+    desc 'sqs_queue', 'Delete the SQS Queue.'
+    option :ignores, type: :array, aliases: '-i', desc: 'Specify resources to be undeleted (you can specify multiple resources).'
+    option :check, type: :boolean, aliases: '-c', desc: 'Check the resources to be deleted.'
+    def sqs_queue
+      seiton = Seiton::Sqs.new
+      seiton.sqs_queue(options[:check], options[:ignores])
+    end
+
+  end
+end

data/lib/seiton/client.rb

@@ -0,0 +1,119 @@
+module Seiton
+  class Client
+
+    def initialize
+      raise 'AWS_PROFILE does not exist.' unless ENV['AWS_PROFILE']
+      raise 'AWS_REGION does not exist.' unless ENV['AWS_REGION']
+    end
+
+    CLIENTS = {
+      iam_user: Aws::IAM::CurrentUser,
+      ec2_client: Aws::EC2::Client,
+      rds_client: Aws::RDS::Client,
+      sqs_client: Aws::SQS::Client
+    }
+
+    CLIENTS.each do |method_name, client|
+      define_method method_name do
+        eval "@#{method_name} ||= #{client}.new"
+      end
+    end
+
+    resource_types = %w(image snapshot db_snapshot eip instance volume sqs_queue)
+    resource_types.each do |type|
+      define_method 'display_' + type + '_resources' do |*args|
+        log.info('The following resources will be removed.')
+        resource_rows = []
+        header = []
+        args.first.each do |res|
+          case type
+          when 'instance' then
+            header = [ 'tag:Name', 'ID', 'Launch Time' ]
+            resource_rows << \
+              [ name_tag(res.tags).value, res.instance_id, res.launch_time ]
+          when 'volume' then
+            header = [ 'tag:Name', 'ID', 'Create Time', 'State' ]
+            if res.tags.empty?
+              resource_rows << \
+                [ '', res.volume_id, res.create_time, res.state ]
+            else
+              resource_rows << \
+                [ name_tag(res.tags).value, res.volume_id, res.create_time, res.state ]
+            end
+          when 'image' then
+            header = [ 'tag:Name', 'Name', 'ID', 'Creation Date' ]
+            if res.tags.empty?
+              resource_rows << \
+                [ '', res.name, res.image_id, res.creation_date ]
+            else
+              resource_rows << \
+                [ name_tag(res.tags).value, res.name, res.image_id, res.creation_date ]
+            end
+          when 'snapshot' then
+            header = [ 'tag:Name', 'ID', 'Start Time', 'Description' ]
+            if res.tags.empty?
+              resource_rows << \
+                [ '', res.snapshot_id, res.start_time, res.description ]
+            else
+              resource_rows << \
+                [ name_tag(res.tags).value, res.snapshot_id, res.start_time, res.description ]
+            end
+          when 'db_snapshot' then
+            header = [ 'Name', 'Create Time' ]
+            resource_rows << [ res.db_cluster_snapshot_identifier, res.snapshot_create_time ]
+          when 'eip' then
+            header = [ 'Public IP', 'Allocation ID' ]
+            resource_rows << [ res.public_ip, res.allocation_id ]
+          when 'sqs_queue' then
+            header = [ 'Queue URL' ]
+            resource_rows << [ res ]
+          end
+        end
+        Terminal::Table.new :headings => header, :rows => resource_rows
+      end
+
+      define_method 'delete_' + type + '_action' do |*args|
+        log.info('Delete Resource ' + type + ' : ' + args.first)
+        begin
+          case type
+          when 'instance' then
+            # puts args.first
+            req = { instance_ids: [ args.first ] }
+            method_name = 'terminate_' + type + 's'
+            ec2_client.method(method_name).call(req)
+          when 'volume' then
+            # puts args.first
+            req = { volume_id: args.first }
+            method_name = 'delete_' + type
+            ec2_client.method(method_name).call(req)
+          when 'image' then
+            req = { image_id: args.first }
+            method_name = 'deregister_' + type
+            ec2_client.method(method_name).call(req)
+          when 'snapshot' then
+            req = { snapshot_id: args.first }
+            method_name = 'delete_' + type
+            ec2_client.method(method_name).call(req)
+          when 'db_snapshot' then
+            req = { db_cluster_snapshot_identifier: args.first }
+            method_name = 'delete_db_cluster_snapshot'
+            rds_client.method(method_name).call(req)
+          when 'eip' then
+            req = { allocation_id: args.first }
+            method_name = 'release_address'
+            ec2_client.method(method_name).call(req)
+          when 'sqs_queue' then
+            req = { queue_url: args.first }
+            method_name = 'delete_queue'
+            sqs_client.method(method_name).call(req)
+          end
+
+          log.info('Deleted.')
+        rescue StandardError => e
+          log.error('Failed to delete.' + e.to_s)
+        end
+      end
+    end
+
+  end
+end

data/lib/seiton/common.rb

@@ -0,0 +1,42 @@
+module Seiton
+  module Helper
+    def process_ok?
+      while true
+        puts 'Do you want to continue? [y|n]:'
+        response = STDIN.gets.chomp
+        case response
+        when /^[yY]/
+          log.info('Continue.')
+          return true
+        when /^[nN]/, /^$/
+          log.warn('Abort.')
+          return false
+        end
+      end
+    end
+
+    def datetime_parse(datetime)
+      if datetime.to_s.include?('-')
+        Time.parse(datetime.to_s.tr('-', '/')).to_i
+      else
+        Time.parse(datetime).to_i
+      end
+    end
+
+    def log
+      Logger.new(STDOUT)
+    end
+
+    def name_tag(tags)
+      tags.select { |tag| tag.value if tag.key == 'Name' }.last
+    end
+
+    def volume_ids(mappings)
+      volume_ids = []
+      mappings.each do |mapping|
+        volume_ids << mapping.ebs.volume_id unless mapping.ebs.delete_on_termination
+      end
+      volume_ids
+    end
+  end
+end

data/lib/seiton/ec2.rb

@@ -0,0 +1,300 @@
+module Seiton
+  class Ec2 < Client
+
+    include Seiton::Helper
+    include Seiton::Ec2Check
+
+    def ec2_instance(check = false, dt, ignores)
+      if check
+        log.info('List up the resources to be removed.')
+      else
+        log.info('Start deleting.')
+      end
+      res = ec2_client.describe_instances({
+                                           filters: [{
+                                                      'name': 'instance-state-name', 'values': [ 'stopped' ]
+                                                     }]
+                                          })
+      delete_instances = []
+      res.reservations.each do |i|
+        i.instances.each do |delete_instance|
+          if datetime_parse(delete_instance.launch_time) < datetime_parse(dt)
+            delete_instances << delete_instance
+          end
+        end
+      end
+
+      unless ignores.nil?
+        ignore_resources = []
+        ignores.each do |ignore|
+          ignore_resources << delete_instances.select { |delete_instance| name_tag(delete_instance.tags).value == ignore }.last
+          delete_instances.delete_if { |delete_instance| name_tag(delete_instance.tags).value == ignore }
+        end
+      end
+
+      if delete_instances.empty?
+        log.info('The resource to be deleted does not exist.')
+        exit 0
+      end
+
+      puts display_instance_resources(delete_instances)
+      generator_ec2_instances_check(delete_instances, ignore_resources)
+      exit 0 if check
+
+      delete_volume_ids = []
+      if process_ok?
+        begin
+          delete_instances.each do |instance|
+            delete_instance_action(instance.instance_id)
+            delete_volume_ids << volume_ids(instance.block_device_mappings)
+          end
+        rescue StandardError => e
+          log.error(e)
+          exit 1
+        end
+      else
+        exit 0
+      end
+      delete_volume_ids = delete_volume_ids.flatten
+      ec2_volume(delete_volume_ids) unless delete_volume_ids.empty?
+    end
+
+    def ec2_volume(delete_volume_ids)
+      log.info('Start EC2 volume deleting.')
+      log.info('Waiting for the status of the EC2 volume to become available.')
+      loop do
+        res = ec2_client.describe_volumes({ volume_ids: delete_volume_ids })
+        status = res.volumes.map { |volume| volume.volume_id if volume.state == 'available' }
+        if delete_volume_ids.sort == status.sort
+          log.info('The status of all EC2 volumes is now available.')
+          break
+        else
+          log.info('Waiting.')
+          sleep 3
+        end
+      end
+
+      delete_volumes = ec2_client.describe_volumes({ volume_ids: delete_volume_ids })
+      puts display_volume_resources(delete_volumes.volumes)
+
+      generator_ec2_volumes_check(delete_volumes.volumes)
+
+      if process_ok?
+        begin
+          delete_volume_ids.each do |delete_volume_id|
+            delete_volume_action(delete_volume_id)
+          end
+        rescue StandardError => e
+          log.error(e)
+          exit 1
+        end
+      else
+        exit 0
+      end
+
+    end
+
+    def ec2_image(check = false, dt, ignores)
+      if check
+        log.info('List up the resources to be removed.')
+      else
+        log.info('Start deleting.')
+      end
+      res = ec2_client.describe_images({ owners: ['self'] })
+      delete_images = []
+      res.images.each do |delete_image|
+        if datetime_parse(delete_image.creation_date) < datetime_parse(dt)
+          delete_images << delete_image
+        end
+      end
+
+      unless ignores.nil?
+        ignore_resources = []
+        ignores.each do |ignore|
+          delete_images.each do |delete_image|
+            if name_tag(delete_image.tags).nil?
+              if delete_image.name == ignore or delete_image.image_id == ignore
+                ignore_resources << delete_image
+              end
+            elsif name_tag(delete_image.tags).value == ignore or delete_image.name == ignore
+              ignore_resources << delete_image
+            end
+          end
+          delete_images.delete_if do |delete_image|
+            if name_tag(delete_image.tags).nil?
+              delete_image.name == ignore
+            else
+              name_tag(delete_image.tags).value == ignore or \
+              delete_image.name == ignore or \
+              delete_image.image_id == ignore
+            end
+          end
+        end
+      end
+
+      if delete_images.empty?
+        log.info('The resource to be deleted does not exist.')
+        exit 0
+      end
+
+      puts display_image_resources(delete_images)
+      generator_ec2_images_check(delete_images, ignore_resources)
+      exit 0 if check
+
+      delete_image_ids = []
+      if process_ok?
+        begin
+          delete_images.each do |image|
+            delete_image_action(image.image_id)
+            delete_image_ids << image.image_id
+          end
+        rescue StandardError => e
+          log.error(e)
+          exit 1
+        end
+      else
+        exit 0
+      end
+
+      ec2_snapshot(delete_image_ids)
+    end
+
+    def ec2_snapshots(check = false, dt, ignores)
+      if check
+        log.info('List up the resources to be removed.')
+      else
+        log.info('Start deleting.')
+      end
+      res = ec2_client.describe_snapshots({ owner_ids: ['self'] })
+      delete_snapshots = []
+      res.snapshots.each do |delete_snapshot|
+        if datetime_parse(delete_snapshot.start_time) < datetime_parse(dt)
+          delete_snapshots << delete_snapshot
+        end
+      end
+
+      unless ignores.nil?
+        ignore_resources = []
+        ignores.each do |ignore|
+          delete_snapshots.each do |delete_snapshot|
+            if name_tag(delete_snapshot.tags).nil?
+              if delete_snapshot.snapshot_id == ignore
+                ignore_resources << delete_snapshot
+              end
+            elsif name_tag(delete_snapshot.tags).value == ignore or delete_snapshot.snapshot_id == ignore
+              ignore_resources << delete_snapshot
+            end
+          end
+          delete_snapshots.delete_if do |delete_snapshot|
+            if name_tag(delete_snapshot.tags).nil?
+              delete_snapshot.snapshot_id == ignore
+            else
+              name_tag(delete_snapshot.tags).value == ignore or \
+              delete_snapshot.snapshot_id == ignore
+            end
+          end
+        end
+      end
+
+      if delete_snapshots.empty?
+        log.info('The resource to be deleted does not exist.')
+        exit 0
+      end
+
+      puts display_snapshot_resources(delete_snapshots)
+      generator_ec2_snapshots_check(delete_snapshots)
+      exit 0 if check
+
+      delete_snapshot_ids = []
+      if process_ok?
+        begin
+          delete_snapshots.each do |s|
+            delete_snapshot_ids << s.snaphost_id
+          end
+        rescue StandardError => e
+          log.error(e)
+          exit 1
+        end
+      else
+        exit 0
+      end
+
+      ec2_snapshot(delete_image_ids)
+    end
+
+    def ec2_snapshot(delete_image_ids)
+      log.info('Start EC2 Snapshot deleting.')
+      res = ec2_client.describe_snapshots(owner_ids: [iam_user.arn.split(':')[4]])
+      delete_snapshots = []
+      delete_image_ids.each do |delete_image_id|
+        res.snapshots.each do |delete_snapshot|
+          delete_snapshots << delete_snapshot if delete_snapshot.description.include?(delete_image_id)
+        end
+      end
+
+      if delete_snapshots.empty?
+        log.info('The EC2 snapshot to be deleted does not exist.')
+        return true
+      end
+
+      puts display_snapshot_resources(delete_snapshots)
+      generator_ec2_snapshots_check(delete_snapshots)
+
+      if process_ok?
+        begin
+          delete_snapshots.each do |delete_snapshot|
+            delete_snapshot_action(delete_snapshot.snapshot_id)
+          end
+        rescue StandardError => e
+          log.error(e)
+          exit 1
+        end
+      else
+        exit 0
+      end
+    end
+
+    def eip(check = false, ignores)
+      if check
+        log.info('List up the resources to be removed.')
+      else
+        log.info('Start deleting.')
+      end
+      res = ec2_client.describe_addresses({})
+      delete_addresses = []
+      res.addresses.each do |delete_address|
+        if delete_address.instance_id.nil?
+          delete_addresses << delete_address
+        end
+      end
+
+      unless ignores.nil?
+        ignores.each do |ignore|
+          delete_addresses.delete_if { |delete_address| delete_address.public_ip == ignore }
+        end
+      end
+
+      if delete_addresses.empty?
+        log.info('The resource to be deleted does not exist.')
+        exit 0
+      end
+
+      puts display_eip_resources(delete_addresses)
+      generator_ec2_eips_check(delete_addresses, ignores)
+      exit 0 if check
+
+      if process_ok?
+        begin
+          delete_addresses.each do |delete_address|
+            delete_eip_action(delete_address.allocation_id)
+          end
+        rescue StandardError => e
+          log.error(e)
+          exit 1
+        end
+      else
+        exit 0
+      end
+    end
+  end
+end