Remove useless eunit include

Update to use couch_stats

Return ok for pattern matching in client code

Replace twig with couch_log

The couch_log functions are all two-arity

Remove vestigal call to margaret

We'll re-add the metric when couch_stats is merged.

Allow for timeout message while waiting for sender

In 9c36c1b0 we fixed counting bug in the bufffer but introduced another
one. We started asserting that the timeout message can only arrive when
the sender is not nil, but in fact it can absolutely happen that the
buffer is asked to deliver a message while one is in flight. This causes
the rexi_buffer to crash. The fix is to simply restore the clause that
ignores the timeout message if the server is waiting for a sender to
return.

BugzID: 32669

Fix error_limit = 0, and make it the default

Setting the error_limit to 0 would previously cause rexi_server to crash
on the next error because of an unhandled exception in a queue:drop/1.
This fixes that exception and makes a limit of 0 the default. Operators
can still raise the limit to capture errors in the future if we end up
finding that useful.

BugzID: 30821

Add max_count to state record

Fix counting bug in buffer

Quoting @davisp:

There's a bug in rexi_buffer that can lead to the counter in its state
running negative. I noticed this on malort looking for memory usage. A
quick reading of the code suggests its due to us getting a timeout
message with an empty queue. Theoretically this could happen if we've
exceeded the MAX_MEMORY threshold when sending a message or even with
just grabbing the buffered count when its idle.

BugzID: 28049

Configure buffer limit by message count

This allows an operator to decide how large the buffers should be. It
also provides an escape valve to clear the buffer entirely.

Slight style tweaks to rexi_buffer hibernation

Avoid using a possibly misleading variable name by not naming it.
Alternatively, this is not the variable name you are looking for.

BugzId: 27672

Hibernate rexi_buffer when becoming idle

The rexi_buffer gen_server can hold onto quite a bit of RAM during idle
operation. This just checks when we're going back to the idle state and
hibernates until the next message arrives. This ensures that we run
garbage collection before sitting idle.

BugzId: 27672

Removed upgrade statement in rexi:kill/2

Removing cruft we no longer need that was sending an extra useless
message.

BugzId: 27671

Revert "Tag all replies to the coordinator"

Not all rexi communication happens through `rexi_utils:recv/6`. We'll
need to audit all of our apps to see anywhere that doesn't to update to
the new message format.

This reverts commit 2f967906730eedf5851752be06155fc49edd28a1.

Rename governor to buffer

Buffer describes the behavior quite a bit better than governor.

BugzId: 23717
BugzId: 23718

Don't block the governor to send a message

This allows the governor to continue prioritizing incoming requests
instead of hanging for several seconds to try to connect to the remote
node.

BugzID: 23717
BugzID: 23718

Try to start per-node servers immediately

I can't think of a good reason not to do this.

Remove gov_manager from supervision

We'll remove the module itself in a subsequent release.

Start a supervised rexi_governor per node

This generalizes rexi_server_mon to start per-node versions of a server
specified by a child module.

BugzID: 23717
BugzID: 23718

Rejigger the governor implementation

Previously we'd spawn a number of processes to send messages to
'noconnect' / 'nosuspend' nodes.  Now we're buffering the messages that
need to be sent directly in each governor and sending them one at a
time.  This prevents the net_kernel from tipping over in the noconnect
case.  We also decide whether to drop messages based on memory
consumption in the node instead of process limits (since we're not
spawning anymore).

BugzID: 23717
BugzID: 23718

Remove old code_change, set module version to 1

Implement new stream2 API

This embeds the stream_init/1 logic into the stream functions so that we
don't have to maintain the logic for inititalizing the stream for all
clients.

BugzId: 24635

Allow callbacks to update their list of workers

We need this to be able to allow coordinators to replace nodes that are
in maintenance mode.

BugzId: 22729

Exit with timeout instead of returning an atom

Every function that called `rexi:stream/1` had to check the return value
for timeout and would then call `erlang:exit/1` if that atom were
returned. Rather than force every function to make this check this just
calls exit in `rexi:stream/1`. Its possible to catch this if a process
ever happens to require it.

BugzId: 22729

Implement new streaming APIs

This adds new functions that are used by coordinators and workers to
negotiate an RPC stream. A stream is simply any response that requires
multiple messages from the worker.

BugzId: 22729

Use '$initial_call' instead of initial_call

BugzID: 18742

Tag all replies to the coordinator

BugzID: 20204

Handle rexi-tagged messages

BugzID: 20204

Start per-node servers regardless of feature flag

Previously rexi_server_mon would fail to start per-node servers on a
node where the use of those servers in rexi:cast messages was disabled
by the "server_per_node" feature flag.  This mostly defeats the purpose
of the feature flag, which is to ensure that we can start all the
per-node servers before we try to use them.  Moreover, it cluttered up
the error logs because rexi_server_mon would crash after trying to
execute a `start_child` on rexi_server.

The fix is not DRY but it does the job well.

BugzID: 18970

Use the unadulterated node name in server name

BugzID: 18215

Add a temporary feature flag for server-per-node

[2/3] Start a rexi_server per remote node

Switch sending rexi messages to the rexi_server handling requests for
the local node. This replaces the use of the singleton rexi_server
process with a rexi_server instance for each node.

The only slight gotchya in the switch is that we need to send kill
messages to both the per-node and singleton instances during the
transition because we can't tell which process may have generated the
job. The extra kill message will be removed in the next commit.

[1/3] Start a rexi_server per remote node

This is part of a multi-release upgrade to switch to using a rexi_server
instance per remote node. The first commit introduces the new
rexi_server instances, the second switches to using the new instances
and the third will remove the singleton rexi_server. Each of these
commits should be in a separate release.

