Network.Starling

A haskell implementation of the memcahed protocol.

This implements the new binary protocol, so it only works with memcached version 1.3 and newer.

Example of usage, using the network package to obain a handle, and the OverloadedStrings language extension:

 h <- connectTo "filename" $ UnixSocket "filename"
 hSetBuffering h NoBuffering
 con <- open h

 set con "hello" "world"
 get con "hello"

In the above example we connect to a unix socket in the file "filename", set the key "hello" to the value "world" and then retrieve the value.

Operations are thread safe - multiple threads of execution may make concurrent requests on the memcahced connection.

Operations are blocking, but do not block other concurrent threads from placing requests on the connection.

Documentation

open :: Handle -> IO Connection

Create a connection. Please don't use the handle after opening a connection with it.

close :: Connection -> IO ()

Shut down the connection. Non-blocking.

data Connection

For thread safety of operations, we perform all requests on a wrapper around a handle.

type Key = ByteString

type Value = ByteString

type Result a = IO (Either (ResponseStatus, ByteString) a)

data ResponseStatus

Constructors

NoError

KeyNotFound

KeyExists

ValueTooLarge

InvalidArguments

ItemNotStored

IncrDecrOnNonNumeric

UnknownCommand

OutOfMemory

Instances

Eq ResponseStatus

Ord ResponseStatus

Read ResponseStatus

Show ResponseStatus

Deserialize ResponseStatus

set :: Connection -> Key -> Value -> Result ()

Set a value in the cache

get :: Connection -> Key -> Result ByteString

Retrive a value from the cache

delete :: Connection -> Key -> Result ()

Delete an entry in the cache

flush :: Connection -> Result ()

Delete all entries in the cache

stats :: Connection -> Result [(ByteString, ByteString)]

Returns a list of stats about the server in key,value pairs

version :: Connection -> Result ByteString

Returns the version of the server