virtuoso-ensure-state 0.0.6.beta

data/CHANGELOG

@@ -0,0 +1,23 @@
+0.0.6.beta
+====
+* Fix permission issues in gem deployment
+
+0.0.5.beta
+====
+* Sync code versioning schema
+
+0.0.4.beta
+====
+* Up version to fix back library push
+
+0.0.3.beta
+====
+* Fix issue with require paths in gemspec
+
+0.0.2.beta
+=====
+* Initial feature complete release of virtualbox backend
+
+0.0.1.beta
+=====
+* Initial release

data/LICENSE

@@ -0,0 +1,14 @@
+ Copyright (C) 2010 3Crowd Technologies, Inc.
+
+ This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <http://www.gnu.org/licenses/>.

data/README

@@ -0,0 +1,12 @@
+README for Virtuoso-ensure-state
+=============================
+Virtuoso-ensure-state is a program which converges virtual machines into a certain state. Essentially,
+it's an easy way to specify a state machine to ensure that your virtual machine remain in a state you
+control.
+
+Example
+=======
+./virtuoso-ensure-state -b virtualbox -m myvirtualmachine --ifpowered_off start --ifpaused resume --no-gui --silent
+
+would silently start the virtualbox based virtual machine if it were powered off and would resume it if it were paused, and would
+attempt to start it in the background in a non-gui mode.

data/bin/virtuoso-ensure-state

@@ -0,0 +1,10 @@
+#!/usr/bin/env ruby
+
+# Ensure library path is in load path
+library_path = File.join(File.dirname(__FILE__),'..','lib')
+$:.push(library_path) unless $:.include?(library_path)
+
+require 'ensure-state'
+require 'ensure-state/cli'
+
+Virtuoso::EnsureState::CLI.run!(ARGV)

data/lib/ensure-state.rb

@@ -0,0 +1,3 @@
+#Ensure the ensure-state library directory is on the include path
+include_path_location = File.join(File.dirname(__FILE__),'ensure-state')
+$:.push(include_path_location) unless $:.include?(include_path_location)

data/lib/ensure-state/cli.rb

@@ -0,0 +1,84 @@
+require 'ensure-state/cli/option_parser'
+require 'ensure-state/engine'
+
+require 'logger'
+
+module Virtuoso
+module EnsureState
+class CLI
+
+  class << self
+
+    # Creates and starts a new CLI instance for ensure-state.
+    # By default reads options from command line ARGV.
+    def run!(run_flags=ARGV)
+      self.new(run_flags).run!
+    end
+
+  end
+  
+  attr_reader :logger
+
+  def initialize(raw_run_flags)
+    @raw_run_flags = raw_run_flags
+    @logger = Logger.new(STDOUT)
+    
+    # defaults
+    
+    @logger.level = Logger::WARN
+    @logger.progname = self.class.name
+  end
+
+  # Starts a virtual machine convergence run using the ensure-state system guided by the run_flags passed into the initializer.
+  def run!
+    cli_parser = parse_run_flags(@raw_run_flags)
+    # display any informational messages emitted by the parser
+    puts cli_parser.messages.join("\n") unless cli_parser.messages.empty?
+    # exit if suggested by parser
+    exit(cli_parser.suggested_exit_return_code) if cli_parser.exit_after_message_display_suggested
+    
+    # setup logger
+    logger.level = Logger::DEBUG if cli_parser.options[:debug]
+    logger.level = Logger::INFO if cli_parser.options[:verbose]
+
+    # nothing within this application should log at a level higher than fatal
+    logger.level = Logger::UNKNOWN if cli_parser.options[:silent]
+    
+    logger.debug "Completed parsing command line arguments. Starting convergence engine."
+    
+    display_mode = cli_parser.options[:nogui] ? :vrdp : :gui
+    
+    # this is where all the actual work happens
+    engine = EnsureState::Engine.new(cli_parser.options[:backend], cli_parser.options[:machine], display_mode, cli_parser.options[:ifinstate], @logger)
+    
+    begin
+      engine.converge_vm_state!
+    rescue Errors::BackendUnavailableError => e
+      logger.fatal "Unable to access backend. Message: (#{e.message})"
+      exit(1)
+    rescue Errors::StateTransitionError => e
+      logger.fatal "Could not transition to state. Message: (#{e.message})"
+      exit(1)
+    rescue Errors::VMNotFoundError => e
+      logger.fatal "Unable to find VM. Message: (#{e.message})"
+      exit(1)
+    rescue Errors::InvalidVMBackendError => e
+      logger.fatal "Unable to find specified VM Backend. Message: (#{e.message})"
+      exit(1)
+    rescue StandardError => e
+      logger.fatal "Fatal Error: #{e.inspect}"
+      logger.fatal "Debug Backtrace: \n#{e.backtrace.join("\n")}" if cli_parser.options[:debug]
+      exit(1)
+    end
+    
+  end
+
+  private
+
+  def parse_run_flags(run_flags_to_parse)
+    CLIOptionParser.new(run_flags_to_parse)
+  end
+
+end
+end
+end