The new pattern introduced by this commit will start a 'rexi_server_%b'
process where the '%b' is replaced by the `erlang:phash2(Node)` for
which it will service requests. After the second commit is release each
rexi generated message will be sent to the rexi_server instance on the
remote node handling requests for the local node. The
`rexi_utils:server_pid/1` function is used to generate the id of the
remote server.

Change API to function per level

Switch to couch_log

Remove references to margaret

Build with rebar

Fix up copyright headers

New build system for rexi

Remove Cloudant build system remnants

Allow sending to anonymous remote PIDs

BugzID: 17296

Change startup order in rexi_sup

Ensures rexi_governor comes up before rexi_server. Also removed the custom appup

BugzID:17287

Add custom appup to start governor

Merge pull request #7 from cloudant/15608-too-much-spawning2

Install a governor to limit the amount of spawning we'll do to send messages to an unresponsive node.

BugzID: 15608

Pull settings from new config app

BugzID: 15608

Manage Excessive amount of spawned pids

rexi_utils:send uses the noconnect and nosuspend options in order to immediately
return to the controller and spawns new processes to actually send the messages, assuming
the remote node is only temporarily down. In the nosuspend case these pids
can hang around indefinitely and build up.

This patch sends the messages that need to be sent from spawned processes to a new
gen_server, rexi_manager, which manages a group of rexi_governors, one for each node.
The governor does the spawning and monitoring of the pids and keeps track of how many are sent.
If a node down message is received the manager sets a timer which when expired tells the appropriate
governor to kill all the pids waiting on that node. A cap prevents spawning of processes above
a certain amount, after which messages are dropped on the floor.

BugzID: 15608

Ignore some files

Whitespace

Merge pull request #6 from cloudant/16883-smaller-send-buffer

Reduce stream message limit

Reduce stream message limit

Its possible that a worker is starved out of running during the initial
spin up of worker processes. When there's a high Q running its possible
that a few of the workers are prevented from sending messages back which
ends up causing significant latency as they wait for other workers to
fill up their 100 message buffer and get swapped out.

Once they start sending though the view streams fine. While we don't
understand why some workers behave like this a quick fix is to just
reduce the size of the buffer so that we're not introducing as large of
a delay in the time to first byte.

Merge pull request #4 from cloudant/13311-improve-view-back-pressure

Implement message stream interface

BugzID: 13311
BugzID: 14075

Implement message stream interface

This allows workers to stream messages to a coordinator process which is
then responsible for acking each message. When a worker reaches a
configurable number of outstanding messages it will wait for acks before
continuing to send messages.

Provide a rexi:cast that uses erlang:send/2

Sometimes we want to have workers avoid deferring their casts to a
temporary process. This can lead to message pileups on the distribution
control sockets.

BugzID: 13469

Merge pull request #3 from cloudant/13298-remove-blocking-send

Don't block rexi_server to send a message

When a worker dies rexi_server needs to notify the remote client.  If
communication to the remote node is impaired rexi_server may block for
several seconds trying to send the rexi_EXIT message.

Fix is to use the same 'noconnect' and 'nosuspend' options in
rexi_server that we use to submit jobs from a client.

BugzID: 13298

Use a tagged version of twig

Remove unused variables

Merge pull request #2 from cloudant/12713-fail-rexi_DOWN-faster

BugzID: 12713

Remove an ancient debugging statement

Keep the DOWN notifications DRY

Fail fast if asked to monitor process on down node

BugzID: 12713

Track client pid in ets table

We need the client pid in order to respond to clients when the worker
crashes.

BugzID: 12344

Add an index keyed on client reference

This prevents table scans triggered by the kill handler from causing
the server to fall over under very high throughput.

I also took the opportunity to refactor a bit and use #job records
throughout the server instead of raw tuples.

BugzID: 12344

Use 'nosuspend' for all messages to remote nodes

The motivation for this change is to avoid suspending rexi clients
when 'busy_dist_port' events occur.

Do not allow sender to be suspended for any reason

Always provide the nonce to the spawned process

Small tweak to logging level

Use twig for logging

Remove old appup

Update rebar to 2cff499

Ignore unknown cast messages

This server needs to be bulletproof.

BugzID: 11762

Update spec to include accumulator in timeout response

BugzID: 11432

Include accumulator in timeout response, BugzID 11432

Fix a minor problem in the README and add a couple of links

Include the exception class in the #error{}

Move #error{} definition to rexi.hrl

Multi-faceted refactor of error logging

* Store errors as instances of internal #error{} record
* Move error buffer API calls to rexi.erl
* Don't badmatch if an old process exits abnormally
* Trivial rename of internal state fields

code_change for new server state

correct specification to allow undefined nonces

reduce code duplication in doit handler

keep init_p/2 around for a smoother upgrade

keep a circular buffer of errors cached in memory

bundle rebar

set version to `git describe` during rebar compile

relax return type of recv

log abnormal rexi worker deaths

b25b5b was sloppy, erlang:send_after/3 does not wrap w/ ok

use erlang:send_after/3 instead of timer version

http://www.erlang.org/doc/efficiency_guide/commoncaveats.html#id52228

let rebar manage the module lists

add README.md back in for apps

split some rexi utilities out from fabric

Apache 2 license, Cloudant copyright when appropriate

bah, missed a rename

kill was looking up the wrong ref(), so it never found anything

5 minute default timeout for sync_reply

thank you dialyzer

demonitor before killing the worker

switch to ets for managing the workers

update rexi.app to 1.2 to match dbcore 1.1.x numbering