scalaroid 0.0.1

data/lib/scalaroid/json_connection.rb

@@ -0,0 +1,370 @@
+module Scalaroid
+  # Abstracts connections to Scalaris using JSON
+  class JSONConnection
+    # Creates a JSON connection to the given URL using the given TCP timeout (or default)
+    def initialize(url = DEFAULT_URL, timeout = nil)
+      begin
+        @uri = URI.parse(url)
+        @timeout = timeout
+        start
+      rescue Exception => error
+        raise ConnectionError.new(error)
+      end
+    end
+
+    def start
+      if @conn == nil or not @conn.started?
+        @conn = Net::HTTP.start(@uri.host, @uri.port)
+        unless @timeout.nil?
+          @conn.read_timeout = @timeout
+        end
+      end
+    end
+    private :start
+
+    # Calls the given function with the given parameters via the JSON
+    # interface of Scalaris.
+    def call(function, params)
+      start
+      req = Net::HTTP::Post.new(DEFAULT_PATH)
+      req.add_field('Content-Type', 'application/json; charset=utf-8')
+      req.body = URI::encode({
+        :jsonrpc => :'2.0',
+        :method => function,
+        :params => params,
+        :id => 0 }.to_json({:ascii_only => true}))
+      begin
+        res = @conn.request(req)
+        if res.is_a?(Net::HTTPSuccess)
+          data = res.body
+          return JSON.parse(data)['result']
+        else
+          raise ConnectionError.new(res)
+        end
+      rescue ConnectionError => error
+        raise error
+      rescue Exception => error
+        raise ConnectionError.new(error)
+      end
+    end
+
+    # Encodes the value to the form required by the Scalaris JSON API
+    def self.encode_value(value, binary = false)
+      if binary
+        return { :type => :as_bin, :value => Base64.encode64(value) }
+      else
+        return { :type => :as_is, :value => value }
+      end
+    end
+
+    # Decodes the value from the Scalaris JSON API form to a native type
+    def self.decode_value(value)
+      if not (value.has_key?('type') and value.has_key?('value'))
+        raise ConnectionError.new(value)
+      end
+      if value['type'] == 'as_bin'
+        return Base64.decode64(value['value'])
+      else
+        return value['value']
+      end
+    end
+
+    # Processes the result of some Scalaris operation and raises a
+    # TimeoutError if found.
+    #
+    # result: {'status': 'ok'} or
+    #         {'status': 'fail', 'reason': 'timeout'}
+    def self.check_fail_abort(result)
+      if result == {:status => 'fail', :reason => 'timeout'}
+        raise TimeoutError.new(result)
+      end
+    end
+
+    # Processes the result of a read operation.
+    # Returns the read value on success.
+    # Raises the appropriate exception if the operation failed.
+    #
+    # result: {'status' => 'ok', 'value': xxx} or
+    #         {'status' => 'fail', 'reason' => 'timeout' or 'not_found'}
+    def self.process_result_read(result)
+      if result.is_a?(Hash) and result.has_key?('status') and result.length == 2
+        if result['status'] == 'ok' and result.has_key?('value')
+          return decode_value(result['value'])
+        elsif result['status'] == 'fail' and result.has_key?('reason')
+          if result['reason'] == 'timeout'
+            raise TimeoutError.new(result)
+          elsif result['reason'] == 'not_found'
+            raise NotFoundError.new(result)
+          end
+        end
+      end
+      raise UnknownError.new(result)
+    end
+
+    # Processes the result of a write operation.
+    # Raises the appropriate exception if the operation failed.
+    #
+    # result: {'status' => 'ok'} or
+    #         {'status' => 'fail', 'reason' => 'timeout'}
+    def self.process_result_write(result)
+      if result.is_a?(Hash)
+        if result == {'status' => 'ok'}
+          return true
+        elsif result == {'status' => 'fail', 'reason' => 'timeout'}
+          raise TimeoutError.new(result)
+        end
+      end
+      raise UnknownError.new(result)
+    end
+
+    # Processes the result of a commit operation.
+    # Raises the appropriate exception if the operation failed.
+    #
+    # result: {'status' => 'ok'} or
+    #         {'status' => 'fail', 'reason' => 'abort', 'keys' => <list>} or
+    #         {'status' => 'fail', 'reason' => 'timeout'}
+    def self.process_result_commit(result)
+      if result.is_a?(Hash) and result.has_key?('status')
+        if result == {'status' => 'ok'}
+          return true
+        elsif result['status'] == 'fail' and result.has_key?('reason')
+          if result.length == 2 and result['reason'] == 'timeout'
+            raise TimeoutError.new(result)
+          elsif result.length == 3 and result['reason'] == 'abort' and result.has_key?('keys')
+            raise AbortError.new(result, result['keys'])
+          end
+        end
+      end
+      raise UnknownError.new(result)
+    end
+
+    # Processes the result of a add_del_on_list operation.
+    # Raises the appropriate exception if the operation failed.
+    #
+    # results: {'status': 'ok'} or
+    #          {'status': 'fail', 'reason': 'timeout' or 'not_a_list'}
+    def self.process_result_add_del_on_list(result)
+      if result.is_a?(Hash) and result.has_key?('status')
+        if result == {'status' => 'ok'}
+          return nil
+        elsif result['status'] == 'fail' and result.has_key?('reason')
+          if result.length == 2
+            if result['reason'] == 'timeout'
+              raise TimeoutError.new(result)
+            elsif result['reason'] == 'not_a_list'
+              raise NotAListError.new(result)
+            end
+          end
+        end
+      end
+      raise UnknownError.new(result)
+    end
+
+    # Processes the result of a add_on_nr operation.
+    # Raises the appropriate exception if the operation failed.
+    #
+    # results: {'status': 'ok'} or
+    #          {'status': 'fail', 'reason': 'timeout' or 'not_a_number'}
+    def self.process_result_add_on_nr(result)
+      if result.is_a?(Hash) and result.has_key?('status')
+        if result == {'status' => 'ok'}
+          return nil
+        elsif result['status'] == 'fail' and result.has_key?('reason')
+          if result.length == 2
+            if result['reason'] == 'timeout'
+              raise TimeoutError.new(result)
+            elsif result['reason'] == 'not_a_number'
+              raise NotANumberError.new(result)
+            end
+          end
+        end
+      end
+      raise UnknownError.new(result)
+    end
+
+    # Processes the result of a test_and_set operation.
+    # Raises the appropriate exception if the operation failed.
+    #
+    # results: {'status' => 'ok'} or
+    #          {'status' => 'fail', 'reason' => 'timeout' or 'not_found'} or
+    #          {'status' => 'fail', 'reason' => 'key_changed', 'value': xxx}
+    def self.process_result_test_and_set(result)
+      if result.is_a?(Hash) and result.has_key?('status')
+        if result == {'status' => 'ok'}
+          return nil
+        elsif result['status'] == 'fail' and result.has_key?('reason')
+          if result.length == 2
+            if result['reason'] == 'timeout'
+              raise TimeoutError.new(result)
+            elsif result['reason'] == 'not_found'
+              raise NotFoundError.new(result)
+            end
+          elsif result['reason'] == 'key_changed' and result.has_key?('value') and result.length == 3
+            raise KeyChangedError.new(result, decode_value(result['value']))
+          end
+        end
+      end
+      raise UnknownError.new(result)
+    end
+
+    # Processes the result of a publish operation.
+    # Raises the appropriate exception if the operation failed.
+    #
+    # results: {'status': 'ok'}
+    def self.process_result_publish(result)
+      if result == {'status' => 'ok'}
+        return nil
+      end
+      raise UnknownError.new(result)
+    end
+
+    # Processes the result of a subscribe operation.
+    # Raises the appropriate exception if the operation failed.
+    #
+    # results: {'status': 'ok'} or
+    #          {'status': 'fail', 'reason': 'timeout' or 'abort'}
+    def self.process_result_subscribe(result)
+      process_result_commit(result)
+    end
+
+    # Processes the result of a unsubscribe operation.
+    # Raises the appropriate exception if the operation failed.
+    #
+    # results: {'status': 'ok'} or
+    #          {'status': 'fail', 'reason': 'timeout' or 'abort' or 'not_found'}
+    def self.process_result_unsubscribe(result)
+      if result == {'status' => 'ok'}
+        return nil
+      elsif result.is_a?(Hash) and result.has_key?('status')
+        if result['status'] == 'fail' and result.has_key?('reason')
+          if result.length == 2
+            if result['reason'] == 'timeout'
+              raise TimeoutError.new(result)
+            elsif result['reason'] == 'not_found'
+              raise NotFoundError.new(result)
+            end
+          elsif result.length == 3 and result['reason'] == 'abort' and result.has_key?('keys')
+            raise AbortError.new(result, result['keys'])
+          end
+        end
+      end
+      raise UnknownError.new(result)
+    end
+
+    # Processes the result of a get_subscribers operation.
+    # Returns the list of subscribers on success.
+    # Raises the appropriate exception if the operation failed.
+    #
+    # results: [urls=str()]
+    def self.process_result_get_subscribers(result)
+      if result.is_a?(Array)
+        return result
+      end
+      raise UnknownError.new(result)
+    end
+
+    # Processes the result of a delete operation.
+    # Returns an Array of
+    # {:success => true | :timeout, :ok => <number of deleted items>, :results => <detailed results>}
+    # on success.
+    # Does not raise an exception if the operation failed unless the result
+    # is invalid!
+    #
+    # results: {'ok': xxx, 'results': ['ok' or 'locks_set' or 'undef']} or
+    #          {'failure': 'timeout', 'ok': xxx, 'results': ['ok' or 'locks_set' or 'undef']}
+    def self.process_result_delete(result)
+      if result.is_a?(Hash) and result.has_key?('ok') and result.has_key?('results')
+        if not result.has_key?('failure')
+          return {:success => true,
+            :ok => result['ok'],
+            :results => result['results']}
+        elsif result['failure'] == 'timeout'
+          return {:success => :timeout,
+            :ok => result['ok'],
+            :results => result['results']}
+        end
+      end
+      raise UnknownError.new(result)
+    end
+
+    # Creates a new DeleteResult from the given result list.
+    #
+    # result: ['ok' or 'locks_set' or 'undef']
+    def self.create_delete_result(result)
+      ok = 0
+      locks_set = 0
+      undefined = 0
+      if result.is_a?(Array)
+        for element in result
+          if element == 'ok'
+              ok += 1
+          elsif element == 'locks_set'
+              locks_set += 1
+          elsif element == 'undef'
+              undefined += 1
+          else
+            raise UnknownError.new(:'Unknown reason ' + element + :'in ' + result)
+          end
+        end
+        return DeleteResult.new(ok, locks_set, undefined)
+      end
+      raise UnknownError.new(:'Unknown result ' + result)
+    end
+
+    # Processes the result of a req_list operation of the Transaction class.
+    # Returns the Array (:tlog => <tlog>, :result => <result>) on success.
+    # Raises the appropriate exception if the operation failed.
+    #
+    # results: {'tlog': xxx,
+    #           'results': [{'status': 'ok'} or {'status': 'ok', 'value': xxx} or
+    #                       {'status': 'fail', 'reason': 'timeout' or 'abort' or 'not_found'}]}
+    def self.process_result_req_list_t(result)
+      if (not result.has_key?('tlog')) or (not result.has_key?('results')) or
+          (not result['results'].is_a?(Array))
+        raise UnknownError.new(result)
+      end
+      {:tlog => result['tlog'], :result => result['results']}
+    end
+
+    # Processes the result of a req_list operation of the TransactionSingleOp class.
+    # Returns <result> on success.
+    # Raises the appropriate exception if the operation failed.
+    #
+    # results: [{'status': 'ok'} or {'status': 'ok', 'value': xxx} or
+    #           {'status': 'fail', 'reason': 'timeout' or 'abort' or 'not_found'}]
+    def self.process_result_req_list_tso(result)
+      if not result.is_a?(Array)
+        raise UnknownError.new(result)
+      end
+      result
+    end
+
+    # Processes the result of a nop operation.
+    # Raises the appropriate exception if the operation failed.
+    #
+    # result: 'ok'
+    def self.process_result_nop(result)
+      if result != 'ok'
+        raise UnknownError.new(result)
+      end
+    end
+
+    # Returns a new ReqList object allowing multiple parallel requests for
+    # the Transaction class.
+    def self.new_req_list_t(other = nil)
+      JSONReqListTransaction.new(other)
+    end
+
+    # Returns a new ReqList object allowing multiple parallel requests for
+    # the TransactionSingleOp class.
+    def self.new_req_list_tso(other = nil)
+      JSONReqListTransactionSingleOp.new(other)
+    end
+
+    def close
+      if @conn.started?
+        @conn.finish()
+      end
+    end
+  end
+end

