vagrant-vcloud 0.4.4 → 0.4.6

data/lib/vagrant-vcloud/action/forward_ports.rb

@@ -14,7 +14,7 @@ module VagrantPlugins
 
           # Get the ports we are forwarding
           env[:forwarded_ports] ||= compile_forwarded_ports(
-            env[:machine].config
+            env[:machine]
           )
 
           forward_ports
@@ -23,7 +23,7 @@ module VagrantPlugins
         end
 
         def forward_ports
-          ports = []
+          ports = {}
           edge_ports = []
 
           cfg = @env[:machine].provider_config
@@ -41,6 +41,7 @@ module VagrantPlugins
           @logger.debug('Getting VM info...')
           vm = cnx.get_vapp(vapp_id)
           vm_info = vm[:vms_hash][vm_name.to_sym]
+          network_name = ''
 
           @env[:forwarded_ports].each do |fp|
 
@@ -50,12 +51,17 @@ module VagrantPlugins
             )
 
             # Add the options to the ports array to send to the driver later
-            ports << {
+            ports["#{fp.network_name}#{fp.edge_network_name}"] = { rules: [] } if !ports["#{fp.network_name}#{fp.edge_network_name}"]
+            ports["#{fp.network_name}#{fp.edge_network_name}"][:network_name]      = fp.network_name
+            ports["#{fp.network_name}#{fp.edge_network_name}"][:parent_network]    = fp.edge_network_id
+            ports["#{fp.network_name}#{fp.edge_network_name}"][:edge_network_name] = fp.edge_network_name
+            ports["#{fp.network_name}#{fp.edge_network_name}"][:rules] << {
               :guestip                => fp.guest_ip,
               :nat_internal_port      => fp.guest_port,
               :hostip                 => fp.host_ip,
               :nat_external_port      => fp.host_port,
               :name                   => fp.id,
+              :nat_vmnic_id           => fp.vmnic_id,
               :nat_protocol           => fp.protocol.upcase,
               :vapp_scoped_local_id   => vm_info[:vapp_scoped_local_id]
             }
@@ -64,24 +70,26 @@ module VagrantPlugins
           if !ports.empty?
             # We only need to forward ports if there are any to forward
             @logger.debug("Port object to be passed: #{ports.inspect}")
-            @logger.debug("Current network id #{cfg.vdc_network_id}")
 
             ### Here we apply the nat_rules to the vApp we just built
-            add_ports = cnx.add_vapp_port_forwarding_rules(
-              vapp_id,
-              'Vagrant-vApp-Net',
-              {
-                :fence_mode       => 'natRouted',
-                :parent_network   => cfg.vdc_network_id,
-                :nat_policy_type  => 'allowTraffic',
-                :nat_rules        => ports
-              }
-            )
-
-            wait = cnx.wait_task_completion(add_ports)
-
-            if !wait[:errormsg].nil?
-              raise Errors::ComposeVAppError, :message => wait[:errormsg]
+            ports.values.each do |port|
+              add_ports = cnx.add_vapp_port_forwarding_rules(
+                vapp_id,
+                port[:network_name],
+                port[:edge_network_name],
+                {
+                  :fence_mode       => 'natRouted',
+                  :parent_network   => port[:parent_network],
+                  :nat_policy_type  => 'allowTraffic',
+                  :nat_rules        => port[:rules]
+                }
+              )
+
+              wait = cnx.wait_task_completion(add_ports)
+
+              if !wait[:errormsg].nil?
+                raise Errors::ComposeVAppError, :message => wait[:errormsg]
+              end
             end
 
 
@@ -97,15 +105,17 @@ module VagrantPlugins
                                                                 r[:translated_ip] == vapp_edge_ip)}
               vapp_edge_ports_in_use = vapp_edge_dnat_rules.map{|r| r[:original_port].to_i}.to_set
 
-              ports.each do |port|
-                if port[:vapp_scoped_local_id] == vm_info[:vapp_scoped_local_id] &&
-                  !vapp_edge_ports_in_use.include?(port[:nat_external_port])
-                  @env[:ui].info(
-                    "Creating NAT rules on [#{cfg.vdc_edge_gateway}] " +
-                    "for IP [#{vapp_edge_ip}] port #{port[:nat_external_port]}."
-                  )
-
-                  edge_ports << port[:nat_external_port]
+              ports.values.each do |port|
+                port[:rules].each do |rule|
+                  if rule[:vapp_scoped_local_id] == vm_info[:vapp_scoped_local_id] &&
+                    !vapp_edge_ports_in_use.include?(rule[:nat_external_port])
+                    @env[:ui].info(
+                      "Creating NAT rules on [#{cfg.vdc_edge_gateway}] " +
+                      "for IP [#{vapp_edge_ip}] port #{rule[:nat_external_port]}."
+                    )
+
+                    edge_ports << rule[:nat_external_port]
+                  end
                 end
               end
 

