jubatus 0.4.1 → 0.5.0

data/lib/jubatus/common/client.rb

@@ -0,0 +1,83 @@
+module Jubatus
+module Common
+
+class InterfaceMismatch < Exception; end
+class UnknownMethod < InterfaceMismatch; end
+class TypeMismatch < InterfaceMismatch; end
+
+class Client
+  def initialize(client, name)
+    @client = client
+    @name = name
+  end
+
+  def call(method, args, ret_type, args_type)
+    if args.size != args_type.size
+      raise "number of arguemnts for \"%s\" must to be %d, but %d arguments are given" % [method, args_type.size, args.size]
+    end
+    values = [@name]
+    args.zip(args_type).each do |v, t|
+      values << t.to_msgpack(v)
+    end
+    future = @client.call_async_apply(method, values)
+    future.attach_error_handler do |error, result|
+      error_handler(error, result)
+    end
+    ret = future.get
+
+    if ret_type != nil
+      return ret_type.from_msgpack(ret)
+    end
+  end
+
+  def error_handler(error, result)
+    if error == 1
+      raise UnknownMethod
+    elsif error == 2
+      raise TypeMismatch
+    else
+      raise MessagePack::RPC::RPCError.create(error, result)
+    end
+  end
+end
+
+class ClientBase
+  def initialize(host, port, name, timeout_sec)
+    @cli = MessagePack::RPC::Client.new(host, port)
+    @cli.timeout = timeout_sec
+    @jubatus_client = Jubatus::Common::Client.new(@cli, name)
+  end
+
+  def self.connect(host, port, name, timeout_sec, &block)
+    begin
+      client = self.new(host, port, name, timeout_sec)
+      block.call(client)
+    ensure
+      client.get_client.close
+    end
+  end
+
+  def get_client
+    @cli
+  end
+
+  def get_config
+    @jubatus_client.call("get_config", [], TString.new, [])
+  end
+
+  def save(id)
+    @jubatus_client.call("save", [id], TBool.new, [TString.new])
+  end
+
+  def load(id)
+    @jubatus_client.call("load", [id], TBool.new, [TString.new])
+  end
+
+  def get_status
+    @jubatus_client.call("get_status", [], TMap.new(TString.new, TMap.new(
+        TString.new, TString.new)), [])
+  end
+end
+
+end
+end

data/lib/jubatus/common/datum.rb

@@ -0,0 +1,85 @@
+require 'jubatus/common'
+module Jubatus
+module Common
+
+class Datum
+  include Jubatus::Common
+  TYPE = TTuple.new(TList.new(TTuple.new(TString.new, TString.new)),
+                    TList.new(TTuple.new(TString.new, TFloat.new)),
+                    TList.new(TTuple.new(TString.new, TString.new)))
+
+  def initialize(values = {})
+    @string_values = []
+    @num_values = []
+    @binary_values = []
+    values.each { |k, v|
+      raise TypeError unless String === k
+      if String === v
+        @string_values << [k, v]
+      elsif Integer === v
+        @num_values << [k, v.to_f]
+      elsif Float === v
+        @num_values << [k, v]
+      else
+        raise TypeError
+      end
+    }
+  end
+
+  def add_string(key, value)
+    raise TypeError unless String === key
+    if String === value
+      @string_values << [k, v]
+    else
+      raise TypeError
+    end
+  end
+
+  def add_number(key, value)
+    raise TypeError unless String === key
+    if Integer === v
+      @num_values << [k, v.to_f]
+    elsif Float === v
+      @num_values << [k, v]
+    else
+      raise TypeError
+    end
+  end
+
+  def add_binary(key, value)
+    raise TypeError unless String === key
+    if String === value
+      @binary_values << [k, v]
+    else
+      raise TypeError
+    end
+  end
+
+  def to_msgpack(out = '')
+    t = [@string_values, @num_values, @binary_values]
+    return TYPE.to_msgpack(t)
+  end
+
+  def Datum.from_msgpack(m)
+    val = TYPE.from_msgpack(m)
+    d = Datum.new
+    d.string_values.concat(m[0])
+    d.num_values.concat(m[1])
+    d.binary_values.concat(m[2])
+    return d
+  end
+
+  def to_s
+    gen = Jubatus::Common::MessageStringGenerator.new
+    gen.open("datum")
+    gen.add("string_values", @string_values)
+    gen.add("num_values", @num_values)
+    gen.add("binary_values", @binary_values)
+    gen.close()
+    return gen.to_s
+  end
+  attr_reader :string_values, :num_values, :binary_values
+end
+
+end
+end