data/lib/ensure-state/cli/option_parser.rb

@@ -0,0 +1,145 @@
+require 'optparse' #stdlib
+require 'ensure-state/version'
+
+module Virtuoso
+module EnsureState
+class CLIOptionParser
+
+  STATES = [:powered_off, :running, :saved, :paused]
+  ACTIONS = [:start, :pause, :stop, :shutdown, :resume]
+  BACKENDS = [:virtualbox]
+
+  attr_reader :options
+  attr_reader :messages
+  attr_reader :exit_after_message_display_suggested
+  attr_reader :suggested_exit_return_code
+
+  def initialize(args)
+    @messages = Array.new
+    @options = Hash.new
+    @exit_after_message_display_suggested = false
+    @suggested_exit_return_code = 0
+    parse!(args)
+  end
+
+  private
+
+  def parse!(args)
+
+    # If we have no options, we need to display usage, which is the help option
+    args << '-h' if args.empty?
+
+    # The options specified on the command line will be collected in *options*
+    # We set defaults here.
+    options[:machine] = nil
+    options[:ifinstate] = Hash.new
+
+    opts = OptionParser.new do |opts|
+      opts.banner = "Usage: virtuoso-ensure-state [required options] [options]"
+      opts.separator "Example: virtuoso-ensure-state -b virtualbox -m development_vm --ifPoweredOff powerUp"
+      opts.separator "Version: #{Version.to_s}"
+
+      opts.separator ""
+      opts.separator "Required options:"
+
+      # Mandatory arguments
+      opts.on('-b', '--backend BACKEND',
+        "Backend to use") do |backend|
+        options[:backend] = backend.to_sym
+      end
+      
+      opts.on('-m', '--machine MACHINE',
+              'Virtual Machine name or UUID this application should manage') do |machine|
+        options[:machine] = machine
+      end
+      
+      opts.separator ""
+      opts.separator "available BACKENDs: #{BACKENDS.join(', ')}"
+      
+      opts.separator ""
+      opts.separator "Specific options:"
+
+      # Optional arguments
+      STATES.each do |state|
+
+        opts.on("--if#{state} ACTION",
+                "Action to take if a given virtual machine is in state #{state}") do |action|
+          options[:ifinstate][state] = action.to_sym
+        end
+
+      end
+
+      opts.separator ""
+      opts.separator "Available ACTIONs: #{ACTIONS.join(', ')}"
+      opts.separator ""
+      opts.separator "Common options:"
+
+      opts.on('--no-gui', "Attempt to run virtual machines in no-gui mode (dependent on backend)") do
+        options[:nogui] = true
+      end
+
+      opts.on('-s', "--silent", "Run silently (no output)") do
+        options[:silent] = true
+      end
+
+      opts.on('-v', "--[no-]verbose", "Run verbosely") do |v|
+        options[:verbose] = v
+      end
+
+      opts.on('-d', "--debug", "Run with debugging messages and behavior turned on") do
+        options[:debug] = true
+      end
+
+      # No argument, shows at tail. This will print an options summary.
+      opts.on_tail('-h', '--help', 'Show this message') do
+        @messages << opts.to_s
+        options[:help_requested] = true
+        suggest_exit_after_message_display
+      end
+
+      opts.on_tail('-v', '--version', 'Show application version') do
+        @messages << Version.to_s
+        suggest_exit_after_message_display
+      end
+
+    end
+
+    opts.parse!(args)
+
+    ensure_required_switches_passed!
+
+  end
+
+  def ensure_required_switches_passed!
+    return if @options[:help_requested]
+    
+    if @options[:backend].nil? || @options[:machine].nil? then
+      @messages << 'Error: Required option not set. Please ensure all required options have been set. See usage by using -h flag.'
+      suggest_exit_after_message_display
+      suggest_exit_return_code(1)
+    end
+    
+    unless @options[:backend] && BACKENDS.member?(@options[:backend])
+      @messages << 'Error: Invalid backend specified. Please ensure backend exists in available backend list. See available backends using -h flag.'
+      suggest_exit_after_message_display
+      suggest_exit_return_code(1)
+    end
+    
+    unless @options[:ifinstate] && @options[:ifinstate].values.all?{|value|ACTIONS.member?(value)}
+      @messages << 'Error: Invalid action specified for :ifinstate. Ensure all actions are set appropriately. See usage and available actions by using the -h flag.'
+      suggest_exit_after_message_display
+      suggest_exit_return_code(1)
+    end
+  end
+
+  def suggest_exit_return_code(code)
+    @suggested_exit_return_code = code
+  end
+
+  def suggest_exit_after_message_display
+    @exit_after_message_display_suggested = true
+  end
+
+end
+end
+end

