gizzmo 0.12.1 → 0.13.0

data/VERSION

@@ -1 +1 @@
-0.12.1
+0.13.0

data/gizzmo.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{gizzmo}
-  s.version = "0.12.1"
+  s.version = "0.13.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Kyle Maxwell"]
-  s.date = %q{2011-10-20}
+  s.date = %q{2012-01-09}
   s.description = %q{Gizzmo is a command-line client for managing gizzard clusters.}
   s.email = %q{kmaxwell@twitter.com}
   s.executables = ["setup_shards", "gizzmo"]

data/lib/gizzard/commands.rb

@@ -64,6 +64,54 @@ module Gizzard
         puts string
       end
     end
+
+    def require_tables
+      if !global_options.tables
+        puts "Please specify tables to repair with the --tables flag" 
+        exit 1
+      end
+    end
+
+    def require_template_options
+      options = command_options.template_options || {}
+      if global_options.template_options && global_options.template_options[:simple]
+          fail = false
+          if !options[:concrete]
+            fail = true
+            STDERR.puts "Please specify a concrete shard type with --concrete flag when using --simple"
+          end
+          if !options[:source_type]
+            fail = true
+            STDERR.puts "Please specify a source data type with --source-type flag when using --simple"
+          end
+          if !options[:dest_type]
+            fail = true
+            STDERR.puts "Please specify a destination data type with --dest-type flag when using --simple"
+          end
+          exit 1 if fail
+        end
+    end
+
+    # Infer the shard base_name from a list of transformations
+    def get_base_name(transformations)
+      # Gets the first valid tree from the map of transformations -> applicable trees
+      # Trees are maps of forwardings -> shards. Gets the first valid shard from the this tree.
+      # Gets the ShardId of that shard and pulls the base name out of the table prefix
+      transformations.values.find {|v| v.is_a?(Hash) && !v.values.empty? }.values.find {|v| !v.nil?}.id.table_prefix.split('_').first
+    end
+
+    def confirm!(message="Continue?")
+      unless global_options.force
+        begin
+        print "#{message} (y/n) "; $stdout.flush
+        resp = $stdin.gets.chomp.downcase
+        puts ""
+        end while resp != 'y' && resp != 'n'
+        exit if resp == 'n'
+      end
+    end
+
+
   end
 
   class RetryProxy
@@ -494,30 +542,49 @@ module Gizzard
   end
 
   class CopyCommand < Command
-    def run
-      from_shard_id_string, to_shard_id_string = @argv
-      help!("Requires source & destination shard id") unless from_shard_id_string && to_shard_id_string
-      from_shard_id = ShardId.parse(from_shard_id_string)
-      to_shard_id = ShardId.parse(to_shard_id_string)
-      manager.copy_shard(from_shard_id, to_shard_id)
-    end
-  end
-
-  class RepairShardsCommand < Command
     def run
       shard_id_strings = @argv
       help!("Requires at least two shard ids") unless shard_id_strings.size >= 2
       shard_ids = shard_id_strings.map{|s| ShardId.parse(s)}
-      manager.repair_shards(shard_ids)
+      manager.copy_shard(shard_ids)
+      sleep 2
+      while manager.get_busy_shards().size > 0
+        sleep 5
+      end 
     end
   end
 
-  class DiffShardsCommand < Command
+  class RepairTablesCommand < Command
     def run
-      shard_id_strings = @argv
-      help!("Requires at least two shard ids") unless shard_id_strings.size >= 2
-      shard_ids = shard_id_strings.map{|s| ShardId.parse(s)}
-      manager.diff_shards(shard_ids)
+      require_tables
+
+      table_ids = global_options.tables
+      manifest = manager.manifest(*table_ids)
+      num_copies = command_options.num_copies || 100
+      shard_sets = []
+      manifest.trees.values.each do |tree|
+        shard_sets << concrete_leaves(tree)
+      end
+      shard_sets.each do |shard_ids|
+        while  manager.get_busy_shards().size > num_copies
+          sleep 1
+        end
+        puts "Repairing " + shard_ids.map {|s| s.to_unix }.join(",")
+        manager.copy_shard(shard_ids)
+      end
+
+      while manager.get_busy_shards().size > 0
+        sleep 5
+      end
+    end
+
+    def concrete_leaves(tree)
+      list = []
+      list << tree.info.id if tree.children.empty? && !tree.info.class_name.include?("BlackHoleShard")
+      tree.children.each do |child|
+        list += concrete_leaves(child)
+      end
+      list
     end
   end
 
@@ -714,110 +781,203 @@ module Gizzard
 
   class TablesCommand < Command
     def run
-      puts manager.list_tables.join(" ")
+      puts manager.list_tables.join(",")
     end
   end
 
   class TopologyCommand < Command
     def run
+      require_tables
+
       manifest  = manager.manifest(*global_options.tables)
-      templates = manifest.templates.inject({}) do |h, (t, fs)|
-        h.update t.to_config => fs
-      end
+      templates = manifest.templates
 
       if command_options.forwardings
         templates.
-          inject([]) { |h, (t, fs)| fs.each { |f| h << [f.inspect, t] }; h }.
+          inject([]) { |h, (t, fs)| fs.each { |f| h << [f.inspect, t.to_config] }; h }.
           sort.
           each { |a| puts "%s\t%s" % a }
       elsif command_options.root_shards
         templates.
-          inject([]) { |a, (t, fs)| fs.each { |f| a << [f.shard_id.inspect, t] }; a }.
+          inject([]) { |a, (t, fs)| fs.each { |f| a << [f.shard_id.inspect, t.to_config] }; a }.
           sort.
           each { |a| puts "%s\t%s" % a }
       else
         templates.
-          map { |(t, fs)| [fs.length, t] }.
+          map { |(t, fs)| [fs.length, t.to_config] }.
           sort.reverse.
           each { |a| puts "%4d %s" % a }
       end
     end
   end
 
-  class TransformTreeCommand < Command
+  class BaseTransformCommand < Command
     def run
-      help!("wrong number of arguments") unless @argv.length == 2
-
       scheduler_options = command_options.scheduler_options || {}
