furnish-ip 0.1.0 → 0.2.0

checksums.yaml

@@ -1,15 +1,7 @@
 ---
-!binary "U0hBMQ==":
-  metadata.gz: !binary |-
-    ZjEyYTIzYTc1ZjYxNTI2YTU0NTZlODMwMDE4MjJiYzliNDMxZDUwNA==
-  data.tar.gz: !binary |-
-    MjdhMmIxMjU0YTA2MGU0NDMxMDI3YmI4M2Q3NmY2NTBjMGVlZDlmYQ==
-!binary "U0hBNTEy":
-  metadata.gz: !binary |-
-    YTllZWEwMDU2ZDNhZGY3YWIwNWY5MjEyYjgyNDEyMDI0ZDllZTM2ZGVkNzBj
-    YmQ3MmFjOTJiZWMxYzg0MzNiOTNkYjM0YmNiZWQxNWEzZDhkNDUwMDVjNDRj
-    YThmNDZlYjFmZjc2MmE0YmE2MjdjNGEwZWVjYTg2OTIwMTVmY2U=
-  data.tar.gz: !binary |-
-    ZmQyYzA3ZjE2M2I2YzQ0MzM3ODVlZjE1MmE5ZDk1YTUxMmVhMGZiOWVkM2U0
-    MGE3MjFhOTIyMTNlODI5NjA2MTU4NWQ1ZjEzNDc3ODcxOGQ4ZWY2MWY4ZGVm
-    OTc2Y2YyZDgwOWI2MWM1Y2VkNjliMGRhZDNhN2NiYmNhMWNmZDE=
+SHA1:
+  metadata.gz: 7ae2b7f6a9a956d835025a4511039237a3146583
+  data.tar.gz: 81a04a106c02e6c9cdab500831618d6eb5e9ef50
+SHA512:
+  metadata.gz: d01f9db27c11ba7b63d9cb98e0ced564ffd8efb4ffd9ee04aa2ba97e4d661d9dac3da068b0a92c63c741a7347a29c4caa87c93a016c905291de8d8feefbb4e2b
+  data.tar.gz: 82d29e0d7311b3e9890e6c127e77d7ad2afda8f9f619df264127a174cf8f46e8664b4a7959cda57cbb66aa5ce602d8b3bc168333010b420a196c68d7481c3c3f

data/CHANGELOG.md

@@ -1,3 +1,8 @@
+* 0.2.0 (05/1/2013)
+  * Most of Furnish::IP was moved to Furnish::RangeSet, which is basically the
+    same thing only without the IP limitation.
+  * Furnish::Port was created, which is quite literally Furnish::RangeSet.
+  * This release is pretty experimental and likely shouldn't be used.
 * 0.1.0 (04/10/2013)
   * Now supports Furnish 0.1.0, include protocol and property definitions and
     all Provisioners inherit from Furnish::Provisioner::API.  Recovery is still

data/README.md

@@ -1,8 +1,13 @@
 # Furnish::IP
 
-This provides 3 classes:
-
-* Furnish::IP, a simple class to maintain a grouped IP registry
+This provides 5 classes:
+
+* Furnish::RangeSet, a registry that takes its values from a range for
+  allocation purposes.
+* Furnish::IP, a simple class to maintain a grouped IP registry, derived from
+  RangeSet.
+* Furnish::Port, a simple class to maintain a grouped Port registry, also
+  derived from RangeSet.
 * Furnish::Provisioner::IP, a furnish provisioner intended to be chained to
   resources that allocate their own IP addresses for recording purposes.
 * Furnish::Provisioner::AutoIP, a furnish provisioner that works against a

data/furnish-ip.gemspec

@@ -21,7 +21,7 @@ Gem::Specification.new do |gem|
   gem.add_dependency 'palsy',   '~> 0.0.4'
 
   gem.add_development_dependency 'rake'
-  gem.add_development_dependency 'minitest', '~> 4.5.0'
+  gem.add_development_dependency 'minitest', '~> 4.7'
   gem.add_development_dependency 'guard-minitest'
   gem.add_development_dependency 'guard-rake', '~> 0.0.8'
   gem.add_development_dependency 'rdoc', '~> 4'