data/lib/vagrant-vcloud/action/handle_nat_port_collisions.rb

@@ -47,7 +47,9 @@ module VagrantPlugins
           vm = cnx.get_vapp(vapp_id)
           vm_info = vm[:vms_hash][vm_name.to_sym]
 
-          vapp_edge_ip = cnx.get_vapp_edge_public_ip(vapp_id)
+          network_name = get_edge_network_name(env)
+
+          vapp_edge_ip = cnx.get_vapp_edge_public_ip(vapp_id, network_name)
 
           @logger.debug('Getting edge gateway port forwarding rules...')
           edge_gateway_rules = cnx.get_edge_gateway_rules(cfg.vdc_edge_gateway,
@@ -56,7 +58,7 @@ module VagrantPlugins
           edge_ports_in_use = edge_dnat_rules.map{|r| r[:original_port].to_i}.to_set
 
           @logger.debug('Getting port forwarding rules...')
-          vapp_nat_rules = cnx.get_vapp_port_forwarding_rules(vapp_id)
+          vapp_nat_rules = cnx.get_vapp_port_forwarding_rules(vapp_id, network_name)
           ports_in_use = vapp_nat_rules.map{|r| r[:nat_external_port].to_i}.to_set
 
           # merge the vapp ports and the edge gateway ports together, all are in use
@@ -143,9 +145,33 @@ module VagrantPlugins
           env[:machine].config.vm.networks.each do |type, options|
             # Ignore anything but forwarded ports
             next if type != :forwarded_port
+            next if !options[:disabled].nil? && options[:disabled] == true
 
             yield options
           end
+          # advanced networking check
+          if !env[:machine].provider_config.nics.nil?
+            env[:machine].provider_config.nics.each do |nic|
+              next if nic[:forwarded_port].nil?
+              nic[:forwarded_port].each do |fp|
+                next if !fp[:disabled].nil? && fp[:disabled] == true
+                yield fp
+              end
+            end
+          end
+        end
+
+        def get_edge_network_name(env)
+          # advanced networking check
+          if !env[:machine].provider_config.networks.nil?
+            env[:machine].provider_config.networks[:vapp].each do |net|
+              # Ignore anything but forwarded ports
+              next if net[:vdc_network_name].nil?
+
+              return net[:vdc_network_name]
+            end
+          end
+          return env[:machine].provider_config.vdc_network_name
         end
       end
     end

data/lib/vagrant-vcloud/action/inventory_check.rb

@@ -138,14 +138,16 @@ module VagrantPlugins
           @logger.debug("Catalog item is now #{cfg.catalog_item}")
 
           # This only works with Org Admin role or higher
-          cfg.vdc_network_id = cfg.org[:networks][cfg.vdc_network_name]
-          if !cfg.vdc_network_id
-            # TEMP FIX: permissions issues at the Org Level for vApp authors
-            #           to "view" Org vDC Networks but they can see them at the
-            #           Organization vDC level (tsugliani)
-            cfg.vdc_network_id = cfg.vdc[:networks][cfg.vdc_network_name]
+          if cfg.vdc_network_name
+            cfg.vdc_network_id = cfg.org[:networks][cfg.vdc_network_name]
             if !cfg.vdc_network_id
-              raise 'vCloud User credentials has insufficient privileges'
+              # TEMP FIX: permissions issues at the Org Level for vApp authors
+              #           to "view" Org vDC Networks but they can see them at the
+              #           Organization vDC level (tsugliani)
+              cfg.vdc_network_id = cfg.vdc[:networks][cfg.vdc_network_name]
+              if !cfg.vdc_network_id
+                raise 'vCloud User credentials has insufficient privileges'
+              end
             end
           end
 
@@ -167,13 +169,17 @@ module VagrantPlugins
               "in Catalog [#{cfg.catalog_name}] does not exist!"
             )
 
