ec2ex 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 6fd690807cff2f0f5be2b942621f1efe62ff96de
-  data.tar.gz: 7ef5ca48952371e67172a80caa92c372b1751144
+  metadata.gz: 5755c9dc27c67e067cb6813e6e130a830ab2b320
+  data.tar.gz: a3eb2fe48d2cbec37f45dbf310222f6e22891e34
 SHA512:
-  metadata.gz: 81c2592526c7d51688a431c99167abe994b3f1a940c22b38ec7ad56909238efc4b841e78df317ecf27d2a66692cfec228115994d44c6f0e32e0d498f56ff8cde
-  data.tar.gz: 5ba6cbfc97e284c35de7f77e9125f4c48c0fabe740dc91a2b076803095865425d3c071d98df36ec73cd8b94666ed08d7274ed03dbf698692ff2c65768537d4ac
+  metadata.gz: 689bd524c9c9a9f77d77cb3c3e85d1e588d49cc9e89422e6497a7b0b1881d764995589cd778d9065146a8cf22d36a2ba2369f788f980c3eddbc0b57acc99cd74
+  data.tar.gz: 432de3ba88dc99d2dbae99d36e7371257eb85f6cd1454c41d50629b907d7cf4e04424c919710d04c970d1a1e17441b7da192aac1870f89dae49a51f7c8118ecf

data/README.md

@@ -1,19 +1,67 @@
 # ec2ex [![Build Status](https://secure.travis-ci.org/toyama0919/ec2ex.png?branch=master)](http://travis-ci.org/toyama0919/ec2ex)
 
-TODO: Summary
+## Examples
 
-TODO: Description
+### Search Instance
 
-## Examples
+```
+$ ec2ex -s 'stgweb01'
+```
+
+### Copy Instance
+
+```
+$ ec2ex copy -n "stgembulk01" -t Name:stgembulk02 --public_ip_address auto --instance_count 3
+```
+
+### Copy Spot Instance
+
+```
+$ ec2ex spot -n "web01" --price 0.5 --private_ip_address 10.0.0.100 -t Name:web02
+```
+
+### Deployment Instance
+
+```
+$ ec2ex run_spot -n "stgembulk01" --price 0.5
+```
+
+### Connect ELB Instance
+
+```
+$ ec2ex connect_elb -n "web01" -l elbname
+```
+
+### Disconnect ELB Instance
+
+```
+$ ec2ex disconnect_elb -n "web02" -l elbname
+```
+
+### Terminate Instance
+
+```
+$ ec2ex terminate -n web01
+```
+
+### Renew Instance
+
+```
+$ ec2ex renew -n "presto01" --private-ip-address 10.0.81.201 -p '{iam_instance_profile: { name: "iap-role"} }'
+```
+
+### Create AMI with tag
+
+```
+$ ec2 create_image -n "presto01"
+```
 
-    $ ec2ex sample
-    #=> hoge
 
 ## Installation
 
 Add this line to your application's Gemfile:
 
-    gem 'ec2ex'
+    gem 'ec2ex', github: 'ipros-team/ec2ex'
 
 And then execute:
 
@@ -21,7 +69,7 @@ And then execute:
 
 Or install it yourself as:
 
-    $ gem install ec2ex
+    $ gem specific_install -l https://github.com/ipros-team/ec2ex
 
 ## Contributing
 

data/ec2ex.gemspec

@@ -20,10 +20,12 @@ Gem::Specification.new do |gem|
   gem.add_dependency 'thor'
   gem.add_dependency 'hashie'
   gem.add_dependency 'ipaddress'
-  gem.add_dependency 'aws-sdk', '~> 2.0.11.pre'
+  gem.add_dependency 'aws-sdk'
   gem.add_dependency 'activesupport'
+  gem.add_dependency 'parallel'
+  gem.add_dependency 'net-ping'
 
-  gem.add_development_dependency 'bundler', '~> 1.7.2'
+  gem.add_development_dependency 'bundler'
   gem.add_development_dependency 'pry', '~> 0.10.1'
   gem.add_development_dependency 'rake', '~> 10.3.2'
   gem.add_development_dependency 'rspec', '~> 2.4'

data/lib/ec2ex/cli.rb

@@ -1,8 +1,7 @@
 require 'thor'
 require 'json'
 require 'pp'
-require 'hashie'
-require 'aws-sdk'
+require 'parallel'
 require 'active_support/core_ext/hash'
 
 module Ec2ex
@@ -19,15 +18,16 @@ module Ec2ex
       super(args, options, config)
       @global_options = config[:shell].base.options
       @core = Core.new
-      @ec2 = Aws::EC2::Client.new
-      @elb = Aws::ElasticLoadBalancing::Client.new
+      @ec2 = @core.client
+      @elb = @core.elb_client
+      @logger = @core.logger
     end
 
     desc 'search', 'search instance'
     option :name, aliases: '-n', type: :string, default: '', required: true, desc: 'name tag'
     option :running_only, aliases: '--ro', type: :boolean, default: true, desc: 'grouping key'
-    def search(name = options['name'])
-      results = @core.instances_hash({ Name: name }, options['running_only'])
+    def search(name = options[:name])
+      results = @core.instances_hash({ Name: name }, options[:running_only])
       puts_json results
     end
 
@@ -35,7 +35,7 @@ module Ec2ex
     option :condition, aliases: '-c', type: :hash, default: {}, desc: 'grouping key'
     option :running_only, aliases: '--ro', type: :boolean, default: true, desc: 'grouping key'
     def search_by_tags
-      puts_json @core.instances_hash(options['condition'], options['running_only'])
+      puts_json @core.instances_hash(options[:condition], options[:running_only])
     end
 
     desc 'reserved', 'reserved instance'
