mbailey-ruby-xen 0.0.2 → 0.0.3

data/lib/xen/lvm.rb

@@ -0,0 +1,33 @@
+require 'open4'
+
+module Xen
+  
+  class VolumeGroup
+    
+    attr_reader :name, :size
+  
+    def initialize(name, size)
+      @name = name
+      @size = size
+    end
+  
+    def self.find(name=nil)
+      name ||= nil
+      # XXX deal with not found error
+      cmd = "vgs --options=vg_name,vg_size --separator=' ' --noheadings --units=g --nosuffix #{name}"
+      output = Xen::Command.run cmd
+      result = output.collect { |line|
+        name, size = line.strip.split(' ')
+        new name, size
+      }
+      name ? result[0] : result
+    end
+  
+    def free
+      cmd = "vgs --options=vg_free --separator=' ' --noheadings --units=g --nosuffix #{@name}"
+      Xen::Command.run cmd
+    end
+    
+  end
+  
+end

data/lib/xen/slice.rb

@@ -1,55 +1,129 @@
-class Xen::Slice
-  attr_accessor :name, :image, :config
+module Xen
+  class Slice
+    attr_accessor :name, :image, :config_file, :backups
+  
+    def self.find(*args)
+      options = args.extract_options!
+      case args.first
+        when :all       then Xen::ConfigFile.find(:all, options).collect { |config_file| new :name => config_file.name }
+        when :running   then Xen::Instance.find(:all, options).collect { |instance| new :name => instance.name }
+        # Retrieve a Slice by name
+        else            Xen::ConfigFile.find_by_name(args.first) && new(:name => args.first)
+      end
+    end
+  
+    def self.all(options={})
+      self.find(:all, options)
+    end
+  
+    def initialize(*args)
+      options = args.extract_options! 
+      @name = options[:name]
+      @config_file = options[:config_file]
+      @instance = options[:instance]
+      @instance_cache_expires = Time.now
+      @backups = Array(options[:backups])
+    end
 
-  def initialize(name)
-    @name = name
-    @config = Xen::Config.find(name)
-    @instance = Xen::Instance.find(name)
-    @image = Xen::Image.find(name)
-  end
+    def create_image(*args)
+      options = args.extract_options!.stringify_keys
+      
+      # Load default values for options that have not been set
+      options.reverse_merge! Xen::XenToolsConf.find.to_hash 
+      
+      # Set some derived options
+      options.reverse_merge! 'hostname' => name # Name host after this slice
+      options['dhcp'] = true unless options['ip']
+      options['swap'] ||= options['memory'].to_i * 2
+      if options['root_pass']
+        options['role'] = 'passwd'
+        options['role-args'] = options['root_pass']
+      end
+      unless [nil,''].include?(options['tarball'])
+        options['install-method'] = 'tar'
+        options['install-source'] = options['tarball']
+        options.delete('dist')
+      end
+      
+      args = %w(hostname dist memory size
+                force boot
+                role role-args roledir
+                dir lvm mirror 
+                ip mac netmask broadcast gateway dhcp
+                swap
+                accounts admins cache config fs image image-dev initrd 
+                keep kernel modules output install hooks partitions 
+                passwd tar-cmd extension swap-dev noswap ide arch 
+                install-method install-source template evms)
+      # Remove options that are not in allowed argument list
+      options.keys.each { |key| options.delete(key) unless args.include?(key) }
+      
+      Xen::Command.create_image(options)
+    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  
 
-  def instance
-    if @instance && @instance.object_expires > Time.now
-      @instance
-    else
-      @instance = Xen::Instance.find(@name)
+    # XXX We're assuming other processes aren't going to edit config_files
+    # This is reasonable in simple cases.
+    def config_file
+      @config_file ||= Xen::ConfigFile.find(name) if @name
     end
-  end
   
-  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)
+    def backups
+      Xen::Backup.find(name)
     end
-  end
   
-  def all(options={})
-    self.find(:all, options)
-  end
+    def create_backup(options = {})
+      Xen::Backup.create(name, :options)
+    end
 
-  def state
-    self.instance ? :running : :stopped
-  end
+    def state
+      self.instance ? :running : :stopped
+    end
     
-  def running?
-    self.instance ? true : false
-  end
+    def running?
+      self.instance ? true : false
+    end
   
-  def start
-    Xen::Instance.create(@name)
-    @instance = Xen::Instance.find(@name)
-  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 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 config_file_newer_than_instance?
+  	  instance && config_file.updated_at > instance.start_time 
+  	end
+	
+  	def save
+  	  @config_file.save
+    end
+    
+    def root_disk
+      config_file.vbds.detect { |vbd| vbd.name == "#{name}-disk" } unless config_file.nil?
+    end
+    
+    # Primary IP
+    def ip
+      config_file.vifs[0].ip
+    end
   
-end
+  end
+end
+
+
+

data/lib/xen/xen_tools_conf.rb

@@ -0,0 +1,56 @@
+module Xen
+  # puts Xen::XenToolsConf.load.to_hash.inspect
+
+  class XenToolsConf
+
+    # XXX underscorize :install-method, install-source, copy_cmd, tar-cmd
+    attr_accessor :dir, :lvm, :install__method, :install__source, :copy_cmd,  
+                  :tar_cmd, :debootstrap__cmd, :size, :memory, :swap, :noswap,
+                  :fs,    
+                  :dist, :image, :gateway,       
+                  :netmask, :broadcast, :dhcp, :cache, :passwd, :accounts, 
+                  :kernel, :initrd, :mirror, :ext3_options, :ext2_options, 
+                  :xfs_options, :reiser_options, :boot, :serial_device, 
+                  :disk_device, :output, :extension
+
+    def initialize(*args)
+    end
+
+    def self.find(file=nil)
+      file ||= Xen::XEN_TOOLS_CONFIG_FILE
+      xtc = new # Create a new XenToolsConf object
+      xtc.load_from_config_file(File.readlines(file))
+      xtc
+    end
+
+    def load_from_config_file(file_contents)
+      file_contents.reject! { |line| line.match /^\s*#/ } # Ignore commented out lines
+      file_contents.grep(/(.*) = (.*)/).each { |setting|
+        setting.scan(/\s*(.+?)\s*=\s*([^#]+)/).each { |match|
+          key, val = match    
+          instance_variable_set("@#{key.strip.underscorize}", val.strip) 
+        }
+      }
+    end
+
+    def to_hash
+      self.instance_variables.inject({}) { |m, variable_name| 
+        m[variable_name.sub('@','').ununderscorize] = instance_variable_get(variable_name); m 
+      }
+    end
+
+    def to_file
+      template = ERB.new(IO.read(File.join(TEMPLATES_BASE, 'xen-tools.conf.erb')))
+      template.result(binding)
+    end
+
+    def save(filename=nil)
+      filename ||= Xen::XEN_TOOLS_CONFIG_FILE
+      File.open(filename, 'w') do |f|
+        f.write(to_file)
+      end
+      # XXX check for errors
+    end
+
+  end
+end

data/test/test_ruby-xen.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: mbailey-ruby-xen
 version: !ruby/object:Gem::Version 
-  version: 0.0.2
+  version: 0.0.3
 platform: ruby
 authors: 
 - Mike Bailey
@@ -10,10 +10,27 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2008-09-11 00:00:00 -07:00
+date: 2008-09-21 00:00:00 -07:00
 default_executable: 
-dependencies: []
-
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: activesupport
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: open4
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
 description: ruby-xen allows you to manage Xen virtual servers via Ruby. It currently  wraps the command line tools provided by Xen (xm) as well as Steve Kemps  excellent Xen-tools (http://www.xen-tools.org/software/xen-tools/).
 email: mike@bailey.net.au
 executables: []
@@ -34,14 +51,16 @@ files:
 - test/test_ruby-xen.rb
 - lib/xen/backup.rb
 - lib/xen/command.rb
-- lib/xen/config.rb
-- lib/xen/slice.rb
+- lib/xen/config_file.rb
 - lib/xen/host.rb
-- lib/xen/image.rb
 - lib/xen/instance.rb
+- lib/xen/lvm.rb
+- lib/xen/slice.rb
+- lib/xen/xen_tools_conf.rb
 - lib/templates/domu.cfg.erb
+- lib/templates/xen-tools.conf.erb
 has_rdoc: true
-homepage: http://github.com/schacon/grit
+homepage: http://github.com/mbailey/ruby-xen
 post_install_message: 
 rdoc_options: 
 - --main

data/lib/xen/config.rb

@@ -1,139 +0,0 @@
-require 'erb'
-
-# The Xen config files on disk
-class Xen::Config
-  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))
-  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 Network Interface
-#
-# 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 :dom0, :domu, :mode
-  def initialize(dom0, domu, mode='w')
-    @dom0, @domu, @mode = dom0, domu, mode
-  end
-
-  def self.from_str(value)
-    dom0, domu, mode = value.split(',')
-    new(dom0, domu, mode)
-  end
-
-  def to_str
-    "#{dom0},#{domu},#{mode}"
-  end 
-end
-
-