data/lib/ensure-state/engine.rb

@@ -0,0 +1,81 @@
+require 'ensure-state/vm_backend/virtualbox'
+
+require 'ensure-state/vm'
+
+require 'ensure-state/errors/invalid_vm_backend_error'
+
+module Virtuoso
+module EnsureState
+
+  class Engine
+
+    attr_reader :state_and_action_map, :logger
+
+    # Instantiate a new engine for converging vm state
+    #
+    # @param [EnsureState::VMBackend::Base] backend The VM Backend where the machine specified in vm_name can be found
+    # @param [String] vm_name A name or UUID which uniquely identifies the virtual machine inside the backend specified in backend
+    # @param [Hash<Symbol, Symbol>] state_and_action_map A mapping of states, if a VM is in one of those keyed states, take the specified action. Otherwise, do nothing
+    # @param [Logger] logger The logger for engine information
+    def initialize backend, vm_name, vm_display_mode, state_and_action_map, logger = Logger.new(STDOUT)
+      @backend_name = backend
+      @vm_display_mode = vm_display_mode
+      @vm_name = vm_name
+      @state_and_action_map = state_and_action_map
+      @logger = logger.dup
+      @logger.progname = self.class.name
+    end
+
+    # Converges the specified backend VM state utilizing the state_and_action_map
+    #
+    # @raise [Errors::BackendUnavailableError] The specified backend was unavailable for interaction
+    # @raise [Errors::StateTransitionError] There was an error transitioning a VirtualMachine into a specified state
+    # @raise [Errors::VMNotFoundError] The VM specified as not found by the backend
+    # @raise [Errors::InvalidVMBackendError] The specified VM Backend was not registered
+    def converge_vm_state!
+      logger.debug "Converging VM State"
+      action_to_take = state_and_action_map[vm.state]
+      if action_to_take.nil?
+        logger.info "No action specified for current virtual machine state (#{vm.state})"
+      else
+        logger.info "Taking action: #{action_to_take}"
+        vm.state = action_to_take if backend.can_transition_to_state?(vm.state, action_to_take)
+      end
+    end
+
+    # The backend in which the specified virtual machine should be found
+    #
+    # @raise [Errors::InvalidVMBackendError] The specified VM Backend was not registered
+    def backend
+      @backend ||= load_backend(@backend_name)
+    end
+
+    # The virtual machine to be operated on by this engine
+    #
+    # @raise [Errors::VMNotFoundError] The VM specified was not found by the backend
+    def vm
+      logger.debug("Finding VM (#{@vm_name})")
+      return @vm if @vm
+      @vm = VM.find!(@vm_name, backend, logger)
+      @vm.display_mode = @vm_display_mode
+      @vm
+    end
+
+    private
+    
+    def load_backend(backend)
+      logger.debug "Finding backend for load call: #{backend}"
+      backend_instance = case backend
+        when :virtualbox
+          VMBackend::VirtualBox.new(logger)
+        else
+          raise Errors::InvalidVMBackendError, "Specified backend (#{backend}) is not a registered backend"
+      end
+      logger.debug "Found backend for load call: #{backend}"
+      return backend_instance
+    end
+
+  end
+
+end
+end

