vagrant-auto_network 0.2.2 → 1.0.0.beta1

checksums.yaml

@@ -1,15 +1,7 @@
 ---
-!binary "U0hBMQ==":
-  metadata.gz: !binary |-
-    NzlhOTk0NThjMzA5MTNkYzZhYzFiNTJkZDU1ODQzOGE0YWU2NDU4Mg==
-  data.tar.gz: !binary |-
-    YzIxNzVkYzI0N2RlMTkyZjAyYjA3OWNlNjgzMjhlN2JhZTcyMDlkYg==
+SHA1:
+  metadata.gz: 1d671793aef1384eda1a6563c8c5c82fb5ef080f
+  data.tar.gz: d1e246dfdc649d07761ae4d778557ff796fb66af
 SHA512:
-  metadata.gz: !binary |-
-    NGUxNjYyM2JlYTRmZTEwOTI4ZjMxZGJkMmIxMzljYjRhZjUxMzBjNmQ1NGRj
-    YTg4NjVjY2ZlNzdiOGM3ZTZhNmM4Yjk5N2QwZmIyZTAwOGY2MjNlMDFkOTVm
-    NTlmYjBlN2JiMWI3MGY4Yjg3OWUwYTQ0NWQyMjg3ZTFkYTY1MTc=
-  data.tar.gz: !binary |-
-    NjgwZTBlYmMwMmZlZTUyNjM2YTUxMWY5NDgwZDg2ZmU3ZjllYTNjNmMzOGE2
-    ZDE3NDNlNjhjZDZmNDc0MDA1MzZlNGQ2MTg5OTExOTFjMjJjMWY2YzhkMmU1
-    YjY2YTMyODY2ZmI0NjM4MmI0ZjM1YTQ4NTRiNGRkNGY2Y2QzODU=
+  metadata.gz: de702cdcb9d60ab2d1f55116b9a6d7a4cd4f392892e49fba9ae4764c87fe2c0024e6916f439f963e2bec84b77d568a6b73bef3abd427e1f0a1499bb19a7a8d77
+  data.tar.gz: e83c9eb3a06775ccf5fa59e5ab837a6d05f767f36babc1ce9ee7a5f08a1826a7ea18107df9df2df230032cc792cb377fc1da20e67538b1c53ada63f0b1c64e5d

data/.yardopts

@@ -0,0 +1 @@
+--markup markdown

data/CHANGELOG

@@ -1,6 +1,32 @@
 vagrant-auto_network
 ====================
 
+1.0.0
+-----
+
+2014-05-05
+
+This is a mostly-backwards compatible feature release.
+
+For this release, serialization format has been completely re-written to add
+support for multiple providers and to better manage global state and guard
+against race conditions. Care has been taken to support existing AutoNetwork
+environments, but it is possible that some breakage will occur.
+
+Specifically, the following issues have been addressed:
+
+  * (GH-12) Support for more than just the VirtualBox provider. The
+		implementation has been tested against the VMware Fusion provider but
+		should be general enough to support other providers as well.
+
+  * (GH-2) The infamous `0.0.0.0` hack is no longer necessary when using
+	  AutoNetwork.
+
+  * (GH-6) The IP address pools managed by AutoNetwork are now backed by a
+	  storage mechanism that offers more resiliance to race conditions and data
+		loss from aborted actions.
+
+
 0.2.2
 -----
 

data/Gemfile

@@ -1,3 +1,12 @@
 source 'https://rubygems.org'
+ruby '2.0.0'
 
 gemspec
+
+group :development do
+  gem 'vagrant', :github => 'mitchellh/vagrant', :tag => 'v1.5.4'
+end
+
+if File.exists? "#{__FILE__}.local"
+  eval(File.read("#{__FILE__}.local"), binding)
+end

data/lib/auto_network.rb

@@ -7,6 +7,7 @@ module AutoNetwork
   require 'auto_network/mixin'
   require 'auto_network/plugin'
   require 'auto_network/version'
+  require 'auto_network/pool_manager'
 end
 
 I18n.load_path << File.expand_path('../templates/locales/en.yml', File.dirname(__FILE__))

data/lib/auto_network/action/filter_networks.rb

@@ -50,7 +50,7 @@ class AutoNetwork::Action::FilterNetworks
   def assign_address(machine)
     machine_auto_networks(machine).each do |net|
       addr = @pool.address_for(machine)