-      template_s, shard_id_s = @argv
-
-      to_template    = ShardTemplate.parse(template_s)
-      shard_id       = ShardId.parse(shard_id_s)
-      base_name      = shard_id.table_prefix.split('_').first
-      forwarding     = manager.get_forwarding_for_shard(shard_id)
-      manifest       = manager.manifest(forwarding.table_id)
-      shard          = manifest.trees[forwarding]
-      copy_wrapper   = scheduler_options[:copy_wrapper]
-      be_quiet       = global_options.force && command_options.quiet
-      transformation = Transformation.new(shard.template, to_template, copy_wrapper)
+      be_quiet          = global_options.force && command_options.quiet
 
       scheduler_options[:quiet] = be_quiet
 
-      if transformation.noop?
+      transformations = get_transformations
+      transformations.reject! {|t,trees| t.noop? or trees.empty? }
+
+      if transformations.empty?
         puts "Nothing to do!"
         exit
       end
 
+      base_name = get_base_name(transformations)
+
       unless be_quiet
-        puts transformation.inspect
+        transformations.each do |transformation, trees|
+          puts transformation.inspect
+          puts "Applied to #{trees.length} shards"
+          #trees.keys.sort.each {|f| puts "  #{f.inspect}" }
+        end
         puts ""
       end
 
-      unless global_options.force
-        print "Continue? (y/n) "; $stdout.flush
-        exit unless $stdin.gets.chomp == "y"
-        puts ""
-      end
+      confirm!
 
       Gizzard.schedule! manager,
                         base_name,
-                        { transformation => { forwarding => shard } },
+                        transformations,
                         scheduler_options
     end
   end
 
-  class TransformCommand < Command
-    def run
+  class TransformTreeCommand < BaseTransformCommand
+    def get_transformations
+      help!("must have an even number of arguments") unless @argv.length % 2 == 0
+      require_template_options
+
+      scheduler_options = command_options.scheduler_options || {}
+      copy_wrapper   = scheduler_options[:copy_wrapper]
+      skip_copies    = scheduler_options[:skip_copies] || false
+      transformations   = {}
+
+      memoized_transforms = {}
+      @argv.each_slice(2) do |(template_s, shard_id_s)|
+        to_template    = ShardTemplate.parse(template_s)
+        shard_id       = ShardId.parse(shard_id_s)
+        base_name      = shard_id.table_prefix.split('_').first
+        forwarding     = manager.get_forwarding_for_shard(shard_id)
+        manifest       = manager.manifest(forwarding.table_id)
+        shard          = manifest.trees[forwarding]
+
+        transform_args = [shard.template, to_template, copy_wrapper, skip_copies]
+        transformation = memoized_transforms.fetch(transform_args) do |args|
+          memoized_transforms[args] = Transformation.new(*args)
+        end
+        tree = transformations.fetch(transformation) do |t|
+          transformations[t] = {}
+        end
+        tree[forwarding] = shard
+      end
+
+      transformations
+    end
+  end
+
+  class TransformCommand < BaseTransformCommand
+    def get_transformations
       help!("must have an even number of arguments") unless @argv.length % 2 == 0
+      require_tables
+      require_template_options
 
       scheduler_options = command_options.scheduler_options || {}
       manifest          = manager.manifest(*global_options.tables)
       copy_wrapper      = scheduler_options[:copy_wrapper]
-      be_quiet          = global_options.force && command_options.quiet
+      skip_copies       = scheduler_options[:skip_copies] || false
       transformations   = {}
 
-      scheduler_options[:quiet] = be_quiet
-
       @argv.each_slice(2) do |(from_template_s, to_template_s)|
         from, to       = [from_template_s, to_template_s].map {|s| ShardTemplate.parse(s) }
-        transformation = Transformation.new(from, to, copy_wrapper)
+        transformation = Transformation.new(from, to, copy_wrapper, skip_copies)
         forwardings    = Set.new(manifest.templates[from] || [])
         trees          = manifest.trees.reject {|(f, s)| !forwardings.include?(f) }
 
         transformations[transformation] = trees
       end
 
-      transformations.reject! {|t,trees| t.noop? or trees.empty? }
+      transformations
+    end
+  end
+
+  class RebalanceCommand < BaseTransformCommand
+    def get_transformations
+      help!("must have an even number of arguments") unless @argv.length % 2 == 0
+      require_tables
+      require_template_options
+
+      scheduler_options = command_options.scheduler_options || {}
+      manifest          = manager.manifest(*global_options.tables)
+      copy_wrapper      = scheduler_options[:copy_wrapper]
+      transformations   = {}
+
+      dest_templates_and_weights = {}
+
+      @argv.each_slice(2) do |(weight_s, to_template_s)|
+        to     = ShardTemplate.parse(to_template_s)
+        weight = weight_s.to_i
+
+        dest_templates_and_weights[to] = weight
+      end
+
+      global_options.tables.inject({}) do |all, table|
+        trees      = manifest.trees.reject {|(f, s)| f.table_id != table }
+        rebalancer = Rebalancer.new(trees, dest_templates_and_weights, copy_wrapper)
+
+        all.update(rebalancer.transformations) {|t,a,b| a.merge b }
+      end
+    end
+  end
+
+  class AddPartitionCommand < Command
+    def run
+      require_tables
+      require_template_options
+
+      scheduler_options = command_options.scheduler_options || {}
+      manifest          = manager.manifest(*global_options.tables)
+      copy_wrapper      = scheduler_options[:copy_wrapper]
+      be_quiet          = global_options.force && command_options.quiet
+      transformations   = {}
+
+      scheduler_options[:quiet] = be_quiet
+
+      puts "Note: All partitions, including existing ones, will be weighted evenly." unless be_quiet
+
+      add_templates_and_weights = {}
+
+      @argv.each do |template_s|
+        to     = ShardTemplate.parse(template_s)
+
+        add_templates_and_weights[to] = ShardTemplate::DEFAULT_WEIGHT
+      end
+
+      orig_templates_and_weights = manifest.templates.inject({}) do |h, (template, forwardings)|
+        h[template] = ShardTemplate::DEFAULT_WEIGHT; h
+      end
+
+      dest_templates_and_weights = orig_templates_and_weights.merge(add_templates_and_weights)
+
+      transformations = global_options.tables.inject({}) do |all, table|
+        trees      = manifest.trees.reject {|(f, s)| f.table_id != table }
+        rebalancer = Rebalancer.new(trees, dest_templates_and_weights, copy_wrapper)
+
+        all.update(rebalancer.transformations) {|t,a,b| a.merge b }
+      end
 
       if transformations.empty?
         puts "Nothing to do!"
         exit
       end
 
