vagrant-vcloud 0.1.0

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

@@ -0,0 +1,33 @@
+require "i18n"
+
+module VagrantPlugins
+  module VCloud
+    module Action
+      class PowerOff
+
+        def initialize(app, env)
+          @app = app
+          @logger = Log4r::Logger.new("vagrant_vcloud::action::poweroff")
+        end
+
+        def call(env)
+
+          cfg = env[:machine].provider_config
+          cnx = cfg.vcloud_cnx.driver
+
+          vAppId = env[:machine].get_vapp_id
+          vmId = env[:machine].id
+          vmName = env[:machine].name
+
+          env[:ui].info("Powering off VM...")
+          task_id = cnx.poweroff_vm(vmId)
+          wait = cnx.wait_task_completion(task_id)
+          
+          true
+
+          @app.call env
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,46 @@
+require "i18n"
+
+module VagrantPlugins
+  module VCloud
+    module Action
+      class PowerOn
+        def initialize(app, env)
+          @app = app
+          @logger = Log4r::Logger.new("vagrant_vcloud::action::power_on")
+        end
+
+        def call(env)
+          @env = env
+
+
+          cfg = env[:machine].provider_config
+          cnx = cfg.vcloud_cnx.driver
+          vmName = env[:machine].name
+          vAppId = env[:machine].get_vapp_id
+
+	      env[:ui].info("Booting VM...")
+
+        testIp = cnx.get_vapp_edge_public_ip(vAppId)
+
+        poweronVM = cnx.poweron_vm(env[:machine].id)
+        cnx.wait_task_completion(poweronVM)
+
+        if testIp.nil? && cfg.vdc_edge_gateway_ip && cfg.vdc_edge_gateway
+          @logger.debug("This is our first boot, we should map ports on org edge!")
+          env[:ui].info("Mapping ip #{cfg.vdc_edge_gateway_ip} on Edge #{cfg.vdc_edge_gateway} as our entry point.")
+          edgeMap = cnx.set_edge_gateway_rules(cfg.vdc_edge_gateway, cfg.vdc_id, cfg.vdc_edge_gateway_ip, vAppId)
+          cnx.wait_task_completion(edgeMap)
+        end
+
+
+
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end
+
+
+

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