-      @logger.info "Reassigning #{addr.inspect} to existing machine #{machine.id}"
+      @logger.info "Reassigning #{addr.inspect} to existing machine #{machine.name}"
       filter_private_network(net, addr)
     end
   end

data/lib/auto_network/action/load_pool.rb

@@ -1,5 +1,4 @@
 require 'auto_network'
-require 'yaml'
 
 class AutoNetwork::Action::LoadPool
 
@@ -23,7 +22,6 @@ class AutoNetwork::Action::LoadPool
       setup_ivars
       deserialize!
       @app.call(@env)
-      serialize!
     else
       @app.call(@env)
     end
@@ -41,21 +39,6 @@ class AutoNetwork::Action::LoadPool
   end
 
   def deserialize!
-    pool = nil
-    if @statefile.exist?
-      pool = YAML.load(@statefile.read)
-    else
-      range = AutoNetwork.default_pool
-      @env[:ui].info "No auto_network pool available, generating a pool with the range #{range}"
-      pool = AutoNetwork::Pool.new(range)
-    end
-    @env[:auto_network_pool] = pool
-  end
-
-  def serialize!
-    @config_path.mkpath unless @config_path.exist?
-
-    pool_data = YAML.dump(@env[:auto_network_pool])
-    @statefile.open('w') { |fh| fh.write(pool_data) }
+    @env[:auto_network_pool] = AutoNetwork::PoolManager.new(@statefile)
   end
 end

data/lib/auto_network/action/release.rb

@@ -31,7 +31,7 @@ class AutoNetwork::Action::Release
 
   def release_network_addresses
     addr = @pool.address_for(@machine)
-    @env[:ui].info "Releasing #{addr.inspect} from #{@machine.id}", :prefix => true
+    @env[:ui].info "Releasing #{addr.inspect} from #{@machine.name}", :prefix => true
     @pool.release(@machine)
   end
 end

data/lib/auto_network/action/request.rb

@@ -32,7 +32,7 @@ class AutoNetwork::Action::Request
   def request_address
     machine_auto_networks(@machine).each do |net|
       addr = @pool.request(@machine)
-      @env[:ui].info "Assigning #{addr.inspect} to '#{@machine.id}'", :prefix => true
+      @env[:ui].info "Assigning #{addr.inspect} to '#{@machine.name}'", :prefix => true
       filter_private_network(net, addr)
     end
   end

data/lib/auto_network/plugin.rb

@@ -19,14 +19,18 @@ module AutoNetwork
       hook.after(action, AutoNetwork::Action::FilterNetworks)
     end
 
-    action_hook('Auto network: request address', :machine_action_up) do |hook|
-      action = VagrantPlugins::ProviderVirtualBox::Action::Network
+    action_hook('Auto network: request address') do |hook|
+      action = Vagrant::Action::Builtin::ConfigValidate
       hook.before(action, AutoNetwork::Action::Request)
     end
 
     action_hook('Auto network: release address', :machine_action_destroy) do |hook|
-      action = VagrantPlugins::ProviderVirtualBox::Action::Destroy
-      hook.before(action, AutoNetwork::Action::Release)
+      # This is redundant, but the VirtualBox Destroy Action flushes UUID
+      # values. So we double the  hook here as it is our only chance to clean
+      # old-style IDs out of the cache.
+      hook.before(VagrantPlugins::ProviderVirtualBox::Action::Destroy, AutoNetwork::Action::Release)
+
+      hook.append(AutoNetwork::Action::Release)
     end
   end
 end

data/lib/auto_network/pool.rb

@@ -1,28 +1,43 @@
 require 'ipaddr'
+require 'vagrant/errors'
 
 module AutoNetwork
+  # The Pool is a class that manages a range of IP addresses and manages the
+  # allocation of specific addresses to individual Vagrant machines.
   class Pool
 
+    # An error class raised when no allocatable addresses remain in the Pool.
+    #
+    # @api private
     class PoolExhaustedError < Vagrant::Errors::VagrantError
       error_key(:pool_exhausted, 'vagrant_auto_network')
     end
 
