lxc-extra 0.0.2 → 0.0.3

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    YjA2YjFkNzA4ZTU0MzRjMjU3YjEyN2Q5ZmE4ZTYwMjAzMzNkOTMwNg==
+    ODA1YTcyNmFhODEwYmEyZTFkZDBiMjk1Y2ZkZTFiNWEwODg2ZmY0Yg==
   data.tar.gz: !binary |-
-    YmYzYTI1YWQ2OGQ3YjRiMWNhYzlhMzEwMzQ2MmUxYzUxMDdmMjNmNw==
+    OTlkNTdiNTNlNTQ3YTAwZDExZTY0NWZmYjAxMDMyZjJiMWQ4OWE3Zg==
 SHA512:
   metadata.gz: !binary |-
-    MmVhMzg0NmFlNDBlNDQ4OTZlZmQ4ZTg3N2E2NTg1YjM4ZDY2MmYyMDI2NzIz
-    YWUxODNhMGIwNDNkYzYwOWU1NGJmZjM0NTk1NmJiMDZlMjQ5MzIzMTYzNWQ2
-    MGY0MmVkYjMwM2FlZjM1NDUwYzcyZjEyOTU0ZDNiZGMwYTk5NGM=
+    YjBmYTdkNDM2OTMyZThiNTczOTE4ZDBkMDFmNmNlYjNiMmNlYTdmZTFlYjZl
+    MDIzOGMzYTNiZTAzZDFlNzlhYmRhZDc1NDc4YjY1ZjI4Y2VkOGJhMDhmMDE2
+    OGEzNjZjN2MxZGQzN2E4YjI5MGQ1MTVjZDM5Y2M1MGYzNWRiYmE=
   data.tar.gz: !binary |-
-    MDc0OTAwZGY4MmJkMWRiYTUxODU2NzFiMzFkNTBhZDYyOThjZTBjZGZlODAy
-    NWM4ZjljMGEyMDFlZWQwYjQyOGFhNTlkZWE1MjBjZTdiZjE1NTYwZDMyYWYy
-    ODZjNWQzNGFkOGNiZGI0YmVlN2U3MWE0YWIwZDU1MDRiZTU1OGM=
+    YjhiZjE1MTAyZmZiMWJhNjVlMGQ4ZTBmZWE5ZDJlNWYyNmNkNGRjYzJmODMz
+    ZGFkYjQwMTUxZGNhMmVmY2IwMzc5Y2RjNjc5OTgxMjI3Zjg4YzczNmE2Njlh
+    NTYxMjNjZWQwZTk1NDI3N2NmY2FiYzVmYjA5ODIxNWUwYjc4NjU=

data/lib/lxc/extra.rb

@@ -1,24 +1,31 @@
 require 'lxc'
 require 'lxc/extra/version'
+require 'lxc/extra/channel'
 require 'io/wait'
+require 'timeout'
 
 module LXC
   module Extra
-    def execute(&block)
+    def execute(opts= {}, &block)
+      attach_opts = opts[:attach_options] || {}
+      attach_opts[:wait] ||= true
+      timeout = opts[:timeout] || 3600
       r,w = IO.pipe
-      ret = attach(wait:true) do
+      ret = attach(attach_opts) do
         ENV.clear
         ENV['PATH'] = '/usr/bin:/bin:/usr/sbin:/sbin'
         ENV['TERM'] = 'xterm-256color'
         ENV['SHELL'] = '/bin/bash'
         r.close
         begin
-          out = block.call
-          w.write(Marshal.dump(out))
+          Timeout::timeout(timeout) do
+            out = block.call
+            w.write(Marshal.dump(out))
+          end
         rescue Exception => e
           w.write(Marshal.dump(e))
         end
-      end  
+      end
       w.close
       o = nil
       if r.ready?
@@ -28,6 +35,14 @@ module LXC
       raise o if o.is_a?(Exception)
       o
     end
+
+    def open_channel(&block)
+      channel = ::LXC::Extra::Channel.new
+      pid = attach do
+        channel.listen(&block)
+      end
+      [channel, pid]
+    end
   end
   class Container
     include Extra

data/lib/lxc/extra/channel.rb

