warden-client 0.1.0

data/Gemfile

@@ -0,0 +1,10 @@
+source "http://rubygems.org"
+
+gemspec
+
+gem "rake"
+gem "warden-protocol", :path => "../warden-protocol"
+
+group :spec do
+  gem "rspec"
+end

data/README.md

@@ -0,0 +1,13 @@
+# warden-client
+
+> This README describes a **client** component. Please refer to the top
+> level [README][tlr] for an overview of all components.
+
+[tlr]: /README.md
+
+## License
+
+The project is licensed under the Apache 2.0 license (see the
+[`LICENSE`][license] file in the root directory of the repository).
+
+[license]: /LICENSE

data/Rakefile

@@ -0,0 +1,8 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+require "rspec/core/version"
+
+desc "Run all examples"
+RSpec::Core::RakeTask.new(:spec) do |t|
+  t.rspec_opts = %w[--color --format documentation]
+end

data/lib/warden/client.rb

@@ -0,0 +1,115 @@
+require "socket"
+require "warden/protocol"
+require "warden/client/v1"
+
+module Warden
+
+  class Client
+
+    class Error       < StandardError; end
+    class ServerError < Error; end
+
+    attr_reader :path
+
+    def initialize(path)
+      @path = path
+      @v1mode = false
+    end
+
+    def connected?
+      !@sock.nil?
+    end
+
+    def connect
+      raise "already connected" if connected?
+      @sock = ::UNIXSocket.new(path)
+    end
+
+    def disconnect
+      raise "not connected" unless connected?
+      @sock.close rescue nil
+      @sock = nil
+    end
+
+    def reconnect
+      disconnect if connected?
+      connect
+    end
+
+    def io
+      rv = yield
+      if rv.nil?
+        disconnect
+        raise ::EOFError
+      end
+
+      rv
+    end
+
+    def read
+      length = io { @sock.gets }
+      data = io { @sock.read(length.to_i) }
+
+      # Discard \r\n
+      io { @sock.read(2) }
+
+      response = Warden::Protocol::Message.decode(data).response
+
+      # Raise error replies
+      if response.is_a?(Warden::Protocol::ErrorResponse)
+        raise Warden::Client::ServerError.new(response.message)
+      end
+
+      if @v1mode
+        response = V1.response_to_v1(response)
+      end
+
+      response
+    end
+
+    def write(request)
+      if request.kind_of?(Array)
+        @v1mode = true
+        request = V1.request_from_v1(request.dup)
+      end
+
+      unless request.kind_of?(Warden::Protocol::BaseRequest)
+        raise "Expected #kind_of? Warden::Protocol::BaseRequest"
+      end
+
+      data = request.wrap.encode.to_s
+      @sock.write data.length.to_s + "\r\n"
+      @sock.write data + "\r\n"
+    end
+
+    def stream(request, &blk)
+      unless request.is_a?(Warden::Protocol::StreamRequest)
+        msg = "Expected argument to be of type:"
+        msg << "'#{Warden::Protocol::StreamRequest}'"
+        msg << ", but received: '#{request.class}'."
+        raise ArgumentError, msg
+      end
+
+      response = call(request)
+      while response.exit_status.nil?
+        blk.call(response)
+        response = read
+      end
+
+      response
+    end
+
+    def call(request)
+      write(request)
+      read
+    end
+
+    def method_missing(sym, *args, &blk)
+      klass_name = sym.to_s.gsub(/(^|_)([a-z])/) { $2.upcase }
+      klass_name += "Request"
+      klass = Warden::Protocol.const_get(klass_name)
+
+      call(klass.new(*args))
+    end
+  end
+end

data/lib/warden/client/v1.rb

