roadworker 0.0.1

data/README.md

@@ -0,0 +1,69 @@
+# Roadworker
+
+Roadworker is a tool to manage Route53.
+
+It defines the state of Route53 using DSL, and updates Route53 according to DSL.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'roadworker'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install roadworker
+
+## Usage
+
+```
+shell> export AWS_ACCESS_KEY_ID='...'
+shell> export AWS_SECRET_ACCESS_KEY='...'
+shell> roadwork -e -o Routefile
+shell> vi Routefile
+shell> roadwork --dry-run
+shell> roudwork
+```
+
+## Routefile esample
+
+```ruby
+require 'other/routefile'
+
+hosted_zone "winebarrel.jp." do
+  rrset "winebarrel.jp.", "MX" do
+    ttl 300
+    resource_records(
+      "10 mx.winebarrel.jp",
+      "10 mx2.winebarrel.jp"
+    )
+  end
+
+  rrset "winebarrel.jp.", "NS" do
+    ttl 86400
+    resource_records(
+      "ns-XXX.awsdns-XX.com.",
+      "ns-XXX.awsdns-XX.org.",
+      "ns-XXX.awsdns-XX.net.",
+      "ns-XXX.awsdns-XX.co.uk."
+    )
+  end
+
+  rrset "winebarrel.jp.", "SOA" do
+    ttl 86400
+    resource_records(
+      "ns-XXX.awsdns-XX.com. awsdns-hostmaster.amazon.com. 1 7200 900 1209600 86400"
+    )
+  end
+end
+
+hosted_zone "info.winebarrel.jp." do
+  rrset "xxx.info.winebarrel.jp.", "A" do
+    dns_name "elb-dns-name.elb.amazonaws.com"
+  end
+end
+```

data/bin/roadwork

@@ -0,0 +1,89 @@
+#!/usr/bin/env ruby
+$: << File.expand_path("#{File.dirname __FILE__}/../lib")
+require 'rubygems'
+require 'roadworker'
+require 'optparse'
+require 'logger'
+
+file = 'Routefile'
+output_file = '-'
+export_mode = false
+logger = Logger.new($stdout)
+
+logger.formatter = proc {|severity, datetime, progname, msg|
+  "#{msg}\n"
+}
+options = {
+  :logger  => logger,
+  :dry_run => false,
+  :debug   => false,
+  :force   => false,
+  :color   => true,
+}
+
+ARGV.options do |opt|
+  access_key = nil
+  secret_key = nil
+
+  opt.on('-k', '--access-key ACCESS_KEY') {|v| access_key        = v     }
+  opt.on('-s', '--secret-key SECRET_KEY') {|v| secret_key        = v     }
+  opt.on('-f', '--file FILE')             {|v| file              = v     }
+  opt.on('-e', '--export')                {|v| export_mode       = true  }
+  opt.on('-o', '--output FILE')           {|v| output_file       = v     }
+  opt.on('',   '--dry-run')               {|v| options[:dry_run] = true  }
+  opt.on(''  , '--force')                 {    options[:force]   = true  }
+  opt.on(''  , '--no-color')              {    options[:color]   = false }
+  opt.on(''  , '--debug')                 {    options[:debug]   = true  }
+  opt.parse!
+
+  if access_key and secret_key
+    AWS.config({
+      :access_key_id     => access_key,
+      :secret_access_key => secret_key,
+    })
+  elsif (access_key and !secret_key) or (!access_key and secret_key)
+    puts opt.help
+    exit 1
+  end
+end
+
+if options[:debug]
+  AWS.config(
+    :http_wire_trace => true,
+    :logger => options[:logger]
+  )
+end
+
+begin
+  client = Roadworker::Client.new(options)
+
+  if export_mode
+    exported = client.export
+
+    if output_file == '-'
+      logger.info('Export Route53')
+      puts client.export
+    else
+      logger.info("Export Route53 to `#{output_file}`")
+      open(output_file, 'wb') {|f| f.puts client.export }
+    end
+  else
+    unless File.exist?(file)
+      raise "No Routefile found (looking for: #{file})"
+    end
+
+    msg = "Apply `#{file}` to Route53"
+    msg << ' (dry-run)' if options[:dry_run]
+    logger.info(msg)
+
+    updated = client.apply(file)
+
+    logger.info('There is no update') unless updated
+  end
+rescue => e
+  if options[:debug]
+    raise e
+  else
+    $stderr.puts e
+  end
+end