data/lib/jubatus/common/message_string_generator.rb

@@ -0,0 +1,41 @@
+module Jubatus
+module Common
+
+class MessageStringGenerator
+  OPEN = "{"
+  COLON = ": "
+  DELIMITER = ", "
+  CLOSE = "}"
+
+  def initialize()
+    @buf = []
+    @first = true
+  end
+
+  def open(typ)
+    @buf << typ.to_s
+    @buf << OPEN
+  end
+
+  def add(key, value)
+    if @first
+      @first = false
+    else
+      @buf << DELIMITER
+    end
+    @buf << key.to_s
+    @buf << COLON
+    @buf << value.to_s
+  end
+
+  def close
+    @buf << CLOSE
+  end
+
+  def to_s
+    @buf.join
+  end
+end
+
+end
+end

data/lib/jubatus/common/types.rb

@@ -0,0 +1,247 @@
+module Jubatus
+module Common
+
+class TypeError < Exception; end
+class ValueError < Exception; end
+
+def self.check_type(value, typ)
+  if not (typ === value)
+    raise TypeError, "type %s is expected, but %s is given" % [typ, value.class]
+  end
+end
+
+def self.check_types(value, types)
+  types.each do |t|
+    return if t === value
+  end
+  t = types.map { |t| t.to_s }.join(", ")
+  raise TypeError, "type %s is expected, but %s is given" % [t, value.class]
+end
+
+class TPrimitive
+  def initialize(types)
+    @types = types
+  end
+
+  def from_msgpack(m)
+    Jubatus::Common.check_types(m, @types)
+    return m
+  end
+
+  def to_msgpack(m)
+    Jubatus::Common.check_types(m, @types)
+    return m
+  end
+end
+
+class TInt < TPrimitive
+  def initialize(signed, byts)
+    if signed
+      @max = (1 << (8 * byts - 1)) - 1
+      @min = - (1 << (8 * byts - 1))
+    else
+      @max = (1 << (8 * byts)) - 1
+      @min = 0
+    end
+  end
+
+  def from_msgpack(m)
+    Jubatus::Common.check_type(m, Integer)
+    if not (@min <= m and m <= @max)
+      raise ValueError, "int value must be in (%d, %d), but %d is given" % [@min, @max, m]
+    end
+    return m
+  end
+
+  def to_msgpack(m)
+    Jubatus::Common.check_type(m, Integer)
+    if not (@min <= m and m <= @max)
+      raise ValueError, "int value must be in (%d, %d), but %d is given" % [@min, @max, m]
+    end
+    return m
+  end
+end
+
+class TFloat < TPrimitive
+  def initialize
+    super([Float])
+  end
+end
+
+class TBool < TPrimitive
+  def initialize
+    super([TrueClass, FalseClass])
+  end
+end
+
+class TString < TPrimitive
+  def initialize()
+    super([String])
+  end
+end
+
+class TDatum
+  def from_msgpack(m)
+    Jubatus::Common::Datum.from_msgpack(m)
+  end
+
+  def to_msgpack(m)
+    Jubatus::Common.check_type(m, Jubatus::Common::Datum)
+    m.to_msgpack()
+  end
+end
+
+class TRaw < TPrimitive
+  def initialize()
+    super([String])
+  end
+end
+
+class TNullable
+  def initialize(type)
+    @type = type
+  end
+
+  def from_msgpack(m)
+    if m.nil?
+      return nil
+    else
+      @type.from_msgpack(m)
+    end
+  end
+
+  def to_msgpack(m)
+    if m.nil?
+      nil
+    else
+      @type.to_msgpack(m)
+    end
+  end
+end
+
+class TList
+  def initialize(type)
+    @type = type
+  end
+
+  def from_msgpack(m)
+    Jubatus::Common.check_type(m, Array)
+    return m.map { |v| @type.from_msgpack(v) }
+  end
+
+  def to_msgpack(m)
+    Jubatus::Common.check_type(m, Array)
+    return m.map { |v| @type.to_msgpack(v) }
+  end
+end
+
+class TMap
+  def initialize(key, value)
+    @key = key
+    @value = value
+  end
+
+  def from_msgpack(m)
+    Jubatus::Common.check_type(m, Hash)
+    dic = {}
+    m.each do |k, v|
+      dic[@key.from_msgpack(k)] = @value.from_msgpack(v)
+    end
+    return dic
+  end
+
+  def to_msgpack(m)
+    Jubatus::Common.check_type(m, Hash)
+    dic = {}
+    m.each do |k, v|
+      dic[@key.to_msgpack(k)] = @value.to_msgpack(v)
+    end
+    return dic
+  end
+end
+
+class TTuple
+  def initialize(*types)
+    @types = types
+  end
+
+  def check_tuple(m)
+    Jubatus::Common.check_type(m, Array)
+    if m.size != @types.size
+      raise TypeError, "size of tuple is %d, but %d is expected: %s" % [m.size, @types.size, m.to_s]
+    end
+  end
+
+  def from_msgpack(m)
+    check_tuple(m)
+    tpl = []
+    @types.zip(m).each do |type, x|
+      tpl << type.from_msgpack(x)
+    end
+    return tpl
+  end
+
+  def to_msgpack(m)
+    check_tuple(m)
+    tpl = []
+    @types.zip(m).each do |type, x|
+      tpl << type.to_msgpack(x)
+    end
+    return tpl
+  end
+end
+
+class TUserDef
+  def initialize(type)
+    @type = type
+  end
+
+  def from_msgpack(m)
+    return @type.from_msgpack(m)
+  end
+
+  def to_msgpack(m)
+    if @type === m
+      return m.to_msgpack()
+    elsif Array === m
+      return @type::TYPE.to_msgpack(m)
+    else
+      raise TypeError, "type %s or Array are expected, but %s is given" % [@type, m.class]
+    end
+  end
+end
+
+class TObject
+  def from_msgpack(m)
+    return m
+  end
+
+  def to_msgpack(m)
+    return m
+  end
+end
+
+class TEnum
+  def initialize(values)
+    @values = values
+  end
+
+  def from_msgpack(m)
+    Jubatus::Common.check_type(m, Integer)
+    if not (@values.include?(m))
+      raise ValueError
+    end
+    return m
+  end
+
+  def to_msgpack(m)
+    Jubatus::Common.check_type(m, Integer)
+    if not (@values.inlcude?(m))
+      raise ValueError
+    end
+    return m
+  end
+end
+
+end
+end

