mappru 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 4f5864c5b6cc52cc629a4ae35a83f18f399ef296
+  data.tar.gz: 03d30ac958f959f74900786ac356cb2f1a3e97ab
+SHA512:
+  metadata.gz: 5ded9bd4f3118d025cb55b9dadf41b92c7fb045ca9004ef454a39444333e6f429e2dadc97460fb5be898e544291aa87a2767c0e46386012f26734f65f4286682
+  data.tar.gz: 38a59ce1b8050cfbeda278ce4092eaddefabb414fed9935a2a9cc04648947aecfdf7dad3ca462977a47a6c6e73ec7fce5304a58d5bed0248afd0cef99a0656f4

data/.gitignore

@@ -0,0 +1,12 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+test.rb
+RouteTable
+*.table

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--require spec_helper

data/.travis.yml

@@ -0,0 +1,4 @@
+language: ruby
+rvm:
+  - 2.2.4
+before_install: gem install bundler -v 1.11.2

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 winebarrel
+
+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,76 @@
+# Mappru
+
+Mappru is a tool to manage VPC Route Table.
+
+It defines the state of VPC Route Table using DSL, and updates VPC Route Table according to DSL.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'mappru'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install mappru
+
+## Usage
+
+```sh
+export AWS_ACCESS_KEY_ID='...'
+export AWS_SECRET_ACCESS_KEY='...'
+mappru -e -o RouteTable  # export VPC Route Table
+vi PolicyFile
+mappru -a --dry-run
+mappru -a                # apply `RouteTable`
+```
+
+## Help
+
+```
+Usage: mappru [options]
+    -k, --access-key ACCESS_KEY
+    -s, --secret-key SECRET_KEY
+    -r, --region REGION
+        --profile PROFILE
+        --credentials-path PATH
+    -a, --apply
+    -f, --file FILE
+        --dry-run
+    -e, --export
+    -o, --output FILE
+        --split
+        --vpc-id REGEXP
+        --rt-name REGEXP
+        --no-color
+        --debug
+```
+
+## RouteTable example
+
+```ruby
+require 'other/tablefile'
+
+vpc "vpc-12345678" do
+  route_table "foo-rt" do
+    subnets "subnet-12345678"
+    route destination_cidr_block: "0.0.0.0/0", gateway_id: "igw-12345678"
+    route destination_cidr_block: "192.168.100.101/32", network_interface_id: "eni-12345678"
+  end
+
+  route_table "bar-rt" do
+    subnets "subnet-87654321"
+    route destination_cidr_block: "192.168.100.102/32", network_interface_id: "eni-87654321"
+  end
+
+  # Undefined Route Table will be ignored
+end
+
+# Undefined VPC will be ignored
+```

data/Rakefile

@@ -0,0 +1,6 @@
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "mappru"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start

data/bin/setup

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

data/exe/mappru