-            user_input = env[:ui].ask(
-              "Would you like to upload the [#{box_name}] " +
-              "box to [#{cfg.catalog_name}] Catalog?\n" +
-              'Choice (yes/no): '
-            )
-
-            if user_input.downcase == 'yes' || user_input.downcase == 'y'
+            if cfg.auto_yes_for_upload.nil? || cfg.auto_yes_for_upload == false
+	            user_input = env[:ui].ask(
+	              "Would you like to upload the [#{box_name}] " +
+	              "box to [#{cfg.catalog_name}] Catalog?\n" +
+	              'Choice (yes/no): '
+	            )
+	        else
+	        	auto_upload = cfg.auto_yes_for_upload
+	        end
+
+            if !auto_upload.nil? || user_input.downcase == 'yes' || user_input.downcase == 'y'
               env[:ui].info("Uploading [#{box_name}]...")
               vcloud_upload_box(env)
             else

data/lib/vagrant-vcloud/action/power_off_vapp.rb

@@ -21,7 +21,9 @@ module VagrantPlugins
 
           # this is a helper to get vapp_edge_ip into cache for later destroy
           # of edge gateway rules
-          vapp_edge_ip = cnx.get_vapp_edge_public_ip(vapp_id) if cfg.network_bridge.nil?
+          if cfg.network_bridge.nil? && cfg.networks.nil?
+            vapp_edge_ip = cnx.get_vapp_edge_public_ip(vapp_id)
+          end
 
           # Poweroff vApp
           env[:ui].info('Single VM left in the vApp, Powering off vApp...')

data/lib/vagrant-vcloud/action/power_on.rb

@@ -13,24 +13,51 @@ module VagrantPlugins
           cfg = env[:machine].provider_config
           cnx = cfg.vcloud_cnx.driver
 
-          env[:ui].info('Setting VM hardware...')
+          # add vm metadata
+          if !cfg.metadata_vm.nil?
+            env[:ui].info('Setting VM metadata...')
+            set_metadata_vm = cnx.set_vm_metadata env[:machine].id, cfg.metadata_vm
+            cnx.wait_task_completion(set_metadata_vm)
+          end
 
+          # add/update hardware
+          env[:ui].info('Setting VM hardware...')
           set_vm_hardware = cnx.set_vm_hardware(env[:machine].id, cfg)
           if set_vm_hardware
-            cnx.wait_task_completion(set_vm_hardware)
+            wait = cnx.wait_task_completion(set_vm_hardware)
+            unless wait[:errormsg].nil?
+              fail Errors::ModifyVAppError, :message => wait[:errormsg]
+            end
+          end
+          set_vm_network_connected = cnx.set_vm_network_connected(env[:machine].id)
+          if set_vm_network_connected
+            env[:ui].info('Connecting all NICs...')
+            wait = cnx.wait_task_completion(set_vm_network_connected)
+            unless wait[:errormsg].nil?
+              fail Errors::ModifyVAppError, :message => wait[:errormsg]
+            end
           end
 
-          env[:ui].info('Powering on VM...')
-
-          if ! cfg.nested_hypervisor.nil?
-            set_vm_nested_hypervisor = cnx.set_vm_nested_hypervisor(env[:machine].id, cfg.nested_hypervisor)
+          # enable nested hypervisor
+          if !cfg.nested_hypervisor.nil? && cfg.nested_hypervisor == true
+            env[:ui].info('Enabling nested hypervisor...')
+            set_vm_nested_hypervisor = cnx.set_vm_nested_hypervisor(env[:machine].id, true)
             if set_vm_nested_hypervisor
-              cnx.wait_task_completion(set_vm_nested_hypervisor)
+              wait = cnx.wait_task_completion(set_vm_nested_hypervisor)
+              unless wait[:errormsg].nil?
+                fail Errors::ModifyVAppError, :message => wait[:errormsg]
+              end
             end
           end
 
-          poweron_vm = cnx.poweron_vm(env[:machine].id)
-          cnx.wait_task_completion(poweron_vm)
+          if cfg.power_on.nil? || cfg.power_on == true
+            env[:ui].info('Powering on VM...')
+            poweron_vm = cnx.poweron_vm(env[:machine].id)
+            wait = cnx.wait_task_completion(poweron_vm)
+            unless wait[:errormsg].nil?
+              fail Errors::PoweronVAppError, :message => wait[:errormsg]
+            end
+          end
 
           @app.call(env)
         end

data/lib/vagrant-vcloud/action/read_ssh_info.rb

@@ -17,6 +17,7 @@ module VagrantPlugins
         # Small method to check the tcp connection to an ip:port works.
         # Return false if anything fails, and true if it succeeded.
         def check_for_port(ip, port, port_name)