data/lib/ensure-state/errors/ensure_state_error.rb

@@ -0,0 +1,10 @@
+module Virtuoso
+module EnsureState
+module Errors
+
+  class EnsureStateError < StandardError
+  end
+
+end
+end
+end

data/lib/ensure-state/errors/invalid_vm_backend_error.rb

@@ -0,0 +1,12 @@
+require 'ensure-state/errors/ensure_state_error'
+
+module Virtuoso
+module EnsureState
+module Errors
+
+  class InvalidVMBackendError < EnsureStateError
+  end
+
+end
+end
+end

data/lib/ensure-state/errors/vm_backend_error.rb

@@ -0,0 +1,12 @@
+require 'ensure-state/errors/ensure_state_error'
+
+module Virtuoso
+module EnsureState
+module Errors
+
+  class VMBackendError < EnsureStateError
+  end
+
+end
+end
+end

data/lib/ensure-state/errors/vm_backend_errors/backend_unavailable_error.rb

@@ -0,0 +1,12 @@
+require 'ensure-state/errors/vm_backend_error'
+
+module Virtuoso
+module EnsureState
+module Errors
+
+  class BackendUnavailableError < VMBackendError
+  end
+
+end
+end
+end

data/lib/ensure-state/errors/vm_backend_errors/invalid_state_error.rb

@@ -0,0 +1,12 @@
+require 'ensure-state/errors/vm_backend_error'
+
+module Virtuoso
+module EnsureState
+module Errors
+
+  class InvalidStateError < VMBackendError
+  end
+
+end
+end
+end

data/lib/ensure-state/errors/vm_backend_errors/state_transition_error.rb

@@ -0,0 +1,12 @@
+require 'ensure-state/errors/vm_backend_error'
+
+module Virtuoso
+module EnsureState
+module Errors
+
+  class StateTransitionError < VMBackendError
+  end
+
+end
+end
+end

data/lib/ensure-state/errors/vm_backend_errors/vm_not_found_error.rb

@@ -0,0 +1,12 @@
+require 'ensure-state/errors/vm_backend_error'
+
+module Virtuoso
+module EnsureState
+module Errors
+
+  class VMNotFoundError < VMBackendError
+  end
+
+end
+end
+end

data/lib/ensure-state/version.rb

@@ -0,0 +1,16 @@
+module Virtuoso
+module EnsureState
+class Version
+
+  MAJOR = '0'
+  MINOR = '0'
+  POINT = '6'
+  RELEASE_MARKER = 'beta'
+
+  def self.to_s
+    [MAJOR,MINOR,POINT,RELEASE_MARKER].join('.')
+  end
+
+end
+end
+end

data/lib/ensure-state/vm.rb

