=======
Drivers
=======

Tooz is provided with several drivers implementing the provided coordination
API. While all drivers provides the same set of features with respect to the
API, some of them have different characteristics:

Zookeeper
---------

**Driver:** :py:class:`tooz.drivers.zookeeper.KazooDriver`

**Characteristics:**

:py:attr:`tooz.drivers.zookeeper.KazooDriver.CHARACTERISTICS`

**Entrypoint name:** ``zookeeper`` or ``kazoo``

**Summary:**

The zookeeper is the reference implementation and provides the most solid
features as it's possible to build a cluster of zookeeper servers that is
resilient towards network partitions for example.

**Test driver:** :py:class:`tooz.drivers.zake.ZakeDriver`

**Characteristics:**

:py:attr:`tooz.drivers.zake.ZakeDriver.CHARACTERISTICS`

**Test driver entrypoint name:** ``zake``

Considerations
~~~~~~~~~~~~~~

- Primitives are based on sessions (and typically require careful selection
  of session heartbeat periodicity and server side configuration of session
  expiry).

Memcached
---------

**Driver:** :py:class:`tooz.drivers.memcached.MemcachedDriver`

**Characteristics:**

:py:attr:`tooz.drivers.memcached.MemcachedDriver.CHARACTERISTICS`

**Entrypoint name:** ``memcached``

**Summary:**

The memcached driver is a basic implementation and provides little
resiliency, though it's much simpler to setup. A lot of the features provided
in tooz are based on timeout (heartbeats, locks, etc) so are less resilient
than other backends.

Considerations
~~~~~~~~~~~~~~

- Less resilient than other backends such as zookeeper and redis.
- Primitives are often based on TTL(s) that may expire before
  being renewed.
- Lacks certain primitives (compare and delete) so certain functionality
  is fragile and/or broken due to this.

Redis
-----

**Driver:** :py:class:`tooz.drivers.redis.RedisDriver`

**Characteristics:**

:py:attr:`tooz.drivers.redis.RedisDriver.CHARACTERISTICS`

**Entrypoint name:** ``redis``

**Summary:**

The redis driver is a basic implementation and provides reasonable resiliency
when used with `redis-sentinel`_. A lot of the features provided in tooz are
based on timeout (heartbeats, locks, etc) so are less resilient than other
backends.

Considerations
~~~~~~~~~~~~~~

- Less resilient than other backends such as zookeeper.
- Primitives are often based on TTL(s) that may expire before
  being renewed.

IPC
---

**Driver:** :py:class:`tooz.drivers.ipc.IPCDriver`

**Characteristics:** :py:attr:`tooz.drivers.ipc.IPCDriver.CHARACTERISTICS`

**Entrypoint name:** ``ipc``

**Summary:**

The IPC driver is based on Posix IPC API and implements a lock
mechanism and some basic group primitives (with **huge**
limitations).

Considerations
~~~~~~~~~~~~~~

- The lock can **only** be distributed locally to a computer
  processes.

File
----

**Driver:** :py:class:`tooz.drivers.file.FileDriver`

**Characteristics:** :py:attr:`tooz.drivers.file.FileDriver.CHARACTERISTICS`

**Entrypoint name:** ``file``

**Summary:**

The file driver is a **simple** driver based on files and directories. It
implements a lock based on POSIX or Window file level locking
mechanism and some basic group primitives (with **huge**
limitations).

Considerations
~~~~~~~~~~~~~~

- The lock can **only** be distributed locally to a computer processes.
- Certain concepts provided by it are **not** crash tolerant.

PostgreSQL
----------

**Driver:** :py:class:`tooz.drivers.pgsql.PostgresDriver`

**Characteristics:**

:py:attr:`tooz.drivers.pgsql.PostgresDriver.CHARACTERISTICS`

**Entrypoint name:** ``postgresql``

**Summary:**

The postgresql driver is a driver providing only a distributed lock (for now)
and is based on the `PostgreSQL database server`_ and its API(s) that provide
for `advisory locks`_ to be created and used by applications. When a lock is
acquired it will release either when explicitly released or automatically when
the database session ends (for example if the program using the lock crashes).

Considerations
~~~~~~~~~~~~~~

- Lock that may be acquired restricted by
  ``max_locks_per_transaction * (max_connections + max_prepared_transactions)``
  upper bound (PostgreSQL server configuration settings).

MySQL
-----

**Driver:**  :py:class:`tooz.drivers.mysql.MySQLDriver`

**Characteristics:** :py:attr:`tooz.drivers.mysql.MySQLDriver.CHARACTERISTICS`

**Entrypoint name:** ``mysql``

**Summary:**

The MySQL driver is a driver providing only distributed locks (for now)
and is based on the `MySQL database server`_ supported `get_lock`_
primitives. When a lock is acquired it will release either when explicitly
released or automatically when the database session ends (for example if
the program using the lock crashes).

Considerations
~~~~~~~~~~~~~~

- Does **not** work correctly on some MySQL versions.
- Does **not** work when MySQL replicates from one server to another (locks
  are local to the server that they were created from).

Etcd
----

**Driver:**  :py:class:`tooz.drivers.etcd.EtcdDriver`

**Characteristics:** :py:attr:`tooz.drivers.etcd.EtcdDriver.CHARACTERISTICS`

**Entrypoint name:** ``etcd``

**Summary:**

The etcd driver is a driver providing only distributed locks (for now)
and is based on the `etcd server`_ supported key/value storage and
associated primitives.

Etcd3
-----

**Driver:**  :py:class:`tooz.drivers.etcd3.Etcd3Driver`

**Characteristics:** :py:attr:`tooz.drivers.etcd3.Etcd3Driver.CHARACTERISTICS`

**Entrypoint name:** ``etcd3``

**Summary:**

The etcd3 driver is a driver providing only distributed locks (for now)
and is based on the `etcd server`_ supported key/value storage and
associated primitives.

Etcd3 Gateway
-------------

**Driver:**  :py:class:`tooz.drivers.etcd3gw.Etcd3Driver`

**Characteristics:**
:py:attr:`tooz.drivers.etcd3gw.Etcd3Driver.CHARACTERISTICS`

**Entrypoint name:** ``etcd3+http``

**Summary:**

The etcd3gw driver is a driver providing only distributed locks (for now)
and is based on the `etcd server`_ supported key/value storage and
associated primitives. It relies on the `GRPC Gateway`_ to provide HTTP access
to etcd3.

Consul
------

**Driver:**  :py:class:`tooz.drivers.consul.ConsulDriver`

**Characteristics:**

:py:attr:`tooz.drivers.consul.ConsulDriver.CHARACTERISTICS`

**Entrypoint name:** ``consul``

**Summary:**

The `consul`_ driver is a driver providing distributed locking and group
membership and is based on the consul server key/value storage and/or
primitives. When a lock is acquired it will release either when explicitly
released or automatically when the consul session ends (for example if
the program using the lock crashes).

Characteristics
---------------

.. autoclass:: tooz.coordination.Characteristics

.. _etcd server: https://coreos.com/etcd/
.. _consul: https://www.consul.io/
.. _advisory locks: http://www.postgresql.org/docs/8.2/interactive/\
                    explicit-locking.html#ADVISORY-LOCKS
.. _get_lock: http://dev.mysql.com/doc/refman/5.5/en/\
              miscellaneous-functions.html#function_get-lock
.. _PostgreSQL database server: http://postgresql.org
.. _MySQL database server: http://mysql.org
.. _redis-sentinel: http://redis.io/topics/sentinel
.. _GRPC Gateway: https://github.com/grpc-ecosystem/grpc-gateway
