testlab 0.0.3 → 0.0.4

data/README.md

@@ -6,10 +6,20 @@
 
 # TestLab
 
-A framework for building lightweight virtual laboratories using LXC
+A framework for building lightweight virtual infrastructure using LXC
+
+# REQUIREMENTS
+
+* Latest VirtualBox Package
+* Latest Vagrant Package (non-gem version)
+* Ubuntu 13.04 Server 64-bit (Raring) Base Box - https://github.com/zpatten/raring64
 
 # RESOURCES
 
+Documentation:
+
+* http://zpatten.github.io/testlab/
+
 Source:
 
 * https://github.com/zpatten/testlab
@@ -18,10 +28,6 @@ Issues:
 
 * https://github.com/zpatten/testlab/issues
 
-Documentation:
-
-* http://zpatten.github.com/testlab/
-
 # LICENSE
 
 TestLab - A framework for building lightweight virtual laboratories using LXC

data/lib/testlab/container/actions.rb

@@ -0,0 +1,47 @@
+class TestLab
+  class Container
+
+    module Actions
+
+      # Create the container
+      def create
+        @ui.logger.debug { "Container Create: #{self.id} " }
+
+        self.distro  ||= "ubuntu"
+        self.release ||= "precise"
+        self.arch    ||= detect_arch
+
+        self.lxc.config.clear
+        self.lxc.config['lxc.utsname'] = self.id
+        self.lxc.config['lxc.arch'] = self.arch
+        self.lxc.config.networks = build_lxc_network_conf(self.interfaces)
+        self.lxc.config.save
+
+        self.lxc.create(*create_args)
+      end
+
+      # Destroy the container
+      def destroy
+        @ui.logger.debug { "Container Destroy: #{self.id} " }
+
+        self.lxc.destroy
+      end
+
+      # Start the container
+      def up
+        @ui.logger.debug { "Container Up: #{self.id} " }
+
+        self.lxc.start
+      end
+
+      # Stop the container
+      def down
+        @ui.logger.debug { "Container Down: #{self.id} " }
+
+        self.lxc.stop
+      end
+
+    end
+
+  end
+end

data/lib/testlab/container/generators.rb

@@ -0,0 +1,42 @@
+class TestLab
+  class Container
+
+    module Generators
+
+      def generate_ip
+        octets = [ 192..192,
+                   168..168,
+                   0..254,
+                   1..254 ]
+        ip = Array.new
+        for x in 1..4 do
+          ip << octets[x-1].to_a[rand(octets[x-1].count)].to_s
+        end
+        ip.join(".")
+      end
+
+      def generate_mac
+        digits = [ %w(0),
+                   %w(0),
+                   %w(0),
+                   %w(0),
+                   %w(5),
+                   %w(e),
+                   %w(0 1 2 3 4 5 6 7 8 9 a b c d e f),
+                   %w(0 1 2 3 4 5 6 7 8 9 a b c d e f),
+                   %w(5 6 7 8 9 a b c d e f),
+                   %w(3 4 5 6 7 8 9 a b c d e f),
+                   %w(0 1 2 3 4 5 6 7 8 9 a b c d e f),
+                   %w(0 1 2 3 4 5 6 7 8 9 a b c d e f) ]
+        mac = ""
+        for x in 1..12 do
+          mac += digits[x-1][rand(digits[x-1].count)]
+          mac += ":" if (x.modulo(2) == 0) && (x != 12)
+        end
+        mac
+      end
+
+    end
+
+  end
+end

data/lib/testlab/container/lifecycle.rb

@@ -0,0 +1,25 @@
+class TestLab
+  class Container
+
+    module Lifecycle
+
+      # Container Setup
+      def setup
+        @ui.logger.debug { "Container Setup: #{self.id} " }
+
+        self.create
+        self.up
+      end
+
+      # Container Teardown
+      def teardown
+        @ui.logger.debug { "Container Teardown: #{self.id} " }
+
+        self.down
+        self.destroy
+      end
+
+    end
+
+  end
+end

data/lib/testlab/container/lxc.rb

