vagrant-vcloudair 0.5.0

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

@@ -0,0 +1,25 @@
+module VagrantPlugins
+  module VCloudAir
+    module Action
+      class Resume
+        def initialize(app, env)
+          @app = app
+          @logger = Log4r::Logger.new('vagrant_vcloudair::action::resume')
+        end
+
+        def call(env)
+          cfg = env[:machine].provider_config
+          cnx = cfg.vcloudair_cnx.driver
+
+          vm_id = env[:machine].id
+
+          env[:ui].info(I18n.t(vagrant_vcloudair.vm.poweron_vm))
+          task_id = cnx.poweron_vm(vm_id)
+          cnx.wait_task_completion(task_id)
+
+          @app.call env
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+module VagrantPlugins
+  module VCloudAir
+    module Action
+      class Suspend
+        def initialize(app, env)
+          @app = app
+          @logger = Log4r::Logger.new('vagrant_vcloudair::action::suspend')
+        end
+
+        def call(env)
+          cfg = env[:machine].provider_config
+          cnx = cfg.vcloudair_cnx.driver
+
+          vm_id = env[:machine].id
+
+          env[:ui].info(I18n.t('vagrant_vcloudair.vm.suspend_vm'))
+          task_id = cnx.suspend_vm(vm_id)
+          cnx.wait_task_completion(task_id)
+
+          @app.call env
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,74 @@
+require 'set'
+
+module VagrantPlugins
+  module VCloudAir
+    module Action
+      # This middleware class will detect and handle collisions with
+      # forwarded ports, whether that means raising an error or repairing
+      # them automatically.
+      #
+      # Parameters it takes from the environment hash:
+      #
+      #   * `:port_collision_repair` - If true, it will attempt to repair
+      #     port collisions. If false, it will raise an exception when
+      #     there is a collision.
+      #
+      #   * `:port_collision_extra_in_use` - An array of ports that are
+      #     considered in use.
+      #
+      #   * `:port_collision_remap` - A hash remapping certain host ports
+      #     to other host ports.
+      #
+      class UnmapPortForwardings
+        def initialize(app, env)
+          @app    = app
+          @logger = Log4r::Logger.new(
+            'vagrant_vcloudair::action::unmap_port_forwardings'
+          )
+        end
+
+        def call(env)
+          cfg = env[:machine].provider_config
+          cnx = cfg.vcloudair_cnx.driver
+          vapp_id = env[:machine].get_vapp_id
+          vm_name = env[:machine].name
+
+          cfg.org = cnx.get_organization_by_name(cfg.vdc_name)
+          cfg.vdc_network_id = cfg.org[:networks][cfg.vdc_network_name]
+
+          @logger.debug('Getting vApp information...')
+          vm = cnx.get_vapp(vapp_id)
+          myhash = vm[:vms_hash][vm_name.to_sym]
+          @logger.debug('Getting port forwarding rules...')
+          rules = cnx.get_vapp_port_forwarding_rules(vapp_id)
+
+          unless myhash.nil?
+            # FIXME: not familiar with this syntax (tsugliani)
+            new_rule_set = rules.select {
+              |h| !myhash[:vapp_scoped_local_id].include? h[:vapp_scoped_local_id]
+            }
+
+            @logger.debug("OUR NEW RULE SET, PURGED: #{new_rule_set}")
+
+            remove_ports = cnx.set_vapp_port_forwarding_rules(
+              vapp_id,
+              'Vagrant-vApp-Net',
+              :fence_mode       => 'natRouted',
+              :parent_network   => cfg.vdc_network_id,
+              :nat_policy_type  => 'allowTraffic',
+              :nat_rules        => new_rule_set
+            )
+
+            wait = cnx.wait_task_completion(remove_ports)
+
+            unless wait[:errormsg].nil?
+              fail Errors::ComposeVAppError, :message => wait[:errormsg]
+            end
+          end
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-vcloudair/cap/forwarded_ports.rb