@@ -0,0 +1,286 @@
+require "warden/protocol"
+
+module Warden
+  class Client
+    class V1
+      def self.request_from_v1(args)
+        command = args.shift
+
+        m = "convert_#{command}_request".downcase
+        if respond_to?(m)
+          send(m, args)
+        else
+          raise "Unknown command: #{command.upcase}"
+        end
+      end
+
+      def self.response_to_v1(response)
+        klass_name = response.class.name.split("::").last
+        klass_name = klass_name.gsub(/Response$/, "")
+        klass_name = klass_name.gsub(/(.)([A-Z])/) { |m| "#{m[0]}_#{m[1]}" }
+        klass_name = klass_name.downcase
+
+        m = "convert_#{klass_name}_response".downcase
+        if respond_to?(m)
+          send(m, response)
+        else
+          raise "Unknown response: #{response.class.name.split("::").last}"
+        end
+      end
+
+      private
+
+      def self.convert_create_request(args)
+        request = Protocol::CreateRequest.new
+        config = args.shift || {}
+
+        config.each do |key, value|
+          case key
+          when "bind_mounts"
+            bind_mounts = value.map do |src_path, dst_path, mode|
+              bind_mount = Protocol::CreateRequest::BindMount.new
+              bind_mount.src_path = src_path
+              bind_mount.dst_path = dst_path
+
+              if mode.kind_of?(Hash)
+                mode = mode["mode"]
+              end
+
+              bind_mount.mode = Protocol::CreateRequest::BindMount::Mode.const_get(mode.to_s.upcase)
+              bind_mount
+            end
+
+            request.bind_mounts = bind_mounts
+          when "grace_time"
+            request.grace_time = Integer(value)
+          end
+        end
+
+        request
+      end
+
+      def self.convert_create_response(response)
+        response.handle
+      end
+
+      def self.convert_stop_request(args)
+        request = Protocol::StopRequest.new
+        request.handle = args.shift
+        request
+      end
+
+      def self.convert_stop_response(response)
+        "ok"
+      end
+
+      def self.convert_destroy_request(args)
+        request = Protocol::DestroyRequest.new
+        request.handle = args.shift
+        request
+      end
+
+      def self.convert_destroy_response(response)
+        "ok"
+      end
+
+      def self.convert_info_request(args)
+        request = Protocol::InfoRequest.new
+        request.handle = args.shift
+        request
+      end
+
+      def self.convert_info_response(response)
+        stringify_hash response.to_hash
+      end
+
+      def self.convert_spawn_request(args)
+        request = Protocol::SpawnRequest.new
+        request.handle = args.shift
+        request.script = args.shift
+        request
+      end
+
+      def self.convert_spawn_response(response)
+        response.job_id
+      end
+
+      def self.convert_link_request(args)
+        request = Protocol::LinkRequest.new
+        request.handle = args.shift
+        request.job_id = Integer(args.shift)
+        request
+      end
+
+      def self.convert_link_response(response)
+        [response.exit_status, response.stdout, response.stderr]
+      end
+
+      def self.convert_stream_request(args)
+        request = Protocol::StreamRequest.new
+        request.handle = args.shift
+        request.job_id = Integer(args.shift)
+        request
+      end
+
+      def self.convert_stream_response(response)
+        [response.name, response.data, response.exit_status]
+      end
+
+      def self.convert_run_request(args)
+        request = Protocol::RunRequest.new
+        request.handle = args.shift
+        request.script = args.shift
+        request
+      end
+
+      def self.convert_run_response(response)
+        [response.exit_status, response.stdout, response.stderr]
+      end
+
+      def self.convert_net_request(args)
+        request = nil
+        handle = args.shift
+        direction = args.shift
+
+        case direction
+        when "in"
+          request = Protocol::NetInRequest.new
+          request.handle = handle
+        when "out"
+          request = Protocol::NetOutRequest.new
+          request.handle = handle
+
+          network, port = args.shift.split(":", 2)
+          request.network = network
+          request.port = Integer(port)
+        else
+          raise "Unknown net direction: #{direction}"
+        end
+
+        request
+      end
+
+      def self.convert_net_in_response(response)
+        stringify_hash response.to_hash
+      end
+
+      def self.convert_net_out_response(response)
+        "ok"
+      end
+
+      def self.convert_copy_request(args)
+        request   = nil
+        handle    = args.shift
+        direction = args.shift
+        src_path  = args.shift
+        dst_path  = args.shift
+        owner     = args.shift
+
+        attributes = {
+          :handle => handle,
+          :src_path => src_path,
+          :dst_path => dst_path
+        }
+
+        case direction
+        when "in"
+          request = Protocol::CopyInRequest.new(attributes)
+        when "out"
+          request = Protocol::CopyOutRequest.new(attributes)
+          request.owner = owner if owner
+        else
+          raise "Unknown copy direction: #{direction}"
+        end
+
+        request
+      end
+
+      def self.convert_copy_in_response(response)
+        "ok"
+      end
+
+      def self.convert_copy_out_response(response)
+        "ok"
+      end
+
+      def self.convert_limit_request(args)
+        request = nil
+        handle  = args.shift
+        limit   = args.shift
+
+        attributes = {
+          :handle => handle,
+        }
+
+        case limit
+        when "mem"
+          request = Protocol::LimitMemoryRequest.new(attributes)
+          request.limit_in_bytes = Integer(args.shift) unless args.empty?
+        when "disk"
+          request = Protocol::LimitDiskRequest.new(attributes)
+          request.byte = Integer(args.shift) unless args.empty?
+        when "bandwidth"
+          request = Protocol::LimitBandwidthRequest.new(attributes)
+          request.rate = Integer(args.shift) unless args.empty?
+          request.burst = Integer(args.shift) unless args.empty?
+        else
+          raise "Unknown limit: #{limit}"
+        end
+
+        request
+      end
+
+      def self.convert_limit_memory_response(response)
+        response.limit_in_bytes
+      end
+
+      def self.convert_limit_disk_response(response)
+        response.byte
+      end
+
+      def self.convert_limit_bandwidth_response(response)
+        "rate: #{response.rate} burst: #{response.burst}"
+      end
+
+      def self.convert_ping_request(args)
+        request = Protocol::PingRequest.new
+        request
+      end
+
+      def self.convert_ping_response(response)
+        "pong"
+      end
+
+      def self.convert_list_request(args)
+        request = Protocol::ListRequest.new
+        request
+      end
+
+      def self.convert_list_response(response)
+        response.handles
+      end
+
+      def self.convert_echo_request(args)
+        request = Protocol::EchoRequest.new
+        request.message = args.shift
+        request
+      end
+
+      def self.convert_echo_response(response)
+        response.message
+      end
+
+      private
+
+      def self.stringify_hash(hash)
+        Hash[hash.map do |key, value|
+          if value.kind_of?(Hash)
+            value = stringify_hash(value)
+          end
+
+          [key.to_s, value]
+        end]
+      end
+    end
+  end
+end

