warden-protocol 0.1.3

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.rspec

@@ -0,0 +1 @@
+--fail-fast --backtrace --color

data/CHANGELOG.md

@@ -0,0 +1,14 @@
+## 0.0.3
+
+* Ignore string encoding when a request or response is encoded
+
+## 0.0.2
+
+### `StopRequest`
+
+* Added `background` flag
+* Added `kill` flag
+
+## 0.0.1
+
+* Initial version.

data/Gemfile

@@ -0,0 +1,6 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in warden-protocol.gemspec
+gemspec
+
+gem 'rake'

data/README.md

@@ -0,0 +1,13 @@
+# warden-protocol
+
+> This README describes the **protocol** library. 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,40 @@
+# coding: UTF-8
+
+require "rspec/core/rake_task"
+require "rspec/core/version"
+
+task :default => :spec
+
+desc "Run all examples"
+RSpec::Core::RakeTask.new(:spec) do |t|
+  # See .rspec
+end
+
+desc "Build pb.rb"
+task :build do
+  sh("lib/warden/protocol/build.sh")
+end
+
+task :ensure_coding do
+  patterns = [
+    /Rakefile$/,
+    /\.rb$/,
+  ]
+
+  files = `git ls-files`.split.select do |file|
+    patterns.any? { |e| e.match(file) }
+  end
+
+  header = "# coding: UTF-8\n\n"
+
+  files.each do |file|
+    content = File.read(file)
+
+    unless content.start_with?(header)
+      File.open(file, "w") do |f|
+        f.write(header)
+        f.write(content)
+      end
+    end
+  end
+end

data/lib/warden/protocol.rb

@@ -0,0 +1,4 @@
+# coding: UTF-8
+
+require "warden/protocol/version"
+require "warden/protocol/message"

data/lib/warden/protocol/base.rb

@@ -0,0 +1,168 @@
+# coding: UTF-8
+
+require "beefcake"
+
+module Beefcake
+  class Buffer
+    # Patch beefcake to be encoding-agnostic
+    def append_string(s)
+      if s.respond_to?(:force_encoding)
+        s = s.dup.force_encoding("binary")
+      end
+
+      append_uint64(s.length)
+      self << s
+    end
+  end
+end
+
+module Warden
+  module Protocol
+    TypeConverter = {
+      :bool     => lambda do |arg|
+        return true if arg.downcase == "true"
+        return false if arg.downcase == "false"
+        raise ArgumentError, "Expected 'true' or 'false', but received: '#{arg}'."
+      end,
+
+      :int32    => lambda { |arg| Integer(arg) },
+      :uint32   => lambda { |arg| Integer(arg) },
+      :sint32   => lambda { |arg| Integer(arg) },
+      :int64    => lambda { |arg| Integer(arg) },
+      :uint64   => lambda { |arg| Integer(arg) },
+      :fixed32  => lambda { |arg| Float(arg) },
+      :sfixed32 => lambda { |arg| Float(arg) },
+      :float    => lambda { |arg| Float(arg) },
+      :fixed64  => lambda { |arg| Float(arg) },
+      :sfixed64 => lambda { |arg| Float(arg) },
+      :double   => lambda { |arg| Float(arg) },
+      :string   => lambda { |arg| String(arg) },
+    }
+
+    # Used to wrap around Beefcake errors.
+    class ProtocolError < StandardError
+      attr_reader :cause
+
+      def initialize(cause)
+        @cause = cause
+      end
+
+      def message
+        return @cause.message
+      end
+    end
+
+    def self.protocol_type_to_str(protocol_type)
+      if protocol_type.class == Module
+        return "#{protocol_type.constants.join(", ")}"
+      elsif protocol_type.is_a?(Symbol)
+        return "#{protocol_type.to_s}"
+      end
+
+      return nil
+    end
+
+    def self.to_ruby_type(str, protocol_type)
+      converter = Warden::Protocol::TypeConverter[protocol_type]
+      return converter.call(str) if converter
+
+      # Enums are defined as Ruby Modules in Beefcake
+      error_msg = nil
+      if protocol_type.class == Module
+        return protocol_type.const_get(str) if protocol_type.const_defined?(str)
+        raise TypeError, "The constant: '#{str}' is not defined in the module: '#{protocol_type}'."
+      end
+
+      raise TypeError, "Non-existent protocol type passed: '#{protocol_type}'."
+    end
+
+    module BaseMessage
+      def self.included(base)
+        base.send(:include, Beefcake::Message)
+
+        if base.name =~ /(Request|Response)$/
+          base.extend(ClassMethods)
+
+          case $1
+          when "Request"
+            base.send(:include, BaseRequest)
+          when "Response"
+            base.send(:include, BaseResponse)
+          end
+        end
+      end
+
+      def safe
+        yield
+      rescue Beefcake::Message::WrongTypeError,
+             Beefcake::Message::InvalidValueError,
+             Beefcake::Message::RequiredFieldNotSetError => e
+        raise ProtocolError, e
+      end
+
+      def reload
+        safe do
+          self.class.decode(encode)
+        end
+      end
+
+      def wrap
+        safe do
+          Message.new(:type => self.class.type, :payload => encode)
+        end
+      end
+
+      def to_hash
+        fields.values.inject({}) do |h, fld|
+          if v = self[fld.name]
+            v = v.to_hash if v.respond_to?(:to_hash)
+            h[fld.name] = v
+          end
+          h
+        end
+      end
+
+      module ClassMethods
+        def type
+          Message::Type.const_get(type_name)
+        end
+
+        def type_camelized
+          type_name
+        end
+
+        def type_underscored
+          type_name.gsub(/(.)([A-Z])/, "\\1_\\2").downcase
+        end
+
+        def type_name
+          type_name = name.gsub(/(Request|Response)$/, "")
+          type_name = type_name.split("::").last
+          type_name
+        end
+      end
+    end
+
+    module BaseRequest
+      def create_response(attributes = {})
+        klass_name = self.class.name.gsub(/Request$/, "Response")
+        klass_name = klass_name.split("::").last
+        klass = Protocol.const_get(klass_name)
+        klass.new(attributes)
+      end
+    end
+
+    module BaseResponse
+      def ok?
+        !error?
+      end
+
+      def error?
+        self.class.type == Message::Type::Error
+      end
+    end
+  end
+end
+
+require "warden/protocol/pb"
+require "warden/protocol/message"