+          @logger.debug("Checking #{port_name} (#{ip}:#{port})...")
           begin
             Timeout::timeout(1) do
               begin
@@ -71,9 +72,22 @@ module VagrantPlugins
             @external_ip = vm_info[:networks]['Vagrant-vApp-Net'][:ip]
             @external_port = "#{@port}"
           else
+            network_name = nil
+            if cfg.nics
+              cfg.nics.each do |nic|
+                next if nic[:forwarded_port].nil?
+                if !cfg.networks.nil? && !cfg.networks[:vapp].nil?
+                  cfg.networks[:vapp].each do |net|
+                    next if net[:name] != nic[:network]
+                    network_name = net[:vdc_network_name]
+                    break
+                  end
+                end
+              end
+            end
 
             @logger.debug('Getting port forwarding rules...')
-            rules = cnx.get_vapp_port_forwarding_rules(vapp_id)
+            rules = cnx.get_vapp_port_forwarding_rules(vapp_id, network_name)
 
             rules.each do |rule|
               if rule[:vapp_scoped_local_id] == myhash[:vapp_scoped_local_id] && rule[:nat_internal_port] == "#{@port}"

data/lib/vagrant-vcloud/action/shut_down.rb

@@ -0,0 +1,33 @@
+module VagrantPlugins
+  module VCloud
+    module Action
+      class ShutDown
+        def initialize(app, env)
+          @app = app
+          @logger = Log4r::Logger.new('vagrant_vcloud::action::shutdown')
+        end
+
+        def call(env)
+          cfg = env[:machine].provider_config
+          cnx = cfg.vcloud_cnx.driver
+
+          vapp_id = env[:machine].get_vapp_id
+          vm_id = env[:machine].id
+
+          test_vapp = cnx.get_vapp(vapp_id)
+
+          @logger.debug(
+            "Number of VMs in the vApp: #{test_vapp[:vms_hash].count}"
+          )
+
+          # Shutdown VM
+          env[:ui].info('Shutting down VM...')
+          task_id = cnx.shutdown_vm(vm_id)
+          cnx.wait_task_completion(task_id)
+
+          @app.call env
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-vcloud/config.rb

@@ -146,6 +146,122 @@ module VagrantPlugins
       # NestedHypervisor (Bool)
       attr_accessor :nested_hypervisor
 
+      # Specify a vApp name (String)
+      attr_accessor :vapp_name
+
+      # Use advanced networking settings (Bool = false)
+      attr_accessor :advanced_network
+
+      # Specify networks to add to the vApp (Hash)
+      #   networks: {
+      #     org: [ 'Organization VDC network' ],
+      #     vapp: [ {
+      #               name: 'vApp network',
+      #               ip_subnet: '172.16.4.0/255.255.255.0'
+      #           } ]
+      #   }
+      #
+      attr_accessor :networks
+
+      # Add hard disks to the VM (Array)
+      #   add_hdds: [ 20480 ]
+      #
+      attr_accessor :add_hdds
+
+      # Update / add network cards to the VM (Array)
+      # type is not updated for existing network cards
+      #   nics: [ {
+      #     type: :vmxnet3,
+      #     connected: true,
+      #     network: "vApp network",
+      #     primary: true,
+      #     ip_mode: "static",
+      #     ip: "10.10.10.1",
+      #     mac: "00:50:56:00:00:01"
+      #   } ]
+      #
+      attr_accessor :nics
+
+      # Power on the VM once created (Bool = true)
+      attr_accessor :power_on
+
+      # Attempt to connect via SSH to the VM (Bool = true)
+      attr_accessor :ssh_enabled
+
+      # Attempt to sync files to the VM (Bool = true)
+      attr_accessor :sync_enabled
+
+      # Turn DHCP on for this network (Bool = false)
+      attr_accessor :dhcp_enabled
+
+      # POOL ip range if dhcp is enabled (Array)
+      attr_accessor :pool_range
+
+      # DHCP ip range if enabled (Array)
+      attr_accessor :dhcp_range
+
+      # Add metadata to the vApp (Array)
+      #   metadata_vapp: [
+      #     [ 'key', 'value' ]
+      #   ]
+      #
+      attr_accessor :metadata_vapp
+
+      # Add metadata to the VM (Array)
+      #   metadata_vapp: [
+      #     [ 'key', 'value' ]
+      #   ]
+      #
+      attr_accessor :metadata_vm
+
+      # Auto answer "Yes" to upload the box to vCloud (Bool = false)
+      attr_accessor :auto_yes_for_upload
+
+      # ability to disable gc for vms without tools installed
+      attr_accessor :enable_guest_customization
+
+      # scripts to run on machine boot
+      attr_accessor :guest_customization_script
+
+      # guest customization change sid setting (Windows only) (Bool = false)
+      attr_accessor :guest_customization_change_sid
+
+      # guest customization join domain (Windows only) (Bool = false)
+      attr_accessor :guest_customization_join_domain
+
+      # guest customization domain name (Windows only) (String)
+      attr_accessor :guest_customization_domain_name
+
+      # guest customization domain user name (Windows only) (String)
+      attr_accessor :guest_customization_domain_user_name
+
+      # guest customization domain user password (Windows only) (String)
+      attr_accessor :guest_customization_domain_user_password
+
+      # guest customization domain machine ou (Windows only) (String)
+      attr_accessor :guest_customization_domain_ou
+
+      # guest customization local admin (Bool = false)
+      attr_accessor :guest_customization_admin_password_enabled
+
+      # guest customization auto generate admin password (Bool = false)
+      attr_accessor :guest_customization_admin_password_auto
+
+      # guest customization specify admin password (String)
+      attr_accessor :guest_customization_admin_password
+
+      # guest customization admin auto login (Windows only) (Bool = false)
+      attr_accessor :guest_customization_admin_auto_login
+
+      # guest customization admin auto login count (Windows only) (Integer)
+      attr_reader :guest_customization_admin_auto_login_count
+      def guest_customization_admin_auto_login_count=(count)
+        @guest_customization_admin_auto_login_count = count.to_i
+      end
+
+      # guest customization admin require password reset (Bool = false)
+      attr_accessor :guest_customization_admin_password_reset
+
       def validate(machine)
         errors = _detected_errors
 