@@ -50,7 +50,7 @@ module Ec2ex
       list = @core.instances_hash({}, true).select { |instance| instance[:instance_lifecycle].nil? }
       list = list.map{ |_instance|
         ['instance_type', 'placement.availability_zone'].map do |key|
-          eval("instance.#{key} ")
+          eval("_instance.#{key} ")
         end.join('_')
       }
       result = {}
@@ -66,22 +66,64 @@ module Ec2ex
     end
 
     desc 'create_image', 'create image'
-    option :name, aliases: '-n', type: :string, default: '', required: true, desc: 'name tag'
+    option :name, aliases: '-n', type: :string, required: true, desc: 'name tag'
+    option :proc, type: :numeric, default: Parallel.processor_count, desc: 'Number of parallel'
+    option :region, aliases: '-r', type: :string, required: false, default: nil, desc: 'region'
     def create_image
-      results = @core.instances_hash({ Name: options['name'] }, false)
-      results.each do |instance|
-        @core.create_image_with_instance(instance)
+      results = @core.instances_hash({ Name: options[:name] }, false)
+      Parallel.map(results, in_threads: options[:proc]) do |instance|
+        begin
+          @core.create_image_with_instance(instance, options[:region])
+        rescue => e
+          @logger.info "\n#{e.message}\n#{e.backtrace.join("\n")}"
+        end
+      end
+    end
+
+    desc 'deregister_image', 'deregister image'
+    option :name, aliases: '-n', type: :string, default: '', required: true, desc: 'name tag'
+    option :older_than, aliases: '--older_than', type: :numeric, default: 30, desc: 'older than count.'
+    def deregister_image
+      @core.get_old_images(options[:name], options[:older_than]).each do |image|
+        image_id = image[:image_id]
+        @logger.info "delete AMI #{image_id} [#{image[:name]}]"
+        @ec2.deregister_image({image_id: image_id})
+        snapshot_ids = image[:block_device_mappings]
+            .select{ |block_device_mapping| block_device_mapping[:ebs] != nil }
+            .map{ |block_device_mapping| block_device_mapping[:ebs][:snapshot_id] }
+
+        snapshot_ids.each do |snapshot_id|
+          @logger.info "delete snapshot #{snapshot_id}"
+          @ec2.delete_snapshot({snapshot_id: snapshot_id})
+        end
       end
     end
 
+    desc 'deregister_image', 'deregister image'
+    option :name, aliases: '-n', type: :string, default: '', required: true, desc: 'name tag'
+    option :older_than, aliases: '--older_than', type: :numeric, default: 30, desc: 'older than count.'
+    def old_images
+      puts_json(@core.get_old_images(options[:name], options[:older_than]))
+    end
+
+    desc 'deregister_snapshot_no_related', 'AMI not related snapshot basis delete all'
+    option :owner_id, type: :string, required: true, desc: 'owner_id'
+    def deregister_snapshot_no_related
+      @core.deregister_snapshot_no_related(options[:owner_id])
+    end
+
     desc 'copy', 'copy instance'
     option :name, aliases: '-n', type: :string, default: '', required: true, desc: 'name tag'
     option :params, aliases: '-p', type: :string, default: '{}', desc: 'params'
     option :tag, aliases: '-t', type: :hash, default: {}, desc: 'name tag'
+    option :private_ip_address, type: :string, default: nil, desc: 'private_ip_address'
+    option :public_ip_address, type: :string, default: nil, desc: 'public_ip_address'
+    option :instance_count, type: :numeric, default: 1, desc: 'instance_count'
     def copy
-      results = @core.instances_hash({ Name: options['name'] }, true)
-      results.each do |instance|
-        image_id = @core.create_image_with_instance(instance)
+      instance = @core.instances_hash_first_result({ Name: options[:name] }, true)
+      image_id = @core.create_image_with_instance(instance)
+      instance_count = options[:instance_count]
+      Parallel.map(instance_count.times.to_a, in_threads: Parallel.processor_count) do |server_index|
         security_group_ids = instance.security_groups.map { |security_group| security_group.group_id }
         request = {
           image_id: image_id,
@@ -89,43 +131,61 @@ module Ec2ex
           max_count: 1,
           security_group_ids: security_group_ids,
           instance_type: instance.instance_type,
-          placement: instance.placement.to_hash,
-          subnet_id: instance.subnet_id,
-          private_ip_address: instance.private_ip_address
+          placement: instance.placement.to_hash
         }
-        unless instance.iam_instance_profile.nil?
+        request[:private_ip_address] = options[:private_ip_address] if options[:private_ip_address]
+        if instance.iam_instance_profile
           request[:iam_instance_profile] = { name: instance.iam_instance_profile.arn.split('/').last }
         end
-        request.merge!(eval(options['params']))
-        request[:subnet_id] = @core.get_subnet(request[:private_ip_address]).subnet_id
+        if instance.key_name
+          request[:key_name] = instance.key_name
+        end
+
+        request.merge!(eval(options[:params]))
+        request[:subnet_id] = if request[:private_ip_address]
+          @core.get_subnet(request[:private_ip_address]).subnet_id
+        else
+          instance.subnet_id
+        end
 
         response = @ec2.run_instances(request)
         instance_id = response.instances.first.instance_id
         @ec2.wait_until(:instance_running, instance_ids: [instance_id])
         @ec2.create_tags(resources: [instance_id], tags: instance.tags)
-        unless options['tag'].nil?
-          @ec2.create_tags(resources: [instance_id], tags: @core.format_tag(options['tag']))
+        @ec2.create_tags(resources: [instance_id], tags: [{ key: 'InstanceIndex', value: "#{server_index}" }])
+        @ec2.create_tags(resources: [instance_id], tags: [{ key: 'InstanceCount', value: "#{instance_count}" }])
+        unless options[:tag].nil?
+          @ec2.create_tags(
+            resources: [instance_id],
+            tags: @core.format_tag(
+              options[:tag],
+              @core.get_tag_hash_from_id(instance_id)
+            )
+          )
         end
