vagrant-vcloudair 0.5.0

data/lib/vagrant-vcloudair/action/announce_ssh_exec.rb

@@ -0,0 +1,22 @@
+module VagrantPlugins
+  module VCloudAir
+    module Action
+      # Override the builtin SSHExec action to show the IP used to connect
+      class AnnounceSSHExec < Vagrant::Action::Builtin::SSHExec
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          ssh_info = env[:machine].ssh_info
+          env[:ui].success(
+            I18n.t('vagrant_vcloudair.vm.ssh_announce',
+                   machine_name: env[:machine].name,
+                   ip: ssh_info[:host])
+          )
+          super
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-vcloudair/action/build_vapp.rb

@@ -0,0 +1,235 @@
+require 'securerandom'
+require 'etc'
+require 'netaddr'
+
+module VagrantPlugins
+  module VCloudAir
+    module Action
+      class BuildVApp
+        def initialize(app, env)
+          @app = app
+          @logger = Log4r::Logger.new('vagrant_vcloudair::action::build_vapp')
+        end
+
+        def call(env)
+          # FIXME: we need to find a way to clean things up when a SIGINT get
+          # called... see env[:interrupted] in the vagrant code
+
+          cfg = env[:machine].provider_config
+          cnx = cfg.vcloudair_cnx.driver
+          vm_name = env[:machine].name
+
+          if cfg.ip_dns.nil?
+            dns_address1 = '8.8.8.8'
+            dns_address2 = '8.8.4.4'
+          else
+            dns_address1 = NetAddr::CIDR.create(cfg.ip_dns.shift).base
+            dns_address2 = NetAddr::CIDR.create(cfg.ip_dns.shift).base
+          end
+
+          if !cfg.ip_subnet.nil?
+            @logger.debug("Input address: #{cfg.ip_subnet}")
+
+            range_addresses = cidr.range(0)
+
+            @logger.debug("Range: #{range_addresses}")
+
+            # Delete the "network" address from the range.
+            range_addresses.shift
+            # Retrieve the first usable IP, to be used as a gateway.
+            gateway_ip = range_addresses.shift
+            # Reverse the array in place.
+            range_addresses.reverse!
+            # Delete the "broadcast" address from the range.
+            range_addresses.shift
+            # Reverse back the array.
+            range_addresses.reverse!
+
+            @logger.debug("Gateway IP: #{gateway_ip.to_s}")
+            @logger.debug("Netmask: #{cidr.wildcard_mask}")
+            @logger.debug(
+              "IP Pool: #{range_addresses.first}-#{range_addresses.last}"
+            )
+            @logger.debug("DNS1: #{dns_address1} DNS2: #{dns_address2}")
+
+            network_options = {
+              :name               => 'Vagrant-vApp-Net',
+              :gateway            => gateway_ip.to_s,
+              :netmask            => cidr.wildcard_mask,
+              :start_address      => range_addresses.first,
+              :end_address        => range_addresses.last,
+              :fence_mode         => 'natRouted',
+              :ip_allocation_mode => 'POOL',
+              :parent_network     => cfg.vdc_network_id,
+              :enable_firewall    => 'false',
+              :dns1               => dns_address1,
+              :dns2               => dns_address2
+            }
+
+          elsif !cfg.network_bridge.nil?
+            # Bridged mode, avoid deploying a vShield Edge altogether.
+            network_options = {
+              :name               => 'Vagrant-vApp-Net',
+              :fence_mode         => 'bridged',
+              :ip_allocation_mode => 'POOL',
+              :parent_network     => cfg.vdc_network_id
+            }
+
+            env[:bridged_network] = true
+
+          else
+
+            @logger.debug("DNS1: #{dns_address1} DNS2: #{dns_address2}")
+            # No IP subnet specified, reverting to defaults
+            network_options = {
+              :name               => 'Vagrant-vApp-Net',
+              :gateway            => '10.1.1.1',
+              :netmask            => '255.255.255.0',
+              :start_address      => '10.1.1.2',
+              :end_address        => '10.1.1.254',
+              :fence_mode         => 'natRouted',
+              :ip_allocation_mode => 'POOL',
+              :parent_network     => cfg.vdc_network_id,
+              :enable_firewall    => 'false',
+              :dns1               => dns_address1,
+              :dns2               => dns_address2
+            }
+
+          end
+
+          if env[:machine].get_vapp_id.nil?
+            env[:ui].info(I18n.t('vagrant_vcloudair.vapp.build_vapp'))
+
+            vapp_prefix = cfg.vapp_prefix
+            vapp_prefix = 'Vagrant' if vapp_prefix.nil?
+
+            compose = cnx.compose_vapp_from_vm(
+              cfg.vdc_id,
+              "#{vapp_prefix}-#{Etc.getlogin}-#{Socket.gethostname.downcase}-" +
+              "#{SecureRandom.hex(4)}",
+              "vApp created by #{Etc.getlogin} running on " +
+              "#{Socket.gethostname.downcase} using vagrant-vcloudair on " +
+              "#{Time.now.strftime("%B %d, %Y")}",
+              {
+                vm_name => cfg.catalog_item[:vms_hash].first.last[:id]
+              },
+              network_options
+            )
+            @logger.debug('Launch Compose vApp...')
+
+            # Fetch thenewly created vApp ID
+            vapp_id = compose[:vapp_id]
+
+            # putting the vApp Id in a globally reachable var and file.
+            env[:machine].vappid = vapp_id
+
+            # Wait for the task to finish.
+            wait = cnx.wait_task_completion(compose[:task_id])
+
+            unless wait[:errormsg].nil?
+              fail Errors::ComposeVAppError, :message => wait[:errormsg]
+            end
+
+            # Fetching new vApp object to check stuff.
+            new_vapp = cnx.get_vapp(vapp_id)
+
+            if new_vapp
+              env[:ui].success(I18n.t('vagrant_vcloudair.vapp.vapp_created',
+                                      vapp_name: new_vapp[:name]))
+
+              # Add the vm id as machine.id
+              new_vm_properties = new_vapp[:vms_hash].fetch(vm_name)
+              env[:machine].id = new_vm_properties[:id]
+
+              ### SET GUEST CONFIG
+              @logger.info(
+                "Setting Guest Customization on ID: [#{vm_name}] " +
+                "of vApp [#{new_vapp[:name]}]"
+              )
+
+              set_custom = cnx.set_vm_guest_customization(
+                new_vm_properties[:id],
+                vm_name,
+                {
+                  :enabled              => true,
+                  :admin_passwd_enabled => false
+                }
+              )
+              wait = cnx.wait_task_completion(set_custom)
+
+              unless wait[:errormsg].nil?
+                fail Errors::ComposeVAppError, :message => wait[:errormsg]
+              end
+
+            else
+              env[:ui].error(I18n.t(
+                             'vagrant_vcloudair.vapp.vapp_creation_failed'),
+                             vapp_name: new_vapp[:name])
+              fail Errors::ComposeVAppError,
+                   :message => 'vApp created but cannot get a working id, \
+                                please report this error'
+            end
+
+          else
+            env[:ui].info(I18n.t('vagrant_vcloudair.vapp.adding_vm'))
+
+            recompose = cnx.recompose_vapp_from_vm(
+              env[:machine].get_vapp_id,
+              {
+                vm_name => cfg.catalog_item[:vms_hash].first.last[:id]
+              },
+              network_options
+            )
+
+            @logger.info('Waiting for the recompose task to complete ...')
+
+            # Wait for the task to finish.
+            wait = cnx.wait_task_completion(recompose[:task_id])
+
+            unless wait[:errormsg].nil?
+              fail Errors::ComposeVAppError, :message => wait[:errormsg]
+            end
+
+            new_vapp = cnx.get_vapp(env[:machine].get_vapp_id)
+
+            if new_vapp
+              new_vm_properties = new_vapp[:vms_hash].fetch(vm_name)
+              env[:machine].id = new_vm_properties[:id]
+
+              ### SET GUEST CONFIG
+              @logger.info(
+                'Setting Guest Customization on ID: ' +
+                "[#{new_vm_properties[:id]}] of vApp [#{new_vapp[:name]}]"
+              )
+
+              set_custom = cnx.set_vm_guest_customization(
+                new_vm_properties[:id],
+                vm_name,
+                {
+                  :enabled              => true,
+                  :admin_passwd_enabled => false
+                }
+              )
+              wait = cnx.wait_task_completion(set_custom)
+
+              unless wait[:errormsg].nil?
+                fail Errors::ComposeVAppError, :message => wait[:errormsg]
+              end
+
+            else
+              # env[:ui].error("VM #{vm_name} add to #{new_vapp[:name]} failed!")
+              env[:ui].error(I18n.t('vagrant_vcloudair.vapp.vm_add_failed',
+                                    vm_name: vm_name,
+                                    vapp_name: new_vapp[:name]))
+              fail Errors::ComposeVAppError,
+                   :message => 'VM added to vApp but cannot get a working id, \
+                                please report this error'
+            end
+          end
+
+          @app.call env
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-vcloudair/action/connect_vcloud.rb