data/lib/warden/protocol/buffer.rb

@@ -0,0 +1,69 @@
+# coding: UTF-8
+
+require "warden/protocol/base"
+
+module Warden
+  module Protocol
+    class Buffer
+      CRLF = "\r\n"
+
+      def self.request_to_wire(request)
+        unless request.kind_of?(BaseRequest)
+          raise ArgumentError, "Expected #kind_of? ::%s" % BaseRequest.name
+        end
+        payload_to_wire request.wrap.encode.to_s
+      end
+
+      def self.response_to_wire(response)
+        unless response.kind_of?(BaseResponse)
+          raise ArgumentError, "Expected #kind_of? ::%s" % BaseResponse.name
+        end
+        payload_to_wire response.wrap.encode.to_s
+      end
+
+      def initialize
+        @buffer = ""
+      end
+
+      def <<(data)
+        @buffer += data
+      end
+
+      def each_request(&blk)
+        each do |payload|
+          yield(Warden::Protocol::Message.decode(payload).request)
+        end
+      end
+
+      def each_response(&blk)
+        each do |payload|
+          yield(Warden::Protocol::Message.decode(payload).response)
+        end
+      end
+
+      protected
+
+      def self.payload_to_wire(payload)
+        payload.to_s.length.to_s + CRLF + payload.to_s + CRLF
+      end
+
+      def each
+        loop do
+          crlf = @buffer.index(CRLF)
+          break unless crlf
+
+          length = Integer(@buffer[0...crlf])
+          protocol_length = crlf + 2 + length + 2
+          break unless @buffer.length >= protocol_length
+
+          payload = @buffer[crlf + 2, length]
+
+          # Trim buffer
+          @buffer = @buffer[protocol_length..-1]
+
+          yield(payload)
+        end
+      end
+    end
+  end
+end

data/lib/warden/protocol/build.sh

@@ -0,0 +1,13 @@
+#!/bin/bash
+
+set -e
+
+cd $(dirname $0)/pb
+
+export BEEFCAKE_NAMESPACE=Warden::Protocol
+
+out=bundle
+(echo "package protocol;" && (find . -name '*.proto' | sort | xargs cat | sed /^package/d)) > $out
+protoc --beefcake_out=. $out
+sed -e "s/Beefcake::Message/Warden::Protocol::BaseMessage/" $out.pb.rb > ../pb.rb
+rm -f $out*

data/lib/warden/protocol/message.rb