@@ -0,0 +1,101 @@
+require 'ensure-state/vm_backend/base'
+require 'ensure-state/errors/vm_backend_errors/vm_not_found_error'
+
+module Virtuoso
+module EnsureState
+class VM
+
+  # Find a virtual machine instance on the specified backend
+  #
+  # @params [String] name_or_uuid The name or uuid of the vm to find
+  # @params [VMBackend::Base] backend a virtual machine backend implementation,
+  #   usage of the abstract implementation is not recommended
+  # @return [VM, false] The virtual machine instance, or false if the instance is
+  #   is not found
+  def self.find name_or_uuid, backend, logger = Logger.new(STDOUT)
+    begin
+      self.find! name_or_uuid, backend, logger
+    rescue Errors::VMNotFoundError => e
+      false
+    end
+  end
+
+  # Find a virtual machine instance on the specified backend, raising an exception
+  # if the virtual machine is not found
+  #
+  # @params [String] name_or_uuid The name or uuid of the vm to find
+  # @params [VMBackend::Base] backend a virtual machine backend implementation,
+  #   usage of the abstract implementation is not recommended
+  # @return [VM, false] The virtual machine instance
+  # @raise [VMNotFoundError] Exception raised if virtual machine is not found
+  def self.find! name_or_uuid, backend, logger = Logger.new(STDOUT)
+    self.new name_or_uuid, backend, logger
+  end
+
+  attr_accessor :display_mode
+  attr_reader :vm_name, :backend, :logger
+
+  def initialize name_or_uuid, backend, logger = Logger.new(STDOUT)
+    @logger = logger.dup
+    @logger.progname = self.class.name
+
+    @display_mode = nil
+    @vm_name = name_or_uuid
+    @backend = backend
+    verify_backend_is_a_valid_backend @backend
+    @vm = retrieve_backend_reference_to_named_vm @backend, @vm_name
+  end
+  
+  # The human readable name of the VM, may be the UUID if there is no human readable
+  # name assigned by the backend
+  #
+  # @return [String] The human readable Virtual Machine name, or uuid if no human readable
+  #   name is available
+  def name
+    name = @backend.vm_name(@vm)
+    unless name
+      uuid
+    end
+  end
+
+  # The state of the vm.
+  #
+  # @return [Symbol] The state of the virtual machine
+  def state
+    state = @backend.vm_state(@vm)
+  end
+  
+  # Set the state of the vm
+  #
+  # @raise [Errors::InvalidStateError] Error raised if the specified state is not recognized by the backend, or if the current
+  #   state of the virtual machine does not allow for setting the specified state
+  def state= state
+    @backend.vm_set_state!(@vm, state, { :mode => display_mode })
+  end
+
+  # The unique identifier for the VM. Note: The score of the uniqueness is guaranteed by
+  # the backend. It may not be universally unique
+  #
+  # @return [String] The Virtual Machine unique identifier
+  def uuid
+    @backend.vm_uuid(@vm)
+  end
+  
+  private
+  
+  def verify_backend_is_a_valid_backend backend
+    logger.debug("Verifying backend type")
+    backend.kind_of? VMBackend::Base
+  end
+  
+  def retrieve_backend_reference_to_named_vm backend, named_vm
+    logger.debug("Retrieving backend reference to named vm. Backend: #{backend}. Named VM: #{named_vm}")
+    vm = backend.vm_find named_vm
+    raise Errors::VMNotFoundError if vm.nil?
+    logger.debug("Successfully retrieved backend reference to named vm. Backend Reference Class: #{vm.class.name}")
+    vm
+  end
+
+end
+end
+end

data/lib/ensure-state/vm_backend/base.rb

@@ -0,0 +1,96 @@
+require 'ensure-state/errors/vm_backend_errors/state_transition_error'
+
+module Virtuoso
+module EnsureState
+module VMBackend
+
+  class Base
+
+    class << self
+
+      # The logger for EnsureState::VMBackend objects
+      #
+      # @return [Logger] The logger
+      def logger
+        @@logger
+      end
+
+      # Set the logger used for EnsureState::VMBackend objects
+      #
+      # @param [Logger] logger A logger conforming to the Ruby 1.8+ Logger class interface
+      def logger= logger
+        @@logger = logger
+      end
+
+    end
+    
+    VALID_ACTION_TO_STATE_APPLICATION_MAP = {
+    }
+
+    # Find a virtual machine on the backend
+    #
+    # @param [String] name_or_uuid the name or uuid to find
+    # @return [EnsureState::VM, false] the virtual machine or false if the machine was not found
+    def vm_find name_or_uuid
+      raise NotImplementedError, "#find is not implemented on the abstract VM Backend, please use a concrete implementation"
+    end
+    
+    # Retrieve the human readable name of the given virtual machine or false if no human readable name
+    # is available
+    #
+    # @param [EnsureState::VM] virtual_machine The virtual machine on which the name should be retrieved
+    # @return [String, false] The human readable name of the virtual machine, or false if no human readable name is available
+    def vm_name virtual_machine
+      raise NotImplementedError, "#vm_name is not implemented on the abstract VM Backend, please use a concrete implementation"
+    end
+    
+    # Retrieve the unique identifier for given virtual machine. This should always be available. The unique
+    # identifier (or uuid) is an arbitrary token, chosen by the backend, that uniquely identifies the virtual machine
+    # within a scope to be decided by the backend
+    #
+    # @param [EnsureState::VM] virtual_machine The virtual machine whose uuid should be retrieved
+    # @return [String] The unique identifier
+    def vm_uuid virtual_machine
+      raise NotImplementedError, "#vm_uuid is not implemented on the abstract VM Backend, please use a concrete implementation"
+    end
+    
+    # Retrieve the state of a given virtual machine
+    #
+    # @param [EnsureState::VM] virtual_machine The virtual machine whose state should be retrieved
+    # @return [Symbol] The state of the virtual machine
+    def vm_state virtual_machine
+      raise NotImplementedError, "#vm_state is not implemented on the abstract VM Backend, please use a concrete implementation"
+    end
+    
+    # Attempt to set the state of a given virtual machine. You must check the return value to ensure the state of of the virtual
+    # machine in the backend. To be certain please use vm_set_state! which raises exceptions if the specified state could not
+    # be reached
+    #
+    # @param [Ensure_State::VM] virtual_machine The virtual machine whose state should be set
+    # @param [Symbol] state The state to which the machine should be moved
+    # @return [Boolean] True if machine has successfully been moved to the specified state, False if not
+    def vm_set_state virtual_machine, state
+      begin
+        vm_set_state! virtual_machine, state
+      rescue Errors::StateTransitionError => e
+        return false
+      end
+      true
+    end
+    
+    # Set the state of a given virtual machine. If the state cannot be reached from the current state or a failure occurs in setting
+    # an exception is raised, depending on the specific error. The exception thrown will always subclass Errors::StateTransitionError
+    #
+    # @param [Ensure_State::VM] virtual_machine The virtual machine whose state will be set
+    # @param [Symbol] state The state to which the machine will be moved
+    # @raise [Errors::StateTransitionError] An exception, or a subclass thereof, which is raised when the specified state could not be reached.
+    #   The reason for which is specified by the particular subclass of StateTransitionError
+    def vm_set_state! virtual_machine, state
+      riase NotImplementedError, "#vm_set_state! is not implemented on the abstract VM Backend, please use a concrete implementation"
+    end
+
+  end
+
+end
+end
+end