@@ -0,0 +1,167 @@
+#!/usr/bin/env ruby
+$: << File.expand_path('../../lib', __FILE__)
+
+require 'mappru'
+require 'optparse'
+
+Version = Mappru::VERSION
+
+DEFAULT_FILENAME = 'RouteTable'
+
+MAGIC_COMMENT = <<-EOS
+# -*- mode: ruby -*-
+# vi: set ft=ruby :
+EOS
+
+def parse_options(argv)
+  options = {
+    file: DEFAULT_FILENAME,
+    output: '-',
+    color: true,
+    aws: {},
+  }
+
+  opt = OptionParser.new
+  opt.on('-k', '--access-key ACCESS_KEY') {|v| options[:aws][:access_key_id]     = v }
+  opt.on('-s', '--secret-key SECRET_KEY') {|v| options[:aws][:secret_access_key] = v }
+  opt.on('-r', '--region REGION')         {|v| options[:aws][:region]            = v }
+
+  opt.on('', '--profile PROFILE') do |v|
+    options[:aws][:credentials] ||= {}
+    options[:aws][:credentials][:profile_name] = v
+  end
+
+  opt.on('', '--credentials-path PATH') do |v|
+    options[:aws][:credentials] ||= {}
+    options[:aws][:credentials][:path] = v
+  end
+
+  opt.on('-a', '--apply')          {    options[:mode]    = :apply        }
+  opt.on('-f', '--file FILE')      {|v| options[:file]    = v             }
+  opt.on(''  , '--dry-run')        {    options[:dry_run] = true          }
+  opt.on('-e', '--export')         {    options[:mode]    = :export       }
+  opt.on('-o', '--output FILE')    {|v| options[:output]  = v             }
+  opt.on(''  , '--split')          {    options[:split]   = :true         }
+  opt.on(''  , '--vpc-id REGEXP')  {|v| options[:vpc_id]  = Regexp.new(v) }
+  opt.on(''  , '--rt-name REGEXP') {|v| options[:rt_name] = Regexp.new(v) }
+  opt.on(''  , '--no-color')       {    options[:color]   = false         }
+  opt.on(''  , '--debug')          {    options[:debug]   = true          }
+
+  opt.parse!(argv)
+
+  unless options[:mode]
+    puts opt.help
+    exit 1
+  end
+
+  if options[:aws][:credentials]
+    credentials = Aws::SharedCredentials.new(options[:aws][:credentials])
+    options[:aws][:credentials] = credentials
+  end
+
+  Aws.config.update(options[:aws])
+  String.colorize = options[:color]
+
+  if options[:debug]
+    Mappru::Logger.instance.set_debug(options[:debug])
+
+    Aws.config.update(
+      :http_wire_trace => true,
+      :logger => Mappru::Logger.instance
+    )
+  end
+
+  options
+rescue => e
+  $stderr.puts("[ERROR] #{e.message}")
+  exit 1
+end
+
+def main(argv)
+  options = parse_options(argv)
+  client = Mappru::Client.new(options)
+  logger = Mappru::Logger.instance
+
+  case options[:mode]
+  when :export
+    exported = client.export
+    output = options[:output]
+
+    if options[:split]
+      logger.info('Export Route Table')
+
+      output = DEFAULT_FILENAME if output == '-'
+      dir = File.dirname(output)
+      FileUtils.mkdir_p(dir)
+      requires = []
+
+      exported.each do |vpc_id, rts|
+        vpc_dir = File.join(dir, vpc_id)
+        FileUtils.mkdir_p(vpc_id)
+
+        rts.each do |rt_name, attrs|
+          filename = "#{rt_name}.table"
+          requires << File.join(vpc_id, filename)
+          rt_file = File.join(vpc_dir, filename)
+
+          logger.info("  write `#{rt_file}`")
+
+          dsl = Mappru::DSL.convert({vpc_id => {rt_name => attrs}}, options)
+
+          open(rt_file, 'wb') do |f|
+            f.puts MAGIC_COMMENT
+            f.puts dsl
+          end
+        end
+      end
+
+      logger.info("  write `#{output}`")
+
+      open(output, 'wb') do |f|
+        f.puts MAGIC_COMMENT
+
+        requires.each do |rt_file|
+          f.puts "require '#{rt_file}'"
+        end
+      end
+    else
+      dsl = Mappru::DSL.convert(exported, options)
+
+      if output == '-'
+        logger.info('# Export Route Table')
+        puts dsl
+      else
+        logger.info("Export Route Table to `#{output}`")
+        open(output, 'wb') do |f|
+          f.puts MAGIC_COMMENT
+          f.puts dsl
+        end
+      end
+    end
+  when :apply
+    file = options[:file]
+
+    unless File.exist?(file)
+      raise "No RouteTable found (looking for: #{file})"
+    end
+
+    message = "Apply `#{file}` to Route Table"
+    message << ' (dry-run)' if options[:dry_run]
+    logger.info(message)
+
+    updated = client.apply(file)
+
+    logger.info('No change'.intense_blue) unless updated
+  else
+    raise "Unknown mode: #{options[:mode]}"
+  end
+rescue => e
+  if options[:debug]
+    raise e
+  else
+    $stderr.puts("[ERROR] #{e.message}".red)
+    exit 1
+  end
+end
+
+main(ARGV)

