vagrant-openstack 0.0.4

data/lib/vagrant-openstack/driver/base.rb

@@ -0,0 +1,344 @@
+require 'log4r'
+
+require 'vagrant/util/busy'
+require 'vagrant/util/platform'
+require 'vagrant/util/retryable'
+require 'vagrant/util/subprocess'
+
+module VagrantPlugins
+  module ProviderOpenStack
+    module Driver
+      # Base class for all VirtualBox drivers.
+      #
+      # This class provides useful tools for things such as executing
+      # VBoxManage and handling SIGINTs and so on.
+      class Base
+        # Include this so we can use `Subprocess` more easily.
+        include Vagrant::Util::Retryable
+
+        def initialize
+          @logger = Log4r::Logger.new("vagrant::provider::virtualbox::base")
+
+          # This flag is used to keep track of interrupted state (SIGINT)
+          @interrupted = false
+
+          # Set the path to VBoxManage
+          @vboxmanage_path = "VBoxManage"
+
+          if Vagrant::Util::Platform.windows?
+            @logger.debug("Windows. Trying VBOX_INSTALL_PATH for VBoxManage")
+
+            # On Windows, we use the VBOX_INSTALL_PATH environmental
+            # variable to find VBoxManage.
+            if ENV.has_key?("VBOX_INSTALL_PATH")
+              # Get the path.
+              path = ENV["VBOX_INSTALL_PATH"]
+              @logger.debug("VBOX_INSTALL_PATH value: #{path}")
+
+              # There can actually be multiple paths in here, so we need to
+              # split by the separator ";" and see which is a good one.
+              path.split(";").each do |single|
+                # Make sure it ends with a \
+                single += "\\" if !single.end_with?("\\")
+
+                # If the executable exists, then set it as the main path
+                # and break out
+                vboxmanage = "#{path}VBoxManage.exe"
+                if File.file?(vboxmanage)
+                  @vboxmanage_path = vboxmanage
+                  break
+                end
+              end
+            end
+          end
+
+          @logger.info("VBoxManage path: #{@vboxmanage_path}")
+        end
+
+        # Clears the forwarded ports that have been set on the virtual machine.
+        def clear_forwarded_ports
+        end
+
+        # Clears the shared folders that have been set on the virtual machine.
+        def clear_shared_folders
+        end
+
+        # Creates a DHCP server for a host only network.
+        #
+        # @param [String] network Name of the host-only network.
+        # @param [Hash] options Options for the DHCP server.
+        def create_dhcp_server(network, options)
+        end
+
+        # Creates a host only network with the given options.
+        #
+        # @param [Hash] options Options to create the host only network.
+        # @return [Hash] The details of the host only network, including
+        #   keys `:name`, `:ip`, and `:netmask`
+        def create_host_only_network(options)
+        end
+
+        # Deletes the virtual machine references by this driver.
+        def delete
+        end
+
+        # Deletes any host only networks that aren't being used for anything.
+        def delete_unused_host_only_networks
+        end
+
+        # Discards any saved state associated with this VM.
+        def discard_saved_state
+        end
+
+        # Enables network adapters on the VM.
+        #
+        # The format of each adapter specification should be like so:
+        #
+        # {
+        #   :type     => :hostonly,
+        #   :hostonly => "vboxnet0",
+        #   :mac_address => "tubes"
+        # }
+        #
+        # This must support setting up both host only and bridged networks.
+        #
+        # @param [Array<Hash>] adapters Array of adapters to enable.
+        def enable_adapters(adapters)
+        end
+
+        # Execute a raw command straight through to VBoxManage.
+        #
+        # @param [Array] command Command to execute.
+        def execute_command(command)
+        end
+
+        # Exports the virtual machine to the given path.
+        #
+        # @param [String] path Path to the OVF file.
+        # @yield [progress] Yields the block with the progress of the export.
+        def export(path)
+        end
+
+        # Forwards a set of ports for a VM.
+        #
+        # This will not affect any previously set forwarded ports,
+        # so be sure to delete those if you need to.
+        #
+        # The format of each port hash should be the following:
+        #
+        #     {
+        #       :name => "foo",
+        #       :hostport => 8500,
+        #       :guestport => 80,
+        #       :adapter => 1,
+        #       :protocol => "tcp"
+        #     }
+        #
+        # Note that "adapter" and "protocol" are optional and will default
+        # to 1 and "tcp" respectively.
+        #
+        # @param [Array<Hash>] ports An array of ports to set. See documentation
+        #   for more information on the format.
+        def forward_ports(ports)
+        end
+
+        # Halts the virtual machine (pulls the plug).
+        def halt
+        end
+
+        # Imports the VM from an OVF file.
+        #
+        # @param [String] ovf Path to the OVF file.
+        # @return [String] UUID of the imported VM.
+        def import(ovf)
+        end
+
+        # Returns a list of forwarded ports for a VM.
+        #
+        # @param [String] uuid UUID of the VM to read from, or `nil` if this
+        #   VM.
+        # @param [Boolean] active_only If true, only VMs that are running will
+        #   be checked.
+        # @return [Array<Array>]
+        def read_forwarded_ports(uuid=nil, active_only=false)
+        end
+
+        # Returns a list of bridged interfaces.
+        #
+        # @return [Hash]
+        def read_bridged_interfaces
+        end
+
+        # Returns the guest additions version that is installed on this VM.
+        #
+        # @return [String]
+        def read_guest_additions_version
+        end
+
+        # Returns a list of available host only interfaces.
+        #
+        # @return [Hash]
+        def read_host_only_interfaces
+        end
+
+        # Returns the MAC address of the first network interface.
+        #
+        # @return [String]
+        def read_mac_address
+        end
+
+        # Returns the folder where VirtualBox places it's VMs.
+        #
+        # @return [String]
+        def read_machine_folder
+        end
+
+        # Returns a list of network interfaces of the VM.
+        #
+        # @return [Hash]
+        def read_network_interfaces
+        end
+
+        # Returns the current state of this VM.
+        #
+        # @return [Symbol]
+        def read_state
+        end
+
+        # Returns a list of all forwarded ports in use by active
+        # virtual machines.
+        #
+        # @return [Array]
+        def read_used_ports
+        end
+
+        # Returns a list of all UUIDs of virtual machines currently
+        # known by VirtualBox.
+        #
+        # @return [Array<String>]
+        def read_vms
+        end
+
+        # Sets the MAC address of the first network adapter.
+        #
+        # @param [String] mac MAC address without any spaces/hyphens.
+        def set_mac_address(mac)
+        end
+
+        # Share a set of folders on this VM.
+        #
+        # @param [Array<Hash>] folders
+        def share_folders(folders)
+        end
+
+        # Reads the SSH port of this VM.
+        #
+        # @param [Integer] expected Expected guest port of SSH.
+        def ssh_port(expected)
+        end
+
+        # Starts the virtual machine.
+        #
+        # @param [String] mode Mode to boot the VM. Either "headless"
+        #   or "gui"
+        def start(mode)
+        end
+
+        # Suspend the virtual machine.
+        def suspend
+        end
+
+        # Verifies that the driver is ready to accept work.
+        #
+        # This should raise a VagrantError if things are not ready.
+        def verify!
+        end
+
+        # Verifies that an image can be imported properly.
+        #
+        # @param [String] path Path to an OVF file.
+        # @return [Boolean]
+        def verify_image(path)
+        end
+
+        # Checks if a VM with the given UUID exists.
+        #
+        # @return [Boolean]
+        def vm_exists?(uuid)
+        end
+
+        # Execute the given subcommand for VBoxManage and return the output.
+        def execute(*command, &block)
+          # Get the options hash if it exists
+          opts = {}
+          opts = command.pop if command.last.is_a?(Hash)
+
+          tries = 0
+          tries = 3 if opts[:retryable]
+
+          # Variable to store our execution result
+          r = nil
+
+          retryable(:on => Vagrant::Errors::VBoxManageError, :tries => tries, :sleep => 1) do
+            # Execute the command
+            r = raw(*command, &block)
+
+            # If the command was a failure, then raise an exception that is
+            # nicely handled by Vagrant.
+            if r.exit_code != 0
+              if @interrupted
+                @logger.info("Exit code != 0, but interrupted. Ignoring.")
+              else
+                raise Vagrant::Errors::VBoxManageError, :command => command.inspect
+              end
+            else
+              # Sometimes, VBoxManage fails but doesn't actual return a non-zero
+              # exit code. For this we inspect the output and determine if an error
+              # occurred.
+              if r.stderr =~ /VBoxManage: error:/
+                @logger.info("VBoxManage error text found, assuming error.")
+                raise Vagrant::Errors::VBoxManageError, :command => command.inspect
+              end
+            end
+          end
+
+          # Return the output, making sure to replace any Windows-style
+          # newlines with Unix-style.
+          r.stdout.gsub("\r\n", "\n")
+        end
+
+        # Executes a command and returns the raw result object.
+        def raw(*command, &block)
+          int_callback = lambda do
+            @interrupted = true
+            @logger.info("Interrupted.")
+          end
+
+          # Append in the options for subprocess
+          command << { :notify => [:stdout, :stderr] }
+
+          # The following is a workaround for a combined VirtualBox and
+          # Mac OS X 10.8 bug:
+          #
+          # Remove the DYLD_LIBRARY_PATH environmental variable on Mac. This
+          # is to fix a bug in Mac OS X 10.8 where a warning is printed to the
+          # console if this is set when executing certain programs, which
+          # can cause some VBoxManage commands to break because they work
+          # by just reading stdout and don't expect the OS to just inject
+          # garbage into it.
+          old_dyld_lib_path = ENV.delete("DYLD_LIBRARY_PATH")
+          old_ld_lib_path   = ENV.delete("LD_LIBRARY_PATH")
+
+          Vagrant::Util::Busy.busy(int_callback) do
+            Vagrant::Util::Subprocess.execute(@vboxmanage_path, *command, &block)
+          end
+        ensure
+          # Reset the library path if it was set before. See above comments
+          # for more information on why this was unset in the first place.
+          ENV["DYLD_LIBRARY_PATH"] = old_dyld_lib_path if old_dyld_lib_path
+          ENV["LD_LIBRARY_PATH"]   = old_ld_lib_path if old_ld_lib_path
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-openstack/driver/folsom.rb