data/lib/scalaroid/version.rb

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

data/lib/scalaroid.rb

@@ -0,0 +1,108 @@
+#!/usr/bin/ruby -KU
+# Copyright 2008-2011 Zuse Institute Berlin
+#
+#    Licensed under the Apache License, Version 2.0 (the "License");
+#    you may not use this file except in compliance with the License.
+#    You may obtain a copy of the License at
+#
+#        http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS,
+#    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#    See the License for the specific language governing permissions and
+#    limitations under the License.
+
+require 'rubygems'
+gem 'json', '>=1.4.1'
+require 'json'
+require 'net/http'
+require 'base64'
+require 'open-uri'
+
+module InternalScalarisSimpleError
+  attr_reader :raw_result
+  def initialize(raw_result)
+    @raw_result = raw_result
+  end
+
+  def to_s
+    @raw_result
+  end
+end
+
+module InternalScalarisNopClose
+  # No operation (may be used for measuring the JSON overhead).
+  def nop(value)
+    value = @conn.class.encode_value(value)
+    result = @conn.call(:nop, [value])
+    @conn.class.process_result_nop(result)
+  end
+
+  # Close the connection to Scalaris
+  # (it will automatically be re-opened on the next request).
+  def close_connection
+    @conn.close()
+  end
+end
+
+# work around floating point numbers not being printed precisely enough
+class Float
+  # note: can not override to_json (this is not done recursively, e.g. in a Hash, before ruby 1.9)
+  alias_method :orig_t_s, :to_s
+  def to_s
+    if not finite?
+      orig_to_json(*a)
+    else
+      sprintf("%#.17g", self)
+    end
+  end
+end
+
+module Scalaroid
+  autoload :ScalarisError, "scalaroid/errors"
+  autoload :AbortError, "scalaroid/errors"
+  autoload :ConnectionError, "scalaroid/errors"
+  autoload :KeyChangedError, "scalaroid/errors"
+  autoload :NodeNotFoundError, "scalaroid/errors"
+  autoload :NotFoundError, "scalaroid/errors"
+  autoload :NotAListError, "scalaroid/errors"
+  autoload :NotANumberError, "scalaroid/errors"
+  autoload :TimeoutError, "scalaroid/errors"
+  autoload :UnknownError, "scalaroid/errors"
+
+  autoload :DeleteResult, "scalaroid/delete_result"
+  autoload :JSONConnection, "scalaroid/json_connection"
+  autoload :JSONReqList, "scalaroid/json_req_list"
+  autoload :JSONReqListTransaction, "scalaroid/json_req_list_transaction"
+  autoload :JSONReqListTransactionSingleOp, "scalaroid/json_req_list_transaction_single_op"
+  autoload :PubSub, "scalaroid/pub_sub"
+  autoload :ReplicatedDHT, "scalaroid/replicated_dht"
+  autoload :Transaction, "scalaroid/transaction"
+  autoload :TransactionSingleOp, "scalaroid/transaction_single_op"
+  autoload :VERSION, "scalaroid/version"
+
+  # default URL and port to a scalaris node
+  if ENV.has_key?('SCALARIS_JSON_URL') and not ENV['SCALARIS_JSON_URL'].empty?
+    DEFAULT_URL = ENV['SCALARIS_JSON_URL']
+  else
+    DEFAULT_URL = 'http://localhost:8000'
+  end
+
+  # path to the json rpc page
+  DEFAULT_PATH = '/jsonrpc.yaws'
+
+
+  # Converts a string to a list of integers.
+  # If the expected value of a read operation is a list, the returned value
+  # could be (mistakenly) a string if it is a list of integers.
+  def str_to_list(value)
+    if value.is_a?(String)
+      return value.unpack("U*")
+    else
+      return value
+    end
+  end
+
+  module_function :str_to_list
+end

