vagrant-nixos-plugin 0.0.6 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c737e0645fac2818dd42a92841b641922710b899
-  data.tar.gz: 4b2af76eac1964a5faddad7e5f375e1d337668b6
+  metadata.gz: c911867561067b8671b40f4b276be48f34cb9370
+  data.tar.gz: 226ab372bd8459b6bc873ab2b6c468d530598895
 SHA512:
-  metadata.gz: 7b11d262f33643617ac54812edb26f3be635fdf21f17c6bc782ea9f185a3520ab6541105c0dc0083391525775706a395ac4ae833d3d2cf8f9771be76970f269f
-  data.tar.gz: 435f35e02644364e68a5f95655fe549047d5e2e8845797d173547f58a32bfee174c3f045123955d7280886ece3c0773806e207255ff234807603b7bddd352886
+  metadata.gz: 4c27a65d2dd4fd2c4c109854ca62bb4d359b54e536648be0deb5ef4ae4a3ee102a251ebf0b414d30480cb7868e749be4336e1108d90771d448dfba664ced096d
+  data.tar.gz: a7ffeadd3f6495e5bc8caf29ce45d710e2614407d5c66bdcdb03d499a8d182506006c2364fcd87c9ba0bc521560d0495417c8be24e3e8392e4985d8d56de5cc0

data/History.md

@@ -0,0 +1,21 @@
+
+0.1.1 / 2015-10-18
+==================
+
+Previous release was a bit hasty
+
+  * Misc cleanup and fixes
+
+0.1.0 / 2015-10-18
+==================
+
+Big refactor / fork of the vagrant-nixos plugin.
+
+Vagrant 1.6.4+ has capabilities to setup the hostname and networking by
+writing to /etc/nixos/vagrant-hostname.nix and
+/etc/nixos/vagrant-networking.nix respectively but doesn't run
+`nixos-rebuild switch`.
+
+This is a complementary plugin that just takes care of the provisioning. All
+of the nice Nix+ruby DLS is from the original plugin.
+

data/LICENSE.txt

@@ -1,4 +1,4 @@
-Copyright (c) 2014 Chris Farmiloe
+Copyright (c) 2014 Chris Farmiloe, 2015 zimbatm
 
 MIT License
 

data/README.md

@@ -1,10 +1,14 @@
 # NixOS Vagrant Plugin
 