data/lib/furnish/ip.rb

@@ -1,27 +1,16 @@
 require 'ipaddr'
-require 'set'
+require 'furnish/range_set'
 
 module Furnish # :nodoc:
-
   #
   # Furnish::IP maintains a saved registry of IP allocations, and can be
   # instantiated any time after Furnish is.
   #
-  class IP
-
+  class IP < RangeSet
     ##
     # the subnet being worked over as an IPAddr object.
+    #
     attr_reader :subnet
-    ##
-    # the name of the registry.
-    attr_reader :name
-    ##
-    # A Palsy::Set of the sum of allocated addresses.
-    attr_reader :allocated
-    ##
-    # A Palsy::Map of the individual groups of addresses. Each item yields a
-    # set of string IP addresses.
-    attr_reader :groups
 
     #
     # Instantiate a new IP registry.
@@ -40,34 +29,8 @@ module Furnish # :nodoc:
         subnet = IPAddr.new(subnet) unless subnet.kind_of?(IPAddr)
       end
 
-      @subnet     = subnet
-      @name       = name
-      @allocated  = Palsy::Set.new('furnish_ip_allocations', name)
-      @groups     = Palsy::Map.new('furnish_ip_groups', name)
-    end
-
-    #
-    # Allocates an IP without putting it in a group. Useful for placeholders.
-    #
-    # Makes no attempt to check if something's allocated already.
-    #
-
-    def allocate(ip)
-      allocated.add(ip.encode("UTF-8"))
-    end
-
-    #
-    # Deallocates IPs from the global allocation pool. Always succeeds.
-    #
-    def deallocate(ip)
-      allocated.delete(ip.encode("UTF-8"))
-    end
-
-    #
-    # Predicate to determine whether or not an IP is already allocated.
-    #
-    def allocated?(ip)
-      allocated.include?(ip.encode("UTF-8"))
+      @subnet = subnet
+      super(subnet ? subnet.to_range : (0..0), "ip", name)
     end
 
     #
@@ -84,106 +47,7 @@ module Furnish # :nodoc:
         raise ArgumentError, "#{self.class}#unused_ip requires an IPAddr object to work"
       end
 
-      subnet_range = subnet.to_range
-
-      net = subnet
-
-      subnet_range.count.times do
-        this_ip = net.to_s.encode("UTF-8")
-
-        begin
-          unless allocated.include?(this_ip)
-            return name ? assign_group_ips(name, this_ip, true).first : this_ip
-          end
-        rescue
-        end
-
-        net = net.succ
-
-        unless subnet_range.include?(net.to_s)
-          net = subnet
-        end
-      end
-
-      raise "No free IP address for subnet #{subnet.inspect}"
-    end
-
-    #
-    # Get a set of IPs for a given group. Returns a Set object regardless of
-    # whether the group exists or not (it will just be empty).
-    #
-    def group_ips(name)
-      groups[name] || Set.new
-    end
-
-    #
-    # Overwrite a group for name with a given group.
-    #
-    def replace_group(name, group)
-      groups[name] = group
-    end
-
-    #
-    # Assign one or more ips to a group. This method is additive, so multiple
-    # calls will grow the group, not replace it.
-    #
-    def assign_group_ips(name, ips, raise_if_exists=false)
-      group = group_ips(name)
-
-      if ips.kind_of?(Array)
-        ips = Set[*ips]
-      elsif !ips.kind_of?(Set)
-        ips = Set[ips]
-      end
-
-      c_allocated = allocated.count
-      c_group = group.count
-
-      ips.each do |ip|
-        utf8_ip = ip.encode("UTF-8")
-        allocated.add(utf8_ip)
-        group.add(utf8_ip)
-      end
-
-      if raise_if_exists
-        raise unless group.count == c_group + ips.count && allocated.count == c_allocated + ips.count
-      end
-
-      replace_group(name, group)
-
-      return ips
-    end
-
-    #
-    # Remove the IPs from the group provided by name, also deallocates them.
-    #
-    def remove_from_group(name, ips)
-      group = group_ips(name)
-
-      ips.each do |ip|
-        utf8_ip = ip.encode("UTF-8")
-        deallocate(utf8_ip)
-        group.delete(utf8_ip)
-      end
-
-      replace_group(name, group)
-
-      return ips
-    end
-
-    #
-    # Remove a group and free its allocated IP addresses.
-    #
-    def decommission_group(name)
-      group = group_ips(name)
-
-      group.each do |ip|
-        deallocate(ip)
-      end
-
-      groups.delete(name)
-
-      return name
+      unused(name)
     end
   end
 end