-    # @param network_addr [String] The network address range to use as the
+    # @!attribute [r] network_range
+    #   @return [String] The address range manged by this Pool instance.
+    attr_reader :network_range
+
+    # Create a new Pool object that manages a range of IP addresses.
+    #
+    # @param network_range [String] The network address range to use as the
     #   address pool.
     def initialize(network_range)
       @network_range = network_range
       generate_pool
     end
 
-    # Retrieve an IP address for the given machine. If a machine already has
-    # an IP address requested, then return that.
+    # Allocate an IP address for the given machine. If a machine already has an
+    # IP address allocated, then return that.
     #
     # @param machine [Vagrant::Machine]
+    # @return [IPAddr] the IP address assigned to the machine.
+    # @raise [PoolExhaustedError] if no allocatable addresses remain in the
+    #   range managed by the pool.
     def request(machine)
       if (address = address_for(machine))
         return address
       elsif (address = next_available_lease)
-        @pool[address] = machine.id
+        @pool[address] = id_for(machine)
         return address
       else
         raise PoolExhaustedError,
@@ -31,20 +46,41 @@ module AutoNetwork
       end
     end
 
-    # Release an IP address associated with a machine
+    # Release an IP address associated with a machine.
     #
     # @param machine [Vagrant::Machine]
+    # @return [nil]
     def release(machine)
       if (address = address_for(machine))
         @pool[address] = nil
       end
     end
 
+    # Look up the address assigned to a given machine.
+    #
+    # @param machine [Vagrant::Machine]
+    # @return [IPAddr] the IP address assigned to the machine.
+    # @return [nil] if the machine has no address assigned.
     def address_for(machine)
-      return nil if machine.id.nil?
-      next_addr, _ = @pool.find { |(addr, id)| machine.id == id }
+      machine_id = id_for(machine)
+      addr, _ = @pool.find do |(addr, id)|
+        if id.is_a?(String)
+          # Check for old-style UUID values. These should eventually cycle out
+          # as machines are destroyed.
+          id == machine.id
+        else
+          id == machine_id
+        end
+      end
 
-      next_addr
+      addr
+    end
+
+    def id_for(machine)
+      {
+        'path' => machine.env.root_path.to_s,
+        'name' => machine.name.to_s,
+      }
     end
 
     private

data/lib/auto_network/pool_manager.rb