@@ -0,0 +1,50 @@
+# coding: UTF-8
+
+require "warden/protocol/base"
+
+module Warden
+  module Protocol
+    class Message
+      module Type
+        def self.generate_klass_map(suffix)
+          map = Hash[self.constants.map do |name|
+            klass_name = "#{name}#{suffix}"
+            if Protocol.const_defined?(klass_name)
+              [const_get(name), Protocol.const_get(klass_name)]
+            end
+          end]
+
+          if map.respond_to?(:default_proc=)
+            map.default_proc = lambda do |h, k|
+              raise "Unknown request type: #{k}"
+            end
+          end
+
+          map
+        end
+
+        def self.to_request_klass(type)
+          @request_klass_map ||= generate_klass_map("Request")
+          @request_klass_map[type]
+        end
+
+        def self.to_response_klass(type)
+          @response_klass_map ||= generate_klass_map("Response")
+          @response_klass_map[type]
+        end
+      end
+
+      def request
+        safe do
+          Type.to_request_klass(type).decode(payload)
+        end
+      end
+
+      def response
+        safe do
+          Type.to_response_klass(type).decode(payload)
+        end
+      end
+    end
+  end
+end

data/lib/warden/protocol/pb.rb

@@ -0,0 +1,497 @@
+## Generated from bundle for protocol
+require "beefcake"
+
+module Warden
+  module Protocol
+
+    class CopyInRequest
+      include Warden::Protocol::BaseMessage
+
+
+      required :handle, :string, 1
+      required :src_path, :string, 2
+      required :dst_path, :string, 3
+
+    end
+
+    class CopyInResponse
+      include Warden::Protocol::BaseMessage
+
+
+
+    end
+
+    class CopyOutRequest
+      include Warden::Protocol::BaseMessage
+
+
+      required :handle, :string, 1
+      required :src_path, :string, 2
+      required :dst_path, :string, 3
+      optional :owner, :string, 4
+
+    end
+
+    class CopyOutResponse
+      include Warden::Protocol::BaseMessage
+
+
+
+    end
+
+    class CreateRequest
+      include Warden::Protocol::BaseMessage
+
+
+      class BindMount
+        include Warden::Protocol::BaseMessage
+
+        module Mode
+          RO = 0
+          RW = 1
+        end
+
+        required :src_path, :string, 1
+        required :dst_path, :string, 2
+        required :mode, CreateRequest::BindMount::Mode, 3
+
+      end
+
+      repeated :bind_mounts, CreateRequest::BindMount, 1
+      optional :grace_time, :uint32, 2
+      optional :handle, :string, 3
+      optional :network, :string, 4
+      optional :rootfs, :string, 5
+
+    end
+
+    class CreateResponse
+      include Warden::Protocol::BaseMessage
+
+
+      required :handle, :string, 1
+
+    end
+
+    class DestroyRequest
+      include Warden::Protocol::BaseMessage
+
+
+      required :handle, :string, 1
+
+    end
+
+    class DestroyResponse
+      include Warden::Protocol::BaseMessage
+
+
+
+    end
+
+    class EchoRequest
+      include Warden::Protocol::BaseMessage
+
+
+      required :message, :string, 1
+
+    end
+
+    class EchoResponse
+      include Warden::Protocol::BaseMessage
+
+
+      required :message, :string, 1
+
+    end
+
+    class ErrorResponse
+      include Warden::Protocol::BaseMessage
+
+
+      optional :message, :string, 2
+      optional :data, :string, 4
+      repeated :backtrace, :string, 3
+
+    end
+
+    class InfoRequest
+      include Warden::Protocol::BaseMessage
+
+
+      required :handle, :string, 1
+
+    end
+
+    class InfoResponse
+      include Warden::Protocol::BaseMessage
+
+
+      class MemoryStat
+        include Warden::Protocol::BaseMessage
+
+
+        optional :cache, :uint64, 1
+        optional :rss, :uint64, 2
+        optional :mapped_file, :uint64, 3
+        optional :pgpgin, :uint64, 4
+        optional :pgpgout, :uint64, 5
+        optional :swap, :uint64, 6
+        optional :pgfault, :uint64, 7
+        optional :pgmajfault, :uint64, 8
+        optional :inactive_anon, :uint64, 9
+        optional :active_anon, :uint64, 10
+        optional :inactive_file, :uint64, 11
+        optional :active_file, :uint64, 12
+        optional :unevictable, :uint64, 13
+        optional :hierarchical_memory_limit, :uint64, 14
+        optional :hierarchical_memsw_limit, :uint64, 15
+        optional :total_cache, :uint64, 16
+        optional :total_rss, :uint64, 17
+        optional :total_mapped_file, :uint64, 18
+        optional :total_pgpgin, :uint64, 19
+        optional :total_pgpgout, :uint64, 20
+        optional :total_swap, :uint64, 21
+        optional :total_pgfault, :uint64, 22
+        optional :total_pgmajfault, :uint64, 23
+        optional :total_inactive_anon, :uint64, 24
+        optional :total_active_anon, :uint64, 25
+        optional :total_inactive_file, :uint64, 26
+        optional :total_active_file, :uint64, 27
+        optional :total_unevictable, :uint64, 28
+
+      end
+
+      class CpuStat
+        include Warden::Protocol::BaseMessage
+
+
+        optional :usage, :uint64, 1
+        optional :user, :uint64, 2
+        optional :system, :uint64, 3
+
+      end
+
+      class DiskStat
+        include Warden::Protocol::BaseMessage
+
+
+        optional :bytes_used, :uint64, 1
+        optional :inodes_used, :uint64, 2
+
+      end
+
+      class BandwidthStat
+        include Warden::Protocol::BaseMessage
+
+
+        optional :in_rate, :uint64, 1
+        optional :in_burst, :uint64, 2
+        optional :out_rate, :uint64, 3
+        optional :out_burst, :uint64, 4
+
+      end
+
+      optional :state, :string, 10
+      repeated :events, :string, 20
+      optional :host_ip, :string, 30
+      optional :container_ip, :string, 31
+      optional :container_path, :string, 32
+      optional :memory_stat, InfoResponse::MemoryStat, 40
+      optional :cpu_stat, InfoResponse::CpuStat, 41
+      optional :disk_stat, InfoResponse::DiskStat, 42
+      optional :bandwidth_stat, InfoResponse::BandwidthStat, 43
+      repeated :job_ids, :uint64, 44
+
+    end
+
+    class LimitBandwidthRequest
+      include Warden::Protocol::BaseMessage
+
+
+      required :handle, :string, 1
+      required :rate, :uint64, 2
+      required :burst, :uint64, 3
+
+    end
+
+    class LimitBandwidthResponse
+      include Warden::Protocol::BaseMessage
+
+
+      required :rate, :uint64, 1
+      required :burst, :uint64, 2
+
+    end
+
+    class LimitDiskRequest
+      include Warden::Protocol::BaseMessage
+
+
+      required :handle, :string, 1
+      optional :block_limit, :uint64, 10
+      optional :block, :uint64, 11
+      optional :block_soft, :uint64, 12
+      optional :block_hard, :uint64, 13
+      optional :inode_limit, :uint64, 20
+      optional :inode, :uint64, 21
+      optional :inode_soft, :uint64, 22
+      optional :inode_hard, :uint64, 23
+      optional :byte_limit, :uint64, 30
+      optional :byte, :uint64, 31
+      optional :byte_soft, :uint64, 32
+      optional :byte_hard, :uint64, 33
+
+    end
+
+    class LimitDiskResponse
+      include Warden::Protocol::BaseMessage
+
+
+      optional :block_limit, :uint64, 10
+      optional :block, :uint64, 11
+      optional :block_soft, :uint64, 12
+      optional :block_hard, :uint64, 13
+      optional :inode_limit, :uint64, 20
+      optional :inode, :uint64, 21
+      optional :inode_soft, :uint64, 22
+      optional :inode_hard, :uint64, 23
+      optional :byte_limit, :uint64, 30
+      optional :byte, :uint64, 31
+      optional :byte_soft, :uint64, 32
+      optional :byte_hard, :uint64, 33
+
+    end
+
+    class LimitMemoryRequest
+      include Warden::Protocol::BaseMessage
+
+
+      required :handle, :string, 1
+      optional :limit_in_bytes, :uint64, 2
+
+    end
+
+    class LimitMemoryResponse
+      include Warden::Protocol::BaseMessage
+
+
+      optional :limit_in_bytes, :uint64, 1
+
+    end
+
+    class LinkRequest
+      include Warden::Protocol::BaseMessage
+
+
+      required :handle, :string, 1
+      required :job_id, :uint32, 2
+
+    end
+
+    class LinkResponse
+      include Warden::Protocol::BaseMessage
+
+
+      optional :exit_status, :uint32, 1
+      optional :stdout, :string, 2
+      optional :stderr, :string, 3
+      optional :info, InfoResponse, 4
+
+    end
+
+    class ListRequest
+      include Warden::Protocol::BaseMessage
+
+
+
+    end
+
+    class ListResponse
+      include Warden::Protocol::BaseMessage
+
+
+      repeated :handles, :string, 1
+
+    end
+
+    class Message
+      include Warden::Protocol::BaseMessage
+
+      module Type
+        Error = 1
+        Create = 11
+        Stop = 12
+        Destroy = 13
+        Info = 14
+        Spawn = 21
+        Link = 22
+        Run = 23
+        Stream = 24
+        NetIn = 31
+        NetOut = 32
+        CopyIn = 41
+        CopyOut = 42
+        LimitMemory = 51
+        LimitDisk = 52
+        LimitBandwidth = 53
+        Ping = 91
+        List = 92
+        Echo = 93
+      end
+
+      required :type, Message::Type, 1
+      required :payload, :bytes, 2
+
+    end
+
+    class NetInRequest
+      include Warden::Protocol::BaseMessage
+
+
+      required :handle, :string, 1
+      optional :host_port, :uint32, 3
+      optional :container_port, :uint32, 2
+
+    end
+
+    class NetInResponse
+      include Warden::Protocol::BaseMessage
+
+
+      required :host_port, :uint32, 1
+      required :container_port, :uint32, 2
+
+    end
+
+    class NetOutRequest
+      include Warden::Protocol::BaseMessage
+
+
+      required :handle, :string, 1
+      optional :network, :string, 2
+      optional :port, :uint32, 3
+
+    end
+
+    class NetOutResponse
+      include Warden::Protocol::BaseMessage
+
+
+
+    end
+
+    class PingRequest
+      include Warden::Protocol::BaseMessage
+
+
+
+    end
+
+    class PingResponse
+      include Warden::Protocol::BaseMessage
+
+
+
+    end
+
+    class ResourceLimits
+      include Warden::Protocol::BaseMessage
+
+
+      optional :as, :uint64, 1
+      optional :core, :uint64, 2
+      optional :cpu, :uint64, 3
+      optional :data, :uint64, 4
+      optional :fsize, :uint64, 5
+      optional :locks, :uint64, 6
+      optional :memlock, :uint64, 7
+      optional :msgqueue, :uint64, 8
+      optional :nice, :uint64, 9
+      optional :nofile, :uint64, 10
+      optional :nproc, :uint64, 11
+      optional :rss, :uint64, 12
+      optional :rtprio, :uint64, 13
+      optional :sigpending, :uint64, 14
+      optional :stack, :uint64, 15
+
+    end
+
+    class RunRequest
+      include Warden::Protocol::BaseMessage
+
+
+      required :handle, :string, 1
+      required :script, :string, 2
+      optional :privileged, :bool, 3, :default => false
+      optional :rlimits, ResourceLimits, 4
+
+    end
+
+    class RunResponse
+      include Warden::Protocol::BaseMessage
+
+
+      optional :exit_status, :uint32, 1
+      optional :stdout, :string, 2
+      optional :stderr, :string, 3
+      optional :info, InfoResponse, 4
+
+    end
+
+    class SpawnRequest
+      include Warden::Protocol::BaseMessage
+
+
+      required :handle, :string, 1
+      required :script, :string, 2
+      optional :privileged, :bool, 3, :default => false
+      optional :rlimits, ResourceLimits, 4
+
+    end
+
+    class SpawnResponse
+      include Warden::Protocol::BaseMessage
+
+
+      required :job_id, :uint32, 1
+
+    end
+
+    class StopRequest
+      include Warden::Protocol::BaseMessage
+
+
+      required :handle, :string, 1
+      optional :background, :bool, 10, :default => false
+      optional :kill, :bool, 20, :default => false
+
+    end
+
+    class StopResponse
+      include Warden::Protocol::BaseMessage
+
+
+
+    end
+
+    class StreamRequest
+      include Warden::Protocol::BaseMessage
+
+
+      required :handle, :string, 1
+      required :job_id, :uint32, 2
+
+    end
+
+    class StreamResponse
+      include Warden::Protocol::BaseMessage
+
+
+      optional :name, :string, 1
+      optional :data, :string, 2
+      optional :exit_status, :uint32, 3
+      optional :info, InfoResponse, 4
+
+    end
+  end
+end