@@ -0,0 +1,69 @@
+require "awesome_print"
+
+module VagrantPlugins
+  module VCloud
+    module Action
+      class ReadSSHInfo
+
+        # FIXME: More work needed here for vCloud logic (vApp, VM IPs, etc.)
+
+        def initialize(app, env)
+          @app = app
+          @logger = Log4r::Logger.new("vagrant_vcloud::action::read_ssh_info")
+        end
+
+        def call(env)
+          env[:machine_ssh_info] = read_ssh_info(env)
+
+          @app.call env
+        end
+
+
+        def read_ssh_info(env)
+          return nil if env[:machine].id.nil?
+
+          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]
+
+          if vm.nil?
+            # The machine can't be found
+            @logger.info("Machine couldn't be found, assuming it got destroyed.")
+            machine.id = nil
+            return nil
+          end
+
+          @logger.debug("Getting port forwarding rules...")
+          rules = cnx.get_vapp_port_forwarding_rules(vAppId)
+          
+          rules.each do |rule|
+            if rule[:vapp_scoped_local_id] == myhash[:vapp_scoped_local_id] && rule[:nat_internal_port] == "22"
+
+              @logger.debug("Our variables: IP #{rule[:nat_external_ip]} and Port #{rule[:nat_external_port]}")
+              
+              @externalIP = rule[:nat_external_ip]
+              @externalPort = rule[:nat_external_port]
+              break
+            end
+          end
+
+          if cfg.vdc_edge_gateway_ip && cfg.vdc_edge_gateway
+            @logger.debug("We're running vagrant behind an org edge")
+            @externalIP = cfg.vdc_edge_gateway_ip
+          end
+
+          return {
+            # FIXME: these shouldn't be self
+              :host => @externalIP,
+              :port => @externalPort
+          }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,59 @@
+require "log4r"
+
+module VagrantPlugins
+  module VCloud
+    module Action
+      class ReadState
+
+        def initialize(app, env)
+          @app = app
+          @logger = Log4r::Logger.new("vagrant_vcloud::action::read_state")
+        end
+
+        def call(env)
+          #env = read_state(env)
+            
+          env[:machine_state_id] = read_state(env) 
+          
+          @app.call env
+        end
+
+        def read_state(env)
+
+          # FIXME: this part needs some cleanup
+
+          begin
+            cfg = env[:machine].provider_config
+            cnx = cfg.vcloud_cnx.driver
+            vAppId = env[:machine].get_vapp_id
+            vmName = env[:machine].name
+
+            if env[:machine].id.nil?
+              @logger.info("VM [#{vmName}] is not created yet")
+              return :not_created
+            end
+
+            vApp = cnx.get_vapp(vAppId)
+            vmStatus = vApp[:vms_hash][vmName][:status]
+
+            if vmStatus == "stopped"
+              @logger.info("VM [#{vmName}] is stopped")
+              return :stopped
+            elsif vmStatus == "running"
+              @logger.info("VM [#{vmName}] is running")
+              return :running
+            elsif vmStatus == "paused"
+              @logger.info("VM [#{vmName}] is suspended")
+              return :suspended
+            end
+          rescue Exception => e
+            ### When bad credentials, we get here.
+            @logger.debug("Couldn't Read VM State: #{e.message}")
+            raise VagrantPlugins::VCloud::Errors::VCloudError, :message => e.message
+          end
+          
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,33 @@
+require "i18n"
+
+module VagrantPlugins
+  module VCloud
+    module Action
+      class Resume
+
+        def initialize(app, env)
+          @app = app
+          @logger = Log4r::Logger.new("vagrant_vcloud::action::resume")
+        end
+
+        def call(env)
+
+          cfg = env[:machine].provider_config
+          cnx = cfg.vcloud_cnx.driver
+
+          vAppId = env[:machine].get_vapp_id
+          vmId = env[:machine].id
+          vmName = env[:machine].name
+
+          env[:ui].info("Powering on VM...")
+          task_id = cnx.poweron_vm(vmId)
+          wait = cnx.wait_task_completion(task_id)
+
+          true
+
+          @app.call env
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,33 @@
+require "i18n"
+
+module VagrantPlugins
+  module VCloud
+    module Action
+      class Suspend
+
+        def initialize(app, env)
+          @app = app
+          @logger = Log4r::Logger.new("vagrant_vcloud::action::suspend")
+        end
+
+        def call(env)
+
+          cfg = env[:machine].provider_config
+          cnx = cfg.vcloud_cnx.driver
+
+          vAppId = env[:machine].get_vapp_id
+          vmId = env[:machine].id
+          vmName = env[:machine].name
+
+          env[:ui].info("Suspending VM...")
+          task_id = cnx.suspend_vm(vmId)
+          wait = cnx.wait_task_completion(task_id)
+
+          true
+
+          @app.call env
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,82 @@
+require "log4r"
+require "vagrant/util/subprocess"
+require "vagrant/util/scoped_hash_override"
+require "unison"
+
+module VagrantPlugins
+  module VCloud
+    module Action
+      class SyncFolders
+        include Vagrant::Util::ScopedHashOverride
+
+        def initialize(app, env)
+          @app    = app
+          @logger = Log4r::Logger.new("vagrant_vcloud::action::sync_folders")
+        end
+
+        def call(env)
+          @app.call(env)
+
+          ### COMPLETELY REDO USING UNISON!!!!
+
+          ssh_info = env[:machine].ssh_info
+
+          env[:machine].config.vm.synced_folders.each do |id, data|
+            data = scoped_hash_override(data, :vcloud)
+
+            # Ignore disabled shared folders
+            next if data[:disabled]
+
+            hostpath  = File.expand_path(data[:hostpath], env[:root_path])
+            guestpath = data[:guestpath]
+
+            # Make sure there is a trailing slash on the host path to
+            # avoid creating an additional directory with rsync
+            hostpath = "#{hostpath}/" if hostpath !~ /\/$/
+
+            @logger.debug("RSYNCING OVER #{hostpath} to #{guestpath}")
+
+            # env[:ui].info(I18n.t("vagrant_aws.rsync_folder",
+            #                     :hostpath => hostpath,
+            #                     :guestpath => guestpath))
+
+            # Create the host path if it doesn't exist and option flag is set
+            if data[:create]
+              begin
+                FileUtils::mkdir_p(hostpath)
+              rescue => err
+                raise Errors::MkdirError,
+                  :hostpath => hostpath,
+                  :err => err
+              end
+            end
+
+            # Create the guest path
+            env[:machine].communicate.sudo("mkdir -p '#{guestpath}'")
+            env[:machine].communicate.sudo(
+              "chown #{ssh_info[:username]} '#{guestpath}'")
+
+            # Rsync over to the guest path using the SSH info
+            command = [
+              "rsync", "--verbose", "--archive", "-z",
+              "--exclude", ".vagrant/",
+              "-e", "ssh -p #{ssh_info[:port]} -o StrictHostKeyChecking=no -i '#{ssh_info[:private_key_path]}'",
+              hostpath,
+              "#{ssh_info[:username]}@#{ssh_info[:host]}:#{guestpath}"]
+
+            r = Vagrant::Util::Subprocess.execute(*command)
+            if r.exit_code != 0
+              raise Errors::RsyncError,
+                :guestpath => guestpath,
+                :hostpath => hostpath,
+                :stderr => r.stderr
+            end
+          end
+        end
+      end
+    end
+  end
+end
+
+
+ 

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