@@ -0,0 +1,130 @@
+require 'auto_network/pool'
+require 'auto_network/pool_storage'
+require 'ipaddr'
+
+module AutoNetwork
+  # The `PoolManager` class manages the mapping between providers and pools of
+  # IP addresses. Each `PoolManager` instance is backed by a file that persists
+  # state and attempts to prevent race conditions between multiple Vagrant
+  # processes.
+  #
+  # Once created, `PoolManager` instances proxy the public interface of the
+  # {AutoNetwork::Pool} instances they manage. New pools will be allocated as
+  # needed and all pool operations are wrapped in transactions that ensure
+  # state is synced to the file system.
+  #
+  # @see AutoNetwork::PoolStorage The object used to implement file-based
+  #   persistance for this class.
+  # @see AutoNetwork::Pool The objects managed by this class.
+  class PoolManager
+    # Create a new `PoolManager` instance with persistent storage.
+    #
+    # @param path [String, Pathname] the location at which to persist the state
+    #   of `AutoNetwork` pools.
+    def initialize(path)
+      # Ensure newly created files start with a skeleton data structure.
+      AutoNetwork::PoolStorage.init(path) unless File.file?(path)
+      @pool_storage = AutoNetwork::PoolStorage.new(path)
+    end
+
+    # Looks up the pool associated with the provider for a given machine and
+    # sets up a transaction where the state of the pool can be safely inspected
+    # or modified. If a pool does not exist for the machine provider, one will
+    # automatically be created.
+    #
+    # @param machine [Vagrant::Machine]
+    # @param read_only [Boolean] whether to create a read_only transaction.
+    # @yieldparam pool [AutoNetwork::Pool]
+    def with_pool_for(machine, read_only=false)
+      @pool_storage.transaction(read_only) do
+        pool = lookup_pool_for(machine)
+        pool ||= generate_pool_for(machine)
+
+        yield pool
+      end
+    end
+
+    # {include:AutoNetwork::Pool#request}
+    #
+    # @see AutoNetwork::Pool#request
+    def request(machine)
+      with_pool_for(machine) do |pool|
+        pool.request(machine)
+      end
+    end
+
+    # {include:AutoNetwork::Pool#release}
+    #
+    # @see AutoNetwork::Pool#release
+    def release(machine)
+      with_pool_for(machine) do |pool|
+        pool.release(machine)
+      end
+    end
+
+    # {include:AutoNetwork::Pool#address_for}
+    #
+    # @see AutoNetwork::Pool#address_for
+    def address_for(machine)
+      with_pool_for(machine, read_only=true) do |pool|
+        pool.address_for(machine)
+      end
+    end
+
+    private
+
+    # Retrieve the {AutoNetwork::Pool} assigned to the provider of a given
+    # machine.
+    #
+    # @note This must be executed within a transaction.
+    # @api private
+    #
+    # @param machine [Vagrant::Machine]
+    # @return [AutoNetwork::Pool] the pool associated with the machine
+    #   provider.
+    # @return [nil] if no pool exists for the machine provider.
+    def lookup_pool_for(machine)
+      @pool_storage['pools'][machine.provider_name.to_s]
+    end
+
+    # Create an {AutoNetwork::Pool} assigned to the provider of a given
+    # machine.
+    #
+    # @note This must be executed within a transaction.
+    # @api private
+    #
+    # @param machine [Vagrant::Machine]
+    # @return [AutoNetwork::Pool] the pool associated with the machine
+    #   provider.
+    def generate_pool_for(machine)
+      if lookup_pool_for(machine).nil?
+        @pool_storage['pools'][machine.provider_name.to_s] = AutoNetwork::Pool.new(next_pool_range)
+      end
+
+      lookup_pool_for(machine)
+    end
+
+    # Scan the list of allocated pools and determine the next usable address
+    # range. Assumes all Pools use a "/24" address range and share the same
+    # "/16" range.
+    #
+    # @note This must be executed within a transaction.
+    # @api private
+    #
+    # @return [String] an IP range ending in "/24".
+    def next_pool_range
+      # Fetch the list of pools under management. Return nil if no pools exist.
+      pools = @pool_storage.fetch('pools', nil)
+
+      if pools.empty?
+        # If no pools have been created, use the default range.
+        AutoNetwork.default_pool
+      else
+        # Look up the highest "XX.XX.YY.XX/24" range in use.
+        last_pool_range = IPAddr.new(pools.values.map{|v| v.network_range}.sort.last)
+        # Increment "YY" by one to generate a new "/24" range.
+        ((last_pool_range >> 8).succ << 8).to_s + '/24'
+      end
+    end
+  end
+end

data/lib/auto_network/pool_storage.rb

@@ -0,0 +1,64 @@
+require 'yaml/store'
+require 'auto_network/pool'
+
+module AutoNetwork
+  # This is a specialized subclass of `YAML::Store` that knows how to
+  # initialize and upgrade AutoNetwork Pool files.
+  #
+  # @api private
+  class PoolStorage < YAML::Store
+    POOLFILE_VERSION = 2
+    POOLFILE_SKELETON =  {
+      'poolfile_version' => POOLFILE_VERSION,
+      'pools' => {},
+    }
+
+    # Creates a new pool file at a target location and fills it with default
+    # data.
+    #
+    # @param path [String, Pathname] the location of the new pool file.
+    # @return [void]
+    def self.init(path)
+      File.write(path, POOLFILE_SKELETON.to_yaml)
+    end
+
+    private
+
+    # Override the method inherited from `YAML::Store`. All `PStore` object
+    # expect load to strictly return a `Hash`. This override allows us to
+    # perform on-the-fly upgrading of data loaded from old pool files and
+    # ensure the right structure is returned.
+    #
+    # @api private
+    #
+    # @param content [String] serialized YAML read from the pool file.
+    # @return [Hash]
+    def load(content)
+      data = super(content)
+
+      if data.is_a? AutoNetwork::Pool
+        upgrade_from_version_1! data
+      else
+        data
+      end
+    end
+
+    # The loosely defined "version 1" of the pool file just serialized a single
+    # {AutoNetwork::Pool} object. All AutoNetwork releases that used Version 1
+    # files only supported the Vagrant VirtualBox provider, so we return a new
+    # Hash-based data structure that includes the old Pool.
+    #
+    # @api private
+    #
+    # @param data [AutoNetwork::Pool] the old pool object.
+    # @return [Hash] a hash containing the old pool object.
+    def upgrade_from_version_1!(data)
+      {
+        'poolfile_version' => POOLFILE_VERSION,
+        'pools' => {
+          'virtualbox' => data,
+        },
+      }
+    end
+  end
+end