@@ -0,0 +1,54 @@
+module VagrantPlugins
+  module VCloudAir
+    module Action
+      class ConnectVCloudAir
+        def initialize(app, env)
+          @app = app
+          @logger = Log4r::Logger.new('vagrant_vcloudair::action::connect_vcloud')
+        end
+
+        def call(env)
+          config = env[:machine].provider_config
+
+          if !config.vcloudair_cnx || !config.vcloudair_cnx.driver.auth_key
+            @logger.info('Connecting to vCloud Air...')
+
+            @logger.debug("config.cloud_id: #{config.cloud_id}") unless config.cloud_id.nil?
+            @logger.debug("config.username: #{config.username}")
+            @logger.debug('config.password: <hidden>')
+            @logger.debug("config.vdc_name: #{config.vdc_name}")
+
+            # Create the vcloud-rest connection object with the configuration
+            # information.
+            config.vcloudair_cnx = Driver::Meta.new(
+              config.cloud_id,
+              config.username,
+              config.password,
+              config.vdc_name
+            )
+
+            @logger.info('Logging into vCloud Air...')
+            # config.vcloudair_cnx.login
+
+            # Check for the vCloud Air authentication token
+            if config.vcloudair_cnx.driver.auth_key
+              @logger.info('Logged in successfully!')
+              @logger.debug(
+                "x-vcloud-authorization=#{config.vcloudair_cnx.driver.auth_key}"
+              )
+            else
+              @logger.info("Login failed in to #{config.hostname}.")
+              fail Errors::UnauthorizedAccess
+            end
+          else
+            @logger.info('Already logged in, using current session')
+            @logger.debug(
+                "x-vcloud-authorization=#{config.vcloudair_cnx.driver.auth_key}"
+            )
+          end
+          @app.call env
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-vcloudair/action/destroy_vapp.rb

