vagabond 0.2.8 → 0.2.10

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

@@ -1,40 +0,0 @@
-module ChefLxc
-  module Resource
-
-    def container(arg=nil)
-      set_or_return(:container, arg, :kind_of => [String], :required => true)
-    end
-
-    def lxc
-      @lxc ||= Lxc.new(
-        @container,
-        :base_dir => node[:lxc][:container_directory]
-      )
-    end
-
-    def path(arg=nil)
-      arg ? super(arg) : lxc.expand_path(super(arg))
-    end
-
-    def self.included(base)
-      base.class_eval do
-        def initialize(*args)
-          super
-          @container = nil
-        end
-      end
-    end
-  end
-end
-
-class Chef
-  class Resource
-    class LxcTemplate < Template
-      include ChefLxc::Resource
-    end
-
-    class LxcFile < File
-      include ChefLxc::Resource
-    end
-  end
-end

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

@@ -1,84 +0,0 @@
-class LxcFileConfig
-
-  attr_reader :network
-  attr_reader :base
-
-  class << self
-    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)
-        %w(type link).each do |k|
-          config << "lxc.network.#{k} = #{nhsh.delete(k)}" if nhsh[k]
-        end
-        nhsh.each_pair do |k,v|
-          config << "lxc.network.#{k} = #{v}"
-        end
-        if(flags)
-          config << "lxc.network.flags = #{flags}"
-        end
-      end
-      if(resource.cap_drop)
-        config << "lxc.cap.drop = #{Array(resource.cap_drop).join(' ')}"
-      end
-      %w(pts tty arch devttydir mount mount_entry rootfs rootfs_mount pivotdir).each do |k|
-        config << "lxc.#{k.sub('_', '.')} = #{resource.send(k)}" if resource.send(k)
-      end
-      prefix = 'lxc.cgroup'
-      resource.cgroup.each_pair do |key, value|
-        if(value.is_a?(Array))
-          value.each do |val|
-            config << "#{prefix}.#{key} = #{val}"
-          end
-        else
-          config << "#{prefix}.#{key} = #{value}"
-        end
-      end
-      config.join("\n") + "\n"
-    end
-
-  end
-
-  def initialize(path)
-    raise 'LXC config file not found' unless File.exists?(path)
-    @path = path
-    @network = []
-    @base = Mash.new
-    parse!
-  end
-
-  private
-
-  def parse!
-    cur_net = nil
-    File.readlines(@path).each do |line|
-      if(line.start_with?('lxc.network'))
-        parts = line.split('=')
-        name = parts.first.split('.').last.strip
-        if(name.to_sym == :type)
-          @network << cur_net if cur_net
-          cur_net = Mash.new
-        end
-        if(cur_net)
-          cur_net[name] = parts.last.strip
-        else
-          raise "Expecting 'lxc.network.type' to start network config block. Found: 'lxc.network.#{name}'"
-        end
-      else
-        parts = line.split('=')
-        name = parts.first.sub('lxc.', '').strip
-        if(@base[name])
-          @base[name] = [@base[name], parts.last.strip].flatten
-        else
-          @base[name] = parts.last
-        end
-      end
-    end
-    @network << cur_net if cur_net
-  end
-end

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

@@ -1,51 +0,0 @@
-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

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

@@ -1,12 +0,0 @@
-name             'lxc'
-maintainer       'Chris Roberts'
-maintainer_email 'chrisroberts.code@gmail.com'
-license          'Apache 2.0'
-description      'Chef driven Linux Containers'
-long_description IO.read(File.join(File.dirname(__FILE__), 'README.md'))
-version          '1.0.1'
-
-supports 'ubuntu'
-
-suggests 'omnibus_updater'
-suggests 'bridger'

data/lib/vagabond/cookbooks/lxc/providers/config.rb