@@ -0,0 +1,169 @@
+module LXC
+  module Extra
+    #
+    # Bidirectional Ruby communications between a host and an LXC container.
+    # It handles bidirectional communications: the host can send a message to
+    # the container using channel.send_message, and the container can send to
+    # the host using channel.send_message as well.
+    #
+    # This class is intended to be created before ct.attach and used by both
+    # the host and the container.
+    #
+    # == Shorthand Usage
+    #
+    # require 'lxc'
+    # require 'lxc/extra'
+    #
+    # container = LXC::Container.new('simple')
+    # channel, pid = container.open_channel do |host, number|
+    #   puts "received #{number} INSIDE!"
+    #   if number > 10
+    #     host.stop
+    #   else
+    #     host.send_message(number+1)
+    #   end
+    # end
+    # channel.send_message(1)
+    # channel.listen do |container, number|
+    #   puts "received #{number} OUTSIDE!"
+    #   container.send_message(number+1) unless number > 10
+    # end
+    #
+    # == Extended Usage
+    #
+    #   channel = Channel.new
+    #   ct.attach do
+    #     channel.listen do |host, number|
+    #       "received #{number} INSIDE!"
+    #       if number > 10
+    #         host.stop
+    #       else
+    #         host.send(number+1)
+    #       end
+    #     end
+    #   end
+    #   channel.listen do |container, number|
+    #     "received #{number} OUTSIDE!"
+    #     container.send(number+1)
+    #   end
+    #
+    class Channel
+      #
+      # Create a new LXC channel.
+      #
+      def initialize
+        @from_container, @to_host = IO.pipe
+        @from_host, @to_container = IO.pipe
+        @host_pid = Process.pid
+      end
+
+      attr_reader :from_container
+      attr_reader :to_host
+      attr_reader :from_host
+      attr_reader :to_container
+      attr_reader :host_pid
+
+      #
+      # Listen for data from the other side.  Loops until stop is received.
+      #
+      # == Arguments
+      # &block:: callback
+      #
+      # == Example
+      #
+      #   channel.listen do |*args|
+      #     puts "Received #{args} from the other side."
+      #   end
+      #
+      def listen(&block)
+        while true
+          args = self.next
+          if args.is_a?(Stop)
+            return
+          end
+          block.call(self, *args)
+        end
+      end
+
+      #
+      # Send a message to the other side.
+      # You may send arbitrary Ruby, which will be sent with Marshal.dump.
+      #
+      # == Arguments
+      # args:: a list of arguments to send. Arbitrary Ruby objects may be sent.
+      #        The other side's listen callback will receive these arguments.
+      #
+      def send_message(*args)
+        Marshal.dump(args, write_fd)
+      end
+
+      #
+      # Get the next result.
+      #
+      # == Arguments
+      # stop_result:: result to return when the channel wants to shut down.  Defaults to LXC::Extra::Channel::Stop.singleton
+      #
+      # == Returns
+      # Returns nextLXC::Extra::Channel::Stop instance if the channel closes.
+      def next(stop_result = Stop.singleton)
+        if read_fd.closed?
+          stop_result
+        else
+          Marshal.load(read_fd)
+        end
+      end
+
+      #
+      # Stop the channel.  Sends a message to the other side to stop it, too.
+      #
+      def stop
+        send_message(Stop.singleton)
+        @from_container.close
+        @to_host.close
+        @from_host.close
+        @to_container.close
+      end
+
+      #
+      # Pretend a message was sent from the other side.
+      #
+      # For debug purposes.
+      #
+      def pretend_message_was_sent(*args)
+        if Process.pid == @host_pid
+          Marshal.dump(args, @to_host)
+        else
+          Marshal.dump(args, @to_container)
+        end
+      end
+
+      #
+      # File descriptor that sends data to the other side.
+      #
+      def write_fd
+        if Process.pid == @host_pid
+          @to_container
+        else
+          @to_host
+        end
+      end
+
+      #
+      # File descriptor that receives data from the other side.
+      #
+      def read_fd
+        if Process.pid == @host_pid
+          @from_container
+        else
+          @from_host
+        end
+      end
+
+      class Stop
+        def self.singleton
+          @@singleton ||= Stop.new
+        end
+      end
+    end
+  end
+end

data/lib/lxc/extra/proxy_client_side.rb