data/lib/auto_network/version.rb

@@ -1,3 +1,3 @@
 module AutoNetwork
-  VERSION = '0.2.2'
+  VERSION = '1.0.0.beta1'
 end

data/spec/auto_network/pool/pool_spec.rb

@@ -0,0 +1,71 @@
+require 'spec_helper'
+
+describe AutoNetwork::Pool do
+  let(:ip_range) { '10.20.1.0/24' }
+  let(:machine_a) do
+    machine = double(
+      :name => 'machine_a',
+      :id   => 'some-uuid',
+    )
+    machine.stub_chain(:env, :root_path, :to_s).and_return('/some/Vagrantfile')
+
+    machine
+  end
+  let(:machine_b) do
+    machine = double(
+      :name => 'machine_b',
+      :id   => 'some-uuid',
+    )
+    machine.stub_chain(:env, :root_path, :to_s).and_return('/some/Vagrantfile')
+
+    machine
+  end
+
+  subject { AutoNetwork::Pool.new(ip_range) }
+
+  describe 'requesting an address for a machine' do
+
+    it 'returns the next available address' do
+      expect(subject.request(machine_a)).to eq('10.20.1.2')
+    end
+
+    it 'is idempotent' do
+      subject.request(machine_a)
+      expect(subject.request(machine_a)).to eq('10.20.1.2')
+    end
+
+    context 'when the pool is full' do
+      subject { AutoNetwork::Pool.new('10.20.1.0/30') }
+
+      it 'raises an error' do
+        subject.request(machine_a)
+        expect { subject.request(machine_b) }.to raise_error(AutoNetwork::Pool::PoolExhaustedError)
+      end
+    end
+
+  end
+
+  describe 'releasing an address from a machine' do
+
+    it 'makes the address available' do
+      subject.request(machine_a)
+      subject.release(machine_a)
+      expect(subject.request(machine_b)).to eq('10.20.1.2')
+    end
+
+  end
+
+  describe 'looking up an address for a machine' do
+
+    it 'returns the address assigned' do
+      subject.request(machine_a)
+      expect(subject.address_for(machine_a)).to eq('10.20.1.2')
+    end
+
+    it 'returns nil for unassigned machines' do
+      expect(subject.address_for(machine_b)).to be_nil
+    end
+
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,4 @@
+$LOAD_PATH.unshift File.expand_path('../lib', __FILE__)
+
+require 'rspec'
+require 'auto_network'

data/vagrant-auto_network.gemspec

@@ -17,4 +17,6 @@ Gem::Specification.new do |gem|
   gem.require_path = 'lib'
 
   gem.license = 'Apache 2.0'
+
+  gem.add_development_dependency 'rspec', '~> 2.14.0'
 end

metadata

@@ -1,21 +1,36 @@
 --- !ruby/object:Gem::Specification
 name: vagrant-auto_network
 version: !ruby/object:Gem::Version
-  version: 0.2.2
+  version: 1.0.0.beta1
 platform: ruby
 authors:
 - Adrien Thebo
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-03-19 00:00:00.000000000 Z
-dependencies: []
+date: 2014-05-05 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.14.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.14.0
 description: 
 email: adrien@somethingsinistral.net
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- .yardopts
 - CHANGELOG
 - Gemfile
 - README.markdown
@@ -30,8 +45,12 @@ files:
 - lib/auto_network/mixin.rb
 - lib/auto_network/plugin.rb
 - lib/auto_network/pool.rb
+- lib/auto_network/pool_manager.rb
+- lib/auto_network/pool_storage.rb
 - lib/auto_network/version.rb
 - lib/vagrant-auto_network.rb
+- spec/auto_network/pool/pool_spec.rb
+- spec/spec_helper.rb
 - templates/locales/en.yml
 - vagrant-auto_network.gemspec
 homepage: https://github.com/adrienthebo/vagrant-auto_network
@@ -44,19 +63,18 @@ 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'
+      version: 1.3.1
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.1
+rubygems_version: 2.0.14
 signing_key: 
 specification_version: 4
 summary: Automatically create an internal network for all vagrant boxes
 test_files: []
-has_rdoc: