openvz 1.1

data/lib/openvz/inventory.rb

@@ -0,0 +1,20 @@
+module OpenVZ
+    class Inventory < ConfigHash
+        def load
+            s = Shell.new("/usr/sbin/vzlist -a", :cwd => "/tmp")
+            s.runcommand
+
+            ret_code = s.status
+            if ret_code != 0
+                raise StandardError, "Execution of shell command failed. Command: #{s.command} RC: #{ret_code} Error: #{s.stderr}\n\n"
+            end
+
+            s.stdout.each { |l|
+                # inventarize a container object for each avaiable container.
+                if l =~ /^\s+(\d+)\s+(.*)\s+(running|stopped)\s+(.*)\s\s(.*)$/
+                    self[$1] = Container.new($1)
+                end
+            }
+        end
+    end
+end

data/lib/openvz/log.rb

@@ -0,0 +1,67 @@
+module OpenVZ
+    # A simple class that allows logging at various levels.
+    class Log
+        class << self
+            @logger = nil
+
+            # Obtain the class name of the currently configured logger
+            def logger
+                @logger.class
+            end
+
+            # Logs at info level
+            def info(msg)
+                log(:info, msg)
+            end
+
+            # Logs at warn level
+            def warn(msg)
+                log(:warn, msg)
+            end
+
+            # Logs at debug level
+            def debug(msg)
+                log(:debug, msg)
+            end
+
+            # Logs at fatal level
+            def fatal(msg)
+                log(:fatal, msg)
+            end
+
+            # Logs at error level
+            def error(msg)
+                log(:error, msg)
+            end
+
+            # handle old code that relied on this class being a singleton
+            def instance
+                self
+            end
+
+            # increments the active log level
+            def cycle_level
+                @logger.cycle_level if @configured
+            end
+
+            # logs a message at a certain level
+            def log(level, msg)
+                t = Time.new.strftime("%H:%M:%S")
+                STDERR.puts "#{t}: #{level}: #{from}: #{msg}"
+            end
+
+            # sets the logger class to use
+            def set_logger(logger)
+                @logger = logger
+            end
+
+
+            # figures out the filename that called us
+            def from
+                from = File.basename(caller[2])
+            end
+        end
+    end
+end
+
+# vi:tabstop=4:expandtab:ai:filetype=ruby

data/lib/openvz/shell.rb

@@ -0,0 +1,90 @@
+module OpenVZ
+    #
+    # This code is completely borrowed from marionette-collective.
+    #
+    # Wrapper around systemu that handles executing of system commands
+    # in a way that makes stdout, stderr and status available.  Supports
+    # timeouts and sets a default sane environment.
+    #
+    #   s = Shell.new("date", opts)
+    #   s.runcommand
+    #   puts s.stdout
+    #   puts s.stderr
+    #   puts s.status.exitcode
+    #
+    # Options hash can have:
+    #
+    #   cwd         - the working directory the command will be run from
+    #   stdin       - a string that will be sent to stdin of the program
+    #   stdout      - a variable that will receive stdout, must support <<
+    #   stderr      - a variable that will receive stdin, must support <<
+    #   environment - the shell environment, defaults to include LC_ALL=C
+    #                 set to nil to clear the environment even of LC_ALL
+    #
+    class Shell
+        attr_reader :environment, :command, :status, :stdout, :stderr, :stdin, :cwd
+
+        def initialize(command, options={})
+            @environment = {"LC_ALL" => "C"}
+            @command = command
+            @status = nil
+            @stdout = ""
+            @stderr = ""
+            @stdin = nil
+            @cwd = "/tmp"
+
+            options.each do |opt, val|
+                case opt.to_s
+                    when "stdout"
+                        raise "stdout should support <<" unless val.respond_to?("<<")
+                        @stdout = val
+
+                    when "stderr"
+                        raise "stderr should support <<" unless val.respond_to?("<<")
+                        @stderr = val
+
+                    when "stdin"
+                        raise "stdin should be a String" unless val.is_a?(String)
+                        @stdin = val
+
+                    when "cwd"
+                        raise "Directory #{val} does not exist" unless File.directory?(val)
+                        @cwd = val
+
+                    when "environment"
+                        if val.nil?
+                            @environment = {}
+                        else
+                            @environment.merge!(val.dup)
+                        end
+                end
+            end
+        end
+
+        # Actually does the systemu call passing in the correct environment, stdout and stderr
+        def runcommand
+            opts = {"env"    => @environment,
+                    "stdout" => @stdout,
+                    "stderr" => @stderr,
+                    "cwd"    => @cwd}
+
+            opts["stdin"] = @stdin if @stdin
+
+            # Running waitpid on the cid here will start a thread
+            # with the waitpid in it, this way even if the thread
+            # that started this process gets killed due to agent
+            # timeout or such there will still be a waitpid waiting
+            # for the child to exit and not leave zombies.
+            @status = systemu(@command, opts) do |cid|
+                begin
+                    sleep 1
+                    Process::waitpid(cid)
+                rescue SystemExit
+                rescue Errno::ECHILD
+                rescue Exception => e
+                    Log.info("Unexpected exception received while waiting for child process: #{e.class}: #{e}")
+                end
+            end
+        end
+    end
+end

