mbailey-ruby-xen 0.0.2 → 0.0.3

data/lib/xen/backup.rb

@@ -1,3 +1,72 @@
-class Xen::Backup
-  include Xen::Parentable
+module Xen
+  class Backup
+    include Xen::Parentable
+  
+    attr_accessor :name, :version
+  
+    def self.create(*args)
+      options = args.extract_options!
+      name = args.first
+      
+      options = {}
+      name = 'foo' # XXX replace with real value
+      version = options[:version] || Time.now.strftime('%Y%m%d')
+      backup_dir = options[:backup_dir] || Xen::BACKUP_DIR
+      backup_file_ext = options[:backup_file_ext] || Xen::BACKUP_FILE_EXT
+      archive_name="#{name}-#{version}.#{backup_file_ext}"
+            
+      slice = Xen::Slice.find(name) # XXX test for failure
+      slice.stop
+      sleep 10
+
+      temp_mount = `mktemp -d -p /mnt #{name}-XXXXX`.chomp # XXX test for failure
+      `mount #{slice.root_disk.path} #{temp_mount}` # XXX test for failure
+
+      # Creating archive at $ARCHIVE_DIR/$ARCHIVE_NAME ...
+      `tar --create --exclude=/proc --exclude=/etc/udev/rules.d/70-persistent-net.rules --directory #{temp_mount} --file #{backup_dir}/#{archive_name} .`
+      # XXX test for failure
+      
+      # Unmounting image
+      `umount #{temp_mount}`
+      Dir.delete(temp_mount)
+
+      # Creating symlink from new backup to filename without version number
+      last_backup = "#{backup_dir}/#{name}.#{backup_file_ext}"
+      File.delete(last_backup) if File.symlink(last_backup)
+      `ln -sf #{backup_dir}/#{archive_name} #{last_backup}`
+      
+      slice.start
+      
+      new(:name => name, :version => version)
+    end
+
+    def initialize(*args)
+      options = args.extract_options!
+      @name = options[:name]
+      @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(:name => 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
 end

data/lib/xen/command.rb

@@ -1,30 +1,101 @@
-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
+module Xen
+  class Command
+    
+    class ExternalFailure < RuntimeError; end
+        
+    # 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
+    
+    def self.run(cmd)
+      output = []
+      error = nil
+      stat = Open4.popen4(cmd) do |pid, stdin, stdout, stderr|
+        while line = stdout.gets
+          output << line.strip
+        end
+        error = stderr.read.strip
+      end
+      # if stat.exited? # Is this needed?
+        if stat.exitstatus > 0
+          raise ExternalFailure, "Fatal error, `#{cmd}` returned #{stat.exitstatus} with '#{error}'"
+        end
+      # end
+      return output
+    end
   
-  def self.detailed_instance_list(name='')
-    raw_entries = `xm list --long #{name}`.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 } 
+    # 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
-  end
   
-  def self.create(config_file)
-    `xm create #{config_file}`
-  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.shutdown(name, blocking=false)
-    `xm shutdown #{'-w' if blocking} #{name}`
-  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"
+    #
+    # XXX call with a hash by default
+    #
+    def self.create_image(*args)
+      options = args.extract_options!
+      cmd = "xen-create-image #{args.concat(options.to_args).join(' ')}"
+      puts 
+      puts "Running the command:"
+      puts cmd
+      puts
+      system(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 }
+    def self.xm_info
+      result = `/usr/sbin/xm info`
+      result.scan(/(\S+)\s*:\s*([^\n]+)/).inject({}){ |m, (i,j)| m[i.to_sym] = j; m }
+    end
   end
 end

data/lib/xen/config_file.rb