data/lib/ensure-state/vm_backend/virtualbox.rb

@@ -0,0 +1,118 @@
+require 'ensure-state/errors/vm_backend_errors/backend_unavailable_error'
+require 'ensure-state/errors/vm_backend_errors/invalid_state_error'
+require 'ensure-state/errors/vm_backend_errors/vm_not_found_error'
+
+require 'ensure-state/vm_backend/base'
+
+require 'rubygems'
+require 'virtualbox'
+
+module Virtuoso
+module EnsureState
+module VMBackend
+
+  class VirtualBox < Base
+    
+    VALID_ACTION_TO_STATE_APPLICATION_MAP = {
+      :start => [:powered_off, :saved],
+      :pause => [:running],
+      :saved_state => [:running],
+      :stop => [:running],
+      :shutdown => [:running],
+      :resume => [:paused]
+    }
+    
+    VM_BACKEND_SETTLE_TIME = 0.5 #seconds
+    
+    attr_reader :logger
+    
+    def initialize(logger = Logger.new(STDOUT))
+      @logger = logger.dup
+      @logger.progname = self.class.name
+      
+      logger.debug("Initializing VirtualBox Backend")
+      
+      @backend = ::VirtualBox
+      ensure_valid_backend_version @backend
+    end
+
+    def vm_find name_or_uuid
+      logger.debug("Finding VM (#{name_or_uuid})")
+      vm = @backend::VM.find(name_or_uuid)
+      logger.debug("Found VM (#{name_or_uuid})") if vm
+      vm
+    end
+    
+    def vm_name virtual_machine
+      virtual_machine.name
+    end
+    
+    def vm_uuid virtual_machine
+      virtual_machine.uuid
+    end
+    
+    def vm_state virtual_machine
+      virtual_machine.state
+    end
+    
+    def vm_set_state! virtual_machine, state_to_set, options = {}
+      ensure_transition_action_valid!(virtual_machine.state, state_to_set)
+      options[:mode] = :gui if state_to_set == :start && options[:mode].nil?
+      state_set_successfully = case state_to_set
+        when :start then
+          logger.debug("Backend starting VM (#{virtual_machine.uuid}/#{virtual_machine.name})")
+          virtual_machine.start(options[:mode])
+        when :pause then
+          logger.debug("Backend pausing VM (#{virtual_machine.uuid}/#{virtual_machine.name})")
+          virtual_machine.pause
+          #FIXME: evil hack, this method doesn't seem to block until completed
+          sleep(VM_BACKEND_SETTLE_TIME)
+          virtual_machine.paused?
+        when :saved_state then
+          logger.debug("Backend saving state of VM (#{virtual_machine.uuid}/#{virtual_machine.name})")
+          virtual_machine.save_state
+        when :stop then
+          logger.debug("Backend stopping VM (#{virtual_machine.uuid}/#{virtual_machine.name})")
+          virtual_machine.stop
+          #FIXME: evil hack, this method doesn't seem to block until completed
+          sleep(VM_BACKEND_SETTLE_TIME)
+          virtual_machine.powered_off?
+        when :shutdown then
+          logger.debug("Backend shutting down VM (#{virtual_machine.uuid}/#{virtual_machine.name})")
+          virtual_machine.shutdown
+          #FIXME: this command should not fail, but the guest operating system won't neccessarily shut down immediately. this is a safe shutdown
+          true
+        when :resume then
+          logger.debug("Backend resuming VM (#{virtual_machine.uuid}/#{virtual_machine.name})")
+          virtual_machine.resume
+          #FIXME: evil hack, this method doesn't seem to block until completed
+          sleep(VM_BACKEND_SETTLE_TIME)
+          virtual_machine.running?
+      end
+      raise Errors::StateTransitionError, "Error transitioning VM to state #{state_to_set}. Virtual Machine backend thinks machine is now in state: #{virtual_machine.state}" unless state_set_successfully
+    end
+    
+    def can_transition_to_state? current_state, action
+      action_set = VALID_ACTION_TO_STATE_APPLICATION_MAP[action]
+      !action_set.nil? && action_set.member?(current_state)
+    end
+    
+    private
+    
+    def ensure_transition_action_valid! current_state, action
+      message = VALID_ACTION_TO_STATE_APPLICATION_MAP[action].nil? ? "Setting state to #{action} not implemented" : "Machine not in one of (#{VALID_ACTION_TO_STATE_APPLICATION_MAP[action] }) states. Cannot #{action}"
+      raise Errors::InvalidStateError, message unless can_transition_to_state? current_state, action
+    end
+    
+    def ensure_valid_backend_version backend
+      version = backend.version
+      logger.debug("VirtualBox backend version: #{version}")
+      raise Errors::BackendUnavailableError, "Backend could not be loaded" if version.nil?
+      true
+    end
+    
+  end
+
+end
+end
+end