data/lib/warden/client/version.rb

@@ -0,0 +1,5 @@
+module Warden
+  class Client
+    VERSION = "0.1.0"
+  end
+end

data/spec/client/v1_spec.rb

@@ -0,0 +1,447 @@
+require "spec_helper"
+require "warden/client/v1"
+
+describe Warden::Client::V1 do
+  def to_request(args)
+    described_class.request_from_v1(args)
+  end
+
+  def to_response(response)
+    described_class.response_to_v1(response)
+  end
+
+  describe "create" do
+    describe "request" do
+      describe "bind_mount parameter" do
+        it "should use src and dst parameters" do
+          request = to_request [
+            "create",
+            { "bind_mounts" => [["/src", "/dst", "ro"]] },
+          ]
+
+          request.bind_mounts.should have(1).bind_mount
+
+          bind_mount = request.bind_mounts.first
+          bind_mount.src_path.should == "/src"
+          bind_mount.dst_path.should == "/dst"
+        end
+
+        ["ro", { "mode" => "ro" }].each do |mode|
+          it "should convert ro mode when passed as #{mode.inspect}"  do
+            request = to_request [
+              "create",
+              { "bind_mounts" => [["/src", "/dst", mode]] },
+            ]
+
+            request.bind_mounts.should have(1).bind_mount
+
+            bind_mount = request.bind_mounts.first
+            bind_mount.src_path.should == "/src"
+            bind_mount.dst_path.should == "/dst"
+            bind_mount.mode.should == Warden::Protocol::CreateRequest::BindMount::Mode::RO
+          end
+        end
+
+        ["rw", { "mode" => "rw" }].each do |mode|
+          it "should convert rw mode when passed as #{mode.inspect}" do
+            request = to_request [
+              "create",
+              { "bind_mounts" => [["/src", "/dst", "rw"]] },
+            ]
+
+            request.bind_mounts.first.mode.should ==
+              Warden::Protocol::CreateRequest::BindMount::Mode::RW
+          end
+        end
+
+        ["rx", { "mode" => "rx" }].each do |mode|
+          it "should raise on an invalid mode when passed as #{mode.inspect}" do
+            expect do
+              to_request [
+                "create",
+                { "bind_mounts" => [["/src", "/dst", "rx"]] },
+              ]
+            end.to raise_error
+          end
+        end
+      end
+
+      describe "grace_time parameter" do
+        it "should be converted to an integer" do
+          request = to_request [
+            "create",
+            { "grace_time" => 1.1 },
+          ]
+
+          request.grace_time.should == 1
+        end
+
+        it "should raise on an invalid value" do
+          expect do
+            to_request [
+              "create",
+              { "grace_time" => "invalid" },
+            ]
+          end.to raise_error
+        end
+      end
+    end
+
+    describe "response" do
+      it "should return the handle" do
+        response = to_response \
+          Warden::Protocol::CreateResponse.new(:handle => "handle")
+        response.should == "handle"
+      end
+    end
+  end
+
+  describe "stop" do
+    describe "request" do
+      subject { to_request ["stop", "handle"] }
+
+      its(:class)  { should == Warden::Protocol::StopRequest }
+      its(:handle) { should == "handle" }
+    end
+
+    describe "response" do
+      it "should always be ok" do
+        response = to_response \
+          Warden::Protocol::StopResponse.new
+        response.should == "ok"
+      end
+    end
+  end
+
+  describe "destroy" do
+    describe "request" do
+      subject { to_request ["destroy", "handle"] }
+
+      its(:class)  { should == Warden::Protocol::DestroyRequest }
+      its(:handle) { should == "handle" }
+    end
+
+    describe "response" do
+      it "should always be ok" do
+        response = to_response \
+          Warden::Protocol::DestroyResponse.new
+        response.should == "ok"
+      end
+    end
+  end
+
+  describe "info" do
+    describe "request" do
+      subject { to_request ["info", "handle"] }
+
+      its(:class)  { should == Warden::Protocol::InfoRequest }
+      its(:handle) { should == "handle" }
+    end
+
+    describe "response" do
+      let(:response) do
+        to_response \
+          Warden::Protocol::InfoResponse.new({
+            :state => "state",
+            :memory_stat => Warden::Protocol::InfoResponse::MemoryStat.new({
+              :cache => 1,
+              :rss => 2,
+            })
+          })
+      end
+
+      it "should return a hash" do
+        response.should be_a(Hash)
+      end
+
+      it "should stringify keys" do
+        response["state"].should == "state"
+      end
+
+      it "should stringify keys of nested hashes" do
+        response["memory_stat"]["cache"].should == 1
+        response["memory_stat"]["rss"].should == 2
+      end
+    end
+  end
+
+  describe "spawn" do
+    describe "request" do
+      subject { to_request ["spawn", "handle", "echo foo"] }
+
+      its(:class)  { should == Warden::Protocol::SpawnRequest }
+      its(:handle) { should == "handle" }
+      its(:script) { should == "echo foo" }
+    end
+
+    describe "response" do
+      it "should return job_id" do
+        response = to_response \
+          Warden::Protocol::SpawnResponse.new(:job_id => 3)
+        response.should == 3
+      end
+    end
+  end
+
+  describe "link" do
+    describe "request" do
+      subject { to_request ["link", "handle", "1"] }
+
+      its(:class)  { should == Warden::Protocol::LinkRequest }
+      its(:handle) { should == "handle" }
+      its(:job_id) { should == 1 }
+    end
+
+    describe "response" do
+      it "should return a 3-element tuple" do
+        response = to_response \
+          Warden::Protocol::LinkResponse.new(
+            :exit_status => 255,
+            :stdout => "stdout",
+            :stderr => "stderr"
+          )
+
+        response[0].should == 255
+        response[1].should == "stdout"
+        response[2].should == "stderr"
+      end
+    end
+  end
+
+  describe "stream" do
+    describe "request" do
+      subject { to_request ["stream", "handle", "1"] }
+
+      its(:class)  { should == Warden::Protocol::StreamRequest }
+      its(:handle) { should == "handle" }
+      its(:job_id) { should == 1 }
+    end
+
+    describe "response" do
+      it "should return a 3-element tuple" do
+        response = to_response \
+          Warden::Protocol::StreamResponse.new(
+            :name => "stdout",
+            :data => "data",
+            :exit_status => 25,
+          )
+
+        response[0].should == "stdout"
+        response[1].should == "data"
+        response[2].should == 25
+      end
+    end
+  end
+
+  describe "run" do
+    describe "request" do
+      subject { to_request ["run", "handle", "echo foo"] }
+
+      its(:class)  { should == Warden::Protocol::RunRequest }
+      its(:handle) { should == "handle" }
+      its(:script) { should == "echo foo" }
+    end
+
+    describe "response" do
+      it "should return a 3-element tuple" do
+        response = to_response \
+          Warden::Protocol::RunResponse.new(
+            :exit_status => 255,
+            :stdout => "stdout",
+            :stderr => "stderr"
+          )
+
+        response[0].should == 255
+        response[1].should == "stdout"
+        response[2].should == "stderr"
+      end
+    end
+  end
+
+  describe "net" do
+    describe "request (in)" do
+      subject { to_request ["net", "handle", "in"] }
+
+      its(:class)  { should == Warden::Protocol::NetInRequest }
+      its(:handle) { should == "handle" }
+    end
+
+    describe "request (out)" do
+      subject { to_request ["net", "handle", "out", "network:1234"] }
+
+      its(:class)   { should == Warden::Protocol::NetOutRequest }
+      its(:handle)  { should == "handle" }
+      its(:network) { should == "network" }
+      its(:port)    { should == 1234 }
+    end
+
+    describe "response (in)" do
+      it "should return a hash with both properties" do
+        response = to_response \
+          Warden::Protocol::NetInResponse.new(
+            :host_port => 1234,
+            :container_port => 2345,
+          )
+
+        response["host_port"].should == 1234
+        response["container_port"].should == 2345
+      end
+    end
+
+    describe "response (out)" do
+      it "should always be ok" do
+        response = to_response \
+          Warden::Protocol::NetOutResponse.new
+        response.should == "ok"
+      end
+    end
+  end
+
+  describe "copy" do
+    describe "request (in)" do
+      subject { to_request ["copy", "handle", "in", "/src", "/dst"] }
+
+      its(:class)    { should == Warden::Protocol::CopyInRequest }
+      its(:handle)   { should == "handle" }
+      its(:src_path) { should == "/src" }
+      its(:dst_path) { should == "/dst" }
+    end
+
+    describe "request (out)" do
+      subject { to_request ["copy", "handle", "out", "/src", "/dst", "owner"] }
+
+      its(:class)    { should == Warden::Protocol::CopyOutRequest }
+      its(:handle)   { should == "handle" }
+      its(:src_path) { should == "/src" }
+      its(:dst_path) { should == "/dst" }
+      its(:owner)    { should == "owner" }
+    end
+
+    describe "response (in)" do
+      it "should always be ok" do
+        response = to_response \
+          Warden::Protocol::CopyInResponse.new
+        response.should == "ok"
+      end
+    end
+
+    describe "response (out)" do
+      it "should always be ok" do
+        response = to_response \
+          Warden::Protocol::CopyOutResponse.new
+        response.should == "ok"
+      end
+    end
+  end
+
+  describe "limit" do
+    describe "request (mem)" do
+      describe "without limit" do
+        subject { to_request ["limit", "handle", "mem"] }
+
+        its(:class)          { should == Warden::Protocol::LimitMemoryRequest }
+        its(:handle)         { should == "handle" }
+        its(:limit_in_bytes) { should be_nil }
+      end
+
+      describe "with limit" do
+        subject { to_request ["limit", "handle", "mem", "1234"] }
+
+        its(:class)          { should == Warden::Protocol::LimitMemoryRequest }
+        its(:handle)         { should == "handle" }
+        its(:limit_in_bytes) { should == 1234 }
+      end
+    end
+
+    describe "response (mem)" do
+      it "should return #limit_in_bytes" do
+        response = to_response \
+          Warden::Protocol::LimitMemoryResponse.new({
+            :limit_in_bytes => 1234
+          })
+        response.should == 1234
+      end
+    end
+
+    describe "request (disk)" do
+      describe "without limit" do
+        subject { to_request ["limit", "handle", "disk"] }
+
+        its(:class)          { should == Warden::Protocol::LimitDiskRequest }
+        its(:handle)         { should == "handle" }
+        its(:byte)           { should be_nil }
+      end
+
+      describe "with limit" do
+        subject { to_request ["limit", "handle", "disk", "1234"] }
+
+        its(:class)          { should == Warden::Protocol::LimitDiskRequest }
+        its(:handle)         { should == "handle" }
+        its(:byte)           { should == 1234 }
+      end
+    end
+
+    describe "response (disk)" do
+      it "should return #byte" do
+        response = to_response \
+          Warden::Protocol::LimitDiskResponse.new({
+            :byte => 1234
+          })
+        response.should == 1234
+      end
+    end
+  end
+
+  describe "ping" do
+    describe "request" do
+      subject { to_request ["ping"] }
+
+      its(:class) { should == Warden::Protocol::PingRequest }
+    end
+
+    describe "response" do
+      it "should return pong" do
+        response = to_response \
+          Warden::Protocol::PingResponse.new
+        response.should == "pong"
+      end
+    end
+  end
+
+  describe "list" do
+    describe "request" do
+      subject { to_request ["list"] }
+
+      its(:class) { should == Warden::Protocol::ListRequest }
+    end
+
+    describe "response" do
+      it "should return an array with handles" do
+        response = to_response \
+          Warden::Protocol::ListResponse.new({
+            :handles => ["h1", "h2"]
+          })
+        response.should == ["h1", "h2"]
+      end
+    end
+  end
+
+  describe "echo" do
+    describe "request" do
+      subject { to_request ["echo", "hello world"] }
+
+      its(:class)   { should == Warden::Protocol::EchoRequest }
+      its(:message) { should == "hello world" }
+    end
+
+    describe "response" do
+      it "should return #message" do
+        response = to_response \
+          Warden::Protocol::EchoResponse.new({
+            :message => "hello world"
+          })
+        response.should == "hello world"
+      end
+    end
+  end
+end