data/lib/furnish/ip/version.rb

@@ -1,6 +1,7 @@
+require 'furnish/range_set'
 module Furnish
-  class IP
+  class IP < RangeSet
     # Version for furnish-ip
-    VERSION = "0.1.0"
+    VERSION = "0.2.0"
   end
 end

data/lib/furnish/port.rb

@@ -0,0 +1,10 @@
+require 'furnish/range_set'
+
+module Furnish # :nodoc:
+  #
+  # Furnish::Port is similar to Furnish::IP and maintains a registry of port
+  # allocations for a given host. It does not have any different API from
+  # RangeSet, it merely exists as a nicety.
+  #
+  Port = RangeSet
+end

data/lib/furnish/provisioners/auto_ip.rb

@@ -67,7 +67,7 @@ module Furnish # :nodoc:
           @controlled_ips.add(this_ip)
         end
 
-        return({ :ips => ip.group_ips(furnish_group_name) })
+        return({ :ips => ip.group_items(furnish_group_name) })
       end
 
       ##
@@ -80,7 +80,7 @@ module Furnish # :nodoc:
           ip.remove_from_group(furnish_group_name, @controlled_ips)
         end
 
-        if ip.group_ips(furnish_group_name).empty?
+        if ip.group_items(furnish_group_name).empty?
           ip.decommission_group(furnish_group_name)
         end
 
@@ -90,7 +90,7 @@ module Furnish # :nodoc:
       ##
       # Display the allocated addresses for this group.
       def report
-        ip.group_ips(furnish_group_name).to_a rescue []
+        ip.group_items(furnish_group_name).to_a rescue []
       end
     end
   end

data/lib/furnish/provisioners/ip.rb

@@ -46,8 +46,8 @@ module Furnish # :nodoc:
       #
       def startup(args={})
         @controlled_ips = args[:ips]
-        ip.assign_group_ips(furnish_group_name, @controlled_ips)
-        return({ :ips => ip.group_ips(furnish_group_name) })
+        ip.assign_group_items(furnish_group_name, @controlled_ips)
+        return({ :ips => ip.group_items(furnish_group_name) })
       end
 
       ##
@@ -58,7 +58,7 @@ module Furnish # :nodoc:
           ip.remove_from_group(furnish_group_name, @controlled_ips)
         end
 
-        if ip.group_ips(furnish_group_name).empty?
+        if ip.group_items(furnish_group_name).empty?
           ip.decommission_group(furnish_group_name)
         end
 
@@ -68,7 +68,7 @@ module Furnish # :nodoc:
       ##
       # Display the allocated addresses for this group.
       def report
-        ip.group_ips(furnish_group_name).to_a rescue []
+        ip.group_items(furnish_group_name).to_a rescue []
       end
     end
   end

data/lib/furnish/range_set.rb

