knife-vagrant3 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 903e63d91b1390d43259125945d61be2da6e0d94
+  data.tar.gz: a6639aab2fa6aa981343c1f81331b5a5f763a6d3
+SHA512:
+  metadata.gz: ca1a239ff9aa4719786ae503ea52836262d7b80260aa7a32213468279036208fd84a5c5abbadf54a6d64fc96b2b8a12263c8768dea7d9438c620edc6639d3620
+  data.tar.gz: b98869c57ad6d4bd9be1ed25b20f0c67f40985a00803a4216da3788b4778728077e84afae20c0e2ffc7a4e8ce1df00cc289292bc3df6c60a95a92e7bf0cb4d9a

data/.gitignore

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

data/CHANGELOG.md

@@ -0,0 +1,43 @@
+# 0.0.5 (unreleased)
+
+## Changes and new features
+
+## Fixes
+
+
+# 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)

data/Gemfile

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

data/LICENSE

@@ -0,0 +1,13 @@
+Copyright 2013 Markus Kern <chef@mkern.fastmail.fm>
+
+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,4 @@
+knife-vagrant3
+==============
+
+This plugin is an extended version of the [knife-vagrant2 plugin](https://github.com/makern/knife-vagrant2), that adds the ability to create an attach storage when launching the boxes.

data/Rakefile

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

data/knife-vagrant3.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-vagrant3'
+  s.version      = Knife::Vagrant::VERSION
+  s.authors      = ['Markus Kern']
+  s.email        = ['chef@mkern.fastmail.fm']
+  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,173 @@
+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
+
+          # Dir.getwd throws an unknown exception when this plugin
+          # is run in a multi-threaded environment
+          begin
+            cwd = Dir.getwd()
+          rescue
+            no_cwd_change = true
+          end
+
+          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,473 @@
+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_parameters,
+        :long => "--vmx-parameters VMX_PARAMETERS",
+        :description => "List of parameters for the vmware fusion/workstation vagrant provider separated by::"
+
+      option :provider,
+        :long => "--provider Provider",
+        :description => "The vagrant provider to use for the server",
+        :default => 'virtualbox'
+
+      option :inline_config,
+        :long => "--inline_config snippet",
+        :description => "A snippet of configuration to be inserted into the Vagrantfile."
+
+      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,instance_dir)
+        vmx_params = ""
+        if customize
+          customize.chomp! if customize.end_with?("\n")
+          disks = {}
+          customize.split(/::/).each do |p|
+            kv = p.split('=')
+            k = kv[0].strip
+            v = kv[1].strip
+            if v
+              if k.start_with?('scsi')
+                ss = k.split('.')
+                disks[ss[0]] ||= {}
+                case ss[1]
+                  when 'fileName'
+                    if v.start_with?('/')
+                      disks[ss[0]]['fileName'] = v
+                    else
+                      v = File.expand_path(v,instance_dir)
+                      disks[ss[0]]['fileName'] = v
+                    end
+                  when 'fileSize'
+                    disks[ss[0]]['fileSize'] = v
+                    next
+                end
+              end
+              vmx_params += "v.vmx[\"#{k}\"] = \"#{v}\"\n"
+            end
+          end
+          if locate_config_value(:provider).start_with?('vmware')
+            # Create extra disks as unlike virtual box vmware-fusion/workstation
+            # will not create disks automatically based on configuration params
+            disks.each_value do |f|
+              vdiskmgr = %x(which vmware-vdiskmanager)
+              vdiskmgr = "/Applications/VMware Fusion.app/Contents/Library/vmware-vdiskmanager" if vdiskmgr.empty?
+              if File.exist?(vdiskmgr)
+                disk = f['fileName']
+                %x("#{vdiskmgr}" -c -t 0 -s #{f['fileSize']} -a ide #{disk}) unless File.exist?(f['fileName'])
+                unless File.exist?(disk)
+                  ui.error("Disk #{disk} could not be created.")
+                  exit 1
+                end
+              else
+                ui.error("Unable to determine path to vmware-vdiskmanager to create the requested additional disk.")
+                exit 1
+              end
+            end
+          end
+        end
+        vmx_params
+      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
+
+        # Create folder and write Vagrant file
+        instance_dir = File.join(locate_config_value(:vagrant_dir), @server.name)
+        FileUtils.mkdir_p(instance_dir)
+
+        additions = []
+        if @server.use_cachier
+          additions << 'config.cache.auto_detect = true' # enable vagarant-cachier
+        end
+        if @server.inline_config
+          additions << @server.inline_config
+        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_parameters,instance_dir)}
+  end
+
+  config.vm.provider :vmware_workstation do |v|
+    v.vmx["memsize"] = "#{@server.memsize}"
+    #{build_vmx_customize(@server.vmx_parameters,instance_dir)}
+  end
+
+  #{additions.join("\n")}
+end
+        EOF
+        file
+
+        instance_file = File.join(instance_dir, 'Vagrantfile')
+        ui.msg("Creating #{instance_file}")
+        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_parameters => locate_config_value(:vmx_parameters),
+          :inline_config => config[:inline_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.1"
+    MAJOR, MINOR, TINY = VERSION.split('.')
+  end
+end

metadata

@@ -0,0 +1,89 @@
+--- !ruby/object:Gem::Specification
+name: knife-vagrant3
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+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:
+- chef@mkern.fastmail.fm
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- CHANGELOG.md
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- knife-vagrant3.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.4.3
+signing_key: 
+specification_version: 4
+summary: Vagrant support for Chef's knife command
+test_files: []