@@ -0,0 +1,38 @@
+module VagrantPlugins
+  module VCloudAir
+    module Cap
+      module ForwardedPorts
+        # Reads the forwarded ports that currently exist on the machine
+        # itself. This raises an exception if the machine isn't running.
+        #
+        # This also may not match up with configured forwarded ports, because
+        # Vagrant auto port collision fixing may have taken place.
+        #
+        # @return [Hash<Integer, Integer>] Host => Guest port mappings.
+        def self.forwarded_ports(machine)
+          result = {}
+
+          cfg = machine.provider_config
+          cnx = cfg.vcloudair_cnx.driver
+          vapp_id = machine.get_vapp_id
+          vm_name = machine.name
+          vm = cnx.get_vapp(vapp_id)
+          myhash = vm[:vms_hash][vm_name.to_sym]
+
+          return if vm.nil?
+
+          if cfg.network_bridge.nil?
+            rules = cnx.get_vapp_port_forwarding_rules(vapp_id)
+
+            rules.each do |rule|
+              if rule[:vapp_scoped_local_id] == myhash[:vapp_scoped_local_id]
+                result[rule[:nat_external_port].to_i] = rule[:nat_internal_port].to_i
+              end
+            end
+          end
+          result
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-vcloudair/cap/public_address.rb

@@ -0,0 +1,18 @@
+module VagrantPlugins
+  module VCloudAir
+    module Cap
+      module PublicAddress
+        def self.public_address(machine)
+          # Initial try for vagrant share feature.
+          # It seems ssh_info[:port] is given automatically.
+          # I think this feature was built planning that the port forwarding
+          # and networking was done on the vagrant machine, which isn't the
+          # case in vagrant-vcloudair
+
+          ssh_info = machine.ssh_info
+          ssh_info[:host]
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-vcloudair/cap/rdp_info.rb

@@ -0,0 +1,18 @@
+module VagrantPlugins
+  module VCloudAir
+    module Cap
+      module RDP
+
+        # Reads the RDP forwarded port that currently exists on the machine
+        # itself. This raises an exception if the machine isn't running.
+        # @return [Hash<Integer, Integer>] Host => Guest port mappings.
+        def self.rdp_info(machine)
+          env = machine.action('read_rdp_info')
+          env[:machine_ssh_info]
+        end
+
+      end
+    end
+  end
+end
+

data/lib/vagrant-vcloudair/cap/winrm_info.rb

@@ -0,0 +1,15 @@
+module VagrantPlugins
+  module VCloudAir
+    module Cap
+      module WinRM
+        # Reads the WinRM forwarded port that currently exists on the machine
+        # itself. This raises an exception if the machine isn't running.
+        # @return [Hash<Integer, Integer>] Host => Guest port mappings.
+        def self.winrm_info(machine)
+          env = machine.action('read_winrm_info')
+          env[:machine_ssh_info]
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-vcloudair/command.rb