+        public_ip_address = get_public_ip_address(options[:public_ip_address], instance.public_ip_address, false)
+        @core.associate_address(instance_id, public_ip_address)
+        @logger.info("created instance => #{instance_id}")
       end
     end
 
     desc 'renew', 'renew instance'
     option :name, aliases: '-n', type: :string, default: '', required: true, desc: 'name tag'
     option :stop, type: :boolean, default: true, desc: 'stop'
-    option :params, aliases: '-p', type: :string, default: nil, desc: 'params'
+    option :params, aliases: '-p', type: :string, default: '{}', desc: 'params'
     def renew
-      params = eval(options['params'])
-      results = @core.instances_hash({ Name: options['name'] }, false)
+      params = eval(options[:params])
+      results = @core.instances_hash({ Name: options[:name] }, false)
       results.each do |instance|
         tags = instance.tags
         tag_hash = @core.get_tag_hash(tags)
-        if options['stop']
+        if options[:stop]
           @core.stop_instance(instance.instance_id)
         end
 
         image_id = @core.create_image_with_instance(instance)
 
-        @core.terminate_instance(instance.instance_id)
+        @core.terminate_instance(instance)
         security_group_ids = instance.security_groups.map { |security_group| security_group.group_id }
         request = {
           image_id: image_id,
@@ -136,9 +196,13 @@ module Ec2ex
           placement: instance.placement.to_hash,
           private_ip_address: instance.private_ip_address
         }
-        unless instance.iam_instance_profile.nil?
+        if instance.iam_instance_profile
           request[:iam_instance_profile] = { name: instance.iam_instance_profile.arn.split('/').last }
         end
+
+        if instance.key_name
+          request[:key_name] = instance.key_name
+        end
         request.merge!(params)
         request[:subnet_id] = @core.get_subnet(request[:private_ip_address]).subnet_id
 
@@ -157,18 +221,26 @@ module Ec2ex
     option :price, type: :string, required: true, desc: 'price'
     option :private_ip_address, type: :string, default: nil, desc: 'private_ip_address'
     option :public_ip_address, type: :string, default: nil, desc: 'public_ip_address'
+    option :block_duration_minutes, type: :numeric, default: nil, desc: 'block_duration_minutes'
     option :params, aliases: '-p', type: :string, default: '{}', desc: 'params'
     option :tag, aliases: '-t', type: :hash, default: {}, desc: 'name tag'
     option :renew, aliases: '-r', type: :boolean, default: false, desc: 'renew instance'
     option :persistent, type: :boolean, default: false, desc: 'persistent request'
+    option :stop, type: :boolean, default: false, desc: 'stop'
+    option :instance_count, type: :numeric, default: 1, desc: 'instance_count'
     def spot
-      results = @core.instances_hash({ Name: options['name'] }, true)
-      results.each do |instance|
-        image_id = @core.create_image_with_instance(instance)
+      instance = @core.instances_hash_first_result({ Name: options[:name] }, true)
+      if options[:stop]
+        @core.stop_instance(instance.instance_id)
+      end
+      image_id = @core.create_image_with_instance(instance)
+
+      instance_count = options[:instance_count]
+      Parallel.map(instance_count.times.to_a, in_threads: Parallel.processor_count) do |server_index|
         security_group_ids = instance.security_groups.map { |security_group| security_group.group_id }
         option = {
           instance_count: 1,
-          spot_price: options['price'],
+          spot_price: options[:price],
           launch_specification: {
             image_id: image_id,
             instance_type: instance.instance_type,
@@ -176,52 +248,61 @@ module Ec2ex
             subnet_id: instance.subnet_id
           },
         }
-        option[:type] = 'persistent' if options['persistent']
+        option[:type] = 'persistent' if options[:persistent]
+        option[:block_duration_minutes] = options[:block_duration_minutes] if options[:block_duration_minutes]
 
-        unless instance.iam_instance_profile.nil?
+        if instance.iam_instance_profile
           option[:launch_specification][:iam_instance_profile] = { name: instance.iam_instance_profile.arn.split('/').last }
         end
 
-        option[:launch_specification].merge!(eval(options['params']))
+        if instance.key_name
+          option[:launch_specification][:key_name] = instance.key_name
+        end
+
+        option[:launch_specification].merge!(eval(options[:params]))
 
         private_ip_address = nil
-        if options['private_ip_address'].nil?
-          private_ip_address = instance.private_ip_address if options['renew']
+        if options[:private_ip_address].nil?
+          private_ip_address = instance.private_ip_address if options[:renew]
         else
-          private_ip_address = options['private_ip_address']
+          private_ip_address = options[:private_ip_address]
         end
 
-        unless private_ip_address.nil?
+        if private_ip_address
           network_interface = {
             device_index: 0,
             subnet_id: @core.get_subnet(private_ip_address).subnet_id,
-            groups: security_group_ids,
+            groups: option[:launch_specification][:security_group_ids],
             private_ip_addresses: [{ private_ip_address: private_ip_address, primary: true }]
           }
           option[:launch_specification][:network_interfaces] = [network_interface]
           option[:launch_specification].delete(:security_group_ids)
           option[:launch_specification].delete(:subnet_id)
         end
-        @core.terminate_instance(instance.instance_id) if options['renew']
+        @core.terminate_instance(instance) if options[:renew]
 
         response = @ec2.request_spot_instances(option)
         spot_instance_request_id = response.spot_instance_requests.first.spot_instance_request_id
         sleep 5
         instance_id = @core.wait_spot_running(spot_instance_request_id)
