vagrant-vcloudair 0.5.0

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

@@ -0,0 +1,153 @@
+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 HandleNATPortCollisions
+        def initialize(app, env)
+          @app    = app
+          @logger = Log4r::Logger.new(
+            'vagrant_vcloudair::action::handle_port_collisions'
+          )
+        end
+
+        def call(env)
+          @logger.info('Detecting any forwarded port collisions...')
+
+          # Determine a list of usable ports for repair
+          usable_ports = Set.new(env[:machine].config.vm.usable_port_range)
+
+          # Pass one, remove all defined host ports from usable ports
+          with_forwarded_ports(env) do |options|
+            usable_ports.delete(options[:host])
+          end
+
+          cfg = env[:machine].provider_config
+          cnx = cfg.vcloudair_cnx.driver
+          vapp_id = env[:machine].get_vapp_id
+
+          @logger.debug('Getting VM info...')
+          vm_name = env[:machine].name
+          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)
+
+          @logger.debug('Getting edge gateway port forwarding rules...')
+          edge_gateway_rules = cnx.get_edge_gateway_rules(cfg.vdc_edge_gateway,
+                                                          cfg.vdc_id)
+          edge_dnat_rules = edge_gateway_rules.select {|r| (r[:rule_type] == 'DNAT' && r[:translated_ip] != vapp_edge_ip)}
+          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)
+          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
+          ports_in_use = ports_in_use | edge_ports_in_use
+
+          # Pass two, detect/handle any collisions
+          with_forwarded_ports(env) do |options|
+            guest_port = options[:guest]
+            host_port  = options[:host]
+
+            # Find if there already is a NAT rule to guest_port of this VM
+            if r = vapp_nat_rules.find { |rule| (rule[:vapp_scoped_local_id] == vm_info[:vapp_scoped_local_id] &&
+                                                 rule[:nat_internal_port] == guest_port.to_s) }
+              host_port = r[:nat_external_port].to_i
+              @logger.info(
+                "Found existing port forwarding rule #{host_port} to #{guest_port}"
+              )
+              options[:host] = host_port
+              options[:already_exists] = true
+            else
+              # If the port is open (listening for TCP connections)
+              if ports_in_use.include?(host_port)
+                unless options[:auto_correct]
+                  fail Errors::ForwardPortCollision,
+                       :guest_port => guest_port.to_s,
+                       :host_port  => host_port.to_s
+                end
+
+                @logger.info("Attempting to repair FP collision: #{host_port}")
+
+                repaired_port = nil
+                until usable_ports.empty?
+                  # Attempt to repair the forwarded port
+                  repaired_port = usable_ports.to_a.sort[0]
+                  usable_ports.delete(repaired_port)
+
+                  # If the port is in use, then we can't use this either...
+                  if ports_in_use.include?(repaired_port)
+                    @logger.info(
+                      "Repaired port also in use: #{repaired_port}." +
+                      'Trying another...'
+                    )
+                    next
+                  end
+
+                  # We have a port so break out
+                  break
+                end
+
+                # If we have no usable ports then we can't repair
+                if !repaired_port && usable_ports.empty?
+                  fail Errors::ForwardPortAutolistEmpty,
+                       :vm_name    => env[:machine].name,
+                       :guest_port => guest_port.to_s,
+                       :host_port  => host_port.to_s
+                end
+
+                # Modify the args in place
+                options[:host] = repaired_port
+
+                @logger.info(
+                  "Repaired FP collision: #{host_port} to #{repaired_port}"
+                )
+
+                # Notify the user
+                env[:ui].info(
+                  I18n.t(
+                    'vagrant.actions.vm.forward_ports.fixed_collision',
+                    :host_port  => host_port.to_s,
+                    :guest_port => guest_port.to_s,
+                    :new_port   => repaired_port.to_s
+                  )
+                )
+              end
+            end
+          end
+
+          @app.call(env)
+        end
+
+        protected
+
+        def with_forwarded_ports(env)
+          env[:machine].config.vm.networks.each do |type, options|
+            # Ignore anything but forwarded ports
+            next if type != :forwarded_port
+
+            yield options
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,210 @@
+require 'etc'
+
+module VagrantPlugins
+  module VCloudAir
+    module Action
+      class InventoryCheck
+        def initialize(app, env)
+          @app = app
+          @logger = Log4r::Logger.new('vagrant_vcloudair::action::inventory_check')
+        end
+
+        def call(env)
+          vcloud_check_inventory(env)
+
+          @app.call env
+        end
+
+        def vcloud_upload_box(env)
+          cfg = env[:machine].provider_config
+          cnx = cfg.vcloudair_cnx.driver
+
+          box_dir = env[:machine].box.directory.to_s
+
+          if env[:machine].box.name.to_s.include? '/'
+            box_file = env[:machine].box.name.rpartition('/').last.to_s
+            box_name = env[:machine].box.name.to_s
+          else
+            box_file = env[:machine].box.name.to_s
+            box_name = box_file
+          end
+
+          box_ovf = "#{box_dir}/#{box_file}.ovf"
+
+          # Still relying on ruby-progressbar because report_progress
+          # basically sucks.
+          @logger.debug("OVF File: #{box_ovf}")
+          upload_ovf = cnx.upload_ovf(
+            cfg.vdc_id,
+            box_name,
+            'Vagrant Box',
+            box_ovf,
+            cfg.catalog_id,
+            {
+              :progressbar_enable => true,
+              # Set the chunksize for upload at the configured value or default
+              # to 5M
+              :chunksize => (cfg.upload_chunksize || 5_242_880)
+            }
+          )
+
+          env[:ui].info(I18n.t('vagrant_vcloudair.catalog.add_to_catalog',
+                               box_name: box_name,
+                               catalog_name: cfg.catalog_name))
+
+          add_ovf_to_catalog = cnx.wait_task_completion(upload_ovf)
+
+          unless add_ovf_to_catalog[:errormsg].nil?
+            fail Errors::CatalogAddError,
+                 :message => add_ovf_to_catalog[:errormsg]
+          end
+
+          # Retrieve catalog_item ID
+          cfg.catalog_item = cnx.get_catalog_item_by_name(
+            cfg.catalog_id,
+            box_name
+          )
+        end
+
+        def vcloud_create_catalog(env)
+          cfg = env[:machine].provider_config
+          cnx = cfg.vcloudair_cnx.driver
+
+          catalog_creation = cnx.create_catalog(
+            cfg.org_id,
+            cfg.catalog_name,
+            "Created by #{Etc.getlogin} " +
+            "running on #{Socket.gethostname.downcase} " +
+            "using vagrant-vcloudair on #{Time.now.strftime("%B %d, %Y")}"
+          )
+          cnx.wait_task_completion(catalog_creation[:task_id])
+
+          @logger.debug("Catalog Creation result: #{catalog_creation.inspect}")
+          env[:ui].info(I18n.t('vagrant_vcloudair.catalog.create_catalog',
+                               catalog_name: cfg.catalog_name))
+
+          cfg.catalog_id = catalog_creation[:catalog_id]
+        end
+
+        def vcloud_check_inventory(env)
+          # Will check each mandatory config value against the vCloud Air
+          # Instance and will setup the global environment config values
+          cfg = env[:machine].provider_config
+          cnx = cfg.vcloudair_cnx.driver
+
+          if env[:machine].box.name.to_s.include? '/'
+            box_file = env[:machine].box.name.rpartition('/').last.to_s
+            box_name = env[:machine].box.name.to_s
+          else
+            box_file = env[:machine].box.name.to_s
+            box_name = box_file
+          end
+
+          cfg.org = cnx.get_organization_by_name(cfg.vdc_name)
+          @logger.debug("cfg.org: #{cfg.org}")
+          cfg.org_id = cnx.get_organization_id_by_name(cfg.vdc_name)
+          @logger.debug("cfg.org_id: #{cfg.org_id}")
+
+          cfg.vdc = cnx.get_vdc_by_name(cfg.org, cfg.vdc_name)
+          cfg.vdc_id = cnx.get_vdc_id_by_name(cfg.org, cfg.vdc_name)
+
+          cfg.catalog = cnx.get_catalog_by_name(cfg.org, cfg.catalog_name)
+          cfg.catalog_id = cnx.get_catalog_id_by_name(cfg.org, cfg.catalog_name)
+
+          if cfg.catalog_id.nil?
+            env[:ui].warn(I18n.t(
+                          'vagrant_vcloudair.catalog.nonexistant_catalog',
+                          catalog_name: cfg.catalog_name))
+
+            user_input = env[:ui].ask(
+              I18n.t('vagrant_vcloudair.catalog.create_catalog_ask',
+                     catalog_name: cfg.catalog_name) + ' '
+            )
+
+            if user_input.downcase == 'yes' || user_input.downcase == 'y'
+              vcloud_create_catalog(env)
+            else
+              env[:ui].error(I18n.t(
+                             'vagrant_vcloudair.catalog.catalog_not_created'))
+              fail Errors::WontCreate, :item => 'Catalog'
+            end
+          end
+
+          @logger.debug(
+            "Getting catalog item with cfg.catalog_id: [#{cfg.catalog_id}] " +
+            "and machine name [#{box_name}]"
+          )
+          cfg.catalog_item = cnx.get_catalog_item_by_name(
+            cfg.catalog_id,
+            box_name
+          )
+
+          @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]
+          unless cfg.vdc_network_id
+            # TODO: 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]
+            fail Errors::InvalidNetSpecification unless cfg.vdc_network_id
+          end
+
+          # Checking Catalog mandatory requirements
+          if !cfg.catalog_id
+            @logger.info("Catalog [#{cfg.catalog_name}] STILL does not exist!")
+            fail Errors::ObjectNotFound,
+                 :message => 'Catalog not found after creation'
+          else
+            @logger.info("Catalog [#{cfg.catalog_name}] exists")
+          end
+
+          if !cfg.catalog_item
+            env[:ui].warn(I18n.t(
+                          'vagrant_vcloudair.catalog.nonexistant_catalog_item',
+                          catalog_item: box_name,
+                          catalog_name: cfg.catalog_name))
+
+            user_input = env[:ui].ask(
+                         I18n.t('vagrant_vcloudair.catalog.upload_ask',
+                                catalog_item: box_name,
+                                catalog_name: cfg.catalog_name) + ' ')
+
+            if user_input.downcase == 'yes' || user_input.downcase == 'y'
+              env[:ui].info(I18n.t('vagrant_vcloudair.catalog.uploading',
+                                   catalog_item: box_name))
+              vcloud_upload_box(env)
+            else
+              env[:ui].error(
+                I18n.t('vagrant_vcloudair.catalog.catalog_item_notavailable'))
+              fail Errors::WontCreate, :item => 'Box'
+            end
+
+          else
+            @logger.info(
+              "Using catalog item [#{box_name}] " +
+              "in Catalog [#{cfg.catalog_name}]..."
+            )
+          end
+
+          # Test if Gateway Edge and its IP are correct
+          if !cfg.vdc_edge_gateway.nil? && !cfg.vdc_edge_gateway_ip.nil?
+            env[:ui].info(I18n.t('vagrant_vcloudair.edge.network_test'))
+            # Test if Edge Gateway exists
+            cnx.find_edge_gateway_id(cfg.vdc_edge_gateway, cfg.vdc_id)
+            # Test if Edge Gateway IP exists
+            cnx.find_edge_gateway_network(cfg.vdc_edge_gateway,
+                                          cfg.vdc_id,
+                                          cfg.vdc_edge_gateway_ip)
+            # Test if Network is connected to Edge Gateway
+            cnx.check_edge_gateway_network(cfg.vdc_edge_gateway,
+                                           cfg.vdc_id,
+                                           cfg.vdc_network_name)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+module VagrantPlugins
+  module VCloudAir
+    module Action
+      class IsBridged
+        def initialize(app, env)
+          @app = app
+          @logger = Log4r::Logger.new('vagrant_vcloudair::action::is_bridged')
+        end
+
+        def call(env)
+          vapp_id = env[:machine].get_vapp_id
+
+          cfg = env[:machine].provider_config
+          cnx = cfg.vcloudair_cnx.driver
+
+          begin
+            @logger.debug('Trying to get the vApp port forwarding rules')
+            cnx.get_vapp_port_forwarding_rules(vapp_id)
+          rescue
+            @logger.debug('Setting the bridged_network environment var to true')
+            env[:bridged_network] = true
+          end
+
+          @app.call env
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+module VagrantPlugins
+  module VCloudAir
+    module Action
+      class IsCreated
+        def initialize(app, env)
+          @app = app
+          @logger = Log4r::Logger.new('vagrant_vcloudair::action::is_created')
+        end
+
+        def call(env)
+          vapp_id = env[:machine].get_vapp_id
+
+          if vapp_id.nil?
+            @logger.warn('vApp has not been created')
+            env[:result] = false
+          else
+            @logger.info("vApp has been created and ID is: [#{vapp_id}]")
+
+            vm_id = env[:machine].id
+            if vm_id
+              @logger.info("VM has been added to vApp and ID is: [#{vm_id}]")
+              env[:result] = true
+            else
+              @logger.warn('VM has not been added to vApp')
+              env[:result] = false
+            end
+
+          end
+
+          @app.call env
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+module VagrantPlugins
+  module VCloudAir
+    module Action
+      class IsLastVM
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          cfg = env[:machine].provider_config
+          cnx = cfg.vcloudair_cnx.driver
+
+          vapp_id = env[:machine].get_vapp_id
+
+          test_vapp = cnx.get_vapp(vapp_id)
+
+          if test_vapp[:vms_hash].count == 1
+          # Set the result to be true if the machine is running.
+            env[:result] = true
+          else
+            env[:result] = false
+          end
+
+          # Call the next if we have one (but we shouldn't, since this
+          # middleware is built to run with the Call-type middlewares)
+          @app.call(env)
+        end
+      end
+    end
+  end
+end