-      base_name = transformations.values.find {|v| v.is_a?(Hash) && !v.values.empty? }.values.find {|v| !v.nil?}.id.table_prefix.split('_').first
+      base_name = get_base_name(transformations)
 
       unless be_quiet
-        transformations.sort.each do |transformation, trees|
+        transformations.each do |transformation, trees|
           puts transformation.inspect
           puts "Applied to #{trees.length} shards:"
           trees.keys.sort.each {|f| puts "  #{f.inspect}" }
@@ -825,11 +985,7 @@ module Gizzard
         puts ""
       end
 
-      unless global_options.force
-        print "Continue? (y/n) "; $stdout.flush
-        exit unless $stdin.gets.chomp == "y"
-        puts ""
-      end
+      confirm!
 
       Gizzard.schedule! manager,
                         base_name,
@@ -838,9 +994,9 @@ module Gizzard
     end
   end
 
-  class RebalanceCommand < Command
+  class RemovePartitionCommand < Command
     def run
-      help!("must have an even number of arguments") unless @argv.length % 2 == 0
+      require_tables
 
       scheduler_options = command_options.scheduler_options || {}
       manifest          = manager.manifest(*global_options.tables)
@@ -850,13 +1006,16 @@ module Gizzard
 
       scheduler_options[:quiet] = be_quiet
 
-      dest_templates_and_weights = {}
+      puts "Note: All partitions will be weighted evenly." unless be_quiet
 
-      @argv.each_slice(2) do |(weight_s, to_template_s)|
-        to     = ShardTemplate.parse(to_template_s)
-        weight = weight_s.to_i
+      dest_templates_and_weights = manifest.templates.inject({}) do |h, (template, forwardings)|
+        h[template] = ShardTemplate::DEFAULT_WEIGHT; h
+      end
 
-        dest_templates_and_weights[to] = weight
+      @argv.each do |template_s|
+        t     = ShardTemplate.parse(template_s)
+
+        dest_templates_and_weights.delete(t)
       end
 
       transformations = global_options.tables.inject({}) do |all, table|
@@ -871,7 +1030,7 @@ module Gizzard
         exit
       end
 
-      base_name = transformations.values.first.values.first.id.table_prefix.split('_').first
+      base_name = get_base_name(transformations)
 
       unless be_quiet
         transformations.each do |transformation, trees|
@@ -882,11 +1041,7 @@ module Gizzard
         puts ""
       end
 
-      unless global_options.force
-        print "Continue? (y/n) "; $stdout.flush
-        exit unless $stdin.gets.chomp == "y"
-        puts ""
-      end
+      confirm!
 
       Gizzard.schedule! manager,
                         base_name,
@@ -895,7 +1050,6 @@ module Gizzard
     end
   end
 
-
   class CreateTableCommand < Command
 
     DEFAULT_NUM_SHARDS   = 1024
@@ -934,6 +1088,8 @@ module Gizzard
 
     def run
       help!("must have an even number of arguments") unless @argv.length % 2 == 0
+      require_tables
+      require_template_options
 
       base_name    = command_options.base_name || DEFAULT_BASE_NAME
       num_shards   = (command_options.shards || DEFAULT_NUM_SHARDS).to_i
@@ -979,11 +1135,7 @@ module Gizzard
         puts ""
       end
 
-      unless global_options.force
-        print "Continue? (y/n) "; $stdout.flush
-        exit unless $stdin.gets.chomp == "y"
-        puts ""
-      end
+      confirm!
 
       global_options.tables.each do |table_id|
         templates_and_base_ids.each do |template, base_ids|

data/lib/gizzard/nameserver.rb

@@ -37,7 +37,7 @@ module Gizzard
 
     REPLICATING_SHARD_TYPES = ["ReplicatingShard", "FailingOverShard"]
 
-    INVALID_COPY_TYPES = ["ReadOnlyShard", "WriteOnlyShard", "BlockedShard"]
+    INVALID_COPY_TYPES = ["ReadOnlyShard", "BlackHoleShard", "BlockedShard"]
 
     SHARD_SUFFIXES = {
       "FailingOverShard" => 'replicating',
@@ -47,6 +47,14 @@ module Gizzard
       "BlockedShard" => 'blocked'
     }
 
+    SHARD_TAGS = {
+      "ReplicatingShard" => 'replicating',
+      "ReadOnlyShard" => 'read_only',
+      "WriteOnlyShard" => 'write_only',
+      "BlockedShard" => 'blocked',
+      "BlackHoleShard" => 'blackhole'
+    }
+
     def id; info.id end
     def hostname; id.hostname end
     def table_prefix; id.table_prefix end
@@ -118,9 +126,9 @@ module Gizzard
       end
     end
 
-    def copy_shard(from_shard_id, to_shard_id)
+    def copy_shard(*shards)
       c = random_client
-      with_retry { c.copy_shard(from_shard_id, to_shard_id) }
+      with_retry { c.copy_shard(*shards) }
     end
 
     def repair_shards(*shards)
@@ -175,6 +183,8 @@ module Gizzard
       times ||= @retries
       yield
     rescue Exception => e
+      STDERR.puts "\nException: #{e.description rescue "(no description)"}"
+      STDERR.puts "Retrying #{times} more time#{'s' if times > 1}..." if times > 0 
       times -= 1
       (times < 0) ? raise : (sleep 0.1; retry)
     end

data/lib/gizzard/shard_template.rb

@@ -38,6 +38,10 @@ module Gizzard
       Shard::SHARD_SUFFIXES[type.split('.').last]
     end
 
+    def shard_tag
+      Shard::SHARD_TAGS[type.split('.').last]
+    end
+
     def host
       if concrete?
         @host
@@ -135,6 +139,10 @@ module Gizzard
       false
     end
 
+    def contains_shard_type?(other)
+      descendants.map {|d| d.type }.include? other
+    end
+
     def hash
       weight.hash + host.hash + type.hash + children.hash
     end
@@ -165,38 +173,113 @@ module Gizzard
     end
 
     def to_config
+      if ShardTemplate.options[:simple]
+        to_simple_config
+      else
+        to_complex_config
+      end
+    end
+    
+    def to_complex_config
       if children.empty?
         config_definition
       else
-        child_defs = children.map {|c| c.to_config }
+        child_defs = children.map {|c| c.to_complex_config }
         child_defs_s = child_defs.length == 1 ? child_defs.first : "(#{child_defs.join(", ")})"
         "#{config_definition} -> #{child_defs_s}"
       end
     end
 
