vagrant-nixos-plugin 0.0.6

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: c737e0645fac2818dd42a92841b641922710b899
+  data.tar.gz: 4b2af76eac1964a5faddad7e5f375e1d337668b6
+SHA512:
+  metadata.gz: 7b11d262f33643617ac54812edb26f3be635fdf21f17c6bc782ea9f185a3520ab6541105c0dc0083391525775706a395ac4ae833d3d2cf8f9771be76970f269f
+  data.tar.gz: 435f35e02644364e68a5f95655fe549047d5e2e8845797d173547f58a32bfee174c3f045123955d7280886ece3c0773806e207255ff234807603b7bddd352886

data/.gitignore

@@ -0,0 +1,5 @@
+Vagrantfile
+.vagrant/
+Gemfile.lock
+pkg/
+vendor/

data/Gemfile

@@ -0,0 +1,11 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in vagrant-nixos.gemspec
+gemspec
+
+group :development do
+  # We depend on Vagrant for development, but we don't add it as a
+  # gem dependency because we expect to be installed within the
+  # Vagrant environment itself using `vagrant plugin`.
+  gem "vagrant", :git => "git://github.com/mitchellh/vagrant.git"
+end

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Chris Farmiloe
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,111 @@
+# NixOS Vagrant Plugin
+
+This plugin makes working with [NixOS](http://nixos.org) guests in [Vagrant](http://www.vagrantup.com) a bit nicer:
+
+* Allow network configurations
+* Allow hostname setting
+* Provide nix provisioning
+
+## Install:
+
+NOTE: this project is a fork of the `vagrant-nixos` gem. Both can't be
+      installed at the same time.
+
+```bash
+$ vagrant plugin install vagrant-nixos-plugin
+```
+
+## Example Vagrantfile
+
+```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 ]
+		}
+	}
+
+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.
+
+```ruby
+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.
+
+You can also use an external nix configuration file:
+
+```ruby
+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
+```
+
+You can enable verbose provision output during rebuild process with:
+
+```ruby
+config.vm.provision :nixos,
+	:path => “configuration.nix”,
+	:verbose => true
+```
+
+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"
+		}
+	}
+}	
+```
+
+
+## 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`.
+
+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`.
+
+See the configuration in our [NixOS packer template](http://github.com/oxdi/nixos) 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.
+

data/Rakefile

@@ -0,0 +1,3 @@
+require 'rubygems'
+require 'bundler/setup'
+Bundler::GemHelper.install_tasks

data/lib/vagrant-nixos-plugin.rb

@@ -0,0 +1,17 @@
+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

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

@@ -0,0 +1,30 @@
+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

@@ -0,0 +1,56 @@
+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/config.rb

@@ -0,0 +1,51 @@
+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
+end

data/lib/vagrant-nixos/guest.rb

@@ -0,0 +1,13 @@
+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/nix.rb

@@ -0,0 +1,94 @@
+#################################################
+# Naughty extending of builtins.
+# Add to_nix functions to convert ruby2nix (ish).
+#################################################
+
+module Nix
+	INDENT_STRING="  "
+
+	def self.method_missing(m, *args, &block)
+		NixBuilder.new(nil, m.to_sym, *args)
+	end
+
+	class NixBuilder
+
+		attr_accessor :exprs
+		attr_accessor :parent
+
+		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 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
+end
+
+class NilClass
+	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
+end
+
+class Array
+	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
+end
+
+class Fixnum
+	def to_nix(indent = 0)
+	    to_s
+	end
+end
+
+class TrueClass
+	def to_nix(indent = 0)
+	    to_s
+	end
+end
+
+class FalseClass
+	def to_nix(indent = 0)
+	    to_s
+	end
+end

data/lib/vagrant-nixos/plugin.rb

@@ -0,0 +1,52 @@
+begin
+	require "vagrant"
+rescue LoadError
+	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+"
+end
+
+module VagrantPlugins
+	module Nixos
+
+		@@nix_imports = {}
+
+		class Plugin < Vagrant.plugin("2")
+			name "nixos"
+			description <<-DESC
+			This plugin installs nixos guest capabilities.
+			DESC
+
+			guest("nixos", "linux") do
+				require_relative "guest"
+				Guest
+			end
+
+			guest_capability("nixos", "configure_networks") do
+				require_relative "cap/configure_networks"
+				Cap::ConfigureNetworks
+			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

data/lib/vagrant-nixos/provisioner.rb

@@ -0,0 +1,27 @@
+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
+end

data/lib/vagrant-nixos/util.rb

@@ -0,0 +1,122 @@
+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
+

data/lib/vagrant-nixos/version.rb

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

data/vagrant-nixos-plugin.gemspec

@@ -0,0 +1,24 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+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.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.5"
+  spec.add_development_dependency "rake"
+  spec.add_dependency "netaddr"
+end

metadata

@@ -0,0 +1,103 @@
+--- !ruby/object:Gem::Specification
+name: vagrant-nixos-plugin
+version: !ruby/object:Gem::Version
+  version: 0.0.6
+platform: ruby
+authors:
+- Chris Farmiloe
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-09-01 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.5'
+- !ruby/object:Gem::Dependency
+  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
+  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
+email:
+- chrisfarms@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- 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: ''
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+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: []
+rubyforge_project: 
+rubygems_version: 2.0.14
+signing_key: 
+specification_version: 4
+summary: Guest capabilities and nix provisioning for NixOS
+test_files: []