+        @core.set_delete_on_termination(@core.instances_hash_with_id(instance_id))
 
         @ec2.create_tags(resources: [instance_id], tags: instance.tags)
         @ec2.create_tags(resources: [instance_id], tags: [{ key: 'Spot', value: 'true' }])
-
-        unless options['tag'].empty?
-          @ec2.create_tags(resources: [instance_id], tags: @core.format_tag(options['tag']))
+        @ec2.create_tags(resources: [instance_id], tags: [{ key: 'InstanceIndex', value: "#{server_index}" }])
+        @ec2.create_tags(resources: [instance_id], tags: [{ key: 'InstanceCount', value: "#{instance_count}" }])
+
+        unless options[:tag].empty?
+          @ec2.create_tags(
+            resources: [instance_id],
+            tags: @core.format_tag(
+              options[:tag],
+              @core.get_tag_hash_from_id(instance_id)
+            )
+          )
         end
 
-        public_ip_address = nil
-        if options['public_ip_address'].nil?
-          public_ip_address = instance.public_ip_address if options['renew']
-        else
-          public_ip_address = options['public_ip_address']
-        end
+        public_ip_address = get_public_ip_address(options[:public_ip_address], instance.public_ip_address, options[:renew])
         @core.associate_address(instance_id, public_ip_address)
       end
     end
@@ -229,34 +310,49 @@ module Ec2ex
     desc 'run_spot', 'run_spot latest image'
     option :name, aliases: '-n', type: :string, required: true, desc: 'name tag'
     option :price, type: :string, required: true, desc: 'price'
+    option :private_ip_address, type: :string, default: nil, desc: 'private_ip_address'
+    option :params, aliases: '-p', type: :string, default: '{}', desc: 'params'
+    option :block_duration_minutes, type: :numeric, default: nil, desc: 'block_duration_minutes'
     def run_spot
-      image = @core.latest_image_with_name(options['name'])
+      image = @core.latest_image_with_name(options[:name])
+
       tag_hash = @core.get_tag_hash(image[:tags])
+      private_ip_address = options[:private_ip_address] || tag_hash.private_ip_address
+      exit 0 if @core.ping?(private_ip_address)
+
       option = {
         instance_count: 1,
-        spot_price: options['price'],
+        spot_price: options[:price],
         launch_specification: {
           image_id: image[:image_id],
           instance_type: tag_hash.instance_type
         },
       }
 
+      option[:block_duration_minutes] = options[:block_duration_minutes] if options[:block_duration_minutes]
+
       if tag_hash.iam_instance_profile
         option[:launch_specification][:iam_instance_profile] = { name: tag_hash.iam_instance_profile }
       end
 
+      if tag_hash.key_name
+        option[:launch_specification][:key_name] = tag_hash.key_name
+      end
+
       network_interface = {
         device_index: 0,
-        subnet_id: @core.get_subnet(tag_hash.private_ip_address).subnet_id,
+        subnet_id: @core.get_subnet(private_ip_address).subnet_id,
         groups: JSON.parse(tag_hash.security_groups),
-        private_ip_addresses: [{ private_ip_address: tag_hash.private_ip_address, primary: true }]
+        private_ip_addresses: [{ private_ip_address: private_ip_address, primary: true }]
       }
       option[:launch_specification][:network_interfaces] = [network_interface]
+      option[:launch_specification].merge!(eval(options[:params]))
 
       response = @ec2.request_spot_instances(option)
       spot_instance_request_id = response.spot_instance_requests.first.spot_instance_request_id
       sleep 5
       instance_id = @core.wait_spot_running(spot_instance_request_id)
+      @core.set_delete_on_termination(@core.instances_hash_with_id(instance_id))
       @ec2.create_tags(resources: [instance_id], tags: JSON.parse(tag_hash[:tags]))
 
       if tag_hash.public_ip_address
@@ -268,7 +364,7 @@ module Ec2ex
     option :acl_id, type: :string, default: '', required: true, desc: 'name tag'
     option :ip_address, type: :string, default: '', required: true, desc: 'name tag'
     def regist_deny_acl