data/lib/roadworker.rb

@@ -0,0 +1,2 @@
+require 'roadworker/version'
+require 'roadworker/client'

data/lib/roadworker/client.rb

@@ -0,0 +1,109 @@
+require 'roadworker/string-ext'
+require 'roadworker/dsl'
+require 'roadworker/log'
+require 'roadworker/route53-wrapper'
+
+require 'logger'
+require 'ostruct'
+
+module Roadworker
+  class Client
+    include Roadworker::Log
+
+    def initialize(options)
+      @options = OpenStruct.new(options)
+      @options.logger ||= Logger.new($stdout)
+      String.colorize = @options.color
+      @options.route53 = AWS::Route53.new
+      @route53 = Route53Wrapper.new(@options)
+    end
+
+    def apply(file)
+      dsl = nil
+
+      if file.kind_of?(String)
+        open(file) do |f|
+          dsl = DSL.define(f.read, file).result
+        end
+      else
+        dsl = DSL.define(file.read, file.path).result
+      end
+
+      updated = false
+
+      if dsl.hosted_zones.empty? and not @options.force
+        log(:warn, "Nothing is defined (pass `--force` if you want to remove)", :yellow)
+      else
+        AWS.memoize {
+          walk_hosted_zones(dsl)
+          updated = @options.updated
+        }
+      end
+
+      return updated
+    end
+
+    def export
+      exported = AWS.memoize { @route53.export }
+      DSL.convert(exported)
+    end
+
+    private
+
+    def walk_hosted_zones(dsl)
+      expected = collection_to_hash(dsl.hosted_zones, :name)
+      actual   = collection_to_hash(@route53.hosted_zones, :name)
+
+      expected.each do |keys, expected_zone|
+        name = keys[0]
+        actual_zone = actual.delete(keys) || @route53.hosted_zones.create(name)
+        walk_rrsets(expected_zone, actual_zone)
+      end
+
+      actual.each do |keys, zone|
+        zone.rrsets.each do |record|
+          record.delete(:cascaded => true)
+        end
+
+        zone.delete
+      end
+    end
+
+    def walk_rrsets(expected_zone, actual_zone)
+      expected = collection_to_hash(expected_zone.rrsets, :name, :type, :set_identifier)
+      actual   = collection_to_hash(actual_zone.rrsets, :name, :type, :set_identifier)
+
+      expected.each do |keys, expected_record|
+        name = keys[0]
+        type = keys[1]
+        set_identifier = keys[2]
+
+        actual_record = actual.delete(keys)
+
+        if actual_record
+          unless actual_record.eql?(expected_record)
+            actual_record.update(expected_record)
+          end
+        else
+          actual_record = actual_zone.rrsets.create(name, type, expected_record)
+        end
+      end
+
+      actual.each do |keys, record|
+        record.delete
+      end
+    end
+
+    def collection_to_hash(collection, *keys)
+      hash = {}
+
+      collection.each do |item|
+        key_list = keys.map {|k| item.send(k) }
+        hash[key_list] = item
+      end
+
+      return hash
+    end
+
+  end # Client
+end # Roadworker

data/lib/roadworker/collection.rb

@@ -0,0 +1,21 @@
+module Roadworker
+  class Collection
+
+    class << self
+      def batch(collection)
+        if collection.respond_to?(:each_batch)
+          collection.each_batch do |batch|
+            batch.each do |item|
+              yield(item)
+            end
+          end
+        else
+          collection.each do |item|
+            yield(item)
+          end
+        end
+      end
+    end # of class method
+
+  end # Collection
+end # Roadworker

data/lib/roadworker/dsl-converter.rb