@@ -0,0 +1,285 @@
+require 'awesome_print'
+require 'terminal-table'
+
+module VagrantPlugins
+  module VCloudAir
+    # This Class exposes an additional 'vcloudair' namespace within the vagrant
+    # command.
+    class Command < Vagrant.plugin('2', :command)
+      def self.synopsis
+        'namespace to interact with vCloud Air specifics [vCloud Air provider]'
+      end
+
+      def command_vcloud_status(cfg, vapp_id)
+        # Set our handlers to the driver and objects
+
+        puts 'Fetching vCloud Air status...'
+        cnx = cfg.vcloudair_cnx.driver
+        vapp = cnx.get_vapp(vapp_id)
+
+        organization = cnx.get_organization_by_name(cfg.vdc_name)
+        cfg.vdc_id = cnx.get_vdc_id_by_name(organization, cfg.vdc_name)
+
+        # Create a new table for the general information
+        table = Terminal::Table.new
+        table.title = "Vagrant vCloud Air Status : #{cfg.hostname}"
+
+        table << ['Organization Name', cfg.vdc_name]
+        table << ['Organization vDC Name', cfg.vdc_name]
+        table << ['Organization vDC ID', cfg.vdc_id]
+        table << ['Organization vDC Network Name', cfg.vdc_network_name]
+        table << ['Organization vDC Edge Gateway Name',
+                  cfg.vdc_edge_gateway] unless cfg.vdc_edge_gateway.nil?
+        table << ['Organization vDC Edge IP',
+                  cfg.vdc_edge_gateway_ip] unless cfg.vdc_edge_gateway_ip.nil?
+        table << :separator
+        table << ['vApp Name', vapp[:name]]
+        table << ['vAppID', vapp_id]
+
+        vapp[:vms_hash].each do |vm|
+          # This should be checked indivudually
+          # When 1 VM is destroyed, ID is still populated, should be cleaned.
+          table << ["-> #{vm[0]}", vm[1][:id]]
+        end
+
+        # Print the General Information Table
+        puts table
+      end
+
+      def command_vcloud_network(cfg, vapp_id, ssh_host)
+        # FIXME: this needs to be fixed to accomodate the bridged scenario
+        # potentially showing only the assigned IPs in the VMs
+
+        puts 'Fetching vCloud Air network settings ...'
+        cnx = cfg.vcloudair_cnx.driver
+        vapp = cnx.get_vapp(vapp_id)
+
+        organization = cnx.get_organization_by_name(cfg.vdc_name)
+        cfg.vdc_id = cnx.get_vdc_id_by_name(organization, cfg.vdc_name)
+
+        if !cfg.network_bridge.nil?
+          # Create a new table for the network information
+          network_table = Terminal::Table.new
+          network_table.title = 'Network Map'
+
+          network_table << ['VM Name', 'IP Address', 'Connection']
+          network_table << :separator
+
+          vapp[:vms_hash].each do |vm|
+            network_table << [vm[0], vm[1][:addresses][0], 'Direct']
+          end
+        else
+          vapp_edge_ip = cnx.get_vapp_edge_public_ip(vapp_id)
+          vapp_edge_rules = cnx.get_vapp_port_forwarding_rules(vapp_id)
+          edge_gateway_rules = cnx.get_edge_gateway_rules(cfg.vdc_edge_gateway,
+                                                          cfg.vdc_id)
+
+          # Create a new table for the network information
+          network_table = Terminal::Table.new
+          network_table.title = 'Vagrant vCloud Air Network Map'
+
+          network_table << ['VM Name', 'Destination NAT Mapping', 'Enabled']
+          network_table << :separator
+
+          # Fetching Destination NAT Rules for each vApp/Edge/VM/Mapping
+          vapp_edge_rules.each do |vapp_edge_rule|
+            edge_gateway_rule = edge_gateway_rules.find {|r|
+                    (r[:rule_type] == 'DNAT' &&
+                     r[:original_ip] == cfg.vdc_edge_gateway_ip &&
+                     r[:translated_ip] == vapp_edge_ip)}
+
+            # Loop on every VM in the vApp
+            vapp[:vms_hash].each do |vm|
+              # Only Map valid vAppEdge scope to VM scope
+              vm_scope = vm[1][:vapp_scoped_local_id]
+              vapp_edge_scope = vapp_edge_rule[:vapp_scoped_local_id]
+
+              if vm_scope == vapp_edge_scope
+                # Generate DNAT Mappings for the valid machines
+                # If rules don't match, you will not see them !
+                if edge_gateway_rule
+                  # DNAT rule from edge to vapp to vm
+                  connect_host = nil
+
+                  # Add support for config.ssh.host
+                  if ssh_host
+                    connect_host = "#{ssh_host}:" +
+                                   "#{vapp_edge_rule[:nat_external_port]}" +
+                                   ' -> ' +
+                                   "#{cfg.vdc_edge_gateway_ip}:" +
+                                   "#{vapp_edge_rule[:nat_external_port]}"
+                  else
+                    connect_host = "#{cfg.vdc_edge_gateway_ip}:" +
+                                   "#{vapp_edge_rule[:nat_external_port]}"
+                  end
+
+                  network_table << [
+                    "#{vm[0]}",
+                    "#{connect_host}" +
+                    " -> #{vapp_edge_ip}:" +
+                    "#{vapp_edge_rule[:nat_external_port]}" +
+                    " -> #{vm[1][:addresses][0]}:" +
+                    "#{vapp_edge_rule[:nat_internal_port]}",
+                    edge_gateway_rule[:is_enabled]
+                  ]
+                else
+                  # DNAT rule only from vapp to vm
+                  network_table << [
+                    "#{vm[0]}",
+                    "#{vapp_edge_ip}:" +
+                    "#{vapp_edge_rule[:nat_external_port]}" +
+                    " -> #{vm[1][:addresses][0]}:" +
+                    "#{vapp_edge_rule[:nat_internal_port]}",
+                    true
+                  ]
+                end
+              end
+            end
+          end
+
+          # Fetching Source NAT Rules for the vApp
+          network_table << :separator
+          network_table << ['Network Name', 'Source NAT Mapping', 'Enabled']
+          network_table << :separator
+
+          edge_gateway_rules.each do |edge_gateway_rule|
+            # Only check SNAT and src/dst
+            if edge_gateway_rule[:rule_type] == 'SNAT' &&
+               edge_gateway_rule[:original_ip] == vapp_edge_ip &&
+               edge_gateway_rule[:translated_ip] == cfg.vdc_edge_gateway_ip
+
+              network_table << [
+                edge_gateway_rule[:interface_name],
+                "#{vapp_edge_ip} -> #{cfg.vdc_edge_gateway_ip}",
+                edge_gateway_rule[:is_enabled]
+              ]
+            end
+          end
+
+          # Fetching Edge Gateway Firewall Rules
+          network_table << :separator
+          network_table << ['Rule# - Description', 'Firewall Rules', 'Enabled']
+          network_table << :separator
+          edge_gateway_rules.each do |edge_gateway_rule|
+            # Only add firewall rules
+            if edge_gateway_rule[:rule_type] == 'Firewall'
+              network_table << [
+                "#{edge_gateway_rule[:id]} - " +
+                "(#{edge_gateway_rule[:description]})",
+                "#{edge_gateway_rule[:policy]} " +
+                "SRC:#{edge_gateway_rule[:source_ip]}:" +
+                "#{edge_gateway_rule[:source_portrange]} to " +
+                "DST:#{edge_gateway_rule[:destination_ip]}:" +
+                "#{edge_gateway_rule[:destination_portrange]}",
+                "#{edge_gateway_rule[:is_enabled]}"
+              ]
+            end
+          end
+        end
+        # Print the Network Table
+        puts network_table
+      end
+
+      def command_vcloud_redeploy_edge_gw(cfg)
+        cnx = cfg.vcloudair_cnx.driver
+
+        organization = cnx.get_organization_by_name(cfg.vdc_name)
+        cfg.vdc_id = cnx.get_vdc_id_by_name(organization, cfg.vdc_name)
+
+        edge_gw_id = cnx.find_edge_gateway_id(cfg.vdc_edge_gateway, cfg.vdc_id)
+        task_id = cnx.redeploy_edge_gateway(edge_gw_id)
+
+        puts "Redeploying #{cfg.vdc_edge_gateway} vShield Edge Gateway... " +
+             '(This task can take a few minutes)'
+        cnx.wait_task_completion(task_id)
+        puts 'Done'
+      end
+
+      def execute
+        options = {}
+        opts = OptionParser.new do |o|
+          o.banner = 'Usage: vagrant vcloud [options]'
+
+          # We can probably extend this if needed for specific information
+          o.on(
+            '-n',
+            '--network',
+            'Display the vCloud Air network mapping information'
+          ) do |f|
+            options[:network] = true
+          end
+
+          o.on(
+            '-s',
+            '--status',
+            'Display the vCloud Air objects IDs'
+          ) do |f|
+            options[:status] = true
+          end
+
+          o.on(
+            '-r',
+            '--redeploy-edge-gw',
+            'Redeploy the vCloud Air Edge Gateway'
+          ) do |f|
+            options[:redeploy_edge_gw] = true
+          end
+
+        end
+
+        @argv = parse_options(opts)
+        return unless @argv
+
+        # If no arguments, print help
+        if options.keys.count() == 0
+          puts opts
+          exit 1
+        end
+
+        puts 'Initializing vCloud Air provider...'
+        # initialize some variables
+        ssh_host = nil
+        vapp_id = nil
+        cfg = nil
+
+        # Go through the vagrant machines
+        with_target_vms(@argv) do |machine|
+
+          # FIXME/Bug: why does the provider switch to virtualbox when
+          # destroying VMs within the the vApp:
+          # .vagrant/machines/<machine>/virtualbox Cannot trace why this
+          # happens :-( (tsugliani)
+          if machine.provider_name != :vcloudair
+            # Not a vCloud Air provider, exit with explicit error message
+            puts "#{machine.provider_name} provider is incompatible with " +
+                  'this command'
+            exit 1
+          end
+
+          # Force reloads on objects by fetching the ssh_info
+          machine.provider.ssh_info
+
+          # populate cfg & vApp Id for later use.
+          cfg = machine.provider_config
+          vapp_id = machine.get_vapp_id
+          ssh_host = machine.config.ssh.host
+          break
+        end
+
+        # iterate through each option and call the according command.
+        options.keys.each do |key|
+          case key
+          when :status
+            command_vcloud_status(cfg, vapp_id)
+          when :network
+            command_vcloud_network(cfg, vapp_id, ssh_host)
+          when :redeploy_edge_gw
+            command_vcloud_redeploy_edge_gw(cfg)
+          end
+        end
+
+        0
+      end
+    end
+  end
+end