ruby-xen 0.0.1 → 0.0.3

data/History.txt

@@ -1,3 +1,13 @@
+=== 0.0.3 / 2008-09-21
+
+* fleshed out :backup class
+* Xen::Commands are now easily called by backgroundjob (bj)
+
+=== 0.0.2 / 2008-09-11
+
+* Broke out classes into separate files
+* Added rspec outline
+
 === 0.0.1 / 2008-09-08
 
 * Initial import

data/Manifest.txt

@@ -4,5 +4,13 @@ README.rdoc
 Rakefile
 bin/ruby-xen
 lib/ruby-xen.rb
-test/test-ruby-xen.rb
+test/test_ruby-xen.rb
 lib/ruby-xen/domain.rb
+lib/xen/backup.rb
+lib/xen/command.rb
+lib/xen/config.rb
+lib/xen/slice.rb
+lib/xen/host.rb
+lib/xen/image.rb
+lib/xen/instance.rb
+lib/templates/domu.cfg.erb

data/README.rdoc

@@ -1,6 +1,9 @@
 = ruby-xen
 
-* FIX (url)
+# Warning! Not ready yet - project started Sep 2008
+
+http://github.com/mbailey/ruby-xen
+
 
 == DESCRIPTION:
 
@@ -19,11 +22,20 @@ ruby-xen can also be used by ruby code or from irb.
 
 == SYNOPSIS:
 
-  FIX (code sample of usage)
+  require 'rubygems'
+  require 'ruby-xen'
+
+  slice = Xen::Slice.find(:example)
+  slice.running? # true
+  slice.stop
+  slice.running? # false
+  slice.start
+  slice.running? # true
 
 == REQUIREMENTS:
 
