Calling norns(ctl)?_error() to query the status of a running task will
release its descriptor in the server if the task already completed
(NORNS_EFINISHED or NORNS_EFINISHEDWERROR). Since norns(ctl)?_wait()
internally queries the task status to check whether a task has
completed, we cache the retrieved task_status into the iotask_t user
descriptor so that it can be retrieved by a subsequent
norns(ctl)?_error() call.

Functions norns_wait() and nornsctl_wait() now accept an optional
const struct timespec *timeout (see nanosleep(2)) to allow users
to suspend the calling thread until one of the following occurs:

* A signal is delivered and the task has already completed.
* The specified time interval has already passed.

If timeout is NULL, the functions will suspend the thread for
a predefined amount of time and query the server upon waking up.

Note that since the server does not allow registering listeners at the
moment, the thread will wake only when one of the aforementioned
conditions has occurred, even if the task of interest has already finished.

Add nornsctl_iotask_init()
Add NORNSCTL_IOTASK()
Add nornsctl_submit()
Add nornsctl_wait()
Add nornsctl_cancel()
Add nornsctl_error()

We need to provide a nornsctl_status() function to check the status of
administrative data transfer tasks, but we already have
a nornsctl_status() function in the API that checks the global status of
the service. Thus, we decided to keep the current nornsctl_status() and
rename norns_status() to norns_error() and provide a nornsctl_error()
for simmetry.

The duration of 'sleep phases' in dry run tasks can now be defined both
in the command line (by passing an integer with the number of usecs to
wait) and in tests (by using the dry_run_duration field in the
fake_daemon_cfg class).

When invoked, the daemon checks whether active tasks remain to be
processed and, if so, returns NORNS_ETASKSPENDING. If there are no
active tasks, but there are tracked namespaces that are not empty, the
daemon return NORNS_ENAMESPACENOTEMPTY. Otherwise, the daemon returns
NORNS_SUCCESS and shuts itself down.

Clients can now provide a 'track' flag when defining a namespace to let
urd know that it must keep track of the namespace contents. The flag is
currently propagated by the messaging system and stored in the internal
backend metadata. Tracking not implemented yet.

The norns library and service now supports a new type of i/o task called
NORNS_IOTASK_REMOVE that enqueues the deletion of a resource from
a backend. As of right now, only the deletion of NORNS_LOCAL_PATHs is
supported.

This commit defines the NORNS_IOTASK_REMOVE subtype and also implements
the basic mechanism so that a task of this type can be executed.

This commit fixes #6.

Added a new environment variable NORNS_DEBUG_CONFIG_FILE_OVERRIDE that
allows test programs to override the load process for the default
configuration file. When setting this variable, the test program is
expected to call either libnorns_reload_config_file() or
libnornsctl_reload_config_file() to set the configuration file for the
test explicitly.

This commit closes #3.

The new nornctl_status function queries the urd daemon and returns
summarized stats about all iotasks currently in the system. More
specifically, the function returns a nornsctl_stat_t structure that
contains the following information:
    st_running_tasks: Number of tasks currently running
    st_pending_tasks: Number of tasks currently pending
    st_eta: Estimated Time of Arrival of the currently running tasks
            (in seconds). Note that, internally, the daemon estimates
            how long a task will take by keeping track of the average
            namespace-to-namespace bandwidth from previous requests.
            This means that this field may contain NaN if no tasks
            have yet completed, since the daemon will not be able to
            estimate the E.T.A.

- Changed the format of the global service configuration file to a
YAML-like format
- Urd daemon is now able to read its configuration from the
newly-formatted configuration file.
- Companion libraries linorns and libnornsctl are now capable of
reading their configuration from the global service configuration file.
- Libraries now encapsulate their state in a context structure shared
by all threads rather than in globals.
- Tests are only built now if the --enable-tests option is passed
when invoking configure
- Tests updated to patch the libraries on the fly in order to use
case-by-case configuration files.
- Tests now only cleanup their internal data if the test succeeds.

- Add transferor_registry class to manage resource transfer functions
- First implementation of 'local path' to 'local path' transferor using
  fadvice+fallocate+sendfile.
- Add stubs for other converters
- Move dispatch_table from api to common since it's now also used by
  transferor_registry.
- Add get() function to dispatch_table class so that stored functors
  can be retrieved.
- Generic implementation of task::operator()() to transfer resources and
  resource elements between different backends. When constructed, the
  task is provided with the input and ouput resources as well as a
  'transferor' functor that is invoked upon them to perform the actual
  transfer.
- Add new_resource() and get_resource() methods to backends to promote
  resource_info instances to fully qualified resources.
- Implementation of new_resource() and get_resource() for a POSIX
  filesystem. Stubs for other backends.
- New convenience library that aggregates all symbols for resources
- Add name() and is_collection() methods to class resource_info.
- Provide implementation for boost::filesystem::relative() in utils.cpp
  if boost version <= 1.6.0
- Remove resource::buffer, no longer needed (superseeded by transferors).
- Remove resource::stream, no longer needed (superseeded by transferors).
- Remove functions resource::info(), resource::backend(), and
  resource::set_backend().
- Reorganize resources build hierarchy
- Remove self-registration of backends
- Update tests
- Cleanup unused code

- Rename norns_register_backend to norns_register_namespace
- Rename norns_unregister_backend to norns_unregister_namespace
- Rename norns_update_backend to norns_update_namespace
- API is now more symmetrical: all norns_*_namespace functions
receive an nsid as first parameter (in previous versions this
was not consistent).
- The norns_job_t descriptor now requires a norns_job_limit_t
parameter that defines what the job will be allowed to do, rather
than a norns_backend_t specification as in previous versions.
- Other changes: message passing logic improved

- task_manager is now a full-fledged class rather than
inheriting from std::unordered_map
- changes to handlers to reflect the new interface
in task_manager
- new dry_run option for enabling "fake task mode"
- in libraries, log errors to stderr only if env var
NORNS_DBG_LOG_TO_STDERR is defined.

For now, only available in *_debug libraries

Application credentials are no longer needed given that
authentication of administrator clients is now enforced
with appropriate permissions to the communication socket.

User-level functions are provided by libnorns.so,
which communicates with the daemon through the
norns_api_global_socket. This socket should allow
anyone to read and write from/to it.

Admin-level functions are provided by
libnornsctl.so, which communicates with urd
through the norns_api_control_socket. This socket
should allow only selected processes to read and
write from/to it.

Added support for the API listener to receive requests from
different endpoints: local sockets for user/control requests and
remote sockets for requests from other daemons. Signals are also
managed by the API listener.

Better abstraction and internal management of data
resources and storage backends

Bump spdlog to 0.13.0
Bump catch to 2.0