knife-wsfusion 0.1.0

data/lib/chef/knife/base_command.rb

@@ -0,0 +1,207 @@
+require 'open3'
+require 'chef/knife'
+
+
+module KnifeWsFusion
+    class BaseCommand < Chef::Knife
+        @@fusion_search_paths = [
+            File.join('/', 'Applications', 'VMware Fusion Tech Preview.app'),
+            File.join('/', 'Applications', 'VMware Fusion.app'),
+        ]
+
+        def is_fusion?
+            @@fusion_search_paths.each do |path|
+                if File.directory?(path)
+                    return true
+                end
+            end
+
+            return false
+        end
+
+        def get_vmrun_path
+            if config[:vmrun_path]
+                return config[:vmrun_path]
+            end
+
+            path = get_exe_from_path('vmrun')
+
+            if path
+                return path
+            end
+
+            if is_fusion?
+                @@fusion_search_paths.each do |search_path|
+                    vmrun_path = File.join(search_path, 'Contents', 'Library',
+                                           'vmrun')
+
+                    if File.executable?(vmrun_path)
+                        return vmrun_path
+                    end
+                end
+            end
+
+            return nil
+        end
+
+        def get_exe_from_path(exe)
+            exts = ENV['PATHEXT'] ? ENV['PATHEXT'].split(';') : ['']
+            ENV['PATH'].split(File::PATH_SEPARATOR).each do |path|
+                exts.each do |ext|
+                    exe_path = File.join(path, "#{exe}#{ext}")
+                    return exe_path if File.executable?(exe_path)
+                end
+            end
+
+            return nil
+        end
+
+        def create_vm_directory(vms_dir, vm_name)
+            if is_fusion?
+                vm_name += '.vmwarevm'
+            end
+
+            vm_dir = File.join(vms_dir, vm_name)
+            Dir.mkdir(vm_dir, 0755)
+
+            return vm_dir
+        end
+
+        def normalize_vmx_path(path)
+            path = File.expand_path(path)
+
+            if not File.exists?(path)
+                return nil
+            end
+
+            if path.end_with?('.vmx')
+                return path
+            end
+
+            if not File.directory?(path)
+                # Well, it had better be a VMX file then.
+                return path
+            end
+
+            Dir.foreach(path) do |filename|
+                if filename.end_with?('.vmx')
+                    return File.join(path, filename)
+                end
+            end
+
+            return nil
+        end
+
+        def run_vmrun(args)
+            vmrun_path = get_vmrun_path()
+            cmd = [vmrun_path] + args
+            out = nil
+            err = nil
+            exit_status = nil
+
+            Chef::Log.debug("Running #{cmd.join(' ')}")
+
+            Open3.popen3(*cmd) do |stdin, stdout, stderr, wait_thr|
+                wait_thr.join()
+
+                out = stdout.read()
+                err = stderr.read()
+
+                exit_status = wait_thr.value
+            end
+
+            Chef::Log.debug("... stdout: {#{out}}")
+            Chef::Log.debug("... stderr: {#{err}}")
+            Chef::Log.debug("... exit code: {#{exit_status}}")
+
+            return exit_status, out, err
+        end
+
+        def set_vmx_variable(vmx_path, key, value)
+            lines = []
+
+            File.open(vmx_path, 'r') do |file|
+                lines = file.readlines()
+            end
+
+            line_re = Regexp.new("^#{key}\s*=")
+
+            File.open(vmx_path, 'w') do |file|
+                lines.each do |line|
+                    if line_re.match(line)
+                        file.write("#{key} = \"#{value}\"\n")
+                    else
+                        file.write(line)
+                    end
+                end
+            end
+        end
+
+        def clone_vm(src_vmx_path, dest_vmx_path, clone_type, clone_name,
+                     snapshot_name=nil)
+            args = [
+                'clone',
+                src_vmx_path,
+                dest_vmx_path,
+                clone_type,
+                #"-cloneName=#{clone_name}",
+            ]
+
+            if snapshot_name
+                args.push("-snapshot=#{snapshot_name}")
+            end
+
+            exit_status, out, err = run_vmrun(args)
+
+            return exit_status == 0
+        end
+
+        def wait_for_ssh(ip_address, port)
+            tcp_socket = TCPSocket.new(ip_address, port)
+            readable = IO.select([tcp_socket], nil, nil, 5)
+
+            if readable
+                Chef::Log.debug("Connected to sshd on #{ip_address}")
+                yield
+                return true
+            else
+                return false
+            end
+        rescue Errno::ETIMEDOUT, Errno::EPERM
+            return false
+        rescue Errno::ECONNREFUSED, Errno::EHOSTUNREACH, Errno::ENETUNREACH
+            sleep 2
+            return false
+        ensure
+            tcp_socket && tcp_socket.close
+        end
+
+        def power_on_vm(vmx_path)
+            exit_status, out, err = run_vmrun(['start', vmx_path, 'nogui'])
+
+            return exit_status == 0
+        end
+
+        def get_tools_state(vmx_path)
+            exit_status, out, err = run_vmrun(['checkToolsState', vmx_path])
+
+            return out.strip()
+        end
+
+        def get_guest_ip_address(vmx_path)
+            exit_status, out, err = \
+                run_vmrun(['getGuestIPAddress', vmx_path, '-wait'])
+
+            if exit_status == 0
+                return out.strip()
+            else
+                return ''
+            end
+        end
+
+        def locate_config_value(key)
+            key = key.to_sym
+            return Chef::Config[:knife][key] || config[key]
+        end
+    end
+end