-xen-tools (http://www.xen-tools.org/software/xen-tools/)
+ruby-xen must be run as root as it uses Xen's 'xm' command.
+xen-tools must be installed (http://www.xen-tools.org/software/xen-tools/)
 
 == INSTALL:
 
@@ -36,7 +48,7 @@ or open source applications. More details found here:
 http://www.gnu.org/licenses/gpl.html
 
 ruby-xen
-Copyright (C) 2008 Mike Bailey and Nick Markfleet
+Copyright (C) 2008 Mike Bailey and Nick Marfleet
 
 This program is free software; you can redistribute it and/or
 modify it under the terms of the GNU General Public License

data/Rakefile

@@ -1,12 +1,12 @@
 # -*- ruby -*-
 
-require 'rubygems'
-require 'hoe'
-require './lib/ruby_xen.rb'
-
-Hoe.new('ruby-xen', RubyXen::VERSION) do |p|
-  # p.rubyforge_name = 'ruby-xenx' # if different than lowercase project name
-  p.developer('Mike Bailey', 'mike@bailey.net.au')
-end
+# require 'rubygems'
+# require 'hoe'
+# require './lib/ruby-xen.rb'
+# 
+# Hoe.new('ruby-xen', Xen::VERSION) do |p|
+#   # p.rubyforge_name = 'ruby-xenx' # if different than lowercase project name
+#   p.developer('Mike Bailey', 'mike@bailey.net.au')
+# end
 
 # vim: syntax=Ruby

data/lib/ruby-xen.rb

@@ -1,4 +1,80 @@
-class RubyXen
-  VERSION = '1.0.0'
+module Xen
+  # General configuration for ruby-xen
+  
+  # Location of Xen config files
+  XEN_DOMU_CONFIG_DIR = '/etc/xen'
+  # XEN_DOMU_CONFIG_DIR = File.expand_path(File.join(File.dirname(__FILE__), '..', '..', '/spec/fixtures/xen_domu_configs'))
+  
+  # We don't want out library to hit Xen too often (premature optimization perhaps?)
+  # so we keep information about Xen instances in an object. Specify how long before
+  # the object expires.
+  INSTANCE_OBJECT_LIFETIME = 5 # seconds
+  
+  # General location for config file templates
+  TEMPLATE_DIR = File.expand_path(File.dirname(__FILE__) + '/../lib/templates')
+  
+  # Extension for Xen domU config files
+  CONFIG_FILE_EXTENSION = '.cfg'
+  
+  # Directory for backups of system images
+  BACKUP_DIR='/var/xen_images'
+  
+  # FIle extension for backups
+  BACKUP_FILE_EXT = '.tar'
 end
-require "#{File.dirname(__FILE__)}/ruby-xen/domain"
+
+class Array #:nodoc:
+  # Extracts options from a set of arguments. Removes and returns the last
+  # element in the array if it's a hash, otherwise returns a blank hash.
+  #
+  #   def options(*args)
+  #     args.extract_options!
+  #   end
+  #
+  #   options(1, 2)           # => {}
+  #   options(1, 2, :a => :b) # => {:a=>:b}
+  def extract_options!
+    last.is_a?(::Hash) ? pop : {}
+  end
+end
+
+class Hash #:nodoc:
+  # Converts a Hash into an array of key=val formatted strings
+  #
+  # puts { :nics => 2, :vcpus => 1, :memory => 64 }.to_args 
+  #
+  # produces:
+  #
+  # ["memory=64", "nics=2", "vcpus=1"]
+  def to_args
+    collect{|k,v| "#{k}=#{v}"}
+  end
+end
+
+module Xen
+  # DRY up some classes (children of Slice) with some module funkiness.
+  module Parentable
+    # Returns the parent Slice object (d) for a sub-object. 
+    # We ensure d.instance.object_id == self.object_id
+    # 
+    # ==== Example
+    #   i = Xen::Instance.all[2]
+    #   s = i.slice
+    #   i.object_id == s.instance.object_id # true
+    #
+    def slice
+      d = Xen::Slice.new(name)
+      # Insert the current object into the newly created Slice's attributes
+      d.instance_variable_set("@#{self.class.to_s.sub('Xen::','').downcase}", self)
+      d
+    end
+  end
+end
+
+require "#{File.dirname(__FILE__)}/xen/backup"
+require "#{File.dirname(__FILE__)}/xen/command"
+require "#{File.dirname(__FILE__)}/xen/config"
+require "#{File.dirname(__FILE__)}/xen/slice"
+require "#{File.dirname(__FILE__)}/xen/host"
+require "#{File.dirname(__FILE__)}/xen/image"
+require "#{File.dirname(__FILE__)}/xen/instance"

data/lib/templates/domu.cfg.erb

@@ -0,0 +1,40 @@
+#
+# Configuration file for the Xen instance <%= name %>, created
+# by ruby-xen on <%= Time.now %>.
+#
+
+#
+#  Kernel + memory size
+#
+kernel      = '<%= kernel %>'
+ramdisk     = '<%= ramdisk %>'
+memory      = '<%= memory %>'
+
+#
+#  Disk device(s).
+#
+root        = '<%= root %>'
+disk        = [ 
+	'<%= Array(vbds).collect{|d| d.to_str}.join("',\n\t'") %>' 
+]
+
+#
+#  Hostname
+#
+name        = '<%= name %>'
+
+#
+#  Networking
+#
+vif         = [
+	'<%= Array(vifs).collect{|v| v.to_str}.join("',\n\t'") %>'
+]
+
+#
+#  Behaviour
+#
+on_poweroff = '<%= on_poweroff %>'
+on_reboot   = '<%= on_reboot %>'
+on_crash    = '<%= on_crash %>'
+
+extra = '<%= extra %>'

data/lib/xen/backup.rb

@@ -0,0 +1,42 @@
+class Xen::Backup
+  include Xen::Parentable
+  
+  attr_accessor :name, :version
+  
+  def self.create(*args)
+    options = args.extract_options!
+    name = args.first
+    version = options[:version] || generate_version
+    Xen::Command.backup_slice(name, version)
+    new(name, version)
+  end
+      
+  def initialize(*args)
+    options = args.extract_options!
+    @name = args.first
+    @version = options[:version]
+  end
+  
+  def self.find(*args)
+    # return all
+    slice = args.first
+    Dir.glob("#{Xen::BACKUP_DIR}/*-*#{Xen::BACKUP_FILE_EXT}").collect { |file|
+      if match = File.basename(file, Xen::BACKUP_FILE_EXT).match(/(#{ slice || '.*' })-(.*)/)
+        new(match[1], :version => match[2])
+      end
+    }.compact
+  end
+    
+  def filename
+    "#{@name}-#{@version}#{Xen::BACKUP_FILE_EXT}"
+  end
+  
+  def fullpath
+    File.join(Xen::BACKUP_DIR, filename)
+  end
+  
+  def size
+    File.size(fullpath)
+  end
+
+end

data/lib/xen/command.rb

@@ -0,0 +1,73 @@
+class Xen::Command
+  # def self.xm_list
+  #   raw = `xm list`.scan(/(\S+)\s+(\S+)\s+(\S+)\s+(\S+)\s+(\S+)\s+(\S+)/)
+  #   headers = raw.delete_at(0)
+  #   raw.map do |row|
+  #     headers.enum_with_index.inject({}) { |m, (head, i)| m[head] = row[i]; m  }
+  #   end
+  # end
+  
+  # Return the size of a logical volume in gigabytes
+  def self.lv_size(vg_name, lv_name)
+    cmd = "lvs --noheadings --nosuffix --options lv_size --units g #{vg_name}/#{lv_name}"
+    `#{cmd}`.strip
+  end
+  
+  # Return list of logical volumes
+  def self.lv_list(vg_name)
+    cmd = "lvs --noheadings --nosuffix --options vg_name,lv_name,lv_size --units g #{vg_name}"
+    raw = `#{cmd}`
+    raw.scan(/(\S+)\s+(\S+)\s+(\S+)/).collect{ |vg_name, lv_name, size| 
+      {
+      :vg => vg_name,
+      :name => lv_name,
+      :size => size
+      }
+    }
+  end
+  
+  def self.vg_list
+    cmd = "vgs --noheadings --units g --nosuffix --options vg_name,vg_size,vg_free,lv_count,max_lv"
+    raw = `#{cmd}`
+    raw.scan(/(\S+)\s+(\S+)\s+(\S+)\s+(\S+)\s+(\S+)/).collect{ |vg_name, vg_size, vg_free, lv_count, max_lv|
+      {
+      :name => vg_name,
+      :size => vg_size,
+      :free => vg_free,
+      :lv_count => lv_count,
+      :max_lv => max_lv 
+      }
+    }
+  end
+  
+  def self.detailed_instance_list(name='')
+    cmd = "xm list --long #{name}"
+    raw_entries = `#{cmd}`.split(/\n\(domain/)
+    raw_entries.collect do |entry|
+      attributes = entry.scan(/\((name|domid|memory|vcpus|state|cpu_time|start_time) (.*)\)/)
+      attributes.inject({}) { |m, (key, val)| m[key.to_sym] = val; m } 
+    end
+  end
+  
+  def self.start_instance(config_file)
+    `xm create #{config_file}`
+  end
+  
+  def self.shutdown_instance(name, blocking=false)
+    `xm shutdown #{'-w' if blocking} #{name}`
+  end
+  
+  # Xen::Command.create_image('memory=512', :size => '10Gb')
+  # => "xm-create-image memory=512 size=10Gb"
+  #
+  def self.create_image(*args)
+    options = args.extract_options!
+    cmd = "xm-create-image #{args.concat(options.to_args).join(' ')}"
+    `cmd`
+  end
+    
+  def self.xm_info
+    result = `xm info`
+    result.scan(/(\S+)\s*:\s*([^\n]+)/).inject({}){ |m, (i,j)| m[i.to_sym] = j; m }
+  end
+end

data/lib/xen/config.rb

@@ -0,0 +1,146 @@
+require 'erb'
+
+class Xen::Config
+  # The config files for each Xen domU
+  include Xen::Parentable
+  attr_accessor :name, :kernel, :ramdisk, :memory, :root, :vbds, :vifs, :on_poweroff, :on_reboot, :on_crash, :extra
+
+  def initialize(*args)
+    options = args.extract_options!
+    @name = args.first
+    @kernel = options[:kernel]
+    @ramdisk = options[:ramdisk]
+    @memory = options[:memory]
+    @root = options[:root]
+    @vbds = options[:vbds]
+    @vifs = options[:vifs]
+    @on_poweroff = options[:on_poweroff]
+    @on_reboot = options[:on_reboot]
+    @on_crash = options[:on_crash]
+    @extra = options[:extra]
+  end
+
+  def self.find(*args)
+    options = args.extract_options!
+    case args.first
+      when :all       then all
+      else            find_by_name(args.first)
+    end
+  end
+
+  def self.all
+    config_files = Dir.glob("#{Xen::XEN_DOMU_CONFIG_DIR}/*#{Xen::CONFIG_FILE_EXTENSION}")
+    config_files.collect do |filename|
+      create_from_config_file(File.read(filename))
+    end
+  end    
+
+  def self.find_by_name(name)
+    return new('Domain-0') if name == 'Domain-0' 
+    filename = "#{Xen::XEN_DOMU_CONFIG_DIR}/#{name}#{Xen::CONFIG_FILE_EXTENSION}"
+    create_from_config_file(File.read(filename)) if File.exists?(filename)
+  end
+    
+  def config_file
+    "#{Xen::XEN_DOMU_CONFIG_DIR}/#{name}#{Xen::CONFIG_FILE_EXTENSION}"
+  end
+  
+  def auto_file
+    "#{Xen::XEN_DOMU_CONFIG_DIR}/auto/#{name}#{Xen::CONFIG_FILE_EXTENSION}"
+  end
+  
+  def updated_at
+	  File.mtime(config_file)
+	end
+	
+	# Set to true|false to enable|disable autostart of slice
+	def auto=(value)
+    filename = File.basename(config_file)
+    if value == true
+      File.symlink("../#{filename}", auto_file)
+    else
+      File.unlink(auto_file)
+    end
+  end
+  
+  # Returns true|false depending on whether slice is set to start automatically
+  def auto
+    File.symlink?(auto_file) && File.expand_path(File.readlink(auto_file), File.dirname(auto_file)) == config_file
+  end
+  
+  def self.create_from_config_file(config)
+    name, kernel, ramdisk, memory, root, disk, vif, on_poweroff, on_reboot, on_crash, extra = nil
+    eval(config)
+    vifs = Array(vif).collect { |v| Xen::Vif.from_str(v) }
+    vbds = Array(disk).collect { |d| Xen::Vbd.from_str(d) }
+    new(name, :disk => disk, :kernel => kernel, :ramdisk => ramdisk, :memory => memory, :root => root, :vbds => vbds, :vifs => vifs, :on_poweroff => on_poweroff, :on_reboot => on_reboot, :on_crash => on_crash, :extra => extra)
+  end
+  
+  def save
+    template = ERB.new IO.read(Xen::TEMPLATE_DIR + '/domu.cfg.erb')
+    File.open(config_file, 'w'){ |f| f.write template.result(binding) }
+  end
+  
+end
+
+
+# Virtual Network Interface
+#
+# http://wiki.xensource.com/xenwiki/XenNetworking
+#
+class Xen::Vif
+  attr_accessor :ip, :mac, :bridge, :vifname
+  def initialize(*args)
+    options = args.extract_options!
+    @ip = options[:ip] 
+    @mac = options[:mac]
+    @bridge = options[:bridge]
+    @vifname = options[:vifname]
+  end
+
+  def self.from_str(value)
+    options = value.scan(/(\w+)=([^,]+)/).inject({}){ |m, (k, v)| m[k.to_sym] = v; m }
+    new(options)
+  end
+
+  def to_str
+    %w(ip mac bridge vifname).collect { |key| 
+      "#{key}=#{instance_variable_get('@' + key)}" if !instance_variable_get('@'+key).nil?
+    }.compact.join(',')
+  end 
+end
+
+
+# Virtual Block Device
+#
+# We're only supporting Logical Volumes. No loopback devices.
+#
+# http://wiki.xensource.com/xenwiki/XenStorage
+#
+# == Example 
+#
+#   disk        = [ 'phy:xendisks/example-disk,sda1,w', 
+#                   'phy:xendisks/example-swap,sda2,w',
+#                   'phy:assets/example-assets,sdb1,w' ]
+class Xen::Vbd
+  attr_accessor :name, :vg, :domu, :mode
+  def initialize(name, vg, domu, mode='w')
+    @name, @vg, @domu, @mode = name, vg, domu, mode
+  end
+
+  def self.from_str(value)
+    dom0, domu, mode = value.split(',')
+    vg, name = dom0.split(/[\/:]/).slice(-2, 2)
+    new(name, vg, domu, mode)
+  end
+  
+  def size
+    Xen::Command.lv_size(@vg, @name)
+  end
+  
+  def to_str
+    "phy:#{vg}/#{lv},#{domu},#{mode}"
+  end 
+end
+
+

data/lib/xen/host.rb

@@ -0,0 +1,10 @@
+class Xen::Host
+  attr_reader :host, :machine, :total_memory, :free_memory
+
+  def initialize
+    Xen::Command.xm_info.each do |i,j|
+      instance_variable_set("@#{i}", j)
+    end
+  end
+  
+end

data/lib/xen/image.rb

@@ -0,0 +1,12 @@
+# class Xen::Image
+#   include Xen::Parentable
+#   attr_accessor :name
+# 
+#   def initialize(name)
+#     @name = name
+#   end
+# 
+#   def self.find(name)
+#     new name
+#   end
+# end

data/lib/xen/instance.rb

@@ -0,0 +1,66 @@
+class Xen::Instance
+  include Xen::Parentable
+  attr_reader :name, :domid, :memory, :cpu_time, :vcpus, :state, :start_time
+
+  def initialize(name, options={})
+    @name       = name
+    @domid      = options[:domid]
+    @memory     = options[:memory]
+    @cpu_time   = options[:cpu_time]
+    @vcpus      = options[:vcpus]
+    @state      = options[:state]
+    @start_time = Time.at(options[:start_time].to_f) if options[:start_time]
+  end
+
+  def self.find(*args)
+    options = args.extract_options!
+    case args.first
+    when :all       then all
+    else            find_by_name(args.first)
+    end
+  end
+
+  def self.all
+    Xen::Command.detailed_instance_list.collect do |instance|
+      new(name, instance)
+    end
+  end
+
+  def self.find_by_name(name)
+    Xen::Command.detailed_instance_list(name).each do |instance|
+      return new(name, instance)
+    end
+    return false
+  end
+
+  def self.create(name)
+    output = Xen::Command.start_instance(name.to_s + Xen::CONFIG_FILE_EXTENSION)
+    $? == 0 ? true : false
+  end
+
+  def self.shutdown(name)
+    output = Xen::Command.shutdown_instance(name)
+    $? == 0 ? true : false
+  end
+
+  # A convenience wrapper for <tt>find(:dom0)</tt>.</tt>.
+  def self.dom0(*args)
+    find_by_name(:dom0)
+  end
+
+  def uptime
+    start_time ? Time.now - start_time : nil
+  end
+
+  def reboot
+    `xm reboot #{name}`
+    $? == 0 ? true : false
+  end
+
+  def destroy
+  end
+
+  def pause
+  end
+
+end

data/lib/xen/slice.rb

@@ -0,0 +1,80 @@
+class Xen::Slice
+  attr_accessor :name, :image, :config, :backups
+  
+  def self.find(*args)
+    options = args.extract_options!
+    case args.first
+      when :all       then Xen::Config.find(:all, options).collect { |config| config.slice }
+      when :running   then Xen::Instance.find(:all, options).collect { |instance| instance.slice }
+      # Retrieve a Slice by name
+      else            Xen::Config.find_by_name(args.first) && self.new(args.first)
+    end
+  end
+  
+  def self.all(options={})
+    self.find(:all, options)
+  end
+  
+  def initialize(*args)
+    options = args.extract_options! # remove trailing hash (not used)
+    @name = args.first
+    @config = options[:config]
+    @instance = options[:instance]
+    @instance_cache_expires = Time.now
+    @backups = Array(options[:backups])
+  end
+
+  def create_image(args)
+    args = hash.collect{|k,v| "#{k}=#{v}"}
+    Xen::Command.create_image
+  end
+  
+  # Cache Xen instance info to reduce system calls to xm command.
+  # It still needs to be checked regularly as operations like shutdown
+  # and create can take a while.
+  def instance
+    if @instance_cache_expires > Time.now
+      @instance
+    else
+      @instance_cache_expires = Time.now + Xen::INSTANCE_OBJECT_LIFETIME
+      @instance = Xen::Instance.find(@name) if @name
+    end
+  end  
+
+  # XXX We're assuming other processes aren't going to edit configs
+  # This is reasonable in simple cases.
+  def config
+    @config ||= Xen::Config.find(name) if @name
+  end
+  
+  def backups
+    Xen::Backup.find(name)
+  end
+
+  def state
+    self.instance ? :running : :stopped
+  end
+    
+  def running?
+    self.instance ? true : false
+  end
+  
+  def start
+    Xen::Instance.create(@name)
+    @instance = Xen::Instance.find(@name)
+  end
+  
+  def stop
+    Xen::Instance.shutdown(@name)
+    @instance = Xen::Instance.find(@name)
+  end
+  
+  def config_newer_than_instance?
+	  instance && config.updated_at > instance.start_time 
+	end
+	
+	def save
+	  @config.save
+  end
+  
+end

data/test/test_ruby-xen.rb

@@ -0,0 +1,3 @@
+require '../lib/ruby-xen'
+c = Xen::Config.new
+c.save

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: ruby-xen
 version: !ruby/object:Gem::Version 
-  version: 0.0.1
+  version: 0.0.3
 platform: ruby
 authors: 
 - Mike Bailey
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2008-09-08 00:00:00 +10:00
+date: 2008-09-21 00:00:00 +10:00
 default_executable: 
 dependencies: []
 
@@ -32,13 +32,20 @@ files:
 - bin/ruby-xen
 - lib/ruby-xen.rb
 - test/test_ruby-xen.rb
-- lib/ruby-xen/domain.rb
+- lib/xen/backup.rb
+- lib/xen/command.rb
+- lib/xen/config.rb
+- lib/xen/host.rb
+- lib/xen/image.rb
+- lib/xen/instance.rb
+- lib/xen/slice.rb
+- lib/templates/domu.cfg.erb
 has_rdoc: true
-homepage: http://github.com/schacon/grit
+homepage: http://github.com/mbailey/ruby-xen
 post_install_message: 
 rdoc_options: 
 - --main
-- README.txt
+- README.rdoc
 require_paths: 
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement 

data/lib/ruby-xen/domain.rb

@@ -1,229 +0,0 @@
-class Array #:nodoc:
-  # Extracts options from a set of arguments. Removes and returns the last
-  # element in the array if it's a hash, otherwise returns a blank hash.
-  #
-  #   def options(*args)
-  #     args.extract_options!
-  #   end
-  #
-  #   options(1, 2)           # => {}
-  #   options(1, 2, :a => :b) # => {:a=>:b}
-  def extract_options!
-    last.is_a?(::Hash) ? pop : {}
-  end
-end
-
-module Xen
-  class Host
-  
-    attr_reader :host, :machine, :total_memory, :free_memory
-    def initialize
-      result = `xm info`
-      result.scan(/(\S+)\s*:\s*([^\n]+)/).each do |i,j| 
-        instance_variable_set("@#{i}", j)
-      end
-    end
-    
-  end
-
-
-  class Domain
-  
-    attr_accessor :name, :image, :config, :instance
-  
-    def initialize(name)
-      @name = name
-      @config = Xen::Config.find(name)
-      @instance = Xen::Instance.find(name)
-      @image = Xen::Image.find(name)
-    end
-  
-    def self.find(*args)
-      options = args.extract_options!
-      case args.first
-        when :all       then Xen::Config.find(:all, options).collect { |config| Xen::Domain.new(config.name) }
-        when :running   then Xen::Instance.find(:all, options).collect { |instance| Xen::Domain.new(instance.name) }
-        # Retrieve a Domain by name
-        else            Xen::Config.find_by_name(args.first) && self.new(args.first)
-      end
-    end
-  
-    def running?
-      @instance
-    end
-    
-  end
-
-
-  class Config
-  
-    attr_reader :name, :memory, :ip
-  
-    def initialize(*args)
-      options = args.extract_options!
-      @name = args.first
-      @memory = options[:memory] || nil
-      @ip = options[:ip] || nil
-    end
-  
-    def self.find(*args)
-      options = args.extract_options!
-      case args.first
-        when :all       then all
-        else            find_by_name(args.first)
-      end
-    end
-
-    def self.all
-      result = `xen-list-images`
-      configs = result.scan(/Name: (\w+)\nMemory: (\w+)\nIP: (\S+)/)
-      configs.collect do |config|
-        name, memory, ip = config
-        new(name, :memory => memory, :ip => ip)
-      end
-    end    
-  
-    def self.find_by_name(name)
-      return new('Domain-0') if name == 'Domain-0' 
-      all.detect {|config| puts config; config.name == name.to_s}
-    end
-  
-  end
-
-
-  class Image
-  
-    attr_accessor :name
-  
-    def initialize(name)
-      @name = name
-    end
-  
-    def self.find(name)
-      new name
-    end
-  
-    def find_one(name, options)
-      if result = find_every(options).first
-        result
-      else
-        raise RecordNotFound, "Couldn't find domain with name=#{name}"
-      end
-    end
-  end
-
-
-  class Instance
-  
-    attr_reader :name, :domid, :memory, :cpu_time, :vcpus, :state, :start_time
-  
-    def initialize(name, options={})
-      @name       = name
-      @domid      = options[:domid] || nil 
-      @memory     = options[:memory] || nil
-      @cpu_time   = options[:cpu_time] || nil
-      @vcpus      = options[:vcpus] || nil
-      @state      = options[:state] || nil
-      @start_time = options[:start_time] || nil
-    end
-  
-    def self.find(*args)
-      options = args.extract_options!
-      case args.first
-        when :all       then all
-        else            find_by_name(args.first)
-      end
-    end
-  
-    def self.all
-      result = `xm list`
-      # XXX check for failed command
-      result_array = result.split("\n")
-      result_array.shift
-      result_array.collect do |domain|
-        name, domid, memory, vcpus, state, cpu_time = domain.scan(/[^ ,]+/)
-        new(name, :domid => domid, :memory => memory, :cpu_time => cpu_time)
-      end
-    end
-  
-    def self.find_by_name(name)
-      all.detect{|domain| domain.name == name.to_s }
-    end
-  
-    # XXX Rails version - we need some error checking! 
-    #
-    # def self.find_by_name(name, options)
-    #   if result = find_every(options)
-    #     result.detect{ |domain| domain.name == name }
-    #   else
-    #     raise RecordNotFound, "Couldn't find domain with name=#{name}"
-    #   end
-    # end
-  
-    # A convenience wrapper for <tt>find(:dom0)</tt>.</tt>.
-    def dom0(*args)
-      find_by_name(:dom0)
-    end
-
-    # This is an alias for find(:all).  You can pass in all the same arguments to this method as you can
-    # to find(:all)
-    def all(*args)
-      find(:all, *args)
-    end
-  
-    def uptime
-      start_time ? Time.now - start_time : nil
-    end
-  
-    def running?
-      output = `xm list #{name}`
-      $? == 0 ? true : false
-    end
-  
-    def start
-      output = `xm create #{name}.cfg`
-      $? == 0 ? true : false
-    end
-  
-    def shutdown
-      output = `xm shutdown #{name}`
-      $? == 0 ? true : false
-    end
-  
-    def reboot
-      `xm reboot #{name}`
-      $? == 0 ? true : false
-    end
-  
-    def destroy
-    end
-  
-    def pause
-    end
-  
-  end
-
-  class Backup
-  end
-  
-  # class XenTools
-  # 
-  #   def self.xen_list_images
-  #     puts "returning list of images"
-  #   end
-  # 
-  #   def xen_create_image
-  #     puts "creating image"
-  #   end
-  # 
-  #   def xen_delete_image
-  #     puts "creating image"
-  #   end
-  # 
-  #   def xen_archive_image
-  #     puts "archiving image"
-  #   end
-  # 
-  # end
-
-end