Fix possible infinite loop when using gdp_event_next with a GIN
specified. Version 2.1.17.
Update license date on all files. No functional changes.
Change (and document) defaults for event timeouts to be more realistic.
Debugging on reordering of asynchronous data retrieval. Finally appears
Second cut at sorting asynchronous data records. Currently all done with
simulation (-Dtest.gdp.chan.seqno=102 randomizes the incoming sequence
numbers), and so missing or duplicated incoming records have not been
First pass at ordering results of asynchronous reads. Works if the
reads come in pre-sorted, but so far untested for out-of-order delivery.
Additional debugging for events and PDU processing for debugging out of
order PDU problems.
Tweaks to hopefully do a better job of handling out-of-order results for
Make event queue a TAILQ instead of an STAILQ to avoid n2 algorithm
when results arrive in order.
First cut at fixing bug that sometimes caused an "End of Results" PDU to
be delivered before some of the results themselves. This involves
passing a "number of results sent" field in the "End of Results" PDU and
saving that PDU until the indicated number of results are processed....
Improvements to event and metadata printing.
Fix or expand on FIXME comments.
Cleanup signature and hash type handling. There's no point in storing
the MD algorithm with each datum since it is fixed per GOB, nor in
passing it over the wire since it is just a blob unless you have either
the secret or public key, either of which contain that information...
Change GDP_EVENT_EOS to GDP_EVENT_DONE, since it isn't specific to
subscriptions. Also documentation updates reflecting the datum changes
in the previous commit.
Snapshot: change physical interface to make more efficient use of SQLite
when retrieving sets. Use this for asynchronous reads.
It turns out that including a GOB pointer in the datum causes too many
locking problems. Just pass the gob in as needed.
The grand renaming: GCL is (mostly) gone in favor of GOB and GIN.
Simplify the datum interface back to what it was before. Basic
subscriptions and subscription timeout seems to work now.
Get basic subscriptions working again.
Checkpoint: basic create, write, read all work. Subscriptions, async
commands, and multireads untested.
Snapshot: compiles cleanly with updated protocol and crypto
support, but completely untested.
Rather non-intuitive changes to suppress "return value not used"
warning; just (void)ing the call no longer works.
Changes necessary to compile under C++ because it doesn't understand
that (void *) is compatible with other pointer types. This adds a lot
of explicit casts that are not needed in C.
Fix signature generation and checking.
First cut at flattening out protobuf definition. Some changes to data
structure printing (e.g., _gdp_pdu_dump) to get indenting more rational
so as to make reading the output easier.
First cut at running Layer 5 network protocol version 4 over old
(version 3) Layer 4 stack. Substantial parts are unimplemented,
including signature generation and checking, read or subscribe by
timestamp or hash, and others. No asynchronous operations including...
First cut at separating GCL instances (GINs) from GDP Objects (GOBs).
This is intended to fix some semantic problems with subscriptions. End
users always use GINs (aliased to gdp_gcl_t for now for compatibility),
and there is one GIN for each call to gdp_gcl_open (i.e., no returning...
Somewhat better diagnostics in gdp_event_next.
Print more information if there is a failure in gdp_event_next when
doing a cond_wait.
More work on making helgrind happy. This seems to be pretty close,
maybe worth a try in production.
Make Helgrind annotations work properly for (most?) race conditions.
Initial implementation of unsubscribe.
When doing final close on a GCL, free all events associated with it.
Add some additional parameter checking macros.
Additional checking for GDP events to try to find a free list problem.
Implement a way to deliver "record missing" back to client.
Add order specification for some leaf locks.
Update licenses to 2017.
Split req->pdu into two: cpdu holds the PDU for the command and rpdu
holds the PDU for the response. This makes it easier to make restart
work and the code to understand. However, it also means more copying of
data and a general lack of elegance. It also means that the datum in...
Extensive work on reliability, notably sharing a datum between threads.
Increases reliability, but still not fully tested. Basic things seem to
work though. Note: this may disrupt the replication code.
Fix problem that might occur if an initial response PDU to a command
such as MULTIREAD is delayed; follow-on data was treated as a response to
the initial command rather than as asynchronous events.
Fix some glitches in subscriptions and event handling that break
multiple subscriptions to the same log in different threads. This is
improved, but it still doesn't work.
Make many parameters "const" where possible.
Clean up event printing output.
Avoid possible lost events in asynchronous event handling. This delayed
delivery of some events, possibly forever.
Beginnings of attempt to deal with subscription-based memory leaks.
Code cleanup and comments.
Better printing of gdp_event_t.
First cut on implementing FWD_APPEND command. Still not working for all
Update license. No code changes.
Include copyright in all files. There are scripts to do bulk
replacement of the copyright if desired.
Implement asynchronous writes. Adds new interfaces:
* gdp_gcl_append_async -- initiate an asynchronous write.
* gdp_event_getstat -- get the status code from an event.
Asynchronous reads can be done using multiread.
Note that asynchronous writes do not attempt retransmissions, unlike...
Try to at least reduce the number of compile warnings on gcc. It
compiles clean on the NUC (Debian 7, gcc 4.7.2) but still gives some
errors on Ubuntu 14.04.1 (gcc 4.8.2).
More debugging output.
Back out changes carrying over req to event --- it's important that they
Keep old PDU around after delivering data from subscription; this let's
us renew the subscription periodically so that records will not be lost.
Change gdp_event_next to allow selection of events for a specific GCL.
Run subscription callbacks in dedicated thread. Untested.
Beginnings of changes to move event callbacks into a separate thread.
Change gdp_event_next to take an int64_t timeout (in nanoseconds);
also, convert it to use the new ep_thr_cond_wait "absolute time"
Change ep_thr_cond_wait and gdp_event_next to take timeout parameters
(NULL = forever). THESE CHANGE THE API!!
Implement subscription callbacks. Note that these almost never do what
you actually want, so the event interface is preferred.
Simplify event queue implementation (TAILQ => STAILQ)
First cut at returning multiple results. This extends "subscribe" to
have a starting record number and a record count.
Clean out unnecessary #includes. Linux portability.
Another snapshot. Much closer to having subscriptions working.