@@ -0,0 +1,160 @@
+require 'erb'
+
+module Xen
+  class ConfigFile
+    # 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 = options[:name]
+      @kernel = options[:kernel]
+      @ramdisk = options[:ramdisk]
+      @memory = options[:memory].to_i
+      @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(:name => '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 filename
+      "#{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(filename)
+  	end
+	
+  	# Set to true|false to enable|disable autostart of slice
+  	def set_auto(value)
+      if value == true
+        File.symlink("../#{File.basename(filename)}", auto_file) unless auto
+      else
+        File.unlink(auto_file) if auto
+      end
+      auto == value # return true if final state is as requested
+    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)) == filename
+    end
+  
+    alias auto? auto
+  
+    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 => 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(filename, '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!
+      
+      # Validations - move them out into a validate function
+      raise(ValidationFailed, 'message') if options[:vifname] == 'foos' 
+      
+      @ip = options[:ip].to_s.gsub /['"]/, ''
+      @mac = options[:mac].to_s.gsub /['"]/, ''
+      @bridge = options[:bridge].to_s.gsub /['"]/, ''
+      @vifname = options[:vifname].to_s.gsub /['"]/, ''
+    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, :volume_group, :domu, :mode
+    def initialize(name, volume_group, domu, mode='w')
+      @name, @volume_group, @domu, @mode = name, volume_group, domu, mode
+    end
+
+    def self.from_str(value)
+      dom0, domu, mode = value.split(',')
+      volume_group, name = dom0.split(/[\/:]/).slice(-2, 2)
+      new(name, volume_group, domu, mode)
+    end
+  
+    def size
+      Xen::Command.lv_size(@volume_group, @name)
+    end
+    
+    # XXX Not needed?
+    # def path
+    #   "/dev/#{volume_group}/#{name}"
+    # end
+    
+    def to_str
+      "phy:#{volume_group}/#{name},#{domu},#{mode}"
+    end 
+  end
+  
+end
+

data/lib/xen/host.rb

@@ -1,9 +1,27 @@
-class Xen::Host
-  attr_reader :host, :machine, :total_memory, :free_memory
+module Xen
+  class Host
+    attr_reader :host, :machine, :total_memory, :nr_cpus
 
-  def initialize
-    Xen::Command.xm_info.each do |i,j|
-      instance_variable_set("@#{i}", j)
+    def initialize(detail_hash={})
+      detail_hash.each { |i,j| instance_variable_set("@#{i}", j) }
     end
+    
+    def self.find
+      new Xen::Command.xm_info
+    end
+    
+    def free_memory
+      if f = `free -m`
+        if (m = f.match /buffers\/cache.*\s+(\w+)\n/)
+          m[1].to_i
+        end
+      end
+    end
+    
+    def domu_memory
+      Xen::Slice.find(:running).inject(0){|m, slice| m += slice.instance.memory.to_i; m}
+    end
+  
   end
+  
 end

data/lib/xen/instance.rb

@@ -1,67 +1,68 @@
-class Xen::Instance
-  include Xen::Parentable
-  attr_reader :name, :domid, :memory, :cpu_time, :vcpus, :state, :start_time, :object_expires
+module Xen
+  class 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]
-    @object_expires = Time.now + Xen::INSTANCE_OBJECT_LIFETIME
-  end
+    def initialize(options={})
+      @name       = options[: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)
+    def self.find(*args)
+      options = args.extract_options!
+      case args.first
+      when :all       then all
+      else            find_by_name(args.first)
+      end
     end
-  end
 
-  def self.all
-    Xen::Command.detailed_instance_list.collect do |instance|
-      new(name, instance)
+    def self.all
+      Xen::Command.detailed_instance_list.collect do |instance|
+        new(instance)
+      end
     end
-  end
 
-  def self.find_by_name(name)
-    Xen::Command.detailed_instance_list(name).each do |instance|
-      return new(name, instance)
+    def self.find_by_name(name)
+      Xen::Command.detailed_instance_list(name).each do |instance|
+        return new(instance)
+      end
+      return false
     end
-    return false
-  end
 
-  def self.create(name)
-    output = Xen::Command.create(name.to_s + Xen::CONFIG_FILE_EXTENSION)
-    $? == 0 ? true : 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(name)
-    $? == 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
+    # 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 uptime
+      start_time ? Time.now - start_time : nil
+    end
 
-  def reboot
-    `xm reboot #{name}`
-    $? == 0 ? true : false
-  end
+    def reboot
+      `xm reboot #{name}`
+      $? == 0 ? true : false
+    end
 
-  def destroy
-  end
+    def destroy
+    end
 
-  def pause
-  end
+    def pause
+    end
 
-end
+  end
+end