vagrant-vcloud 0.1.0

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

@@ -0,0 +1,17 @@
+module VagrantPlugins
+  module VCloud
+    module Action
+      class AnnounceSSHExec < Vagrant::Action::Builtin::SSHExec
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          sshInfo = env[:machine].ssh_info
+          env[:ui].success("External IP for #{env[:machine].name}: #{sshInfo[:host]}")
+          super
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,197 @@
+require "securerandom"
+require "etc"
+require "netaddr"
+
+module VagrantPlugins
+  module VCloud
+    module Action
+      class BuildVApp
+        def initialize(app, env)
+          @app = app
+          @logger = Log4r::Logger.new("vagrant_vcloud::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.vcloud_cnx.driver
+          vmName = env[:machine].name
+
+          if !cfg.ip_subnet.nil?
+
+            @logger.debug("Input address: #{cfg.ip_subnet}")
+
+            begin
+              cidr = NetAddr::CIDR.create(cfg.ip_subnet)
+            rescue NetAddr::ValidationError
+              raise Errors::InvalidSubnet, :message => cfg.ip_subnet
+            end
+              if cidr.bits > 30
+                @logger.debug("Subnet too small!")
+                raise Errors::SubnetTooSmall, :message => cfg.ip_subnet
+              end
+
+            rangeAddresses = cidr.range(0)
+
+            @logger.debug("Range: #{rangeAddresses}")
+
+            rangeAddresses.shift # Delete the "network" address from the range.
+            gatewayIp = rangeAddresses.shift # Retrieve the first usable IP, to be used as a gateway.
+            rangeAddresses.reverse! # Reverse the array in place.
+            rangeAddresses.shift # Delete the "broadcast" address from the range.
+            rangeAddresses.reverse! # Reverse back the array.
+
+            @logger.debug("Gateway IP: #{gatewayIp.to_s}")
+            @logger.debug("Netmask: #{cidr.wildcard_mask}")
+            @logger.debug("IP Pool: #{rangeAddresses.first}-#{rangeAddresses.last}")
+
+            network_options = { 
+              :name => "Vagrant-vApp-Net", 
+              :gateway => gatewayIp.to_s, 
+              :netmask => cidr.wildcard_mask, 
+              :start_address => rangeAddresses.first, 
+              :end_address => rangeAddresses.last, 
+              :fence_mode => "natRouted",
+              :ip_allocation_mode => "POOL",
+              :parent_network =>  cfg.vdc_network_id,
+              :enable_firewall => "false",
+              :dns1 => "8.8.8.8", # FIXME: We should let the user choose DNS servers and then 
+              :dns2 => "8.8.4.4"  # fall back to Google's if they're not specified.
+            }
+
+          else
+
+            # 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 => "8.8.8.8",
+              :dns2 => "8.8.4.4"
+            }
+
+          end
+
+          if env[:machine].get_vapp_id.nil?
+
+            env[:ui].info("Building vApp...")
+
+            compose = cnx.compose_vapp_from_vm(
+              cfg.vdc_id, 
+              "Vagrant-#{Etc.getlogin}-#{Socket.gethostname.downcase}-#{SecureRandom.hex(4)}",
+              "vApp created by #{Etc.getlogin} running on #{Socket.gethostname.downcase} using vagrant-vcloud on #{Time.now.strftime("%B %d, %Y")}",
+              { 
+                vmName => cfg.catalog_item[:vms_hash][env[:machine].box.name.to_s][:id]
+              }, 
+              network_options
+            )
+            @logger.debug("Launched Compose vApp")
+            # Wait for the task to finish.
+            wait = cnx.wait_task_completion(compose[:task_id])
+
+            if !wait[:errormsg].nil?
+              raise Errors::ComposeVAppError, :message => wait[:errormsg]
+            end
+
+
+            # Fetch thenewly created vApp ID
+            vAppId = compose[:vapp_id]
+
+            # putting the vApp Id in a globally reachable var and file.
+            env[:machine].vappid = vAppId
+
+            # Fetching new vApp object to check stuff.
+            newVApp = cnx.get_vapp(vAppId)            
+
+            # FIXME: Add a lot of error handling for each step here !
+
+            if newVApp
+              env[:ui].success("vApp #{newVApp[:name]} created successfully!")
+
+              # Add the vm id as machine.id
+              newVMProperties = newVApp[:vms_hash].fetch(vmName)
+              env[:machine].id = newVMProperties[:id]
+
+              ### SET GUEST CONFIG
+              #env[:ui].info("Setting Guest Customization on ID: [#{vmName}] of vApp [#{newVApp[:name]}]")
+              setCustom = cnx.set_vm_guest_customization(newVMProperties[:id], vmName, {
+                :enabled => true,
+                :admin_passwd_enabled => false
+                })
+              cnx.wait_task_completion(setCustom)
+
+#              @logger.info("Starting VM [#{vmName}] - this will take a while as vShield Edge is getting deployed as well")
+#              env[:ui].info("Starting VM [#{vmName}] - this will take a while as vShield Edge is getting deployed as well")
+#              poweronVM = cnx.poweron_vm(newVMProperties[:id])
+#              cnx.wait_task_completion(poweronVM)
+
+            else
+              env[:ui].error("vApp #{newVApp[:name]} creation failed!")
+              raise
+           end 
+          else
+            env[:ui].info("Adding VM to existing vApp...")
+            
+            recompose = cnx.recompose_vapp_from_vm(
+              env[:machine].get_vapp_id, 
+              { 
+                vmName => cfg.catalog_item[:vms_hash][env[:machine].box.name.to_s][:id]
+              }, 
+              network_options
+            )
+
+            @logger.info("Waiting for the add to complete ...")
+
+            # Wait for the task to finish.
+            wait = cnx.wait_task_completion(recompose[:task_id])
+
+            newVApp = cnx.get_vapp(env[:machine].get_vapp_id)
+
+            # FIXME: Add a lot of error handling for each step here !
+
+            if newVApp
+
+              #env[:ui].success("VM #{vmName} added to #{newVApp[:name]} successfully!")
+              #@logger.info("VM #{vmName} added to #{newVApp[:name]} successfully!")
+
+              # Add the vm id as machine.id
+              newVMProperties = newVApp[:vms_hash].fetch(vmName)
+              env[:machine].id = newVMProperties[:id]
+
+              ### SET GUEST CONFIG
+              #@logger.info("Setting Guest Customization on ID: [#{newVMProperties[:id]}] of vApp [#{newVApp[:name]}]")
+              #env[:ui].info("Setting Guest Customization on ID: [#{vmName}] of vApp [#{newVApp[:name]}]")
+              setCustom = cnx.set_vm_guest_customization(newVMProperties[:id], vmName, {
+                :enabled => true,
+                :admin_passwd_enabled => false
+                })
+              cnx.wait_task_completion(setCustom)
+
+#              @logger.info("Starting VM [#{vmName}]")
+#              env[:ui].info("Starting VM [#{vmName}]")
+#              poweronVM = cnx.poweron_vm(newVMProperties[:id])
+#              cnx.wait_task_completion(poweronVM)
+
+            else
+
+              env[:ui].error("VM #{vmName} add to #{newVApp[:name]} failed!")
+              raise
+            end 
+          end
+
+          @app.call env
+
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,68 @@
+#require "vcloud-rest/connection"
+require "log4r"
+
+module VagrantPlugins
+  module VCloud
+    module Action
+      class ConnectVCloud
+        def initialize(app, env)
+          @app = app
+          @logger = Log4r::Logger.new("vagrant_vcloud::action::connect_vcloud")
+        end
+
+        def call(env)
+          config = env[:machine].provider_config
+
+#          begin
+            # Avoid recreating a new session each time.
+            if !config.vcloud_cnx
+              @logger.info("Connecting to vCloud Director...")
+
+              @logger.debug("config.hostname    : #{config.hostname}")
+              @logger.debug("config.username    : #{config.username}")
+              @logger.debug("config.password    : #{config.password}")
+              @logger.debug("config.org_name    : #{config.org_name}")
+
+              # Create the vcloud-rest connection object with the configuration 
+              # information.
+              config.vcloud_cnx = Driver::Meta.new(
+                config.hostname,
+                config.username,
+                config.password, 
+                config.org_name
+              )
+
+              @logger.info("Logging into vCloud Director...")
+              config.vcloud_cnx.login
+
+              # Check for the vCloud Director authentication token
+              if config.vcloud_cnx.driver.auth_key
+                @logger.info("Logged in successfully!")
+                @logger.debug(
+                  "x-vcloud-authorization=#{config.vcloud_cnx.driver.auth_key}"
+                )
+              else
+                @logger.info("Login failed in to #{config.hostname}.")
+                env[:ui].error("Login failed in to #{config.hostname}.")
+                raise
+              end
+            else
+              @logger.info("Already logged in, using current session")
+              @logger.debug(
+                  "x-vcloud-authorization=#{config.vcloud_cnx.driver.auth_key}"
+              )
+            end
+
+            @app.call env
+
+#          rescue Exception => e
+#            ### When bad credentials, we get here.
+#            @logger.debug("Couldn't connect to vCloud Director: #{e.inspect}")
+#            raise VagrantPlugins::VCloud::Errors::VCloudError, :message => e.message
+#          end
+
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,69 @@
+require "i18n"
+
+module VagrantPlugins
+  module VCloud
+    module Action
+      class Destroy
+
+        def initialize(app, env)
+          @app = app
+          @logger = Log4r::Logger.new("vagrant_vcloud::action::destroy")
+        end
+
+        def call(env)
+
+          cfg = env[:machine].provider_config
+          cnx = cfg.vcloud_cnx.driver
+          vAppId = env[:machine].get_vapp_id
+          vmId = env[:machine].id
+
+          cfg.org = cnx.get_organization_by_name(cfg.org_name)
+          cfg.vdc_id = cnx.get_vdc_id_by_name(cfg.org, cfg.vdc_name)
+
+          testvApp = cnx.get_vapp(vAppId)
+
+          @logger.debug("Number of VMs in the vApp: #{testvApp[:vms_hash].count}")
+
+          if testvApp[:vms_hash].count == 1
+            env[:ui].info("Single VM left in the vApp, destroying the vApp...")
+
+            if cfg.vdc_edge_gateway_ip && cfg.vdc_edge_gateway
+              env[:ui].info("Removing mapping for ip #{cfg.vdc_edge_gateway_ip} on Edge #{cfg.vdc_edge_gateway}.")
+              @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, vAppId)
+              cnx.wait_task_completion(edge_remove)
+            end
+
+            env[:ui].info("Powering off vApp...")
+            vAppStopTask = cnx.poweroff_vapp(vAppId)
+            vAppStopWait = cnx.wait_task_completion(vAppStopTask)
+
+            if !vAppStopWait[:errormsg].nil?
+              raise Errors::StopVAppError, :message => vAppStopWait[:errormsg]
+            end
+
+            env[:ui].info("Destroying vApp...")
+            vAppDeleteTask = cnx.delete_vapp(vAppId)
+            @logger.debug("vApp Delete task id #{vAppDeleteTask}")
+            cnx.wait_task_completion(vAppDeleteTask)
+
+
+            # FIXME: Look into this.
+            ####env[:machine].provider.driver.delete
+            env[:machine].id=nil
+            env[:machine].vappid=nil
+          else
+            env[:ui].info("Destroying VM...")
+            vmDeleteTask = cnx.delete_vm(vmId)
+            @logger.debug("VM Delete task id #{vmDeleteTask}")
+            cnx.wait_task_completion(vmDeleteTask)
+            env[:machine].id=nil
+          end
+
+          @app.call env
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,33 @@
+module VagrantPlugins
+  module VCloud
+    module Action
+      class DisconnectVCloud
+        def initialize(app, env)
+          @app = app
+          @logger = Log4r::Logger.new("vagrant_vcloud::action::disconnect_vcloud")
+        end
+
+        def call(env)
+          begin
+           @logger.info("Disconnecting from vCloud Director...")
+
+            # Fetch the global vCloud Director connection handle            
+            cnx = env[:machine].provider_config.vcloud_cnx.driver
+
+            # Delete the current vCloud Director Session
+            cnx.logout
+
+            # If session key doesn't exist, we are disconnected
+            if !cnx.auth_key
+              @logger.info("Disconnected from vCloud Director successfully!")
+            end
+
+          rescue Exception => e
+            #raise a properly namespaced error for Vagrant
+            raise Errors::VCloudError, :message => e.message
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,127 @@
+module VagrantPlugins
+  module VCloud
+    module Action
+      class ForwardPorts
+        include Util::CompileForwardedPorts
+
+        def initialize(app, env)
+          @app = app
+          @logger = Log4r::Logger.new("vagrant_vcloud::action::forward_ports")
+        end
+
+        #--------------------------------------------------------------
+        # Execution
+        #--------------------------------------------------------------
+        def call(env)
+          @env = env
+
+          # Get the ports we're forwarding
+          env[:forwarded_ports] ||= compile_forwarded_ports(env[:machine].config)
+
+          @logger.debug("WE'RE GOING TO FORWARD THIS!: #{@env[:forwarded_ports]}")
+
+          forward_ports
+
+          @app.call(env)
+        end
+
+        def forward_ports
+          ports = []
+
+          # interfaces = @env[:machine].provider.driver.read_network_interfaces
+
+          cfg = @env[:machine].provider_config
+          cnx = cfg.vcloud_cnx.driver
+          vmName = @env[:machine].name
+          vAppId = @env[:machine].get_vapp_id
+
+          cfg.org = cnx.get_organization_by_name(cfg.org_name)
+          cfg.vdc_network_id = cfg.org[:networks][cfg.vdc_network_name]
+
+          @logger.debug("Getting VM info...")
+          vm = cnx.get_vapp(vAppId)
+          vmInfo = vm[:vms_hash][vmName.to_sym]
+
+
+          @env[:forwarded_ports].each do |fp|
+            message_attributes = {
+              :guest_port => fp.guest_port,
+              :host_port => fp.host_port
+            }
+
+            # Assuming the only reason to establish port forwarding is
+            # because the VM is using Virtualbox NAT networking. Host-only
+            # bridged networking don't require port-forwarding and establishing
+            # forwarded ports on these attachment types has uncertain behaviour.
+            @env[:ui].info("Forwarding Ports: VM port #{fp.guest_port} -> vShield Edge port #{fp.host_port}")
+
+            # Verify we have the network interface to attach to
+            # if !interfaces[fp.adapter]
+            #   raise Vagrant::Errors::ForwardPortAdapterNotFound,
+            #     :adapter => fp.adapter.to_s,
+            #     :guest => fp.guest_port.to_s,
+            #     :host => fp.host_port.to_s
+            # end
+
+            # Port forwarding requires the network interface to be a NAT interface,
+            # so verify that that is the case.
+            # if interfaces[fp.adapter][:type] != :nat
+            #   @env[:ui].info(I18n.t("vagrant.actions.vm.forward_ports.non_nat",
+            #                         message_attributes))
+            #   next
+            # end
+
+            # 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 => vmInfo[:vapp_scoped_local_id]
+            }
+          end
+
+          if !ports.empty?
+            # We only need to forward ports if there are any to forward
+
+            @logger.debug("Here's what we should pass to the driver method: #{ports.inspect}")
+            @logger.debug("here's our network id #{cfg.vdc_network_id}")
+            # @env[:machine].provider.driver.forward_ports(ports)
+
+            # newvapp[:vms_hash].each do |key, value|
+
+            # nat_rules << { :nat_external_port => j.to_s, :nat_internal_port => "873", :nat_protocol => "UDP", :vm_scoped_local_id => value[:vapp_scoped_local_id]}
+            # j += 1
+
+            ### Here we apply the nat_rules to the vApp we just built
+
+            # puts "### Applying Port Forwarding NAT Rules"
+
+            addports = cnx.add_vapp_port_forwarding_rules(
+              vAppId,
+              "Vagrant-vApp-Net",
+              {
+                :fence_mode => "natRouted",
+                :parent_network => cfg.vdc_network_id,
+                :nat_policy_type => "allowTraffic",
+                :nat_rules => ports
+              })
+
+            wait = cnx.wait_task_completion(addports)
+
+            if !wait[:errormsg].nil?
+              raise Errors::ComposeVAppError, :message => wait[:errormsg]
+            end
+
+
+          end
+
+
+
+        end
+      end
+    end
+  end
+end