rangeclient 0.0.3 → 0.0.5

data/bin/er

@@ -0,0 +1,60 @@
+#!/usr/bin/ruby
+
+require 'rubygems'
+require 'rangeclient'
+
+require 'optparse'
+require 'ostruct'
+options = {
+  :timeout => 60,
+}
+optparse = OptionParser.new do |opts|
+  opts.on('-e', '--expand', 'Print one element per line') do |arg|
+    options[:expand] = arg 
+  end
+  opts.on('-c', '--count', 'Print the count of range elements, not the range itself') do |arg|
+    options[:count] = arg 
+  end
+  opts.on('-v', '--vip range:80', 'Which host or host:port to query') do |arg|
+    options[:vip] = arg 
+  end
+  opts.on('-p', '--port 80', 'Port to use when connecting') do |arg|
+    options[:port] = arg 
+  end
+  opts.on('-t', '--timeout', "Wait this long for a response ") do |arg|
+    options[:timeout] = arg 
+  end
+  opts.on('-h', '--help', "Usage ") do |arg|
+    options[:verbose] = arg 
+  end
+end
+optparse.parse!
+
+range = Range::Client.new
+
+in_range = ARGV.join ','
+
+raise "No range given" if in_range.empty?
+
+if in_range  == '-'
+  in_range = STDIN.readlines.map { |l| l.chomp }.join ','
+end
+
+nodes = range.expand(in_range)
+
+if options[:count]
+  # if counting, return count
+  puts nodes.size
+elsif not nodes.size.zero?
+  # if we got a result, display it accordingly
+  if options[:expand]
+    nodes.each do |node|
+      puts node
+    end
+  else
+    puts range.compress(nodes)
+  end
+else
+  # no nodes returned.
+  raise "No nodes specified"
+end

data/lib/rangeclient.rb

@@ -6,6 +6,13 @@ require 'cgi'
 
 class Range::Client
 
+  # used to split hostnames into component parts for compression
+  @@NodeRegx = /
+                 ([-\w.]*?)                                # $1 - prefix
+                 (\d+)                                     # $2 - start of range
+                 (\.[-A-Za-z\d.]*[-A-Za-z]+[-A-Za-z\d.]*)? # optional domain
+               /x;
+
   def initialize(options = {})
     default_host = 'range'
     default_host = ENV['RANGE_HOST'] if ENV.has_key?('RANGE_HOST')
@@ -23,10 +30,163 @@ class Range::Client
     return res.split "\n"
   end
 