metadata

@@ -0,0 +1,105 @@
+--- !ruby/object:Gem::Specification 
+name: virtuoso-ensure-state
+version: !ruby/object:Gem::Version 
+  hash: 31098201
+  prerelease: true
+  segments: 
+  - 0
+  - 0
+  - 6
+  - beta
+  version: 0.0.6.beta
+platform: ruby
+authors: 
+- 3Crowd Technologies, Inc.
+- Justin Lynn
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-11-10 00:00:00 -08:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: virtualbox
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 9
+        segments: 
+        - 0
+        - 7
+        - 5
+        version: 0.7.5
+  type: :runtime
+  version_requirements: *id001
+description: Ensures the state of virtual machines on the host system. If a Virtual Machine is not in the desired state, report it, and, if desired, take action to put them in that state
+email: 
+- eng@3crowd.com
+executables: 
+- virtuoso-ensure-state
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- bin/virtuoso-ensure-state
+- lib/ensure-state.rb
+- lib/ensure-state/version.rb
+- lib/ensure-state/vm.rb
+- lib/ensure-state/cli/option_parser.rb
+- lib/ensure-state/cli.rb
+- lib/ensure-state/engine.rb
+- lib/ensure-state/vm_backend/base.rb
+- lib/ensure-state/vm_backend/virtualbox.rb
+- lib/ensure-state/errors/ensure_state_error.rb
+- lib/ensure-state/errors/vm_backend_errors/backend_unavailable_error.rb
+- lib/ensure-state/errors/vm_backend_errors/invalid_state_error.rb
+- lib/ensure-state/errors/vm_backend_errors/state_transition_error.rb
+- lib/ensure-state/errors/vm_backend_errors/vm_not_found_error.rb
+- lib/ensure-state/errors/invalid_vm_backend_error.rb
+- lib/ensure-state/errors/vm_backend_error.rb
+- LICENSE
+- README
+- CHANGELOG
+has_rdoc: true
+homepage: http://github.com/3Crowd/virtuoso-ensure-state
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 23
+      segments: 
+      - 1
+      - 3
+      - 6
+      version: 1.3.6
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Ensures the state of virtual machines on the host system
+test_files: []
+