+    def to_simple_config(tag="")
+      if children.empty? && concrete?
+        tag += "+#{shard_tag}" if shard_tag
+        "#{host}#{tag if !tag.empty?}"
+      elsif !children.empty?
+        if replicating?
+          children.map {|c| c.to_simple_config }.join(", ")
+        else
+          children.map {|c| c.to_simple_config("#{tag}#{'+' + shard_tag.to_s if shard_tag}")}
+        end
+      else
+        ""
+      end
+    end
 
     # Class Methods
 
     class << self
+
+      def configure(options)
+        @@options ||= {}
+        @@options.merge!(options)
+      end
+
+      def options
+        @@options ||= {}
+        @@options[:replicating] ||= "ReplicatingShard"
+        #@@options[:source_type] ||= "BIGINT UNSIGNED"
+        #@@options[:dest_type] ||= "BIGINT UNSIGNED"
+        @@options
+      end
+
       def parse(string)
+        if options[:simple]
+          parse_simple(string)
+        else
+          parse_complex(string)
+        end
+      end
+
+      private
+
+      def parse_simple(definition_s)
+        shards = definition_s.split(",")
+        templates = []
+        shards.each do |s|
+          s.strip!
+          host, *tags = s.split("+")
+          templates << build_nested_template(host, tags)
+        end
+        ShardTemplate.new(options[:replicating], nil, 1, "", "", templates)
+      end
+
+      def build_nested_template(host, tags)
+        if tags.empty?
+          return ShardTemplate.new(options[:concrete], host, 1, options[:source_type], options[:dest_type], [])
+        end
+
+        tag = tags.shift
+        type = Shard::SHARD_TAGS.invert[tag]
+
+        if type == "BlackHoleShard" # end at blackhole shards immediately since they're concrete
+          return ShardTemplate.new(type, ABSTRACT_HOST, 1, "", "", [])
+        end
+
+        if type
+          return ShardTemplate.new(type, nil, 1, "", "", [build_nested_template(host, tags)])
+        end
+
+        []
+      end
+
+
+      def parse_complex(string)
         definition_s, children_s = string.split(/\s*->\s*/, 2)
 
         children =
         if children_s.nil?
           []
         else
-          list = parse_arg_list(children_s).map {|c| parse c }
+          list = parse_arg_list(children_s).map {|c| parse_complex c }
           raise ArgumentError, "invalid shard config. -> given, no children found" if list.empty?
           list
         end
 
-        template_args = parse_definition(definition_s) << children
+        template_args = parse_complex_definition(definition_s) << children
         ShardTemplate.new(*template_args)
       end
 
-      private
-
-      def parse_definition(definition_s)
+      def parse_complex_definition(definition_s)
         type, arg_list = definition_s.split("(", 2)
 
         host, weight, source_type, dest_type =

data/lib/gizzard/thrift.rb

@@ -183,7 +183,7 @@ module Gizzard
     thrift_method :list_tables, list(i32), :throws => exception(GizzardException)
 
     thrift_method :mark_shard_busy, void, field(:id, struct(ShardId), 1), field(:busy, i32, 2), :throws => exception(GizzardException)
-    thrift_method :copy_shard, void, field(:source_id, struct(ShardId), 1), field(:destination_id, struct(ShardId), 2), :throws => exception(GizzardException)
+    thrift_method :copy_shard, void, field(:shard_ids, list(struct(ShardId)), 1), :throws => exception(GizzardException)
     thrift_method :repair_shard, void, field(:shard_ids, list(struct(ShardId)), 1), :throws => exception(GizzardException)
     thrift_method :diff_shards, void, field(:shard_ids, list(struct(ShardId)), 1), :throws => exception(GizzardException)
 

data/lib/gizzard/transformation.rb

@@ -37,11 +37,11 @@ module Gizzard
       Op::DiffShards       => 9
     }
 
-    DEFAULT_DEST_WRAPPER = 'WriteOnlyShard'
+    DEFAULT_DEST_WRAPPER = 'BlockedShard'
 
-    attr_reader :from, :to, :copy_dest_wrapper
+    attr_reader :from, :to, :copy_dest_wrapper, :skip_copies
 
-    def initialize(from_template, to_template, copy_dest_wrapper = nil)
+    def initialize(from_template, to_template, copy_dest_wrapper = nil, skip_copies = false)
       copy_dest_wrapper ||= DEFAULT_DEST_WRAPPER
 
       unless Shard::VIRTUAL_SHARD_TYPES.include? copy_dest_wrapper
@@ -51,6 +51,7 @@ module Gizzard
       @from = from_template
       @to   = to_template
       @copy_dest_wrapper = copy_dest_wrapper
+      @skip_copies = skip_copies
 
       if copies_required? && copy_source.nil?
         raise ArgumentError, "copy required without a valid copy source"
@@ -87,17 +88,27 @@ module Gizzard
     end
 
     def inspect
+      # TODO: Need to limit this to e.g. 10 ops in the list, and show a total
+      # count instead of showing the whole thing.
       op_inspect = operations.inject({}) do |h, (phase, ops)|
         h.update phase => ops.map {|job| "    #{job.inspect}" }.join("\n")
       end
 
+      # TODO: This seems kind of daft to copy around these long strings.
+      # Loop over it once just for display?
       prepare_inspect = op_inspect[:prepare].empty? ? "" : "  PREPARE\n#{op_inspect[:prepare]}\n"
       copy_inspect    = op_inspect[:copy].empty?    ? "" : "  COPY\n#{op_inspect[:copy]}\n"
       repair_inspect  = op_inspect[:repair].empty?  ? "" : "  REPAIR\n#{op_inspect[:repair]}\n"
       diff_inspect    = op_inspect[:diff].empty?  ? "" : "  DIFF\n#{op_inspect[:diff]}\n"
       cleanup_inspect = op_inspect[:cleanup].empty? ? "" : "  CLEANUP\n#{op_inspect[:cleanup]}\n"
 
-      op_inspect = [prepare_inspect, copy_inspect, repair_inspect, cleanup_inspect].join
+      op_inspect = [
+        prepare_inspect,
+        copy_inspect,
+        repair_inspect,
+        diff_inspect,
+        cleanup_inspect,
+      ].join
 
       "#{from.inspect} => #{to.inspect} :\n#{op_inspect}"
     end
@@ -111,7 +122,6 @@ module Gizzard
 
       # compact
       log = collapse_jobs(log)
-
       @operations = expand_jobs(log)
 
       @operations.each do |(phase, jobs)|
@@ -131,7 +141,7 @@ module Gizzard
 
     def expand_jobs(jobs)
       expanded = jobs.inject({:prepare => [], :copy => [], :repair => [], :cleanup => [], :diff => []}) do |ops, job|
-        job_ops = job.expand(self.copy_source, involved_in_copy?(job.template), @copy_dest_wrapper)
+        job_ops = job.expand(self.copy_source, involved_in_copy?(job.template))
         ops.update(job_ops) {|k,a,b| a + b }
       end
 
@@ -146,6 +156,7 @@ module Gizzard
     end
 
     def copies_required?
+      return false if skip_copies
       return @copies_required unless  @copies_required.nil?
 
       @copies_required = !from.nil? &&
@@ -169,10 +180,19 @@ module Gizzard
     end
 
     def create_tree(root)
-      jobs = visit_collect(root) do |parent, child|
-        [Op::CreateShard.new(child), Op::AddLink.new(parent, child)]
+      get_wrapper_type = Proc.new { |template, wrapper_type|
+        if wrapper_type.nil?
+          nil
+        elsif template.contains_shard_type? wrapper_type 
+          nil
+        else
+          wrapper_type
+        end
+      }
+      jobs = visit_collect(root, get_wrapper_type, @copy_dest_wrapper) do |parent, child, wrapper|
+        [Op::CreateShard.new(child, wrapper), Op::AddLink.new(parent, child, wrapper)]
       end
-      [Op::CreateShard.new(root)].concat jobs << Op::SetForwarding.new(root)
+      [Op::CreateShard.new(root, @copy_dest_wrapper)].concat jobs << Op::SetForwarding.new(root, @copy_dest_wrapper)
     end
 
     def destroy_tree(root)
@@ -184,9 +204,10 @@ module Gizzard
 
     private
 
-    def visit_collect(parent, &block)
+    def visit_collect(parent, pass_down_method=Proc.new{}, pass_down_value=nil, &block)
       parent.children.inject([]) do |acc, child|
-        visit_collect(child, &block).concat(acc.concat(block.call(parent, child)))
+        pass_down_value = pass_down_method.call(child, pass_down_value)
+        visit_collect(child, pass_down_method, pass_down_value, &block).concat(acc.concat(block.call(parent, child, pass_down_value)))
       end
     end
   end
@@ -251,10 +272,12 @@ module Gizzard
 
     def copy_descs
       transformation.operations[:copy].map do |copy|
-        from_id = copy.from.to_shard_id(@table_prefix, @translations)
-        to_id   = copy.to.to_shard_id(@table_prefix, @translations)
-        "#{from_id.inspect} -> #{to_id.inspect}"
+        desc = copy.shards.inject("") do |d, shard|
+          d += shard.to_shard_id(@table_prefix, @translations).inspect + " <-> "
+        end
+        desc.chomp " <-> "
       end
+      
     end
 
     private

data/lib/gizzard/transformation_op.rb

@@ -12,7 +12,7 @@ module Gizzard
       alias == eql?
 
       def inspect
-        templates = (is_a?(LinkOp) ? [from, to] : [template]).map {|t| t.identifier }.join(" -> ")
+        templates = (is_a?(LinkOp) ? [from, to] : [*template]).map {|t| t.identifier }.join(" -> ")
         name      = Transformation::OP_NAMES[self.class]
         "#{name}(#{templates})"
       end
@@ -29,26 +29,22 @@ module Gizzard
     class CopyShard < BaseOp
       BUSY = 1
 
-      attr_reader :from, :to
-      alias template to
+      attr_reader :from, :to, :shards
+      alias template shards
 
-      def initialize(from, to)
-        @from = from
-        @to   = to
+      def initialize(*shards)
+        @shards = shards
       end
 
       def expand(*args); { :copy => [self] } end
 
       def involved_shards(table_prefix, translations)
-        [to.to_shard_id(table_prefix, translations)]
+        shards.map{|s| s.to_shard_id(table_prefix, translations)}
       end
 
       def apply(nameserver, table_id, base_id, table_prefix, translations)
-        from_shard_id = from.to_shard_id(table_prefix, translations)
-        to_shard_id   = to.to_shard_id(table_prefix, translations)
-
-        nameserver.mark_shard_busy(to_shard_id, BUSY)
-        nameserver.copy_shard(from_shard_id, to_shard_id)
+        involved_shards(table_prefix, translations).each { |sid| nameserver.mark_shard_busy(sid, BUSY) }
+        nameserver.copy_shard(involved_shards(table_prefix, translations))
       end
     end
 
@@ -98,9 +94,10 @@ module Gizzard
       attr_reader :from, :to
       alias template to
 
-      def initialize(from, to)
+      def initialize(from, to, wrapper_type=nil)
         @from = from
         @to   = to
+        @wrapper_type = wrapper_type
       end
 
       def inverse?(other)
@@ -113,9 +110,9 @@ module Gizzard
     end
 
     class AddLink < LinkOp
-      def expand(copy_source, involved_in_copy, wrapper_type)
-        if involved_in_copy
-          wrapper = ShardTemplate.new(wrapper_type, to.host, to.weight, '', '', [to])
+      def expand(copy_source, involved_in_copy)
+        if involved_in_copy && @wrapper_type
+          wrapper = ShardTemplate.new(@wrapper_type, to.host, to.weight, '', '', [to])
           { :prepare => [AddLink.new(from, wrapper)],
             :cleanup => [self, RemoveLink.new(from, wrapper)] }
         else
@@ -132,7 +129,7 @@ module Gizzard
     end
 
     class RemoveLink < LinkOp
-      def expand(copy_source, involved_in_copy, wrapper_type)
+      def expand(copy_source, involved_in_copy)
         { (involved_in_copy ? :cleanup : :prepare) => [self] }
       end
 
@@ -147,8 +144,9 @@ module Gizzard
     class ShardOp < BaseOp
       attr_reader :template
 
-      def initialize(template)
+      def initialize(template, wrapper_type=nil)
         @template = template
+        @wrapper_type = wrapper_type
       end
 
       def inverse?(other)
@@ -161,12 +159,15 @@ module Gizzard
     end
 
     class CreateShard < ShardOp