-This plugin makes working with [NixOS](http://nixos.org) guests in [Vagrant](http://www.vagrantup.com) a bit nicer:
+This plugin adds nix provisioning for [NixOS](http://nixos.org) guests to
+[Vagrant](http://www.vagrantup.com).
 
-* Allow network configurations
-* Allow hostname setting
-* Provide nix provisioning
+Vagrant 1.6.4+ itself already provides capabilities to change the hostname and
+networking settings by generating `/etc/nixos/vagrant-{network,hostname}.nix`
+files but then doesn't invoke `nixos-rebuild switch`.
+
+This plugin takes care of that, plus gives different ways for the user to
+configure the VM using a special DSL.
 
 ## Install:
 
@@ -20,35 +24,40 @@ $ vagrant plugin install vagrant-nixos-plugin
 ```ruby
 Vagrant.configure("2") do |config|
 
-	# use a suitable NixOS base
-	# http://github.com/oxdi/nixos
-	config.vm.box = "nixos-14.02-x86_64"
-	config.vm.box_url = "http://s3.amazonaws.com/oxdi/nixos-14.02-x86_64-virtualbox.box"
-  	
-  	# set hostname
-  	config.vm.hostname = "nixy"
-  
-  	# Setup networking
-	config.vm.network "private_network", :ip => "172.16.16.16"
-
-	# Add the htop package
-	config.vm.provision :nixos, :expression => {
-		environment: {
-			systemPackages: [ :htop ]
-		}
-	}
+  # Use a suitable NixOS base. VM built with nixbox are tested to work with
+  # this plugin.
+  config.vm.box = "zimbatm/nixos-15.09-x86_64"
+
+  # set hostname
+  config.vm.hostname = "nixy"
+
+  # Setup networking
+  config.vm.network "private_network", ip: "172.16.16.16"
+
+  # Add the htop package
+  config.vm.provision :nixos, expression: {
+    environment: {
+      systemPackages: [ :htop ]
+    }
+  }
 
 end
 ```
 
-In the above `Vagrantfile` example we provision the box using the `:expression` method, which will perform a simple ruby -> nix conversion. `:expression` provisioning creates a nix module that executes with `pkgs` in scope. It is roughly equivilent to the below version that uses the `:inline` method.
+In the above `Vagrantfile` example we provision the box using the
+`:expression` method, which will perform a simple ruby -> nix conversion.
+`:expression` provisioning creates a nix module that executes with `pkgs` in
+scope. It is roughly equivilent to the below version that uses the `:inline`
+method.
 
 ```ruby
-config.vm.provision :nixos, :inline => %{
-	{config, pkgs, ...}: with pkgs; {
-		environment.systemPackages = [ htop ];
-	}
-}, :NIX_PATH => "/custom/path/to/nixpkgs"
+config.vm.provision :nixos,
+  inline: %{
+{config, pkgs, ...}: with pkgs; {
+  environment.systemPackages = [ htop ];
+}
+  },
+  NIX_PATH: "/custom/path/to/nixpkgs"
 ```
 
 The above example also shows the optional setting of a custom `NIX_PATH` path.
@@ -56,56 +65,65 @@ The above example also shows the optional setting of a custom `NIX_PATH` path.
 You can also use an external nix configuration file:
 
 ```ruby
-config.vm.provision :nixos, :path => “configuration.nix”
+config.vm.provision :nixos, path: "configuration.nix"
 ```
 
 If you need provisioning to be included explicitly during rebuild use:
 
 ```ruby
 config.vm.provision :nixos,
-	:path => “configuration.nix”,
-	:include => true
+  path: “configuration.nix”,
+  include: true
 ```
 
 You can enable verbose provision output during rebuild process with:
 
 ```ruby
 config.vm.provision :nixos,
-	:path => “configuration.nix”,
-	:verbose => true
+  path: “configuration.nix”,
+  verbose: true
 ```
 
-If you need to use functions or access values using dot syntax you can use the `Nix` module:
+If you need to use functions or access values using dot syntax you can use the
+`Nix` module:
 
 ```ruby
-config.vm.provision :nixos, :expression => {
-	services: {
-		postgresql: {
-			enable: true,
-			package: Nix.pkgs.postgresql93,
-			enableTCPIP: true,
-			authentication: Nix.lib.mkForce(%{
-				local all all              trust
-				host  all all 127.0.0.1/32 trust
-			}),
-			initialScript: "/etc/nixos/postgres.sql"
-		}
-	}
-}	
+config.vm.provision :nixos, expression: {
+  services: {
+    postgresql: {
+      enable: true,
+      package: Nix.pkgs.postgresql93,
+      enableTCPIP: true,
+      authentication: Nix.lib.mkForce(%{
+        local all all              trust
+        host  all all 127.0.0.1/32 trust
+      }),
+      initialScript: "/etc/nixos/postgres.sql"
+    }
+  }
+}
 ```
 
 
 ## How it works
 
-In nixos we don't mess around with the files in `/etc` instead we write expressions for the system configuration starting in `/etc/nixos/configuration.nix`.
+In nixos we don't mess around with the files in `/etc` instead we write
+expressions for the system configuration starting in
+`/etc/nixos/configuration.nix`.
 
-This plugin sets some ground rules for nixos boxes to keep this configuration clean and provisioning possible.
+This plugin sets some ground rules for nixos boxes to keep this configuration
+clean and provisioning possible.
 
-Box creators should ensure that their `configuration.nix` file imports an nix module `/etc/nixos/vagrant.nix` which will be overwritten by `vagrant-nixos-plugin` during `vagrant up` or `vagrant provision`.
+Box creators should ensure that their `configuration.nix` file imports an nix
+module `/etc/nixos/vagrant.nix` which will be overwritten by
+`vagrant-nixos-plugin` during `vagrant up` or `vagrant provision`.
 
-See the configuration in our [NixOS packer template](http://github.com/oxdi/nixos) for an example.
+See the configuration in our
+[NixOS packer template](http://github.com/zimbatm/nixbox) for an example.
 
 ## Issues
 
-It's a bit slow on the initial boot/provision at the moment as it must run nixos-rebuild several times. This is far from ideal I'm sure I'll find a better place to hook in the rebuild step soon.
+It's a bit slow on the initial boot/provision at the moment as it must run
+nixos-rebuild several times. This is far from ideal I'm sure I'll find a
+better place to hook in the rebuild step soon.
 

data/lib/vagrant-nixos-plugin.rb

@@ -1,17 +1,3 @@
-require "vagrant-nixos/version"
-require "vagrant-nixos/plugin"
-require "vagrant-nixos/util"
-require "vagrant-nixos/nix"
-
-module VagrantPlugins
-	module Nixos
-		lib_path = Pathname.new(File.expand_path("../nixos", __FILE__))
-		autoload :Action, lib_path.join("action")
-		autoload :Errors, lib_path.join("errors")
-
-	    # This returns the path to the source of this plugin.
-	    def self.source_root
-	    	@source_root ||= Pathname.new(File.expand_path("../../../", __FILE__))
-	    end
-	end
-end
+require 'vagrant-nixos/version'
+require 'vagrant-nixos/plugin'
+require 'vagrant-nixos/nix'

data/lib/vagrant-nixos/config.rb

@@ -1,51 +1,78 @@
 module VagrantPlugins
-	module Nixos
-		class Config < Vagrant.plugin("2", :config)
-			attr_accessor :inline
-			attr_accessor :path
-			attr_accessor :expression
-			attr_accessor :include
-			attr_accessor :verbose
-			attr_accessor :NIX_PATH
-
-			def initialize
-				@inline      = UNSET_VALUE
-				@path        = UNSET_VALUE
-				@expression  = UNSET_VALUE
-				@include     = UNSET_VALUE
-				@verbose     = UNSET_VALUE
-				@NIX_PATH    = UNSET_VALUE
-			end
-
-			def finalize!
-				@inline      = nil if @inline == UNSET_VALUE
-				@path        = nil if @path == UNSET_VALUE
-				@expression  = nil if @expression == UNSET_VALUE
-				@include     = nil if @include == UNSET_VALUE
-				@verbose     = nil if @verbose == UNSET_VALUE
-				@NIX_PATH    = nil if @NIX_PATH == UNSET_VALUE
-			end
-
-			def expression=(v)
-				@expression = v.to_nix
-			end
-
-			def validate(machine)
-				errors = _detected_errors
-
-				if (path && inline) or (path && expression) or (inline && expression)
-					errors << "You can have one and only one of :path, :expression or :inline for nixos provisioner"
-				elsif !path && !inline && !expression
-					errors << "Missing :inline, :expression or :path for nixos provisioner"
-				end
-
-				if path && !File.exist?(path)
-					errors << "Invalid path #{path}"
-				end
-
-				{ "nixos provisioner" => errors }
-			end
-
-		end
-	end
+  module Nixos
+    class Config < Vagrant.plugin("2", :config)
+      # Some inline nix configuration data
+      # @return [String, nil]
+      attr_accessor :inline
+
+      # The path to some nix configuration file
+      # @return [String, nil]
+      attr_accessor :path
+
+      # Some inline ruby DSL that generates nix configuration data
+      # @return [Hash, nil]
+      attr_accessor :expression
+
+      # Include /etc/nixos/vagrant.nix in the build
+      # @return [true, false]
+      attr_accessor :include
+
+      # Show debug information during the build
+      # @return [true, false]
+      attr_accessor :verbose
+
+      # Override the default NIX_PATH
+      # @return [String, nil]
+      attr_accessor :NIX_PATH
+
+      # Configure which files to import in the vagrant.nix file
+      # @return [Array<String>]
+      attr_accessor :imports
+
+      def initialize
+        @inline      = UNSET_VALUE
+        @path        = UNSET_VALUE
+        @expression  = UNSET_VALUE
+        @include     = UNSET_VALUE
+        @verbose     = UNSET_VALUE
+        @NIX_PATH    = UNSET_VALUE
+        @imports     = [
+          "./vagrant-network.nix",
+          "./vagrant-hostname.nix",
+          "./vagrant-provision.nix",
+        ]
+      end
+
+      def finalize!
+        @inline      = nil    if @inline      == UNSET_VALUE
+        @path        = nil    if @path        == UNSET_VALUE
+        @expression  = nil    if @expression  == UNSET_VALUE
+        @include     = false  if @include     == UNSET_VALUE
+        @verbose     = false  if @verbose     == UNSET_VALUE
+        @NIX_PATH    = nil    if @NIX_PATH    == UNSET_VALUE
+      end
+
+      def expression=(v)
+        @expression = v.to_nix
+      end
+
+      def validate(machine)
+        errors = _detected_errors
+
+        if (path && inline) or (path && expression) or (inline && expression)
+          errors << "You can have one and only one of :path, :expression or :inline for nixos provisioner"
+        end
+
+        if path && !File.exist?(path)
+          errors << "Invalid path #{path}"
+        end
+
+        unless imports.is_a?(Array)
+          errors << "Expected imports to be an array of paths"
+        end
+
+        { "nixos provisioner" => errors }
+      end
+    end
+  end
 end

data/lib/vagrant-nixos/nix.rb

@@ -4,91 +4,91 @@
 #################################################
 
 module Nix
-	INDENT_STRING="  "
+  INDENT_STRING="  "
 
-	def self.method_missing(m, *args, &block)
-		NixBuilder.new(nil, m.to_sym, *args)
-	end
+  def self.method_missing(m, *args, &block)
+    NixBuilder.new(nil, m.to_sym, *args)
+  end
 
-	class NixBuilder
+  class NixBuilder
 
-		attr_accessor :exprs
-		attr_accessor :parent
+    attr_accessor :exprs
+    attr_accessor :parent
 
-		def initialize(parent, expr, *args)
-			@parent = parent
-			@exprs  = args.inject([expr]){|exs, e| exs << e}
-		end
+    def initialize(parent, expr, *args)
+      @parent = parent
+      @exprs  = args.inject([expr]){|exs, e| exs << e}
+    end
 
-		def method_missing(m, *args, &block)
-			NixBuilder.new(self, m.to_sym, *args)
-		end
+    def method_missing(m, *args, &block)
+      NixBuilder.new(self, m.to_sym, *args)
+    end
 
-		def to_nix(indent = 0)
-			s = ""
-			s << "(" if @exprs[0] == :import
-			if @parent
-				s = @parent.to_nix << "."
-			end
-			s << @exprs.map{|e| e.to_nix}.join(" ")
-			s << ")" if @exprs[0] == :import
-			s
-		end
-	end
+    def to_nix(indent = 0)
+      s = ""
+      s << "(" if @exprs[0] == :import
+      if @parent
+        s = @parent.to_nix << "."
+      end
+      s << @exprs.map{|e| e.to_nix}.join(" ")
+      s << ")" if @exprs[0] == :import
+      s
+    end
+  end
 end
 
 class Symbol
-	def to_nix(indent = 0)
-		to_s
-	end
+  def to_nix(indent = 0)
+    to_s
+  end
 end
 
 class NilClass
-	def to_nix(indent = 0)
-		"null"
-	end
+  def to_nix(indent = 0)
+    "null"
+  end
 end
 
 class Hash
-	def to_nix(indent = 0)
-		"{\n" +
-		sort {|a, b| a[0].to_s <=> b[0].to_s}.map do |key, value|
-			raise "Key must be a Symbol, not #{key.class}" unless key.is_a?(Symbol)
-			Nix::INDENT_STRING * (indent + 1)+ key.to_nix +
-			" = " + value.to_nix(indent + 1) + ";"
-		end.join("\n") + "\n" +
-		Nix::INDENT_STRING * indent + "}"
-	end
+  def to_nix(indent = 0)
+    "{\n" +
+    sort {|a, b| a[0].to_s <=> b[0].to_s}.map do |key, value|
+      raise "Key must be a Symbol, not #{key.class}" unless key.is_a?(Symbol)
+      Nix::INDENT_STRING * (indent + 1)+ key.to_nix +
+      " = " + value.to_nix(indent + 1) + ";"
+    end.join("\n") + "\n" +
+    Nix::INDENT_STRING * indent + "}"
+  end
 end
 
 class Array
-	def to_nix(indent = 0)
-		"[ " + map(&:to_nix).join(" ") + " ]"
-	end
+  def to_nix(indent = 0)
+    "[ " + map(&:to_nix).join(" ") + " ]"
+  end
 end
 
 class String
-	def to_nix(indent = 0)
-		return self if self.slice(0,2) == "./"
-		return %{''#{self}''} if self =~ /\n/
-		%{"#{self}"}
-	end
+  def to_nix(indent = 0)
+    return self if self.slice(0,2) == "./"
+    return %{''#{self}''} if self =~ /\n/
+    %{"#{self}"}
+  end
 end
 
 class Fixnum
-	def to_nix(indent = 0)
-	    to_s
-	end
+  def to_nix(indent = 0)
+    to_s
+  end
 end
 
 class TrueClass
-	def to_nix(indent = 0)
-	    to_s
-	end
+  def to_nix(indent = 0)
+    to_s
+  end
 end
 
 class FalseClass
-	def to_nix(indent = 0)
-	    to_s
-	end
+  def to_nix(indent = 0)
+    to_s
+  end
 end

data/lib/vagrant-nixos/plugin.rb

@@ -1,52 +1,37 @@
 begin
-	require "vagrant"
+  require "vagrant"
 rescue LoadError
-	raise "The Nixos plugin must be run within Vagrant."
+  raise "The Nixos plugin must be run within Vagrant."
 end
 
 # This is a sanity check to make sure no one is attempting to install
 # this into an early Vagrant version.
-if Vagrant::VERSION < "1.2.0"
-	raise "The Nixos plugin is only compatible with Vagrant 1.2+"
+if Vagrant::VERSION < "1.6.4"
+  raise "The Nixos plugin is only compatible with Vagrant 1.6.4+"
 end
 
 module VagrantPlugins
-	module Nixos
+  module Nixos
 
-		@@nix_imports = {}
+    @@nix_imports = {}
 
-		class Plugin < Vagrant.plugin("2")
-			name "nixos"
-			description <<-DESC
-			This plugin installs nixos guest capabilities.
-			DESC
+    class Plugin < Vagrant.plugin("2")
+      name "nixos"
+      description <<-DESC
+      This plugin add nixos provisioning capabilities.
+      DESC
 
-			guest("nixos", "linux") do
-				require_relative "guest"
-				Guest
-			end
+      config :nixos, :provisioner do
+        require_relative "config"
+        Config
+      end
+      
+      provisioner :nixos do
+        require_relative "provisioner"
+        Provisioner
+      end
 
-			guest_capability("nixos", "configure_networks") do
-				require_relative "cap/configure_networks"
-				Cap::ConfigureNetworks
-			end
+    end
 
-			guest_capability("nixos", "change_host_name") do
-				require_relative "cap/change_host_name"
-				Cap::ChangeHostName
-			end
-
-			config :nixos, :provisioner do
-				require_relative "config"
-				Config
-			end
-			
-			provisioner :nixos do
-				require_relative "provisioner"
-				Provisioner
-			end
-
-		end
-
-	end
+  end
 end

data/lib/vagrant-nixos/provisioner.rb

@@ -1,27 +1,105 @@
 module VagrantPlugins
-	module Nixos
-		class NixosConfigError < Vagrant::Errors::VagrantError
-		end
-
-		class Provisioner < Vagrant.plugin("2", :provisioner)
-	        # This is the method called when the actual provisioning should be
-	        # done. The communicator is guaranteed to be ready at this point,
-	        # and any shared folders or networks are already setup.
-	        #
-	        # No return value is expected.
-	        def provision
-	        	conf = if @config.inline
-	        		@config.inline
-	        	elsif @config.path
-	        		File.read(@config.path)
-	        	elsif @config.expression
-	        		"{config, pkgs, ...}: with pkgs; #{@config.expression}"
-	        	else
-	        		raise NixosConfigError, "Mising :path, :inline or :expression"
-	        	end
-	        	Nixos.write_config(machine, "vagrant-provision.nix", conf)
-	        	Nixos.rebuild!(machine, @config)
-	        end
-	    end
-	end
+  module Nixos
+    NixosConfigError = Class.new(Vagrant::Errors::VagrantError)
+
+    CONFIG_HEADER = "# This file is overwritten by the vagrant-nixos plugin\n"
+
+    class Provisioner < Vagrant.plugin("2", :provisioner)
+      # This is the method called when the actual provisioning should be
+      # done. The communicator is guaranteed to be ready at this point,
+      # and any shared folders or networks are already setup.
+      #
+      # No return value is expected.
+      def provision
+        prov = if config.inline
+          config.inline
+        elsif config.path
+          File.read(config.path)
+        elsif config.expression
+          "{config, pkgs, ...}: with pkgs; #{@config.expression}"
+        else
+          "{}"
+        end
+        write_config('vagrant-provision.nix', prov)
+        rebuild!
+      end
+
+      protected
+
+      # just do nixos-rebuild
+      def rebuild!
+        prepare!
+
+        # rebuild
+        rebuild_cmd = "nixos-rebuild switch"
+        rebuild_cmd = "#{rebuild_cmd} -I nixos-config=/etc/nixos/vagrant.nix" if config.include
+        rebuild_cmd = "NIX_PATH=#{config.NIX_PATH}:$NIX_PATH #{rebuild_cmd}" if config.NIX_PATH
+
+        machine.communicate.tap do |comm|
+          comm.execute(rebuild_cmd, sudo: true) do |type, data|
+            if [:stderr, :stdout].include?(type)
+              # Output the data with the proper color based on the stream.
+              color = type == :stdout ? :green : :red
+
+              options = {
+                new_line: false,
+                prefix: false,
+              }
+              options[:color] = color
+
+              machine.env.ui.info(data, options) if config.verbose
+            end
+          end
+        end
+      end
+
+      # rebuild the base vagrant.nix configuration
+      def prepare!
+        # build
+        conf = <<CONF
+{ config, pkgs, ... }:
+{
+  imports = [
+    #{config.imports.join("\n  ")}
+  ];
+CONF
+        # default NIX_PATH
+        conf << <<CONF if config.NIX_PATH
+  config.environment.shellInit = ''
+    export NIX_PATH=#{config.NIX_PATH}:$NIX_PATH
+  '';
+CONF
+        conf << '}'
+        # output / build the config
+
+        write_config("vagrant.nix", conf)
+      end
+
+      # Send file to machine.
+      # Returns true if the uploaded file if different from any
+      # preexisting file, false if the file is indentical
+      def write_config(filename, conf)
+        temp = Tempfile.new("vagrant")
+        temp.binmode
+        temp.write(CONFIG_HEADER + conf)
+        temp.close
+        changed = true
+        machine.communicate.tap do |comm|
+          source = "/tmp/#{filename}"
+          target = "/etc/nixos/#{filename}"
+          comm.upload(temp.path, source)
+          if same?(source, target)
+            changed = false
+          else
+            comm.sudo("mv #{source} #{target}")
+          end
+        end
+        return changed
+      end
+
+      def same?(f1, f2)
+        machine.communicate.test("cmp --silent #{f1} #{f2}")
+      end
+    end
+  end
 end

data/lib/vagrant-nixos/version.rb

@@ -1,5 +1,5 @@
 module VagrantPlugins
-	module Nixos
-		VERSION = "0.0.6"
-	end
+  module Nixos
+    VERSION = '0.1.1'
+  end
 end

data/vagrant-nixos-plugin.gemspec

@@ -6,11 +6,11 @@ require 'vagrant-nixos/version'
 Gem::Specification.new do |spec|
   spec.name          = "vagrant-nixos-plugin"
   spec.version       = VagrantPlugins::Nixos::VERSION
-  spec.authors       = ["Chris Farmiloe"]
-  spec.email         = ["chrisfarms@gmail.com"]
-  spec.summary       = %q{Guest capabilities and nix provisioning for NixOS}
-  spec.description   = %q{Add capabilities and basic nix configuration provisioning for NixOS guests in Vagrant}
-  spec.homepage      = ""
+  spec.authors       = ["Chris Farmiloe", "zimbatm"]
+  spec.email         = ["chrisfarms@gmail.com", "zimbatm@zimbatm.com"]
+  spec.summary       = %q{Vagrant Nix provisioning plugin for NixOS}
+  spec.description   = %q{Add basic nix configuration provisioning for NixOS guests in Vagrant}
+  spec.homepage      = "https://github.com/zimbatm/vagrant-nixos-plugin"
   spec.license       = "MIT"
 
   spec.files         = `git ls-files -z`.split("\x0")
@@ -20,5 +20,4 @@ Gem::Specification.new do |spec|
 
   spec.add_development_dependency "bundler", "~> 1.5"
   spec.add_development_dependency "rake"
-  spec.add_dependency "netaddr"
 end

metadata

@@ -1,14 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: vagrant-nixos-plugin
 version: !ruby/object:Gem::Version
-  version: 0.0.6
+  version: 0.1.1
 platform: ruby
 authors:
 - Chris Farmiloe
+- zimbatm
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-09-01 00:00:00.000000000 Z
+date: 2015-10-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -38,45 +39,28 @@ dependencies:
     - - '>='
       - !ruby/object:Gem::Version
         version: '0'
-- !ruby/object:Gem::Dependency
-  name: netaddr
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - '>='
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - '>='
-      - !ruby/object:Gem::Version
-        version: '0'
-description: Add capabilities and basic nix configuration provisioning for NixOS guests
-  in Vagrant
+description: Add basic nix configuration provisioning for NixOS guests in Vagrant
 email:
 - chrisfarms@gmail.com
+- zimbatm@zimbatm.com
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
 - .gitignore
 - Gemfile
+- History.md
 - LICENSE.txt
 - README.md
 - Rakefile
 - lib/vagrant-nixos-plugin.rb
-- lib/vagrant-nixos/cap/change_host_name.rb
-- lib/vagrant-nixos/cap/configure_networks.rb
 - lib/vagrant-nixos/config.rb
-- lib/vagrant-nixos/guest.rb
 - lib/vagrant-nixos/nix.rb
 - lib/vagrant-nixos/plugin.rb
 - lib/vagrant-nixos/provisioner.rb
-- lib/vagrant-nixos/util.rb
 - lib/vagrant-nixos/version.rb
 - vagrant-nixos-plugin.gemspec
-homepage: ''
+homepage: https://github.com/zimbatm/vagrant-nixos-plugin
 licenses:
 - MIT
 metadata: {}
@@ -99,5 +83,5 @@ rubyforge_project:
 rubygems_version: 2.0.14
 signing_key: 
 specification_version: 4
-summary: Guest capabilities and nix provisioning for NixOS
+summary: Vagrant Nix provisioning plugin for NixOS
 test_files: []

data/lib/vagrant-nixos/cap/change_host_name.rb

@@ -1,30 +0,0 @@
-require 'set'
-require 'tempfile'
-
-
-module VagrantPlugins
-	module Nixos
-		module Cap
-			class ChangeHostName
-				include Vagrant::Util
-
-				def self.nix_module(name)
-					<<-NIX
-						{ config, pkgs, ... }:
-						{
-							networking.hostName = "#{name}";
-						}
-					NIX
-				end
-
-				def self.change_host_name(machine, name)
-					if Nixos.write_config(machine, "vagrant-hostname.nix", nix_module(name))
-						machine.env[:ui].info "Change host name to #{name}"
-					end
-				end
-
-			end
-		end
-	end
-end
-

data/lib/vagrant-nixos/cap/configure_networks.rb

@@ -1,56 +0,0 @@
-require 'set'
-require 'tempfile'
-require 'netaddr'
-
-require "vagrant/util/template_renderer"
-
-module VagrantPlugins
-    module Nixos
-        module Cap
-            class ConfigureNetworks
-                include Vagrant::Util
-
-                def self.nix_interface_expr(options)
-                    addr = NetAddr::CIDR.create("#{options[:ip]} #{options[:netmask]}")
-                    prefix_length = addr.netmask[1, addr.netmask.size]
-                    <<-NIX
-{
-    name = "eth#{options[:interface]}";
-    ipAddress = "#{options[:ip]}";
-    prefixLength = #{prefix_length};
-}
-                    NIX
-                end
-
-                def self.nix_module(networks)
-                    exprs = networks.inject([]) do |exprs, network|
-                        # Interfaces without an ip set will fallback to
-                        # DHCP if useDHCP is set. So skip them.
-                        if network[:ip].nil? or network[:ip].empty?
-                            exprs
-                        else
-                            exprs << nix_interface_expr(network)
-                        end
-                    end
-                    <<-NIX
-{ config, pkgs, ... }:
-{
-    networking.usePredictableInterfaceNames = false;
-    networking.useDHCP = true;
-    networking.interfaces = [
-                    #{exprs.join("\n")}
-    ];
-}
-                    NIX
-                end
-
-                def self.configure_networks(machine, networks)
-                    if Nixos.write_config(machine, "vagrant-interfaces.nix", nix_module(networks))
-                        machine.env.ui.info "Setting up network interfaces #{networks}"
-                    end
-                end
-
-            end
-        end
-    end
-end

data/lib/vagrant-nixos/guest.rb

@@ -1,13 +0,0 @@
-module VagrantPlugins
-	module Nixos
-		class Guest < Vagrant.plugin("2", :guest)
-
-			attr_accessor :nix_imports
-
-			def detect?(machine)
-				machine.communicate.test("test -d /etc/nixos")
-			end
-
-		end
-	end
-end

data/lib/vagrant-nixos/util.rb

@@ -1,122 +0,0 @@
-module VagrantPlugins
-	module Nixos
-		##############################################
-		# Not sure if this is legit. But We'll use this module
-		# to store the state of the nix configuration and handle
-		# sending it to the machine.
-		#############################################
-
-		@@imports = {}
-
-		# Send file to machine and report if it changed
-		# See _write_config
-		def self.write_config(machine, filename, conf)
-			include_config(machine, filename)
-			_write_config(machine, filename, conf)
-		end
-
-		# mark a file that should be imported to the main config
-		def self.include_config(machine, filename)
-			if @@imports[machine.id].nil?
-				@@imports[machine.id] = {}
-			end
-			@@imports[machine.id][filename] = true
-		end
-
-		def imports
-		end
-
-		# rebuild the base vagrant.nix configuration
-		def self.prepare(machine, config)
-			# build
-			conf = "{ config, pkgs, ... }:\n{"
-			# Add a mock provision file if it is missing as during boot the
-			# provisioning file may not be deployed yet.
-			if !machine.communicate.test("test -f /etc/nixos/vagrant-provision.nix")
-				_write_config(machine, "vagrant-provision.nix", "{ config, pkgs, ... }: {}")
-			end
-			# imports
-			include_config(machine, 'vagrant-provision.nix')
-			conf_paths =
-				@@imports[machine.id].keys.inject([]) do |paths, filename|
-					paths << "./#{filename}"
-				end
-			# construct the nix module
-			conf << %{
-				imports = [
-					#{conf_paths.join("\n\t\t")}
-				];
-			}
-			# default NIX_PATH
-			if config.NIX_PATH
-				conf << %{
-					config.environment.shellInit = ''
-						export NIX_PATH=#{config.NIX_PATH}:$NIX_PATH
-					'';
-				}
-			end
-			conf << "}"
-			# output / build the config
-			_write_config(machine, "vagrant.nix", conf)
-		end
-
-		# just do nixos-rebuild
-		def self.rebuild!(machine, config)
-			self.prepare(machine, config)
-			# Add a tmp vagreant.nix file if it is missing
-			if !machine.communicate.test("grep 'provision' </etc/nixos/vagrant.nix")
-				_write_config(machine, "vagrant.nix", %{{ config, pkgs, ... }: { imports = [ ./vagrant-provision.nix ];}})
-			end
-			# rebuild
-			rebuild_cmd = "nixos-rebuild switch"
-			rebuild_cmd = "#{rebuild_cmd} -I nixos-config=/etc/nixos/vagrant.nix" if config.include
-			rebuild_cmd = "NIX_PATH=#{config.NIX_PATH}:$NIX_PATH #{rebuild_cmd}" if config.NIX_PATH
-
-			machine.communicate.tap do |comm|
-				comm.execute(rebuild_cmd, sudo: true) do |type, data|
-					if [:stderr, :stdout].include?(type)
-					# Output the data with the proper color based on the stream.
-					color = type == :stdout ? :green : :red
-
-					options = {
-					  new_line: false,
-					  prefix: false,
-					}
-					options[:color] = color
-
-					machine.env.ui.info(data, options) if config.verbose
-					end
-				end
-			end
-		end
-
-		def self.same?(machine, f1, f2)
-			machine.communicate.test("cmp --silent #{f1} #{f2}")
-		end
-
-		protected
-
-		# Send file to machine.
-		# Returns true if the uploaded file if different from any 
-		# preexisting file, false if the file is indentical
-		def self._write_config(machine, filename, conf)
-			temp = Tempfile.new("vagrant")
-			temp.binmode
-			temp.write(conf)
-			temp.close
-			changed = true
-			machine.communicate.tap do |comm|
-				source = "/tmp/#{filename}"
-				target = "/etc/nixos/#{filename}"
-	            comm.upload(temp.path, source)
-	            if same?(machine, source, target)
-	            	changed = false
-	            else
-	            	comm.sudo("mv #{source} #{target}")
-	            end
-	        end
-	        return changed
-		end
-	end
-end
-