@@ -0,0 +1,50 @@
+module Roadworker
+  class DSL
+    class Converter
+
+      class << self
+        def convert(hosted_zones)
+          hosted_zones.map {|i| output_zone(i) }.join("\n")
+        end
+
+        private
+
+        def output_rrset(recrod)
+          name = recrod.delete(:name).inspect
+          type = recrod.delete(:type).inspect
+
+          attrs = recrod.map {|key, value|
+            if value.kind_of?(Array)
+              if value.empty?
+                nil
+              else
+                value = value.map {|i| i.inspect }.join(",\n      ")
+                "#{key}(\n      #{value}\n    )"
+              end
+            else
+              "#{key} #{value.inspect}"
+            end
+          }.select {|i| i }.join("\n    ")
+
+          return(<<-EOS)
+  rrset #{name}, #{type} do
+    #{attrs}
+  end
+          EOS
+        end
+
+        def output_zone(zone)
+          name = zone[:name].inspect
+          rrsets = zone[:rrsets]
+
+          return(<<-EOS)
+hosted_zone #{name} do
+#{rrsets.map {|i| output_rrset(i) }.join("\n").chomp}
+end
+          EOS
+        end
+      end # of class method
+
+    end # Converter
+  end # DSL
+end # Roadworker

data/lib/roadworker/dsl.rb

@@ -0,0 +1,119 @@
+require 'roadworker/dsl-converter'
+
+require 'ostruct'
+
+module Roadworker
+  class DSL
+
+    class << self
+      def define(source, path)
+        self.new(path) do
+          eval(source, binding)
+        end
+      end
+
+      def convert(hosted_zones)
+        Converter.convert(hosted_zones)
+      end
+    end # of class method
+
+    attr_reader :result
+
+    def initialize(path, &block)
+      @path = path
+      @result = OpenStruct.new({:hosted_zones => []})
+      instance_eval(&block)
+    end
+
+    private
+
+    def require(file)
+      routefile = File.expand_path(File.join(File.dirname(@path), file))
+
+      if File.exist?(routefile)
+        instance_eval(File.read(routefile))
+      else
+        Kernel.require(file)
+      end
+    end
+
+    def hosted_zone(name, &block)
+      @result.hosted_zones << HostedZone.new(name, &block).result
+    end
+
+    class HostedZone
+      attr_reader :result
+
+      def initialize(name, &block)
+        @name = name
+        rrsets = []
+
+        @result = OpenStruct.new({
+          :name => name,
+          :resource_record_sets => rrsets,
+          :rrsets => rrsets,
+        })
+
+        instance_eval(&block)
+      end
+
+      private
+
+      def resource_record_set(rrset_name, type, &block)
+        if rrset_name.gsub(/\.\Z/, '') !~ /#{Regexp.escape(@name.gsub(/\.\Z/, ''))}\Z/i
+          raise "Invalid ResourceRecordSet Name: #{rrset_name}"
+        end
+
+        @result.resource_record_sets << ResourceRecordSet.new(rrset_name, type, &block).result
+      end
+      alias rrset resource_record_set
+
+      class ResourceRecordSet
+        attr_reader :result
+
+        def initialize(name, type, &block)
+          @result = OpenStruct.new({
+            :name => name,
+            :type => type,
+          })
+
+          instance_eval(&block)
+        end
+
+        private
+
+        def set_identifier(value = nil)
+          @result.set_identifier = value
+        end
+        alias identifier set_identifier
+
+        def weight(value)
+          @result.weight = value
+        end
+
+        def ttl(value)
+          @result.ttl = value
+        end
+
+        def region(value)
+          @result.region = value
+        end
+
+        def dns_name(value)
+          @result.dns_name = value
+        end
+
+        def resource_records(*values)
+          if values.uniq.length != values.length
+            raise "Duplicate ResourceRecords: #{values.join(', ')}"
+          end
+
+          @result.resource_records = [values].flatten.map {|i| {:value => i} }
+        end
+
+      end # ResourceRecordSet
+
+    end # HostedZone
+
+  end # DSL
+end # RoadWorker

data/lib/roadworker/log.rb

@@ -0,0 +1,12 @@
+module Roadworker
+  module Log
+
+    def log(level, message, color, log_id = nil)
+      log_id = yield if block_given?
+      message = "#{message}: #{log_id}"
+      message << ' (dry-run)' if @options.dry_run
+      @options.logger.send(level, message.send(color))
+    end
+
+  end # Log
+end # Roadworker

data/lib/roadworker/route53-exporter.rb

@@ -0,0 +1,69 @@
+require 'roadworker/collection'
+
+require 'ostruct'
+
+module Roadworker
+  class Exporter
+
+    class << self
+      def export(route53)
+        self.new(route53).export
+      end
+    end # of class method
+
+    def initialize(route53)
+      @route53 = route53
+    end
+
+    def export
+      result = []
+
+      Collection.batch(@route53.hosted_zones) do |zone|
+        zone_h = item_to_hash(zone, :name)
+        result << zone_h
+
+        rrsets = []
+        zone_h[:rrsets] = rrsets
+
+        Collection.batch(zone.rrsets) do |record|
+          attrs = [
+            :name,
+            :type,
+            :set_identifier,
+            :weight,
+            :ttl,
+            :resource_records,
+            :alias_target,
+            :region,
+          ]
+
+          record_h = item_to_hash(record, *attrs)
+          rrsets << record_h
+
+          rrs = record_h.delete(:resource_records)
+          record_h[:resource_records] = rrs.map {|i| i[:value] }
+
+          if (alias_target = record_h.delete(:alias_target))
+            record_h[:dns_name] = alias_target[:dns_name]
+          end
+        end
+      end
+
+      return result
+    end
+
+    private
+
+    def item_to_hash(item, *attrs)
+      h = {}
+
+      attrs.each do |attr|
+        value = item.send(attr)
+        h[attr] = value if value
+      end
+
+      return h
+    end
+
+  end # Exporter
+end # Roadworker

data/lib/roadworker/route53-ext.rb

@@ -0,0 +1,32 @@
+require 'aws-sdk'
+
+module AWS
+  class Route53
+
+    def dns_name_to_alias_target(name)
+      name = name.gsub(/\.\Z/, '')
+
+      unless name =~ /([^.]+)\.elb\.amazonaws.com\Z/i
+        raise "Invalid DNS Name: #{name}"
+      end
+
+      region = $1.downcase
+      elb = AWS::ELB.new(:region => region)
+
+      load_balancer = elb.load_balancers.find do |lb|
+        lb.dns_name == name
+      end
+
+      unless load_balancer
+        raise "Cannot find ELB: #{name}"
+      end
+
+      {
+        :hosted_zone_id         => load_balancer.canonical_hosted_zone_name_id,
+        :dns_name               => load_balancer.dns_name,
+        :evaluate_target_health => false, # XXX:
+      }
+    end
+
+  end # Route53
+end # Roadworker

data/lib/roadworker/route53-wrapper.rb