-      acls = @ec2.describe_network_acls(network_acl_ids: [options['acl_id']])
+      acls = @ec2.describe_network_acls(network_acl_ids: [options[:acl_id]])
 
       allow_any_rule_number = acls.network_acls.first.entries.select {|r|
                          !r.egress && r.cidr_block == '0.0.0.0/0' && r.rule_action == 'allow'
@@ -280,13 +376,13 @@ module Ec2ex
 
       next_rule_number = deny_rules.empty? ? 1 : deny_rules.last.rule_number + 1
 
-      unless deny_rules.any? { |r| r.cidr_block == "#{options['ip_address']}/32" }
+      unless deny_rules.any? { |r| r.cidr_block == "#{options[:ip_address]}/32" }
         option = {
-          network_acl_id: options['acl_id'],
+          network_acl_id: options[:acl_id],
           rule_number: next_rule_number,
           rule_action: 'deny',
           protocol: '-1',
-          cidr_block: "#{options['ip_address']}/32",
+          cidr_block: "#{options[:ip_address]}/32",
           egress: false
         }
         @ec2.create_network_acl_entry(option)
@@ -296,7 +392,7 @@ module Ec2ex
     desc 'delete_deny_acl_all', 'delete deny acl'
     option :acl_id, type: :string, required: true, desc: 'name tag'
     def delete_deny_acl_all
-      acls = @ec2.describe_network_acls(network_acl_ids: [options['acl_id']])
+      acls = @ec2.describe_network_acls(network_acl_ids: [options[:acl_id]])
 
       allow_any_rule_number = acls.network_acl_set.first.entries.select {|r|
                          !r.egress && r.cidr_block == '0.0.0.0/0' && r.rule_action == 'allow'
@@ -308,7 +404,7 @@ module Ec2ex
 
       deny_rules.each do |deny_rule|
         option = {
-          network_acl_id: options['acl_id'],
+          network_acl_id: options[:acl_id],
           rule_number: deny_rule.rule_number,
           egress: false
         }
@@ -334,25 +430,34 @@ module Ec2ex
     desc 'copy_tag', 'request spot instances'
     option :source, aliases: '--src', type: :string, default: nil, required: true, desc: 'name tag'
     option :dest, aliases: '--dest', type: :string, default: nil, required: true, desc: 'name tag'
-    def copy_tag(_name = options['name'])
-      source = @core.instances_hash({ Name: options['source'] }, true)
-      dest = @core.instances_hash({ Name: options['dest'] }, true)
+    def copy_tag(_name = options[:name])
+      source = @core.instances_hash({ Name: options[:source] }, true)
+      dest = @core.instances_hash({ Name: options[:dest] }, true)
       @ec2.create_tags(resources: dest.map { |instance| instance.instance_id }, tags: source.first.tags)
-      @ec2.create_tags(resources: dest.map { |instance| instance.instance_id }, tags: [{ key: 'Name', value: options['dest'] }])
+      @ec2.create_tags(resources: dest.map { |instance| instance.instance_id }, tags: [{ key: 'Name', value: options[:dest] }])
     end
 
     desc 'set_tag', 'set tag'
     option :name, aliases: '-n', type: :string, required: true, desc: 'name tag'
     option :tag, aliases: '-t', type: :hash, required: true, desc: 'name tag'
     def set_tag
-      instances = @core.instances_hash({ Name: options['name'] }, true)
-      tags = @core.format_tag(options['tag'])
+      instances = @core.instances_hash({ Name: options[:name] }, true)
+      tags = @core.format_tag(options[:tag])
       @ec2.create_tags(resources: instances.map { |instance| instance.instance_id }, tags: tags)
     end
 
+    desc 'set_delete_on_termination', 'set delete on termination instance'
+    option :name, aliases: '-n', type: :string, required: true, desc: 'name tag'
+    def set_delete_on_termination
+      @core.instances_hash({ Name: options[:name] }, true).each do |instance|
+        @core.set_delete_on_termination(instance)
+        @logger.info "set delete on termination => #{instance.instance_id}"
+      end
+    end
+
     desc 'search_images', 'search images'
     option :name, aliases: '-n', type: :string, default: '', required: true, desc: 'name tag'
-    def search_images(name = options['name'])
+    def search_images(name = options[:name])
       puts_json @core.images(name)
     end
 
@@ -361,8 +466,8 @@ module Ec2ex
     option :key, aliases: '-k', type: :array, required: true, desc: 'grouping key'
     option :running_only, aliases: '--ro', type: :boolean, default: true, desc: 'grouping key'
     def aggregate
-      list = @core.instances_hash(options['condition'], options['running_only']).map do |_instance|
-        options['key'].map do |key|
+      list = @core.instances_hash(options[:condition], options[:running_only]).map do |instance|
+        options[:key].map do |key|
           eval("instance.#{key} ")
         end.join('_')
       end
@@ -372,7 +477,7 @@ module Ec2ex
     desc 'reboot', 'reboot instance'
     option :name, aliases: '-n', type: :string, default: '', required: true, desc: 'name tag'
     def reboot
-      @core.instances_hash({ Name: options['name'] }, true).each do |instance|
+      @core.instances_hash({ Name: options[:name] }, true).each do |instance|
         @ec2.reboot_instances(instance_ids: [instance.instance_id])
         sleep 5
         @ec2.wait_until(:instance_running, instance_ids: [instance.instance_id])
@@ -382,13 +487,13 @@ module Ec2ex
     desc 'stop_start', 'stop after start instance'
     option :names, aliases: '-n', type: :array, default: [], required: true, desc: 'name tag'
     def stop_start
-      options['names'].each do |name|
+      options[:names].each do |name|
         @core.instances_hash({ Name: name }, true).each do |instance|
           instance.stop
           @ec2.wait_until(:instance_stopped, instance_ids: [instance.instance_id])
           instance.start
           @ec2.wait_until(:instance_running, instance_ids: [instance.instance_id])
-          puts "#{instance.tags['Name']} restart complete!"
+          @logger.info "#{instance.tags['Name']} restart complete!"
         end
       end
     end
@@ -396,25 +501,34 @@ module Ec2ex
     desc 'terminate', 'terminate instance'
     option :name, aliases: '-n', type: :string, required: true, desc: 'name tag'
     def terminate
-      @core.instances_hash({ Name: options['name'] }, false).each do |instance|
-        @core.terminate_instance(instance.instance_id)
+      instances = @core.instances_hash({ Name: options[:name] }, false)
+      Parallel.map(instances, in_threads: Parallel.processor_count) do |instance|
+        @core.terminate_instance(instance)
       end
     end
 
-    desc 'terminate', 'terminate instance'
+    desc 'start', 'start instance'
     option :name, aliases: '-n', type: :string, required: true, desc: 'name tag'
     def start
-      @core.instances_hash({ Name: options['name'] }, false).each do |instance|
+      @core.instances_hash({ Name: options[:name] }, false).each do |instance|
         @core.start_instance(instance.instance_id)
       end
     end
 
+    desc 'stop', 'stop instance'
+    option :name, aliases: '-n', type: :string, required: true, desc: 'name tag'
+    def stop
+      @core.instances_hash({ Name: options[:name] }, false).each do |instance|
+        @core.stop_instance(instance.instance_id)
+      end
+    end
+
     desc 'connect elb', 'connect elb'
     option :name, aliases: '-n', type: :string, default: '', required: true, desc: 'name tag'
     option :load_balancer_name, aliases: '-l', type: :string, default: '', required: true, desc: 'name tag'
-    def connect_elb(_name = options['name'])
-      @core.instances_hash({ Name: options['name'] }, true).each do |instance|
-        option = { load_balancer_name: options['load_balancer_name'], instances: [instance_id: instance.instance_id] }
+    def connect_elb(_name = options[:name])
+      @core.instances_hash({ Name: options[:name] }, true).each do |instance|
+        option = { load_balancer_name: options[:load_balancer_name], instances: [instance_id: instance.instance_id] }
         @elb.deregister_instances_from_load_balancer(option)
         @elb.register_instances_with_load_balancer(option)
         print 'connecting ELB...'
@@ -426,6 +540,16 @@ module Ec2ex
       end
     end
 
+    desc 'disconnect elb', 'disconnect elb'
+    option :name, aliases: '-n', type: :string, default: '', required: true, desc: 'name tag'
+    option :load_balancer_name, aliases: '-l', type: :string, default: '', required: true, desc: 'name tag'
+    def disconnect_elb
+      @core.instances_hash({ Name: options[:name] }, true).each do |instance|
+        option = { load_balancer_name: options[:load_balancer_name], instances: [instance_id: instance.instance_id] }
+        @elb.deregister_instances_from_load_balancer(option)
+      end
+    end
+
     desc 'elbs', 'show elbs'
     def elbs
       puts_json @elb.describe_load_balancers.data.to_h[:load_balancer_descriptions]
@@ -452,25 +576,56 @@ module Ec2ex
     desc 'latest_image', 'show elbs'
     option :name, aliases: '-n', type: :string, required: true, desc: 'name tag'
     def latest_image
-      puts_json @core.latest_image_with_name(options['name'])
+      puts_json @core.latest_image_with_name(options[:name])
     end
 
     desc 'allocate_address', 'allocate address'
-    def allocate_address
-      response = @ec2.allocate_address(domain: 'vpc')
+    def allocate_address_vpc
+      response = @core.allocate_address_vpc
+      puts response.data
+    end
+
+    desc 'instance_metadata', 'instance metadata'
+    option :path, type: :string, required: true, desc: 'path'
+    def instance_metadata
+      response = @core.get_metadata(options[:path])
       puts response
     end
 
+    desc 'own_tag', 'own tag'
+    option :key, type: :string, desc: 'key'
+    def own_tag
+      response = @core.own_tag
+      if options[:key]
+        puts response[options[:key]]
+      else
+        puts_json response
+      end
+    end
+
     private
     def instances(name, _running_only = true)
       @ec2.instances.with_tag('Name', "#{name}")
     end
 
     def puts_json(data)
-      unless @global_options['fields'].nil?
-        data = @core.extract_fields(data, @global_options['fields'])
+      unless @global_options[:fields].nil?
+        data = @core.extract_fields(data, @global_options[:fields])
       end
       puts JSON.pretty_generate(data)
     end
+
+    def get_public_ip_address(define_public_ip_address, instance_public_ip_address, renew)
+      public_ip_address = nil
+      if define_public_ip_address == 'auto'
+        allocate_address_result = @core.allocate_address_vpc
+        public_ip_address = allocate_address_result.public_ip
+      elsif define_public_ip_address.nil?
+        public_ip_address = instance_public_ip_address if renew
+      else
+        public_ip_address = define_public_ip_address
+      end
+      public_ip_address
+    end
   end
 end

data/lib/ec2ex/core.rb

@@ -1,10 +1,47 @@
 require 'aws-sdk'
 require 'ipaddress'
+require 'open-uri'
+require "logger"
+require 'hashie'
+require 'net/ping'
 
+TIME_OUT = 3
 module Ec2ex
   class Core
     def initialize
+      ENV['AWS_REGION'] = ENV['AWS_REGION'] || get_document['region']
       @ec2 = Aws::EC2::Client.new
+      @elb = Aws::ElasticLoadBalancing::Client.new
+      @logger = Logger.new(STDOUT);
+    end
+
+    def client
+      @ec2
+    end
+
+    def logger
+      @logger
+    end
+
+    def get_document
+      JSON.parse(get_metadata('/latest/dynamic/instance-identity/document/'))
+    end
+
+    def get_metadata(path)
+      begin
+        result = {}
+        ::Timeout.timeout(TIME_OUT) {
+          body = open('http://169.254.169.254' + path).read
+          return body
+        }
+        return result
+      rescue TimeoutError => e
+        raise "not EC2 instance"
+      end
+    end
+
+    def elb_client
+      @elb
     end
 
     def extract_fields(data, fields)
@@ -24,10 +61,11 @@ module Ec2ex
       Hash[list.group_by { |e| e }.map { |k, v| [k, v.length] }]
     end
 
-    def format_tag(tag)
+    def format_tag(tag, preset_tag_hash = {})
       tags = []
       tag.each do |k, v|
-        tags << { key: k, value: v }
+        value = v ? ERB.new(v.gsub(/\$\{([^}]+)\}/, "<%=preset_tag_hash['" + '\1' + "'] %>")).result(binding) : ''
+        tags << { key: k, value: value }
       end
       tags
     end
@@ -40,6 +78,14 @@ module Ec2ex
       Hashie::Mash.new(result)
     end
 
+    def get_tag_hash_from_id(instance_id)
+      preset_tag = {}
+      @ec2.describe_tags(filters: [{ name: 'resource-id', values: [instance_id] }]).tags.each do |tag|
+        preset_tag[tag.key] = tag.value
+      end
+      preset_tag
+    end
+
     def instances_hash(condition, running_only = true)
       filter = []
       condition.each do |key, value|
@@ -55,66 +101,113 @@ module Ec2ex
       ).data.to_h[:reservations].map { |instance| Hashie::Mash.new(instance[:instances].first) }
     end
 
