class Sr::Jimson::ClientHelper

Constants

JSON_RPC_VERSION

Public Class Methods

make_id() click to toggle source
# File lib/sr/jimson/client.rb, line 11
def self.make_id
  rand(10**12)
end
new(url, opts = {}, namespace = nil) click to toggle source
# File lib/sr/jimson/client.rb, line 15
def initialize(url, opts = {}, namespace = nil)
  @url = url
  URI.parse(@url) # for the sake of validating the url
  @batch = []
  @opts = opts
  @namespace = namespace
  @opts[:content_type] = 'application/json'
end

Public Instance Methods

process_batch_response(responses) click to toggle source
# File lib/sr/jimson/client.rb, line 66
def process_batch_response(responses)
  responses.each do |resp|
    saved_response = @batch.map { |r| r[1] }.select { |r| r.id == resp['id'] }.first
    raise Client::Error::InvalidResponse.new if saved_response.nil?
    saved_response.populate!(resp)
  end
end
process_call(sym, args) click to toggle source
# File lib/sr/jimson/client.rb, line 24
def process_call(sym, args)
  resp = send_single_request(sym.to_s, args)

  begin
    data = MultiJson.load(resp, :symbolize_keys => true)
  rescue
    raise Client::Error::InvalidJSON.new(resp)
  end

  return process_single_response(data)

  rescue Exception, StandardError => e
    e.extend(Client::Error) unless e.is_a?(Client::Error)
    raise e
end
process_single_response(data) click to toggle source
# File lib/sr/jimson/client.rb, line 74
def process_single_response(data)
  raise Client::Error::InvalidResponse.new if !valid_response?(data)

  if !!data[:error]
    code = data[:error][:code]
    msg = data[:error][:message]
    raise Client::Error::ServerError.new(code, msg)
  end

  return data[:result]
end
push_batch_request(request) click to toggle source
# File lib/sr/jimson/client.rb, line 111
def push_batch_request(request)
  request.id = self.class.make_id
  response = Response.new(request.id)
  @batch << [request, response]
  return response
end
send_batch() click to toggle source
# File lib/sr/jimson/client.rb, line 118
def send_batch
  batch = @batch.map(&:first) # get the requests
  response = send_batch_request(batch)

  begin
    responses = MultiJson.load(response, :symbolize_keys)
  rescue
    raise Client::Error::InvalidJSON.new(json)
  end

  process_batch_response(responses)
  @batch = []
end
send_batch_request(batch) click to toggle source
# File lib/sr/jimson/client.rb, line 56
def send_batch_request(batch)
  post_data = MultiJson.dump(batch)
  resp = RestClient.post(@url, post_data, @opts)
  if resp.nil? || resp.body.nil? || resp.body.empty?
    raise Client::Error::InvalidResponse.new
  end

  return resp.body
end
send_single_request(method, args) click to toggle source
# File lib/sr/jimson/client.rb, line 40
def send_single_request(method, args)
  namespaced_method = @namespace.nil? ? method : "#@namespace#{method}"
  post_data = MultiJson.dump({
    'jsonrpc' => JSON_RPC_VERSION,
    'method'  => namespaced_method,
    'params'  => args,
    'id'      => self.class.make_id
  })
  resp = RestClient.post(@url, post_data, @opts)
  if resp.nil? || resp.body.nil? || resp.body.empty?
    raise Client::Error::InvalidResponse.new
  end

  return resp.body
end
valid_response?(data) click to toggle source
# File lib/sr/jimson/client.rb, line 86
def valid_response?(data)
  return false if !data.is_a?(Hash)

  return false if data[:jsonrpc] != JSON_RPC_VERSION

  return false if !data.has_key?(:id)

  return false if data.has_key?(:error) && data.has_key?(:result)

  if data.has_key?(:error)
    if !data[:error].is_a?(Hash) || !data[:error].has_key?(:code) || !data[:error].has_key?(:message)
      return false
    end

    if !data[:error][:code].is_a?(Fixnum) || !data[:error][:message].is_a?(String)
      return false
    end
  end

  return true

  rescue
    return false
end