@@ -0,0 +1,127 @@
+require 'lxc/extra/selector'
+
+module LXC
+  module Extra
+    #
+    # Proxy server that listens for connections on the client side and sends
+    # the data to the corresponding ProxyServerSide through an Channel.
+    #
+    # == Usage
+    #
+    #   # Forward 127.0.0.1:80 in the container to google.com from the host
+    #   channel = LXC::Extra::Channel.new
+    #   pid = container.attach do
+    #     server = TCPServer.new('127.0.0.1', 5559)
+    #     proxy = LXC::Extra::ProxyClientSide.new(channel, server)
+    #     proxy.start
+    #   end
+    #
+    #   # Here is the proxy server
+    #   proxy = LXC::Extra::ProxyServerSide.new(channel) do
+    #     TCPSocket.new('127.0.0.1', 9995)
+    #   end
+    #   proxy.start
+    #
+    class ProxyClientSide
+      #
+      # Create a new ProxyClientSide.
+      #
+      # == Arguments
+      # channel:: Channel to communicate over
+      # listen_server:: TCPServer to listen to
+      #
+      def initialize(channel, listen_server)
+        @channel = channel
+        @listen_server = listen_server
+        @sockets = {}
+      end
+
+      attr_reader :channel
+      attr_reader :listen_server
+
+      #
+      # Start forwarding connections and data.  This call will not return until
+      # stop is called.
+      #
+      def start
+        begin
+          begin
+            @selector = Selector.new
+            @selector.on_select(@listen_server, &method(:on_server_accept))
+            @selector.on_select(@channel.read_fd, &method(:on_channel_response))
+            @selector.main_loop
+          ensure
+            @sockets.values.each { |socket| socket.close }
+            @sockets = {}
+            @selector = nil
+          end
+        rescue
+          STDERR.puts("Proxy server error on client side: #{$!}\n#{$!.backtrace.join("\n")}")
+          @channel.send_message(:server_error, $!)
+          raise
+        end
+      end
+
+      #
+      # Stop forwarding connections and data.  Existing connections will be closed
+      # and a stop message will be sent to the other side.
+      #
+      def stop
+        @sockets.values.each { |socket| socket.close }
+        @sockets = {}
+        @selector = nil
+        @channel.send_message(:stop)
+      end
+
+      private
+
+      def on_server_accept(server)
+        socket = server.accept
+        @selector.on_select(socket, &method(:on_client_data))
+        @sockets[socket.fileno] = socket
+        @channel.send_message(:open, socket.fileno)
+      end
+
+      def on_client_data(socket)
+        message, *args = socket.recvmsg
+        if message.length == 0
+          @channel.send_message(:close, socket.fileno)
+          @selector.delete(socket)
+          @sockets.delete(socket.fileno)
+          socket.close
+        else
+          @channel.send_message(:data, socket.fileno, message)
+        end
+      end
+
+      def on_channel_response(read_fd)
+        message_type, fileno, *args = @channel.next(:stop)
+        begin
+          case message_type
+          when :data
+            @sockets[fileno].sendmsg(args[0])
+          when :close, :connection_error
+            @sockets[fileno].close
+            @selector.delete(@sockets[fileno])
+            @sockets.delete(fileno)
+          when :stop, :server_error
+            return :stop
+          else
+            raise "Unknown message type #{message_type} passed from server to client side proxy"
+          end
+        rescue
+          STDERR.puts("Error in on_channel_response: #{$!}\n#{$!.backtrace.join("\n")}")
+          if fileno
+            @server.send_message(:connection_error, fileno, $!) unless message_type == :close || message_type == :connection_error
+            socket = @sockets[fileno]
+            if socket
+              socket.close
+              @selector.delete(socket)
+            end
+            @sockets.delete(fileno)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/lxc/extra/proxy_server_side.rb