@@ -0,0 +1,54 @@
+module VagrantPlugins
+  module VCloudAir
+    module Action
+      class DestroyVApp
+        def initialize(app, env)
+          @app = app
+          @logger = Log4r::Logger.new('vagrant_vcloudair::action::destroy_vapp')
+        end
+
+        def call(env)
+          cfg = env[:machine].provider_config
+          cnx = cfg.vcloudair_cnx.driver
+          vapp_id = env[:machine].get_vapp_id
+
+          cfg.org = cnx.get_organization_by_name(cfg.vdc_name)
+          cfg.vdc_id = cnx.get_vdc_id_by_name(cfg.org, cfg.vdc_name)
+
+          test_vapp = cnx.get_vapp(vapp_id)
+
+          @logger.debug(
+            "Number of VMs in the vApp: #{test_vapp[:vms_hash].count}"
+          )
+
+          if cfg.vdc_edge_gateway_ip && cfg.vdc_edge_gateway
+            env[:ui].info(I18n.t('vagrant_vcloudair.edge.removing_nat_rules',
+                                 vdc_edge_gateway: cfg.vdc_edge_gateway,
+                                 vdc_edge_gateway_ip: cfg.vdc_edge_gateway_ip))
+
+            @logger.debug(
+              "Deleting Edge Gateway rules - vdc id: #{cfg.vdc_id}"
+            )
+            edge_remove = cnx.remove_edge_gateway_rules(
+              cfg.vdc_edge_gateway,
+              cfg.vdc_id,
+              cfg.vdc_edge_gateway_ip,
+              vapp_id
+            )
+            cnx.wait_task_completion(edge_remove)
+          end
+
+          env[:ui].info(I18n.t('vagrant_vcloudair.vapp.destroy_vapp'))
+          vapp_delete_task = cnx.delete_vapp(vapp_id)
+          @logger.debug("vApp Delete task id #{vapp_delete_task}")
+          cnx.wait_task_completion(vapp_delete_task)
+
+          env[:machine].id = nil
+          env[:machine].vappid = nil
+
+          @app.call env
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-vcloudair/action/destroy_vm.rb

@@ -0,0 +1,37 @@
+module VagrantPlugins
+  module VCloudAir
+    module Action
+      class DestroyVM
+        def initialize(app, env)
+          @app = app
+          @logger = Log4r::Logger.new('vagrant_vcloudair::action::destroy_vm')
+        end
+
+        def call(env)
+          cfg = env[:machine].provider_config
+          cnx = cfg.vcloudair_cnx.driver
+          vapp_id = env[:machine].get_vapp_id
+          vm_id = env[:machine].id
+
+          cfg.org = cnx.get_organization_by_name(cfg.vdc_name)
+          cfg.vdc_id = cnx.get_vdc_id_by_name(cfg.org, cfg.vdc_name)
+
+          test_vapp = cnx.get_vapp(vapp_id)
+
+          @logger.debug(
+            "Number of VMs in the vApp: #{test_vapp[:vms_hash].count}"
+          )
+
+          env[:ui].info(I18n.t('vagrant_vcloudair.vm.destroy_vm'))
+          vm_delete_task = cnx.delete_vm(vm_id)
+          @logger.debug("VM Delete task id #{vm_delete_task}")
+          cnx.wait_task_completion(vm_delete_task)
+
+          env[:machine].id = nil
+
+          @app.call env
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-vcloudair/action/disconnect_vcloud.rb