-      def expand(copy_source, involved_in_copy, wrapper_type)
-        if involved_in_copy
-          wrapper = ShardTemplate.new(wrapper_type, template.host, template.weight, '', '', [template])
+      def expand(copy_source, involved_in_copy)
+        if involved_in_copy && @wrapper_type
+          wrapper = ShardTemplate.new(@wrapper_type, template.host, template.weight, '', '', [template])
           { :prepare => [self, CreateShard.new(wrapper), AddLink.new(wrapper, template)],
             :cleanup => [RemoveLink.new(wrapper, template), DeleteShard.new(wrapper)],
             :copy => [CopyShard.new(copy_source, template)] }
+        elsif involved_in_copy
+          { :prepare => [self],
+            :copy => [CopyShard.new(copy_source, template)] }
         else
           { :prepare => [self] }
         end
@@ -178,7 +179,7 @@ module Gizzard
     end
 
     class DeleteShard < ShardOp
-      def expand(copy_source, involved_in_copy, wrapper_type)
+      def expand(copy_source, involved_in_copy)
         { (involved_in_copy ? :cleanup : :prepare) => [self] }
       end
 
@@ -188,9 +189,9 @@ module Gizzard
     end
 
     class SetForwarding < ShardOp
-      def expand(copy_source, involved_in_copy, wrapper_type)
-        if involved_in_copy
-          wrapper = ShardTemplate.new(wrapper_type, nil, 0, '', '', [to])
+      def expand(copy_source, involved_in_copy)
+        if involved_in_copy && @wrapper_type
+          wrapper = ShardTemplate.new(@wrapper_type, nil, 0, '', '', [to])
           { :prepare => [SetForwarding.new(template, wrapper)],
             :cleanup => [self] }
         else
@@ -209,7 +210,7 @@ module Gizzard
     # XXX: A no-op, but needed for setup/teardown symmetry
 
     class RemoveForwarding < ShardOp
-      def expand(copy_source, involved_in_copy, wrapper_type)
+      def expand(copy_source, involved_in_copy)
         { (involved_in_copy ? :cleanup : :prepare) => [self] }
       end
 

data/lib/gizzard/transformation_scheduler.rb

@@ -13,7 +13,7 @@ module Gizzard
     DEFAULT_OPTIONS = {
       :max_copies      => 30,
       :copies_per_host => 8,
-      :poll_interval   => 10
+      :poll_interval   => 10,
     }.freeze
 
     def initialize(nameserver, base_name, transformations, options = {})
@@ -25,6 +25,7 @@ module Gizzard
       @poll_interval      = options[:poll_interval]
       @be_quiet           = options[:quiet]
       @dont_show_progress = options[:no_progress] || @be_quiet
+      @batch_finish       = options[:batch_finish]
 
       @jobs_in_progress = []
       @jobs_finished    = []
@@ -53,10 +54,10 @@ module Gizzard
       
       loop do
         reload_busy_shards
-        
-        cleanup_jobs
+        cleanup_jobs if !@batch_finish
         schedule_jobs(max_copies - busy_shards.length)
 
+        cleanup_jobs if @batch_finish && @jobs_pending.empty? && jobs_completed == @jobs_in_progress
         break if @jobs_pending.empty? && @jobs_in_progress.empty?
 
         unless nameserver.dryrun?

data/lib/gizzmo.rb

@@ -4,33 +4,56 @@ class HelpNeededError < RuntimeError; end
 require "optparse"
 require "ostruct"
 require "gizzard"
+require "shellwords"
 require "yaml"
 
 DOC_STRINGS = {
+  "add-host" => "Add a remote cluster host to replicate to. Format: cluster:host:port.",
   "addforwarding" => "Add a forwarding from a graph_id / base_source_id to a given shard.",
   "addlink" => "Add a relationship link between two shards.",
+  "add-partition" => "Rebalance the cluster by appending new partitions to the current topology.",
+  "busy" => "List any shards with a busy flag set.",
+  "copy" => "Copy between the given list of shards. Given a set of shards, it will copy and repair to ensure that all shards have the latest data.",
   "create" => "Create shard(s) of a given Java/Scala class. If you don't know the list of available classes, you can just try a bogus class, and the exception will include a list of valid classes.",
+  "create-table" => "Create tables in an existing cluster.",
+  "delete" => "", # TODO: Undocumented
+  "deleteforwarding" => "", # TODO: Undocumented
+  "diff-shards" => "Log differences between n shards",
   "drill" => "Show shard trees for replicas of a given structure signature (from 'report').",
   "dump" => "Show shard trees for given table ids.",
   "find" => "Show all shards with a given hostname.",
+  "finish-migrate" => "", # TODO: Undocumented
   "finish-replica" => "Remove the write-only barrier in front of a shard that's finished being copied after 'setup-replica'.",
   "flush" => "Flush error queue for a given priority.",
   "forwardings" => "Get a list of all forwardings.",
   "hosts" => "List hosts used in shard names in the forwarding table and replicas.",
   "info" => "Show id/class/busy for shards.",
   "inject" => "Inject jobs (as literal json) into the server. Jobs can be linefeed-terminated from stdin, or passed as arguments. Priority is server-defined, but typically lower numbers (like 1) are lower priority.",
-  "links" => "List parent & child links for shards.",
+  "links" => "List parent and child links for shards.",
+  "list-hosts" => "List remote cluster hosts being replicated to.",
   "lookup" => "Lookup the shard id that holds the record for a given table / source_id.",
-  "markbusy" => "Mark a shard as busy.",
+  "markbusy" => "Mark a list of shards as busy.",
+  "markunbusy" => "Mark a list of shards as not busy.",
   "pair" => "Report the replica pairing structure for a list of hosts.",
+  "rebalance" => "Restructure and move shards to reflect a new list of tree structures.",
   "reload" => "Instruct application servers to reload the nameserver state.",
-  "repair-shards" => "Reconcile n shards by detecting differences and rescheduling them",
-  "diff-shards" => "Log differences between n shards",
+  "remove-host" => "Remove a remote cluster host being replicate to.",
+  "remove-partition" => "Rebalance the cluster by removing the provided partitions from the current topology.",
+  "repair-tables" => "Reconcile all the shards in the given tables (supplied with -T) by detecting differences and writing them back to shards as needed.",
   "report" => "Show each unique replica structure for a given list of shards. Usually this shard list comes from << gizzmo forwardings | awk '{ print $3 }' >>.",
+  "setup-migrate" => "", # TODO: Undocumented
   "setup-replica" => "Add a replica to be parallel to an existing replica, in write-only mode, ready to be copied to.",
+  "subtree" => "Show the subtree of replicas given a shard id.",
+  "tables" => "List the table IDs known by this nameserver.",
+  "topology" => "List the full topologies known for the table IDs provided.",
+  "transform" => "Transform from one topology to another.",
+  "transform-tree" => "Transforms given forwardings to the corresponding given tree structure.",
+  "unlink" => "Remove a link from one shard to another.",
+  "unwrap" => "Remove a wrapper created with wrap.",
   "wrap" => "Wrapping creates a new (virtual, e.g. blocking, replicating, etc.) shard, and relinks SHARD_ID_TO_WRAP's parent links to run through the new shard.",
 }
 