data/spec/client_spec.rb

@@ -0,0 +1,224 @@
+require "spec_helper"
+require "support/mock_warden_server"
+
+describe Warden::Client do
+
+  include_context :mock_warden_server
+
+  let(:client) do
+    new_client
+  end
+
+  it "shouldn't be able to connect without a server" do
+    expect do
+      client.connect
+    end.to raise_error
+
+    client.should_not be_connected
+  end
+
+  it "should be able to connect with a server" do
+    start_server
+
+    expect do
+      client.connect
+    end.to_not raise_error
+
+    client.should be_connected
+  end
+
+  context "connection management" do
+
+    # This is super-racy: the ivar is updated from the server thread
+    def connection_count
+      sleep 0.001
+      @sessions.size
+    end
+
+    before(:each) do
+      @sessions = {}
+      start_server do |session, _|
+        @sessions[session] = 1
+      end
+    end
+
+    context "when connected" do
+
+      before(:each) do
+        client.connect
+        client.should be_connected
+        connection_count.should == 1
+      end
+
+      it "should not allow connecting" do
+        expect do
+          client.connect
+        end.to raise_error
+
+        # This should not affect the connection
+        client.should be_connected
+
+        # This should not reconnect
+        connection_count.should == 1
+      end
+
+      it "should allow disconnecting" do
+        client.disconnect
+        client.should_not be_connected
+
+        # This should not reconnect
+        connection_count.should == 1
+      end
+
+      it "should allow reconnecting" do
+        client.reconnect
+        client.should be_connected
+
+        # This should have reconnected
+        connection_count.should == 2
+      end
+    end
+
+    context "when disconnected" do
+
+      before(:each) do
+        connection_count.should == 0
+      end
+
+      it "should not allow disconnecting" do
+        expect do
+          client.disconnect
+        end.to raise_error
+
+        # This should not affect the connection
+        client.should_not be_connected
+
+        # This should not reconnect
+        connection_count.should == 0
+      end
+
+      it "should allow connecting" do
+        client.connect
+        client.should be_connected
+
+        # This should have connected
+        connection_count.should == 1
+      end
+
+      # While it is semantically impossible to reconnect when the client was
+      # never connected to begin with, it IS possible.
+      it "should allow reconnecting" do
+        client.reconnect
+        client.should be_connected
+
+        # This should have connected
+        connection_count.should == 1
+      end
+    end
+  end
+
+  context "when connected" do
+
+    before(:each) do
+      container = nil
+      job_id = nil
+
+      start_server do |session, request|
+        next if request.nil?
+
+        if request.class == Warden::Protocol::EchoRequest
+          case request.message
+          when "eof"
+            session.close
+          when "error"
+            args = { :message => "error" }
+            session.respond(Warden::Protocol::ErrorResponse.new(args))
+          else
+            args = { :message => request.message }
+            session.respond(request.create_response(args))
+          end
+        elsif request.class == Warden::Protocol::CreateRequest
+          raise 'Cannot create more than one container' unless container.nil?
+
+          container = "test"
+          args = { :handle => container }
+          session.respond(Warden::Protocol::CreateResponse.new(args))
+        elsif request.class == Warden::Protocol::SpawnRequest
+          raise 'Unknown handle' unless request.handle == container
+          raise 'Cannot spawn more than one job' unless job_id.nil?
+
+          job_id = 1
+          args = { :job_id => job_id }
+          session.respond(Warden::Protocol::SpawnResponse.new(args))
+        elsif request.class == Warden::Protocol::StreamRequest
+          raise 'Unknown handle' unless request.handle == container
+          raise 'Unknown job' unless request.job_id == job_id
+
+          args = { :name => "stream", :data => "test" }
+          session.respond(Warden::Protocol::StreamResponse.new(args))
+          args = { :exit_status => 0 }
+          session.respond(Warden::Protocol::StreamResponse.new(args))
+        else
+          raise "Unknown request type: #{request.class}."
+        end
+      end
+
+      client.connect
+      client.should be_connected
+    end
+
+    it "should raise EOFError on eof" do
+      expect do
+        client.echo(:message => "eof")
+      end.to raise_error(::EOFError)
+
+      # This should update the connection status
+      client.should_not be_connected
+    end
+
+    it "should raise Warden::Client::ServerError on error payloads" do
+      expect do
+        client.echo(:message => "error")
+      end.to raise_error(Warden::Client::ServerError)
+
+      # This should not affect the connection
+      client.should be_connected
+    end
+
+    it "should return decoded payload for non-error replies" do
+      response = client.echo(:message => "hello")
+      response.message.should == "hello"
+    end
+
+    it "should work when called with the old API" do
+      response = client.call(["echo", "hello"])
+      response.should == "hello"
+    end
+
+    it "should stream data" do
+      handle = client.create.handle
+      response = client.spawn(:handle => handle, :script => "echo test")
+
+      called = false
+      block = lambda do |response|
+        raise "Block should not be called more than once." if called
+
+        response.should be_an_instance_of Warden::Protocol::StreamResponse
+        response.data.should == "test"
+        response.name.should == "stream"
+        response.exit_status.should be_nil
+
+        called = true
+      end
+
+      request = Warden::Protocol::StreamRequest.new(:handle => handle,
+                                                    :job_id => response.job_id)
+      response = client.stream(request, &block)
+      response.data.should be_nil
+      response.name.should be_nil
+      response.exit_status.should == 0
+
+      called.should be_true
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,6 @@
+require "rspec"
+require "warden/client"
+
+RSpec.configure do |config|
+  # not much to do here...
+end