@@ -0,0 +1,122 @@
+require 'lxc/extra/selector'
+
+module LXC
+  module Extra
+    #
+    # Proxy server that listens for connections froom the corresponsing
+    # ProxyClientSide and sends them to the actual server.
+    #
+    # == Usage
+    #
+    #   # Forward 127.0.0.1:80 in the container to google.com from the host
+    #   channel = LXC::Extra::Channel.new
+    #   pid = container.attach do
+    #     server = TCPServer.new('127.0.0.1', 5559)
+    #     proxy = LXC::Extra::ProxyClientSide.new(channel, server)
+    #     proxy.start
+    #   end
+    #
+    #   # Here is the proxy server
+    #   proxy = LXC::Extra::ProxyServerSide.new(channel) do
+    #     TCPSocket.new('127.0.0.1', 9995)
+    #   end
+    #   proxy.start
+    #
+    class ProxyServerSide
+      #
+      # Create a new ProxyServerSide.
+      #
+      # == Arguments
+      # channel: Channel to send/receive connections from the other side.
+      # &server_connector:: block that will be called (with no arguments) when the server
+      #                     opens a new connection, to create a new connection to the
+      #                     server. Must return a socket.
+      #
+      def initialize(channel, &server_connector)
+        @channel = channel
+        @server_connector = server_connector
+      end
+
+      attr_reader :channel
+      attr_reader :server_connector
+
+      #
+      # Start forwarding connections from the other side to the server.  Blocks
+      # until stop is called.
+      #
+      def start
+        @filenos = {}
+        @sockets = {}
+        begin
+          @selector = Selector.new
+          @selector.on_select(channel.read_fd, &method(:on_channel_message))
+          @selector.main_loop
+        ensure
+          @sockets.values.each { |socket| socket.close }
+        end
+      end
+
+      #
+      # Stop forwarding connections and data.  Existing connections will be closed
+      # and a stop message will be sent to the other side.
+      #
+      def stop
+        @selector.stop
+      end
+
+      private
+
+      def on_channel_message(read_fd)
+        message_type, fileno, *args = @channel.next(:stop)
+        socket = @sockets[fileno]
+        begin
+          case message_type
+          when :open
+            socket = @server_connector.call
+            @selector.on_select(socket, &method(:on_server_response))
+            @sockets[fileno] = socket
+            @filenos[socket] = fileno
+          when :data
+            socket.sendmsg(args[0])
+          when :close, :connection_error
+            socket.close
+            @selector.delete(socket)
+            @filenos.delete(socket)
+            @sockets.delete(fileno)
+          when :stop, :server_error
+            return :stop
+          else
+            raise "Unknown message type #{message_type} passed from channel to host"
+          end
+        rescue
+          STDERR.puts("Error in on_channel_message: #{$!}\n#{$!.backtrace.join("\n")}")
+          if fileno
+            @channel.send_message(:connection_error, fileno) unless message_type == :close || message_type == :connection_error
+            if socket
+              socket.close
+              @selector.delete(socket)
+              @filenos.delete(socket)
+            end
+            @sockets.delete(fileno)
+          end
+        end
+      end
+
+      def on_server_response(socket)
+        message, *args = socket.recvmsg
+        fileno = @filenos[socket]
+        if message.length == 0
+          socket.close
+          if fileno
+            @channel.send_message(:close, fileno)
+            @sockets.delete(fileno)
+          end
+          @filenos.delete(socket)
+          @selector.delete(socket)
+        else
+          @channel.send_message(:data, fileno, message)
+        end
+      end
+    end
+  end
+end

data/lib/lxc/extra/selector.rb