@@ -1,75 +0,0 @@
-require 'securerandom'
-
-def load_current_resource
-  @lxc = ::Lxc.new(
-    new_resource.name,
-    :base_dir => node[:lxc][:container_directory],
-    :dnsmasq_lease_file => node[:lxc][:dnsmasq_lease_file]
-  )
-  new_resource.utsname new_resource.name unless new_resource.utsname
-  new_resource.rootfs @lxc.rootfs.to_path unless new_resource.rootfs
-  new_resource.default_bridge node[:lxc][:bridge] unless new_resource.default_bridge
-  new_resource.mount @lxc.path.join('fstab').to_path unless new_resource.mount
-  config = LxcFileConfig.new(@lxc.container_config)
-  if((new_resource.network.nil? || new_resource.network.empty?))
-    if(config.network.empty?)
-      default_net = {
-        :type => :veth,
-        :link => new_resource.default_bridge,
-        :flags => :up,
-        :hwaddr => "00:16:3e#{SecureRandom.hex(3).gsub(/(..)/, ':\1')}"
-      }
-    else
-      default_net = config.network.first
-      default_net.delete(:ipv4) if default_net.has_key?(:ipv4)
-      default_net.merge!(:link => new_resource.default_bridge)
-    end
-    new_resource.network(default_net)
-  else
-    [new_resource.network].flatten.each_with_index do |net_hash, idx|
-      if(config.network[idx].nil? || config.network[idx][:hwaddr].nil?)
-        net_hash[:hwaddr] ||= "00:16:3e#{SecureRandom.hex(3).gsub(/(..)/, ':\1')}"
-      end
-    end
-  end
-  new_resource.cgroup(
-    Chef::Mixin::DeepMerge.merge(
-      Mash.new(
-        'devices.deny' => 'a',
-        'devices.allow' => [
-          'c *:* m',
-          'b *:* m',
-          'c 1:3 rwm',
-          'c 1:5 rwm',
-          'c 5:1 rwm',
-          'c 5:0 rwm',
-          'c 1:9 rwm',
-          'c 1:8 rwm',
-          'c 136:* rwm',
-          'c 5:2 rwm',
-          'c 254:0 rwm',
-          'c 10:229 rwm',
-          'c 10:200 rwm',
-          'c 1:7 rwm',
-          'c 10:228 rwm',
-          'c 10:232 rwm'
-        ]
-      ),
-      new_resource.cgroup
-    )
-  )
-end
-
-action :create do
-  _lxc = @lxc
-  
-  directory @lxc.path.to_path do
-    action :create
-  end
-
-  file "lxc update_config[#{new_resource.utsname}]" do
-    path _lxc.container_config.to_path
-    content LxcFileConfig.generate_config(new_resource)
-    mode 0644
-  end
-end

data/lib/vagabond/cookbooks/lxc/providers/container.rb