@@ -0,0 +1,31 @@
+module VagrantPlugins
+  module VCloudAir
+    module Action
+      class DisconnectVCloudAir
+        def initialize(app, env)
+          @app = app
+          @logger = Log4r::Logger.new(
+            'vagrant_vcloudair::action::disconnect_vcloud'
+          )
+        end
+
+        def call(env)
+          @logger.info('Disconnecting from vCloud Air...')
+
+          # Fetch the global vCloud Air connection handle
+          cnx = env[:machine].provider_config.vcloudair_cnx.driver
+
+          # Delete the current vCloud Air Session
+          cnx.logout
+
+          # If session key doesn't exist, we are disconnected
+          if !cnx.auth_key
+            @logger.info('Disconnected from vCloud Air successfully!')
+          else
+            fail Errors::VCloudAirGenericError, :message => e.message
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,132 @@
+module VagrantPlugins
+  module VCloudAir
+    module Action
+      class ForwardPorts
+        include Util::CompileForwardedPorts
+
+        def initialize(app, env)
+          @app = app
+          @logger = Log4r::Logger.new('vagrant_vcloudair::action::forward_ports')
+        end
+
+        def call(env)
+          @env = env
+
+          # Get the ports we are forwarding
+          env[:forwarded_ports] ||= compile_forwarded_ports(
+            env[:machine].config
+          )
+
+          forward_ports
+
+          @app.call(env)
+        end
+
+        def forward_ports
+          ports = []
+          edge_ports = []
+
+          cfg = @env[:machine].provider_config
+          cnx = cfg.vcloudair_cnx.driver
+          vapp_id = @env[:machine].get_vapp_id
+          vm_name = @env[:machine].name
+
+          # FIXME: why are we overriding this here ?
+          #        It's already been taken care during the initial
+          #        InventoryCheck. (tsugliani)
+          #
+          # cfg.org = cnx.get_organization_by_name(cfg.vdc_name)
+          # cfg.vdc_network_id = cfg.org[:networks][cfg.vdc_network_name]
+
+          @logger.debug('Getting VM info...')
+          vm = cnx.get_vapp(vapp_id)
+          vm_info = vm[:vms_hash][vm_name.to_sym]
+
+          @env[:forwarded_ports].each do |fp|
+
+            @env[:ui].info(I18n.t('vagrant_vcloudair.edge.port_forwarding',
+                                  guest_port: fp.guest_port,
+                                  host_port: fp.host_port))
+
+            # Add the options to the ports array to send to the driver later
+            ports << {
+              :guestip                => fp.guest_ip,
+              :nat_internal_port      => fp.guest_port,
+              :hostip                 => fp.host_ip,
+              :nat_external_port      => fp.host_port,
+              :name                   => fp.id,
+              :nat_protocol           => fp.protocol.upcase,
+              :vapp_scoped_local_id   => vm_info[:vapp_scoped_local_id]
+            }
+          end
+
+          unless 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)
+
+            unless wait[:errormsg].nil?
+              fail Errors::ComposeVAppError, :message => wait[:errormsg]
+            end
+
+            if cfg.vdc_edge_gateway_ip && \
+               cfg.vdc_edge_gateway && \
+               cfg.network_bridge.nil?
+
+              vapp_edge_ip = cnx.get_vapp_edge_public_ip(vapp_id)
+              @logger.debug('Getting edge gateway port forwarding rules...')
+              edge_gateway_rules = cnx.get_edge_gateway_rules(cfg.vdc_edge_gateway,
+                                                              cfg.vdc_id)
+              vapp_edge_dnat_rules = edge_gateway_rules.select {|r| (r[:rule_type] == 'DNAT' &&
+                                                                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(I18n.t(
+                                 'vagrant_vcloudair.edge.nat_rules_creation',
+                                 vdc_edge_gateway: cfg.vdc_edge_gateway,
+                                 vapp_edge_ip: vapp_edge_ip,
+                                 port: port[:nat_external_port]))
+
+                  edge_ports << port[:nat_external_port]
+                end
+              end
+
+              unless edge_ports.empty?
+                # Add the vShield Edge Gateway rules
+                add_ports = cnx.add_edge_gateway_rules(
+                  cfg.vdc_edge_gateway,
+                  cfg.vdc_id,
+                  cfg.vdc_edge_gateway_ip,
+                  vapp_id,
+                  edge_ports
+                )
+
+                wait = cnx.wait_task_completion(add_ports)
+
+                fail Errors::ComposeVAppError, :message => wait[:errormsg] unless wait[:errormsg].nil?
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end