wf_node_api 0.6.0

data/lib/wf_node_api/container_manager_adapter/lxc.rb

@@ -0,0 +1,431 @@
+=begin
+__        ___     _ _       _____                ____ __  __
+\ \      / / |__ (_) |_ ___|  ___|   _ ___  ___ / ___|  \/  |
+ \ \ /\ / /| '_ \| | __/ _ \ |_ | | | / __|/ _ \ |   | |\/| |
+  \ V  V / | | | | | ||  __/  _|| |_| \__ \  __/ |___| |  | |
+   \_/\_/  |_| |_|_|\__\___|_|   \__,_|___/\___|\____|_|  |_|
+                                            Container Manager
+
+Copyright (C) 2015 David Prandzioch <kontakt@davidprandzioch.de>
+
+This program is free software; you can redistribute it and/or
+modify it under the terms of the GNU General Public License
+as published by the Free Software Foundation; either version 2
+of the License, or (at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+=end
+
+module ContainerManagerAdapter
+  # Container adapter for LXC. Encapsulates all LXC specific command line
+  # wrapping
+  class Lxc
+    # Lists all available containers
+    #
+    # @return [Array]
+    def containers
+      container_list = []
+
+      self.container_names.each do |item|
+        container_list << container(item)
+      end
+
+      container_list
+    end
+
+    # Starts a container with the given name
+    #
+    # @param name [String] The container name
+    #
+    # @raise [RuntimeError]
+    #
+    # @return [String] CLI output
+    def start(name)
+      res = Open3.capture3($lxc_cmd_start.gsub('[name]', name))
+
+      if res[1].empty? && res[2].exitstatus == 0
+        $logger.info("container " + name + " successfully started")
+        return res[0].strip
+      end
+
+      $logger.warn("container " + name + " could not be started")
+      raise RuntimeError, res[1].strip
+    end
+
+    # Stops a container with the given name
+    #
+    # @param name [String] The container name
+    #
+    # @raise [RuntimeError]
+    #
+    # @return [String] CLI output
+    def stop(name)
+      res = Open3.capture3($lxc_cmd_stop.gsub('[name]', name))
+
+      if res[1].empty? && res[2].exitstatus == 0
+        $logger.info("container " + name + " successfully stopped")
+        return res[0].strip
+      end
+
+      $logger.warn("container " + name + " could not be stopped")
+      raise RuntimeError, res[1].strip
+    end
+
+    # Kills a container with the given name
+    #
+    # @param name [String] The container name
+    #
+    # @raise [RuntimeError]
+    #
+    # @return [String] CLI output
+    def kill(name)
+      res = Open3.capture3($lxc_cmd_kill.gsub('[name]', name))
+
+      if res[1].empty? && res[2].exitstatus == 0
+        $logger.info("container " + name + " successfully killed")
+        return res[0].strip
+      end
+
+      $logger.warn("container " + name + " could not be killed")
+      raise RuntimeError, res[1].strip
+    end
+
+    # Deletes a container with the given name
+    #
+    # @param name [String] The container name
+    #
+    # @raise [RuntimeError]
+    #
+    # @return [String] CLI output
+    def delete(name)
+      res = Open3.capture3($lxc_cmd_destroy.gsub('[name]', name))
+
+      if res[1].empty? && res[2].exitstatus == 0
+        $logger.info("container " + name + " successfully deleted")
+        return res[0].strip
+      end
+
+      $logger.warn("container" + name + " could not be deleted")
+      raise RuntimeError, res[1].strip
+    end
+
+    # Returns information for a single container
+    #
+    # @param name [String] The container name
+    #
+    # @return [Hash] Hash with information about the container
+    def container(name)
+      data = {}
+
+      data[:name] = name
+      data[:state] = translate_state(state(name))
+      data[:ip_address] = ip_addr(name)
+      data[:cpu_cores] = assigned_cpu_cores(name).count
+      data[:memory_limit_bytes] = memory_limit(name).to_i
+      data[:memory_usage_bytes] = memory_usage(name).to_i
+      data[:disk_space_gb] = 0
+      data[:disk_usage_gb] = 0
+      data[:container_type] = 'lxc'
+
+      data
+    end
+
+    # Creates a container with the given parameters
+    #
+    # @param name             [String]    The container name
+    # @param ip_address       [String]    A valid IPv4 address
+    # @param disk_size_gb     [Integer]   The disk size in GB
+    # @param memory_limit_mb  [Integer]   The memory limit in MB
+    # @param cpu_core_count   [Integer]   Amount of Vcores to assign. 0 if no limit should be set
+    #
+    # @raise [RuntimeError]
+    #
+    # @return [String] CLI output
+    def create_container(name, ip_address, disk_size_gb, memory_limit_mb, cpu_core_count)
+      output = ''
+
+      begin
+        if cpu_core_count != 0
+          cpuset = self.generate_cpu_set(cpu_core_count, ResourceManager.new('linux'))
+        end
+
+        create_result = Open3.capture3($lxc_cmd_create.gsub('[name]', name))
+
+        output += create_result[0]
+        output += create_result[1]
+
+        config_path = $lxc_container_config_path.gsub('[name]', name)
+
+        open(config_path, 'a') do |f|
+          f << "lxc.network.ipv4=#{ip_address}/#{$lxc_ip_netmask}\n"
+          f << "lxc.start.auto=1\n"
+          f << "lxc.start.delay=5\n"
+
+          if cpu_core_count != 0
+            f << "lxc.cgroup.cpuset.cpus=#{cpuset}\n"
+          end
+
+          f << "lxc.cgroup.memory.limit_in_bytes=#{memory_limit_mb.to_s}M\n"
+        end
+
+        $logger.info("creation of container " + name + " successful")
+        return output.strip
+      rescue => e
+        $logger.warn("container " + name + " could not be created, rolling back...")
+
+        # rollback
+        delete(name) if exist?(name)
+
+        output += e.message
+        raise RuntimeError, output.strip
+      end
+    end
+
+    # Checks if a container with the given name exists
+    #
+    # @param name [String] The container name
+    #
+    # @return [Boolean] Existing/not existing
+    def exist?(name)
+      self.container_names().include?(name)
+    end
+
+    # Returns the amount of free cpu cores
+    #
+    # @param resman [ResourceManager] A ResourceManager instance
+    #
+    # @return [Integer] The amount of free cpu cores
+    def free_cpu_core_count(resman)
+      self.free_cpu_cores(resman).count
+    end
+
+    protected
+      # Reads the config file of a LXC container
+      #
+      # @param name [String] The container name
+      #
+      # @raise [StandardError]
+      #
+      # @return [String] Contents of the configuration file
+      def read_config(name)
+        config = config_path(name)
+
+        if File.exists?(config) == false
+          raise 'config file does not exist'
+        end
+
+        if File.readable?(config) == false
+          raise 'config file not readable'
+        end
+
+        File.read(config)
+      end
+
+      # Returns the config path for a container
+      #
+      # @param name [String] The container name
+      #
+      # @return [String] The config path
+      def config_path(name)
+        $lxc_container_config_path.gsub('[name]', name)
+      end
+
+      # Returns the info string for a container using lxc-info
+      #
+      # @param name [String] The container name
+      #
+      # @return [String] info string
+      def get_info(name)
+        output = `#{$lxc_cmd_info.gsub('[name]', name)}`
+
+        if output.nil?
+          return ''
+        end
+
+        return output
+      end
+
+      # Returns the assigned IP addresses for the container
+      #
+      # @param name [String] The container name
+      #
+      # @return [String|NilClass] IP address
+      def ip_addr(name)
+        result = get_info(name).scan(/^IP:\s+([0-9.]+)$/).flatten
+
+        result.first.nil? || result.first.empty? ? nil : result.first
+      end
+
+      # Returns the state of the container
+      #
+      # @param name [String] The container name
+      #
+      # @return [String|NilClass] State
+      def state(name)
+        result = get_info(name).scan(/^State:\s+([A-Za-z]+)$/).flatten
+
+        result.first.nil? || result.first.empty? ? nil : result.first
+      end
+
+      # Returns cgroup information for a container
+      #
+      # @param name   [String] The container name
+      # @param param  [String] The cgroup parameter to read
+      #
+      # @return [String|NilClass] The result
+      def cgroup_info(name, param)
+        res = `lxc-cgroup -n #{name} #{param}`
+        res.empty? ? nil : res.strip
+      end
+
+      # Returns the current cpu usage for a container
+      #
+      # @param name [String] The container name
+      #
+      # @return [String|NilClass] CPU usage
+      def cpu_usage(name)
+        cgroup_info(name, 'cpuacct.usage')
+      end
+
+      # Returns the memory limit for a container
+      #
+      # @param name [String] The container name
+      #
+      # @return [Integer|NilClass] Memory limit in bytes
+      def memory_limit(name)
+        cgroup_info(name, 'memory.limit_in_bytes').to_i
+      end
+
+        # Returns the memory usage for a container
+        #
+        # @param name [String] The container name
+        #
+        # @return [Integer|NilClass] Memory usage in bytes
+      def memory_usage(name)
+        cgroup_info(name, 'memory.usage_in_bytes').to_i
+      end
+
+      # Returns a list of all container names
+      #
+      # @return [Array] Container names
+      def container_names
+        `#{$lxc_cmd_ls}`.lines.map(&:strip).uniq
+      end
+
+      # Returns an array with assigned CPU core ids
+      #
+      # return [Array] assigned cpu cores
+      def globally_assigned_cpu_cores
+        assigned_cores = []
+
+        container_names.each do |c|
+          self.assigned_cpu_cores(c).each do |cpu|
+            assigned_cores.push(cpu)
+          end
+        end
+
+        assigned_cores
+      end
+
+      # Reads a config value from the containers config file
+      #
+      # @param name   [String] The container name
+      # @param regex  [Regexp] The pattern to search for
+      #
+      # @return [Boolean|String] The config result
+      def read_config_value(name, regex)
+        config = self.read_config(name)
+        line = config.scan(regex)
+
+        if line.empty?
+          return false
+        end
+
+        value = line.flatten.first.strip
+
+        value
+      end
+
+      # Returns an array with Vcores assigend to a container
+      #
+      # @param name [String] The container name
+      #
+      # @return [Array] Array with cpu core ids
+      def assigned_cpu_cores(name)
+        value = self.read_config_value(name, /lxc\.cgroup\.cpuset\.cpus\s*\=(.*)$/)
+        used_cores = []
+
+        if value == false
+          return used_cores
+        end
+
+        value.split(',').each do |cpu|
+          if cpu.include?('-')
+            range = Range.new(*cpu.split('-').map(&:to_i))
+
+            range.each do |i|
+              used_cores.push(i)
+            end
+          else
+            used_cores.push(cpu.to_i)
+          end
+        end
+
+        used_cores
+      end
+
+      # Returns an array of unassigned cpu cores
+      #
+      # @param resman [ResourceManager] A ResourceManager instance
+      #
+      # @raise [ArgumentError]
+      #
+      # @return [Array]
+      def free_cpu_cores(resman)
+        raise ArgumentError, 'no valid ResourceManager instance' unless resman.is_a?(ResourceManager)
+
+        free_cores = []
+        used_cores = self.globally_assigned_cpu_cores()
+
+        (0..(resman.total_cpu_cores-1)).each do |i|
+          if used_cores.include?(i) == false
+            free_cores.push(i)
+          end
+        end
+
+        free_cores
+      end
+
+      # Generates a cpu set for a container
+      #
+      # @param count    [Integer]         Number of cpu cores to use
+      # @param resman   [ResourceManager] A ResourceManager instance
+      #
+      # @raise [RuntimeError]
+      #
+      # @return [String] cpuset string
+      def generate_cpu_set(count, resman)
+        count = count.to_i
+        free_cores = self.free_cpu_cores(resman)
+
+        if count > free_cores.count
+          raise RuntimeError, 'not enough cpu cores left'
+        end
+
+        cores_to_use = []
+
+        count.times do
+          cores_to_use.push(free_cores.shift)
+        end
+
+        cores_to_use.join(',')
+      end
+  end
+end