awful 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 7bedcb9861ea2075c3ea043bd651ebf56edd2668
+  data.tar.gz: aa9e8729e5772fef666e9334ad6405bf8977c816
+SHA512:
+  metadata.gz: b9af606fdddd26cb7455a485690da1e62b7bc02efdc5d2d2ee494c092957cfdd47b8adb5cae71e98188a0d3f16ecedb26fd44420734de7b4bc128f2fe4e0eec3
+  data.tar.gz: 6c6218d4692d44c435aad729be0346d166e6421cc4cf9f6d2ec686b6866179b6f11fbf4ccb2315c391db7740480b545533ddf78155bcf7aff5abc53b36f68ee3

data/.gitignore

@@ -0,0 +1,14 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in awful.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2015 TODO: Write your name
+
+MIT License
+
+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,31 @@
+# Awful
+
+TODO: Write a gem description
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'awful'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install awful
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Contributing
+
+1. Fork it ( https://github.com/[my-github-username]/awful/fork )
+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 a new Pull Request

data/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+

data/awful.gemspec

@@ -0,0 +1,26 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'awful/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "awful"
+  spec.version       = Awful::VERSION
+  spec.authors       = ["Ric Lister"]
+  spec.email         = ["rlister+gh@gmail.com"]
+  spec.summary       = %q{Simple AWS command-line tool.}
+  spec.description   = %q{AWS cmdline and yaml loader.}
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.7"
+  spec.add_development_dependency "rake", "~> 10.0"
+
+  spec.add_dependency('aws-sdk', '~> 2')
+  spec.add_dependency('thor')
+end

data/bin/asg

@@ -0,0 +1,7 @@
+#!/usr/bin/ruby
+#-*- mode: ruby; -*-
+
+require 'awful'
+require 'awful/auto_scaling'
+
+Awful::AutoScaling.start(ARGV)

data/bin/ec2

@@ -0,0 +1,7 @@
+#!/usr/bin/ruby
+#-*- mode: ruby; -*-
+
+require 'awful'
+require 'awful/ec2'
+
+Awful::Ec2.start(ARGV)

data/bin/elb

@@ -0,0 +1,7 @@
+#!/usr/bin/ruby
+#-*- mode: ruby; -*-
+
+require 'awful'
+require 'awful/elb'
+
+Awful::Elb.start(ARGV)

data/bin/lc

@@ -0,0 +1,7 @@
+#!/usr/bin/ruby
+#-*- mode: ruby; -*-
+
+require 'awful'
+require 'awful/launch_config'
+
+Awful::LaunchConfig.start(ARGV)

data/bin/subnet

@@ -0,0 +1,7 @@
+#!/usr/bin/ruby
+#-*- mode: ruby; -*-
+
+require 'awful'
+require 'awful/subnet'
+
+Awful::Subnet.start(ARGV)

data/bin/vpc

@@ -0,0 +1,7 @@
+#!/usr/bin/ruby
+#-*- mode: ruby; -*-
+
+require 'awful'
+require 'awful/vpc'
+
+Awful::Vpc.start(ARGV)

data/lib/awful.rb

@@ -0,0 +1,87 @@
+require "awful/version"
+
+require 'aws-sdk'
+require 'thor'
+require 'yaml'
+
+module Awful
+
+  def ec2
+    @ec2 ||= Aws::EC2::Client.new
+  end
+
+  def autoscaling
+    @autoscaling ||= Aws::AutoScaling::Client.new
+  end
+
+  def elb
+    @elb ||= Aws::ElasticLoadBalancing::Client.new
+  end
+
+  def symbolize_keys(thing)
+    if thing.is_a?(Hash)
+      Hash[ thing.map { |k,v| [ k.to_sym, symbolize_keys(v) ] } ]
+    elsif thing.respond_to?(:map)
+      thing.map { |v| symbolize_keys(v) }
+    else
+      thing
+    end
+  end
+
+  def stringify_keys(thing)
+    if thing.is_a?(Hash)
+      Hash[ thing.map { |k,v| [ k.to_s, stringify_keys(v) ] } ]
+    elsif thing.respond_to?(:map)
+      thing.map { |v| stringify_keys(v) }
+    else
+      thing
+    end
+  end
+
+  def load_cfg(options = {})
+    cfg = $stdin.tty? ? {} : symbolize_keys(YAML.load($stdin.read))
+    cfg.merge(symbolize_keys(options.reject{ |_,v| v.nil? }))
+  end
+
+  def only_keys_matching(hash, keylist)
+    hash.select do |key,_|
+      keylist.include?(key)
+    end
+  end
+
+  def remove_empty_strings(hash)
+    hash.reject do |_,value|
+      value.respond_to?(:empty?) and value.empty?
+    end
+  end
+
+  def tag_name(thing)
+    tn = thing.tags.find { |tag| tag.key == 'Name' }
+    tn && tn.value
+  end
+
+  ## return id for instance by name
+  def find_instance(name)
+    if name .nil?
+      nil?
+    elsif name.match(/^i-[\d[a-f]]{8}$/)
+      name
+    else
+      ec2.describe_instances.map(&:reservations).flatten.map(&:instances).flatten.find do |instance|
+        tag_name(instance) == name
+      end.instance_id
+    end
+  end
+
+  ## return id for subnet by name
+  def find_subnet(name)
+    if name.match(/^subnet-[\d[a-f]]{8}$/)
+      name
+    else
+      ec2.describe_subnets.map(&:subnets).flatten.find do |subnet|
+        tag_name(subnet) == name
+      end.subnet_id
+    end
+  end
+
+end

data/lib/awful/auto_scaling.rb

@@ -0,0 +1,135 @@
+module Awful
+
+  class AutoScaling < Thor
+    include Awful
+
+    desc 'ls [PATTERN]', 'list autoscaling groups with name matching PATTERN'
+    method_option :long, aliases: '-l', default: false, desc: 'Long listing'
+    def ls(name = /./)
+      fields = if options[:long]
+                 ->(a) { [
+                           a.auto_scaling_group_name,
+                           a.launch_configuration_name,
+                           "#{a.instances.length}/#{a.desired_capacity}",
+                           "#{a.min_size}-#{a.max_size}",
+                           a.availability_zones.sort.join(','),
+                           a.created_time
+                         ] }
+               else
+                 ->(a) { [ a.auto_scaling_group_name ] }
+               end
+
+      autoscaling.describe_auto_scaling_groups.map(&:auto_scaling_groups).flatten.select do |asg|
+        asg.auto_scaling_group_name.match(name)
+      end.map do |asg|
+        fields.call(asg)
+      end.tap do |list|
+        print_table list
+      end
+    end
+
+    desc 'delete NAME', 'delete autoscaling group'
+    def delete(name)
+      if yes? "Really delete auto-scaling group #{name}?", :yellow
+        autoscaling.delete_auto_scaling_group(auto_scaling_group_name: name)
+      end
+    end
+
+    desc 'instances', 'list instance IDs for instances in groups matching NAME'
+    method_option :long, aliases: '-l', default: false, desc: 'Long listing'
+    def instances(name)
+      fields = options[:long] ? %i[instance_id auto_scaling_group_name availability_zone lifecycle_state health_status launch_configuration_name] : %i[instance_id]
+
+      autoscaling.describe_auto_scaling_instances.map(&:auto_scaling_instances).flatten.select do |instance|
+        instance.auto_scaling_group_name.match(name)
+      end.map do |instance|
+        fields.map { |field| instance.send(field) }
+      end.tap do |list|
+        print_table list
+      end
+
+    end
+
+    desc 'ips NAME', 'list IPs for instances in groups matching NAME'
+    method_option :long, aliases: '-l', default: false, desc: 'Long listing'
+    def ips(name)
+      fields = options[:long] ? %i[public_ip_address private_ip_address instance_id image_id instance_type launch_time] : %i[ public_ip_address ]
+
+      instance_ids = autoscaling.describe_auto_scaling_instances.map(&:auto_scaling_instances).flatten.select do |instance|
+        instance.auto_scaling_group_name.match(name)
+      end.map(&:instance_id)
+
+      ec2 = Aws::EC2::Client.new
+      ec2.describe_instances(instance_ids: instance_ids).map(&:reservations).flatten.map(&:instances).flatten.map do |instance|
+        fields.map { |field| instance.send(field) }
+      end.tap do |list|
+        print_table list
+      end
+    end
+
+    desc 'dump NAME', 'dump existing autoscaling group as yaml'
+    def dump(name)
+      asg = autoscaling.describe_auto_scaling_groups(auto_scaling_group_names: Array(name)).map(&:auto_scaling_groups).flatten.first.to_hash
+      puts YAML.dump(stringify_keys(asg))
+    end
+
+    desc 'create NAME', 'create a new auto-scaling group'
+    def create(name)
+      opt = load_cfg
+      whitelist = %i[auto_scaling_group_name launch_configuration_name instance_id min_size max_size desired_capacity default_cooldown availability_zones
+                     load_balancer_names health_check_type health_check_grace_period placement_group vpc_zone_identifier termination_policies tags ]
+
+      opt[:auto_scaling_group_name] = name
+      opt = remove_empty_strings(opt)
+      opt = only_keys_matching(opt, whitelist)
+
+      ## scrub aws-provided keys from tags
+      opt[:tags] = opt.has_key?(:tags) ? opt[:tags].map { |tag| only_keys_matching(tag, %i[key value propagate_at_launch]) } : []
+
+      autoscaling.create_auto_scaling_group(opt)
+    end
+
+    desc 'update NAME', 'update existing auto-scaling group'
+    method_option :desired_capacity, aliases: '-d', default: nil, desc: 'Set desired capacity'
+    method_option :min_size,         aliases: '-m', default: nil, desc: 'Set minimum capacity'
+    method_option :max_size,         aliases: '-M', default: nil, desc: 'Set maximum capacity'
+    def update(name)
+      opt = load_cfg(options)
+      whitelist = %i[auto_scaling_group_name launch_configuration_name min_size max_size desired_capacity default_cooldown availability_zones
+                     health_check_type health_check_grace_period placement_group vpc_zone_identifier termination_policies ]
+
+      ## cleanup the group options
+      opt[:auto_scaling_group_name] = name
+      opt = remove_empty_strings(opt)
+
+      ## update the group
+      autoscaling.update_auto_scaling_group(only_keys_matching(opt, whitelist))
+
+      ## update any tags
+      if opt[:tags]
+        tags = opt[:tags].map { |tag| tag.merge(resource_id: name, resource_type: 'auto-scaling-group') }
+        autoscaling.create_or_update_tags(tags: tags)
+      end
+    end
+
+    desc 'terminate NAME', 'terminate instances in group NAME'
+    method_option :decrement, aliases: '-d', default: false, desc: 'Decrement desired capacity for each terminated instance'
+    def terminate(name, num = 1)
+      instance_ids = autoscaling.describe_auto_scaling_instances.map(&:auto_scaling_instances).flatten.select do |instance|
+        instance.auto_scaling_group_name == name
+      end.map(&:instance_id)
+
+      instances = ec2.describe_instances(instance_ids: instance_ids).map(&:reservations).flatten.map(&:instances).flatten.sort_by(&:launch_time)
+      instances.first(num.to_i).map(&:instance_id).tap do |ids|
+        if yes? "Really terminate #{num} instances: #{ids.join(',')}?", :yellow
+          ids.each do |id|
+            autoscaling.terminate_instance_in_auto_scaling_group(instance_id: id, should_decrement_desired_capacity: options[:decrement] && true)
+          end
+        end
+      end
+
+    end
+
+  end
+
+end

data/lib/awful/ec2.rb

@@ -0,0 +1,137 @@
+require 'base64'
+
+module Awful
+
+  class Ec2 < Thor
+    include Awful
+
+    desc 'ls [PATTERN]', 'list EC2 instances [with id or tags matching PATTERN]'
+    method_option :long, aliases: '-l', default: false, desc: 'Long listing'
+    def ls(name = /./)
+      fields = options[:long] ?
+        ->(i) { [ tag_name(i) || '-', i.instance_id, i.instance_type, i.virtualization_type, i.placement.availability_zone, i.state.name,
+                  i.security_groups.map(&:group_name).join(','), i.private_ip_address, i.public_ip_address ] } :
+        ->(i) { [ tag_name(i) || i.instance_id ] }
+
+      ec2.describe_instances.map(&:reservations).flatten.map(&:instances).flatten.select do |instance|
+        instance.instance_id.match(name) or instance.tags.any? { |tag| tag.value.match(name) }
+      end.map do |instance|
+        fields.call(instance)
+      end.tap do |list|
+        print_table list.sort
+      end
+    end
+
+    desc 'dump NAME', 'dump EC2 instance with id or tag NAME as yaml'
+    def dump(name)
+      ec2.describe_instances.map(&:reservations).flatten.map(&:instances).flatten.find do |instance|
+        instance.instance_id == name or tag_name(instance) == name
+      end.tap do |instance|
+        puts YAML.dump(stringify_keys(instance.to_hash))
+      end
+    end
+
+    desc 'create NAME', 'run new EC2 instance'
+    method_option :subnet,     :aliases => '-s', :default => nil,  :desc => 'VPC subnet to use; default nil (classic)'
+    method_option :public_ip,  :aliases => '-p', :default => true, :desc => 'Assign public IP to VPC instances'
+    method_option :elastic_ip, :aliases => '-e', :default => true, :desc => 'Assign new elastic IP to instances'
+    def create(name)
+      opt = load_cfg.merge(symbolize_keys(options))
+      whitelist = %i[image_id min_count max_count key_name security_group_ids user_data instance_type kernel_id
+                     ramdisk_id  monitoring subnet_id disable_api_termination instance_initiated_shutdown_behavior
+                     additional_info iam_instance_profile ebs_optimized network_interfaces]
+
+      opt[:min_count] ||= 1
+      opt[:max_count] ||= 1
+      opt[:monitoring] = {enabled: opt.fetch(:monitoring, {}).fetch(:state, '') == 'enabled'}
+
+      ## set subnet from human-readable name, either for network interface, or instance-level
+      if opt[:subnet]
+        subnet = find_subnet(opt[:subnet])
+        opt[:network_interfaces] ? (opt[:network_interfaces][0][:subnet_id] = subnet) : (opt[:subnet_id] = subnet)
+      end
+
+      (opt[:tags] = opt.fetch(:tags, [])).find_index { |t| t[:key] == 'Name' }.tap do |index|
+        opt[:tags][index || 0] = {key: 'Name', value: name}
+      end
+
+      ## TODO: block_device_mappings
+      ## TODO: placement
+
+      opt[:security_group_ids] = opt.fetch(:security_groups, []).map { |sg| sg[:group_id] }
+      opt[:user_data] = Base64.strict_encode64(opt[:user_data]) if opt[:user_data]
+
+      # scrub unwanted fields from a copied instance dump
+      opt = remove_empty_strings(opt)
+
+      ## start instance
+      response = ec2.run_instances(only_keys_matching(opt, whitelist))
+      ids = response.instances.map(&:instance_id)
+      ec2.create_tags(resources: ids, tags: opt[:tags]) # tag instances
+      puts ids # report new instance ids
+
+      ## wait for instance to enter running state
+      puts 'running instance ...'
+      ec2.wait_until(:instance_running, instance_ids: ids)
+
+      ## allocate and associate new elastic IPs
+      ids.map { |id| associate(id, allocate.allocation_id) } if opt[:elastic_ip]
+
+      ## report DNS or IP for instance
+      ec2.describe_instances(instance_ids: ids).map(&:reservations).flatten.map(&:instances).flatten.map do |instance|
+        instance.public_dns_name or instance.public_ip_address or instance.private_ip_address
+      end.tap do |list|
+        puts list
+      end
+    end
+
+    desc 'allocate', 'allocate a new elastic IP address'
+    def allocate
+      ec2.allocate_address(domain: 'vpc').first.tap do |eip|
+        puts eip.allocation_id, eip.public_ip
+      end
+    end
+
+    desc 'associate NAME IP', 'associate a public ip with an instance'
+    def associate(name, eip)
+      ec2.associate_address(instance_id: find_instance(name), allocation_id: eip).map(&:association_id).tap do |id|
+        puts id
+      end
+    end
+
+    desc 'addresses', 'list elastic IP addresses'
+    def addresses
+      ec2.describe_addresses.map(&:addresses).flatten.map do |ip|
+        [ ip.allocation_id, ip.public_ip, ip.instance_id, ip.domain ]
+      end.tap do |list|
+        print_table list
+      end
+    end
+
+    desc 'dns NAME', 'get public DNS for named instance'
+    def dns(name)
+      ec2.describe_instances.map(&:reservations).flatten.map(&:instances).flatten.find do |instance|
+        instance.instance_id == name or (n = tag_name(instance) and n.match(name))
+      end.public_dns_name.tap do |dns|
+        puts dns
+      end
+    end
+
+    desc 'delete NAME', 'terminate a running instance'
+    def delete(name)
+      id =
+        if name.match(/^i-[\d[a-f]]{8}$/)
+          name
+        else
+          ec2.describe_instances.map(&:reservations).flatten.map(&:instances).flatten.find do |instance|
+            tag_name(instance) == name and not %w[terminated shutting-down].include?(instance.state.name)
+          end.instance_id
+        end
+      if yes? "Really terminate instance #{name} (#{id})?", :yellow
+        ec2.terminate_instances(instance_ids: Array(id))
+      end
+    end
+
+  end
+
+end

data/lib/awful/elb.rb

@@ -0,0 +1,86 @@
+module Awful
+
+  class Elb < Thor
+    include Awful
+
+    desc 'ls [PATTERN]', 'list vpcs [with any tags matching PATTERN]'
+    method_option :long, aliases: '-l', default: false, desc: 'Long listing'
+    def ls(name = /./)
+      fields = options[:long] ?
+        ->(e) { [e.load_balancer_name, e.instances.length, e.availability_zones.join(','), e.dns_name] } :
+        ->(e) { [e.load_balancer_name] }
+
+      elb.describe_load_balancers.map(&:load_balancer_descriptions).flatten.select do |elb|
+        elb.load_balancer_name.match(name)
+      end.map do |elb|
+        fields.call(elb)
+      end.tap do |list|
+        print_table list
+      end
+    end
+
+    desc 'instances NAME', 'list instances and states for elb NAME'
+    def instances(name)
+      instances = elb.describe_instance_health(load_balancer_name: name).map(&:instance_states).flatten
+      instances_by_id = instances.inject({}) { |hash,instance| hash[instance.instance_id] = instance; hash }
+
+      ec2.describe_instances(instance_ids: instances_by_id.keys).map(&:reservations).flatten.map(&:instances).flatten.map do |instance|
+        health = instances_by_id[instance.instance_id]
+        [ instance.tags.map(&:value).sort.join(','), instance.public_ip_address, health.state, health.reason_code, health.description ]
+      end.tap do |list|
+         print_table list
+      end
+    end
+
+    desc 'dump NAME', 'dump VPC with id or tag NAME as yaml'
+    def dump(name)
+      lb = elb.describe_load_balancers(load_balancer_names: Array(name)).map(&:load_balancer_descriptions).flatten.first.to_hash
+      puts YAML.dump(stringify_keys(lb))
+    end
+
+    desc 'dns NAME', 'get DNS name for load-balancers matching NAME'
+    def dns(name)
+      elb.describe_load_balancers.map(&:load_balancer_descriptions).flatten.select do |elb|
+        elb.load_balancer_name.match(name)
+      end.map(&:dns_name).tap do |dns|
+        puts dns
+      end
+    end
+
+    desc 'create NAME', 'create new load-balancer'
+    def create(name)
+      whitelist = %i[load_balancer_name listeners availability_zones subnets security_groups scheme tags]
+      opt = load_cfg
+      opt[:load_balancer_name] = name
+      opt[:listeners] = opt.fetch(:listener_descriptions, []).map { |l| l[:listener] }
+      opt.delete(:availability_zones) unless opt.fetch(:subnets, []).empty?
+      opt = remove_empty_strings(opt)
+      opt = only_keys_matching(opt, whitelist)
+      elb.create_load_balancer(opt).map(&:dns_name).flatten.tap { |dns| puts dns }
+      health_check(name) if opt[:health_check]
+    end
+
+    desc 'health_check NAME', 'set health-check'
+    method_option :target,              aliases: '-t', default: nil, desc: 'Health check target'
+    method_option :interval,            aliases: '-i', default: nil, desc: 'Check interval'
+    method_option :timeout,             aliases: '-o', default: nil, desc: 'Check timeout'
+    method_option :unhealthy_threshold, aliases: '-u', default: nil, desc: 'Unhealthy threshold'
+    method_option :healthy_threshold,   aliases: '-h', default: nil, desc: 'Healthy threshold'
+    def health_check(name)
+      opt = load_cfg.merge(options.reject(&:nil?))
+      hc = elb.configure_health_check(load_balancer_name: name, health_check: opt[:health_check])
+      hc.map(&:health_check).flatten.first.tap do |h|
+        print_table h.to_hash
+      end
+    end
+
+    desc 'delete NAME', 'delete load-balancer'
+    def delete(name)
+      if yes? "really delete ELB #{name}?", :yellow
+        elb.delete_load_balancer(load_balancer_name: name)
+      end
+    end
+
+  end
+
+end

data/lib/awful/launch_config.rb

@@ -0,0 +1,49 @@
+require 'base64'
+
+module Awful
+
+  class LaunchConfig < Thor
+    include Awful
+
+    desc 'ls [PATTERN]', 'list launch configs with name matching PATTERN'
+    method_option :long, aliases: '-l', default: false, desc: 'Long listing'
+    def ls(name = /./)
+      fields = options[:long] ? %i[launch_configuration_name image_id instance_type created_time] : %i[launch_configuration_name]
+      autoscaling.describe_launch_configurations.map(&:launch_configurations).flatten.select do |lc|
+        lc.launch_configuration_name.match(name)
+      end.map do |lc|
+        fields.map { |field| lc.send(field) }
+      end.tap do |list|
+        print_table list
+      end
+    end
+
+    desc 'delete NAME', 'delete launch configuration'
+    def delete(name)
+      autoscaling.delete_launch_configuration(launch_configuration_name: name)
+    end
+
+    desc 'dump NAME', 'dump existing launch_configuration as yaml'
+    def dump(name)
+      lc = autoscaling.describe_launch_configurations(launch_configuration_names: Array(name)).map(&:launch_configurations).flatten.first.to_hash
+      lc[:user_data] = Base64.decode64(lc[:user_data])
+      puts YAML.dump(stringify_keys(lc))
+    end
+
+    desc 'create [NAME]', 'create a new launch configuration'
+    def create(name)
+      opt = load_cfg
+      whitelist = %i[launch_configuration_name image_id key_name security_groups classic_link_vpc_id classic_link_vpc_security_groups user_data
+                     instance_id instance_type kernel_id ramdisk_id block_device_mappings instance_monitoring spot_price iam_instance_profile
+                     ebs_optimized associate_public_ip_address placement_tenancy]
+      opt[:launch_configuration_name] = "#{name}-#{Time.now.utc.strftime('%Y%m%d%H%M%S')}"
+      opt[:user_data] = Base64.encode64(opt[:user_data]) # encode user data
+      opt = remove_empty_strings(opt)
+      opt = only_keys_matching(opt, whitelist)
+      autoscaling.create_launch_configuration(opt)
+      puts opt[:launch_configuration_name]
+    end
+
+  end
+
+end

data/lib/awful/subnet.rb

@@ -0,0 +1,32 @@
+module Awful
+
+  class Subnet < Thor
+    include Awful
+
+    desc 'ls [PATTERN]', 'list subnets [with any tags matching PATTERN]'
+    method_option :long, aliases: '-l', default: false, desc: 'Long listing'
+    def ls(name = /./)
+      fields = options[:long] ?
+        ->(s) { [s.tags.map{ |t| t.value }.join(','), s.subnet_id, s.state, s.cidr_block, s.available_ip_address_count, s.availability_zone] } :
+        ->(s) { [s.subnet_id] }
+      ec2.describe_subnets.map(&:subnets).flatten.select do |subnet|
+        subnet.tags.any? { |tag| tag.value.match(name) }
+      end.map do |subnet|
+        fields.call(subnet)
+      end.tap do |list|
+        print_table list.sort
+      end
+    end
+
+    desc 'dump NAME', 'dump subnet with id or tag NAME as yaml'
+    def dump(name)
+      ec2.describe_subnets.map(&:subnets).flatten.find do |subnet|
+        subnet.subnet_id == name or subnet.tags.any? { |tag| tag.value == name }
+      end.tap do |subnet|
+        puts YAML.dump(stringify_keys(subnet.to_hash))
+      end
+    end
+
+  end
+
+end

data/lib/awful/version.rb

@@ -0,0 +1,3 @@
+module Awful
+  VERSION = "0.0.1"
+end

data/lib/awful/vpc.rb

@@ -0,0 +1,32 @@
+module Awful
+
+  class Vpc < Thor
+    include Awful
+
+    desc 'ls [PATTERN]', 'list vpcs [with any tags matching PATTERN]'
+    method_option :long, aliases: '-l', default: false, desc: 'Long listing'
+    def ls(name = /./)
+      fields = options[:long] ?
+        ->(v) { [v.tags.map{ |t| t.value }.join(','), v.vpc_id, v.state, v.cidr_block] } :
+        ->(v) { [v.vpc_id] }
+      ec2.describe_vpcs.map(&:vpcs).flatten.select do |vpc|
+        vpc.tags.any? { |tag| tag.value.match(name) }
+      end.map do |vpc|
+        fields.call(vpc)
+      end.tap do |list|
+        print_table list
+      end
+    end
+
+    desc 'dump NAME', 'dump VPC with id or tag NAME as yaml'
+    def dump(name)
+      ec2.describe_vpcs.map(&:vpcs).flatten.find do |vpc|
+        vpc.vpc_id == name or vpc.tags.any? { |tag| tag.value == name }
+      end.tap do |vpc|
+        puts YAML.dump(stringify_keys(vpc.to_hash))
+      end
+    end
+
+  end
+
+end

metadata

@@ -0,0 +1,126 @@
+--- !ruby/object:Gem::Specification
+name: awful
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Ric Lister
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-03-05 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: aws-sdk
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2'
+- !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'
+description: AWS cmdline and yaml loader.
+email:
+- rlister+gh@gmail.com
+executables:
+- asg
+- ec2
+- elb
+- lc
+- subnet
+- vpc
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- awful.gemspec
+- bin/asg
+- bin/ec2
+- bin/elb
+- bin/lc
+- bin/subnet
+- bin/vpc
+- lib/awful.rb
+- lib/awful/auto_scaling.rb
+- lib/awful/ec2.rb
+- lib/awful/elb.rb
+- lib/awful/launch_config.rb
+- lib/awful/subnet.rb
+- lib/awful/version.rb
+- lib/awful/vpc.rb
+homepage: ''
+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.2.2
+signing_key: 
+specification_version: 4
+summary: Simple AWS command-line tool.
+test_files: []