@@ -0,0 +1,471 @@
+require 'log4r'
+
+require File.expand_path("../base", __FILE__)
+
+module VagrantPlugins
+  module ProviderOpenStack
+    module Driver
+      class Folsom < Base
+
+        def initialize(uuid)
+          super()
+
+          @logger = Log4r::Logger.new("vagrant::provider::virtualbox_4_2")
+          @uuid = uuid
+        end
+        
+        def clear_forwarded_ports
+          args = []
+          read_forwarded_ports(@uuid).each do |nic, name, _, _|
+            args.concat(["--natpf#{nic}", "delete", name])
+          end
+
+          execute("modifyvm", @uuid, *args) if !args.empty?
+        end
+
+        def clear_shared_folders
+          info = execute("showvminfo", @uuid, "--machinereadable", :retryable => true)
+          info.split("\n").each do |line|
+            if line =~ /^SharedFolderNameMachineMapping\d+="(.+?)"$/
+              execute("sharedfolder", "remove", @uuid, "--name", $1.to_s)
+            end
+          end
+        end
+
+        def create_dhcp_server(network, options)
+          execute("dhcpserver", "add", "--ifname", network,
+                  "--ip", options[:dhcp_ip],
+                  "--netmask", options[:netmask],
+                  "--lowerip", options[:dhcp_lower],
+                  "--upperip", options[:dhcp_upper],
+                  "--enable")
+        end
+
+        def create_host_only_network(options)
+          # Create the interface
+          execute("hostonlyif", "create") =~ /^Interface '(.+?)' was successfully created$/
+            name = $1.to_s
+
+          # Configure it
+          execute("hostonlyif", "ipconfig", name,
+                  "--ip", options[:adapter_ip],
+                  "--netmask", options[:netmask])
+
+          # Return the details
+          return {
+            :name => name,
+            :ip   => options[:adapter_ip],
+            :netmask => options[:netmask],
+            :dhcp => nil
+          }
+        end
+
+        def delete
+          execute("unregistervm", @uuid, "--delete")
+        end
+
+        def delete_unused_host_only_networks
+          networks = []
+          execute("list", "hostonlyifs").split("\n").each do |line|
+            networks << $1.to_s if line =~ /^Name:\s+(.+?)$/
+          end
+
+          execute("list", "vms").split("\n").each do |line|
+            if line =~ /^".+?"\s+\{(.+?)\}$/
+              info = execute("showvminfo", $1.to_s, "--machinereadable", :retryable => true)
+              info.split("\n").each do |inner_line|
+                if inner_line =~ /^hostonlyadapter\d+="(.+?)"$/
+                  networks.delete($1.to_s)
+                end
+              end
+            end
+          end
+
+          networks.each do |name|
+            # First try to remove any DHCP servers attached. We use `raw` because
+            # it is okay if this fails. It usually means that a DHCP server was
+            # never attached.
+            raw("dhcpserver", "remove", "--ifname", name)
+
+            # Delete the actual host only network interface.
+            execute("hostonlyif", "remove", name)
+          end
+        end
+
+        def discard_saved_state
+          execute("discardstate", @uuid)
+        end
+
+        def enable_adapters(adapters)
+          args = []
+          adapters.each do |adapter|
+            args.concat(["--nic#{adapter[:adapter]}", adapter[:type].to_s])
+
+            if adapter[:bridge]
+              args.concat(["--bridgeadapter#{adapter[:adapter]}",
+                          adapter[:bridge]])
+            end
+
+            if adapter[:hostonly]
+              args.concat(["--hostonlyadapter#{adapter[:adapter]}",
+                          adapter[:hostonly]])
+            end
+
+            if adapter[:mac_address]
+              args.concat(["--macaddress#{adapter[:adapter]}",
+                          adapter[:mac_address]])
+            end
+
+            if adapter[:nic_type]
+              args.concat(["--nictype#{adapter[:adapter]}", adapter[:nic_type].to_s])
+            end
+          end
+
+          execute("modifyvm", @uuid, *args)
+        end
+
+        def execute_command(command)
+          raw(*command)
+        end
+
+        def export(path)
+          # TODO: Progress
+          execute("export", @uuid, "--output", path.to_s)
+        end
+
+        def forward_ports(ports)
+          args = []
+          ports.each do |options|
+            pf_builder = [options[:name],
+              options[:protocol] || "tcp",
+              "",
+              options[:hostport],
+              "",
+              options[:guestport]]
+
+            args.concat(["--natpf#{options[:adapter] || 1}",
+                        pf_builder.join(",")])
+          end
+
+          execute("modifyvm", @uuid, *args) if !args.empty?
+        end
+
+        def halt
+          execute("controlvm", @uuid, "poweroff")
+        end
+
+        def import(ovf)
+          output = ""
+          total = ""
+          last  = 0
+          execute("import", ovf) do |type, data|
+            if type == :stdout
+              # Keep track of the stdout so that we can get the VM name
+              output << data
+            elsif type == :stderr
+              # Append the data so we can see the full view
+              total << data
+
+              # Break up the lines. We can't get the progress until we see an "OK"
+              lines = total.split("\n")
+              if lines.include?("OK.")
+                # The progress of the import will be in the last line. Do a greedy
+                # regular expression to find what we're looking for.
+                if lines.last =~ /.+(\d{2})%/
+                  current = $1.to_i
+                  if current > last
+                    last = current
+                    yield current if block_given?
+                  end
+                end
+              end
+            end
+          end
+
+          # Find the name of the VM name
+          if output !~ /Suggested VM name "(.+?)"/
+            @logger.error("Couldn't find VM name in the output.")
+            return nil
+          end
+
+          name = $1.to_s
+
+          output = execute("list", "vms")
+          if output =~ /^"#{Regexp.escape(name)}" \{(.+?)\}$/
+            return $1.to_s
+          end
+
+          nil
+        end
+
+        def read_forwarded_ports(uuid=nil, active_only=false)
+          uuid ||= @uuid
+
+          @logger.debug("read_forward_ports: uuid=#{uuid} active_only=#{active_only}")
+
+          results = []
+          current_nic = nil
+          info = execute("showvminfo", uuid, "--machinereadable", :retryable => true)
+          info.split("\n").each do |line|
+            # This is how we find the nic that a FP is attached to,
+            # since this comes first.
+            current_nic = $1.to_i if line =~ /^nic(\d+)=".+?"$/
+
+              # If we care about active VMs only, then we check the state
+              # to verify the VM is running.
+              if active_only && line =~ /^VMState="(.+?)"$/ && $1.to_s != "running"
+                return []
+              end
+
+            # Parse out the forwarded port information
+            if line =~ /^Forwarding.+?="(.+?),.+?,.*?,(.+?),.*?,(.+?)"$/
+              result = [current_nic, $1.to_s, $2.to_i, $3.to_i]
+              @logger.debug("  - #{result.inspect}")
+              results << result
+            end
+          end
+
+          results
+        end
+
+        def read_bridged_interfaces
+          execute("list", "bridgedifs").split("\n\n").collect do |block|
+            info = {}
+
+            block.split("\n").each do |line|
+              if line =~ /^Name:\s+(.+?)$/
+                info[:name] = $1.to_s
+              elsif line =~ /^IPAddress:\s+(.+?)$/
+                info[:ip] = $1.to_s
+              elsif line =~ /^NetworkMask:\s+(.+?)$/
+                info[:netmask] = $1.to_s
+              elsif line =~ /^Status:\s+(.+?)$/
+                info[:status] = $1.to_s
+              end
+            end
+
+            # Return the info to build up the results
+            info
+          end
+        end
+
+        def read_guest_additions_version
+          output = execute("guestproperty", "get", @uuid, "/VirtualBox/GuestAdd/Version",
+                           :retryable => true)
+          if output =~ /^Value: (.+?)$/
+            # Split the version by _ since some distro versions modify it
+            # to look like this: 4.1.2_ubuntu, and the distro part isn't
+            # too important.
+            value = $1.to_s
+            return value.split("_").first
+          end
+
+          return nil
+        end
+
+        def read_host_only_interfaces
+          dhcp = {}
+          execute("list", "dhcpservers", :retryable => true).split("\n\n").each do |block|
+            info = {}
+
+            block.split("\n").each do |line|
+              if line =~ /^NetworkName:\s+HostInterfaceNetworking-(.+?)$/
+                info[:network] = $1.to_s
+              elsif line =~ /^IP:\s+(.+?)$/
+                info[:ip] = $1.to_s
+              elsif line =~ /^lowerIPAddress:\s+(.+?)$/
+                info[:lower] = $1.to_s
+              elsif line =~ /^upperIPAddress:\s+(.+?)$/
+                info[:upper] = $1.to_s
+              end
+            end
+
+            # Set the DHCP info
+            dhcp[info[:network]] = info
+          end
+
+          execute("list", "hostonlyifs", :retryable => true).split("\n\n").collect do |block|
+            info = {}
+
+            block.split("\n").each do |line|
+              if line =~ /^Name:\s+(.+?)$/
+                info[:name] = $1.to_s
+              elsif line =~ /^IPAddress:\s+(.+?)$/
+                info[:ip] = $1.to_s
+              elsif line =~ /^NetworkMask:\s+(.+?)$/
+                info[:netmask] = $1.to_s
+              elsif line =~ /^Status:\s+(.+?)$/
+                info[:status] = $1.to_s
+              end
+            end
+
+            # Set the DHCP info if it exists
+            info[:dhcp] = dhcp[info[:name]] if dhcp[info[:name]]
+
+            info
+          end
+        end
+
+        def read_mac_address
+          info = execute("showvminfo", @uuid, "--machinereadable", :retryable => true)
+          info.split("\n").each do |line|
+            return $1.to_s if line =~ /^macaddress1="(.+?)"$/
+          end
+
+          nil
+        end
+
+        def read_machine_folder
+          execute("list", "systemproperties", :retryable => true).split("\n").each do |line|
+            if line =~ /^Default machine folder:\s+(.+?)$/i
+              return $1.to_s
+            end
+          end
+
+          nil
+        end
+
+        def read_network_interfaces
+          nics = {}
+          info = execute("showvminfo", @uuid, "--machinereadable", :retryable => true)
+          info.split("\n").each do |line|
+            if line =~ /^nic(\d+)="(.+?)"$/
+              adapter = $1.to_i
+              type    = $2.to_sym
+
+              nics[adapter] ||= {}
+              nics[adapter][:type] = type
+            elsif line =~ /^hostonlyadapter(\d+)="(.+?)"$/
+              adapter = $1.to_i
+              network = $2.to_s
+
+              nics[adapter] ||= {}
+              nics[adapter][:hostonly] = network
+            elsif line =~ /^bridgeadapter(\d+)="(.+?)"$/
+              adapter = $1.to_i
+              network = $2.to_s
+
+              nics[adapter] ||= {}
+              nics[adapter][:bridge] = network
+            end
+          end
+
+          nics
+        end
+
+        def read_state
+          output = execute("showvminfo", @uuid, "--machinereadable", :retryable => true)
+          if output =~ /^name="<inaccessible>"$/
+            return :inaccessible
+          elsif output =~ /^VMState="(.+?)"$/
+            return $1.to_sym
+          end
+
+          nil
+        end
+
+        def read_used_ports
+          ports = []
+          execute("list", "vms", :retryable => true).split("\n").each do |line|
+            if line =~ /^".+?" \{(.+?)\}$/
+              uuid = $1.to_s
+
+              # Ignore our own used ports
+              next if uuid == @uuid
+
+              read_forwarded_ports(uuid, true).each do |_, _, hostport, _|
+                ports << hostport
+              end
+            end
+          end
+
+          ports
+        end
+
+        def read_vms
+          results = {}
+          execute("list", "vms", :retryable => true).split("\n").each do |line|
+            if line =~ /^"(.+?)" \{(.+?)\}$/
+              results[$1.to_s] = $2.to_s
+            end
+          end
+
+          results
+        end
+
+        def set_mac_address(mac)
+          execute("modifyvm", @uuid, "--macaddress1", mac)
+        end
+
+        def set_name(name)
+          execute("modifyvm", @uuid, "--name", name)
+        end
+
+        def share_folders(folders)
+          folders.each do |folder|
+            args = ["--name",
+              folder[:name],
+              "--hostpath",
+              folder[:hostpath]]
+            args << "--transient" if folder.has_key?(:transient) && folder[:transient]
+
+            # Add the shared folder
+            execute("sharedfolder", "add", @uuid, *args)
+
+            # Enable symlinks on the shared folder
+            execute("setextradata", @uuid, "VBoxInternal2/SharedFoldersEnableSymlinksCreate/#{folder[:name]}", "1")
+          end
+        end
+
+        def ssh_port(expected_port)
+          @logger.debug("Searching for SSH port: #{expected_port.inspect}")
+
+          # Look for the forwarded port only by comparing the guest port
+          read_forwarded_ports.each do |_, _, hostport, guestport|
+            return hostport if guestport == expected_port
+          end
+
+          nil
+        end
+
+        def resume
+          @logger.debug("Resuming paused VM...")
+          execute("controlvm", @uuid, "resume")
+        end
+
+        def start(mode)
+          command = ["startvm", @uuid, "--type", mode.to_s]
+          r = raw(*command)
+
+          if r.exit_code == 0 || r.stdout =~ /VM ".+?" has been successfully started/
+            # Some systems return an exit code 1 for some reason. For that
+            # we depend on the output.
+            return true
+          end
+
+          # If we reached this point then it didn't work out.
+          raise Errors::VBoxManageError, :command => command.inspect
+        end
+
+        def suspend
+          execute("controlvm", @uuid, "savestate")
+        end
+
+        def verify!
+          # This command sometimes fails if kernel drivers aren't properly loaded
+          # so we just run the command and verify that it succeeded.
+          execute("list", "hostonlyifs")
+        end
+
+        def verify_image(path)
+          r = raw("import", path.to_s, "--dry-run")
+          return r.exit_code == 0
+        end
+
+        def vm_exists?(uuid)
+          raw("showvminfo", uuid).exit_code == 0
+        end
+      end
+    end
+  end
+end