ec2ex 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 6fd690807cff2f0f5be2b942621f1efe62ff96de
+  data.tar.gz: 7ef5ca48952371e67172a80caa92c372b1751144
+SHA512:
+  metadata.gz: 81c2592526c7d51688a431c99167abe994b3f1a940c22b38ec7ad56909238efc4b841e78df317ecf27d2a66692cfec228115994d44c6f0e32e0d498f56ff8cde
+  data.tar.gz: 5ba6cbfc97e284c35de7f77e9125f4c48c0fabe740dc91a2b076803095865425d3c071d98df36ec73cd8b94666ed08d7274ed03dbf698692ff2c65768537d4ac

data/.document

@@ -0,0 +1,3 @@
+- 
+ChangeLog.md
+LICENSE.txt

data/.gitignore

@@ -0,0 +1,8 @@
+Gemfile.lock
+doc/
+pkg/
+**/*.gem
+.yardoc/
+.bundle/
+vendor/bundle/
+.tags

data/.rspec

@@ -0,0 +1 @@
+--colour --format documentation

data/.travis.yml

@@ -0,0 +1,16 @@
+language: ruby
+
+rvm:
+  - 1.9.3
+  - 2.0.0
+  - 2.1
+  - ruby-head
+
+os:
+  - linux
+  - osx
+
+gemfile:
+  - Gemfile
+
+script: 'bundle exec rake spec'

data/.yardopts

@@ -0,0 +1 @@
+--markup markdown --title "ec2ex Documentation" --protected

data/ChangeLog.md

@@ -0,0 +1,4 @@
+### 0.1.0 / 2014-12-15
+
+* Initial release:
+

data/Gemfile

@@ -0,0 +1,7 @@
+source 'https://rubygems.org'
+
+gemspec
+
+group :development do
+  gem 'kramdown'
+end

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2014 Hiroshi Toyama
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,45 @@
+# ec2ex [![Build Status](https://secure.travis-ci.org/toyama0919/ec2ex.png?branch=master)](http://travis-ci.org/toyama0919/ec2ex)
+
+TODO: Summary
+
+TODO: Description
+
+## Examples
+
+    $ ec2ex sample
+    #=> hoge
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'ec2ex'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install ec2ex
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new [Pull Request](../../pull/new/master)
+
+## Information
+
+* [Homepage](https://github.com/toyama0919/ec2ex)
+* [Issues](https://github.com/toyama0919/ec2ex/issues)
+* [Documentation](http://rubydoc.info/gems/ec2ex/frames)
+* [Email](mailto:toyama0919@gmail.com)
+
+## Copyright
+
+Copyright (c) 2014 Hiroshi Toyama
+
+See [LICENSE.txt](../LICENSE.txt) for details.

data/Rakefile

@@ -0,0 +1,40 @@
+# encoding: utf-8
+
+require 'rubygems'
+require 'rake'
+
+begin
+  gem 'rubygems-tasks', '~> 0.2'
+  require 'rubygems/tasks'
+
+  Gem::Tasks.new
+rescue LoadError => e
+  warn e.message
+  warn "Run `gem install rubygems-tasks` to install Gem::Tasks."
+end
+
+begin
+  gem 'rspec', '~> 2.4'
+  require 'rspec/core/rake_task'
+
+  RSpec::Core::RakeTask.new
+rescue LoadError => e
+  task :spec do
+    abort "Please run `gem install rspec` to install RSpec."
+  end
+end
+
+task :test    => :spec
+task :default => :spec
+
+begin
+  gem 'yard', '~> 0.8'
+  require 'yard'
+
+  YARD::Rake::YardocTask.new  
+rescue LoadError => e
+  task :yard do
+    abort "Please run `gem install yard` to install YARD."
+  end
+end
+task :doc => :yard

data/bin/ec2ex

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+
+require 'rubygems'
+require 'ec2ex'
+
+Ec2ex::CLI.start

data/ec2ex.gemspec

@@ -0,0 +1,33 @@
+# -*- encoding: utf-8 -*-
+
+require File.expand_path('../lib/ec2ex/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.name          = "ec2ex"
+  gem.version       = Ec2ex::VERSION
+  gem.summary       = %q{ec2 expand command line}
+  gem.description   = %q{ec2 expand command line}
+  gem.license       = "MIT"
+  gem.authors       = ["Hiroshi Toyama"]
+  gem.email         = "toyama0919@gmail.com"
+  gem.homepage      = "https://github.com/toyama0919/ec2ex"
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ['lib']
+
+  gem.add_dependency 'thor'
+  gem.add_dependency 'hashie'
+  gem.add_dependency 'ipaddress'
+  gem.add_dependency 'aws-sdk', '~> 2.0.11.pre'
+  gem.add_dependency 'activesupport'
+
+  gem.add_development_dependency 'bundler', '~> 1.7.2'
+  gem.add_development_dependency 'pry', '~> 0.10.1'
+  gem.add_development_dependency 'rake', '~> 10.3.2'
+  gem.add_development_dependency 'rspec', '~> 2.4'
+  gem.add_development_dependency 'rubocop', '~> 0.24.1'
+  gem.add_development_dependency 'rubygems-tasks', '~> 0.2'
+  gem.add_development_dependency 'yard', '~> 0.8'
+end

data/lib/ec2ex.rb

@@ -0,0 +1,3 @@
+require 'ec2ex/version'
+require 'ec2ex/core'
+require 'ec2ex/cli'

data/lib/ec2ex/cli.rb

@@ -0,0 +1,476 @@
+require 'thor'
+require 'json'
+require 'pp'
+require 'hashie'
+require 'aws-sdk'
+require 'active_support/core_ext/hash'
+
+module Ec2ex
+  class CLI < Thor
+    include Thor::Actions
+    map '-s' => :search
+    map '-t' => :search_by_tags
+    map '-i' => :search_images
+    map '-a' => :aggregate
+
+    class_option :profile, type: :string, default: 'default', required: true, desc: 'name tag'
+    class_option :fields, type: :array, default: nil, desc: 'fields'
+    def initialize(args = [], options = {}, config = {})
+      super(args, options, config)
+      @global_options = config[:shell].base.options
+      @core = Core.new
+      @ec2 = Aws::EC2::Client.new
+      @elb = Aws::ElasticLoadBalancing::Client.new
+    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'])
+      puts_json results
+    end
+
+    desc 'search_by_tags', 'search by tags instance'
+    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'])
+    end
+
+    desc 'reserved', 'reserved instance'
+    def reserved
+      filter = []
+      filter << { name: 'state', values: ['active'] }
+      reserved_hash = {}
+      @ec2.describe_reserved_instances(filters: filter)[:reserved_instances].each{ |reserved|
+        sum = reserved_hash[reserved[:instance_type] + '_' + reserved[:availability_zone]] || 0
+        reserved_hash[reserved[:instance_type] + '_' + reserved[:availability_zone]] = sum + reserved[:instance_count]
+      }
+      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} ")
+        end.join('_')
+      }
+      result = {}
+      @core.group_count(list).each do |k, v|
+        result[k] = { instance_count: v, reserved_count: 0 }
+      end
+      reserved_hash.each do |k, v|
+        hash = result[k] || { instance_count: 0 }
+        hash[:reserved_count] = v
+        result[k] = hash
+      end
+      puts_json(result)
+    end
+
+    desc 'create_image', 'create image'
+    option :name, aliases: '-n', type: :string, default: '', required: true, desc: 'name tag'
+    def create_image
+      results = @core.instances_hash({ Name: options['name'] }, false)
+      results.each do |instance|
+        @core.create_image_with_instance(instance)
+      end
+    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'
+    def copy
+      results = @core.instances_hash({ Name: options['name'] }, true)
+      results.each do |instance|
+        image_id = @core.create_image_with_instance(instance)
+        security_group_ids = instance.security_groups.map { |security_group| security_group.group_id }
+        request = {
+          image_id: image_id,
+          min_count: 1,
+          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
+        }
+        unless instance.iam_instance_profile.nil?
+          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
+
+        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']))
+        end
+      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'
+    def renew
+      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']
+          @core.stop_instance(instance.instance_id)
+        end
+
+        image_id = @core.create_image_with_instance(instance)
+
+        @core.terminate_instance(instance.instance_id)
+        security_group_ids = instance.security_groups.map { |security_group| security_group.group_id }
+        request = {
+          image_id: image_id,
+          min_count: 1,
+          max_count: 1,
+          security_group_ids: security_group_ids,
+          instance_type: instance.instance_type,
+          placement: instance.placement.to_hash,
+          private_ip_address: instance.private_ip_address
+        }
+        unless instance.iam_instance_profile.nil?
+          request[:iam_instance_profile] = { name: instance.iam_instance_profile.arn.split('/').last }
+        end
+        request.merge!(params)
+        request[:subnet_id] = @core.get_subnet(request[:private_ip_address]).subnet_id
+
+        response = @ec2.run_instances(request)
+        instance_id = response.instances.first.instance_id
+        sleep 5
+        @ec2.wait_until(:instance_running, instance_ids: [instance_id])
+        @ec2.create_tags(resources: [instance_id], tags: instance.tags)
+
+        @core.associate_address(instance_id, instance.public_ip_address)
+      end
+    end
+
+    desc 'spot', 'request spot instances'
+    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 :public_ip_address, type: :string, default: nil, desc: 'public_ip_address'
+    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'
+    def spot
+      results = @core.instances_hash({ Name: options['name'] }, true)
+      results.each do |instance|
+        image_id = @core.create_image_with_instance(instance)
+        security_group_ids = instance.security_groups.map { |security_group| security_group.group_id }
+        option = {
+          instance_count: 1,
+          spot_price: options['price'],
+          launch_specification: {
+            image_id: image_id,
+            instance_type: instance.instance_type,
+            security_group_ids: security_group_ids,
+            subnet_id: instance.subnet_id
+          },
+        }
+        option[:type] = 'persistent' if options['persistent']
+
+        unless instance.iam_instance_profile.nil?
+          option[:launch_specification][:iam_instance_profile] = { name: instance.iam_instance_profile.arn.split('/').last }
+        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']
+        else
+          private_ip_address = options['private_ip_address']
+        end
+
+        unless private_ip_address.nil?
+          network_interface = {
+            device_index: 0,
+            subnet_id: @core.get_subnet(private_ip_address).subnet_id,
+            groups: 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']
+
+        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)
+
+        @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']))
+        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
+        @core.associate_address(instance_id, public_ip_address)
+      end
+    end
+
+    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'
+    def run_spot
+      image = @core.latest_image_with_name(options['name'])
+      tag_hash = @core.get_tag_hash(image[:tags])
+      option = {
+        instance_count: 1,
+        spot_price: options['price'],
+        launch_specification: {
+          image_id: image[:image_id],
+          instance_type: tag_hash.instance_type
+        },
+      }
+
+      if tag_hash.iam_instance_profile
+        option[:launch_specification][:iam_instance_profile] = { name: tag_hash.iam_instance_profile }
+      end
+
+      network_interface = {
+        device_index: 0,
+        subnet_id: @core.get_subnet(tag_hash.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 }]
+      }
+      option[:launch_specification][:network_interfaces] = [network_interface]
+
+      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)
+      @ec2.create_tags(resources: [instance_id], tags: JSON.parse(tag_hash[:tags]))
+
+      if tag_hash.public_ip_address
+        @core.associate_address(instance_id, tag_hash.public_ip_address)
+      end
+    end
+
+    desc 'regist_deny_acl', 'regist deny acl'
+    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']])
+
+      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'
+                       }.first.rule_number
+
+      deny_rules = acls.network_acls.first.entries.select {|r|
+                         !r.egress && r.rule_number < allow_any_rule_number
+                       }.sort_by { |r| r.rule_number }
+
+      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" }
+        option = {
+          network_acl_id: options['acl_id'],
+          rule_number: next_rule_number,
+          rule_action: 'deny',
+          protocol: '-1',
+          cidr_block: "#{options['ip_address']}/32",
+          egress: false
+        }
+        @ec2.create_network_acl_entry(option)
+      end
+    end
+
+    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']])
+
+      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'
+                       }.first.rule_number
+
+      deny_rules = acls.network_acls.first.entries.select {|r|
+                         !r.egress && r.rule_number < allow_any_rule_number
+                       }.sort_by { |r| r.rule_number }
+
+      deny_rules.each do |deny_rule|
+        option = {
+          network_acl_id: options['acl_id'],
+          rule_number: deny_rule.rule_number,
+          egress: false
+        }
+        @ec2.delete_network_acl_entry(option)
+      end
+    end
+
+    desc 'acls', 'show acls'
+    def acls
+      puts_json(@ec2.describe_network_acls.data.to_hash[:network_acls])
+    end
+
+    desc 'subnets', 'show subnets'
+    def subnets
+      puts_json(@ec2.describe_subnets.data.to_hash[:subnets])
+    end
+
+    desc 'sg', 'show security groups'
+    def sg
+      puts_json(@ec2.describe_security_groups.data.to_hash[:security_groups])
+    end
+
+    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)
+      @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'] }])
+    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'])
+      @ec2.create_tags(resources: instances.map { |instance| instance.instance_id }, tags: tags)
+    end
+
+    desc 'search_images', 'search images'
+    option :name, aliases: '-n', type: :string, default: '', required: true, desc: 'name tag'
+    def search_images(name = options['name'])
+      puts_json @core.images(name)
+    end
+
+    desc 'aggregate', 'say hello to NAME'
+    option :condition, aliases: '-c', type: :hash, default: {}, desc: 'grouping key'
+    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|
+          eval("instance.#{key} ")
+        end.join('_')
+      end
+      puts @core.group_count(list).to_json
+    end
+
+    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|
+        @ec2.reboot_instances(instance_ids: [instance.instance_id])
+        sleep 5
+        @ec2.wait_until(:instance_running, instance_ids: [instance.instance_id])
+      end
+    end
+
+    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|
+        @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!"
+        end
+      end
+    end
+
+    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)
+      end
+    end
+
+    desc 'terminate', 'terminate 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.start_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] }
+        @elb.deregister_instances_from_load_balancer(option)
+        @elb.register_instances_with_load_balancer(option)
+        print 'connecting ELB...'
+        loop do
+          break if 'InService' == @elb.describe_instance_health(option).instance_states.first.state
+          sleep 10
+          print '.'
+        end
+      end
+    end
+
+    desc 'elbs', 'show elbs'
+    def elbs
+      puts_json @elb.describe_load_balancers.data.to_h[:load_balancer_descriptions]
+    end
+
+    desc 'events', 'show events'
+    def events
+      results = []
+      @core.instances_hash({}, true).each do |i|
+        status = @ec2.describe_instance_status(instance_ids: [i.instance_id])
+        events = status.data[:instance_status_set][0][:events] rescue nil
+        next if events.nil? or events.empty?
+        events.each do |event|
+          next if event[:description] =~ /^\[Completed\]/
+          event[:id] = i.id
+          event[:name] = i.tags['Name']
+          event[:availability_zone] = i.availability_zone
+          results << event
+        end
+      end
+      puts_json results
+    end
+
+    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'])
+    end
+
+    desc 'allocate_address', 'allocate address'
+    def allocate_address
+      response = @ec2.allocate_address(domain: 'vpc')
+      puts response
+    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'])
+      end
+      puts JSON.pretty_generate(data)
+    end
+  end
+end

data/lib/ec2ex/core.rb

@@ -0,0 +1,176 @@
+require 'aws-sdk'
+require 'ipaddress'
+
+module Ec2ex
+  class Core
+    def initialize
+      @ec2 = Aws::EC2::Client.new
+    end
+
+    def extract_fields(data, fields)
+      results = []
+      data.each do |row|
+        row = Hashie::Mash.new(row) if row.class == Hash
+        result = {}
+        fields.map { |key|
+          result[key] = eval("row.#{key}")
+        }
+        results << result
+      end
+      results
+    end
+
+    def group_count(list)
+      Hash[list.group_by { |e| e }.map { |k, v| [k, v.length] }]
+    end
+
+    def format_tag(tag)
+      tags = []
+      tag.each do |k, v|
+        tags << { key: k, value: v }
+      end
+      tags
+    end
+
+    def get_tag_hash(tags)
+      result = {}
+      tags.each {|hash|
+        result[hash['key'] || hash[:key]] = hash['value'] || hash[:value]
+      }
+      Hashie::Mash.new(result)
+    end
+
+    def instances_hash(condition, running_only = true)
+      filter = []
+      condition.each do |key, value|
+        filter << { name: "tag:#{key}", values: ["#{value}"] }
+      end
+      if running_only
+        filter << { name: 'instance-state-name', values: ['running'] }
+      else
+        filter << { name: 'instance-state-name', values: %w(running stopped) }
+      end
+      @ec2.describe_instances(
+        filters: filter
+      ).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]
+    end
+
+    def create_image_with_instance(instance)
+      puts 'image creating...'
+      tags = get_tag_hash(instance.tags)
+      snapshot = {
+        '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
+      unless instance.public_ip_address.nil?
+        snapshot['public_ip_address'] = instance.public_ip_address
+      end
+      snapshot['instance_type'] = instance.instance_type
+      snapshot['placement'] = instance.placement.to_hash.to_json
+      unless instance.iam_instance_profile.nil?
+        snapshot['iam_instance_profile'] = instance.iam_instance_profile.arn.split('/').last
+      end
+
+      image_response = @ec2.create_image(
+        instance_id: instance.instance_id,
+        name: tags['Name'] + ".#{Time.now.strftime('%Y%m%d%H%M%S')}",
+        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
+      end
+      puts "image create complete! image_id => [#{image_response.image_id}]"
+
+      ami_tag = format_tag(snapshot)
+      @ec2.create_tags(resources: [image_response.image_id], tags: ami_tag)
+      image_response.image_id
+    end
+
+    def wait_spot_running(spot_instance_request_id)
+      puts '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
+        end
+        sleep 10
+      end
+      @ec2.wait_until(:instance_running, instance_ids: [instance_id])
+      puts "spot instance create complete! instance_id => [#{instance_id}]"
+      instance_id
+    end
+
+    def get_allocation(public_ip_address)
+      @ec2.describe_addresses(public_ips: [public_ip_address]).addresses.first
+    end
+
+    def get_subnet(private_ip_address)
+      subnets = @ec2.describe_subnets.subnets.select{ |subnet|
+        ip = IPAddress(subnet.cidr_block)
+        ip.to_a.map { |ipv4| ipv4.address }.include?(private_ip_address)
+      }
+      subnets.first
+    end
+
+    def stop_instance(instance_id)
+      puts '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}]"
+    end
+
+    def start_instance(instance_id)
+      puts '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}]"
+    end
+
+    def terminate_instance(instance_id)
+      puts '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}]"
+    end
+
+    def associate_address(instance_id, public_ip_address)
+      unless public_ip_address.nil?
+        allocation_id = get_allocation(public_ip_address).allocation_id
+        resp = @ec2.associate_address(instance_id: instance_id, allocation_id: allocation_id)
+      end
+    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 = result.sort_by{ |image|
+        tag_hash = get_tag_hash(image[:tags])
+        tag_hash['created'].nil? ? '' : tag_hash['created']
+      }
+      result.empty? ? {} : result.last
+    end
+  end
+end

data/lib/ec2ex/version.rb

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

data/spec/cli_spec.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+require 'ec2ex'
+
+describe Ec2ex::CLI do
+  before do
+  end
+
+  it "should stdout sample" do
+    output = capture_stdout do
+      Ec2ex::CLI.start(['sample'])
+    end
+    output.should == "This is your new task\n"
+  end
+
+  after do
+  end
+end

data/spec/core_spec.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+require 'ec2ex'
+
+describe Ec2ex::Core do
+  before do
+    @core = Core.new
+  end
+
+  it "core not nil" do
+    @core.should_not nil
+  end
+
+  after do
+  end
+end

data/spec/ec2ex_spec.rb

@@ -0,0 +1,8 @@
+require 'spec_helper'
+require 'ec2ex'
+
+describe Ec2ex do
+  it "should have a VERSION constant" do
+    subject.const_get('VERSION').should_not be_empty
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,24 @@
+gem 'rspec', '~> 2.4'
+require 'rspec'
+require 'ec2ex/version'
+
+include Ec2ex
+
+def capture_stdout
+  out = StringIO.new
+  $stdout = out
+  yield
+  return out.string
+ensure
+  $stdout = STDOUT
+end
+
+def capture_stderr
+  out = StringIO.new
+  $stderr = out
+  yield
+  return out.string
+ensure
+  $stderr = STDERR
+end
+

metadata

@@ -0,0 +1,236 @@
+--- !ruby/object:Gem::Specification
+name: ec2ex
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Hiroshi Toyama
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-01-14 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: thor
+  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: hashie
+  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: ipaddress
+  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: aws-sdk
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.0.11.pre
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.0.11.pre
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  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
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.7.2
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.10.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.10.1
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 10.3.2
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 10.3.2
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.4'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.4'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.24.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.24.1
+- !ruby/object:Gem::Dependency
+  name: rubygems-tasks
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.2'
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+description: ec2 expand command line
+email: toyama0919@gmail.com
+executables:
+- ec2ex
+extensions: []
+extra_rdoc_files: []
+files:
+- ".document"
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- ".yardopts"
+- ChangeLog.md
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/ec2ex
+- ec2ex.gemspec
+- lib/ec2ex.rb
+- lib/ec2ex/cli.rb
+- lib/ec2ex/core.rb
+- lib/ec2ex/version.rb
+- spec/cli_spec.rb
+- spec/core_spec.rb
+- spec/ec2ex_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/toyama0919/ec2ex
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.2
+signing_key: 
+specification_version: 4
+summary: ec2 expand command line
+test_files:
+- spec/cli_spec.rb
+- spec/core_spec.rb
+- spec/ec2ex_spec.rb
+- spec/spec_helper.rb