vagabond 0.2.0 → 0.2.2

data/lib/vagabond/cookbooks/lxc/libraries/lxc.rb

@@ -1,12 +1,95 @@
+require 'mixlib/shellout'
+require 'pathname'
+require 'tmpdir'
+
 class Lxc
   class CommandFailed < StandardError
   end
+
+  module Helpers
+    
+    # Simple helper to shell out
+    def run_command(cmd, args={})
+      retries = args[:allow_failure_retry].to_i
+      begin
+        shlout = Mixlib::ShellOut.new(cmd, 
+          :logger => defined?(Chef::Log) ? Chef::Log.logger : log,
+          :live_stream => args[:livestream] ? STDOUT : nil,
+          :timeout => args[:timeout] || 1200,
+          :environment => {'HOME' => detect_home}
+        )
+        shlout.run_command
+        shlout.error!
+        shlout
+      rescue Mixlib::ShellOut::ShellCommandFailed, CommandFailed, Mixlib::ShellOut::CommandTimeout
+        if(retries > 0)
+          log.warn "LXC run command failed: #{cmd}"
+          log.warn "Retrying command. #{args[:allow_failure_retry].to_i - retries} of #{args[:allow_failure_retry].to_i} retries remain"
+          sleep(0.3)
+          retries -= 1
+          retry
+        elsif(args[:allow_failure])
+          true
+        else
+          raise
+        end
+      end
+    end
+
+    def command(*args)
+      run_command(*args)
+    end
+    
+    def log
+      if(defined?(Chef::Log))
+        Chef::Log
+      else
+        unless(@logger)
+          require 'logger'
+          @logger = Logger.new('/dev/null')
+        end
+        @logger
+      end
+    end
+    
+    # Detect HOME environment variable. If not an acceptable
+    # value, set to /root or /tmp
+    def detect_home(set_if_missing=false)
+      if(ENV['HOME'] && Pathname.new(ENV['HOME']).absolute?)
+        ENV['HOME']
+      else
+        home = File.directory?('/root') && File.writable?('/root') ? '/root' : '/tmp'
+        if(set_if_missing)
+          ENV['HOME'] = home
+        end
+        home
+      end
+    end
+  end
+
+  # Pathname#join does not act like File#join when joining paths that
+  # begin with '/', and that's dumb. So we'll make our own Pathname,
+  # with a #join that uses File
+  class Pathname < ::Pathname
+    def join(*args)
+      self.class.new(::File.join(self.to_path, *args))
+    end
+  end
   
-  attr_reader :name
+  include Helpers
+
+  attr_reader :name, :base_path, :lease_file, :preferred_device
 
   class << self
 
+    include Helpers
+    
     attr_accessor :use_sudo
+    attr_accessor :base_path
+
+    def base_path
+      @base_path || '/var/lib/lxc'
+    end
 
     def sudo
       case use_sudo
@@ -40,19 +123,28 @@ class Lxc
 
     # List of containers
     def list