-    def images(name)
-      filter = [{ name: 'is-public', values: ['false'] }]
-      filter << { name: 'name', values: ["#{name}"] }
-      @ec2.describe_images(
-        filters: filter
-      ).data.to_h[:images]
+    def instances_hash_first_result(condition, running_only = true)
+      results = instances_hash(condition, running_only)
+      instance = results.first
+      unless instance
+        @logger.warn("not match instance => #{condition}")
+        exit 1
+      end
+      instance
     end
 
-    def create_image_with_instance(instance)
-      puts 'image creating...'
-      tags = get_tag_hash(instance.tags)
-      snapshot = {
+    def instances_hash_with_id(instance_id)
+      @ec2.describe_instances(
+        instance_ids: [instance_id]
+      ).data.to_h[:reservations].map { |instance| Hashie::Mash.new(instance[:instances].first) }.first
+    end
+
+    def own_tag
+      get_tag_hash(instances_hash_with_id(get_metadata('/latest/meta-data/instance-id')).tags)
+    end
+
+    def get_ami_tag_hash(instance, tags)
+      ami_tag_hash = {
         'created' => Time.now.strftime('%Y%m%d%H%M%S'),
         'tags' => instance.tags.map(&:to_hash).to_json,
         'Name' => tags['Name']
       }
-      snapshot['security_groups'] = instance.security_groups.map(&:group_id).to_json
-      snapshot['private_ip_address'] = instance.private_ip_address
+      ami_tag_hash['security_groups'] = instance.security_groups.map(&:group_id).to_json
+      ami_tag_hash['private_ip_address'] = instance.private_ip_address
       unless instance.public_ip_address.nil?
-        snapshot['public_ip_address'] = instance.public_ip_address
+        ami_tag_hash['public_ip_address'] = instance.public_ip_address
       end
-      snapshot['instance_type'] = instance.instance_type
-      snapshot['placement'] = instance.placement.to_hash.to_json
+      ami_tag_hash['instance_type'] = instance.instance_type
+      ami_tag_hash['placement'] = instance.placement.to_hash.to_json
       unless instance.iam_instance_profile.nil?
-        snapshot['iam_instance_profile'] = instance.iam_instance_profile.arn.split('/').last
+        ami_tag_hash['iam_instance_profile'] = instance.iam_instance_profile.arn.split('/').last
       end
+      unless instance.key_name.nil?
+        ami_tag_hash['key_name'] = instance.key_name
+      end
+      ami_tag_hash
+    end
 
+    def create_image_with_instance(instance, region = nil)
+      tags = get_tag_hash(instance.tags)
+      @logger.info "#{tags['Name']} image creating..."
+
+      image_name = tags['Name'] + ".#{Time.now.strftime('%Y%m%d%H%M%S')}"
       image_response = @ec2.create_image(
         instance_id: instance.instance_id,
-        name: tags['Name'] + ".#{Time.now.strftime('%Y%m%d%H%M%S')}",
+        name: image_name,
         no_reboot: true
       )
       sleep 10
       @ec2.wait_until(:image_available, image_ids: [image_response.image_id]) do |w|
         w.interval = 15
-        w.max_attempts = 720
+        w.max_attempts = 1440
       end
-      puts "image create complete! image_id => [#{image_response.image_id}]"
+      @logger.info "image create complete #{tags['Name']}! image_id => [#{image_response.image_id}]"
 
-      ami_tag = format_tag(snapshot)
+      ami_tag = format_tag(get_ami_tag_hash(instance, tags))
       @ec2.create_tags(resources: [image_response.image_id], tags: ami_tag)
+
+      if region
+        @logger.info "copying another region... [#{ENV['AWS_REGION']}] => [#{region}]"
+        dest_ec2 = Aws::EC2::Client.new(region: region)
+        copy_image_response = dest_ec2.copy_image(
+          source_region: ENV['AWS_REGION'],
+          source_image_id: image_response.image_id,
+          name: image_name
+        )
+        dest_ec2.create_tags(resources: [copy_image_response.image_id], tags: ami_tag)
+      end
+
       image_response.image_id
     end
 
     def wait_spot_running(spot_instance_request_id)
-      puts 'spot instance creating...'
+      @logger.info 'spot instance creating...'
       instance_id = nil
       while true
         spot_instance_request = @ec2.describe_spot_instance_requests(spot_instance_request_ids: [spot_instance_request_id]).spot_instance_requests.first
         if spot_instance_request.state == 'active'
           instance_id = spot_instance_request.instance_id
           break
+        elsif spot_instance_request.state == 'failed'
+          @logger.info spot_instance_request.fault.code
+          @ec2.cancel_spot_instance_requests({ spot_instance_request_ids: [spot_instance_request_id] })
+          raise spot_instance_request.fault.message
         end
         sleep 10
       end
       @ec2.wait_until(:instance_running, instance_ids: [instance_id])
-      puts "spot instance create complete! instance_id => [#{instance_id}]"
+      @logger.info "spot instance create complete! instance_id => [#{instance_id}]"
       instance_id
     end
 
+    def set_delete_on_termination(instance)
+      block_device_mappings = instance.block_device_mappings.map{ |block_device_mapping|
+        ebs = block_device_mapping.ebs
+        {
+          device_name: block_device_mapping.device_name,
+          ebs: { volume_id: block_device_mapping.ebs.volume_id, delete_on_termination: true }
+        }
+      }
+      @ec2.modify_instance_attribute({instance_id: instance.instance_id, block_device_mappings: block_device_mappings})
+    end
+
     def get_allocation(public_ip_address)
       @ec2.describe_addresses(public_ips: [public_ip_address]).addresses.first
     end
@@ -128,29 +221,30 @@ module Ec2ex
     end
 
     def stop_instance(instance_id)
-      puts 'stopping...'
+      @logger.info 'stopping...'
       @ec2.stop_instances(
         instance_ids: [instance_id],
         force: true
       )
       @ec2.wait_until(:instance_stopped, instance_ids: [instance_id])
-      puts "stop instance complete! instance_id => [#{instance_id}]"
+      @logger.info "stop instance complete! instance_id => [#{instance_id}]"
     end
 
     def start_instance(instance_id)
-      puts 'starting...'
+      @logger.info 'starting...'
       @ec2.start_instances(
         instance_ids: [instance_id]
       )
       @ec2.wait_until(:instance_running, instance_ids: [instance_id])
-      puts "start instance complete! instance_id => [#{instance_id}]"
+      @logger.info "start instance complete! instance_id => [#{instance_id}]"
     end
 
-    def terminate_instance(instance_id)
-      puts 'terminating...'
+    def terminate_instance(instance)
+      instance_id = instance.instance_id
+      @logger.info 'terminating...'
       @ec2.terminate_instances(instance_ids: [instance_id])
       @ec2.wait_until(:instance_terminated, instance_ids: [instance_id])
-      puts "terminate instance complete! instance_id => [#{instance_id}]"
+      @logger.info "terminate instance complete! instance_id => [#{instance_id}]"
     end
 
     def associate_address(instance_id, public_ip_address)
@@ -161,16 +255,84 @@ module Ec2ex
     end
 
     def latest_image_with_name(name)
-      filter = [{ name: 'is-public', values: ['false'] }]
-      filter << { name: 'tag:Name', values: [name] }
-      result = @ec2.describe_images(
-        filters: filter
-      ).data.to_h[:images]
+      result = search_image_with_name(name)
       result = result.sort_by{ |image|
         tag_hash = get_tag_hash(image[:tags])
         tag_hash['created'].nil? ? '' : tag_hash['created']
       }
       result.empty? ? {} : result.last
     end
+
+    def get_old_images(name, num = 10)
+      result = search_image_with_name(name)
+      return [] if result.empty?
+      map = Hash.new{|h,k| h[k] = []}
+      result = result.each{ |image|
+        tag_hash = get_tag_hash(image[:tags])
+        next if tag_hash['Name'].nil? || tag_hash['created'].nil?
+        map[tag_hash['Name']] << image
+      }
+      old_images = []
+      map.each do |name, images|
+        sorted_images = images.sort_by{ |image|
+          tag_hash = get_tag_hash(image[:tags])
+          Time.parse(tag_hash['created'])
+        }
+        newly_images = sorted_images.last(num)
+        old_images = old_images + (sorted_images - newly_images)
+      end
+      old_images
+    end
+
+    def images(name)
+      filter = [{ name: 'is-public', values: ['false'] }]
+      filter << { name: 'name', values: [name] }
+      @ec2.describe_images(
+        filters: filter
+      ).data.to_h[:images]
+    end
+
+    def search_image_with_name(name)
+      filter = [{ name: 'is-public', values: ['false'] }]
+      filter << { name: 'tag:Name', values: [name] }
+      @ec2.describe_images(
+        filters: filter
+      ).data.to_h[:images]
+    end
+
+    def deregister_snapshot_no_related(owner_id)
+      enable_snapshot_ids = []
+      images('*').each do |image|
+        image_id = image[:image_id]
+        snapshot_ids = image[:block_device_mappings]
+          .select{ |block_device_mapping| block_device_mapping[:ebs] != nil }
+          .map{ |block_device_mapping| block_device_mapping[:ebs][:snapshot_id] }
+        enable_snapshot_ids.concat(snapshot_ids)
+      end
+      filter = [{ name: 'owner-id', values: [owner_id] }]
+      all_snapshot_ids = @ec2.describe_snapshots(
+        filters: filter
+      ).data.to_h[:snapshots].map{ |snapshot| snapshot[:snapshot_id] }
+      disable_snapshot_ids = (all_snapshot_ids - enable_snapshot_ids)
+      disable_snapshot_ids.each do |disable_snapshot_id|
+        @ec2.delete_snapshot({snapshot_id: disable_snapshot_id})
+        @logger.info "delete snapshot #{disable_snapshot_id}"
+      end
+    end
+
+    def ping?(private_ip_address)
+      if private_ip_address
+        pinger = Net::Ping::External.new(private_ip_address)
+        if pinger.ping?
+          @logger.info "already exists private_ip_address => #{private_ip_address}"
+          return true
+        end
+      end
+      return false
+    end
+
+    def allocate_address_vpc
+      @ec2.allocate_address(domain: 'vpc').data
+    end
   end
 end

data/lib/ec2ex/version.rb

@@ -1,4 +1,4 @@
 module Ec2ex
   # ec2ex version
-  VERSION = '0.1.0'
+  VERSION = '0.2.0'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ec2ex
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Hiroshi Toyama
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-01-14 00:00:00.000000000 Z
+date: 2016-12-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: thor
@@ -56,16 +56,16 @@ dependencies:
   name: aws-sdk
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 2.0.11.pre
+        version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 2.0.11.pre
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: activesupport
   requirement: !ruby/object:Gem::Requirement
@@ -80,20 +80,48 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: parallel
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: net-ping
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 1.7.2
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 1.7.2
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: pry
   requirement: !ruby/object:Gem::Requirement
@@ -225,7 +253,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.2
+rubygems_version: 2.5.1
 signing_key: 
 specification_version: 4
 summary: ec2 expand command line