+
 ORIGINAL_ARGV = ARGV.dup
 zero = File.basename($0)
 
@@ -46,11 +69,12 @@ subcommand_options = OpenStruct.new
 # Leftover arguments
 argv = nil
 
+
 GIZZMO_VERSION = File.read(File.dirname(__FILE__) + "/../VERSION") rescue "unable to read version file"
 
 begin
   YAML.load_file(File.join(ENV["HOME"], ".gizzmorc")).each do |k, v|
-    global_options.send("#{k}=", v)
+    #global_options.send("#{k}=", v)
   end
 rescue Errno::ENOENT
   # Do nothing...
@@ -86,6 +110,13 @@ def load_config(options, filename)
   YAML.load(File.open(filename)).each do |k, v|
     k = "hosts" if k == "host"
     v = v.split(",").map {|h| h.strip } if k == "hosts"
+    if k == "template_options"
+      opts = {}
+      v.each do |k1, v1|
+        opts[k1.to_sym] = v1
+      end
+      v = opts
+    end
     options.send("#{k}=", v)
   end
 end
@@ -100,12 +131,36 @@ def add_scheduler_opts(subcommand_options, opts)
   opts.on("--poll-interval=SECONDS", "Sleep SECONDS between polling for copy status") do |c|
     (subcommand_options.scheduler_options ||= {})[:poll_interval] = c.to_i
   end
-  opts.on("--copy-wrapper=TYPE", "Wrap copy destination shards with TYPE. default WriteOnlyShard") do |t|
+  opts.on("--copy-wrapper=SHARD_TYPE", "Wrap copy destination shards with SHARD_TYPE. default BlockedShard") do |t|
     (subcommand_options.scheduler_options ||= {})[:copy_wrapper] = t
   end
+  opts.on("--skip-copies", "Do transformation without copying. WARNING: This is VERY DANGEROUS if you don't know what you're doing!") do
+    (subcommand_options.scheduler_options ||= {})[:skip_copies] = true
+  end
   opts.on("--no-progress", "Do not show progress bar at bottom.") do
     (subcommand_options.scheduler_options ||= {})[:no_progress] = true
   end