@@ -0,0 +1,75 @@
+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 UnmapPortForwardings
+
+
+        def initialize(app, env)
+          @app    = app
+          @logger = Log4r::Logger.new("vagrant_vcloud::action::unmap_port_forwardings")
+        end
+
+        def call(env)
+          
+          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 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_rules(vAppId)
+
+          newRuleSet = rules.select { |h| !myhash[:vapp_scoped_local_id].include? h[:vapp_scoped_local_id] }
+
+          @logger.debug("OUR NEW RULE SET, PURGED: #{newRuleSet}")
+
+          removePorts = cnx.set_vapp_port_forwarding_rules(
+            vAppId,
+            "Vagrant-vApp-Net",
+            {
+              :fence_mode => "natRouted",
+              :parent_network => cfg.vdc_network_id,
+              :nat_policy_type => "allowTraffic",
+              :nat_rules => newRuleSet
+            })
+
+          wait = cnx.wait_task_completion(removePorts)
+
+          if !wait[:errormsg].nil?
+            raise Errors::ComposeVAppError, :message => wait[:errormsg]
+          end
+
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-vcloud/config.rb

@@ -0,0 +1,132 @@
+require "vagrant"
+
+module VagrantPlugins
+  module VCloud
+    class Config < Vagrant.plugin('2', :config)
+
+      # login attributes
+
+      # The vCloud Director hostname
+      #
+      # @return [String]
+      attr_accessor :hostname
+
+      # The Organization Name to log in to
+      #
+      # @return [String]
+      attr_accessor :org_name
+
+      # The username used to log in
+      #
+      # @return [String]
+      attr_accessor :username
+
+      # The password used to log in
+      #
+      # @return [String]
+      attr_accessor :password
+
+      # WIP on these
+
+      # Catalog Name where the item resides
+      #
+      # @return [String]
+      attr_accessor :catalog_name
+
+      # Catalog Item to be used as a template
+      #
+      # @return [String]
+      attr_accessor :catalog_item_name
+
+      # Virtual Data Center to be used
+      #
+      # @return [String]
+      attr_accessor :vdc_name
+
+      # Virtual Data Center Network to be used
+      #
+      # @return [String]
+      attr_accessor :vdc_network_name
+
+      # Virtual Data Center Network Id to be used
+      #
+      # @return [String]
+      attr_accessor :vdc_network_id
+
+      # IP allocation type
+      #
+      # @return [String]
+      attr_accessor :ip_allocation_type
+
+      # IP subnet
+      #
+      # @return [String]
+      attr_accessor :ip_subnet
+
+      # Port forwarding rules
+      #
+      # @return [Hash]
+      attr_reader :port_forwarding_rules
+
+      # Name of the edge gateway [optional]
+      #
+      # @return [String]
+      attr_accessor :vdc_edge_gateway
+
+      # Public IP of the edge gateway [optional, required if :vdc_edge_gateway is specified]
+      #
+      # @return [String]
+      attr_accessor :vdc_edge_gateway_ip
+     
+      ##
+      ## vCloud Director config runtime values
+      ## 
+
+      # connection handle
+      attr_accessor :vcloud_cnx
+      
+      # org object (Hash)
+      attr_accessor :org
+      
+      # org id (String)
+      attr_accessor :org_id
+
+      # vdc object (Hash)
+      attr_accessor :vdc
+
+      # vdc id (String)
+      attr_accessor :vdc_id
+
+      # catalog object (Hash)
+      attr_accessor :catalog
+
+      # catalog id (String)
+      attr_accessor :catalog_id 
+
+      # catalog item object (Hash)
+      attr_accessor :catalog_item 
+
+      # vApp Name (String)
+      attr_accessor :vAppName
+
+      # vApp Id (String)
+      attr_accessor :vAppId
+
+      def validate(machine)
+        errors = _detected_errors
+
+        # TODO: add blank?
+        errors << I18n.t("config.hostname") if hostname.nil?
+        errors << I18n.t("config.org_name") if org_name.nil?
+        errors << I18n.t("config.username") if username.nil?
+        errors << I18n.t("config.password") if password.nil?
+        
+        errors << I18n.t("config.catalog_name") if catalog_name.nil?
+        errors << I18n.t("config.vdc_name") if vdc_name.nil?
+        errors << I18n.t("config.vdc_network_name") if vdc_network_name.nil?
+
+        { "vCloud Provider" => errors }
+      end
+    end
+  end
+end