data/lib/jubatus/common.rb

@@ -0,0 +1,4 @@
+require 'jubatus/common/message_string_generator'
+require 'jubatus/common/types'
+require 'jubatus/common/datum'
+require 'jubatus/common/client'

data/lib/jubatus/graph/client.rb

@@ -1,92 +1,115 @@
-# This file is auto-generated from graph.idl
+# This file is auto-generated from graph.idl(0.4.5-347-g86989a6) with jenerator version 0.4.5-418-gd2d5f04/develop
 # *** DO NOT EDIT ***
 
 require 'rubygems'
 require 'msgpack/rpc'
+require 'jubatus/common'
 require File.join(File.dirname(__FILE__), 'types')
 
 module Jubatus
+
 module Graph
 module Client
 
-class Graph
-  def initialize(host, port)
-    @cli = MessagePack::RPC::Client.new(host, port)
-  end
-  def get_client
-    @cli
-  end
-  def get_config(name)
-    @cli.call(:get_config, name)
-  end
-  def create_node(name)
-    @cli.call(:create_node, name)
+class Graph < Jubatus::Common::ClientBase
+  include Jubatus::Common
+  def initialize(host, port, name, timeout_sec=10)
+    super
   end
-  def remove_node(name, node_id)
-    @cli.call(:remove_node, name, node_id)
-  end
-  def update_node(name, node_id, property)
-    @cli.call(:update_node, name, node_id, property)
-  end
-  def create_edge(name, node_id, e)
-    @cli.call(:create_edge, name, node_id, e)
+
+  def create_node
+    @jubatus_client.call("create_node", [], TString.new, [])
   end
-  def update_edge(name, node_id, edge_id, e)
-    @cli.call(:update_edge, name, node_id, edge_id, e)
+
+  def remove_node(node_id)
+    @jubatus_client.call("remove_node", [node_id], TBool.new, [TString.new])
   end
-  def remove_edge(name, node_id, edge_id)
-    @cli.call(:remove_edge, name, node_id, edge_id)
+
+  def update_node(node_id, property)
+    @jubatus_client.call("update_node", [node_id, property], TBool.new,
+        [TString.new, TMap.new(TString.new, TString.new)])
   end