@@ -0,0 +1,169 @@
+require 'set'
+
+module Furnish
+  class RangeSet
+    ##
+    # the name of the registry.
+    attr_reader :name
+
+    ##
+    # A Palsy::Set of the sum of allocated items.
+    attr_reader :allocated
+
+    ##
+    # A Palsy::Map of the individual groups of items. Each item yields a
+    # set of string item addresses.
+    attr_reader :groups
+
+    ##
+    # The range we're allocating from.
+    attr_reader :range
+
+    ##
+    # The type of thing we're allocating. No spaces.
+    attr_reader :allocation_type
+
+    #
+    # Allocate something from a range. Takes a Range object, a type of
+    # allocation (which is coerced into a table name, so be nice!) and
+    # namespace for the allocations.
+    #
+    # See Furnish::item for an example.
+    #
+    def initialize(range, allocation_type, name="default")
+      @range            = range
+      @allocation_type  = allocation_type
+      @name             = name
+
+      @allocated  = Palsy::Set.new("furnish_#{allocation_type}_allocations", name)
+      @groups     = Palsy::Map.new("furnish_#{allocation_type}_groups", name)
+    end
+
+    #
+    # Get the next unused item. Will raise if the range is exahusted
+    #
+    def unused(name=nil)
+      net = range.first
+
+      range.count.times do
+        this_item = net.to_s.encode("UTF-8")
+
+        begin
+          unless allocated.include?(this_item)
+            return name ? assign_group_items(name, this_item, true).first : this_item
+          end
+        rescue
+        end
+
+        net = net.succ
+
+        unless range.include?(net.to_s)
+          net = range.first
+        end
+      end
+
+      raise "No free #{allocation_type} for subnet #{range.inspect}"
+    end
+
+    #
+    # Allocates an item without putting it in a group. Useful for placeholders.
+    #
+    # Makes no attempt to check if something's allocated already.
+    #
+    def allocate(item)
+      allocated.add(item.encode("UTF-8"))
+    end
+
+    #
+    # Deallocates items from the global allocation pool. Always succeeds.
+    #
+    def deallocate(item)
+      allocated.delete(item.encode("UTF-8"))
+    end
+
+    #
+    # Predicate to determine whether or not an item is already allocated.
+    #
+    def allocated?(item)
+      allocated.include?(item.encode("UTF-8"))
+    end
+
+    #
+    # Get a set of items for a given group. Returns a Set object regardless of
+    # whether the group exists or not (it will just be empty).
+    #
+    def group_items(name)
+      groups[name] || Set.new
+    end
+
+    #
+    # Overwrite a group for name with a given group.
+    #
+    def replace_group(name, group)
+      groups[name] = group
+    end
+
+    #
+    # Assign one or more items to a group. This method is additive, so multitemle
+    # calls will grow the group, not replace it.
+    #
+    def assign_group_items(name, items, raise_if_exists=false)
+      group = group_items(name)
+
+      if items.kind_of?(Array)
+        items = Set[*items]
+      elsif !items.kind_of?(Set)
+        items = Set[items]
+      end
+
+      c_allocated = allocated.count
+      c_group = group.count
+
+      items.each do |item|
+        utf8_item = item.encode("UTF-8")
+        allocated.add(utf8_item)
+        group.add(utf8_item)
+      end
+
+      if raise_if_exists
+        raise unless group.count == c_group + items.count && allocated.count == c_allocated + items.count
+      end
+
+      replace_group(name, group)
+
+      return items
+    end
+
+    #
+    # Remove the items from the group provided by name, also deallocates them.
+    #
+    def remove_from_group(name, items)
+      group = group_items(name)
+
+      items.each do |item|
+        utf8_item = item.encode("UTF-8")
+        deallocate(utf8_item)
+        group.delete(utf8_item)
+      end
+
+      replace_group(name, group)
+
+      return items
+    end
+
+    #
+    # Remove a group and free its allocated item addresses.
+    #
+    def decommission_group(name)
+      group = group_items(name)
+
+      group.each do |item|
+        deallocate(item)
+      end
+
+      groups.delete(name)
+
+      return name
+    end
+  end
+end

data/test/test_auto_ip_provisioner.rb

