rexpro 0.0.1

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/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Philotic, Inc.
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,40 @@
+# Rexpro
+
+*This is an early release and should not be considered stable!*
+
+https://github.com/tinkerpop/rexster/wiki/RexPro
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'rexpro'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install rexpro
+
+## Usage
+
+```ruby
+require 'rexpro'
+
+client = Rexpro::Client.new(host: 'localhost', port: 8184) # defaults
+
+response = client.execute('g.v(2)', graph_name: 'tinkergraph')
+
+response.results
+=> {"_id"=>"2", "_type"=>"vertex", "_properties"=>{"name"=>"vadas", "age"=>27}}
+```
+
+## Contributing
+
+1. Fork it
+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 new Pull Request

data/Rakefile

@@ -0,0 +1,23 @@
+require "bundler/gem_tasks"
+
+require 'rake/testtask'
+
+task :default => :basic_tests
+
+desc 'Run basic (non-integration) tests'
+Rake::TestTask.new(:basic_tests) do |test|
+  test.verbose = true
+  test.test_files = ['spec/*_spec.rb']
+end
+
+desc 'Run integration tests'
+Rake::TestTask.new(:integration_tests) do |test|
+  test.verbose = true
+  test.test_files = ['spec/integration/*_spec.rb']
+end
+
+desc 'Run all tests'
+Rake::TestTask.new do |test|
+  test.verbose = true
+  test.test_files = ['spec/**/*_spec.rb']
+end

data/lib/rexpro/client.rb

@@ -0,0 +1,52 @@
+require 'socket'
+
+require_relative './session'
+
+module Rexpro
+  class Client
+    DEFAULT_HOST = 'localhost'
+    DEFAULT_PORT = 8184
+
+    attr_reader :host, :port, :socket
+
+    def initialize(opts = {})
+      @host = opts[:host] || DEFAULT_HOST
+      @port = opts[:port] || DEFAULT_PORT
+      reconnect
+    end
+
+    def reconnect
+      @socket.close if @socket && !@socket.closed?
+      @socket = TCPSocket.new @host, @port
+    end
+
+    def new_session(*args)
+      req = Rexpro::Message::SessionRequest.new(*args)
+      resp = request(req)
+      Rexpro::Session.new(self, resp.session_uuid, req.channel, resp.languages)
+    end
+
+    def request(req)
+      req.write_to(@socket)
+
+      Rexpro::Message.read_from(@socket).tap do |resp|
+        if resp.request_uuid.bytes.to_a != req.request_uuid.bytes.to_a
+          raise Rexpro::RexproException,
+                "request uuid of response didn't match request"
+        end
+
+        if resp.is_a? Rexpro::Message::Error
+          err_msg = resp.error_message
+          err_msg << " [flag=#{resp.flag}]" if resp.flag
+          raise Rexpro::RexproError.new(err_msg)
+        end
+      end
+    end
+
+    def execute(script, attrs = {})
+      attrs = attrs.merge(script: script)
+      msg = Rexpro::Message::ScriptRequest.new(attrs)
+      request(msg)
+    end
+  end
+end

data/lib/rexpro/message.rb