@@ -1,354 +0,0 @@
-def load_current_resource
-  @lxc = ::Lxc.new(
-    new_resource.name,
-    :base_dir => node[:lxc][:container_directory],
-    :dnsmasq_lease_file => node[:lxc][:dnsmasq_lease_file]
-  )
-  new_resource.subresources.map! do |s_r|
-    s_r.first.run_context = run_context
-    s_r.first.instance_eval(&s_r.last)
-    s_r.first
-  end
-  
-  # TODO: Use some actual logic here, sheesh
-  if(new_resource.static_ip && new_resource.static_gateway.nil?)
-    raise "Static gateway must be defined when static IP is provided (Container: #{new_resource.name})"
-  end
-  new_resource.default_bridge node[:lxc][:bridge] unless new_resource.default_bridge
-  node.run_state[:lxc] ||= Mash.new
-  node.run_state[:lxc][:meta] ||= Mash.new
-  node.run_state[:lxc][:meta][new_resource.name] = Mash.new(
-    :new_container => !@lxc.exists?,
-    :lxc => @lxc
-  )
-end
-
-action :create do
-  _lxc = @lxc # for use inside resources
-  stopped_end_state = _lxc.stopped?
-
-  #### Add custom key for host based interactions
-  directory '/opt/hw-lxc-config' do
-    recursive true
-  end
-
-  execute 'lxc host_ssh_key' do
-    command "ssh-keygen -P '' -f /opt/hw-lxc-config/id_rsa"
-    creates '/opt/hw-lxc-config/id_rsa'
-  end
-
-  #### Create container
-  lxc new_resource.name do
-    if(new_resource.clone)
-      action :clone
-      base_container new_resource.clone
-    else
-      action :create
-      template new_resource.template
-      template_opts new_resource.template_opts
-    end
-  end
-
-  #### Create container configuration bits
-  if(new_resource.default_config)
-    lxc_config new_resource.name do
-      action :create
-      default_bridge new_resource.default_bridge
-    end
-  end
-
-  if(new_resource.default_fstab)
-    lxc_fstab "proc[#{new_resource.name}]" do
-      container new_resource.name
-      file_system 'proc'
-      mount_point 'proc'
-      type 'proc'
-      options %w(nodev noexec nosuid)
-    end
-
-    lxc_fstab "sysfs[#{new_resource.name}]" do
-      container new_resource.name
-      file_system 'sysfs'
-      mount_point 'sys'
-      type 'sysfs'
-      options 'default'
-    end
-  end
-
-  if(new_resource.static_ip)
-    lxc_interface "eth0[#{new_resource.name}]" do
-      container new_resource.name
-      device 'eth0'
-      address new_resource.static_ip
-      netmask new_resource.static_netmask
-      gateway new_resource.static_gateway
-    end
-  end
-
-  ruby_block "LXC #{new_resource.name} - Run subresources" do
-    block do
-      new_resource.subresources.each do |s_r|
-        s_r.run_action(:create)
-      end
-    end
-    not_if do
-      new_resource.subresources.empty?
-    end
-  end
-
-  template @lxc.path.join('fstab').to_path do
-    source 'fstab.erb'
-    cookbook 'lxc'
-    variables :container => new_resource.name
-    only_if do
-      node.run_state[:lxc][:fstabs] &&
-        node.run_state[:lxc][:fstabs][new_resource.name]
-    end
-    mode 0644
-  end
-
-  template @lxc.rootfs.join('etc/network/interfaces').to_path do
-    source 'interface.erb'
-    cookbook 'lxc'
-    variables :container => new_resource.name
-    mode 0644
-    only_if do
-      node.run_state[:lxc][:interfaces] &&
-        node.run_state[:lxc][:interfaces][new_resource.name]
-    end
-  end
-
-  #### Ensure host has ssh access into container
-  directory @lxc.rootfs.join('root/.ssh').to_path
-
-  template @lxc.rootfs.join('root/.ssh/authorized_keys').to_path do
-    source 'file_content.erb'
-    cookbook 'lxc'
-    mode 0600
-    variables(:path => '/opt/hw-lxc-config/id_rsa.pub')
-  end
-
-  #### Use cached chef package from host if available
-  if(%w(debian ubuntu).include?(new_resource.template) && system('ls /opt/chef*.deb 2>1 > /dev/null'))
-    if(::File.directory?('/opt'))
-      file_name = Dir.new('/opt').detect do |item| 
-        item.start_with?('chef') && item.end_with?('.deb')
-      end
-    end
-    
-    execute "lxc copy_chef_full[#{new_resource.name}]" do
-      command "cp /opt/#{file_name} #{_lxc.rootfs.join('opt')}"
-      not_if do
-        file_name.nil? || !new_resource.chef_enabled || _lxc.rootfs.join('opt', file_name).exist?
-      end
-    end
-        
-    execute "lxc install_chef_full[#{new_resource.name}]" do
-      action :nothing
-      command "chroot #{_lxc.rootfs} dpkg -i #{::File.join('/opt', file_name)}"
-      subscribes :run, "execute[lxc copy_chef_full[#{new_resource.name}]]", :immediately
-    end
-  elsif(new_resource.chef_enabled)
-    pkg_coms = ['update -y -q', 'upgrade -y -q','install curl -y -q']
-    if(!new_resource.template.to_s.scan(%r{debian|ubuntu}).empty?)
-      pkg_man = 'apt-get'
-    elsif(!new_resource.template.to_s.scan(%r{fedora|centos}).empty?)
-      pkg_man = 'yum'
-    end
-    if(pkg_man)
-      new_resource.initialize_commands(
-        pkg_coms.map do |c|
-          "#{pkg_man} #{c}"
-        end + new_resource.initialize_commands
-      )
-    end
-  end
-
-  ruby_block "lxc lock_default_users" do
-    block do
-      contents = ::File.readlines(_lxc.rootfs.join('etc/shadow').to_path)
-      ::File.open(_lxc.rootfs.join('etc/shadow').to_path, 'w') do |file|
-        contents.each do |line|
-          parts = line.split(':')
-          if(node[:lxc][:user_locks].include?(parts.first) && !parts[1].start_with?('!'))
-            parts[1] = "!#{parts[1]}"
-          end
-          file.write parts.join(':')
-        end
-      end
-    end
-    only_if do
-      ::File.readlines(_lxc.rootfs.join('etc/shadow').to_path).detect do |line|
-        parts = line.split(':')
-        node[:lxc][:user_locks].include?(parts.first) && !parts[1].start_with?('!')
-      end
-    end
-  end
-
-  ruby_block "lxc default_password_scrub" do
-    block do
-      contents = ::File.readlines(_lxc.rootfs.join('etc/shadow').to_path)
-      ::File.open(_lxc.rootfs.join('etc/shadow'), 'w') do |file|
-        contents.each do |line|
-          if(line.start_with?('root:'))
-            line.sub!(%r{root:.+?:}, 'root:*')
-          end
-          file.write line
-        end
-      end
-    end
-    not_if "grep 'root:*' #{_lxc.rootfs.join('etc/shadow').to_path}"
-  end
-
-  ruby_block "lxc start[#{new_resource.name}]" do
-    block do
-      _lxc.start
-    end
-    only_if do
-      _lxc.rootfs.join('etc/chef/first_run.json').exist? ||
-        !new_resource.container_commands.empty? ||
-        (node.run_state[:lxc][:meta][new_resource.name][:new_container] && new_resource.initialize_commands)
-    end
-  end
-    
-  #### Have initialize commands for the container? Run them now
-  ruby_block "lxc initialize_commands[#{new_resource.name}]" do
-    block do
-      new_resource.initialize_commands.each do |cmd|
-        Chef::Log.info "Running command on #{new_resource.name}: #{cmd}"
-        _lxc.container_command(cmd, 2)
-      end
-    end
-    only_if do
-      node.run_state[:lxc][:meta][new_resource.name][:new_container] &&
-        !new_resource.initialize_commands.empty?
-    end
-  end
-
-  # Make sure we have chef in the container
-  remote_file "lxc chef_install_script[#{new_resource.name}]" do
-    source "http://opscode.com/chef/install.sh"
-    path _lxc.rootfs.join('opt/chef-install.sh').to_path
-    action :create_if_missing
-    only_if do
-      new_resource.chef_enabled && !_lxc.rootfs.join('usr/bin/chef-client').exist?
-    end
-  end
-
-  ruby_block "lxc install_chef[#{new_resource.name}]" do
-    block do
-      _lxc.container_command('bash /opt/chef-install.sh')
-    end
-    action :create
-    only_if do
-      new_resource.chef_enabled &&
-        !_lxc.rootfs.join('usr/bin/chef-client').exist? &&
-        _lxc.rootfs.join('opt/chef-install.sh').exist?
-    end
-  end
-
-  #### Setup chef related bits within container
-  directory @lxc.rootfs.join('etc/chef').to_path do
-    action :create
-    mode 0755
-    only_if{ new_resource.chef_enabled }
-  end
-
-  template "lxc chef-config[#{new_resource.name}]" do
-    source 'client.rb.erb'
-    cookbook 'lxc'
-    path _lxc.rootfs.join('etc/chef/client.rb').to_path
-    variables(
-      :validation_client => new_resource.validation_client || Chef::Config[:validation_client_name],
-      :node_name => new_resource.node_name || "#{node.name}-#{new_resource.name}",
-      :server_uri => new_resource.server_uri || Chef::Config[:chef_server_url],
-      :chef_environment => new_resource.chef_environment || '_default'
-    )
-    mode 0644
-    only_if{ new_resource.chef_enabled }
-  end
-
-  file "lxc chef-validator[#{new_resource.name}]" do
-    path _lxc.rootfs.join('etc/chef/validator.pem').to_path
-    content new_resource.validator_pem || node[:lxc][:validator_pem]
-    mode 0600
-    only_if{ new_resource.chef_enabled && !_lxc.rootfs.join('etc/chef/client.pem').exist? }
-  end
-
-  file "lxc chef-runlist[#{new_resource.name}]" do
-    path _lxc.rootfs.join('etc/chef/first_run.json').to_path
-    content({:run_list => new_resource.run_list}.to_json)
-    only_if do
-      new_resource.chef_enabled && !_lxc.rootfs.join('etc/chef/client.pem').exist?
-    end
-    mode 0644
-  end
-
-  file "lxc chef-data-bag-secret[#{new_resource.name}]" do
-    path _lxc.rootfs.join('etc/chef/encrypted_data_bag_secret').to_path
-    content(
-      ::File.exists?(new_resource.data_bag_secret_file) ? ::File.open(new_resource.data_bag_secret_file, "rb").read : ''
-    )
-    mode 0600
-    only_if do
-      new_resource.chef_enabled &&
-      new_resource.copy_data_bag_secret_file &&
-        ::File.exists?(new_resource.copy_data_bag_secret_file)
-    end
-  end
-  
-  #### Let chef configure the container
-  # NOTE: We run chef-client if the validator.pem exists and the
-  # client.pem file does not exist.
-  ruby_block "lxc run_chef[#{new_resource.name}]" do
-    block do
-      cmd = 'chef-client -K /etc/chef/validator.pem -c /etc/chef/client.rb -j /etc/chef/first_run.json'
-      Chef::Log.info "Running command on #{new_resource.name}: #{cmd}"      
-      _lxc.container_command(cmd, new_resource.chef_retries)
-    end
-    only_if do
-      new_resource.chef_enabled &&
-        _lxc.rootfs.join('etc/chef/validator.pem').exist? &&
-        !_lxc.rootfs.join('etc/chef/client.pem').exist?
-    end
-  end
-
-  #### Have commands for the container? Run them now
-  ruby_block "lxc container_commands[#{new_resource.name}]" do
-    block do
-      new_resource.container_commands.each do |cmd|
-        _lxc.container_command(cmd, 2)
-      end
-    end
-    not_if do
-      new_resource.container_commands.empty?
-    end
-  end
-
-  # NOTE: If the container was not running before we started, make
-  # sure we leave it in a stopped state
-  ruby_block "lxc shutdown[#{new_resource.name}]" do
-    block do
-      _lxc.shutdown
-    end
-    only_if do
-      stopped_end_state && _lxc.running?
-    end
-  end
-  
-  #### Clean up after chef if it's enabled
-  file @lxc.rootfs.join('etc/chef/first_run.json').to_path do
-    action :delete
-  end
-
-  file @lxc.rootfs.join('etc/chef/validator.pem').to_path do
-    action :delete
-  end
-    
-end
-
-action :delete do
-  lxc new_resource.name do
-    action :delete
-  end
-end