-      %x{#{sudo}lxc-ls}.split("\n").uniq
+      Dir.glob(File.join(base_path, '*')).map do |item|
+        if(File.directory?(item) && File.exists?(File.join(item, 'config')))
+          File.basename(item)
+        end
+      end.compact
     end
-
+    
     # name:: Name of container
     # Returns information about given container
     def info(name)
       res = {:state => nil, :pid => nil}
-      info = %x{#{sudo}lxc-info -n #{name}}.split("\n")
-      parts = info.first.split(' ')
-      res[:state] = parts.last.downcase.to_sym
-      parts = info.last.split(' ')
-      res[:pid] = parts.last.to_i
-      res
+      info = run_command("#{sudo}lxc-info -n #{name}").stdout.split("\n")
+      if(info.first)
+        parts = info.first.split(' ')
+        res[:state] = parts.last.downcase.to_sym
+        parts = info.last.split(' ')
+        res[:pid] = parts.last.to_i
+        res
+      else
+        res[:state] = :unknown
+        res[:pid] = -1
+      end
     end
 
     # Return full container information list
@@ -78,10 +170,12 @@ class Lxc
   # args:: Argument hash
   #   - :base_path -> path to container directory
   #   - :dnsmasq_lease_file -> path to lease file
+  #   - :net_device -> network device to use within container for ssh connection
   def initialize(name, args={})
     @name = name
-    @base_path = args[:base_path] || '/var/lib/lxc'
+    @base_path = args[:base_path] || self.class.base_path
     @lease_file = args[:dnsmasq_lease_file] || '/var/lib/misc/dnsmasq.leases'
+    @preferred_device = args[:net_device]
   end
 
   # Returns if container exists
@@ -109,8 +203,20 @@ class Lxc
   def container_ip(retries=0, raise_on_fail=false)
     (retries.to_i + 1).times do
       ip = proc_detected_address || hw_detected_address || leased_address || lxc_stored_address
+      if(ip.is_a?(Array))
+        # Filter any found loopbacks
+        ip.delete_if{|info| info[:device].start_with?('lo') }
+        ip = ip.detect do |info|
+          if(@preferred_device)
+            info[:device] == @preferred_device
+          else
+            true
+          end
+        end
+        ip = ip[:address] if ip
+      end
       return ip if ip && self.class.connection_alive?(ip)
-      Chef::Log.warn "LXC IP discovery: Failed to detect live IP"
+      log.warn "LXC IP discovery: Failed to detect live IP"
       sleep(3) if retries > 0
     end
     raise "Failed to detect live IP address for container: #{name}" if raise_on_fail
@@ -125,7 +231,7 @@ class Lxc
       if(ip.to_s.empty?)
         nil
       else
-        Chef::Log.info "LXC Discovery: Found container address via storage: #{ip}"
+        log.info "LXC Discovery: Found container address via storage: #{ip}"
         ip
       end
     end
@@ -145,25 +251,27 @@ class Lxc
     if(ip.to_s.empty?)
       nil
     else
-      Chef::Log.info "LXC Discovery: Found container address via DHCP lease: #{ip}"
+      log.info "LXC Discovery: Found container address via DHCP lease: #{ip}"
       ip
     end
   end
 
   def hw_detected_address
-    hw = File.readlines(container_config).detect{|line|
-      line.include?('hwaddr')
-    }.to_s.split('=').last.to_s.downcase
-    if(File.exists?(container_config) && !hw.empty?)
-      running? # need to do a list!
-      ip = File.readlines('/proc/net/arp').detect{|line|
-        line.downcase.include?(hw)
-      }.to_s.split(' ').first.to_s.strip
-      if(ip.to_s.empty?)
-        nil
-      else
-        Chef::Log.info "LXC Discovery: Found container address via HW addr: #{ip}"
-        ip
+    if(container_config.readable?)
+      hw = File.readlines(container_config).detect{|line|
+        line.include?('hwaddr')
+      }.to_s.split('=').last.to_s.downcase
+      if(File.exists?(container_config) && !hw.empty?)
+        running? # need to do a list!
+        ip = File.readlines('/proc/net/arp').detect{|line|
+          line.downcase.include?(hw)
+        }.to_s.split(' ').first.to_s.strip
+        if(ip.to_s.empty?)
+          nil
+        else
+          log.info "LXC Discovery: Found container address via HW addr: #{ip}"
+          ip
+        end
       end
     end
   end
@@ -177,8 +285,11 @@ class Lxc
         system("#{sudo}ln -s /proc/#{pid}/ns/net #{path}")
         res = %x{#{sudo}ip netns exec #{name} ip -4 addr show scope global | grep inet}
         system("#{sudo}rm -f #{path}")
-        ip = res.strip.split(' ')[1].to_s.sub(%r{/.*$}, '').strip
-        ip.empty? ? nil : ip
+        ips = res.split("\n").map do |line|
+          parts = line.split(' ')
+          {:address => parts[1].to_s.sub(%r{/.+$}, ''), :device => parts.last}
+        end
+        ips.empty? ? nil : ips
       end
     end
   end
@@ -189,23 +300,23 @@ class Lxc
     
   # Full path to container
   def container_path
-    File.join(@base_path, name)
+    Pathname.new(@base_path).join(name)
   end
   alias_method :path, :container_path
 
   # Full path to container configuration file
   def container_config
-    File.join(container_path, 'config')
+    container_path.join('config')
   end
   alias_method :config, :container_config
 
   def container_rootfs
-    File.join(container_path, 'rootfs')
+    container_path.join('rootfs')
   end
   alias_method :rootfs, :container_rootfs
 
   def expand_path(path)
-    File.join(container_rootfs, path)
+    container_rootfs.join(path)
   end
 
   def state
@@ -217,68 +328,82 @@ class Lxc
   end
 
   # Start the container
-  def start
-    run_command("#{sudo}lxc-start -n #{name} -d")
-    run_command("#{sudo}lxc-wait -n #{name} -s RUNNING", :allow_failure_retry => 2)
+  def start(*args)
+    if(args.include?(:no_daemon))
+      run_command("#{sudo}lxc-start -n #{name}")
+    else
+      run_command("#{sudo}lxc-start -n #{name} -d")
+      wait_for_state(:running)
+    end
   end
 
   # Stop the container
   def stop
     run_command("#{sudo}lxc-stop -n #{name}", :allow_failure_retry => 3)
-    run_command("#{sudo}lxc-wait -n #{name} -s STOPPED", :allow_failure_retry => 2)
+    wait_for_state(:stopped)
   end
   
   # Freeze the container
   def freeze
     run_command("#{sudo}lxc-freeze -n #{name}")
-    run_command("#{sudo}lxc-wait -n #{name} -s FROZEN", :allow_failure_retry => 2)
+    wait_for_state(:frozen)
   end
 
   # Unfreeze the container
   def unfreeze
     run_command("#{sudo}lxc-unfreeze -n #{name}")
-    run_command("#{sudo}lxc-wait -n #{name} -s RUNNING", :allow_failure_retry => 2)
+    wait_for_state(:running)
   end
 
   # Shutdown the container
   def shutdown
     run_command("#{sudo}lxc-shutdown -n #{name}")
-    run_command("#{sudo}lxc-wait -n #{name} -s STOPPED", :allow_failure => true, :timeout => 10)
+    wait_for_state(:stopped, :timeout => 120)
+    # This block is for fedora/centos/anyone else that does not like lxc-shutdown
     if(running?)
       container_command('shutdown -h now')
-      run_command("#{sudo}lxc-wait -n #{name} -s STOPPED")
+      wait_for_state(:stopped, :timeout => 120)
+      # If still running here, something is wrong
+      if(running?)
+        raise "Failed to shutdown container: #{name}"
+      end
     end
   end
 
-  def knife_container(cmd, ip)
-    require 'chef/knife/ssh'
-    Chef::Knife::Ssh.load_deps
-    k = Chef::Knife::Ssh.new([
-      ip, '-m', '-i', '/opt/hw-lxc-config/id_rsa', '--no-host-key-verify', cmd
-    ])
-    e = nil
+  def direct_container_command(command, args={})
+    com = "#{sudo}ssh root@#{args[:ip] || container_ip} -i /opt/hw-lxc-config/id_rsa -oStrictHostKeyChecking=no '#{command}'"
     begin
-      e = k.run
-    rescue SystemExit => e
+      cmd = Mixlib::ShellOut.new(com,
+        :live_stream => args[:live_stream],
+        :timeout => args[:timeout] || 1200
+      )
+      cmd.run_command
+      cmd.error!
+      true
+    rescue
+      raise if args[:raise_on_failure]
+      false
     end
-    raise CommandFailed.new(cmd) if e.nil? || e != 0
   end
+  alias_method :knife_container, :direct_container_command
 
   # Simple helper to shell out
   def run_command(cmd, args={})
     retries = args[:allow_failure_retry].to_i
     begin
       shlout = Mixlib::ShellOut.new(cmd, 
-        :logger => Chef::Log.logger, 
-        :live_stream => STDOUT,
-        :timeout => args[:timeout] || 1200
+        :logger => defined?(Chef::Log) ? Chef::Log.logger : log,
+        :live_stream => args[:livestream] ? nil : STDOUT,
+        :timeout => args[:timeout] || 1200,
+        :environment => {'HOME' => detect_home}
       )
       shlout.run_command
       shlout.error!
+      shlout
     rescue Mixlib::ShellOut::ShellCommandFailed, CommandFailed, Mixlib::ShellOut::CommandTimeout
       if(retries > 0)
-        Chef::Log.warn "LXC run command failed: #{cmd}"
-        Chef::Log.warn "Retrying command. #{args[:allow_failure_retry].to_i - retries} of #{args[:allow_failure_retry].to_i} retries remain"
+        log.warn "LXC run command failed: #{cmd}"
+        log.warn "Retrying command. #{args[:allow_failure_retry].to_i - retries} of #{args[:allow_failure_retry].to_i} retries remain"
         sleep(0.3)
         retries -= 1
         retry
@@ -290,16 +415,44 @@ class Lxc
     end
   end
 
+  def wait_for_state(desired_state, args={})
+    args[:sleep_interval] ||= 1.0
+    wait_total = 0.0
+    until(state == desired_state.to_sym || (args[:timeout].to_i > 0 && wait_total.to_i > args[:timeout].to_i))
+      sleep(args[:sleep_interval])
+      wait_total += args[:sleep_interval]
+    end
+  end
+
+  # Detect HOME environment variable. If not an acceptable
+  # value, set to /root or /tmp
+  def detect_home(set_if_missing=false)
+    if(ENV['HOME'] && Pathname.new(ENV['HOME']).absolute?)
+      ENV['HOME']
+    else
+      home = File.directory?('/root') && File.writable?('/root') ? '/root' : '/tmp'
+      if(set_if_missing)
+        ENV['HOME'] = home
+      end
+      home
+    end
+  end
+  
   # cmd:: Shell command string
   # retries:: Number of retry attempts (1 second sleep interval)
   # Runs command in container via ssh
   def container_command(cmd, retries=1)
     begin
-      knife_container(cmd, container_ip(5))
+      detect_home(true)
+      direct_container_command(cmd,
+        :ip => container_ip(5),
+        :live_stream => STDOUT,
+        :raise_on_failure => true
+      )
     rescue => e
       if(retries.to_i > 0)
-        Chef::Log.info "Encountered error running container command (#{cmd}): #{e}"
-        Chef::Log.info "Retrying command..."
+        log.info "Encountered error running container command (#{cmd}): #{e}"
+        log.info "Retrying command..."
         retries = retries.to_i - 1
         sleep(1)
         retry
@@ -309,4 +462,16 @@ class Lxc
     end
   end
 
+  def log
+    if(defined?(Chef::Log))
+      Chef::Log
+    else
+      unless(@logger)
+        require 'logger'
+        @logger = Logger.new('/dev/null')
+      end
+      @logger
+    end
+  end
+
 end

data/lib/vagabond/cookbooks/lxc/libraries/lxc_file_config.rb

@@ -7,6 +7,9 @@ class LxcFileConfig
     def generate_config(resource)
       config = []
       config << "lxc.utsname = #{resource.utsname}"
+      if(resource.aa_profile)
+        config << "lxc.aa_profile = #{resource.aa_profile}"
+      end
       [resource.network].flatten.each do |net_hash|
         nhsh = Mash.new(net_hash)
         flags = nhsh.delete(:flags)

data/lib/vagabond/cookbooks/lxc/libraries/monkey.rb

@@ -0,0 +1,51 @@
+unless(defined?(LxcMonkey))
+  require 'chef/resource/execute'
+  require 'chef/provider/execute'
+
+  module LxcMonkey
+    module Provider
+      class << self
+        def included(klass)
+          klass.class_eval do
+            alias_method :non_monkey_shell_out!, :shell_out!
+            alias_method :shell_out!, :monkey_shell_out!
+          end
+        end
+      end
+      
+      def monkey_shell_out!(com, opts)
+        if(str = @new_resource.stream_output)
+          opts[:live_stream] = str.kind_of?(IO) ? str : STDOUT
+        end
+        non_monkey_shell_out!(com, opts)
+      end      
+    end
+    module Resource
+
+      class << self
+        def included(klass)
+          klass.class_eval do
+            alias_method :non_monkey_initialize, :initialize
+            alias_method :initialize, :monkey_initialize
+          end
+        end
+      end
+      
+      def monkey_initialize(*args)
+        non_monkey_initialize(*args)
+        @stream_output = nil
+      end
+
+      def stream_output(arg=nil)
+        set_or_return(
+          :stream_output,
+          arg,
+          :kind_of => [TrueClass,FalseClass,IO]
+        )
+      end
+    end
+  end
+
+  Chef::Resource::Execute.send(:include, LxcMonkey::Resource)
+  Chef::Provider::Execute.send(:include, LxcMonkey::Provider)
+end