@@ -0,0 +1,253 @@
+require 'roadworker/collection'
+require 'roadworker/log'
+require 'roadworker/route53-exporter'
+require 'roadworker/route53-ext'
+
+require 'ostruct'
+
+module Roadworker
+  class Route53Wrapper
+
+    RRSET_ATTRS = [
+      :set_identifier,
+      :weight,
+      :ttl,
+      :resource_records,
+      :dns_name,
+      :region
+    ]
+
+    def initialize(options)
+      @options = options
+    end
+
+    def export
+      Exporter.export(@options.route53)
+    end
+
+    def hosted_zones
+      HostedZoneCollectionWrapper.new(@options.route53.hosted_zones, @options)
+    end
+
+    class HostedZoneCollectionWrapper
+      include Roadworker::Log
+
+      def initialize(hosted_zones, options)
+        @hosted_zones = hosted_zones
+        @options = options
+      end
+
+      def each
+        Collection.batch(@hosted_zones) do |zone|
+          yield(HostedZoneWrapper.new(zone, @options))
+        end
+      end
+
+      def create(name, opts = {})
+        log(:info, 'Create HostedZone', :cyan, name)
+
+        if @options.dry_run
+          zone = OpenStruct.new({:name => name, :rrsets => []}.merge(opts))
+        else
+          zone = @hosted_zones.create(name, opts)
+          @options.updated = true
+        end
+
+        HostedZoneWrapper.new(zone, @options)
+      end
+    end # HostedZoneCollection
+ 
+    class HostedZoneWrapper
+      include Roadworker::Log
+
+      def initialize(hosted_zone, options)
+        @hosted_zone = hosted_zone
+        @options = options
+      end
+
+      def resource_record_sets
+        ResourceRecordSetCollectionWrapper.new(@hosted_zone.rrsets, @options)
+      end
+      alias rrsets resource_record_sets
+
+      def delete
+        if @options.force
+          log(:info, 'Delete HostedZone', :red, @hosted_zone.name)
+
+          unless @options.dry_run
+            @hosted_zone.delete
+            @options.updated = true
+          end
+        else
+          log(:info, 'Undefined HostedZone (pass `--force` if you want to remove)', :yellow, @hosted_zone.name)
+        end
+      end
+
+      private
+
+      def method_missing(method_name, *args)
+        @hosted_zone.send(method_name, *args)
+      end
+    end # HostedZoneWrapper
+
+    class ResourceRecordSetCollectionWrapper
+      include Roadworker::Log
+
+      def initialize(resource_record_sets, options)
+        @resource_record_sets = resource_record_sets
+        @options = options
+      end
+
+      def each
+        Collection.batch(@resource_record_sets) do |record|
+          yield(ResourceRecordSetWrapper.new(record, @options))
+        end
+      end
+
+      def create(name, type, expected_record)
+        log(:info, 'Create ResourceRecordSet', :cyan) do 
+          log_id = [name, type].join(' ')
+          rrset_setid = expected_record.set_identifier
+          rrset_setid ? (log_id + " (#{rrset_setid})") : log_id
+        end
+
+        if @options.dry_run
+          record = expected_record
+        else
+          opts = {}
+
+          Route53Wrapper::RRSET_ATTRS.each do |attr|
+            value = expected_record.send(attr)
+            next unless value
+
+            case attr
+            when :dns_name
+              attr = :alias_target
+              value = @options.route53.dns_name_to_alias_target(value)
+            end
+
+            opts[attr] = value
+          end
+
+          record = @resource_record_sets.create(name, type, opts)
+          @options.updated = true
+        end
+
+        ResourceRecordSetWrapper.new(record, @options)
+      end
+    end # ResourceRecordSetCollectionWrapper
+
+    class ResourceRecordSetWrapper
+      include Roadworker::Log
+
+      def initialize(resource_record_set, options)
+        @resource_record_set = resource_record_set
+        @options = options
+      end
+
+      def eql?(expected_record)
+        Route53Wrapper::RRSET_ATTRS.all? do |attr|
+          expected = expected_record.send(attr)
+          expected = nil if expected.kind_of?(Array) && expected.empty?
+          actual = self.send(attr)
+          actual = nil if actual.kind_of?(Array) && actual.empty?
+
+          if !expected and !actual
+            true
+          elsif expected and actual
+            case attr
+            when :resource_records
+              expected = expected.sort_by {|i| i[:value] }
+              actual = actual.sort_by {|i| i[:value] }
+            end
+
+            (expected == actual)
+          else
+            false
+          end
+        end
+      end
+
+      def update(expected_record)
+        log(:info, 'Update ResourceRecordSet', :green) do
+          log_id = [@resource_record_set.name, @resource_record_set.type].join(' ')
+          rrset_setid = @resource_record_set.set_identifier
+          rrset_setid ? (log_id + " (#{rrset_setid})") : log_id
+        end
+
+        Route53Wrapper::RRSET_ATTRS.each do |attr|
+          expected = expected_record.send(attr)
+          expected = nil if expected.kind_of?(Array) && expected.empty?
+          actual = self.send(attr)
+          actual = nil if actual.kind_of?(Array) && actual.empty?
+
+          if (expected and !actual) or (!expected and actual)
+            log(:info, "  set #{attr}=#{expected.inspect}" , :green) do
+              log_id = [@resource_record_set.name, @resource_record_set.type].join(' ')
+              rrset_setid = @resource_record_set.set_identifier
+              rrset_setid ? (log_id + " (#{rrset_setid})") : log_id
+            end
+
+            self.send(:"#{attr}=", expected) unless @options.dry_run
+          elsif expected and actual
+            case attr
+            when :resource_records
+              expected = expected.sort_by {|i| i[:value] }
+              actual = actual.sort_by {|i| i[:value] }
+            end
+
+            if expected != actual
+              log(:info, "  set #{attr}=#{expected.inspect}" , :green) do
+                log_id = [@resource_record_set.name, @resource_record_set.type].join(' ')
+                rrset_setid = @resource_record_set.set_identifier
+                rrset_setid ? (log_id + " (#{rrset_setid})") : log_id
+              end
+
+              self.send(:"#{attr}=", expected) unless @options.dry_run
+            end
+          end
+        end
+
+        unless @options.dry_run
+          @resource_record_set.update
+          @options.updated = true
+        end
+      end
+
+      def delete(opts = {})
+        return if type =~ /\A(SOA|NS)\Z/i
+        if not opts[:cascaded] or @options.force
+          log(:info, 'Delete ResourceRecordSet', :red) do
+            log_id = [@resource_record_set.name, @resource_record_set.type].join(' ')
+            rrset_setid = @resource_record_set.set_identifier
+            rrset_setid ? (log_id + " (#{rrset_setid})") : log_id
+          end
+        end
+
+        unless @options.dry_run
+          @resource_record_set.delete
+          @options.updated = true
+        end
+      end
+
+      def dns_name=(name)
+        if name
+          @resource_record_set.alias_target = @options.route53.dns_name_to_alias_target(name)
+        else
+          @resource_record_set.alias_target = nil
+        end
+      end
+
+      def dns_name
+        (@resource_record_set.alias_target || {})[:dns_name]
+      end
+
+      private
+
+      def method_missing(method_name, *args)
+        @resource_record_set.send(method_name, *args)
+      end
+    end # ResourceRecordSetWrapper
+
+  end # Route53Wrapper
+end # Roadworker