@@ -0,0 +1,103 @@
+module LXC
+  module Extra
+    #
+    # Provides a way to listen to multiple disparate file descriptors with
+    # different callbacks to handle each one.
+    #
+    # == Example
+    #
+    #   require 'lxc/extra/selector'
+    #   require 'socket'
+    #
+    #   def repeat_to(socket, selector, out)
+    #     message, *other = socket.recvmsg
+    #     if message.size == 0
+    #       selector.delete(socket)
+    #       return
+    #     end
+    #     out.write(message)
+    #   end
+    #
+    #   selector = LXC::Extra::Selector.new()
+    #
+    #   # Listen on 20480 and echo output to STDOUT
+    #   server = TCPServer.new(20480)
+    #   selector.on_select(server) do |server|
+    #     socket = server.accept
+    #     selector.on_select(socket, selector, STDOUT, &method(:repeat_to))
+    #   end
+    #
+    #   # Listen on 20481 and echo output to STDERR
+    #   server = TCPServer.new(2049)
+    #   selector.on_select(server) do |server|
+    #     socket = server.accept
+    #     selector.on_select(socket, selector, STDERR, &method(:repeat_to))
+    #   end
+    #
+    #   # Do all that listening on one thread!
+    #   selector.main_loop
+    #
+    # NOTE: This is not presently thread-safe in that adds and deletes must be
+    # done on the same thread as the main_loop.
+    #
+    class Selector
+      #
+      # Create a new selector.
+      #
+      def initialize
+        @fd_callbacks = {}
+      end
+
+      #
+      # Add a file descriptor to listen on.
+      #
+      # == Arguments
+      #
+      # fd:: file descriptor to listen on.
+      # args:: optional set of arguments to pass to callback
+      # callback:: callback to call when file descriptor has data available
+      #
+      def on_select(fd, *args, &callback)
+        @fd_callbacks[fd] = {
+          :args => args,
+          :callback => callback
+        }
+      end
+
+      #
+      # Stop listening to a file descriptor.
+      #
+      # == Arguments
+      #
+      # fd:: file descriptor to stop listening to.
+      #
+      def delete(fd)
+        @fd_callbacks.delete(fd)
+      end
+
+      #
+      # Listen for any of the given file handles to be ready (with IO.select)
+      # and call their callbacks when they are.
+      #
+      def main_loop
+        begin
+          while true
+            ready = IO.select(@fd_callbacks.keys)
+            ready[0].each do |fd|
+              callback = @fd_callbacks[fd]
+              if callback
+                args = [ fd ]
+                args += callback[:args] if callback[:args]
+                if callback[:callback].call(*args) == :stop
+                  return
+                end
+              end
+            end
+          end
+        rescue
+          raise
+        end
+      end
+    end
+  end
+end

data/lib/lxc/extra/version.rb

@@ -1,5 +1,5 @@
 module LXC
   module Extra
-    VERSION = "0.0.2"
+    VERSION = "0.0.3"
   end
 end

data/spec/unit/lxc_channel_spec.rb

@@ -0,0 +1,64 @@
+require 'spec_helper'
+require 'lxc/extra/channel'
+
+describe LXC::Extra::Channel do
+
+  before(:all) do
+    c = LXC::Container.new('test')
+    c.create('ubuntu') unless c.defined?
+    c.start unless c.running?
+  end
+
+  it 'an open channel should successfully pass multiple objects' do
+    c = LXC::Container.new('test')
+    channel = LXC::Extra::Channel.new
+    pid = c.attach do
+      begin
+        channel.listen do |host, number|
+          host.send_message(number+1)
+        end
+      end
+    end
+    begin
+      results = []
+      channel.send_message(1)
+      channel.listen do |container, number|
+        results << number
+        if number > 5
+          container.stop
+        else
+          container.send_message(number)
+        end
+      end
+      Process.waitpid(pid)
+    rescue
+      Process.kill('KILL', pid)
+      raise
+    end
+    expect(results).to eq([ 2, 3, 4, 5, 6 ])
+  end
+
+  it 'container.open_channel works the same as the explicit version' do
+    c = LXC::Container.new('test')
+    channel, pid = c.open_channel do |host, number|
+      host.send_message(number+1)
+    end
+    begin
+      results = []
+      channel.send_message(1)
+      channel.listen do |container, number|
+        results << number
+        if number > 5
+          container.stop
+        else
+          container.send_message(number)
+        end
+      end
+      Process.waitpid(pid)
+    rescue
+      Process.kill('KILL', pid)
+      raise
+    end
+    expect(results).to eq([ 2, 3, 4, 5, 6 ])
+  end
+end

data/spec/unit/lxc_extra_spec.rb

@@ -29,5 +29,14 @@ describe LXC::Extra do
         ct.execute {raise TestError}
       end.to raise_error(TestError)
     end
+    it 'should respect timeout' do
+      expect do
+        ct.execute(timeout: 10) do
+          11.times do |n|
+            sleep 1
+          end
+        end
+      end.to raise_error Timeout::Error
+    end
   end
 end

data/spec/unit/lxc_proxy_spec.rb

