vsimple 0.1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: bb6e9a72ac2427c4a20d503989bd1aeb0eedf6c9
+  data.tar.gz: 754cf76fbfa08a93b7985d7d49019a97ccf4ba75
+SHA512:
+  metadata.gz: 4f84bee0f2e0dcaac067efd5ed13a7e76250365eefa9a40bc8d2e7a30c6b7a071946a6ebfc5d9d4278d64e66c470fe8dcaeaeea67dd6dbb3dc218205cd79e8e7
+  data.tar.gz: e0c5392bf93754501447615f8ada3fc94f66631553f2c04d9956842d0c3a9cd227071b449b81feb5d7a76b383a8587af12fc9b461d3f57dfc6af2d052e3a8fb3

data/.gitignore

@@ -0,0 +1,9 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/.travis.yml

@@ -0,0 +1,3 @@
+language: ruby
+rvm:
+  - 2.0.0

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in vsimple.gemspec
+gemspec

data/README.md

@@ -0,0 +1,66 @@
+# Vsimple
+
+Simple version of rbvmomi easy to use vpshere.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'vsimple'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install vsimple
+
+## Usage
+
+```
+require "vsimple"
+
+config = {
+    :host => "172.16.1.1",
+    :user => "USER",
+    :pass => "PASS"
+}
+
+Vsimple.connect(config)
+
+Vsimple.set_dc("DATACENTER")
+Vsimple.set_cluster("cluster")
+
+vm = Vsimple::VM.new("template/debian-7.3-amd64")
+begin
+    vm.clone("vms/new_vm.vsimple.fr", {
+        :powerOn => true,
+        :network => {
+            "Network adapter 1" => {
+                :port_group => "ext",
+                :ip         => "192.168.42.42/24",
+                :gw         => "192.168.42.254",
+            }
+        }
+    })
+rescue Vsimple::Error => e
+    puts e.msg
+end
+```
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release` to create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+1. Fork it ( https://github.com/etna-alternance/vsimple )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "vsimple"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start

data/bin/setup

@@ -0,0 +1,7 @@
+#!/bin/bash
+set -euo pipefail
+IFS=$'\n\t'
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/vsimple.rb

@@ -0,0 +1,33 @@
+require "rbvmomi"
+require "vsimple/version"
+require "vsimple/error"
+require "vsimple/config"
+
+require "vsimple/vm"
+
+class Vsimple
+
+    def self.connect(opts)
+        Vsimple::Config[:auth] = {
+            :path     => "/sdk",
+            :port     => 443,
+            :use_ssl  => true,
+            :insecure => "USE_INSECURE_SSL"
+            }
+        Vsimple::Config[:auth].merge! opts
+        Vsimple::Config[:vim] = RbVmomi::VIM.connect Vsimple::Config[:auth]
+    end
+
+    def self.set_dc(dcname)
+        Vsimple::Config[:dc_name] = dcname
+        Vsimple::Config[:dc] = Vsimple::Config[:vim].serviceInstance.find_datacenter(Vsimple::Config[:dc_name])
+        raise Vsimple::Error.new "Datacenter #{dcname} not found" unless Vsimple::Config[:dc]
+    end
+
+    def self.set_cluster(c_name)
+        Vsimple::Config[:cluster_name] = c_name
+        Vsimple::Config[:cluster] = Vsimple::Config[:dc].hostFolder.childEntity.grep(RbVmomi::VIM::ClusterComputeResource).find { |x| x.name == Vsimple::Config[:cluster_name] }
+        raise Vsimple::Error.new "Cluster #{Config[:c_name]} not found" unless Vsimple::Config[:cluster]
+    end
+
+end

data/lib/vsimple/config.rb

@@ -0,0 +1,13 @@
+require 'mixlib/config'
+
+class Vsimple
+    class Config
+
+        extend Mixlib::Config
+
+        def self.inspect
+            configuration.inspect
+        end
+
+    end
+end

data/lib/vsimple/error.rb

@@ -0,0 +1,11 @@
+class Vsimple
+    class Error < RuntimeError
+
+        attr :msg
+
+        def initialize(msg)
+            @msg = msg
+        end
+
+    end
+end

data/lib/vsimple/version.rb

@@ -0,0 +1,3 @@
+class Vsimple
+  VERSION = "0.1.1"
+end

data/lib/vsimple/vm.rb

@@ -0,0 +1,375 @@
+require 'netaddr'
+
+class Vsimple
+    class VM
+
+        def initialize(path)
+            @vm = Vsimple::Config[:dc].vmFolder.traverse(path, RbVmomi::VIM::VirtualMachine)
+            raise Vsimple::Error.new "VM #{path} not found" unless @vm
+        end
+
+        def name
+            @vm.name
+        end
+
+        def self.exist?(path)
+            if Vsimple::Config[:dc].vmFolder.traverse(path, RbVmomi::VIM::VirtualMachine)
+                true
+            else
+                false
+            end
+        end
+
+        def powerOn
+            begin
+                @vm.PowerOnVM_Task.wait_for_completion
+            rescue => e
+                raise Vsimple::Error.new "Power on vm #{@vm.name}: #{e.message}"
+            end
+        end
+
+        def poweredOff
+            begin
+                @vm.PowerOffVM_Task.wait_for_completion
+            rescue => e
+                raise Vsimple::Error.new "Power off vm #{@vm.name}: #{e.message}"
+            end
+        end
+
+        def shutdownGuest
+            begin
+                @vm.ShutdownGuest
+            rescue => e
+                raise Vsimple::Error.new "Shutdown vm #{@vm.name}: #{e.message}"
+            end
+        end
+
+        def powerState
+            @vm.summary.runtime.powerState
+        end
+
+        def rebootGuest
+            begin
+                @vm.RebootGuest
+            rescue => e
+                raise Vsimple::Error.new "RebootGuest vm #{@vm.name}: #{e.message}"
+            end
+        end
+
+        def guestToolsReady?
+            @vm.guest.toolsRunningStatus == "guestToolsRunning"
+        end
+
+        # Clone the VirtualMachine.
+        #
+        # == Parameters:
+        # name::
+        #    Name of the machine. Can be the FQDN.
+        #
+        # vm_config::
+        #    machine_options:
+        #    * :path     => Path of the VM
+        #    * :hostname => Hostname of the VM
+        #    * :domain   => Domain name of the VM
+        #    * :powerOn  => Flags to start the VM after the clone (true or false)
+        #    * :ip_dns   => IP separed by commate of the DNS server
+        #    * :network => Network configuration. exemple:
+        #        vm_config[:network] = {
+        #            "Network adapter 1" => {
+        #                :port_group => "port_group_name",
+        #                :ip   => "172.16.1.1/24",
+        #                :gw   => "172.16.1.254"
+        #            }
+        #        }
+        #    Windows only:
+        #    * :commandList
+        #    * :password
+        #    * :timeZone
+        #    * :identification_domainAdmin
+        #    * :identification_domainAdminPassword
+        #    * :identification_joinDomain
+        #    * :identification_joinWorkgroup
+        #    * :userData_orgName
+        #    * :userData_productId
+        #
+        def clone(name, vm_config={})
+            unless vm_config[:path]
+                if name.include?('/')
+                    vm_config[:path] = File.dirname(name)
+                else
+                    vm_config[:path] = ""
+                end
+            end
+            name = File.basename(name)
+
+            vm_config[:hostname] ||= name[/^([^.]*)/, 1]
+            vm_config[:domain]   ||= name[/^[^.]*.(.*)$/, 1]
+
+            clone_spec  = generate_clone_spec(vm_config)
+            dest_folder = Vsimple::Config[:dc].vmFolder.traverse!(vm_config[:path], RbVmomi::VIM::Folder)
+
+            begin
+                @vm.CloneVM_Task(
+                    :folder => dest_folder,
+                    :name   => name,
+                    :spec   => clone_spec
+                ).wait_for_completion
+            rescue => e
+                raise Vsimple::Error.new "Clone vm #{@vm.name}: #{e.message}"
+            end
+
+            Vsimple::VM.new("#{vm_config[:path]}/#{name}")
+        end
+
+        # Check if the machine is a windows
+        #
+        # == Parameters:
+        # vm::
+        #     VM instance given by rbvmomi
+        def is_windows?
+            @vm.summary.config.guestFullName =~ /^Microsoft Windows/
+        end
+
+        # Wait until the guest tools of the machine is start or until timeout if given.
+        #
+        # == Parameters:
+        # server::
+        #     VM instance given by rbvmomi
+        #
+        # timeout::
+        #     Timeout
+        def wait_guest_tools_ready(timeout=nil)
+            wait = 1
+            while @vm.guest.toolsRunningStatus != "guestToolsRunning" && (!timeout || wait < timeout)
+                sleep 1
+                wait += 1
+            end
+            @vm.guest.toolsRunningStatus == "guestToolsRunning"
+        end
+
+        # Wait until the machine stop or until timeout if given
+        #
+        # == Parameters:
+        # server::
+        #     VM instance given by rbvmomi
+        #
+        # timeout::
+        #     Timeout
+        def wait_to_stop(timeout=nil)
+            wait = 1
+            while @vm.summary.runtime.powerState != "poweredOff" && (!timeout || wait < timeout)
+                sleep 1
+                wait += 1
+            end
+            @vm.summary.runtime.powerState == "poweredOff"
+        end
+
+
+        protected
+
+
+        # Generate the adaptater mapping for a network card
+        #
+        # == Parameters:
+        # ip::
+        #     The ip. If not given, use the dhcp configuration
+        # gw::
+        #     The gateway.
+        def generate_adapter_map(ip=nil, gw=nil)
+            settings = RbVmomi::VIM.CustomizationIPSettings
+
+            if ip.nil?
+                settings.ip = RbVmomi::VIM::CustomizationDhcpIpGenerator
+            else
+                cidr_ip             = NetAddr::CIDR.create(ip)
+                settings.ip         = RbVmomi::VIM::CustomizationFixedIp(:ipAddress => cidr_ip.ip)
+                settings.subnetMask = cidr_ip.netmask_ext
+                unless gw.nil?
+                    gw_cidr          = NetAddr::CIDR.create(gw)
+                    settings.gateway = [gw_cidr.ip]
+                end
+            end
+
+            adapter_map         = RbVmomi::VIM.CustomizationAdapterMapping
+            adapter_map.adapter = settings
+            adapter_map
+        end
+
+        # Find a network with a name.
+        #
+        # == Parameters:
+        # networkName::
+        #      The network name.
+        #
+        # == Return Value:
+        # Network instance given by rbvmomi. If the network doesn't exists, an exception will rise.
+        #
+        def find_network(networkName)
+            baseEntity = Vsimple::Config[:dc].network
+            baseEntity.find { |f| f.name == networkName } or raise Vsimple::Error.new "no such network #{networkName}"
+        end
+
+        # Generate the clone specification.
+        #
+        # == Parameters:
+        # vm_config::
+        #      The vm configuration for the new VM.
+        def generate_clone_spec(vm_config)
+            rp         = Vsimple::Config[:cluster].resourcePool
+            rspec      = RbVmomi::VIM.VirtualMachineRelocateSpec(:pool => rp)
+            vm_config[:powerOn] ||= false
+            clone_spec = RbVmomi::VIM.VirtualMachineCloneSpec({
+                :location => rspec,
+                :powerOn  => vm_config[:powerOn],
+                :template => false
+            })
+
+            clone_spec.config        = RbVmomi::VIM.VirtualMachineConfigSpec(:deviceChange => Array.new)
+            clone_spec.customization = generate_custom_spec(clone_spec, vm_config)
+
+            clone_spec
+        end
+
+        # Generate the Customization Specification.
+        #
+        # == Parameters:
+        # clone_spec::
+        #   the clone specification passed by #generate_clone_spec.
+        #
+        # vm_config::
+        #   The vm configuration for the new VM.
+        #
+        def generate_custom_spec(clone_spec, vm_config)
+            src_config = @vm.config
+
+            global_ipset = RbVmomi::VIM.CustomizationGlobalIPSettings
+            cust_spec    = RbVmomi::VIM.CustomizationSpec(:globalIPSettings => global_ipset)
+
+            cust_spec.globalIPSettings.dnsServerList = vm_config[:ip_dns].split(',') if vm_config[:ip_dns]
+            cust_spec.globalIPSettings.dnsSuffixList = vm_config[:domain].split(',')
+
+            nicSettingMap = []
+            src_cards     = []
+            src_config.hardware.device.each do |dev|
+                if dev.deviceInfo.label =~ /^Network adapter/
+                    src_cards << dev.deviceInfo.label
+                end
+            end
+
+            src_cards.each do |name|
+                if vm_config[:network]
+                    config = vm_config[:network][name]
+                else
+                    config = nil
+                end
+
+                card = src_config.hardware.device.find { |d| d.deviceInfo.label == name }
+                unless card
+                    raise Vsimple::Error.new "Can't find source network card #{name} to customize"
+                end
+
+                if config && config[:port_group]
+                    network = find_network(config[:port_group])
+                    begin
+                        switch_port = RbVmomi::VIM.DistributedVirtualSwitchPortConnection(
+                            :switchUuid   => network.config.distributedVirtualSwitch.uuid,
+                            :portgroupKey => network.key
+                        )
+                        card.backing.port = switch_port
+                    rescue
+                        card.backing.deviceName = network.name
+                    end
+                else
+                    switch_port = RbVmomi::VIM.DistributedVirtualSwitchPortConnection(
+                        :switchUuid   => card.backing.port.switchUuid,
+                        :portgroupKey => card.backing.port.portgroupKey
+                    )
+                    card.backing.port = switch_port
+                end
+
+                clone_spec.config.deviceChange.push RbVmomi::VIM.VirtualDeviceConfigSpec(
+                    :device    => card,
+                    :operation => "edit"
+                )
+
+                if config && config[:ip]
+                    nicSettingMap << generate_adapter_map(config[:ip], config[:gw])
+                else
+                    cam            = RbVmomi::VIM.CustomizationAdapterMapping
+                    cam.adapter    = RbVmomi::VIM.CustomizationIPSettings
+                    cam.adapter.ip = RbVmomi::VIM.CustomizationDhcpIpGenerator
+                    nicSettingMap << cam
+                end
+
+            end
+
+            cust_spec.nicSettingMap = nicSettingMap
+            if is_windows?
+                cust_spec.identity = generate_win_ident(vm_config)
+                cust_spec.options  = generate_win_opts
+            else
+                cust_spec.identity = generate_linux_ident(vm_config)
+            end
+
+            cust_spec
+        end
+
+        def generate_win_ident(vm_config)
+            ident = RbVmomi::VIM.CustomizationSysprep
+
+            if vm_config[:commandList]
+                guiRunOnce             = RbVmomi::VIM.CustomizationGuiRunOnce
+                guiRunOnce.commandList = vm_config[:commandList]
+                ident.guiRunOnce       = guiRunOnce
+            else
+                ident.guiRunOnce       = nil
+            end
+
+            guiUnattended                = RbVmomi::VIM.CustomizationGuiUnattended
+            guiUnattended.autoLogon      = false
+            guiUnattended.autoLogonCount = 1
+            password                     = RbVmomi::VIM.CustomizationPassword
+            password.plainText           = true
+            password.value               = vm_config[:password]
+            guiUnattended.password       = password
+            guiUnattended.timeZone       = "#{vm_config[:timeZone]}"
+            ident.guiUnattended          = guiUnattended
+
+            identification                     = RbVmomi::VIM.CustomizationIdentification
+            identification.domainAdmin         = vm_config[:identification_domainAdmin]
+            identification.domainAdminPassword = vm_config[:identification_domainAdminPassword]
+            identification.joinDomain          = vm_config[:identification_joinDomain]
+            identification.joinWorkgroup       = vm_config[:identification_joinWorkgroup]
+            ident.identification               = identification
+
+            userData              = RbVmomi::VIM.CustomizationUserData
+
+            computerName          = RbVmomi::VIM.CustomizationFixedName
+            computerName.name     = vm_config[:hostname].upcase
+
+            userData.computerName = computerName
+            userData.fullName     = "#{vm_config[:hostname]}.#{vm_config[:domain]}"
+            userData.orgName      = vm_config[:userData_orgName]
+            userData.productId    = vm_config[:userData_productId]
+            ident.userData        = userData
+            ident
+        end
+
+        def generate_win_opts()
+            new_windowsOptions                = RbVmomi::VIM.CustomizationWinOptions
+            new_windowsOptions.changeSID      = true
+            new_windowsOptions.deleteAccounts = false
+            new_windowsOptions
+        end
+
+        def generate_linux_ident(vm_config)
+            ident = RbVmomi::VIM.CustomizationLinuxPrep
+
+            ident.hostName      = RbVmomi::VIM.CustomizationFixedName
+            ident.hostName.name = vm_config[:hostname]
+            ident.domain        = vm_config[:domain]
+            ident
+        end
+
+    end
+end

data/vsimple.gemspec

@@ -0,0 +1,27 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'vsimple/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "vsimple"
+  spec.version       = Vsimple::VERSION
+  spec.authors       = ["Steven Pojer"]
+  spec.email         = ["steven.pojer@etna-alternance.net"]
+
+  spec.summary       = "Simple version of rbvmomi easy to use vpshere."
+  spec.description   = spec.summary
+  spec.homepage      = "https://github.com/etna-alternance/vsimple"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_runtime_dependency "rbvmomi", "~> 1.6"
+  spec.add_runtime_dependency "netaddr", "~> 1.5"
+  spec.add_runtime_dependency "mixlib-config", "~> 2.0"
+
+  spec.add_development_dependency "bundler", "~> 1.9"
+  spec.add_development_dependency "rake", "~> 10.0"
+end

metadata

@@ -0,0 +1,126 @@
+--- !ruby/object:Gem::Specification
+name: vsimple
+version: !ruby/object:Gem::Version
+  version: 0.1.1
+platform: ruby
+authors:
+- Steven Pojer
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2015-07-21 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rbvmomi
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.6'
+- !ruby/object:Gem::Dependency
+  name: netaddr
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.5'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.5'
+- !ruby/object:Gem::Dependency
+  name: mixlib-config
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.9'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.9'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '10.0'
+description: Simple version of rbvmomi easy to use vpshere.
+email:
+- steven.pojer@etna-alternance.net
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .travis.yml
+- Gemfile
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- lib/vsimple.rb
+- lib/vsimple/config.rb
+- lib/vsimple/error.rb
+- lib/vsimple/version.rb
+- lib/vsimple/vm.rb
+- vsimple.gemspec
+homepage: https://github.com/etna-alternance/vsimple
+licenses: []
+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.6
+signing_key: 
+specification_version: 4
+summary: Simple version of rbvmomi easy to use vpshere.
+test_files: []