@@ -0,0 +1,43 @@
+class TestLab
+  class Container
+
+    module LXC
+
+      # Our LXC Container class
+      #
+      # @return [LXC] An instance of LXC::Container configured for this
+      #   container.
+      def lxc
+        @lxc ||= self.node.lxc.container(self.id)
+      end
+
+      # Returns arguments for lxc-create based on our distro
+      #
+      # @return [Array] An array of arguments for lxc-create
+      def create_args
+        case self.distro.downcase
+        when "ubuntu" then
+          %W(-f /etc/lxc/#{self.id} -t #{self.distro} -- --release #{self.release} --arch #{self.arch})
+        when "fedora" then
+          %W(-f /etc/lxc/#{self.id} -t #{self.distro} -- --release #{self.release})
+        end
+      end
+
+      # Attempt to detect the architecture of the node.  The value returned is
+      # respective to the container distro.
+      #
+      # @return [String] The arch of the node in the context of the container
+      #   distro
+      def detect_arch
+        case self.distro.downcase
+        when "ubuntu" then
+          ((self.node.arch =~ /x86_64/) ? "amd64" : "i386")
+        when "fedora" then
+          ((self.node.arch =~ /x86_64/) ? "amd64" : "i686")
+        end
+      end
+
+    end
+
+  end
+end

data/lib/testlab/container/network.rb

@@ -0,0 +1,31 @@
+class TestLab
+  class Container
+
+    module Network
+
+      # Builds an array of hashes containing the lxc configuration options for
+      # our networks
+      def build_lxc_network_conf(interfaces)
+        networks = Array.new
+
+        interfaces.each do |network, network_config|
+          networks << Hash[
+            'lxc.network.type'         => :veth,
+            'lxc.network.flags'        => :up,
+            'lxc.network.link'         => TestLab::Network.first(network).bridge,
+            'lxc.network.name'         => network_config[:name],
+            'lxc.network.hwaddr'       => network_config[:mac],
+            'lxc.network.ipv4'         => network_config[:ip]
+          ]
+          if (network_config[:primary] == true) || (interfaces.count == 1)
+            networks.last.merge!('lxc.network.ipv4.gateway' => :auto)
+          end
+        end
+
+        networks
+      end
+
+    end
+
+  end
+end

data/lib/testlab/container/status.rb

@@ -0,0 +1,28 @@
+class TestLab
+  class Container
+
+    module Status
+
+      def status
+        interfaces = self.interfaces.collect{ |network, network_config| "#{network}:#{network_config[:name]}:#{network_config[:ip]}" }.join(', ')
+
+        {
+          :id => self.id,
+          :state => self.state,
+          :distro => self.distro,
+          :release => self.release,
+          :interfaces => interfaces,
+          :provisioner => self.provisioner,
+          :node_id => self.node.id
+        }
+      end
+
+      # State of the container
+      def state
+        self.lxc.state
+      end
+
+    end
+
+  end
+end

data/lib/testlab/container.rb

@@ -14,6 +14,11 @@ class TestLab
     attribute   :provisioner
     attribute   :config
 
+    attribute   :domain
+
+    attribute   :user
+    attribute   :keys
+
     attribute   :interfaces
 
     attribute   :distro
@@ -22,125 +27,85 @@ class TestLab
 
     attribute   :persist
 
-    def initialize(*args)
-      super(*args)
-
-      @ui          = TestLab.ui
-      @provisioner = self.provisioner.new(self.config) if !self.provisioner.nil?
-    end
-
-    def status
-      interfaces = self.interfaces.collect{ |key, value| "#{key}:#{value[:name]}:#{value[:ip]}" }.join(', ')
-
-      {
-        :id => self.id,
-        :state => self.state,
-        :distro => self.distro,
-        :release => self.release,
-        :interfaces => interfaces,
-        :provisioner => self.provisioner,
-        :node_id => self.node.id
-      }
-    end
-
-    # Our LXC Container class
-    def lxc
-      @lxc ||= self.node.lxc.container(self.id)
-    end
-
-    # Create the container
-    def create
-      @ui.logger.debug { "Container Create: #{self.id} " }
-
-      self.arch ||= detect_arch
 
-      self.lxc.config.clear
+    autoload :Actions,    'testlab/container/actions'
+    autoload :Generators, 'testlab/container/generators'
+    autoload :Lifecycle,  'testlab/container/lifecycle'
+    autoload :LXC,        'testlab/container/lxc'
+    autoload :Network,    'testlab/container/network'
+    autoload :Status,     'testlab/container/status'
 
-      self.lxc.config['lxc.utsname'] = self.id
+    include TestLab::Container::Actions
+    include TestLab::Container::Generators
+    include TestLab::Container::Lifecycle
+    include TestLab::Container::LXC
+    include TestLab::Container::Network
+    include TestLab::Container::Status
 
-      self.interfaces.each do |network, network_config|
-        n = Hash.new
-        n['lxc.network.type']         = :veth
-        n['lxc.network.flags']        = :up
-        n['lxc.network.link']         = TestLab::Network.first(network).bridge
-        n['lxc.network.name']         = (network_config[:name] || "eth0")
-        n['lxc.network.hwaddr']       = (network_config[:mac] || generate_mac)
-        n['lxc.network.ipv4']         = (network_config[:ip] || generate_ip)
-        self.lxc.config.networks << n
-      end
 
-      self.lxc.config.save
+    def initialize(*args)
+      super(*args)
 
-      self.lxc.create(*create_args)
+      @ui          = TestLab.ui
+      @provisioner = self.provisioner.new(self.config) if !self.provisioner.nil?
     end
 
-    # Destroy the container
-    def destroy
-      @ui.logger.debug { "Container Destroy: #{self.id} " }
-
-      self.lxc.destroy
-    end
+################################################################################
 
-    # Start the container
-    def up
-      @ui.logger.debug { "Container Up: #{self.id} " }
+    # Does the container exist?
+    def exists?
+      @ui.logger.debug { "Container Exists?: #{self.id} " }
 
-      self.lxc.start
+      self.lxc.exists?
     end
 
-    # Stop the container
-    def down
-      @ui.logger.debug { "Container Down: #{self.id} " }
+################################################################################
 
-      self.lxc.stop
+    # SSH to the container
+    def ssh(options={})
+      self.node.container_ssh(self, options)
     end
 
-    # Reload the container
-    def reload
-      @ui.logger.debug { "Container Reload: #{self.id} " }
-
-      self.down
-      self.up
+    def ip
+      self.primary_interface.last[:ip].split('/').first
     end
 
-    # Does the container exist?
-    def exists?
-      @ui.logger.debug { "Container Exists?: #{self.id} " }
-
-      self.lxc.exists?
+    # Returns the CIDR of the container
+    def cidr
+      self.primary_interface.last[:ip].split('/').last.to_i
     end
 
-    # State of the container
-    def state
-      self.lxc.state
-    end
+    def ptr
+      octets = self.ip.split('.')
 
-################################################################################
+      result = case self.cidr
+      when 0..7 then
+        octets[-4,4]
+      when 8..15 then
+        octets[-3,3]
+      when 16..23 then
+        octets[-2,2]
+      when 24..31 then
+        octets[-1,1]
+      end
 
-    # Container Callback: after_create
-    def after_create
-      @ui.logger.debug { "Container Callback: After Create: #{self.id} " }
+      result.reverse.join('.')
     end
 
-    # Container Callback: after_up
-    def after_up
-      @ui.logger.debug { "Container Callback: After Up: #{self.id} " }
-
-      self.create
-      self.up
+    def primary_interface
+      if self.interfaces.any?{ |i,c| c[:primary] == true }
+        self.interfaces.find{ |i,c| c[:primary] == true }
+      else
+        self.interfaces.first
+      end
     end
 
-    # Container Callback: before_down
-    def before_down
-      @ui.logger.debug { "Container Callback: Before Down: #{self.id} " }
+    class << self
 
-      self.down
-      self.destroy
-    end
+      def domains
+        self.all.map(&:domain).compact
+      end
 
-    # Container Callback: before_destroy
-    def before_destroy
-      @ui.logger.debug { "Container Callback: Before Destroy: #{self.id} " }
     end
 
 ################################################################################
@@ -156,63 +121,6 @@ class TestLab
       end
     end
 
-################################################################################
-  private
-################################################################################
-
-    # Returns arguments for lxc-create based on our distro
-    def create_args
-      case self.distro.downcase
-      when "ubuntu" then
-        %W(-f /etc/lxc/#{self.id} -t #{self.distro} -- --release #{self.release} --arch #{arch})
-      when "fedora" then
-        %W(-f /etc/lxc/#{self.id} -t #{self.distro} -- --release #{self.release})
-      end
-    end
-
-    # Attempt to detect the architecture of the node our container is running on
-    def detect_arch
-      case self.distro.downcase
-      when "ubuntu" then
-        ((self.node.arch =~ /x86_64/) ? "amd64" : "i386")
-      when "fedora" then
-        ((self.node.arch =~ /x86_64/) ? "amd64" : "i686")
-      end
-    end
-
-    def generate_ip
-      octets = [ 192..192,
-                 168..168,
-                 0..254,
-                 1..254 ]
-      ip = Array.new
-      for x in 1..4 do
-        ip << octets[x-1].to_a[rand(octets[x-1].count)].to_s
-      end
-      ip.join(".")
-    end
-
-    def generate_mac
-      digits = [ %w(0),
-                 %w(0),
-                 %w(0),
-                 %w(0),
-                 %w(5),
-                 %w(e),
-                 %w(0 1 2 3 4 5 6 7 8 9 a b c d e f),
-                 %w(0 1 2 3 4 5 6 7 8 9 a b c d e f),
-                 %w(5 6 7 8 9 a b c d e f),
-                 %w(3 4 5 6 7 8 9 a b c d e f),
-                 %w(0 1 2 3 4 5 6 7 8 9 a b c d e f),
-                 %w(0 1 2 3 4 5 6 7 8 9 a b c d e f) ]
-      mac = ""
-      for x in 1..12 do
-        mac += digits[x-1][rand(digits[x-1].count)]
-        mac += ":" if (x.modulo(2) == 0) && (x != 12)
-      end
-      mac
-    end
-
   end
 
 end

data/lib/testlab/network/actions.rb

@@ -0,0 +1,37 @@
+class TestLab
+  class Network
+
+    module Actions
+
+      # Create the network
+      def create
+        @ui.logger.debug { "Network Create: #{self.id} " }
+
+        self.node.ssh.exec(%(sudo brctl addbr #{self.bridge}), :silence => true, :ignore_exit_status => true)
+      end
+
+      # Destroy the network
+      def destroy
+        @ui.logger.debug { "Network Destroy: #{self.id} " }
+
+        self.node.ssh.exec(%(sudo brctl delbr #{self.bridge}), :silence => true, :ignore_exit_status => true)
+      end
+
+      # Start the network
+      def up
+        @ui.logger.debug { "Network Up: #{self.id} " }
+
+        self.node.ssh.exec(%(sudo ifconfig #{self.bridge} #{self.ip} up), :silence => true, :ignore_exit_status => true)
+      end
+
+      # Stop the network
+      def down
+        @ui.logger.debug { "Network Down: #{self.id} " }
+
+        self.node.ssh.exec(%(sudo ifconfig #{self.bridge} down), :silence => true, :ignore_exit_status => true)
+      end
+
+    end
+
+  end
+end

data/lib/testlab/network/cidr.rb

@@ -0,0 +1,102 @@
+class TestLab
+  class Network
+
+    module CIDR
+
+      CIDR_MATRIX = {
+        32 => { :netmask => '255.255.255.255', :broadcast => '%s.%s.%s.%s',     :network => '%s.%s.%s.%s' },
+        31 => { :netmask => '255.255.255.254', :broadcast => '%s.%s.%s.1',      :network => '%s.%s.%s.254' },
+        30 => { :netmask => '255.255.255.252', :broadcast => '%s.%s.%s.3',      :network => '%s.%s.%s.252' },
+        29 => { :netmask => '255.255.255.248', :broadcast => '%s.%s.%s.7',      :network => '%s.%s.%s.248' },
+        28 => { :netmask => '255.255.255.240', :broadcast => '%s.%s.%s.15',     :network => '%s.%s.%s.240' },
+        27 => { :netmask => '255.255.255.224', :broadcast => '%s.%s.%s.31',     :network => '%s.%s.%s.224' },
+        26 => { :netmask => '255.255.255.192', :broadcast => '%s.%s.%s.63',     :network => '%s.%s.%s.192' },
+        25 => { :netmask => '255.255.255.128', :broadcast => '%s.%s.%s.127',    :network => '%s.%s.%s.128' },
+        24 => { :netmask => '255.255.255.0',   :broadcast => '%s.%s.%s.255',    :network => '%s.%s.%s.0' },
+        23 => { :netmask => '255.255.254.0',   :broadcast => '%s.%s.1.255',     :network => '%s.%s.254.0' },
+        22 => { :netmask => '255.255.252.0',   :broadcast => '%s.%s.3.255',     :network => '%s.%s.252.0' },
+        21 => { :netmask => '255.255.248.0',   :broadcast => '%s.%s.7.255',     :network => '%s.%s.248.0' },
+        20 => { :netmask => '255.255.240.0',   :broadcast => '%s.%s.15.255',    :network => '%s.%s.240.0' },
+        19 => { :netmask => '255.255.224.0',   :broadcast => '%s.%s.31.255',    :network => '%s.%s.224.0' },
+        18 => { :netmask => '255.255.192.0',   :broadcast => '%s.%s.63.255',    :network => '%s.%s.192.0' },
+        17 => { :netmask => '255.255.128.0',   :broadcast => '%s.%s.127.255',   :network => '%s.%s.128.0' },
+        16 => { :netmask => '255.255.0.0',     :broadcast => '%s.%s.255.255',   :network => '%s.%s.0.0' },
+        15 => { :netmask => '255.254.0.0',     :broadcast => '%s.1.255.255',    :network => '%s.254.0.0' },
+        14 => { :netmask => '255.252.0.0',     :broadcast => '%s.3.255.255',    :network => '%s.252.0.0' },
+        13 => { :netmask => '255.248.0.0',     :broadcast => '%s.7.255.255',    :network => '%s.248.0.0' },
+        12 => { :netmask => '255.240.0.0',     :broadcast => '%s.15.255.255',   :network => '%s.240.0.0' },
+        11 => { :netmask => '255.224.0.0',     :broadcast => '%s.31.255.255',   :network => '%s.224.0.0' },
+        10 => { :netmask => '255.192.0.0',     :broadcast => '%s.63.255.255',   :network => '%s.192.0.0' },
+         9 => { :netmask => '255.128.0.0',     :broadcast => '%s.127.255.255',  :network => '%s.128.0.0' },
+         8 => { :netmask => '255.0.0.0',       :broadcast => '%s.255.255.255',  :network => '%s.0.0.0' },
+         7 => { :netmask => '254.0.0.0',       :broadcast => '1.255.255.255',   :network => '254.0.0.0' },
+         6 => { :netmask => '252.0.0.0',       :broadcast => '3.255.255.255',   :network => '252.0.0.0' },
+         5 => { :netmask => '248.0.0.0',       :broadcast => '7.255.255.255',   :network => '248.0.0.0' },
+         4 => { :netmask => '240.0.0.0',       :broadcast => '15.255.255.255',  :network => '240.0.0.0' },
+         3 => { :netmask => '224.0.0.0',       :broadcast => '31.255.255.255',  :network => '224.0.0.0' },
+         2 => { :netmask => '192.0.0.0',       :broadcast => '63.255.255.255',  :network => '192.0.0.0' },
+         1 => { :netmask => '128.0.0.0',       :broadcast => '127.255.255.255', :network => '128.0.0.0' },
+         0 => { :netmask => '0.0.0.0',         :broadcast => '255.255.255.255', :network => '0.0.0.0' }
+      }
+
+      # Returns the CIDR of the network
+      def cidr
+        self.ip.split('/').last.to_i
+      end
+
+      # Returns the IP with the CIDR notation stripped away
+      def clean_ip
+        self.ip.split('/').first
+      end
+
+      # Returns the entry from the CIDR_MATRIX constant based on our CIDR
+      def cidr_matrix
+        CIDR_MATRIX[self.cidr]
+      end
+
+      # Returns the network mask
+      def netmask
+        cidr_matrix[:netmask]
+      end
+
+      # Returns the network address
+      def network
+        cidr_matrix[:network] % clean_ip.split('.')
+      end
+
+      # Returns the broadcast address
+      def broadcast
+        cidr_matrix[:broadcast] % clean_ip.split('.')
+      end
+
+      def cidr_octets(fill=nil)
+        octets = self.clean_ip.split('.')
+
+        result = case self.cidr
+        when 0..7 then
+          octets[-4,4]
+        when 8..15 then
+          [octets[-3,3], fill]
+        when 16..23 then
+          [octets[-2,2], fill, fill]
+        when 24..31 then
+          [octets[-1,1], fill, fill, fill]
+        end
+
+        result.flatten.compact
+      end
+
+      def ptr
+        cidr_octets.reverse.join('.')
+      end
+
+      # Returns the ARPA address
+      def arpa
+        result = self.network.split('.').delete_if{ |ip| ip == '0' }.reverse.join('.')
+        "#{result}.in-addr.arpa"
+      end
+
+    end
+
+  end
+end

data/lib/testlab/network/lifecycle.rb

@@ -0,0 +1,25 @@
+class TestLab
+  class Network
+
+    module Lifecycle
+
+      # Network Setup
+      def setup
+        @ui.logger.debug { "Network Setup: #{self.id} " }
+
+        self.create
+        self.up
+      end
+
+      # Network Teardown
+      def teardown
+        @ui.logger.debug { "Network Teardown: #{self.id} " }
+
+        self.down
+        self.destroy
+      end
+
+    end
+
+  end
+end