public
Description: Modular ruby RPC library with blocking and evented API (using EventMachine)
Homepage:
Clone URL: git://github.com/oleganza/emrpc.git
Click here to lend your support to: emrpc and make a donation at www.pledgie.com !
commit  d9535c00689e7161552acff194b5a34a08158193
tree    08054aec153645c9aefb24097346194d9d15428b
parent  952dbc939218c164f32bc5bafebba616b5af2d38
emrpc / TODO
100644 48 lines (38 sloc) 2.048 kb
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
 
IMPROVEMENTS
 
* Rev:
  * Rev::Server#on_connection: on_connect is called before @block.call:
    this is not how EM behaves. The order is crucial because we would like to
    pass some configuration with @block and use it inside on_connect/connection_completed callback.
    TODO: suggest a patch to Toni Arciery.
    
  * lib/rev/loop.rb:60 typo: EVFLAG_NOENV should be used instead of EVFLAG_NOEV
    TODO: suggest a patch to Toni Arciery.
 
* When running $ spec spec/ servers sometimes are not unbinded and some specs fail.
 * fixed issue with reconnecting pid.
 * MultithreadedClient spec fails randomly with 0 timed out threads:
    'EMRPC::MultithreadedClient with PoolTimeout should raise ThreadTimeout' FAILED
    expected: > 10,
         got: 0
    /Users/olegandreev/Work/emrpc.git/spec/blocking_api/multithreaded_client_spec.rb:49:
 * Transactions for MultithreadedClient to enable scheduling the same backend for all messages in a transaction.
   This can be implemented in two ways:
   1. Blocking: when transaction starts, backend is taken out of the queue while transaction is in process.
   2. Non-blocking: backend can be rescheduled to other messages while transaction is in process,
      but when it is needed again, system waits for that particular backend.
      Non-blocking option might seem more efficient, but it also might be less safe: what if you really should
      not interleave communication with the backend with foreign messages?
   
* SinglethreadedClient creates a messaging thread for each Pid. We should use some kind of
shared channel for a number of pids.
* Try to use Thread.critical instead of Queue.new to achive better performance.
 
FEATURES
 
* filters for messages (erlang-like receive() pattern-matching)
* passing particular objects through TCP
* resource discovery
* ring/chord protocol
* rack http server & http client
* Async DNS support
* REv along with eventmachine backend
 
TASKS
 
* Documentation and examples!
* Benchmark against DRb.
* Publish gem somewhere.
* Total world domination.