@@ -0,0 +1,199 @@
+require 'msgpack'
+require 'uuid'
+
+# https://github.com/tinkerpop/rexster/wiki/RexPro-Messages
+
+module Rexpro
+  module Message
+    PROTOCOL_VERSION = 0
+
+    ZERO_UUID = [0, 0, 0, 0].pack('NNNN')
+
+    TYPE_ERROR                    = 0
+    TYPE_SESSION_REQUEST          = 1
+    TYPE_SESSION_RESPONSE         = 2
+    TYPE_SCRIPT_REQUEST           = 3
+    TYPE_CONSOLE_SCRIPT_RESPONSE  = 4
+    TYPE_MSGPACK_SCRIPT_RESPONSE  = 5
+    TYPE_GRAPHSON_SCRIPT_RESPONSE = 6
+
+    CHANNEL_CONSOLE  = 1
+    CHANNEL_MSGPACK  = 2
+    CHANNEL_GRAPHSON = 3
+
+    class << self
+      def generate_uuid
+        @uuid ||= UUID.new
+        hex = @uuid.generate(:compact)
+        ints = hex.each_char.each_slice(8).map { |h| Integer(h.join, 16) }
+        ints.pack('NNNN')
+      end
+
+      def types
+        @types ||= {}
+      end
+
+      def read_from(io)
+        version = io.readbyte
+        if version != PROTOCOL_VERSION
+          raise RexproException, "Unknown protocol version #{version}"
+        end
+
+        header = io.read(5)
+        if header.nil? || header.size < 5
+          raise RexproException, "Unexpected EOF: #{header.inspect}"
+        end
+
+        type, size = header.unpack('CN')
+        type_class = types[type]
+        unless type_class
+          raise RexproException, "Unknown message type #{type}"
+        end
+        fields = type_class.fields
+
+        unpacker = MessagePack::Unpacker.new(io)
+        array_size = unpacker.read_array_header
+        if array_size != fields.length
+          raise RexproException,
+                "Expected #{fields.length} fields, got #{array_size}"
+        end
+
+        values = unpacker.read
+
+        attrs = fields.zip(values).inject({}) do |memo, (field, value)|
+          memo[field] = value
+          memo
+        end
+
+        type_class.new(attrs)
+      end
+    end
+
+    module Base
+      def self.included(klass)
+        klass.extend ClassMethods
+        klass.define_fields session_uuid: :to_s, request_uuid: :to_s,
+                            meta: :to_hash
+      end
+
+      module ClassMethods
+        attr_reader :type
+
+        def type=(type)
+          @type = type
+          Message.types[type] = self
+        end
+
+        def fields
+          @fields ||= []
+        end
+
+        def field_methods
+          @field_methods ||= {}
+        end
+
+        def define_fields(hsh)
+          hsh.each do |name, method|
+            fields << name
+            field_methods[name] = method
+            attr_accessor(name)
+          end
+        end
+
+        def define_meta_fields(*names)
+          names.each do |name|
+            # RexPro uses mixedCase keys in meta
+            name_parts = name.to_s.split('_')
+            name_parts[1..-1].each(&:capitalize!)
+            rexpro_name = name_parts.join
+
+            define_method(name) { meta[rexpro_name] }
+            define_method("#{name}=") { |value| meta[rexpro_name] = value }
+          end
+        end
+      end
+
+      def initialize(attrs = {})
+        self.meta ||= {}
+        attrs.each { |k, v| send("#{k}=", v) }
+        self.session_uuid ||= ZERO_UUID
+        self.request_uuid ||= Message.generate_uuid
+      end
+
+      def to_msgpack(*args)
+        self.class.fields.map do |field|
+          value = send(field)
+          field_method = self.class.field_methods[field]
+          value = value.send(field_method) if field_method
+          value
+        end.to_msgpack(*args)
+      end
+
+      def write_to(io)
+        body = to_msgpack
+        header = [PROTOCOL_VERSION, self.class.type, body.size].pack('CCN')
+        io.write(header)
+        io.write(body)
+      end
+    end
+
+    class Error
+      include Base
+      self.type = TYPE_ERROR
+      define_fields error_message: :to_s
+      define_meta_fields :flag
+    end
+
+    class SessionRequest
+      include Base
+      self.type = TYPE_SESSION_REQUEST
+      define_fields channel: :to_i, username: :to_s, password: :to_s
+      define_meta_fields :graph_name, :graph_obj_name, :kill_session
+
+      def initialize(*_)
+        super
+        self.channel ||= CHANNEL_MSGPACK
+      end
+    end
+
+    class SessionResponse
+      include Base
+      self.type = TYPE_SESSION_RESPONSE
+      define_fields languages: :to_a
+      define_meta_fields :graph_name, :graph_obj_name, :kill_session
+    end
+
+    class ScriptRequest
+      include Base
+      self.type = TYPE_SCRIPT_REQUEST
+      define_fields language_name: :to_s, script: :to_s, bindings: :to_hash
+      define_meta_fields :channel, :in_session, :isolate, :transaction,
+                         :graph_name, :graph_obj_name
+
+      def initialize(*_)
+        super
+        self.language_name ||= 'groovy'
+        self.bindings ||= {}
+        self.channel ||= CHANNEL_MSGPACK
+      end
+    end
+
+    class ConsoleScriptResponse
+      include Base
+      self.type = TYPE_CONSOLE_SCRIPT_RESPONSE
+      define_fields console_lines: :to_a, bindings: :to_hash
+    end
+
+    class MsgpackScriptResponse
+      include Base
+      self.type = TYPE_MSGPACK_SCRIPT_RESPONSE
+      define_fields results: nil, bindings: :to_hash
+    end
+
+    class GraphsonScriptResponse
+      include Base
+      self.type = TYPE_GRAPHSON_SCRIPT_RESPONSE
+      define_fields results: :to_s, bindings: :to_hash
+    end
+  end
+end

