lxc_ssh 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: b1299d54895480465b61dca5ec7b400375465399
+  data.tar.gz: 4694ed8006155c5d7d9bc7aa5d6f360c5847a8a1
+SHA512:
+  metadata.gz: db2af76937ab694f8352c0a46f9ec049d0fd6490f4b856e3087f33a118a8d48615cf70d750a1bd1331f291db7984e419487dbf7bed1d7cf2ed255612ebafbc38
+  data.tar.gz: 22c78717be1114db31aef462339dcf3f709d5d09030a51cd95ba7945d304a7448dcd246f81decc52856fcc327840d38593d1268054b454f8feb5308a971b9bbf

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in lxc_ssh.gemspec
+gemspec

data/README.md

@@ -0,0 +1,127 @@
+# lxc_ssh
+
+lxc_ssh is a ruby gem for managing lxc host systems over an ssh connection.
+Supports LXC version 1.0 and higher. Depends on net-ssh (https://github.com/net-ssh/net-ssh).
+
+
+## Installation
+ 
+!! NOT AT RUBYGEMS.ORG YET !!
+ 
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'lxc_ssh'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install lxc_ssh
+
+## Usage
+
+First create a connection to your system over ssh (currently only the ssh default port is supported)
+and authenticate as a privileged user (lxc is installed to /usr in this case):
+
+```ruby
+con = LxcSsh::Connection.new
+con.connect('my.cool.host', 'root', nil, '/usr')
+```
+
+If no exception occured, you're ready to go.
+
+#### Get containers
+
+```ruby
+containers = con.manager.containers
+```
+
+
+#### Get specific container information
+
+```ruby
+container = con.manager.container 'my-fancy-container-name'
+```
+
+Result:
+
+```ruby
+#<LxcSsh::Container:0x00000000c7ea48 @name="my-fancy-container-name",
+                                     @pid="1234",
+                                     @state="RUNNING",
+                                     @memory_usage=0,
+                                     @memory_limit=0,
+                                     @cpu_shares=1024,
+                                     @cpu_usage="23994168167209",
+                                     @ip="192.168.0.2">
+```
+
+#### Get container config
+
+```ruby
+config = con.manager.container_config 'my-fancy-container-name'
+puts config['lxc.network.veth.pair']
+```
+
+
+#### Update config items
+
+```ruby
+config = con.manager.container_config 'my-fancy-container-name'
+config['lxc.network.veth.pair'] = 'none'
+con.manager.write_config 'my-fancy-container-name', config
+```
+
+### Create container
+
+```ruby
+con.manager.create_container 'testcontainer', 'gentoo'
+```
+
+#### Start container
+
+```ruby
+con.manager.start_container 'testcontainer'
+```
+
+#### Stop container
+
+```ruby
+con.manager.stop_container 'testcontainer'
+```
+
+#### Destroy container
+
+```ruby
+con.manager.destroy_container 'testcontainer'
+```
+
+#### Create container
+
+```ruby
+con.manager.create_container 'testcontainer', 'gentoo'
+```
+
+#### Get templates
+
+```ruby
+con.manager.template_names
+```
+
+#### Get template help text
+
+```ruby
+puts con.manager.template_help 'archlinux'
+```
+
+## Contributing
+
+1. Fork it ( https://github.com/dprandzioch/lxc_ssh/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+

data/lib/lxc_ssh.rb

@@ -0,0 +1,12 @@
+require 'lxc_ssh/version.rb'
+require "lxc_ssh/connection.rb"
+require "lxc_ssh/container.rb"
+require "lxc_ssh/container_info.rb"
+require "lxc_ssh/container_config.rb"
+require "lxc_ssh/manager.rb"
+require "lxc_ssh/manager/specific_manager10.rb"
+
+module LxcSsh
+  LIBNAME = 'lxc_ssh'
+  LIBDIR = File.expand_path("../#{LIBNAME}", __FILE__)
+end

data/lib/lxc_ssh/connection.rb

@@ -0,0 +1,54 @@
+require 'net/ssh'
+
+module LxcSsh
+  class Connection
+
+    attr_reader :manager
+
+    # Initializes the connection
+    def initialize
+      @session = nil
+      @manager = nil
+      @lxc_version = nil
+      @lxc_path = nil
+    end
+
+    # Connects to the host system via ssh and authenticates by
+    # either public key or password authentication
+    #
+    # @param hostname [String] SSH Hostname
+    # @param username [String] SSH Username
+    # @param password [String] SSH Password
+    # @param lxc_path [String] LXC installation path (default: /usr)
+    def connect(hostname, username, password, lxc_path = '/usr')
+      if @password.nil?
+        # pubkey
+        @session = Net::SSH.start(hostname, username)
+      else
+        @session = Net::SSH.start(hostname, username, password)
+      end
+
+      @lxc_path = lxc_path
+      @lxc_version = obtain_version
+      @manager = self.init_manager
+    end
+
+    # Obtains the version number of the lxc installation
+    #
+    # @return string
+    def obtain_version
+      output = @session.exec! @lxc_path + "/bin/lxc-start --version"
+
+      output.strip
+    end
+
+    # Initializes the lxc manager object
+    def init_manager
+      if @lxc_version.nil?
+        raise 'no lxc version set, please detect and set the lxc version using detect_lxc_version'
+      end
+
+      @manager = LxcSsh::Manager.new(@session, @lxc_version, @lxc_path)
+    end
+  end
+end

data/lib/lxc_ssh/container.rb

@@ -0,0 +1,35 @@
+module LxcSsh
+  class Container
+
+    attr_accessor :name,
+                  :state,
+                  :pid,
+                  :ip,
+                  :memory_usage,
+                  :memory_limit,
+                  :cpu_shares,
+                  :cpu_usage
+
+    # Checks if the container is running
+    #
+    # @return [Boolean]
+    def running?
+      @state == 'RUNNING'
+    end
+
+    # Checks if the container is frozen
+    #
+    # @return [Boolean]
+    def frozen?
+      @state == 'FROZEN'
+    end
+
+    # Checks if the container is stopped
+    #
+    # @return [Boolean]
+    def stopped?
+      !running? && !frozen?
+    end
+
+  end
+end

data/lib/lxc_ssh/container_config.rb

@@ -0,0 +1,85 @@
+module LxcSsh
+  class ContainerConfig
+
+    # Loads the configuration object with the config files' content
+    #
+    # @param data [String] config file contents
+    def initialize(data)
+      @content = parse(data)
+    end
+
+    # Loads the configuration object with the config files' content
+    #
+    # @param data [String] config file contents
+    # @return [Hash]
+    def parse(data)
+      items = {}
+
+      # only lines starting with 'lxc.'
+      lines = data.lines.map(&:strip).select do |line|
+        line.start_with?('lxc.')
+      end
+
+      # process lines
+      lines.each do |line|
+        key, value = line.split('=').map(&:strip)
+
+        if items.key?(key) == false
+          items[key] = []
+        end
+
+        items[key] << value
+      end
+
+      items.each_pair do |key, val|
+        if val.length == 1
+          items[key] = val.first
+        end
+      end
+
+      items
+    end
+
+    # Array-style accessor (getter)
+    #
+    # @param key [String] key of the hash
+    # @return [Object]
+    def [](key)
+      if key.kind_of?(String) == false
+        raise ArgumentError, 'key must be a string'
+      end
+
+      @content[key]
+    end
+
+    # Array-style accessor (setter)
+    #
+    # @param key [String] key of the hash
+    # @param val [Object] value to set
+    def []=(key, val)
+      @content[key] = val
+    end
+
+    # Generates a config string from the current object context
+    #
+    # @return [Hash]
+    def config_contents
+      lines = []
+
+      @content.each_pair do |key, value|
+        if value.class == Array
+          # multiple values assigned for a single key, order is important!
+          lines << value.map do |val|
+            key + ' = ' + val
+          end
+        else
+          line = key + ' = ' + value
+          lines << line
+        end
+      end
+
+      lines.join('\n')
+    end
+
+  end
+end

data/lib/lxc_ssh/container_info.rb

@@ -0,0 +1,7 @@
+module LxcSsh
+  class ContainerInfo
+
+    attr_accessor :pid, :state
+
+  end
+end

data/lib/lxc_ssh/manager.rb

@@ -0,0 +1,114 @@
+module LxcSsh
+  class Manager
+
+    # Initializes the lxc manager by creating an instance of the version-specific
+    # lxc manager for the detected version
+    #
+    # @param session [SSH::Connection::Session] ssh session
+    # @param lxc_version [String] lxc version string
+    # @param lxc_path [String] lxc installation path
+    def initialize(session, lxc_version, lxc_path)
+      @lxc_path = lxc_path
+      @specific_manager = nil
+
+      # LXC APIs mac change in the future, therefore a version specific adapter
+      # must be used
+      if    Gem::Version.new(lxc_version) >= Gem::Version.new('1.0')
+        @specific_manager = LxcSsh::SpecificManager10.new(session, lxc_path)
+      # other version checks go here
+      else
+        raise 'lxc versions < 1.0 are not supported'
+      end
+    end
+
+    # Returns an array of lxc containers
+    #
+    # @return [Array]
+    def container_names
+      @specific_manager.container_names
+    end
+
+    # Returns an array containing objects with container metadata
+    #
+    # @return [Array]
+    def containers
+      @specific_manager.containers
+    end
+
+    # Returns a LxcSsh::ContainerConfig object for the container name
+    #
+    # @return [LxcSsh::ContainerConfig]
+    def container_config(name)
+      @specific_manager.container_config name
+    end
+
+    # Returns an LxcSsh::Container object for the given container name
+    #
+    # @return [LxcSsh::Container]
+    def container(name)
+      @specific_manager.get_container_obj name
+    end
+
+    # Writes the config file contents back to the container config
+    #
+    # @param container_name [String] the container to use
+    # @param config [String] configuration string to save
+    def write_config(name, config)
+      @specific_manager.write_config name, config
+    end
+
+    # Returns an array containing all templates
+    #
+    # @todo check path
+    #
+    # @return [Array]
+    def template_names
+      @specific_manager.template_names
+    end
+
+    # Returns the template help text for a given template name
+    #
+    # @param template_name [String] template to use (without 'lxc-'-prefix)
+    # @return [String]
+    def template_help(name)
+      @specific_manager.template_help name
+    end
+
+    # Creates a container with the default configuration and additional template options
+    # and returns the output as a string
+    #
+    # @param name [String] container name
+    # @param template [String] template name (without 'lxc-'-prefix)
+    # @param template_options [String] additional template options
+    #
+    # @return [String]
+    def create_container(name, template, template_options = nil)
+      @specific_manager.create_container name, template, template_options
+    end
+
+    # Starts a container with the given name
+    #
+    # @param name [String] container name
+    # @return [Boolean]
+    def start_container(name)
+      @specific_manager.start_container name
+    end
+
+    # Stops a container
+    #
+    # @param name [String] container name
+    # @return [Boolean]
+    def stop_container(name)
+      @specific_manager.stop_container name
+    end
+
+    # Destroys a container with the given name
+    #
+    # @param name [String] container name
+    # @return [Boolean]
+    def destroy_container(name)
+      @specific_manager.destroy_container name
+    end
+
+  end
+end

data/lib/lxc_ssh/manager/specific_manager10.rb

@@ -0,0 +1,244 @@
+module LxcSsh
+  class SpecificManager10
+
+    # Initializes the manager
+    #
+    # @param session [SSH::Connection::Session] ssh session
+    # @param lxc_path [String] lxc installation path
+    def initialize(session, lxc_path)
+      @session = session
+      @lxc_path = lxc_path
+    end
+
+    # Returns an array of lxc containers
+    #
+    # @return [Array]
+    def container_names
+      result = @session.exec! @lxc_path + '/bin/lxc-ls'
+
+      result.lines.map(&:strip).uniq
+    end
+
+    # Returns an array containing objects with container metadata
+    #
+    # @return [Array]
+    def containers
+      containers = []
+
+      container_names.each do |name|
+        containers << get_container_obj(name)
+      end
+
+      containers
+    end
+
+    # Returns an LxcSsh::Container object for the given container name
+    #
+    # @return [LxcSsh::Container]
+    def get_container_obj(name)
+      container = Container.new
+      container.name = name
+
+      info = info(name)
+      container.pid = info.pid
+      container.state = info.state
+
+      container.memory_usage = run_cmd("lxc-cgroup", name, "memory.usage_in_bytes").strip.to_i
+      container.memory_limit = run_cmd("lxc-cgroup", name, "memory.limit_in_bytes").strip.to_i
+      container.cpu_shares = run_cmd("lxc-cgroup", name, "cpu.shares").strip.to_i
+      container.cpu_usage = cpu_usage name
+      container.ip = ip_addr name
+
+      container
+    end
+
+    # Returns a LxcSsh::ContainerConfig object for the container name
+    #
+    # @return [LxcSsh::ContainerConfig]
+    def container_config(name)
+      contents = config_contents name
+
+      ContainerConfig.new contents
+    end
+
+    # Writes the config file contents back to the container config
+    #
+    # @todo verify function
+    # @todo escape contents variable
+    #
+    # @param container_name [String] the container to use
+    # @param config [String] configuration string to save
+    def write_config(container_name, config)
+      if !config.kind_of?(ContainerConfig)
+        raise ArgumentError, "config must be a instance of ContainerConfig"
+      end
+
+      contents = config.config_contents
+
+      @session.exec! "echo -e '" + contents + "' > " + config_path(container_name)
+    end
+
+    # Returns an array containing all templates
+    #
+    # @todo check path
+    #
+    # @return [Array]
+    def template_names
+      output = @session.exec! "ls -1 " + @lxc_path + "/share/lxc/templates/"
+      output.gsub! 'lxc-', ''
+
+      result = output.lines.map(&:strip).uniq
+
+      result
+    end
+
+    # Returns the template help text for a given template name
+    #
+    # @param template_name [String] template to use (without 'lxc-'-prefix)
+    # @return [String]
+    def template_help(template_name)
+      output = run_cmd("lxc-create", nil, "-t lxc-#{template_name} -h")
+
+      output
+    end
+
+    # Creates a container with the default configuration and additional template options
+    # and returns the output as a string
+    #
+    # @param name [String] container name
+    # @param template [String] template name (without 'lxc-'-prefix)
+    # @param template_options [String] additional template options
+    #
+    # @return [String]
+    def create_container(name, template, template_options = nil)
+      args = "-t #{template}"
+
+      if template_options.nil? == false
+        args += " -- #{template_options}"
+      end
+
+      output = run_cmd("lxc-create", name, args)
+
+      output
+    end
+
+    # Starts a container with the given name
+    #
+    # @param name [String] container name
+    # @return [Boolean]
+    def start_container(name)
+      output = run_cmd("lxc-start", name, '-d')
+
+      output.nil?
+    end
+
+    # Stops a container
+    #
+    # @param name [String] container name
+    # @return [Boolean]
+    def stop_container(name)
+      output = run_cmd("lxc-stop", name)
+
+      output.nil?
+    end
+
+    # Destroys a container with the given name
+    #
+    # @param name [String] container name
+    # @return [Boolean]
+    def destroy_container(name)
+      output = run_cmd("lxc-destroy", name)
+
+      output.nil?
+    end
+
+    protected
+      # Executes a lxc command
+      #
+      # @param lxc_binary [String] lxc binary name
+      # @param container_name [String] container name (if needed, otherwise nil)
+      # @param params [String] additional parameter string to append
+      # @return [String]
+      def run_cmd(xlc_binary, container_name = nil, params = nil)
+        cmd = @lxc_path + '/bin/' + xlc_binary
+
+        if container_name.nil? == false
+          cmd += ' -n ' + container_name
+        end
+
+        cmd += ' '
+
+        if params.nil? == false
+          cmd += params
+        end
+
+        @session.exec!(cmd)
+      end
+
+      # Loads the lxc container path using lxc-config
+      #
+      # @return [String]
+      def container_path(name)
+        output = run_cmd("lxc-config", nil, "lxc.lxcpath").strip
+
+        "#{output}/#{name}"
+      end
+
+      # Returns the config file path for a given container
+      #
+      # @return [String]
+      def config_path(name)
+        container_path(name) + '/config'
+      end
+
+      # Obtains the contents of a container config file
+      #
+      # @return [String]
+      def config_contents(name)
+        @session.exec! 'cat ' + config_path(name)
+      end
+
+      # Returns the containers current cpu usage
+      #
+      # @return [String]
+      def cpu_usage(name)
+        result = run_cmd("lxc-cgroup", name, "cpuacct.usage").strip
+
+        result
+      end
+
+      # Returns the containers ip address
+      #
+      # @todo what happens if multiple ip addresses are configured
+      #
+      # @param name [String] container name
+      # @return [String]
+      def ip_addr(name)
+        output = run_cmd("lxc-info", name, "-i")
+
+        if output.nil?
+          return nil
+        end
+
+        result = output.scan(/^IP:\s+([0-9.]+)$/).flatten
+
+        result.first.nil? || result.first.empty? ? nil : result.first
+      end
+
+      # Returns a LxcSsh::ContainerInfo object containing the most essential information.
+      #
+      # @param name [String] container name
+      # @return [LxcSsh::ContainerInfo]
+      def info(name)
+        output = run_cmd("lxc-info", name)
+        result = output.scan(/^State:\s+([\w]+)|PID:\s+(-?[\d]+)$/).flatten
+
+        ci = ContainerInfo.new
+        ci.state = result.first
+        ci.pid = result.last
+
+        ci
+      end
+
+  end
+end

data/lib/lxc_ssh/version.rb

@@ -0,0 +1,3 @@
+module LxcSsh
+  VERSION = "0.0.1"
+end

metadata

@@ -0,0 +1,98 @@
+--- !ruby/object:Gem::Specification
+name: lxc_ssh
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- David Prandzioch
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-08-26 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: net-ssh
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.9'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.9'
+description: lxc_ssh is a ruby gem for managing lxc host systems over an ssh connection.
+  Supports LXC version 1.0 and higher. Depends on net-ssh.
+email:
+- david@backport.net
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- Gemfile
+- README.md
+- Rakefile
+- lib/lxc_ssh.rb
+- lib/lxc_ssh/connection.rb
+- lib/lxc_ssh/container.rb
+- lib/lxc_ssh/container_config.rb
+- lib/lxc_ssh/container_info.rb
+- lib/lxc_ssh/manager.rb
+- lib/lxc_ssh/manager/specific_manager10.rb
+- lib/lxc_ssh/version.rb
+homepage: https://github.com/dprandzioch/lxc_ssh
+licenses:
+- GPL-2.0
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: LXC CLI wrapper using SSH
+test_files: []