data/spec/support/mock_warden_server.rb

@@ -0,0 +1,78 @@
+require "socket"
+require "tempfile"
+require "warden/protocol"
+
+class Session
+
+  def initialize(sock, handler = nil)
+    @sock = sock
+    @handler = handler
+
+    # Post-initialization
+    handle(nil)
+  end
+
+  def handle(request)
+    @handler.call(self, request) if @handler
+  end
+
+  def close
+    @sock.close
+  ensure
+    @sock = nil
+  end
+
+  def respond(*responses)
+    responses.each do |response|
+      data = response.wrap.encode.to_s
+      @sock.write data.length.to_s + "\r\n"
+      @sock.write data + "\r\n"
+    end
+  end
+
+  def run!
+    while @sock && length = @sock.gets
+      data = @sock.read(length.to_i)
+
+      # Discard \r\n
+      @sock.read(2)
+
+      handle(Warden::Protocol::Message.decode(data).request)
+    end
+  end
+end
+
+shared_context :mock_warden_server do
+
+  SERVER_PATH = File.expand_path("../../../tmp/mock_server.sock", __FILE__)
+
+  def new_client
+    Warden::Client.new(SERVER_PATH)
+  end
+
+  def start_server(&blk)
+    # Make sure the path to the unix socket is not used
+    FileUtils.rm_rf(SERVER_PATH)
+
+    # Create unix socket server
+    server = UNIXServer.new(SERVER_PATH)
+
+    # Accept new connections from a thread
+    @server = Thread.new do
+      begin
+        loop do
+          session = Session.new(server.accept, blk)
+          session.run!
+        end
+      rescue => ex
+        STDERR.puts ex.message
+        STDERR.puts ex.backtrace
+        raise
+      end
+    end
+  end
+
+  after(:each) do
+    @server.kill if @server
+  end
+end

