vagrant-vcloud 0.1.0

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

@@ -0,0 +1,129 @@
+require "set"
+require "log4r"
+
+module VagrantPlugins
+  module VCloud
+    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_vcloud::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)
+
+          @logger.debug("USABLE PORTS: #{usable_ports.inspect}")
+
+          # Pass one, remove all defined host ports from usable ports
+          with_forwarded_ports(env) do |options|
+            usable_ports.delete(options[:host])
+          end
+
+          @logger.debug("USABLE PORTS AFTER IN USE DELETION: #{usable_ports.inspect}")
+
+          cfg = env[:machine].provider_config
+          cnx = cfg.vcloud_cnx.driver
+          vmName = env[:machine].name
+          vAppId = env[:machine].get_vapp_id
+
+          @logger.debug("Getting vapp info...")
+          vm = cnx.get_vapp(vAppId)
+          myhash = vm[:vms_hash][vmName.to_sym]
+
+          @logger.debug("Getting port forwarding rules...")
+          rules = cnx.get_vapp_port_forwarding_external_ports(vAppId)
+
+          # Pass two, detect/handle any collisions
+          with_forwarded_ports(env) do |options|
+            guest_port = options[:guest]
+            host_port  = options[:host]
+
+            #testHash = rules.flatten
+            @logger.debug("DEBUGGING NETWORKS: rules: #{rules.inspect}")         
+
+            # If the port is open (listening for TCP connections)
+            if rules.include?(host_port)
+              @logger.debug("SO OUR PORT IS INCLUDED IN RULES BUT WHAT'S IN OPTIONS?: #{options.inspect}")
+              if !options[:auto_correct]
+                raise 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
+              while !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 rules.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?
+                raise 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
+
+          @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-vcloud/action/inventory_check.rb