data/lib/rexpro/session.rb

@@ -0,0 +1,22 @@
+require 'rexpro'
+
+class Rexpro::Session
+  attr_reader :client, :uuid, :channel, :languages
+
+  def initialize(client, uuid, channel, languages = nil)
+    @client, @uuid, @channel, @languages = client, uuid, channel, languages
+  end
+
+  def kill
+    attrs = {session_uuid: uuid, kill_session: true}
+    msg = Rexpro::Message::SessionRequest.new(attrs)
+    client.request(msg)
+  end
+
+  def execute(script, attrs = {})
+    attrs = attrs.merge(
+      session_uuid: uuid, channel: channel, in_session: true, script: script)
+    msg = Rexpro::Message::ScriptRequest.new(attrs)
+    client.request(msg)
+  end
+end

data/lib/rexpro/version.rb

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

data/lib/rexpro.rb

@@ -0,0 +1,8 @@
+require_relative "./rexpro/version"
+require_relative "./rexpro/client"
+require_relative "./rexpro/message"
+
+module Rexpro
+  class RexproException < StandardError; end
+  class RexproError < RexproException; end
+end

data/rexpro.gemspec

@@ -0,0 +1,28 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'rexpro/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "rexpro"
+  spec.version       = Rexpro::VERSION
+  spec.authors       = ["Lann Martin"]
+  spec.email         = ["lann@causes.com"]
+  spec.description   = %q{RexPro, a binary protocol for Rexster}
+  spec.summary       = <<DESC
+RexPro is a binary protocol for Rexster that can be used to send Gremlin
+scripts to a remote Rexster instance.
+DESC
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.test_files    = spec.files.grep(%r{^spec/})
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "msgpack", "~> 0.5.4"
+  spec.add_dependency "uuid",    "~> 2.3.7"
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+end

data/spec/integration/README.md

@@ -0,0 +1,13 @@
+## Integration tests
+
+The specs in this directory expect a working Rexster server. The easiest way
+to get one is to download rexster from
+https://github.com/tinkerpop/rexster/wiki/Downloads
+and run a local server with `bin/rexster.sh -s`.
+
+If you would rather run against an existing server you can do so by setting the
+`REXPRO_HOST` and/or `REXPRO_PORT` env vars, e.g.:
+
+```
+REXPRO_HOST=rexster-server bundle exec rake integration_tests
+```

data/spec/integration/client_spec.rb

@@ -0,0 +1,35 @@
+require 'minitest/autorun'
+require_relative './integration_helper'
+require 'rexpro'
+
+describe Rexpro::Client do
+  include IntegrationHelper
+
+  subject { Rexpro::Client.new(client_opts) }
+
+  it 'connects' do
+    with_connect_notice do
+      subject.socket.closed?.must_equal false
+    end
+  end
+
+  describe '#new_session' do
+    it 'opens a new session' do
+      session = subject.new_session
+      session.uuid.bytesize.must_equal 16
+    end
+  end
+
+  describe '#execute' do
+    it 'executes a script' do
+      resp = subject.execute('1')
+      resp.results.must_equal 1
+    end
+
+    it 'raises errors' do
+      proc do
+        subject.execute(']invalid script[')
+      end.must_raise Rexpro::RexproError
+    end
+  end
+end

data/spec/integration/integration_helper.rb

@@ -0,0 +1,24 @@
+module IntegrationHelper
+  def client_opts
+    %w[host port].inject({}) do |memo, key|
+      value = ENV["REXPRO_#{key.upcase}"]
+      memo[key.to_sym] = value if value
+      memo
+    end
+  end
+
+  @@notice_shown = false
+
+  def with_connect_notice(&blk)
+    yield
+  rescue SocketError, Errno::ECONNREFUSED
+    unless @@notice_shown
+      puts '!' * 65,
+           'It looks like the client failed to connect. Make sure a server is',
+           'running and that REXPRO_HOST and REXPRO_PORT are set if needed.',
+           '!' * 65
+      @notice_shown = true
+    end
+    raise
+  end
+end