-  def compress(names)
-    escaped_arg = CGI.escape names.join ","
-    return RestClient.get "http://#{@options[:host]}:#{@options[:port]}/range/expand?#{escaped_arg}"
+
+# Keep this extremely basic code for reference
+#  def compress(nodes)
+#    escaped_arg = CGI.escape nodes.join ","
+#    return RestClient.get "http://#{@options[:host]}:#{@options[:port]}/range/expand?#{escaped_arg}"
+#  end
+
+# Take a page from the Perl Seco::Data::Range and perform this locally -- more efficient in both speed/size
+# This was ported over from the Perl version, so it's not quite idiomatic ruby
+
+  def compress(nodes)
+    domain_tbl = {}
+    no_domain_list = []
+    nodes.each do |n|
+      # If this is a quoted range, just compress it without collapsing
+      return _simple_compress(nodes) if n =~ /^(?:"|q\()/
+
+      # Break out host and key by domain, to enable {foo1,foo3}.bar.com grouping
+      host, domain = n.split('.', 2)
+      if domain
+        domain_tbl[domain] ||= []
+        domain_tbl[domain] << host
+      else
+        no_domain_list << host
+      end
+    end
+    result = []
+    # Range elements with no domain component do not group
+    # just return
+    if not no_domain_list.empty?
+      result << _simple_compress(no_domain_list)
+    end
+
+    domain_tbl.keys.sort.each do |domain|
+      r = _extra_compress(domain_tbl[domain])
+      r.gsub!(/\.#{domain},/) {","}
+      r.gsub!(/\.#{domain}$/) {""}
+      if r=~ /,/
+        r = "{#{r}}"
+      end
+      result << "#{r}.#{domain}" 
+    end
+    return result.join ","
   end
+
+  def _extra_compress(nodes)
+    domains = {}
+    nodes = nodes.dup
+    nodes.each do |node|
+      node.gsub!(/^([a-z]+)(\d+)([a-z]\w+)\./) { "#{$1}#{$2}.UNDOXXX#{$3}." }
+    end
+    result = _simple_compress(nodes)
+    result.each do |r|
+      r.gsub!(/(\d+\.\.\d+)\.UNDOXXX/) {"{#{$1}}"}
+      r.gsub!(/(\d+)\.UNDOXXX/) {"#{$1}"}
+    end
+    return result
+  end
+
+  def _simple_compress(nodes)
+    # dedup nodes
+    set = {}
+    nodes.each do |node|
+      set[node] = true
+    end
+    nodes = set.keys
+    nodes = _sort_nodes(nodes)
+
+    result = []
+    prev_prefix, prev_digits, prev_suffix =  "", nil, ""
+    prev_n = nil
+    count = 0
+
+    nodes.each do |n|
+      if n =~ /\A#{@@NodeRegx}\z/
+        # foo100abc => foo 100 abc
+        prefix, digits, suffix = $1, $2, $3
+        prefix = "" if prefix.nil?
+        suffix = "" if suffix.nil?
+      else
+        prefix, digits, suffix = n, nil, nil
+      end
+      if (not digits.to_i.zero?) and
+          (prefix == prev_prefix) and
+          (suffix == prev_suffix) and
+          (not prev_digits.nil?) and
+          (digits.to_i == prev_digits.to_i + count + 1)
+        count += 1
+        next
+      end
+      
+      if prev_n
+        if count > 0
+          result << _get_group(prev_prefix, prev_digits, count, prev_suffix)
+        else
+          result << prev_n
+        end
+      end
+      prev_n = n
+      prev_prefix = prefix
+      prev_digits = digits
+      prev_suffix = suffix
+      count = 0
+    end #nodes.each
+
+    if count > 0
+      result << _get_group(prev_prefix, prev_digits, count, prev_suffix)
+    else
+      result << prev_n
+    end
+    return result.join ","
+  end
+
+  def _sort_nodes(nodes)
+    sorted = nodes.map { |n|
+      # decorate-sort-undecorate
+      # FIXME can this all be pushed into sort_by?
+      n =~ /\A#{@@NodeRegx}\z/
+
+      [ n,
+        $1.nil? ? "" : $1,
+        $2.nil? ? 0 : $2.to_i,
+        $3.nil? ? "" : $3,
+      ]
+    }.sort_by { |e|
+      [ e[1], e[3], e[2], e[0] ]
+    }.map { |n|
+      n[0]
+    }
+    return sorted
+  end
+
+  def _get_group(prefix, digits, count, suffix)
+    prefix = "" if prefix.nil?
+    group = sprintf("%s%0*d..%s",
+                    prefix,
+                    digits.to_s.length, 
+                    digits,
+                    _ignore_common_prefix(digits, (digits.to_i + count).to_s)
+                    )
+    suffix = "" if suffix.nil?
+    return group + suffix
+  end
+
+  def _ignore_common_prefix(start_pos, end_pos)
+    len_start = start_pos.to_s.length
+    return end_pos if len_start < end_pos.to_s.length
+    pick = 0
+    len_start.times do |i|
+      pick = i
+      # find the point at which the two strings deviate
+      break if (start_pos[0..i] != end_pos[0..i])
+    end
+    # and return that substring prior to deviation
+    return end_pos[pick..-1]
+  end
+
 end
 
 if __FILE__ == $0

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: rangeclient
 version: !ruby/object:Gem::Version 
-  hash: 25
+  hash: 21
   prerelease: 
   segments: 
   - 0
   - 0
-  - 3
-  version: 0.0.3
+  - 5
+  version: 0.0.5
 platform: ruby
 authors: 
 - Evan Miller
@@ -15,10 +15,10 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2012-05-16 00:00:00 Z
+date: 2013-02-28 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
-  name: rdoc
+  name: rest-client
   prerelease: false
   requirement: &id001 !ruby/object:Gem::Requirement 
     none: false
@@ -31,20 +31,6 @@ dependencies:
         version: "0"
   type: :runtime
   version_requirements: *id001
-- !ruby/object:Gem::Dependency 
-  name: rest-client
-  prerelease: false
-  requirement: &id002 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 3
-        segments: 
-        - 0
-        version: "0"
-  type: :runtime
-  version_requirements: *id002
 description: Use with ranged from https://github.com/ytoolshed/range
 email: 
 - evan@squareup.com
@@ -56,6 +42,7 @@ extra_rdoc_files:
 - LICENSE.md
 files: 
 - lib/rangeclient.rb
+- bin/er
 - README.md
 - LICENSE.md
 homepage: https://github.com/square/prodeng/tree/master/ruby_rangeclient