Elaios

gem 'elaios'

require 'elaios'

elaios_requester = Elaios::Requester.new

# Call a JSON-RPC method and don't expect a response.
elaios_requester.foo(['some', 'args'])

# Call a JSON-RPC method and expect a response.
elaios_requester.bar(['some', 'other', 'args']) do |data|
  # Do something with the response from the server...
end

request_1 = elaios_requester.pop
request_2 = elaios_requester.pop
# Send the requests to the server somehow (they will be JSON strings)...

# Get a response from the server somehow (it will be a JSON string). This will
# trigger the callback above to be called.
elaios_requester << response

elaios_server = Elaios::Responder.new

elaios_server.foo do |data|
  # Do some processing here...
end

elaios_server.bar do |data|
  # To send a success response...
  res(data['method'], data['id'], ['some', 'response'])

  # Or, to send an error response...
  err(data['method'], data['id'], 'Sorry, an error occurred.')
end

# Get JSON string requests from the client somehow. These will trigger the above
# callbacks to be called.
elaios_server << request_1
elaios_server << request_2

response = elaios_server.pop
# Send the response to the client somehow (it will be a JSON string).

# TCP client.
socket = TCPSocket.open('0.0.0.0', 5000)
elaios_requester = Elaios::Requester.new

# Incoming socket data.
Thread.new do
  loop do
    elaios_requester << socket.gets.chomp
  end
end

# Outgoing socket data.
Thread.new do
  loop do
    result = elaios_requester.pop
    socket.puts(result) if result
  end
end

# Make a service call and expect no response.
elaios_requester.ping('foo')

# Make a service call and expect a response.
elaios_requester.ping('foo') do |response|
  # Do something with the response...
end

# TCP server.
server = TCPServer.open(5000)
loop do
  # New incoming socket connection.
  Thread.fork(server.accept) do |socket|
    # We need a new Elaios instance for every incoming connection.
    elaios_responder = Elaios::Responder.new

    # Create a server handler.
    elaios_responder.ping do |data|
      # Generate some sort of response. Note that we grab the method name and id
      # from the `data` hash.
      #
      # Also note within this block, `self` is the `elaios_responder` object.
      #
      res(data['method'], data['id'], { foo: 'bar' })
    end

    # Incoming socket data.
    Thread.new do
      loop do
        elaios_responder << socket.gets.chomp
      end
    end

    # Outgoing socket data.
    loop do
      result = elaios_responder.pop
      socket.puts(result) if result
      sleep(Float::MIN)
    end
  end
end