elecksee 1.0.0

data/CHANGELOG.md

@@ -0,0 +1,2 @@
+## v0.1.0
+* Initial release

data/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+
+gemspec

data/Gemfile.lock

@@ -0,0 +1,18 @@
+PATH
+  remote: .
+  specs:
+    elecksee (1.0.0)
+      mixlib-shellout
+      net-ssh
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    mixlib-shellout (1.1.0)
+    net-ssh (2.6.7)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  elecksee!

data/README.md

@@ -0,0 +1,48 @@
+# Elecksee
+
+This is a simple library for interacting with LXC. It relies on
+LXC tools being installed on the system to properly function.
+It is extracted from the Chef LXC cookbook, so poke around there
+
+## Usage
+
+```ruby
+
+require 'elecksee/lxc'
+
+lxc = Lxc.new('my-container')
+p lxc.info
+```
+
+## Awesome
+
+Awesome ephemerals lets you create ephemeral nodes with different
+overlays for the rootfs. Since tmpfs will place a size restriction
+on ephemerals based on current memory available, this provides a
+simple workaround. Currently supported is a raw temporary directory
+on the host, or a VBD that defaults to 2GB.
+
+### Using temporary directory
+
+```
+$ lxc-awesome-ephemeral -o ubuntu -d -z /tmp/lxc-roots
+```
+
+### Using VBD
+
+```
+$ lxc-awesome-ephemeral -o ubuntu -d -D 2000
+```
+
+This will create a 2GB virtual block device for the container
+to use for the overlay.
+
+Note
+----
+
+Overlays are not persistent (thus ephemeral) and will be automatically
+cleaned up when the container has reached a stop state.
+
+# Info
+
+* Repository: https://github.com/chrisroberts/elecksee.git

data/bin/lxc-awesome-ephemeral

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+
+require 'elecksee/awesome'
+
+Elecksee::Awesome.run!

data/elecksee.gemspec

@@ -0,0 +1,16 @@
+$LOAD_PATH.unshift File.expand_path(File.dirname(__FILE__)) + '/lib/'
+require 'elecksee/version'
+Gem::Specification.new do |s|
+  s.name = 'elecksee'
+  s.version = Elecksee::VERSION.version
+  s.summary = 'LXC helpers'
+  s.author = 'Chris Roberts'
+  s.email = 'chrisroberts.code@gmail.com'
+  s.homepage = 'http://github.com/chrisroberts/elecksee'
+  s.description = 'LXC helpers'
+  s.require_path = 'lib'
+  s.executables = %w(lxc-awesome-ephemeral)
+  s.add_dependency 'mixlib-shellout'
+  s.add_dependency 'net-ssh'
+  s.files = Dir['**/*']
+end

data/lib/elecksee/awesome.rb

@@ -0,0 +1,14 @@
+module Elecksee
+  class Awesome
+    class << self
+      def run!
+        path = File.expand_path(
+          File.join(
+            File.dirname(__FILE__), 'vendor/lxc/files/default/lxc-awesome-ephemeral'
+          )
+        )
+        exec("/bin/bash #{path} #{ARGV.join(' ')}")
+      end
+    end
+  end
+end

data/lib/elecksee/lxc.rb

@@ -0,0 +1,7 @@
+require 'mixlib/shellout'
+
+require File.expand_path(
+  File.join(
+    File.dirname(__FILE__), 'vendor/lxc/libraries/lxc.rb'
+  )
+)

data/lib/elecksee/vendor/lxc/CHANGELOG.md