data/warden-client.gemspec

@@ -0,0 +1,20 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "warden/client/version"
+
+Gem::Specification.new do |s|
+  s.name        = "warden-client"
+  s.version     = Warden::Client::VERSION
+  s.authors     = ["Pieter Noordhuis", "Matt Page"]
+  s.email       = ["pcnoordhuis@gmail.com", "mpage@vmware.com"]
+  s.homepage    = "http://www.cloudfoundry.org/"
+  s.summary     = %q{Client driver for warden, the ephemeral container manager.}
+  s.description = %q{Provides a blocking client for interacting with the Warden.}
+
+  s.files         = Dir.glob("**/*")
+  s.test_files    = Dir.glob("spec/**/*")
+  s.executables   = []
+  s.require_paths = ["lib"]
+
+  s.add_runtime_dependency "warden-protocol", "~> 0.1.0"
+end

metadata

@@ -0,0 +1,78 @@
+--- !ruby/object:Gem::Specification
+name: warden-client
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- Pieter Noordhuis
+- Matt Page
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-06-12 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: warden-protocol
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.1.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.1.0
+description: Provides a blocking client for interacting with the Warden.
+email:
+- pcnoordhuis@gmail.com
+- mpage@vmware.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- Gemfile
+- lib/warden/client/v1.rb
+- lib/warden/client/version.rb
+- lib/warden/client.rb
+- Rakefile
+- README.md
+- spec/client/v1_spec.rb
+- spec/client_spec.rb
+- spec/spec_helper.rb
+- spec/support/mock_warden_server.rb
+- warden-client.gemspec
+homepage: http://www.cloudfoundry.org/
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.25
+signing_key: 
+specification_version: 3
+summary: Client driver for warden, the ephemeral container manager.
+test_files:
+- spec/client/v1_spec.rb
+- spec/client_spec.rb
+- spec/spec_helper.rb
+- spec/support/mock_warden_server.rb