Network.Etcd

This module contains an implementation of the etcd client.

Documentation

data Client

The Client holds all data required to make requests to the etcd cluster. You should use createClient to initialize a new client.

createClient :: [Text] -> IO Client

Create a new client and initialize it with a list of seed machines. The list must be non-empty.

Types

data Node

The Node corresponds to the node object as returned by the etcd API.

There are two types of nodes in etcd. One is a leaf node which holds a value, the other is a directory node which holds zero or more child nodes. A directory node can not hold a value, the two types are exclusive.

On the wire, the two are not really distinguished, except that the JSON objects have different fields.

A node may be set to expire after a number of seconds. This is indicated by the two fields ttl and expiration.

Constructors

Node

Fields

_nodeKey :: !Key

The key of the node. It always starts with a slash character (0x47).

_nodeCreatedIndex :: !Index

A unique index, reflects the point in the etcd state machine at which the given key was created.

_nodeModifiedIndex :: !Index

Like _nodeCreatedIndex, but reflects when the node was laste changed.

_nodeDir :: !Bool

True if this node is a directory.

_nodeValue :: !(Maybe Value)

The value is only present on leaf nodes. If the node is a directory, then this field is Nothing.

_nodeNodes :: !(Maybe [Node])

If this node is a directory, then these are its children. The list may be empty.

_nodeTTL :: !(Maybe TTL)

If the node has TTL set, this is the number of seconds how long the node will exist.

_nodeExpiration :: !(Maybe UTCTime)

If TTL is set, then this is the time when it expires.

Instances

Eq Node

Ord Node

Show Node

FromJSON Node

type Index = Int

The etcd index is a unique, monotonically-incrementing integer created for each change to etcd. See etcd documentation for more details.

type Key = Text

Keys are strings, formatted like filesystem paths (ie. slash-delimited list of path components).

type Value = Text

Values attached to leaf nodes are strings. If you want to store structured data in the values, you'll need to encode it into a string.

type TTL = Int

TTL is specified in seconds. The server accepts negative values, but they don't make much sense.

Low-level key operations

get :: Client -> Key -> IO (Maybe Node)

Get the node at the given key.

set :: Client -> Key -> Value -> Maybe TTL -> IO (Maybe Node)

Set the value at the given key.

create :: Client -> Key -> Value -> Maybe TTL -> IO Node

Create a value in the given key. The key must be a directory.

Directory operations

createDirectory :: Client -> Key -> Maybe TTL -> IO ()

Create a directory at the given key.

listDirectoryContents :: Client -> Key -> IO [Node]

List all nodes within the given directory.

removeDirectory :: Client -> Key -> IO ()

Remove the directory at the given key. The directory MUST be empty, otherwise the removal fails. If you don't care about the keys within, you can use removeDirectoryRecursive.

removeDirectoryRecursive :: Client -> Key -> IO ()

Remove the directory at the given key, including all its children.