GitLab

Since the function is to reload and we provide an object that can
reload, we just get one and call it. It is just to avoid duplicate code.

So now the loading works correctly (at least as the tests say).

It is mostly copy of the reload() method. Currently, it does not contain
the initialization of load_action for the zone writer, so if a real zone
writer is returned, it doesn't work (it throws). But the tests for the
unsuccessful cases succeed.

There's also need to do something about the duplicate code between this
method and the reload(). Later on, we'll probably rewrite reload to use
the ZoneWriter (and even later deprecate reload, maybe? Or keep it as
the thin wrapper for convenience?)

They are the reload() tests reused for this purpose. They fail, since
the method is temporary and contains almost no code.

now the memory segment is shared for multiple in-memory zones, we cannot check
it in each client.

this is a hack, and we should eventually make it more cleanly.

it compiles, but some tests currently fail.

- add zone and file names to masterload errors
- catch masterload error and log it
- don't quit auth completely on a single zone load failure

Stop doing "using namespace boost" and be specific with the using boost::.

Problem noticed on Solaris 11 with g++ 4.5.2 and boost 1.50.0.
Tested with older g++ 4.1.3 with boost 1.42.0 (on NetBSD).

Discussed little on jabber.

We have a class to keep a reference to it. This is in C++ only yet, the
python part needs to be implemented.

They are special-cased on loading and they need to be special-cased on
reloading too.

The core finding function is separated. This is because we'll want to
reuse it, returning some more information, in the future reload method.

Tests and actual error handling of various scenarios when loading zone
data to caches.

Only the ones that are requested.

This needs a lot of error handling added.

But it is not yet filled up

It is not created now, but there's the place to put it.

And change the parameter type in configure, since we want to preserve
the exact instance and we don't want to do a (deep) copy.

The list.{h,cc} is too generic.

Don't compute the number of matched labels at the first match, there's
nothing to compare against anyway. We hope that there'll be only one one
partial match in practice.

They are likely not to be useful anyway and this allows a small
optimisation.

It is supposed to be called client, not a DataSource only.

As it could potentially slow down the processing.

This is to avoid confusion with DataSourceClientContainer, which is a
completely different class.

To have better naming consistency.

As the pointer should never be NULL anyway, it might be better to pass
reference.