data/scalaroid.gemspec

@@ -0,0 +1,48 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
+# -*- encoding: utf-8 -*-
+# stub: scalaroid 0.0.1 ruby lib
+
+Gem::Specification.new do |s|
+  s.name = "scalaroid"
+  s.version = "0.0.1"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.require_paths = ["lib"]
+  s.authors = ["Teodor Pripoae"]
+  s.date = "2014-07-07"
+  s.description = "Ruby bindings for Scalaris forked from official Scalaris bindings"
+  s.email = "teodor.pripoae@gmail.com"
+  s.executables = ["scalaroid"]
+  s.extra_rdoc_files = [
+    "LICENSE.txt"
+  ]
+  s.files = [
+    ".document",
+    "Gemfile",
+    "Gemfile.lock",
+    "LICENSE.txt",
+    "Rakefile",
+    "bin/scalaroid",
+    "lib/scalaroid.rb",
+    "lib/scalaroid/json_connection.rb",
+    "lib/scalaroid/version.rb",
+    "scalaroid.gemspec",
+    "test/replicated_dht_test.rb",
+    "test/test_helper.rb",
+    "test/test_pub_sub.rb",
+    "test/transaction_single_op_test.rb",
+    "test/transaction_test.rb"
+  ]
+  s.homepage = "http://github.com/teodor-pripoae/scalaroid"
+  s.licenses = ["Apache-2.0"]
+  s.rubygems_version = "2.2.2"
+  s.summary = "Ruby bindings for Scalaris"
+
+  s.add_runtime_dependency(%q<json>, ["~> 1.7"])
+  s.add_development_dependency(%q<rake>, ["~> 10.0"])
+  s.add_development_dependency(%q<minitest>, ["~> 5.3"])
+  s.add_development_dependency(%q<pry>, ["= 0.9.12.6"])
+  s.add_development_dependency(%q<bundler>, ["~> 1.0"])
+end