data/lib/openvz/util.rb

@@ -0,0 +1,39 @@
+module OpenVZ
+    class Util
+        # Generate a mac address based upon three different variables
+        def generate_mac(ctid, vlanid, for_host)
+            ctid_str     = '%06i' % ctid
+            vlanid_str   = '%04i' % vlanid
+
+            bridgemac    = [0,0,0,0,0,0]
+            bridgemac[1] = ctid_str[0..1]
+            bridgemac[2] = ctid_str[2..3]
+            bridgemac[3] = ctid_str[4..5]
+            bridgemac[4] = vlanid_str[0..1]
+            bridgemac[5] = vlanid_str[2..3]
+        
+            if for_host
+                bridgemac[0] = '12'
+            else
+                bridgemac[0] = '02'
+            end
+        
+            # assemble macstring   
+            '%s:%s:%s:%s:%s:%s' % bridgemac[0,6]
+        end    
+
+        # Search for a specific pattern and replace it with string
+        # in file.
+        def searchandreplace(file, pattern, replace)
+            if File.writeable?(file)
+                File.open(file, 'w') do |f|
+                    $<.each_line do |line|
+                        f.puts line.gsub(Regexp.new(pattern), replace)
+                    end
+                end
+            else
+                raise "File not writeable: #{file}."
+            end
+        end
+    end
+end

data/lib/openvz/vendor.rb

@@ -0,0 +1,41 @@
+module OpenVZ
+    # Simple module to manage vendored code.
+    #
+    # To vendor a library simply download its whole git repo or untar
+    # into vendor/libraryname and create a load_libraryname.rb file
+    # to add its libdir into the $:.
+    #
+    # Once you have that file, add a require line in vendor/require_vendored.rb
+    # which will run after all the load_* files.
+    #
+    # The intention is to not change vendored libraries and to eventually
+    # make adding them in optional so that distros can simply adjust their
+    # packaging to exclude this directory and the various load_xxx.rb scripts
+    # if they wish to install these gems as native packages.
+    class Vendor
+        class << self
+            def vendor_dir
+                File.join([File.dirname(File.expand_path(__FILE__)), "vendor"])
+            end
+    
+            def load_entry(entry)
+                Log.debug("Loading vendored #{$1}")
+                load "#{vendor_dir}/#{entry}"
+            end
+    
+            def require_libs
+                require 'openvz/vendor/require_vendored'
+            end
+    
+            def load_vendored
+                Dir.entries(vendor_dir).each do |entry|
+                    if entry.match(/load_(\w+?)\.rb$/)
+                        load_entry entry
+                    end
+                end
+    
+                require_libs
+            end
+        end
+    end
+end

data/lib/openvz/vendor/load_systemu.rb

@@ -0,0 +1 @@
+$: << File.join([File.dirname(__FILE__), "systemu/lib"])

data/lib/openvz/vendor/require_vendored.rb

@@ -0,0 +1 @@
+require 'systemu'

data/lib/openvz/vendor/systemu/README