data/lib/chef/knife/wsfusion_create.rb

@@ -0,0 +1,202 @@
+require 'chef/knife'
+require 'chef/knife/base_command'
+
+
+module KnifeWsFusion
+    class WsfusionCreate < BaseCommand
+        deps do
+            require 'chef/json_compat'
+            require 'chef/knife/bootstrap'
+            Chef::Knife::Bootstrap.load_deps
+        end
+
+        banner "knife wsfusion create (options)"
+
+        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 :use_chef_solo,
+            :long => "--chef-solo",
+            :description => "Use Chef Solo instead of Chef Server",
+            :default => false,
+            :proc => Proc.new { |mode| Chef::Config[:knife][:chef_mode] = mode }
+
+        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 :clone_snapshot_name,
+            :long => '--clone-snapshot-name NAME',
+            :description => 'The name of the snapshot from the template to ' \
+                            'clone'
+
+        option :clone_type,
+            :long => '--clone-type [full|linked]',
+            :description => 'The type of clone to make (full or linked)',
+            :default => 'linked'
+
+        option :distro,
+            :short => "-d DISTRO",
+            :long => "--distro DISTRO",
+            :description => "Bootstrap a distro using a template; default is " \
+                            "'chef-full'",
+            :proc => Proc.new { |d| Chef::Config[:knife][:distro] = d }
+
+        option :identity_file,
+            :short => "-i IDENTITY_FILE",
+            :long => "--identity-file IDENTITY_FILE",
+            :description => "The SSH identity file used for authentication"
+
+        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 :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 :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_user,
+            :short => "-x USERNAME",
+            :long => "--ssh-user USERNAME",
+            :description => "The ssh username",
+            :default => "root"
+
+        option :template_file,
+            :long => "--template-file TEMPLATE",
+            :description => "Full path to the location of the template to use",
+            :proc => Proc.new { |t| Chef::Config[:knife][:template_file] = t },
+            :default => false
+
+        option :vm_source_path,
+            :long => '--vm-source-path PATH',
+            :description => 'Path to the VM used for cloning',
+            :required => true
+
+        option :vm_name,
+            :long => '--vm-name NAME',
+            :description => 'Name of the new VM',
+            :required => true
+
+        option :vmrun_path,
+            :long => '--vmrun-path PATH',
+            :description => 'Custom path to vmrun'
+
+        attr_accessor :initial_sleep_delay
+
+        def run
+            vm_source_path = config[:vm_source_path]
+            src_vmx_path = normalize_vmx_path(vm_source_path)
+
+            if not src_vmx_path
+                ui.fatal("No VM was found at #{vm_source_path}")
+                exit 1
+            end
+
+            vms_dir = File.dirname(File.dirname(src_vmx_path))
+
+            dest_vm_name = config[:vm_name]
+            dest_vm_dir = create_vm_directory(vms_dir, dest_vm_name)
+
+            if not dest_vm_dir
+                ui.fatal('Unable to find a place to create the new VM')
+                exit 1
+            end
+
+            # Check for Tools in the source VM.
+            tools_state = get_tools_state(src_vmx_path)
+
+            if tools_state != 'installed' and tools_state != 'running'
+                ui.fatal("The source VM doesn't appear to have " +
+                         "VMware Tools installed")
+                exit 1
+            end
+
+            dest_vmx_path = File.join(dest_vm_dir, "#{dest_vm_name}.vmx")
+
+            # Create the virtual machine by cloning the existing one.
+            puts "Creating VM #{dest_vm_name} from #{vm_source_path}..."
+
+            success = clone_vm(src_vmx_path, dest_vmx_path, config[:clone_type],
+                               dest_vm_name, config[:clone_snapshot_name])
+
+            if not success
+                ui.fatal("Unable to clone the VM. See the log for details.")
+                exit 1
+            end
+
+            # Now power on the VM.
+            puts "Powering on the new VM..."
+            if not power_on_vm(dest_vmx_path)
+                ui.fatal("Unable to power on the VM. See the log for details.")
+                exit 1
+            end
+
+            # Wait for the guest's IP address.
+            puts "Waiting for an IP address from the guest..."
+            ip_address = get_guest_ip_address(dest_vmx_path)
+
+            # Wait for SSH access.
+            puts "Waiting for sshd..."
+            print ('.') until wait_for_ssh(ip_address, config[:ssh_port]) do
+                sleep @initial_sleep_delay ||= 10;
+                print 'done'
+            end
+
+            if Chef::Config[:knife][:chef_mode] != "solo"
+                puts "Bootstrapping VM"
+                bootstrap_for_node(dest_vm_name, ip_address).run()
+            end
+        end
+
+        def bootstrap_for_node(vm_name, ip_address)
+            knife_config = Chef::Config[:knife]
+
+            bootstrap = Chef::Knife::Bootstrap.new
+            bootstrap.name_args = [ip_address]
+            bootstrap.config[:run_list] = config[:run_list]
+            bootstrap.config[:chef_node_name] = \
+                config[:chef_node_name] || vm_name
+            bootstrap.config[:first_boot_attributes] = \
+                config[:json_attributes] || {}
+            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[:ssh_user] = config[:ssh_user]
+            bootstrap.config[:ssh_password] = config[:ssh_password]
+            bootstrap.config[:use_sudo] = (config[:ssh_user] != 'root')
+            bootstrap.config[:identity_file] = config[:identity_file]
+            bootstrap.config[:no_host_key_verify] = \
+                locate_config_value(:no_host_key_verify)
+            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)
+
+            return bootstrap
+        end
+    end
+end

data/lib/knife-wsfusion/version.rb

@@ -0,0 +1,3 @@
+module KnifeWsFusion
+    VERSION = "0.1"
+end

metadata

@@ -0,0 +1,63 @@
+--- !ruby/object:Gem::Specification
+name: knife-wsfusion
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- Christian Hammond
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-08-22 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: chef
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.10.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.10.0
+description: VMware Workstation/Fusion support for Chef's Knife command.
+email: chipx86@chipx86.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/chef/knife/base_command.rb
+- lib/chef/knife/wsfusion_create.rb
+- lib/knife-wsfusion/version.rb
+homepage: https://github.com/chipx86/knife-wsfusion
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: VMware Workstation/Fusion support for Knife
+test_files: []