knife-vagrant2 0.0.5

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 1ee941f5425873c296f1813ea350eee29f1c1320
+  data.tar.gz: c7254238b04f65993b8fb7de035b0d581ff62c5d
+SHA512:
+  metadata.gz: 21875e807264aaeaaeebd2577c3ef99b2ff921b865be5e341dc988f2f7488d37a2bfb505b9d48807a6f6dd0baca3b0e79cf7b222a2a1bc7ccb966de9f8838d99
+  data.tar.gz: 4508b2332c2c063871df1b3ddd376b61883ef495f7ca311868d0680ce5ac233002513f2f3e8e06e31280f82fd4a331a6402e4041f1ba97b5ea783bc84c517c8c

data/.gitignore

@@ -0,0 +1,9 @@
+# OS files
+.DS_Store
+Icon?
+.Spotlight-V100
+.Trashes
+
+*.gem
+Gemfile.lock
+

data/CHANGELOG.md

@@ -0,0 +1,51 @@
+# 0.0.5 (2014-12-11)
+
+## Changes and new features
+
+* Added --vmx-customize option to pass arbitrary parameters to VMware providers
+* Added --vagrant-config option to extend Vagrantfile with custom options
+
+
+## Fixes
+
+* Fix missing `ostruct` dependency with newer Chef versions
+* Fix `--distro` default value change in newer Chef versions
+
+
+# 0.0.4 (2014-03-14)
+
+## Changes and new features
+
+* Added --provider option to use vagrant providers other than virtualbox
+
+
+# 0.0.3 (2014-01-28)
+
+## Fixes
+
+* Fixed error when not using --vb-customize option
+* Removed unneeded dependency on knife-ec2
+
+
+# 0.0.2 (2013-12-17)
+
+## Changes and new features
+
+* BREAKING: --share-folders option now takes HOST_PATH::GUEST_PATH instead of NAME::GUEST_PATH::HOST_PATH
+* Added --port-forward option to map host ports to VMs
+* Added --vb-customize option to pass arbitrary VirtualBox options to Vagrant
+
+
+# 0.0.1 (2013-12-11)
+
+## Changes and new features
+
+* Initial release
+
+
+# Thanks to our contributors
+
+* [Jāzeps Baško](https://github.com/jbasko)
+* [Robert J. Berger](https://github.com/rberger)
+* [xsunsmile](https://github.com/xsunsmile)
+* [Mevan Samaratunga](https://github.com/mevansam)

data/Gemfile

@@ -0,0 +1,2 @@
+source 'http://rubygems.org'
+gemspec

data/LICENSE

@@ -0,0 +1,13 @@
+Copyright 2013-2014 Markus Kern
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

data/README.md

@@ -0,0 +1,48 @@
+knife-vagrant2
+==============
+
+This plugin gives knife the ability to create, bootstrap, and manage Vagrant instances.
+
+The plugin is a rewrite of the original [knife-vagrant](https://github.com/garrettux/knife-vagrant) but more closely resembles knife-ec2 behaviour. Specifically it does _not_ use Vagrant's built in Chef provisioner and instead relies on knife to bootstrap the VM. It will work nicely with [knife-solo](https://github.com/matschaffer/knife-solo) and doesn't require a Chef server.
+
+
+Installation
+------------
+If you are using bundler, simply add Chef and knife-vagrant2 to your `Gemfile`:
+
+```ruby
+gem 'chef'
+gem 'knife-vagrant2'
+```
+
+If you are not using bundler, you can install the gem manually:
+
+    $ gem install knife-vagrant2
+
+
+Usage
+-----
+knife-vagrant2 creates a `/vagrant` subfolder in your project which it uses to manage Vagrant files for all the instances you launch. You should add this folder to your `.gitignore` file so it is never checked into version control.
+
+To launch a new VM use the `server create` command:
+
+    knife vagrant server create --box-url http://files.vagrantup.com/precise32.box -N db -r role[db]
+
+This will launch a new VM using the `precise32` box, give the node a Chef name of `db` and then use knife to provision the VM with the `db` role.
+
+If a box is already installed into vagrant use `--box` instead of `--box-url` to reference it.
+
+By default knife-vagrant2 picks a private IP address from a predefined pool and assigns it to the VM. You can specify the IP pool using `--subnet` or assign a specfic IP with `--private-ip-address`.
+
+To map folders between host and VM use `--share-folders NAME::GUEST_PATH::HOST_PATH`.
+
+After a VM has been created its Chef name is used to reference it in future commands. Most commands map directly to the Vagrant ones:
+
+    knife vagrant server suspend SERVER [SERVER]
+    knife vagrant server resume SERVER [SERVER]
+    knife vagrant server halt SERVER [SERVER]
+    knife vagrant server up SERVER [SERVER]
+    knife vagrant server delete SERVER [SERVER] (options)
+    knife vagrant server list
+
+All commands can be applied to one or more VMs.

data/Rakefile

@@ -0,0 +1,2 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks

data/knife-vagrant2.gemspec

@@ -0,0 +1,21 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path('../lib', __FILE__)
+require 'knife-vagrant/version'
+
+Gem::Specification.new do |s|
+  s.name         = 'knife-vagrant2'
+  s.version      = Knife::Vagrant::VERSION
+  s.authors      = ['Markus Kern']
+  s.email        = ['makern@users.noreply.github.com']
+  s.homepage     = 'https://github.com/makern/knife-vagrant2'
+  s.summary      = %q{Vagrant support for Chef's knife command}
+  s.description  = s.summary
+  s.license      = 'Apache 2.0'
+
+  s.files        = `git ls-files`.split("\n")
+
+  s.add_dependency 'chef', '>= 0.10.10'
+  s.add_development_dependency 'rake'
+
+  s.require_paths = ['lib']
+end

data/lib/chef/knife/vagrant_base.rb

@@ -0,0 +1,165 @@
+require 'chef/knife'
+
+class Chef
+  class Knife
+    module VagrantBase
+
+      # :nodoc:
+      # Would prefer to do this in a rational way, but can't be done b/c of
+      # Mixlib::CLI's design :(
+      def self.included(includer)
+        includer.class_eval do
+
+          option :vagrant_dir,
+            :short => '-D PATH',
+            :long => '--vagrant-dir PATH',
+            :description => "Path to where Vagrant files are stored. Defaults to cwd/vagrant (#{Dir.pwd}/vagrant)",
+            :proc => Proc.new { |key| Chef::Config[:knife][:vagrant_dir] = key },
+            :default => File.join(Dir.pwd, '/vagrant')
+        end
+      end
+
+      def vagrant_exec(instance, cmd, opts = {})
+        fetch_output = opts[:fetch_output] || false
+        no_cwd_change = opts[:no_cwd_change] || false
+
+        unless no_cwd_change
+          cwd = Dir.getwd()
+          Dir.chdir(File.join(locate_config_value(:vagrant_dir), instance))
+        end
+
+        cmd = "vagrant #{cmd}"
+        output = nil
+        if defined? Bundler
+          # Needed if we are run from inside a bundler environment and vagrant
+          # is installed as global gem. If this causes problems for anyone please
+          # file a bug report.
+          Bundler.with_clean_env do
+            output = fetch_output ? %x(#{cmd}) : system(cmd)
+          end
+        else
+          output = fetch_output ? %x(#{cmd}) : system(cmd)
+        end
+
+        unless no_cwd_change
+          Dir.chdir(cwd)
+        end
+        output
+      end
+
+      def vagrant_instance_state(instance)
+        output = vagrant_exec(instance, 'status', fetch_output: true)
+        state = /Current machine states:.+?default\s+(.+?)\s+\((.+?)\)/m.match(output)
+        unless state
+          ui.warn("Couldn't parse state of instance #{instance}")
+          return ['', '']
+        end
+        return [state[1], state[2]]
+      end
+
+      def vagrant_instance_list
+        # Memoize so we don't have to parse files multiple times
+        if @vagrant_instances
+          return @vagrant_instances
+        end
+
+        vangrant_dir = locate_config_value(:vagrant_dir)
+        @vagrant_instances = []
+
+        unless File.exist? vangrant_dir
+          return @vagrant_instances
+        end    
+
+        Dir.foreach(vangrant_dir) { |subdir|
+          vagrant_file = File.join(vangrant_dir, subdir, 'Vagrantfile')
+          if File.exist? vagrant_file
+            instance = { :name => subdir,
+                         :vagrant_file => vagrant_file
+                       }
+            # Read settings from vagrant file
+            content = IO.read(vagrant_file)
+            instance[:ip_address] = /config\.vm\.network[^,]+,\s*ip:\s*"([0-9\.]+)"/.match(content) { |m| m[1] }
+            unless instance[:ip_address]
+              ui.warn("Couldn't find IP address in #{vagrant_file}. Is it malformed?")           
+            end
+
+            instance[:box] = /config\.vm\.box[^=]*=\s*"([^"]+)"/.match(content) { |m| m[1] }
+            unless instance[:box]
+              ui.warn("Couldn't find box in #{vagrant_file}. Is it malformed?")           
+            end
+            @vagrant_instances.push(instance)
+          end
+        }
+        @vagrant_instances
+      end
+
+      def write_insecure_key
+        # The private key most vagrant boxes use.
+        insecure_key = <<-EOF
+-----BEGIN RSA PRIVATE KEY-----
+MIIEogIBAAKCAQEA6NF8iallvQVp22WDkTkyrtvp9eWW6A8YVr+kz4TjGYe7gHzI
+w+niNltGEFHzD8+v1I2YJ6oXevct1YeS0o9HZyN1Q9qgCgzUFtdOKLv6IedplqoP
+kcmF0aYet2PkEDo3MlTBckFXPITAMzF8dJSIFo9D8HfdOV0IAdx4O7PtixWKn5y2
+hMNG0zQPyUecp4pzC6kivAIhyfHilFR61RGL+GPXQ2MWZWFYbAGjyiYJnAmCP3NO
+Td0jMZEnDkbUvxhMmBYSdETk1rRgm+R4LOzFUGaHqHDLKLX+FIPKcF96hrucXzcW
+yLbIbEgE98OHlnVYCzRdK8jlqm8tehUc9c9WhQIBIwKCAQEA4iqWPJXtzZA68mKd
+ELs4jJsdyky+ewdZeNds5tjcnHU5zUYE25K+ffJED9qUWICcLZDc81TGWjHyAqD1
+Bw7XpgUwFgeUJwUlzQurAv+/ySnxiwuaGJfhFM1CaQHzfXphgVml+fZUvnJUTvzf
+TK2Lg6EdbUE9TarUlBf/xPfuEhMSlIE5keb/Zz3/LUlRg8yDqz5w+QWVJ4utnKnK
+iqwZN0mwpwU7YSyJhlT4YV1F3n4YjLswM5wJs2oqm0jssQu/BT0tyEXNDYBLEF4A
+sClaWuSJ2kjq7KhrrYXzagqhnSei9ODYFShJu8UWVec3Ihb5ZXlzO6vdNQ1J9Xsf
+4m+2ywKBgQD6qFxx/Rv9CNN96l/4rb14HKirC2o/orApiHmHDsURs5rUKDx0f9iP
+cXN7S1uePXuJRK/5hsubaOCx3Owd2u9gD6Oq0CsMkE4CUSiJcYrMANtx54cGH7Rk
+EjFZxK8xAv1ldELEyxrFqkbE4BKd8QOt414qjvTGyAK+OLD3M2QdCQKBgQDtx8pN
+CAxR7yhHbIWT1AH66+XWN8bXq7l3RO/ukeaci98JfkbkxURZhtxV/HHuvUhnPLdX
+3TwygPBYZFNo4pzVEhzWoTtnEtrFueKxyc3+LjZpuo+mBlQ6ORtfgkr9gBVphXZG
+YEzkCD3lVdl8L4cw9BVpKrJCs1c5taGjDgdInQKBgHm/fVvv96bJxc9x1tffXAcj
+3OVdUN0UgXNCSaf/3A/phbeBQe9xS+3mpc4r6qvx+iy69mNBeNZ0xOitIjpjBo2+
+dBEjSBwLk5q5tJqHmy/jKMJL4n9ROlx93XS+njxgibTvU6Fp9w+NOFD/HvxB3Tcz
+6+jJF85D5BNAG3DBMKBjAoGBAOAxZvgsKN+JuENXsST7F89Tck2iTcQIT8g5rwWC
+P9Vt74yboe2kDT531w8+egz7nAmRBKNM751U/95P9t88EDacDI/Z2OwnuFQHCPDF
+llYOUI+SpLJ6/vURRbHSnnn8a/XG+nzedGH5JGqEJNQsz+xT2axM0/W/CRknmGaJ
+kda/AoGANWrLCz708y7VYgAtW2Uf1DPOIYMdvo6fxIB5i9ZfISgcJ/bbCUkFrhoH
++vq/5CIWxCPp0f85R4qxxQ5ihxJ0YDQT9Jpx4TMss4PSavPaBH3RXow5Ohe+bYoQ
+NE5OgEXk2wVfZczCZpigBKbKZHNYcelXtTt/nP3rsCuGcM4h53s=
+-----END RSA PRIVATE KEY-----
+        EOF
+        insecure_key
+
+        # Write key to vagrant folder if it's not there yet.
+        key_file = File.join(locate_config_value(:vagrant_dir), 'insecure_key')
+        unless File.exist? key_file
+          ui.msg("Creating #{key_file}")
+          FileUtils.mkdir_p(locate_config_value(:vagrant_dir))
+          File.open(key_file, 'w') { |f| f.write(insecure_key) }
+          File.chmod(0600, key_file)
+        end
+      end
+
+      def locate_config_value(key)
+        key = key.to_sym
+        config[key] || Chef::Config[:knife][key]
+      end
+
+      def msg_pair(label, value, color=:cyan)
+        if value && !value.to_s.empty?
+          puts "#{ui.color(label, color)}: #{value}"
+        end
+      end
+
+      def colored_vagrant_state(state)
+          case state
+          when 'saved','paused','poweroff', 'stuck', 'aborted', 'gurumeditation', 'inaccessible'
+            ui.color(state, :red)
+          when 'saving'
+            ui.color(state, :yellow)
+          else
+            ui.color(state, :green)
+          end
+      end
+
+    end
+  end
+end
+
+

data/lib/chef/knife/vagrant_box.rb

@@ -0,0 +1,15 @@
+require 'chef/knife/vagrant_base'
+
+class Chef
+  class Knife
+
+    class VagrantBoxList < Knife
+      include Knife::VagrantBase
+      banner "knife vagrant box list"
+      def run
+        vagrant_exec('.', 'box list', no_cwd_change: true)
+      end
+    end
+
+  end
+end

data/lib/chef/knife/vagrant_server_create.rb

@@ -0,0 +1,423 @@
+require 'chef/knife/vagrant_base'
+
+class Chef
+  class Knife
+    class VagrantServerCreate < Knife
+
+      include Knife::VagrantBase
+      deps do
+        require 'ostruct'
+        require 'ipaddr'
+        require 'chef/knife/bootstrap'
+        Chef::Knife::Bootstrap.load_deps
+      end
+
+      banner "knife vagrant server create (options)"
+
+      option :box,
+        :short => "-b BOX",
+        :long => "--box BOX",
+        :description => "The vagrant box to use for the server",
+        :proc => Proc.new { |b| Chef::Config[:knife][:box] = b }
+
+      option :box_url,
+        :short => '-U URL',
+        :long => '--box-url URL',
+        :description => 'URL of pre-packaged vbox template. Can be a local path or an HTTP URL.',
+        :proc => Proc.new { |b| Chef::Config[:knife][:box_url] = b }
+
+      option :memsize,
+        :short => '-m MEMORY',
+        :long => '--memsize MEMORY',
+        :description => 'Amount of RAM to allocate to provisioned VM, in MB. Defaults to 1024',
+        :proc => Proc.new { |m| Chef::Config[:knife][:memsize] = m },
+        :default => 1024
+
+      option :share_folders,
+        :short => '-F',
+        :long => '--share-folders SHARES',
+        :description => 'Comma separated list of share folders in the form of HOST_PATH::GUEST_PATH',
+        :proc => lambda { |o| o.split(/[\s,]+/) },
+        :default => []
+
+      option :use_cachier,
+        :short => '-C',
+        :long => '--use-cachier',
+        :description => 'Enables VM to use the vagrant-cachier plugin',
+        :boolean => true,
+        :default => false
+
+      option :chef_node_name,
+        :short => "-N NAME",
+        :long => "--node-name NAME",
+        :description => "The Chef node name for your new node"
+#        :proc => Proc.new { |key| Chef::Config[:knife][:chef_node_name] = key }
+
+      option :ssh_user,
+        :short => "-x USERNAME",
+        :long => "--ssh-user USERNAME",
+        :description => "The ssh username",
+        :default => "vagrant"
+
+      option :ssh_password,
+        :short => "-P PASSWORD",
+        :long => "--ssh-password PASSWORD",
+        :description => "The ssh password"
+
+      option :ssh_port,
+        :short => "-p PORT",
+        :long => "--ssh-port PORT",
+        :description => "The ssh port",
+        :default => "22",
+        :proc => Proc.new { |key| Chef::Config[:knife][:ssh_port] = key }
+
+      option :ssh_gateway,
+        :short => "-w GATEWAY",
+        :long => "--ssh-gateway GATEWAY",
+        :description => "The ssh gateway server",
+        :proc => Proc.new { |key| Chef::Config[:knife][:ssh_gateway] = key }
+
+      option :identity_file,
+        :short => "-i IDENTITY_FILE",
+        :long => "--identity-file IDENTITY_FILE",
+        :description => "The SSH identity file used for authentication"
+
+      option :prerelease,
+        :long => "--prerelease",
+        :description => "Install the pre-release chef gems"
+
+      option :bootstrap_version,
+        :long => "--bootstrap-version VERSION",
+        :description => "The version of Chef to install",
+        :proc => Proc.new { |v| Chef::Config[:knife][:bootstrap_version] = v }
+
+      option :distro,
+        :short => "-d DISTRO",
+        :long => "--distro DISTRO",
+        :description => "Bootstrap a distro using a template; default is 'chef-full'",
+        :default => 'chef-full',
+        :proc => Proc.new { |d| Chef::Config[:knife][:distro] = d }
+
+      option :template_file,
+        :long => "--template-file TEMPLATE",
+        :description => "Full path to location of template to use",
+        :proc => Proc.new { |t| Chef::Config[:knife][:template_file] = t },
+        :default => false
+
+      option :run_list,
+        :short => "-r RUN_LIST",
+        :long => "--run-list RUN_LIST",
+        :description => "Comma separated list of roles/recipes to apply",
+        :proc => lambda { |o| o.split(/[\s,]+/) }
+
+      option :secret,
+        :short => "-s SECRET",
+        :long => "--secret ",
+        :description => "The secret key to use to encrypt data bag item values",
+        :proc => lambda { |s| Chef::Config[:knife][:secret] = s }
+
+      option :secret_file,
+        :long => "--secret-file SECRET_FILE",
+        :description => "A file containing the secret key to use to encrypt data bag item values",
+        :proc => lambda { |sf| Chef::Config[:knife][:secret_file] = sf }
+
+      option :json_attributes,
+        :short => "-j JSON",
+        :long => "--json-attributes JSON",
+        :description => "A JSON string to be added to the first run of chef-client",
+        :proc => lambda { |o| JSON.parse(o) }
+
+      option :subnet,
+        :short => "-s SUBNET",
+        :long => "--subnet SUBNET",
+        :description => "Subnet from which to pick instance IP address. Default: 192.168.67/24",
+        :proc => Proc.new { |key| Chef::Config[:knife][:subnet] = key }, 
+        :default => '192.168.67.0/24'
+
+      option :ip_address,
+        :short => "-I IP-ADDRESS",
+        :long => "--private-ip-address IP-ADDRESS",
+        :description => "Use this IP address for the new instance"
+#        :proc => Proc.new { |ip| Chef::Config[:knife][:ip_address] = ip }
+
+      option :port_forward,
+        :short => '-f PORTS',
+        :long => '--port-forward PORTS',
+        :description => "Comma separated list of HOST:GUEST ports to forward",
+        :proc => lambda { |o| Hash[o.split(/,/).collect { |a| a.split(/:/) }] },
+        :default => {}
+
+      option :host_key_verify,
+        :long => "--[no-]host-key-verify",
+        :description => "Verify host key, enabled by default.",
+        :boolean => true,
+        :default => true
+
+      option :vb_customize,
+        :long => "--vb-customize VBOXMANAGE_COMMANDS",
+        :description => "List of customize options for the virtualbox vagrant provider separated by ::"
+
+      option :vmx_customize,
+        :long => "--vmx-customize VMX_PARAMETERS",
+        :description => "List of parameters for the vmware vagrant providers separated by ::"
+
+      option :provider,
+        :long => "--provider PROVIDER",
+        :description => "The vagrant provider to use for the server",
+        :default => 'virtualbox'
+
+      option :vagrant_config,
+        :long => "--vagrant-config SETTINGS",
+        :description => "Lines of configuration to be inserted into the Vagrantfile separated by ::"
+
+      def run
+        $stdout.sync = true
+        validate!
+
+        @server = create_server_def
+
+        msg_pair("Instance name", @server.name)
+        msg_pair("Instance IP", @server.ip_address)
+        msg_pair("Box", @server.box || @server.box_url)
+
+        if vagrant_instance_list.detect { |i| i[:name] == @server.name } 
+            ui.error("Instance #{@server.name} already exists")
+            exit 1
+        end
+
+        # Create Vagrant file for new instance
+        print "\n#{ui.color("Launching instance", :magenta)}\n"
+        write_vagrantfile
+        cmd = "up --provider #{locate_config_value(:provider)}"
+        vagrant_exec(@server.name, cmd)
+
+        write_insecure_key
+        print "\n#{ui.color("Waiting for sshd", :magenta)}"
+        wait_for_sshd(@server.ip_address)
+
+        print "\n#{ui.color("Bootstraping instance", :magenta)}\n"
+        bootstrap_node(@server,@server.ip_address).run
+
+
+        puts "\n"
+        msg_pair("Instance Name", @server.name)
+        msg_pair("Box", @server.box || @server.box_url)
+        msg_pair("IP Address", @server.ip_address)
+        msg_pair("Environment", locate_config_value(:environment) || '_default')
+        msg_pair("Run List", (config[:run_list] || []).join(', '))
+        msg_pair("JSON Attributes", config[:json_attributes]) unless !config[:json_attributes] || config[:json_attributes].empty?
+      end
+
+      def build_port_forwards(ports)
+        ports.collect { |k, v| "config.vm.network :forwarded_port, host: #{k}, guest: #{v}, host_ip: '127.0.0.1'" }.join("\n")
+      end
+
+      def build_vb_customize(customize)
+        customize.split(/::/).collect { |k| "vb.customize [ #{k} ]" }.join("\n") if customize
+      end
+
+      def build_vmx_customize(customize)
+        customize.split(/::/).collect { |k| "v.vmx [ #{k} ]" }.join("\n") if customize
+      end
+
+      def build_shares(share_folders)
+        share_folders.collect do |share|
+          host, guest = share.chomp.split "::"
+          "config.vm.synced_folder '#{host}', '#{guest}'"
+        end.join("\n")
+      end
+
+      def write_vagrantfile
+        additions = []
+        if @server.use_cachier
+          additions << 'config.cache.auto_detect = true' # enable vagarant-cachier
+        end
+        if @server.vagrant_config
+          additions << @server.vagrant_config.split(/::/)
+        end
+
+        file = <<-EOF
+Vagrant.configure("2") do |config|
+  config.vm.box = "#{@server.box}"
+  config.vm.box_url = "#{@server.box_url}"
+  config.vm.hostname = "#{@server.name}"
+
+  config.vm.network :private_network, ip: "#{@server.ip_address}"
+  #{build_port_forwards(@server.port_forward)}
+
+  #{build_shares(@server.share_folders)}
+ 
+  config.vm.provider :virtualbox do |vb|
+    vb.customize [ "modifyvm", :id, "--memory", #{@server.memsize} ]
+    #{build_vb_customize(@server.vb_customize)}
+  end
+  
+  config.vm.provider :vmware_fusion do |v|
+    v.vmx["memsize"] = "#{@server.memsize}"
+    #{build_vmx_customize(@server.vmx_customize)}
+  end
+
+  config.vm.provider :vmware_workstation do |v|
+    v.vmx["memsize"] = "#{@server.memsize}"
+    #{build_vmx_customize(@server.vmx_customize)}
+  end
+
+  #{additions.join("\n")}
+end
+        EOF
+        file
+
+        # Create folder and write Vagrant file
+        instance_dir = File.join(locate_config_value(:vagrant_dir), @server.name)
+        instance_file = File.join(instance_dir, 'Vagrantfile')
+        ui.msg("Creating #{instance_file}")
+        FileUtils.mkdir_p(instance_dir)
+        File.open(instance_file, 'w') { |f| f.write(file) }
+      end
+
+      def bootstrap_node(server,ssh_host)
+        bootstrap = Chef::Knife::Bootstrap.new
+        bootstrap.name_args = [ssh_host]
+        bootstrap.config[:ssh_user] = config[:ssh_user]
+        bootstrap.config[:ssh_port] = config[:ssh_port]
+        bootstrap.config[:ssh_gateway] = config[:ssh_gateway]
+        bootstrap.config[:identity_file] = config[:identity_file] || File.join(locate_config_value(:vagrant_dir), 'insecure_key')
+        bootstrap.config[:chef_node_name] = locate_config_value(:chef_node_name) || server.ip
+        bootstrap.config[:distro] = locate_config_value(:distro) || "chef-full"
+        bootstrap.config[:use_sudo] = true unless config[:ssh_user] == 'root'
+        bootstrap.config[:host_key_verify] = config[:host_key_verify]
+
+        bootstrap.config[:run_list] = config[:run_list]
+        bootstrap.config[:prerelease] = config[:prerelease]
+        bootstrap.config[:bootstrap_version] = locate_config_value(:bootstrap_version)
+        bootstrap.config[:distro] = locate_config_value(:distro)
+        bootstrap.config[:template_file] = locate_config_value(:template_file)
+        bootstrap.config[:environment] = locate_config_value(:environment)
+        bootstrap.config[:prerelease] = config[:prerelease]
+        bootstrap.config[:bootstrap_version] = locate_config_value(:bootstrap_version)
+        bootstrap.config[:first_boot_attributes] = locate_config_value(:json_attributes) || {}
+        bootstrap.config[:encrypted_data_bag_secret] = locate_config_value(:encrypted_data_bag_secret)
+        bootstrap.config[:encrypted_data_bag_secret_file] = locate_config_value(:encrypted_data_bag_secret_file)
+        bootstrap.config[:secret] = locate_config_value(:secret)
+        bootstrap.config[:secret_file] = locate_config_value(:secret_file)
+        # Modify global configuration state to ensure hint gets set by
+        # knife-bootstrap
+        Chef::Config[:knife][:hints] ||= {}
+        Chef::Config[:knife][:hints]["vagrant"] ||= {} # Cargo Cult programming FTW?
+
+        msg_pair("SSH User", bootstrap.config[:ssh_user])
+        msg_pair("SSH identity file", bootstrap.config[:identity_file])
+        bootstrap
+      end
+
+      def validate!
+        unless locate_config_value(:box) || locate_config_value(:box_url)
+          ui.error("You need to either specify --box or --box-url")
+          exit 1
+        end
+      end
+
+      def find_available_ip
+        subnet = locate_config_value('subnet')
+        IPAddr.new(subnet).to_range().each { |ip|
+          # 192.168.3.0/24 should yield 192.168.3.2 through 192.168.3.254
+          # 192.168.3.1 cannot be used because virtual box uses it for the router
+          mask = IPAddr::IN4MASK ^ ip.instance_variable_get("@mask_addr")
+          unless [0, 1, mask].include? (ip & mask) or vagrant_instance_list.detect { |i| i[:ip_address] == ip.to_s } 
+            return ip.to_s
+          end
+        }
+        ui.error("No unused IP address available in subnet #{subnet}")
+        exit 1
+      end
+
+      def create_server_def
+        server_def = {
+          :box => locate_config_value(:box),
+          :box_url => locate_config_value(:box_url),
+          :memsize => locate_config_value(:memsize),
+          :share_folders => config[:share_folders],
+          :port_forward => config[:port_forward],
+          :use_cachier => config[:use_cachier],
+          :vb_customize => locate_config_value(:vb_customize),
+          :vmx_customize => locate_config_value(:vmx_customize),
+          :vagrant_config => locate_config_value(:vagrant_config)
+        }
+
+        # Get specified IP address for new instance or pick an unused one from the subnet pool.
+        server_def[:ip_address] = config[:ip_address] || find_available_ip
+
+        collision = vagrant_instance_list.detect { |i| i[:ip_address] == server_def[:ip_address] }
+        if collision
+          ui.error("IP address #{server_def[:ip_address]} already in use by instance #{collision[:name]}")
+          exit 1
+        end
+
+        # Derive name for vagrant instance from chef node name or IP
+        server_def[:name] = locate_config_value(:chef_node_name) || server_def[:ip_address]
+
+        # Turn it into and object like thing
+        OpenStruct.new(server_def)
+      end
+
+      def wait_for_sshd(hostname)
+        config[:ssh_gateway] ? wait_for_tunnelled_sshd(hostname) : wait_for_direct_sshd(hostname, config[:ssh_port])
+      end
+
+      def wait_for_tunnelled_sshd(hostname)
+        print(".")
+        print(".") until tunnel_test_ssh(hostname) {
+          sleep @initial_sleep_delay ||= 2
+          puts("done")
+        }
+      end
+
+      def tunnel_test_ssh(hostname, &block)
+        gw_host, gw_user = config[:ssh_gateway].split('@').reverse
+        gw_host, gw_port = gw_host.split(':')
+        gateway = Net::SSH::Gateway.new(gw_host, gw_user, :port => gw_port || 22)
+        status = false
+        gateway.open(hostname, config[:ssh_port]) do |local_tunnel_port|
+          status = tcp_test_ssh('localhost', local_tunnel_port, &block)
+        end
+        status
+      rescue SocketError, Errno::ECONNREFUSED, Errno::EHOSTUNREACH, Errno::ENETUNREACH, IOError
+        sleep 2
+        false
+      rescue Errno::EPERM, Errno::ETIMEDOUT
+        false
+      end
+
+      def wait_for_direct_sshd(hostname, ssh_port)
+        print(".") until tcp_test_ssh(hostname, ssh_port) {
+          sleep @initial_sleep_delay ||= 2
+          puts("done")
+        }
+      end
+
+      def tcp_test_ssh(hostname, ssh_port)
+        tcp_socket = TCPSocket.new(hostname, ssh_port)
+        readable = IO.select([tcp_socket], nil, nil, 5)
+        if readable
+          Chef::Log.debug("sshd accepting connections on #{hostname}, banner is #{tcp_socket.gets}")
+          yield
+          true
+        else
+          false
+        end
+      rescue SocketError, Errno::ECONNREFUSED, Errno::EHOSTUNREACH, Errno::ENETUNREACH, IOError
+        sleep 2
+        false
+      rescue Errno::EPERM, Errno::ETIMEDOUT
+        false
+      # This happens on some mobile phone networks
+      rescue Errno::ECONNRESET
+        sleep 2
+        false
+      ensure
+        tcp_socket && tcp_socket.close
+      end
+
+    end
+  end
+end

data/lib/chef/knife/vagrant_server_delete.rb

@@ -0,0 +1,73 @@
+require 'chef/knife/vagrant_base'
+
+# These two are needed for the '--purge' deletion case
+require 'chef/node'
+require 'chef/api_client'
+
+class Chef
+  class Knife
+    class VagrantServerDelete < Knife
+
+      include Knife::VagrantBase
+
+      banner "knife vagrant server delete SERVER [SERVER] (options)"
+
+      attr_reader :server
+
+      option :purge,
+        :short => "-P",
+        :long => "--purge",
+        :boolean => true,
+        :default => false,
+        :description => "Destroy corresponding node and client on the Chef Server, in addition to destroying the Vagrant node itself."
+
+      # Extracted from Chef::Knife.delete_object, because it has a
+      # confirmation step built in... By specifying the '--purge'
+      # flag (and also explicitly confirming the server destruction!)
+      # the user is already making their intent known.  It is not
+      # necessary to make them confirm two more times.
+      def destroy_item(klass, name, type_name)
+        begin
+          object = klass.load(name)
+          object.destroy
+          ui.warn("Deleted #{type_name} #{name}")
+        rescue Net::HTTPServerException
+          ui.warn("Could not find a #{type_name} named #{name} to delete!")
+        end
+      end
+
+      def run
+
+        @name_args.each do |name|
+          instance = vagrant_instance_list.detect { |i| i[:name] == name }
+          unless instance
+            ui.error("No instance named #{name}")
+            next            
+          end
+
+          msg_pair("Instance Name", instance[:name])
+          msg_pair("Box", instance[:box])
+          msg_pair("Vagrant File", instance[:vagrant_file])
+          msg_pair("IP Address", instance[:ip_address])
+
+          puts "\n"
+          confirm("Do you really want to delete this instance")
+
+          vagrant_exec(instance[:name], 'destroy -f')
+          instance_dir = File.join(locate_config_value(:vagrant_dir), instance[:name])
+          FileUtils.rm_rf(instance_dir)
+
+          ui.warn("Deleted instance #{instance[:name]}")
+
+          if config[:purge]
+            destroy_item(Chef::Node, instance[:name], "node")
+            destroy_item(Chef::ApiClient, instance[:name], "client")
+          else
+            ui.warn("Corresponding node and client for the #{instance[:name]} instance were not deleted and remain registered with the Chef Server")
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/chef/knife/vagrant_server_halt.rb

@@ -0,0 +1,33 @@
+require 'chef/knife/vagrant_base'
+
+class Chef
+  class Knife
+    class VagrantServerHalt < Knife
+
+      include Knife::VagrantBase
+
+      banner "knife vagrant server halt SERVER [SERVER]"
+
+      def run
+        $stdout.sync = true
+
+        @name_args.each do |instance|
+          unless vagrant_instance_list.detect { |i| i[:name] == instance }
+            ui.error("No instance named #{instance}")
+            next            
+          end
+
+          state, provider = vagrant_instance_state(instance)
+
+          unless state == 'running' or state == 'saved'
+            ui.error("Instance #{instance} needs to be running or suspended for halt. Current state is #{colored_vagrant_state(state)}")
+            next
+          end
+
+          vagrant_exec(instance, 'halt')
+        end
+      end
+
+    end
+  end
+end

data/lib/chef/knife/vagrant_server_list.rb

@@ -0,0 +1,39 @@
+require 'chef/knife/vagrant_base'
+
+class Chef
+  class Knife
+    class VagrantServerList < Knife
+
+      include Knife::VagrantBase
+
+      banner "knife vagrant server list"
+
+      def run
+        $stdout.sync = true
+
+        server_list = [
+          ui.color('Instance Name', :bold),
+          ui.color('IP Address', :bold),
+          ui.color('Box', :bold),
+          ui.color('Provider', :bold),
+          ui.color('State', :bold)
+        ].flatten.compact
+        
+        output_column_count = server_list.length
+                
+        vagrant_instance_list.each do |server|
+          server_list << server[:name]
+          server_list << server[:ip_address]
+          server_list << server[:box]
+
+          state, provider = vagrant_instance_state(server[:name])
+          server_list << provider
+          server_list << colored_vagrant_state(state)
+        end
+
+        puts ui.list(server_list, :uneven_columns_across, output_column_count)
+
+      end
+    end
+  end
+end

data/lib/chef/knife/vagrant_server_resume.rb

@@ -0,0 +1,35 @@
+require 'chef/knife/vagrant_base'
+
+class Chef
+  class Knife
+    class VagrantServerResume < Knife
+
+      include Knife::VagrantBase
+
+      banner "knife vagrant server resume SERVER [SERVER]"
+
+      def run
+        $stdout.sync = true
+
+        @name_args.each do |instance|
+          unless vagrant_instance_list.detect { |i| i[:name] == instance }
+            ui.error("No instance named #{instance}")
+            next            
+          end
+
+          state, provider = vagrant_instance_state(instance)
+
+          # saved: VirtualBox
+          # suspended: VMWare Fusion
+          unless state == 'saved' or state == 'suspended'
+            ui.error("Instance #{instance} needs to be suspended for resume. Current state is #{colored_vagrant_state(state)}")
+            next
+          end
+
+          vagrant_exec(instance, 'resume')
+        end
+      end
+
+    end
+  end
+end

data/lib/chef/knife/vagrant_server_suspend.rb

@@ -0,0 +1,33 @@
+require 'chef/knife/vagrant_base'
+
+class Chef
+  class Knife
+    class VagrantServerSuspend < Knife
+
+      include Knife::VagrantBase
+
+      banner "knife vagrant server suspend SERVER [SERVER]"
+
+      def run
+        $stdout.sync = true
+
+        @name_args.each do |instance|
+          unless vagrant_instance_list.detect { |i| i[:name] == instance }
+            ui.error("No instance named #{instance}")
+            next            
+          end
+
+          state, provider = vagrant_instance_state(instance)
+
+          unless state == 'running'
+            ui.error("Instance #{instance} needs to be running for suspend. Current state is #{colored_vagrant_state(state)}")
+            next
+          end
+
+          vagrant_exec(instance, 'suspend')
+        end
+      end
+
+    end
+  end
+end

data/lib/chef/knife/vagrant_server_up.rb

@@ -0,0 +1,33 @@
+require 'chef/knife/vagrant_base'
+
+class Chef
+  class Knife
+    class VagrantServerUp < Knife
+
+      include Knife::VagrantBase
+
+      banner "knife vagrant server up SERVER [SERVER]"
+
+      def run
+        $stdout.sync = true
+
+        @name_args.each do |instance|
+          unless vagrant_instance_list.detect { |i| i[:name] == instance }
+            ui.error("No instance named #{instance}")
+            next            
+          end
+
+          state, provider = vagrant_instance_state(instance)
+
+          unless state == 'poweroff'
+            ui.error("Instance #{instance} needs to be powered off for up. Current state is #{colored_vagrant_state(state)}")
+            next
+          end
+
+          vagrant_exec(instance, 'up')
+        end
+      end
+
+    end
+  end
+end

data/lib/knife-vagrant/version.rb

@@ -0,0 +1,6 @@
+module Knife
+  module Vagrant
+    VERSION = "0.0.5"
+    MAJOR, MINOR, TINY = VERSION.split('.')
+  end
+end

metadata

@@ -0,0 +1,89 @@
+--- !ruby/object:Gem::Specification
+name: knife-vagrant2
+version: !ruby/object:Gem::Version
+  version: 0.0.5
+platform: ruby
+authors:
+- Markus Kern
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-12-12 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: chef
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.10.10
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.10.10
+- !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'
+description: Vagrant support for Chef's knife command
+email:
+- makern@users.noreply.github.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- CHANGELOG.md
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- knife-vagrant2.gemspec
+- lib/chef/knife/vagrant_base.rb
+- lib/chef/knife/vagrant_box.rb
+- lib/chef/knife/vagrant_server_create.rb
+- lib/chef/knife/vagrant_server_delete.rb
+- lib/chef/knife/vagrant_server_halt.rb
+- lib/chef/knife/vagrant_server_list.rb
+- lib/chef/knife/vagrant_server_resume.rb
+- lib/chef/knife/vagrant_server_suspend.rb
+- lib/chef/knife/vagrant_server_up.rb
+- lib/knife-vagrant/version.rb
+homepage: https://github.com/makern/knife-vagrant2
+licenses:
+- Apache 2.0
+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.2.2
+signing_key: 
+specification_version: 4
+summary: Vagrant support for Chef's knife command
+test_files: []