data/spec/integration/session_spec.rb

@@ -0,0 +1,29 @@
+require 'minitest/autorun'
+require_relative './integration_helper'
+require 'rexpro'
+
+describe Rexpro::Session do
+  include IntegrationHelper
+
+  subject { Rexpro::Client.new(client_opts).new_session }
+
+  it 'is a session' do
+    with_connect_notice do
+      subject.must_be_instance_of Rexpro::Session
+    end
+  end
+
+  describe '#execute' do
+    it 'executes a script in the session' do
+      resp = subject.execute('1')
+      resp.session_uuid.must_equal subject.uuid
+    end
+  end
+
+  describe '#kill' do
+    it 'ends the session' do
+      resp = subject.kill
+      resp.session_uuid.must_equal Rexpro::Message::ZERO_UUID
+    end
+  end
+end

data/spec/message_spec.rb

@@ -0,0 +1,65 @@
+# encoding: utf-8
+
+require 'minitest/autorun'
+require 'stringio'
+
+require 'rexpro'
+
+describe Rexpro::Message do
+  describe '.generate_uuid' do
+    let(:uuid) { Rexpro::Message.generate_uuid }
+
+    it 'generates 16 byte strings' do
+      uuid.bytesize.must_equal 16
+    end
+
+    it 'generates unique strings' do
+      uuid.wont_equal Rexpro::Message.generate_uuid
+    end
+  end
+
+  describe '.read_from' do
+    let(:data) { "\x00\x00\x00\x00\x00/\x94\xB01234567812345678" +
+                 "\xB0abcdefghijklmnop\x81\xA4flag\a\xA4boom" }
+    let(:io) { StringIO.new data }
+    let(:msg) { Rexpro::Message.read_from(io) }
+
+    it 'correctly parses data' do
+      msg.must_be_instance_of Rexpro::Message::Error
+      msg.session_uuid.must_equal '1234567812345678'
+      msg.request_uuid.must_equal 'abcdefghijklmnop'
+      msg.error_message.must_equal 'boom'
+      msg.flag.must_equal 7
+    end
+
+    it 'is symmetrical with #write_to' do
+      out = StringIO.new ''
+      msg.write_to(out)
+      out.string.must_equal data
+    end
+  end
+end
+
+describe Rexpro::Message::SessionRequest do
+  let(:request_uuid) { '1234567812345678' }
+  subject { Rexpro::Message::SessionRequest.new request_uuid: request_uuid }
+
+  describe '#write_to' do
+    let(:io) { StringIO.new '' }
+
+    it 'correctly writes to the io object' do
+      subject.session_uuid = 'abcdefghijklmnop'
+      subject.write_to(io)
+      io.string.must_equal "\x00\x01\x00\x00\x00'\x96\xB0abcdefghijklmnop" +
+                           "\xB01234567812345678\x80\x02\xA0\xA0"
+    end
+
+    it 'is symmetrical with .read_from' do
+      subject.write_to(io)
+      io.rewind
+      msg = Rexpro::Message.read_from(io)
+      msg.must_be_instance_of Rexpro::Message::SessionRequest
+      msg.request_uuid.must_equal subject.request_uuid
+    end
+  end
+end

metadata

@@ -0,0 +1,132 @@
+--- !ruby/object:Gem::Specification
+name: rexpro
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Lann Martin
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-05-09 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: msgpack
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.5.4
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.5.4
+- !ruby/object:Gem::Dependency
+  name: uuid
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.3.7
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.3.7
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: RexPro, a binary protocol for Rexster
+email:
+- lann@causes.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/rexpro.rb
+- lib/rexpro/client.rb
+- lib/rexpro/message.rb
+- lib/rexpro/session.rb
+- lib/rexpro/version.rb
+- rexpro.gemspec
+- spec/integration/README.md
+- spec/integration/client_spec.rb
+- spec/integration/integration_helper.rb
+- spec/integration/session_spec.rb
+- spec/message_spec.rb
+homepage: ''
+licenses:
+- MIT
+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.23
+signing_key: 
+specification_version: 3
+summary: RexPro is a binary protocol for Rexster that can be used to send Gremlin
+  scripts to a remote Rexster instance.
+test_files:
+- spec/integration/README.md
+- spec/integration/client_spec.rb
+- spec/integration/integration_helper.rb
+- spec/integration/session_spec.rb
+- spec/message_spec.rb