ruby-xen 0.0.3 → 0.1.0

data/lib/xen/backup.rb

@@ -1,42 +1,80 @@
-class Xen::Backup
-  include Xen::Parentable
+module Xen
+  class Backup
+    include Xen::Parentable
   
-  attr_accessor :name, :version
+    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 self.create(*args)
+      options = args.extract_options!
+      name = args.first
       
-  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])
+      # 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
+      if slice.running?
+        slice.stop
+        sleep 10
+        restart_slice = true
       end
-    }.compact
-  end
+
+      temp_mount = `mktemp -d -p /mnt #{name}-XXXXX`.chomp # XXX test for failure
+      `mount #{slice.root_disk.path} #{temp_mount}` # XXX test for failure
+      
+      
+
+      FileUtils.mkdir_p backup_dir
+      
+      # Creating archive at backup_dir/archive_name ...
+      excludes_file = File.join(File.dirname(__FILE__),'..','templates','exclude_from_backups')
+      temp_tarball = `mktemp -p #{backup_dir} #{name}-XXXXX`.chomp # XXX test for failure
+      `tar --create --exclude-from=#{excludes_file} --directory #{temp_mount} --file #{temp_tarball} . && mv #{temp_tarball} #{backup_dir}/#{archive_name}`
+      
+      # 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 if restart_slice == true
+      
+      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 filename
+      "#{@name}-#{@version}#{Xen::BACKUP_FILE_EXT}"
+    end
   
-  def fullpath
-    File.join(Xen::BACKUP_DIR, filename)
-  end
+    def fullpath
+      File.join(Xen::BACKUP_DIR, filename)
+    end
   
-  def size
-    File.size(fullpath)
-  end
+    def size
+      File.size(fullpath)
+    end
 
+  end
 end

data/lib/xen/command.rb

@@ -1,73 +1,107 @@
-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
   
-  # 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 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
+    # 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
+    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 
+    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
+    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 } 
+    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
-  end
   
-  def self.start_instance(config_file)
-    `xm create #{config_file}`
-  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
+    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
+    # 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.create_backup(*args)
+      name = args.shift
+      slice = Xen::Slice.find(name)
+      slice.create_backup
+    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,159 @@
+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)}" unless instance_variable_get('@'+key) == ''
+      }.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
+    
+    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,63 @@
-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
+  
+  
+  # XXX Move this somewhere else!
+  
+  # Network Bridge Script looks like this.
+  #
+  # #!/bin/sh
+  # /etc/xen/scripts/network-bridge $1 netdev=eth0 bridge=xenbr0 vifnum=0 antispoof=no
+  # /etc/xen/scripts/network-bridge $1 netdev=eth1 bridge=xenbr1 vifnum=1 antispoof=no
+  
+  class Bridges
+    NETWORK_BRIDGE_WRAPPER = '/etc/xen/scripts/network-bridge-wrapper'
+    
+    def self.find
+      f = File.readlines(NETWORK_BRIDGE_WRAPPER).collect { |line|
+        if (m = line.match /netdev=(.*) bridge=(.*) vifnum=(.*) antispoof=(.*)/)
+          Xen::Bridge.new :netdev => m[1], :bridge => m[2], :vifnum => m[3], :antispoof => m[4]
+        end
+      }.compact
+    end
+    
+    def self.save
+    end
+    
+  end
+  
+  class Bridge
+    attr_accessor :netdev, :bridge, :vifnum, :antispoof
+    
+    def initialize(*args)
+      options = args.extract_options!
+      @netdev = options[:netdev]
+      @bridge = options[:bridge]
+      @vifnum = options[:vifnum]
+      @antispoof = options[:antispoof]
     end
   end