@@ -0,0 +1,37 @@
+## v1.0.0
+* Extract container actions out to new LWRP `lxc`
+* Update `container` to use `lxc` resource for container actions
+* Update `container` to allow nested subresources for `interface` and `fstab_mount`
+* Fix `interface` LWRP to allow IPv6 based values
+* Remove static_ip config set as it was introducing bogus route
+* Provide assumed environment when not available (like when running via runit)
+* Make chef enabled containers properly idempotent
+* Clean up the `container` provider implementation to be more resource based
+* Add `ephemeral` LWRP
+* Add custom ephemeral script to allow host directory overlay or virtual block device
+* Patches execute resource to provide streaming output
+* Updates Lxc library to be more reusable
+* Add proc based network detection for more robust address discovery
+* Shell out directly to ssh for container commands instead of using knife ssh
+
+## v0.1.0
+* Abstracted out packages for cross-platform support later.
+* Added the 'containers' recipe to create containers for the members of the node['lxc']['containers'] hash
+* Add support for use of the apt::cacher-client settings if a proxy is in use.
+* chef_enabled defaults to false on lxc_containers
+* Better idempotency checks when building new containers
+* Refactoring of lxc_service
+* Container based commands run via knife::ssh providing proper logging feedback
+* New networking related attributes added to lxc_container for easy basic network setups
+
+## v0.0.3
+* Remove resource for deprecated template
+
+## v0.0.2
+* Cleanup current config and container LWRPs
+* Add new LWRPs (fstab and interface)
+* Add better configuration build to prevent false updates
+* Thanks to Sean Porter (https://github.com/portertech) for help debugging LWRP updates
+
+## v0.0.1
+* Initial release

data/lib/elecksee/vendor/lxc/Gemfile

@@ -0,0 +1,4 @@
+source "https://rubygems.org"
+
+gem 'test-kitchen', git: 'git://github.com/opscode/test-kitchen.git', branch: '1.0'
+

data/lib/elecksee/vendor/lxc/Gemfile.lock

@@ -0,0 +1,41 @@
+GIT
+  remote: git://github.com/opscode/test-kitchen.git
+  revision: ab1b878561e896c0619a780d168e71addff2ad91
+  branch: 1.0
+  specs:
+    test-kitchen (1.0.0.dev)
+      celluloid
+      mixlib-shellout
+      net-scp
+      net-ssh
+      pry
+      safe_yaml
+      thor
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    celluloid (0.12.4)
+      facter (>= 1.6.12)
+      timers (>= 1.0.0)
+    coderay (1.0.9)
+    facter (1.6.17)
+    method_source (0.8.1)
+    mixlib-shellout (1.1.0)
+    net-scp (1.1.0)
+      net-ssh (>= 2.6.5)
+    net-ssh (2.6.6)
+    pry (0.9.12)
+      coderay (~> 1.0.5)
+      method_source (~> 0.8)
+      slop (~> 3.4)
+    safe_yaml (0.8.5)
+    slop (3.4.4)
+    thor (0.17.0)
+    timers (1.1.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  test-kitchen!

data/lib/elecksee/vendor/lxc/README.md

@@ -0,0 +1,112 @@
+# LXC
+
+Manage linux containers with Chef.
+
+## Recipes
+
+### default
+
+Installs the packages and configuration files needed for lxc on the server. If
+the node uses apt-cacher-ng as a client, the server will be reused when building
+containers.
+
+### install_dependencies
+
+Installs the packages needed to support lxc's containers.
+
+### containers
+
+This recipe creates all of the containers defined in the `['lxc']['containers']`
+hash. Here is an example of an `example` container:
+
+```ruby
+node['lxc']['containers']['example'] = { 
+  'template' => 'ubuntu',
+  'initialize_commands' => ['apt-get update']
+}
+```
+
+### knife
+
+Install and manage containers via the knife-remotelxc plugin.
+
+## LWRPs
+
+### lxc
+
+Allows for creation, deletion, and cloning of containers
+
+### lxc_config
+
+Allows configuration of the LXC configuration file
+
+### lxc_fstab
+
+Allows defining mounts to be used within the container
+
+### lxc_interface
+
+Allows configurations of network interfaces within a container
+
+### lxc_ephemeral
+
+Run a command within an ephemeral container
+
+### lxc_container
+
+Creates a container using the `lxc` LWRP and configures the container
+as requested. This resource also allows nesting `lxc_fstab` and
+`lxc_interface` within the container resource.
+
+## Example
+
+```ruby
+include_recipe 'lxc'
+
+lxc_container 'my_container' do
+  action :create
+  validation_client 'my-validator'
+  server_uri 'https://api.opscode.com/organizations/myorg'
+  validator_pem content_from_encrypted_dbag
+  run_list ['role[base]']
+  chef_enabled true
+  fstab_mount "Persist" do
+    file_system '/opt/file_store'
+    mount_point '/opt/file_store'
+    type 'none'
+    options 'bind,rw'
+  end
+end
+
+lxc_container 'my_container_clone' do
+  action :create
+  clone 'my_container'
+  chef_enabled true
+end
+
+lxc_service 'my_container_clone' do
+  action :start
+end
+```
+
+Containers do not have to be Chef enabled but it does make them
+extremely easy to configure. If you want the Omnibus installer
+cached, you can set the attribute
+
+```ruby
+node['omnibus_updater']['cache_omnibus_installer'] = true
+```
+
+in a role or environment (default is false). The `lxc_container`
+resource also provides `initialize_commands` which an array of
+commands can be provided that will be run after the container is
+created.
+
+### Repository:
+
+* https://github.com/hw-cookbooks/lxc
+
+### Contributors
+
+* Sean Porter (https://github.com/portertech)
+* Matt Ray (https://github.com/mattray)

data/lib/elecksee/vendor/lxc/attributes/default.rb

@@ -0,0 +1,28 @@
+default[:lxc][:start_ipaddress] = nil
+default[:lxc][:validator_pem] = nil
+default[:lxc][:auto_start] = true
+default[:lxc][:bridge] = 'lxcbr0'
+default[:lxc][:use_bridge] = true
+default[:lxc][:addr] = '10.0.3.1'
+default[:lxc][:netmask] = '255.255.255.0'
+default[:lxc][:network] = '10.0.3.0/24'
+default[:lxc][:dhcp_range] = '10.0.3.2,10.0.3.254'
+default[:lxc][:dhcp_max] = '253'
+default[:lxc][:shutdown_timeout] = 120
+default[:lxc][:allowed_types] = %w(debian ubuntu fedora)
+default[:lxc][:container_directory] = '/var/lib/lxc'
+default[:lxc][:dnsmasq_lease_file] = '/var/lib/misc/dnsmasq.leases'
+
+default[:lxc][:knife] = {}
+default[:lxc][:knife][:static_range] = ''
+default[:lxc][:knife][:static_ips] = []
+
+default[:lxc][:user_pass][:debian] = {:username => 'root', :password => 'root'}
+default[:lxc][:user_pass][:ubuntu] = {:username => 'ubuntu', :password => 'ubuntu'}
+default[:lxc][:user_pass][:fedora] = {:username => 'root', :password => 'root'}
+
+default[:lxc][:packages] = %w(lxc)
+default[:lxc][:mirror] = 'http://archive.ubuntu.com/ubuntu'
+default[:lxc][:containers] = {}
+
+default[:lxc][:awesome_ephemerals] = true

data/lib/elecksee/vendor/lxc/files/default/knife_lxc

@@ -0,0 +1,228 @@
+#!/opt/chef/embedded/bin/ruby
+
+require 'json'
+require 'getoptlong'
+
+LXC_HOME = '/var/lib/lxc'
+
+opts = GetoptLong.new(
+  ['--help', '-h', GetoptLong::NO_ARGUMENT],
+  ['--version', '-v', GetoptLong::NO_ARGUMENT],
+  ['--template', '-t', GetoptLong::REQUIRED_ARGUMENT]
+)
+
+# Default
+template = 'ubuntu'
+
+opts.each do |opt, arg|
+  case opt
+  when '--help'
+    show_usage
+    exit 0
+  when '--version'
+    show_version
+    exit 0
+  when '--template'
+    template = arg
+    raise 'Unsupported template provided' unless %w(debian fedora ubuntu).include?(template)
+  end
+end
+
+def conf
+  @c ||= JSON.load(File.read('/etc/knife-lxc/config.json'))
+end
+
+def lxc_exists?(lxc_name)
+  current_names = Dir.glob(File.join(LXC_HOME, '*')).map{|c| File.basename(c)}
+  current_names.include?(lxc_name)
+end
+
+def ensure_name_availability!(name)
+  raise 'Name already in use' if lxc_exists?(name)
+end
+
+def available_ips
+  # TODO: Add range calculation
+  range = conf['address']['range']
+  if(range.to_s.empty?)
+    range = (range.split('-').first.split('.').last..range.split('-').last).map{|oct|
+      "#{range.split('-').first.split('.').slice(0,3).join('.')}.#{oct}"
+    }
+  else
+    range = []
+  end
+  (conf['addresses']['static'] + range).compact
+end
+
+def used_ips
+  Dir.glob(File.join(LXC_HOME, '*')).map{ |ctn|
+    File.readlines(File.join(ctn, 'rootfs', 'etc', 'network', 'interfaces')).detect{ |line|
+      line.include?('address')
+    }.to_s.split(' ').last.to_s.strip
+  }.reject{ |addr|
+    addr.empty?
+  }
+end
+
+def update_container_ip(name)
+  new_ip = (available_ips - used_ips).pop
+  raise 'no ips available' unless new_ip
+  update_network_interfaces(name, new_ip)
+  new_ip
+end
+
+def update_network_interfaces(name, address)
+  default_nm = '255.255.255.0'
+  (parts = address.split('.')).last.replace('1')
+  default_gw = parts.join('.')
+  File.open(File.join(LXC_HOME, name, 'rootfs', 'etc', 'network', 'interfaces'), 'w') do |file|
+    file.puts "auto lo eth0"
+    file.puts "iface lo inet loopback"
+    file.puts "iface eth0 inet static"
+    file.puts "  address #{address}"
+    file.puts "  gateway #{conf['gateway'] || default_gw}"
+    file.puts "  netmask #{conf['netmask'] || default_nm}"
+  end
+end
+
+def sudoable_ubuntu(name)
+  path = File.join(LXC_HOME, name, 'rootfs', 'etc', 'sudoers')
+  content = File.readlines(path).map do |line|
+    if(line.start_with?('%sudo'))
+      '%sudo ALL=(ALL) NOPASSWD:ALL'
+    else
+      line
+    end
+  end
+  File.open(path, 'w') do |file|
+    file.write(content.join("\n"))
+  end
+end
+
+def clone_container(name, template)
+  %x{lxc-clone -o #{template}_base -n #{name}}
+end
+
+def start_container(name)
+  %x{lxc-start -n #{name} -d}
+  %x{lxc-wait -n #{name} -s RUNNING}
+end
+
+def stop_container(name)
+  %x{lxc-shutdown -n #{name} -d}
+  %x{lxc-wait -n #{name} -s STOPPED}
+end
+
+def create_lxc(lxc_name, template)
+  ensure_name_availability!(lxc_name)
+  clone_container(lxc_name, template)
+  address = update_container_ip(lxc_name)
+  # TODO: Update debian and fedora to use sudo user and remove root login
+  if(lxc_name == 'ubuntu')
+    sudoable_ubuntu(lxc_name)
+  end
+  start_container(lxc_name)
+  puts "LXC Node #{lxc_name} available at: #{address}"
+end
+
+def lxc_address(name)
+  if(File.exists?(int = File.join(LXC_HOME, name, 'rootfs', 'etc', 'network', 'interfaces')))
+    addr = File.readlines(int).detect{|l|l.include?('address')}.to_s.split(' ').last.to_s.strip
+    addr.empty? ? 'dynamic' : addr
+  else
+    'dynamic'
+  end
+end
+
+def lxc_type(name)
+  base = File.join(LXC_HOME, name, 'rootfs', 'etc')
+  if(File.exists?(lsb = File.join(base, 'lsb-release')))
+    File.readlines(lsb).last.split('=').last.strip.gsub('"', '')
+  elsif(File.exists?(sys_rel = File.join(base, 'system-release')))
+    File.readlines(sys_rel).first.strip
+  elsif(File.exists?(deb_ver = File.join(base, 'debian_version')))
+    "Debain #{File.read(deb_ver).strip}"
+  else
+    'UNKNOWN'
+  end
+end
+
+def list_lxcs
+  info = Hash[
+    *Dir.glob(File.join(LXC_HOME, '*')).map{|dir|
+      key = File.basename(dir)
+      [key, {:address => lxc_address(key), :type => lxc_type(key)}]
+    }.sort{|a,b|
+      a.first <=> b.first
+    }.flatten
+  ]
+  info.each do |name, info|
+    puts "#{name}"
+    puts "  Type: #{info[:type]}"
+    puts "  Address: #{info[:address]}"
+  end
+end
+
+def info_lxc(lxc_name)
+  puts "#{lxc_name}"
+  puts "  Type: #{lxc_type(lxc_name)}"
+  puts "  Address: #{lxc_address(lxc_name)}"
+end
+
+def delete_lxc(lxc_name)
+  %x{lxc-stop -n #{lxc_name}}
+  %x{lxc-wait -n #{lxc_name} -s STOPPED}
+  %x{lxc-destroy -n #{lxc_name}}
+end
+
+action = ARGV.first.to_s
+
+case action
+when 'create'
+  lxc_name = ARGV[1]
+  create_lxc(lxc_name, template)
+when 'list'
+  list_lxcs
+when 'info'
+  lxc_name = ARGV[1]
+  if(lxc_exists?(lxc_name))
+    info_lxc(lxc_name)
+  else
+    $stderr.puts "Requested container does not exist: #{lxc_name}"
+    exit 2
+  end
+when 'start'
+  lxc_name = ARGV[1]
+  if(lxc_exists?(lxc_name))
+    print "Starting container #{lxc_name}... "
+    start_lxc(lxc_name)
+    puts 'started'
+  else
+    $stderr.puts "Requested container does not exist: #{lxc_name}"
+    exit 2
+  end
+when 'stop'
+  lxc_name = ARGV[1]
+  if(lxc_exists?(lxc_name))
+    print "Stopping container #{lxc_name}... "
+    stop_lxc(lxc_name)
+    puts 'stopped'
+  else
+    $stderr.puts "Requested container does not exist: #{lxc_name}"
+    exit 2
+  end
+when 'delete'
+  lxc_name = ARGV[1]
+  if(lxc_exists?(lxc_name))
+    print "Deleting LXC #{lxc_name}... "
+    destroy_lxc(lxc_name)
+    puts 'done'
+  else
+    $stderr.puts "Requested container does not exist: #{lxc_name}"
+    exit 2
+  end
+else
+  $stderr.puts "ERROR: Unknown action: #{action}"
+  exit 1
+end
+