@@ -0,0 +1,156 @@
+require "etc"
+require "log4r"
+
+module VagrantPlugins
+  module VCloud
+    module Action
+      class InventoryCheck
+
+        def initialize(app, env)
+          @app = app
+          @logger = Log4r::Logger.new("vagrant_vcloud::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.vcloud_cnx.driver
+
+          boxDir = env[:machine].box.directory.to_s
+          boxFile = env[:machine].box.name.to_s
+
+          boxOVF = "#{boxDir}/#{boxFile}.ovf"
+
+          ### Still relying on ruby-progressbar because report_progress basically sucks.
+
+          @logger.debug("OVF File: #{boxOVF}")
+          uploadOVF = cnx.upload_ovf(
+            cfg.vdc_id,
+            env[:machine].box.name.to_s,
+            "Vagrant Box",
+            boxOVF,
+            cfg.catalog_id,
+            {
+              :progressbar_enable => true
+              #:chunksize => 262144
+            }
+          )
+
+          env[:ui].info("Adding [#{env[:machine].box.name.to_s}] to Catalog [#{cfg.catalog_name}]")
+          addOVFtoCatalog = cnx.wait_task_completion(uploadOVF)
+
+          if !addOVFtoCatalog[:errormsg].nil?
+            raise Errors::CatalogAddError, :message => addOVFtoCatalog[:errormsg]
+          end
+
+          ## Retrieve catalog_item ID
+          cfg.catalog_item = cnx.get_catalog_item_by_name(cfg.catalog_id, env[:machine].box.name.to_s)
+
+        end
+
+        def vcloud_create_catalog(env)
+          cfg = env[:machine].provider_config
+          cnx = cfg.vcloud_cnx.driver
+
+          catalogCreation = cnx.create_catalog(cfg.org_id, cfg.catalog_name, "Created by #{Etc.getlogin} running on #{Socket.gethostname.downcase} using vagrant-vcloud on #{Time.now.strftime("%B %d, %Y")}")
+          cnx.wait_task_completion(catalogCreation[:task_id])
+
+          @logger.debug("Catalog Creation result: #{catalogCreation.inspect}")
+
+          env[:ui].info("Catalog [#{cfg.catalog_name}] created successfully.")
+
+          cfg.catalog_id = catalogCreation[:catalog_id]
+
+        end
+
+        def vcloud_check_inventory(env)
+          # Will check each mandatory config value against the vCloud Director
+          # Instance and will setup the global environment config values
+          cfg = env[:machine].provider_config
+          cnx = cfg.vcloud_cnx.driver
+
+          cfg.org = cnx.get_organization_by_name(cfg.org_name)
+          cfg.org_id = cnx.get_organization_id_by_name(cfg.org_name)
+
+          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)
+          
+
+          @logger.debug("BEFORE get_catalog_id_by_name")          
+          cfg.catalog_id = cnx.get_catalog_id_by_name(cfg.org, cfg.catalog_name)
+          @logger.debug("AFTER get_catalog_id_by_name: #{cfg.catalog_id}")
+
+
+          if cfg.catalog_id.nil?
+            env[:ui].warn("Catalog [#{cfg.catalog_name}] does not exist!")
+
+            user_input = env[:ui].ask(
+              "Would you like to create the [#{cfg.catalog_name}] catalog?\nChoice (yes/no): "
+            )
+
+            # FIXME: add an OR clause for just Y
+            if user_input.downcase == "yes"
+              vcloud_create_catalog(env)
+            else
+              env[:ui].error("Catalog not created, exiting...")
+
+              raise VagrantPlugins::VCloud::Errors::VCloudError, 
+                    :message => "Catalog not available, exiting..."
+
+            end
+          end
+
+          
+          @logger.debug("Getting catalog item with cfg.catalog_id: [#{cfg.catalog_id}] and machine name [#{env[:machine].box.name.to_s}]")
+          cfg.catalog_item = cnx.get_catalog_item_by_name(cfg.catalog_id, env[:machine].box.name.to_s)
+          @logger.debug("Catalog item is now #{cfg.catalog_item}")
+          cfg.vdc_network_id = cfg.org[:networks][cfg.vdc_network_name]
+
+
+          # Checking Catalog mandatory requirements
+          if !cfg.catalog_id
+            @logger.info("Catalog [#{cfg.catalog_name}] STILL does not exist!")
+              raise VagrantPlugins::VCloud::Errors::VCloudError, 
+                    :message => "Catalog not available, exiting..."
+
+          else
+            @logger.info("Catalog [#{cfg.catalog_name}] exists")
+          end
+
+          if !cfg.catalog_item
+            env[:ui].warn("Catalog item [#{env[:machine].box.name.to_s}] in Catalog [#{cfg.catalog_name}] does not exist!")
+
+            user_input = env[:ui].ask(
+              "Would you like to upload the [#{env[:machine].box.name.to_s}] box to "\
+              "[#{cfg.catalog_name}] Catalog?\nChoice (yes/no): "
+            )
+
+            # FIXME: add an OR clause for just Y
+            if user_input.downcase == "yes"
+              env[:ui].info("Uploading [#{env[:machine].box.name.to_s}]...")
+              vcloud_upload_box(env)
+            else
+              env[:ui].error("Catalog item not available, exiting...")
+
+              raise VagrantPlugins::VCloud::Errors::VCloudError, 
+                    :message => "Catalog item not available, exiting..."
+
+            end
+
+          else
+            #env[:ui].info("Using catalog item [#{env[:machine].box.name.to_s}] in Catalog [#{cfg.catalog_name}]...")
+          end
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+module VagrantPlugins
+  module VCloud
+    module Action
+      class IsCreated
+        def initialize(app, env)
+          @app = app
+          @logger = Log4r::Logger.new("vagrant_vcloud::action::is_created")
+        end
+
+        def call(env)
+         
+          vAppId = env[:machine].get_vapp_id
+          
+          if vAppId.nil?
+            @logger.warn("vApp has not been created")
+            env[:result] = false
+          else
+            @logger.info("vApp has been created and ID is: [#{vAppId}]")
+            
+            vmId = env[:machine].id
+            if vmId
+              @logger.info("VM has been added to vApp and ID is: [#{vmId}]")
+              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-vcloud/action/is_paused.rb

@@ -0,0 +1,22 @@
+require "i18n"
+
+module VagrantPlugins
+  module VCloud
+    module Action
+      class IsPaused
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          # Set the result to be true if the machine is suspended.
+          env[:result] = env[:machine].state.id == :suspended
+
+          # 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

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

@@ -0,0 +1,22 @@
+require "i18n"
+
+module VagrantPlugins
+  module VCloud
+    module Action
+      class IsRunning
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          # Set the result to be true if the machine is running.
+          env[:result] = env[:machine].state.id == :running
+
+          # 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

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

@@ -0,0 +1,17 @@
+module VagrantPlugins
+  module VCloud
+    module Action
+      class MessageAlreadyRunning
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          # FIXME: This error should be categorized
+          env[:ui].info(I18n.t("vagrant_vcloud.vm_already_running"))
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+module VagrantPlugins
+  module VCloud
+    module Action
+      class MessageCannotSuspend
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          # FIXME: This error should be categorized
+          env[:ui].info(I18n.t("vagrant_vcloud.vm_halted_cannot_suspend"))
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+module VagrantPlugins
+  module VCloud
+    module Action
+      class MessageNotCreated
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          # FIXME: this error should be categorized
+          env[:ui].info(I18n.t("vcloud.vm_not_created"))
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+module VagrantPlugins
+  module VCloud
+    module Action
+      class MessageWillNotDestroy
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          # FIXME: This error should be categorized
+          env[:ui].info(I18n.t("vagrant_vcloud.will_not_destroy", name: env[:machine].name))
+          @app.call(env)
+        end
+      end
+    end
+  end
+end