+  opts.on("--batch-finish", "Wait until all copies are complete before cleaning up unneeded links and shards") do
+    (subcommand_options.scheduler_options ||= {})[:batch_finish] = true
+  end
+end
+
+def add_template_opts(subcommand_options, opts)
+  opts.on("--virtual=SHARD_TYPE", "Concrete shards will exist behind a virtual shard of this SHARD_TYPE (default ReplicatingShard)") do |t|
+    (subcommand_options.template_options ||= {})[:replicating] = t
+  end
+
+  opts.on("-c", "--concrete=SHARD_TYPE", "Concrete shards will be this SHARD_TYPE (REQUIRED when using --simple)") do |t|
+    (subcommand_options.template_options ||= {})[:concrete] = t
+  end
+
+  opts.on("--source-type=DATA_TYPE", "The data type for the source column. (REQUIRED when using --simple)") do |t|
+    (subcommand_options.template_options ||= {})[:source_type] = t
+  end
+
+  opts.on("--dest-type=DATA_TYPE", "The data type for the destination column. (REQUIRED when using --simple)") do |t|
+    (subcommand_options.template_options ||= {})[:dest_type] = t
+  end
 end
 
 subcommands = {
@@ -245,20 +300,15 @@ subcommands = {
     end
   end,
   'copy' => OptionParser.new do |opts|
-    opts.banner = "Usage: #{zero} copy SOURCE_SHARD_ID DESTINATION_SHARD_ID"
+    opts.banner = "Usage: #{zero} copy SHARD_IDS..."
     separators(opts, DOC_STRINGS["copy"])
   end,
-  'repair-shards' => OptionParser.new do |opts|
-    opts.banner = "Usage: #{zero} repair-shards SHARD_IDS..."
-    separators(opts, DOC_STRINGS["repair-shards"])
-  end,
-  'diff-shards' => OptionParser.new do |opts|
-    opts.banner = "Usage: #{zero} diff-shards SHARD_IDS..."
-    separators(opts, DOC_STRINGS["diff-shards"])
-  end,
-  'diff-shards' => OptionParser.new do |opts|
-    opts.banner = "Usage: #{zero} diff-shards SOURCE_SHARD_ID DESTINATION_SHARD_ID"
-    separators(opts, DOC_STRINGS["diff-shards"])
+  'repair-tables' => OptionParser.new do |opts|
+    opts.banner = "Usage: #{zero} -T TABLE,... repair-tables [options]"
+    separators(opts, DOC_STRINGS["repair-tables"])
+    opts.on("--max-copies=COUNT", "Limit max simultaneous copies to COUNT.") do |c|
+      subcommand_options.num_copies = c.to_i
+    end
   end,
   'busy' => OptionParser.new do |opts|
     opts.banner = "Usage: #{zero} busy"
@@ -317,10 +367,11 @@ subcommands = {
     end
   end,
   'transform-tree' => OptionParser.new do |opts|
-    opts.banner = "Usage: #{zero} transform-tree [options] TEMPLATE ROOT_SHARD_ID"
+    opts.banner = "Usage: #{zero} transform-tree [options] TEMPLATE ROOT_SHARD_ID ..."
     separators(opts, DOC_STRINGS['transform-tree'])
 
     add_scheduler_opts subcommand_options, opts
+    add_template_opts subcommand_options, opts
 
     opts.on("-q", "--quiet", "Do not display transformation info (only valid with --force)") do
       subcommand_options.quiet = true
@@ -331,6 +382,7 @@ subcommands = {
     separators(opts, DOC_STRINGS['transform'])
 
     add_scheduler_opts subcommand_options, opts
+    add_template_opts subcommand_options, opts
 
     opts.on("-q", "--quiet", "Do not display transformation info (only valid with --force)") do
       subcommand_options.quiet = true
@@ -340,6 +392,27 @@ subcommands = {
     opts.banner = "Usage: #{zero} rebalance [options] WEIGHT TO_TEMPLATE ..."
     separators(opts, DOC_STRINGS["rebalance"])
 
+    add_scheduler_opts subcommand_options, opts
+    add_template_opts subcommand_options, opts
+
+    opts.on("-q", "--quiet", "Do not display transformation info (only valid with --force)") do
+      subcommand_options.quiet = true
+    end
+  end,
+  'add-partition' => OptionParser.new do |opts|
+    opts.banner = "Usage: #{zero} add-partition [options] TEMPLATE ..."
+    separators(opts, DOC_STRINGS["add-partition"])
+
+    add_scheduler_opts subcommand_options, opts
+
+    opts.on("-q", "--quiet", "Do not display transformation info (only valid with --force)") do
+      subcommand_options.quiet = true
+    end
+  end,
+  'remove-partition' => OptionParser.new do |opts|
+    opts.banner = "Usage: #{zero} remove-partition [options] TEMPLATE ..."
+    separators(opts, DOC_STRINGS["remove-partition"])
+
     add_scheduler_opts subcommand_options, opts
 
     opts.on("-q", "--quiet", "Do not display transformation info (only valid with --force)") do
@@ -350,15 +423,17 @@ subcommands = {
     opts.banner = "Usage: #{zero} create-table [options] WEIGHT TEMPLATE ..."
     separators(opts, DOC_STRINGS["create-table"])
 
+    add_template_opts subcommand_options, opts
+
     opts.on("--shards=COUNT", "Create COUNT shards for each table.") do |count|
       subcommand_options.shards = count.to_i
     end
 
-    opts.on("--min-id=NUM", "Set lower bound on the id space to NUM (default min signed long: -1 * 2^63)") do |min_id|
+    opts.on("--min-id=NUM", "Set lower bound on the id space to NUM (default 0)") do |min_id|
       subcommand_options.min_id = min_id.to_i
     end
 
-    opts.on("--max-id=NUM", "Set upper bound on the id space to NUM (default max signed long: 2^63 - 1)") do |max_id|
+    opts.on("--max-id=NUM", "Set upper bound on the id space to NUM (default 2^60 - 1)") do |max_id|
       subcommand_options.max_id = max_id.to_i
     end
 
@@ -387,6 +462,8 @@ global = OptionParser.new do |opts|
   opts.separator "also useful to remember that global options come *before* the subcommand, while"
   opts.separator "subcommand options come *after* the subcommand."
   opts.separator ""
+  opts.separator "You can find explanations and example usage on the wiki (go/gizzmo)."
+  opts.separator ""
   opts.separator "You may find it useful to create a ~/.gizzmorc file, which is simply YAML"
   opts.separator "key/value pairs corresponding to options you want by default. A common .gizzmorc"
   opts.separator "simply contains:"
@@ -408,15 +485,15 @@ global = OptionParser.new do |opts|
   opts.separator ""
   opts.separator ""
   opts.separator "Global options:"
-  opts.on("-H", "--hosts=HOST[,HOST,...]", "HOSTS of application servers") do |hosts|
+  opts.on("-H", "--hosts=HOST[,HOST,...]", "Comma-delimited list of application servers") do |hosts|
     global_options.hosts = hosts.split(",").map {|h| h.strip }
   end
 
-  opts.on("-P", "--port=PORT", "PORT of remote manager service. default 7920") do |port|
+  opts.on("-P", "--port=PORT", "PORT of remote manager service (default 7920)") do |port|
     global_options.port = port.to_i
   end
 
-  opts.on("-I", "--injector=PORT", "PORT of remote job injector service. default 7921") do |port|
+  opts.on("-I", "--injector=PORT", "PORT of remote job injector service (default 7921)") do |port|
     global_options.injector_port = port.to_i
   end
 
@@ -424,7 +501,7 @@ global = OptionParser.new do |opts|
     global_options.tables = tables.split(",").map {|t| t.to_i }
   end
 
-  opts.on("-F", "--framed", "use the thrift framed transport") do |framed|
+  opts.on("-F", "--framed", "Use the thrift framed transport") do |framed|
     global_options.framed = true
   end
 
@@ -448,6 +525,10 @@ global = OptionParser.new do |opts|
     global_options.dry = true
   end
 
+  opts.on("-s", "--simple", "Represent shard templates in a simple format") do
+    (global_options.template_options ||= {})[:simple] = true #This is a temporary setting until the nameserver design changes match the simpler format
+  end
+
   opts.on("-C", "--config=YAML_FILE", "YAML_FILE of option key/values") do |filename|
     load_config(global_options, filename)
   end
@@ -459,6 +540,10 @@ global = OptionParser.new do |opts|
   opts.on("-f", "--force", "Don't display confirmation dialogs") do |force|
     global_options.force = force
   end
+ 
+  opts.on("--argv=FILE", "Put the contents of FILE onto the command line") do |f|
+    ARGV.push *Shellwords.shellwords(File.read(f))
+  end
 
   opts.on_tail("-v", "--version", "Show version") do
     puts GIZZMO_VERSION
@@ -472,7 +557,6 @@ if ARGV.length == 0
   exit 1
 end
 
-# This
 def process_nested_parsers(global, subcommands)
   begin
     global.order!(ARGV) do |subcommand_name|
@@ -528,6 +612,7 @@ end
 
 begin
   custom_timeout(global_options.timeout) do
+    Gizzard::ShardTemplate.configure((global_options.template_options || {}).merge(subcommand_options.template_options || {}))
     Gizzard::Command.run(subcommand_name, global_options, argv, subcommand_options, log)
   end
 rescue HelpNeededError => e

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: gizzmo
 version: !ruby/object:Gem::Version 
-  hash: 45
+  hash: 43
   prerelease: 
   segments: 
   - 0
-  - 12
-  - 1
-  version: 0.12.1
+  - 13
+  - 0
+  version: 0.13.0
 platform: ruby
 authors: 
 - Kyle Maxwell
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-10-20 00:00:00 -07:00
+date: 2012-01-10 00:00:00 -08:00
 default_executable: 
 dependencies: []