@@ -21,11 +21,11 @@ class TestAutoIPProvisioner < Furnish::RunningSchedulerTestCase
   def test_properties
     assert_equal(
       {
-        :ip => {
+        "ip" => {
           :description => "A Furnish::IP registry object",
           :type => Furnish::IP
         },
-        :number_of_addresses => {
+        "number_of_addresses" => {
           :description => "An integer indicating the number of addresses to generate",
           :type => Integer
         }
@@ -61,10 +61,10 @@ class TestAutoIPProvisioner < Furnish::RunningSchedulerTestCase
 
     assert_solved("test1")
 
-    assert_equal(1, @ip.group_ips("test1").count, "one IP was allocated")
+    assert_equal(1, @ip.group_items("test1").count, "one IP was allocated")
     assert_equal(1, @ip.allocated.count, "reflected in the allocation count")
 
-    first_ip = @ip.group_ips("test1").first
+    first_ip = @ip.group_items("test1").first
 
     assert_equal("test1", provisioner.furnish_group_name, "name reflects provisioner name")
     assert_equal([first_ip], provisioner.report, "report reflects provisioned IPs")
@@ -74,26 +74,26 @@ class TestAutoIPProvisioner < Furnish::RunningSchedulerTestCase
 
     assert_solved("test2")
 
-    assert_equal(10, @ip.group_ips("test2").count, "ten new ips were allocated to the test2 provisioning group")
+    assert_equal(10, @ip.group_items("test2").count, "ten new ips were allocated to the test2 provisioning group")
     assert_equal(11, @ip.allocated.count, "a total of 11 IPs are allocated now, across the two groups")
 
     sched.teardown_group("test1")
 
     refute_solved("test1")
-    assert_equal(0, @ip.group_ips("test1").count, "deprovisioning deallocates the IP group")
+    assert_equal(0, @ip.group_items("test1").count, "deprovisioning deallocates the IP group")
     assert_equal(10, @ip.allocated.count, "ten IPs now, reflecting the loss of the one in this group")
 
     sched.teardown_group("test2")
 
     refute_solved("test2")
-    assert_equal(0, @ip.group_ips("test2").count, "deprovisioning deallocates the IP group")
+    assert_equal(0, @ip.group_items("test2").count, "deprovisioning deallocates the IP group")
     assert_equal(0, @ip.allocated.count, "no IPs left in allocation group")
 
     sched.schedule_provision("test1", make_provisioner, [])
     sched.wait_for("test1")
 
     assert_solved("test1")
-    assert_equal(first_ip, @ip.group_ips("test1").first, "provisioner re-uses deprovisioned IP addresses")
+    assert_equal(first_ip, @ip.group_items("test1").first, "provisioner re-uses deprovisioned IP addresses")
   end
 
   def test_multi_provision
@@ -105,8 +105,8 @@ class TestAutoIPProvisioner < Furnish::RunningSchedulerTestCase
     sched.wait_for("first", "second")
     assert_solved("first")
     assert_solved("second")
-    assert_equal(5, @ip.group_ips("first").count)
-    assert_equal(5, @ip.group_ips("second").count)
+    assert_equal(5, @ip.group_items("first").count)
+    assert_equal(5, @ip.group_items("second").count)
     assert_equal(10, @ip.allocated.count)
 
     sched.deprovision_group("first")
@@ -119,10 +119,10 @@ class TestAutoIPProvisioner < Furnish::RunningSchedulerTestCase
 
     sched.s("both", [first, second])
     sched.wait_for("both")
-    assert_equal(10, @ip.group_ips("both").count)
+    assert_equal(10, @ip.group_items("both").count)
     assert_equal(10, @ip.allocated.count)
     sched.teardown
-    assert_equal(0, @ip.group_ips("both").count)
+    assert_equal(0, @ip.group_items("both").count)
     assert_equal(0, @ip.allocated.count)
   end
 end

data/test/test_ip_lib.rb

@@ -38,8 +38,8 @@ class TestIPLib < Furnish::TestCase
     ip.allocate("127.0.0.42".encode("ASCII-8BIT"))
     assert(ip.allocated?("127.0.0.42".encode("UTF-8")), "127.0.0.42 was allocated encoding-agnostic")
 
-    ip.assign_group_ips("foo", "127.0.0.23".encode("ASCII-8BIT"))
-    assert_equal("UTF-8", ip.group_ips("foo").first.encoding.to_s, "encoding always comes back UTF-8")
+    ip.assign_group_items("foo", "127.0.0.23".encode("ASCII-8BIT"))
+    assert_equal("UTF-8", ip.group_items("foo").first.encoding.to_s, "encoding always comes back UTF-8")
   end
 
   def test_allocated
@@ -47,7 +47,7 @@ class TestIPLib < Furnish::TestCase
     ip.allocate("127.0.0.0")
     assert(ip.allocated?("127.0.0.0"), "127.0.0.0 is allocated")
 
-    ip.assign_group_ips("foo", "127.0.0.1")
+    ip.assign_group_items("foo", "127.0.0.1")
 
     assert(ip.allocated?("127.0.0.1"), "127.0.0.1 is allocated by way of a group")
   end
@@ -55,15 +55,15 @@ class TestIPLib < Furnish::TestCase
   def test_cycle_detection
     ip = Furnish::IP.new(IPAddr.new("127.0.0.1/31"))
 
-    2.times { ip.assign_group_ips("test", ip.unused_ip) }
+    2.times { ip.assign_group_items("test", ip.unused_ip) }
 
     assert_raises(RuntimeError, "No free IP address for subnet #{ip.inspect}") { ip.unused_ip }
   end
 
   def test_group_management
     ip = Furnish::IP.new(IPAddr.new("127.0.0.1/24"))
-    assert_kind_of(Set, ip.group_ips("foo"), "a non-existent group always returns an empty set")
-    assert_empty(ip.group_ips("foo"), "a non-existent group always returns an empty set")
+    assert_kind_of(Set, ip.group_items("foo"), "a non-existent group always returns an empty set")
+    assert_empty(ip.group_items("foo"), "a non-existent group always returns an empty set")
 
     allocated = Set.new
 
@@ -73,11 +73,11 @@ class TestIPLib < Furnish::TestCase
 
     assert_equal(
       Set[ip_arg],
-      ip.assign_group_ips("foo", ip_arg),
+      ip.assign_group_items("foo", ip_arg),
       "single argument is returned as a set"
     )
 
-    assert_equal(Set[ip_arg], ip.group_ips("foo"), "returned as set from group_ips")
+    assert_equal(Set[ip_arg], ip.group_items("foo"), "returned as set from group_items")
 
     unused_ip = ip.unused_ip
     ip_arg = Set[unused_ip, unused_ip.succ, unused_ip.succ.succ]
@@ -86,18 +86,18 @@ class TestIPLib < Furnish::TestCase
 
     assert_equal(
       ip_arg,
-      ip.assign_group_ips("bar", ip_arg.to_a),
+      ip.assign_group_items("bar", ip_arg.to_a),
       "set is returned when array passed"
     )
 
-    assert_equal(Set[*ip_arg], ip.group_ips("bar"), "returned as set from group_ips")
+    assert_equal(Set[*ip_arg], ip.group_items("bar"), "returned as set from group_items")
     assert_equal(allocated, allocated & ip.allocated.to_set, "group IPs are in the allocation table")
 
     ip.decommission_group("foo")
     ip.decommission_group("bar")
 
-    assert_empty(ip.group_ips("foo"), "group foo has been deallocated")
-    assert_empty(ip.group_ips("bar"), "group bar has been deallocated")
+    assert_empty(ip.group_items("foo"), "group foo has been deallocated")
+    assert_empty(ip.group_items("bar"), "group bar has been deallocated")
     assert_empty(ip.allocated.to_set, "nothing in the allocation table since deprovisioning groups")
   end
 end

data/test/test_ip_provisioner.rb

@@ -55,7 +55,7 @@ class TestIPProvisioner < Furnish::RunningSchedulerTestCase
   def test_properties
     assert_equal(
       {
-        :ip => {
+        "ip" => {
           :description => "A Furnish::IP registry object",
           :type => Furnish::IP
         }
@@ -103,7 +103,7 @@ class TestIPProvisioner < Furnish::RunningSchedulerTestCase
     count = ips.count
 
     assert_solved("test1")
-    assert_equal(count, @ip.group_ips("test1").count, "#{count} IPs were allocated")
+    assert_equal(count, @ip.group_items("test1").count, "#{count} IPs were allocated")
     assert_equal(count, @ip.allocated.count, "#{count} IPs were allocated")
 
     assert_equal("test1", provisioner.last.furnish_group_name, "name reflects group name")
@@ -117,7 +117,7 @@ class TestIPProvisioner < Furnish::RunningSchedulerTestCase
     sched.wait_for("test2")
 
     assert_solved("test2")
-    assert_equal(ips.count, @ip.group_ips("test2").count, "#{ips.count} IPs were allocated")
+    assert_equal(ips.count, @ip.group_items("test2").count, "#{ips.count} IPs were allocated")
     assert_equal(count, @ip.allocated.count, "between both groups, #{count} IPs were allocated")
 
     count -= ips.count
@@ -125,11 +125,11 @@ class TestIPProvisioner < Furnish::RunningSchedulerTestCase
     sched.teardown_group("test2")
 
     refute_solved("test2")
-    assert_empty(@ip.group_ips("test2"), "torn down group is empty")
+    assert_empty(@ip.group_items("test2"), "torn down group is empty")
     assert_equal(count, @ip.allocated.count, "count is correct (#{count}) after deprovisioning one group")
 
     sched.teardown_group("test1")
-    assert_empty(@ip.group_ips("test1"), "torn down group is empty")
+    assert_empty(@ip.group_items("test1"), "torn down group is empty")
     assert_equal(0, @ip.allocated.count, "count is zero after deprovisioning all groups")
   end
 
@@ -143,19 +143,19 @@ class TestIPProvisioner < Furnish::RunningSchedulerTestCase
     sched.s("first", first)
     sched.wait_for("first")
     assert_solved("first")
-    assert_equal(first_ips.count, @ip.group_ips("first").count, "#{first_ips.count} IPs were allocated")
+    assert_equal(first_ips.count, @ip.group_items("first").count, "#{first_ips.count} IPs were allocated")
     assert_equal(first_ips.count, @ip.allocated.count, "#{first_ips.count} IPs were allocated")
     sched.deprovision_group("first")
-    assert_equal(0, @ip.group_ips("first").count, "count is zero after deprovision")
+    assert_equal(0, @ip.group_items("first").count, "count is zero after deprovision")
     assert_equal(0, @ip.allocated.count, "count is zero after deprovision")
 
     sched.s("second", second)
     sched.wait_for("second")
     assert_solved("second")
-    assert_equal(second_ips.count, @ip.group_ips("second").count, "#{second_ips.count} IPs were allocated")
+    assert_equal(second_ips.count, @ip.group_items("second").count, "#{second_ips.count} IPs were allocated")
     assert_equal(second_ips.count, @ip.allocated.count, "#{second_ips.count} IPs were allocated")
     sched.deprovision_group("second")
-    assert_equal(0, @ip.group_ips("second").count, "count is zero after deprovision")
+    assert_equal(0, @ip.group_items("second").count, "count is zero after deprovision")
     assert_equal(0, @ip.allocated.count, "count is zero after deprovision")
 
     sched.s("test1", first + second)
@@ -163,10 +163,10 @@ class TestIPProvisioner < Furnish::RunningSchedulerTestCase
 
     assert_solved("test1")
     total = first_ips.count + second_ips.count
-    assert_equal(total, @ip.group_ips("test1").count, "#{total} IPs were allocated")
+    assert_equal(total, @ip.group_items("test1").count, "#{total} IPs were allocated")
     assert_equal(total, @ip.allocated.count, "#{total} IPs were allocated")
     sched.deprovision_group("test1")
-    assert_equal(0, @ip.group_ips("test1").count, "count is zero after deprovision")
+    assert_equal(0, @ip.group_items("test1").count, "count is zero after deprovision")
     assert_equal(0, @ip.allocated.count, "count is zero after deprovision")
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: furnish-ip
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Erik Hollensbe
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-04-10 00:00:00.000000000 Z
+date: 2013-05-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: furnish
@@ -42,14 +42,14 @@ dependencies:
   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
@@ -58,26 +58,26 @@ dependencies:
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: 4.5.0
+        version: '4.7'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: 4.5.0
+        version: '4.7'
 - !ruby/object:Gem::Dependency
   name: guard-minitest
   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
@@ -112,28 +112,28 @@ dependencies:
   name: rb-fsevent
   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: simplecov
   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'
 description: Generic IP allocator for the Furnish provisioning system
@@ -153,8 +153,10 @@ files:
 - furnish-ip.gemspec
 - lib/furnish/ip.rb
 - lib/furnish/ip/version.rb
+- lib/furnish/port.rb
 - lib/furnish/provisioners/auto_ip.rb
 - lib/furnish/provisioners/ip.rb
+- lib/furnish/range_set.rb
 - test/helper.rb
 - test/test_auto_ip_provisioner.rb
 - test/test_ip_lib.rb
@@ -168,12 +170,12 @@ 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: []