@@ -169,10 +285,66 @@ module VagrantPlugins
           errors << I18n.t('vagrant_vcloud.config.vdc_name')
         end
 
-        if vdc_network_name.nil?
+        if networks.nil? && vdc_network_name.nil?
           errors << I18n.t('vagrant_vcloud.config.vdc_network_name')
         end
 
+        # guest customization
+        if enable_guest_customization.nil? ||
+           enable_guest_customization == false
+          if guest_customization_change_sid == true
+            errors << I18n.t('vagrant_vcloud.gc.change_sid')
+          end
+          if !guest_customization_admin_password_enabled.nil?
+            errors << I18n.t('vagrant_vcloud.gc.admin_password')
+          end
+          if !guest_customization_admin_password_reset.nil?
+            errors << I18n.t('vagrant_vcloud.gc.admin_password_reset')
+          end
+          if !guest_customization_script.nil?
+            errors << I18n.t('vagrant_vcloud.gc.script')
+          end
+        else
+          if guest_customization_change_sid.nil? ||
+             guest_customization_change_sid == false
+            if guest_customization_join_domain == true
+              errors << I18n.t('vagrant_vcloud.gc.domain')
+            end
+          else
+            if guest_customization_join_domain == true
+              if guest_customization_domain_name.nil? ||
+                 guest_customization_domain_user_name.nil? ||
+                 guest_customization_domain_user_password.nil?
+                errors << I18n.t('vagrant_vcloud.gc.domain_join')
+              end
+            end
+          end
+          if guest_customization_admin_password_enabled.nil? ||
+             guest_customization_admin_password_enabled == false
+            if guest_customization_admin_auto_login == true
+              errors << I18n.t('vagrant_vcloud.gc.auto_login')
+            end
+          else
+            if guest_customization_admin_auto_login == true
+              if guest_customization_admin_password_auto.nil? ||
+                 guest_customization_admin_password_auto == false
+                if guest_customization_admin_password.nil? ||
+                   guest_customization_admin_password.empty?
+                  errors << I18n.t('vagrant_vcloud.gc.admin_password_gs')
+                end
+              end
+              if guest_customization_admin_auto_login_count.nil?
+                errors << I18n.t('vagrant_vcloud.gc.auto_login_count_req')
+              else
+                if !( guest_customization_admin_auto_login_count >= 1 &&
+                      guest_customization_admin_auto_login_count <= 100 )
+                  errors << I18n.t('vagrant_vcloud.gc.auto_login_count')
+                end
+              end
+            end
+          end
+        end
+
         { 'vCloud Provider' => errors }
       end
     end