data/test/replicated_dht_test.rb

@@ -0,0 +1,143 @@
+require_relative "test_helper"
+
+class TestReplicatedDHT < Minitest::Test
+  def setup
+    @testTime = (Time.now.to_f * 1000).to_i
+  end
+
+  # Test method for ReplicatedDHT()
+  def test_replicated_dht1()
+    rdht = Scalaroid::ReplicatedDHT.new()
+    rdht.close_connection()
+  end
+
+  # Test method for ReplicatedDHT(conn)
+  def test_replicated_dht2()
+    rdht = Scalaroid::ReplicatedDHT.new(conn = Scalaroid::JSONConnection.new(url = Scalaroid::DEFAULT_URL))
+    rdht.close_connection()
+  end
+
+  # Test method for ReplicatedDHT.close_connection() trying to close the connection twice.
+  def test_double_close()
+    rdht = Scalaroid::ReplicatedDHT.new()
+    rdht.close_connection()
+    rdht.close_connection()
+  end
+
+  # Tries to read the value at the given key and fails if this does
+  # not fail with a NotFoundError.
+  def _checkKeyDoesNotExist(key)
+    conn = Scalaroid::TransactionSingleOp.new()
+    begin
+      conn.read(key)
+      assert(false, 'the value at ' + key + ' should not exist anymore')
+    rescue Scalaroid::NotFoundError
+      # nothing to do here
+    end
+    conn.close_connection()
+  end
+
+  # Test method for ReplicatedDHT.delete(key).
+  # Tries to delete some not existing keys.
+  def test_delete_not_existing_key()
+    key = "_Delete_NotExistingKey"
+    rdht = Scalaroid::ReplicatedDHT.new()
+
+    (0..($_TEST_DATA.length - 1)).each do |i|
+      ok = rdht.delete(@testTime.to_s + key + i.to_s)
+      assert_equal(0, ok)
+      results = rdht.get_last_delete_result()
+      assert_equal(0, results.ok)
+      assert_equal(0, results.locks_set)
+      assert_equal(4, results.undefined)
+      _checkKeyDoesNotExist(@testTime.to_s + key + i.to_s)
+    end
+
+    rdht.close_connection()
+  end
+
+  # Test method for ReplicatedDHT.delete(key) and TransactionSingleOp#write(key, value=str()).
+  # Inserts some values, tries to delete them afterwards and tries the delete again.
+  def test_delete1()
+    key = "_Delete1"
+    c = Scalaroid::JSONConnection.new(url = Scalaroid::DEFAULT_URL)
+    rdht = Scalaroid::ReplicatedDHT.new(conn = c)
+    sc = Scalaroid::TransactionSingleOp.new(conn = c)
+
+    (0..($_TEST_DATA.length - 1)).each do |i|
+      sc.write(@testTime.to_s + key + i.to_s, $_TEST_DATA[i])
+    end
+
+    # now try to delete the data:
+    (0..($_TEST_DATA.length - 1)).each do |i|
+      ok = rdht.delete(@testTime.to_s + key + i.to_s)
+      assert_equal(4, ok)
+      results = rdht.get_last_delete_result()
+      assert_equal(4, results.ok)
+      assert_equal(0, results.locks_set)
+      assert_equal(0, results.undefined)
+      _checkKeyDoesNotExist(@testTime.to_s + key + i.to_s)
+
+      # try again (should be successful with 0 deletes)
+      ok = rdht.delete(@testTime.to_s + key + i.to_s)
+      assert_equal(0, ok)
+      results = rdht.get_last_delete_result()
+      assert_equal(0, results.ok)
+      assert_equal(0, results.locks_set)
+      assert_equal(4, results.undefined)
+      _checkKeyDoesNotExist(@testTime.to_s + key + i.to_s)
+    end
+
+    c.close()
+  end
+
+  # Test method for ReplicatedDHT.delete(key) and TransactionSingleOp#write(key, value=str()).
+  # Inserts some values, tries to delete them afterwards, inserts them again and tries to delete them again (twice).
+  def test_delete2()
+    key = "_Delete2"
+    c = Scalaroid::JSONConnection.new(url = Scalaroid::DEFAULT_URL)
+    rdht = Scalaroid::ReplicatedDHT.new(conn = c)
+    sc = Scalaroid::TransactionSingleOp.new(conn = c)
+
+    (0..($_TEST_DATA.length - 1)).each do |i|
+      sc.write(@testTime.to_s + key + i.to_s, $_TEST_DATA[i])
+    end
+
+    # now try to delete the data:
+    (0..($_TEST_DATA.length - 1)).each do |i|
+      ok = rdht.delete(@testTime.to_s + key + i.to_s)
+      assert_equal(4, ok)
+      results = rdht.get_last_delete_result()
+      assert_equal(4, results.ok)
+      assert_equal(0, results.locks_set)
+      assert_equal(0, results.undefined)
+      _checkKeyDoesNotExist(@testTime.to_s + key + i.to_s)
+    end
+
+    (0..($_TEST_DATA.length - 1)).each do |i|
+      sc.write(@testTime.to_s + key + i.to_s, $_TEST_DATA[i])
+    end
+
+    # now try to delete the data:
+    (0..($_TEST_DATA.length - 1)).each do |i|
+      ok = rdht.delete(@testTime.to_s + key + i.to_s)
+      assert_equal(4, ok)
+      results = rdht.get_last_delete_result()
+      assert_equal(4, results.ok)
+      assert_equal(0, results.locks_set)
+      assert_equal(0, results.undefined)
+      _checkKeyDoesNotExist(@testTime.to_s + key + i.to_s)
+
+      # try again (should be successful with 0 deletes)
+      ok = rdht.delete(@testTime.to_s + key + i.to_s)
+      assert_equal(0, ok)
+      results = rdht.get_last_delete_result()
+      assert_equal(0, results.ok)
+      assert_equal(0, results.locks_set)
+      assert_equal(4, results.undefined)
+      _checkKeyDoesNotExist(@testTime.to_s + key + i.to_s)
+    end
+
+    c.close()
+  end
+end