-  def get_centrality(name, node_id, centrality_type, query)
-    @cli.call(:get_centrality, name, node_id, centrality_type, query)
+
+  def create_edge(node_id, e)
+    @jubatus_client.call("create_edge", [node_id, e], TInt.new(false, 8),
+        [TString.new, TUserDef.new(Edge)])
   end
-  def add_centrality_query(name, query)
-    @cli.call(:add_centrality_query, name, query)
+
+  def update_edge(node_id, edge_id, e)
+    @jubatus_client.call("update_edge", [node_id, edge_id, e], TBool.new,
+        [TString.new, TInt.new(false, 8), TUserDef.new(Edge)])
   end
-  def add_shortest_path_query(name, query)
-    @cli.call(:add_shortest_path_query, name, query)
+
+  def remove_edge(node_id, edge_id)
+    @jubatus_client.call("remove_edge", [node_id, edge_id], TBool.new,
+        [TString.new, TInt.new(false, 8)])
   end
-  def remove_centrality_query(name, query)
-    @cli.call(:remove_centrality_query, name, query)
+
+  def get_centrality(node_id, centrality_type, query)
+    @jubatus_client.call("get_centrality", [node_id, centrality_type, query],
+        TFloat.new, [TString.new, TInt.new(true, 4), TUserDef.new(PresetQuery)])
   end
-  def remove_shortest_path_query(name, query)
-    @cli.call(:remove_shortest_path_query, name, query)
+
+  def add_centrality_query(query)
+    @jubatus_client.call("add_centrality_query", [query], TBool.new,
+        [TUserDef.new(PresetQuery)])
   end
-  def get_shortest_path(name, query)
-    @cli.call(:get_shortest_path, name, query)
+
+  def add_shortest_path_query(query)
+    @jubatus_client.call("add_shortest_path_query", [query], TBool.new,
+        [TUserDef.new(PresetQuery)])
   end
-  def update_index(name)
-    @cli.call(:update_index, name)
+
+  def remove_centrality_query(query)
+    @jubatus_client.call("remove_centrality_query", [query], TBool.new,
+        [TUserDef.new(PresetQuery)])
   end
-  def clear(name)
-    @cli.call(:clear, name)
+
+  def remove_shortest_path_query(query)
+    @jubatus_client.call("remove_shortest_path_query", [query], TBool.new,
+        [TUserDef.new(PresetQuery)])
   end
-  def get_node(name, node_id)
-    Node.from_tuple(@cli.call(:get_node, name, node_id))
+
+  def get_shortest_path(query)
+    @jubatus_client.call("get_shortest_path", [query], TList.new(TString.new),
+        [TUserDef.new(ShortestPathQuery)])
   end
-  def get_edge(name, node_id, edge_id)
-    Edge.from_tuple(@cli.call(:get_edge, name, node_id, edge_id))
+
+  def update_index
+    @jubatus_client.call("update_index", [], TBool.new, [])
   end
-  def save(name, id)
-    @cli.call(:save, name, id)
+
+  def clear
+    @jubatus_client.call("clear", [], TBool.new, [])
   end
-  def load(name, id)
-    @cli.call(:load, name, id)
+
+  def get_node(node_id)
+    @jubatus_client.call("get_node", [node_id], TUserDef.new(Node),
+        [TString.new])
   end
-  def get_status(name)
-    @cli.call(:get_status, name)
+
+  def get_edge(node_id, edge_id)
+    @jubatus_client.call("get_edge", [node_id, edge_id], TUserDef.new(Edge),
+        [TString.new, TInt.new(false, 8)])
   end
-  def create_node_here(name, node_id)
-    @cli.call(:create_node_here, name, node_id)
+
+  def create_node_here(node_id)
+    @jubatus_client.call("create_node_here", [node_id], TBool.new,
+        [TString.new])
   end
-  def remove_global_node(name, node_id)
-    @cli.call(:remove_global_node, name, node_id)
+
+  def remove_global_node(node_id)
+    @jubatus_client.call("remove_global_node", [node_id], TBool.new,
+        [TString.new])
   end
-  def create_edge_here(name, edge_id, e)
-    @cli.call(:create_edge_here, name, edge_id, e)
+
+  def create_edge_here(edge_id, e)
+    @jubatus_client.call("create_edge_here", [edge_id, e], TBool.new, [TInt.new(
+        false, 8), TUserDef.new(Edge)])
   end
 end
 
-end
-end
-end
+end  # Client
+end  # Graph
+
+end  # Jubatus