@@ -0,0 +1,160 @@
+NAME
+
+  systemu
+
+SYNOPSIS
+
+  univeral capture of stdout and stderr and handling of child process pid for windows, *nix, etc.
+
+URIS
+
+  http://rubyforge.org/projects/codeforpeople/
+  http://codeforpeople.com/lib/ruby/
+  http://codeforpeople.rubyforge.org/svn/
+
+INSTALL
+
+  gem install systemu
+
+HISTORY
+
+  1.2.0
+
+    - fixed handling of background thread management - needed
+      Thread.current.abort_on_exception = true
+
+    - fixed reporting of child pid, it was reported as the parent's pid before
+
+SAMPLES
+
+  <========< samples/a.rb >========>
+
+  ~ > cat samples/a.rb
+
+    #
+    # systemu can be used on any platform to return status, stdout, and stderr of
+    # any command.  unlike other methods like open3/popen4 there is zero danger of
+    # full pipes or threading issues hanging your process or subprocess.
+    #
+      require 'systemu'
+    
+      date = %q( ruby -e"  t = Time.now; STDOUT.puts t; STDERR.puts t  " )
+    
+      status, stdout, stderr = systemu date
+      p [ status, stdout, stderr ]
+
+  ~ > ruby samples/a.rb
+
+    [#<Process::Status: pid=987,exited(0)>, "Thu Dec 06 16:01:59 -0700 2007\n", "Thu Dec 06 16:01:59 -0700 2007\n"]
+
+
+  <========< samples/b.rb >========>
+
+  ~ > cat samples/b.rb
+
+    #
+    # quite a few keys can be passed to the command to alter it's behaviour.  if
+    # either stdout or stderr is supplied those objects should respond_to? '<<'
+    # and only status will be returned
+    #
+      require 'systemu'
+    
+      date = %q( ruby -e"  t = Time.now; STDOUT.puts t; STDERR.puts t  " )
+    
+      stdout, stderr = '', ''
+      status = systemu date, 'stdout' => stdout, 'stderr' => stderr
+      p [ status, stdout, stderr ]
+
+  ~ > ruby samples/b.rb
+
+    [#<Process::Status: pid=992,exited(0)>, "Thu Dec 06 16:01:59 -0700 2007\n", "Thu Dec 06 16:01:59 -0700 2007\n"]
+
+
+  <========< samples/c.rb >========>
+
+  ~ > cat samples/c.rb
+
+    #
+    # of course stdin can be supplied too.  synonyms for 'stdin' include '0' and
+    # 0.  the other stdio streams have similar shortcuts
+    #
+      require 'systemu'
+    
+      cat = %q( ruby -e"  ARGF.each{|line| puts line}  " )
+    
+      status = systemu cat, 0=>'the stdin for cat', 1=>stdout=''
+      puts stdout
+
+  ~ > ruby samples/c.rb
+
+    the stdin for cat
+
+
+  <========< samples/d.rb >========>
+
+  ~ > cat samples/d.rb
+
+    #
+    # the cwd can be supplied
+    #
+      require 'systemu'
+      require 'tmpdir'
+    
+      pwd = %q( ruby -e"  STDERR.puts Dir.pwd  " )
+    
+      status = systemu pwd, 2=>(stderr=''), :cwd=>Dir.tmpdir
+      puts stderr
+    
+
+  ~ > ruby samples/d.rb
+
+    /private/tmp
+
+
+  <========< samples/e.rb >========>
+
+  ~ > cat samples/e.rb
+
+    #
+    # any environment vars specified are merged into the child's environment
+    #
+      require 'systemu'
+    
+      env = %q( ruby -r yaml -e"  puts ENV[ 'answer' ] " )
+    
+      status = systemu env, 1=>stdout='', 'env'=>{ 'answer' => 0b101010 }
+      puts stdout
+
+  ~ > ruby samples/e.rb
+
+    42
+
+
+  <========< samples/f.rb >========>
+
+  ~ > cat samples/f.rb
+
+    #
+    # if a block is specified then it is passed the child pid and run in a
+    # background thread.  note that this thread will __not__ be blocked during the
+    # execution of the command so it may do useful work such as killing the child
+    # if execution time passes a certain threshold
+    #
+      require 'systemu'
+    
+      looper = %q( ruby -e" loop{ STDERR.puts Time.now.to_i; sleep 1 } " )
+    
+      status, stdout, stderr =
+        systemu looper do |cid|
+          sleep 3
+          Process.kill 9, cid
+        end
+    
+      p status
+      p stderr
+
+  ~ > ruby samples/f.rb
+
+    #<Process::Status: pid=1012,signaled(SIGKILL=9)>
+    "1196982119\n1196982120\n1196982121\n"
+

data/lib/openvz/vendor/systemu/README.tmpl

@@ -0,0 +1,30 @@
+NAME
+
+  systemu
+
+SYNOPSIS
+
+  univeral capture of stdout and stderr and handling of child process pid for windows, *nix, etc.
+
+URIS
+
+  http://rubyforge.org/projects/codeforpeople/
+  http://codeforpeople.com/lib/ruby/
+  http://codeforpeople.rubyforge.org/svn/
+
+INSTALL
+
+  gem install systemu
+
+HISTORY
+
+  1.2.0
+
+    - fixed handling of background thread management - needed
+      Thread.current.abort_on_exception = true
+
+    - fixed reporting of child pid, it was reported as the parent's pid before
+
+SAMPLES
+
+  @samples