data/lib/roadworker/string-ext.rb

@@ -0,0 +1,28 @@
+require 'term/ansicolor'
+
+class String
+  @@colorize = false
+
+  class << self
+    def colorize=(value)
+      @@colorize = value
+    end
+
+    def colorize
+      @@colorize
+    end
+  end # of class method
+
+  Term::ANSIColor::Attribute.named_attributes.map do |attr|
+    class_eval(<<-EOS, __FILE__, __LINE__ + 1)
+      def #{attr.name}
+        if @@colorize
+          Term::ANSIColor.send(#{attr.name.inspect}, self)
+        else
+          self
+        end
+      end
+    EOS
+  end
+
+end

data/lib/roadworker/version.rb

@@ -0,0 +1,5 @@
+module Roadworker
+  VERSION = "0.0.1"
+end
+
+Version = Roadworker::VERSION

metadata

@@ -0,0 +1,124 @@
+--- !ruby/object:Gem::Specification
+name: roadworker
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- winebarrel
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-07-28 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: aws-sdk
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: term-ansicolor
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Roadworker is a tool to manage Route53. It defines the state of Route53
+  using DSL, and updates Route53 according to DSL.
+email: sgwr_dts@yahoo.co.jp
+executables:
+- roadwork
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- bin/roadwork
+- lib/roadworker/client.rb
+- lib/roadworker/collection.rb
+- lib/roadworker/dsl-converter.rb
+- lib/roadworker/dsl.rb
+- lib/roadworker/log.rb
+- lib/roadworker/route53-exporter.rb
+- lib/roadworker/route53-ext.rb
+- lib/roadworker/route53-wrapper.rb
+- lib/roadworker/string-ext.rb
+- lib/roadworker/version.rb
+- lib/roadworker.rb
+homepage: https://bitbucket.org/winebarrel/roadworker
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: Roadworker is a tool to manage Route53.
+test_files: []