ruby-xen 0.0.3 → 0.1.0

data/lib/xen/instance.rb

@@ -1,66 +1,68 @@
-class Xen::Instance
-  include Xen::Parentable
-  attr_reader :name, :domid, :memory, :cpu_time, :vcpus, :state, :start_time
+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]
-  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.start_instance(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_instance(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

data/lib/xen/lvm.rb

@@ -0,0 +1,40 @@
+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}"
+      begin
+        output = Xen::Command.run cmd
+        result = output.collect { |line|
+          name, size = line.strip.split(' ')
+          new name, size
+        }
+      rescue # don't die if `vgs` command missing
+      end
+      name ? result[0] : result
+    end
+  
+    def free
+      cmd = "vgs --options=vg_free --separator=' ' --noheadings --units=g --nosuffix #{@name}"
+      begin
+        result = Xen::Command.run cmd
+      rescue # don't die if `vgs` command missing
+      end
+      result
+    end
+    
+  end
+  
+end

data/lib/xen/slice.rb

@@ -1,80 +1,133 @@
-class Xen::Slice
-  attr_accessor :name, :image, :config, :backups
+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::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 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
-  end
   
-  def self.all(options={})
-    self.find(:all, options)
-  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 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 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
+    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
-  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
+    # 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
   
-  def backups
-    Xen::Backup.find(name)
-  end
+    def backups
+      Xen::Backup.find(name)
+    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 first_ip
+      config_file.vifs.first.ip if config_file and config_file.vifs
+    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.save
-  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: ruby-xen
 version: !ruby/object:Gem::Version 
-  version: 0.0.3
+  version: 0.1.0
 platform: ruby
 authors: 
 - Mike Bailey
@@ -10,10 +10,29 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2008-09-21 00:00:00 +10:00
+date: 2009-09-02 00:00:00 +10:00
 default_executable: 
-dependencies: []
-
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: activesupport
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: open4
+  type: :runtime
+  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,12 +53,15 @@ files:
 - test/test_ruby-xen.rb
 - lib/xen/backup.rb
 - lib/xen/command.rb
-- lib/xen/config.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/exclude_from_backups
+- lib/templates/xen-tools.conf.erb
 has_rdoc: true
 homepage: http://github.com/mbailey/ruby-xen
 post_install_message: 
@@ -63,7 +85,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.2.0
+rubygems_version: 1.3.1
 signing_key: 
 specification_version: 2
 summary: Ruby library for managing Xen virtual hosts