data/lib/mappru/client.rb

@@ -0,0 +1,163 @@
+class Mappru::Client
+  include Mappru::Logger::Helper
+  include Mappru::Utils::Helper
+
+  def initialize(options = {})
+    @options = options
+    @client = @options[:client] || Aws::EC2::Client.new
+    @resource = Aws::EC2::Resource.new(client: @client)
+    @driver = Mappru::Driver.new(@client, @options)
+  end
+
+  def export
+    Mappru::Exporter.export(@client, @options)
+  end
+
+  def apply(file)
+    walk(file)
+  end
+
+  private
+
+  def walk(file)
+    expected = load_file(file)
+    actual = Mappru::Exporter.export(@client, @options)
+
+    updated = walk_vpcs(expected, actual)
+
+    if @options[:dry_run]
+      false
+    else
+      updated
+    end
+  end
+
+  def walk_vpcs(expected, actual)
+    updated = false
+
+    expected.each do |vpc_id, expected_rts|
+      next unless matched?(vpc_id, @options[:vpc_id])
+
+      actual_rts = actual.delete(vpc_id)
+
+      if actual_rts
+        updated = walk_vpc(vpc_id, expected_rts, actual_rts) || updated
+      else
+        log(:warn, "No such VPC: #{vpc_id}")
+      end
+    end
+
+    # Undefined VPC will be ignored
+
+    updated
+  end
+
+  def walk_vpc(vpc_id, expected, actual)
+    updated = false
+
+    expected.each do |rt_name, expected_rt|
+      next unless matched?(rt_name, @options[:rt_name])
+
+      actual_rt = actual.delete(rt_name)
+
+      unless actual_rt
+        actual_rt = @driver.create_route_table(vpc_id, rt_name, expected_rt)
+        updated = true
+      end
+
+      updated = walk_route_table(vpc_id, rt_name, expected_rt, actual_rt) || updated
+    end
+
+    # Undefined Route Table will be ignored
+
+    updated
+  end
+
+  def walk_route_table(vpc_id, name, expected, actual)
+    updated = false
+    updated = walk_subnets(vpc_id, name, expected[:subnets], actual[:subnets]) || updated
+    updated = walk_routes(vpc_id, name, expected[:routes], actual[:routes]) || updated
+    updated
+  end
+
+  def walk_subnets(vpc_id, name, expected, actual)
+    updated = false
+    assoc_subnets = expected - actual
+    disassoc_subnets = actual - expected
+
+    unless assoc_subnets.empty?
+      @driver.associate_subnets(vpc_id, name, assoc_subnets)
+      updated = true
+    end
+
+    unless disassoc_subnets.empty?
+      @driver.disassociate_subnets(vpc_id, name, disassoc_subnets)
+      updated = true
+    end
+
+    updated
+  end
+
+  def walk_routes(vpc_id, rt_name, expected, actual)
+    expected = routes_to_hash(expected)
+    actual = routes_to_hash(actual)
+    updated = false
+
+    expected.each do |dest_cidr, expected_route|
+      if expected_route[:gateway_id] == 'local'
+        log(:warn, %!Cannot configure "local" target: #{vpc_id}: #{rt_name}!, color: :yellow)
+        next
+      end
+
+      actual_route = actual.delete(dest_cidr)
+
+      if actual_route
+        updated = walk_route(vpc_id, rt_name, dest_cidr, expected_route, actual_route) || updated
+      else
+        @driver.create_route(vpc_id, rt_name, dest_cidr, expected_route)
+        updated = true
+      end
+    end
+
+    actual.each do |dest_cidr, actual_route|
+      @driver.delete_route(vpc_id, rt_name, dest_cidr)
+      updated = true
+    end
+  end
+
+  def walk_route(vpc_id, rt_name, dest_cidr, expected, actual)
+    expected = expected.without_nil.sort_pair
+    actual = actual.without_nil.sort_pair
+    updated = false
+
+    if expected != actual
+      @driver.update_route(vpc_id, rt_name, dest_cidr, expected, actual)
+      updated = true
+    end
+
+    updated
+  end
+
+  def load_file(file)
+    if file.kind_of?(String)
+      open(file) do |f|
+        Mappru::DSL.parse(f.read, file)
+      end
+    elsif file.respond_to?(:read)
+      Mappru::DSL.parse(file.read, file.path)
+    else
+      raise TypeError, "can't convert #{file} into File"
+    end
+  end
+
+  def routes_to_hash(routes)
+    hash = {}
+
+    routes.map(&:dup).each do |r|
+      dest_cidr = r.delete(:destination_cidr_block)
+      hash[dest_cidr] = r
+    end
+
+    hash
+  end
+end

data/lib/mappru/driver.rb

@@ -0,0 +1,115 @@
+class Mappru::Driver
+  include Mappru::Logger::Helper
+  include Mappru::Utils::Helper
+
+  def initialize(client, options = {})
+    @client = client
+    @resource = Aws::EC2::Resource.new(client: @client)
+    @options = options
+  end
+
+  def create_route_table(vpc_id, name, attrs)
+    log(:info, "Create Route Table `#{vpc_id}` > `#{name}`", color: :cyan)
+
+    unless @options[:dry_run]
+      vpc = @resource.vpc(vpc_id)
+      rt = vpc.create_route_table
+      name_tag = {key: 'Name', value: name}
+      rt.create_tags(tags: [name_tag])
+      rt_id_by_vpc_rt_name[vpc_id][name] = rt.id
+    end
+
+    {routes: [], subnets: []}
+  end
+
+  def associate_subnets(vpc_id, rt_name, subnet_ids)
+    log(:info, "Associate Subnets `#{vpc_id}` > `#{rt_name}`: #{subnet_ids.join(', ')}", color: :green)
+
+    unless @options[:dry_run]
+      subnet_ids.each do |sbnt_id|
+        rt_id = rt_id_by_vpc_rt_name.fetch(vpc_id).fetch(rt_name)
+        params = {route_table_id: rt_id, subnet_id: sbnt_id}
+        @client.associate_route_table(params)
+      end
+    end
+  end
+
+  def disassociate_subnets(vpc_id, rt_name, subnet_ids)
+    log(:info, "Disassociate Subnets `#{vpc_id}` > `#{rt_name}`: #{subnet_ids.join(', ')}", color: :red)
+
+    unless @options[:dry_run]
+      subnet_ids.each do |sbnt_id|
+        assoc_id = assoc_id_by_subnet.fetch(sbnt_id)
+        params = {association_id: assoc_id}
+        @client.disassociate_route_table(params)
+      end
+    end
+  end
+
+  def create_route(vpc_id, rt_name, dest_cidr, attrs)
+    log(:info, "Create Route `#{vpc_id}` > `#{rt_name}` > `#{dest_cidr}`", color: :cyan)
+
+    unless @options[:dry_run]
+      rt_id = rt_id_by_vpc_rt_name.fetch(vpc_id).fetch(rt_name)
+      params = attrs.merge(route_table_id: rt_id, destination_cidr_block: dest_cidr)
+      @client.create_route(params)
+    end
+  end
+
+  def delete_route(vpc_id, rt_name, dest_cidr)
+    log(:info, "Delete Route `#{vpc_id}` > `#{rt_name}` > `#{dest_cidr}`", color: :red)
+
+    unless @options[:dry_run]
+      rt_id = rt_id_by_vpc_rt_name.fetch(vpc_id).fetch(rt_name)
+      params = {route_table_id: rt_id, destination_cidr_block: dest_cidr}
+      @client.delete_route(params)
+    end
+  end
+
+  def update_route(vpc_id, rt_name, dest_cidr, route, old_route)
+    log(:info, "Update Route `#{vpc_id}` > `#{rt_name}` > `#{dest_cidr}`", color: :green)
+    log(:info, diff(old_route, route, color: @options[:color]), color: false)
+
+
+    unless @options[:dry_run]
+      rt_id = rt_id_by_vpc_rt_name.fetch(vpc_id).fetch(rt_name)
+      params = route.merge(route_table_id: rt_id, destination_cidr_block: dest_cidr)
+      @client.replace_route(params)
+    end
+  end
+
+  def rt_id_by_vpc_rt_name
+    return @rt_ids if @rt_ids
+
+    @rt_ids = {}
+    route_tables = @resource.route_tables
+
+    route_tables.each do |rt|
+      vpc_id = rt.vpc_id
+      name_tag = rt.tags.find {|i| i.key == 'Name' } || {}
+      name = name_tag[:value]
+
+      next unless name
+
+      @rt_ids[vpc_id] ||= {}
+      @rt_ids[vpc_id][name] = rt.id
+    end
+
+    @rt_ids
+  end
+
+  def assoc_id_by_subnet
+    return @assoc_ids if @assoc_ids
+
+    @assoc_ids = {}
+    associations = @resource.route_tables.map(&:associations).flat_map(&:to_a)
+
+    associations.each do |assoc|
+      if assoc.subnet_id
+        @assoc_ids[assoc.subnet_id] = assoc.id
+      end
+    end
+
+    @assoc_ids
+  end
+end

data/lib/mappru/dsl/context/vpc/route_table.rb

@@ -0,0 +1,31 @@
+class Mappru::DSL::Context::VPC::RouteTable
+  include Mappru::DSL::TemplateHelper
+
+  def initialize(context, vpc_id, name, &block)
+    @vpc_id = vpc_id
+    @name = name
+    @context = context.merge(vpc_id: vpc_id, name: name)
+    @result = {subnets: [], routes: []}
+    instance_eval(&block)
+  end
+
+  attr_reader :result
+
+  private
+
+  def subnets(*subnet_ids)
+    if subnet_ids.empty?
+      raise "VPC `#{@vpc_id}` > Route Table `#{@name}`: Subnet Id is empty"
+    end
+
+    @result[:subnets].concat(subnet_ids.map(&:to_s))
+  end
+
+  def route(attributes)
+    unless attributes.is_a?(Hash)
+      raise "VPC `#{@vpc_id}` > Route Table `#{@name}`: Invalid route #{attributes.inspect}:#{attributes.class}"
+    end
+
+    @result[:routes] << attributes
+  end
+end

data/lib/mappru/dsl/context/vpc.rb

@@ -0,0 +1,24 @@
+class Mappru::DSL::Context::VPC
+  include Mappru::DSL::TemplateHelper
+
+  def initialize(context, vpc_id, &block)
+    @vpc_id = vpc_id
+    @context = context.merge(vpc_id: vpc_id)
+    @result = {}
+    instance_eval(&block)
+  end
+
+  attr_reader :result
+
+  private
+
+  def route_table(name, &block)
+    name = name.to_s
+
+    if @result[name]
+      raise "Route Table `#{name}` is already defined"
+    end
+
+    @result[name] = Mappru::DSL::Context::VPC::RouteTable.new(@context, @vpc_id, name, &block).result
+  end
+end

data/lib/mappru/dsl/context.rb

@@ -0,0 +1,49 @@
+class Mappru::DSL::Context
+  include Mappru::DSL::TemplateHelper
+
+  def self.eval(dsl, path, options = {})
+    self.new(path, options) {
+      eval(dsl, binding, path)
+    }
+  end
+
+  attr_reader :result
+
+  def initialize(path, options = {}, &block)
+    @path = path
+    @options = options
+    @result = {}
+
+    @context = Hashie::Mash.new(
+      :path => path,
+      :options => options,
+      :templates => {}
+    )
+
+    instance_eval(&block)
+  end
+
+  def template(name, &block)
+    @context.templates[name.to_s] = block
+  end
+
+  private
+
+  def require(file)
+    rt = (file =~ %r|\A/|) ? file : File.expand_path(File.join(File.dirname(@path), file))
+
+    if File.exist?(rt)
+      instance_eval(File.read(rt), rt)
+    elsif File.exist?(rt + '.rb')
+      instance_eval(File.read(rt + '.rb'), rt + '.rb')
+    else
+      Kernel.require(file)
+    end
+  end
+
+  def vpc(vpc_id, &block)
+    vpc_id = vpc_id.to_s
+    @result[vpc_id] ||= {}
+    @result[vpc_id].update(Mappru::DSL::Context::VPC.new(@context, vpc_id, &block).result)
+  end
+end

data/lib/mappru/dsl/converter.rb

@@ -0,0 +1,83 @@
+class Mappru::DSL::Converter
+  include Mappru::Utils::Helper
+
+  def self.convert(exported, options = {})
+    self.new(exported, options).convert
+  end
+
+  def initialize(exported, options = {})
+    @exported = exported
+    @options = options
+  end
+
+  def convert
+    output_vpcs(@exported)
+  end
+
+  private
+
+  def output_vpcs(rts_by_vpc)
+    vpcs = []
+
+    rts_by_vpc.sort_by(&:first).each do |vpc_id, rt_by_name|
+      next unless matched?(vpc_id, @options[:vpc_id])
+
+      vpcs << output_vpc(vpc_id, rt_by_name)
+    end
+
+    vpcs.join("\n")
+  end
+
+  def output_vpc(vpc_id, rt_by_name)
+    route_tables = output_route_tables(rt_by_name).strip
+
+    <<-EOS
+vpc #{vpc_id.inspect} do
+  #{route_tables}
+end
+    EOS
+  end
+
+  def output_route_tables(rt_by_name)
+    route_tables = []
+
+    rt_by_name.each do |name, rt|
+      route_tables << output_route_table(name, rt)
+    end
+
+    route_tables.join("\n")
+  end
+
+  def output_route_table(name, rt)
+    subnets = output_subnets(rt[:subnets]).strip
+    routes = output_routes(rt[:routes]).strip
+
+    <<-EOS
+  route_table #{name.inspect} do
+    #{subnets}
+    #{routes}
+  end
+    EOS
+  end
+
+  def output_subnets(subnets)
+    if subnets.empty?
+      '#subnets ...'
+    else
+      args = subnets.map(&:inspect).join(', ')
+      "subnets #{args}"
+    end
+  end
+
+  def output_routes(routes)
+    if routes.empty?
+      '#routes destination_cidr_block: ...'
+    else
+      routes.map {|r|
+        <<-EOS
+    route #{r.without_nil.modern_inspect_without_brace}
+        EOS
+      }.join
+    end
+  end
+end

data/lib/mappru/dsl/template_helper.rb

@@ -0,0 +1,18 @@
+module Mappru::DSL::TemplateHelper
+  def include_template(template_name, context = {})
+    tmplt = @context.templates[template_name.to_s]
+
+    unless tmplt
+      raise "Template `#{template_name}` is not defined"
+    end
+
+    context_orig = @context
+    @context = @context.merge(context)
+    instance_eval(&tmplt)
+    @context = context_orig
+  end
+
+  def context
+    @context
+  end
+end

data/lib/mappru/dsl.rb

@@ -0,0 +1,11 @@
+class Mappru::DSL
+  class << self
+    def convert(exported, options = {})
+      Mappru::DSL::Converter.convert(exported, options)
+    end
+
+    def parse(dsl, path, options = {})
+      Mappru::DSL::Context.eval(dsl, path, options).result
+    end
+  end # of class methods
+end

data/lib/mappru/exporter.rb

@@ -0,0 +1,83 @@
+class Mappru::Exporter
+  include Mappru::Logger::Helper
+  include Mappru::Utils::Helper
+
+  def self.export(client, options = {})
+    self.new(client, options).export
+  end
+
+  def initialize(client, options = {})
+    @client = client
+    @resource = Aws::EC2::Resource.new(client: @client)
+    @options = options
+  end
+
+  def export
+    result = {}
+    @resource
+
+    route_tables = @resource.route_tables
+
+    route_tables.each do |rt|
+      vpc_id = rt.vpc_id
+      name_tag = rt.tags.find {|i| i.key == 'Name' } || {}
+      name = name_tag[:value]
+
+      next unless matched?(vpc_id, @options[:vpc_id])
+
+      unless name
+        log(:warn, "No name Route Table can not manage: #{vpc_id}", color: :yellow)
+        next
+      end
+
+      next unless matched?(name, @options[:rt_name])
+
+      result[vpc_id] ||= {}
+
+      if result[vpc_id][name]
+        raise "Duplication Subnet found: #{vpc_id}: #{name}"
+      end
+
+      result[vpc_id][name] = export_route_table(rt)
+    end
+
+    result
+  end
+
+  private
+
+  def export_route_table(rt)
+    result = {
+      route_table_id: rt.id,
+      routes: [],
+      subnets: export_subnets(rt.associations),
+    }
+
+    # route -> (Array<Route>, nil)
+    # http://docs.aws.amazon.com/sdkforruby/api/Aws/EC2/RouteTable.html#routes-instance_method
+    rt.routes.reject(&:nil?).each {|route|
+      # Skip "local"
+      next if route.gateway_id == 'local'
+
+      hash = {}
+
+      [
+        :destination_cidr_block,
+        # TODO: Support Endpoint
+        #:destination_prefix_list_id,
+        :gateway_id,
+        :network_interface_id,
+        :vpc_peering_connection_id,
+        :nat_gateway_id,
+      ].each {|k| hash[k] = route.send(k) }
+
+      result[:routes] << hash
+    }
+
+    result
+  end
+
+  def export_subnets(associations)
+    associations.map(&:subnet_id).reject(&:nil?)
+  end
+end

data/lib/mappru/ext/hash_ext.rb

@@ -0,0 +1,29 @@
+module Mappru::Ext
+  module HashExt
+    def sort_pair
+      new_hash = {}
+
+      self.sort_by(&:to_s).each do |k, v|
+        new_hash[k] = v
+      end
+
+      new_hash
+    end
+
+    def sort_pair!
+      self.replace(self.sort_pair)
+    end
+
+    def without_nil
+      new_hash = {}
+
+      self.each do |k, v|
+        new_hash[k] = v if v
+      end
+
+      new_hash
+    end
+  end
+end
+
+Hash.include(Mappru::Ext::HashExt)

data/lib/mappru/ext/string_ext.rb

@@ -0,0 +1,28 @@
+module Mappru::Ext
+  module StringExt
+    module ClassMethods
+      def colorize=(value)
+        @colorize = value
+      end
+
+      def colorize
+        @colorize
+      end
+    end # ClassMethods
+
+    Term::ANSIColor::Attribute.named_attributes.each do |attribute|
+      class_eval(<<-EOS, __FILE__, __LINE__ + 1)
+        def #{attribute.name}
+          if String.colorize
+            Term::ANSIColor.send(#{attribute.name.inspect}, self)
+          else
+            self
+          end
+        end
+      EOS
+    end
+  end
+end
+
+String.include(Mappru::Ext::StringExt)
+String.extend(Mappru::Ext::StringExt::ClassMethods)

data/lib/mappru/logger.rb

@@ -0,0 +1,28 @@
+class Mappru::Logger < ::Logger
+  include Singleton
+
+  def initialize
+    super($stdout)
+
+    self.formatter = proc do |severity, datetime, progname, msg|
+      "#{msg}\n"
+    end
+
+    self.level = Logger::INFO
+  end
+
+  def set_debug(value)
+    self.level = value ? Logger::DEBUG : Logger::INFO
+  end
+
+  module Helper
+    def log(level, message, log_options = {})
+      global_option = @options || {}
+      message = "[#{level.to_s.upcase}] #{message}" unless level == :info
+      message << ' (dry-run)' if global_option[:dry_run]
+      message = message.send(log_options[:color]) if log_options[:color]
+      logger = global_option[:logger] || Mappru::Logger.instance
+      logger.send(level, message)
+    end
+  end
+end

data/lib/mappru/utils.rb

@@ -0,0 +1,23 @@
+class Mappru::Utils
+  module Helper
+    def matched?(name, regex)
+      if regex
+        regex =~ name
+      else
+        true
+      end
+    end
+
+    def diff(obj1, obj2, options = {})
+      diffy = Diffy::Diff.new(
+        obj1.pretty_inspect,
+        obj2.pretty_inspect,
+        :diff => '-u'
+      )
+
+      out = diffy.to_s(options[:color] ? :color : :text).gsub(/\s+\z/m, '')
+      out.gsub!(/^/, options[:indent]) if options[:indent]
+      out
+    end
+  end
+end

data/lib/mappru/version.rb

@@ -0,0 +1,3 @@
+module Mappru
+  VERSION = '0.1.0'
+end

data/lib/mappru.rb

@@ -0,0 +1,24 @@
+require 'aws-sdk'
+require 'diffy'
+require 'hash_modern_inspect'
+require 'hashie'
+require 'logger'
+require 'pp'
+require 'singleton'
+require 'term/ansicolor'
+
+require 'mappru/version'
+require 'mappru/ext/hash_ext'
+require 'mappru/ext/string_ext'
+require 'mappru/logger'
+require 'mappru/utils'
+
+require 'mappru/client'
+require 'mappru/driver'
+require 'mappru/dsl'
+require 'mappru/dsl/template_helper'
+require 'mappru/dsl/context'
+require 'mappru/dsl/context/vpc'
+require 'mappru/dsl/context/vpc/route_table'
+require 'mappru/dsl/converter'
+require 'mappru/exporter'

data/mappru.gemspec

@@ -0,0 +1,32 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'mappru/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'mappru'
+  spec.version       = Mappru::VERSION
+  spec.authors       = ['winebarrel']
+  spec.email         = ['sgwr_dts@yahoo.co.jp']
+
+  spec.summary       = %q{Mappru is a tool to manage VPC Route Table.}
+  spec.description   = %q{Mappru is a tool to manage VPC Route Table.}
+  spec.homepage      = 'https://github.com/winebarrel/mappru'
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = 'exe'
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+
+  spec.add_dependency 'aws-sdk', '~> 2.3.0'
+  spec.add_dependency 'diffy'
+  spec.add_dependency 'hash_modern_inspect'
+  spec.add_dependency 'hashie'
+  spec.add_dependency 'parallel'
+  spec.add_dependency 'term-ansicolor'
+
+  spec.add_development_dependency 'bundler'
+  spec.add_development_dependency 'rake'
+  spec.add_development_dependency 'rspec', '~> 3.0'
+end

metadata

@@ -0,0 +1,197 @@
+--- !ruby/object:Gem::Specification
+name: mappru
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- winebarrel
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2016-05-05 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: aws-sdk
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.3.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.3.0
+- !ruby/object:Gem::Dependency
+  name: diffy
+  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: hash_modern_inspect
+  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: 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: term-ansicolor
+  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: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+description: Mappru is a tool to manage VPC Route Table.
+email:
+- sgwr_dts@yahoo.co.jp
+executables:
+- mappru
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- exe/mappru
+- lib/mappru.rb
+- lib/mappru/client.rb
+- lib/mappru/driver.rb
+- lib/mappru/dsl.rb
+- lib/mappru/dsl/context.rb
+- lib/mappru/dsl/context/vpc.rb
+- lib/mappru/dsl/context/vpc/route_table.rb
+- lib/mappru/dsl/converter.rb
+- lib/mappru/dsl/template_helper.rb
+- lib/mappru/exporter.rb
+- lib/mappru/ext/hash_ext.rb
+- lib/mappru/ext/string_ext.rb
+- lib/mappru/logger.rb
+- lib/mappru/utils.rb
+- lib/mappru/version.rb
+- mappru.gemspec
+homepage: https://github.com/winebarrel/mappru
+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.5.1
+signing_key: 
+specification_version: 4
+summary: Mappru is a tool to manage VPC Route Table.
+test_files: []