@@ -0,0 +1,114 @@
+require 'spec_helper'
+require 'lxc/extra/channel'
+require 'lxc/extra/proxy_client_side'
+require 'lxc/extra/proxy_server_side'
+require 'lxc/extra/selector'
+require 'socket'
+
+describe 'LXC proxy' do
+
+  before(:all) do
+    c = LXC::Container.new('test')
+    c.create('ubuntu') unless c.defined?
+    c.start unless c.running?
+  end
+
+  def rescue_me(&block)
+    begin
+      block.call
+    rescue
+      STDERR.puts "ERROR in thread: #{$!}"
+      STDERR.puts $!.backtrace.join("\n")
+      raise
+    end
+  end
+
+  def safe_thread(&block)
+    Thread.new do
+      rescue_me(&block)
+    end
+  end
+
+  it 'proxy server receives multiple connections and passes data back and forth' do
+    container = LXC::Container.new('test')
+
+    threads = []
+    pids = []
+    begin
+      # Forward 127.0.0.1:80 in the container to google.com from the host
+      channel = LXC::Extra::Channel.new
+      pids << container.attach do
+        rescue_me do
+          server = TCPServer.new('127.0.0.1', 5559)
+          proxy = LXC::Extra::ProxyClientSide.new(channel, server)
+          proxy.start
+        end
+      end
+
+      # Here is the proxy server
+      threads << safe_thread do
+        proxy = LXC::Extra::ProxyServerSide.new(channel) do
+          TCPSocket.new('127.0.0.1', 9995)
+        end
+        proxy.start
+      end
+
+      # Here is the real TCP server (listener)
+      real_server = TCPServer.new('127.0.0.1', 9995)
+      threads << safe_thread do
+        selector = LXC::Extra::Selector.new
+        selector.on_select(real_server) do |server|
+          socket = server.accept
+          selector.on_select(socket) do |socket|
+            message, *other = socket.recvmsg
+            if message.size == 0
+              selector.delete(socket)
+            else
+              socket.sendmsg((message.to_i*2).to_s)
+            end
+          end
+        end
+        selector.main_loop
+      end
+
+      channel2 = LXC::Extra::Channel.new
+      # Let's open up a client in the container!
+      container.execute do
+        rescue_me do
+          socket = TCPSocket.new('127.0.0.1', 5559)
+          socket.sendmsg('10')
+          response, *other = socket.recvmsg
+          channel2.send_message(response)
+          socket.sendmsg('30')
+          response, *other = socket.recvmsg
+          channel2.send_message(response)
+          socket.close
+        end
+      end
+      container.execute do
+        rescue_me do
+          socket = TCPSocket.new('127.0.0.1', 5559)
+          socket.sendmsg('50')
+          response, *other = socket.recvmsg
+          channel2.send_message(response)
+          socket.sendmsg('70')
+          response, *other = socket.recvmsg
+          channel2.send_message(response)
+          socket.close
+        end
+      end
+      expect(channel2.next).to eq(['20'])
+      expect(channel2.next).to eq(['60'])
+      expect(channel2.next).to eq(['100'])
+      expect(channel2.next).to eq(['140'])
+    ensure
+      threads.each do |t|
+        t.kill
+      end
+      pids.each do |pid|
+
+        Process.kill(9, pid)
+      end
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lxc-extra
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.3
 platform: ruby
 authors:
 - Ranjib Dey
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-03-08 00:00:00.000000000 Z
+date: 2014-03-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ruby-lxc
@@ -79,10 +79,16 @@ files:
 - README.md
 - Rakefile
 - lib/lxc/extra.rb
+- lib/lxc/extra/channel.rb
+- lib/lxc/extra/proxy_client_side.rb
+- lib/lxc/extra/proxy_server_side.rb
+- lib/lxc/extra/selector.rb
 - lib/lxc/extra/version.rb
 - lxc-extra.gemspec
 - spec/spec_helper.rb
+- spec/unit/lxc_channel_spec.rb
 - spec/unit/lxc_extra_spec.rb
+- spec/unit/lxc_proxy_spec.rb
 homepage: https://github.com/ranjib/lxc-extra
 licenses:
 - MIT
@@ -109,4 +115,6 @@ specification_version: 4
 summary: Additional helper methods for ruby lxc binding
 test_files:
 - spec/spec_helper.rb
+- spec/unit/lxc_channel_spec.rb
 - spec/unit/lxc_extra_spec.rb
+- spec/unit/lxc_proxy_spec.rb