Documentation

The ContentStore is an opaque type that contains various pieces of information used to describe an on-disk content store. Values of this type are constructed via mkContentStore and openContentStore, depending on which operation you need to perform. Users should not need to concern themselves with the internals of this type.

A type to represent various errors that can occur during content store operations.

Working with a ContentStore requires a lot of behind-the-scenes management of ResourceT, ExceptT, and IO. Along with runCsMonad, this provides a type and function for doing much of that management for you. These two can be used like so:

result <- runCsMonad $ do
    cs <- mkContentStore "/tmp/cs.repo"
    storeDirectory cs "/tmp/test-data"

case result of
    Left e  -> print e
    Right d -> do putStrLn "Stored objects: "
                  mapM_ print d

Most functions in this module do not explicitly require use of CsMonad, but any that have a return type including m can be run inside it.

See the documentation for CsMonad.

Return the digest type used by a content store.

Check that a content store exists and contains everything it's supposed to. This does not check the validity of all the contents, however. A CsError will be thrown if there are any problems. Otherwise, this function returns True.

Lookup and return some previously stored object as a strict ByteString. Note that you'll probably need to use fromByteString to produce an ObjectDigest from whatever text or binary representation you've got from the usermddbetc.

Given an opened ContentStore and a Conduit of ObjectDigests, load each one into a strict ByteString and put it into the conduit. This is useful for stream many objects out of the content store at a time, like with exporting an RPM or other package format.

Find some object in the content store and write it to a destination. If the destination already exists, it will be overwritten. If the object does not already exist, a CsErrorNoSuchObject will be thrown.

Like fetchByteString, but uses lazy ByteStrings instead.

Like fetchByteStringC, but uses lazy ByteStrings instead.

Create a new ContentStore on disk, rooted at the path given, and return it as if openContentStore had also been called. If a content store already exists at the given root and is valid, return that as if openContentStore had been called. Various CsErrors could be thrown by this process.

Return an already existing ContentStore, after checking that it is valid. Various CsErrors could be thrown by this process.

Store some object into the content store and return its ObjectDigest. If an object with the same digest already exists in the content store, this is a duplicate. Simply return the digest of the already stored object and do nothing else. A CsErrorCollision will NOT be thrown.

Like storeByteString, but read strict ByteStrings from a Conduit and put their ObjectDigests into the conduit. This is useful for storing many objects at a time, like with importing an RPM or other package format.

Read in a Conduit of strict ByteStrings, store the stream into an object in an already opened ContentStore, and return the final digest. This is useful for storing a stream of data as a single object.

Store all objects in a directory tree in the content store, returning the name and ObjectDigest of each. Note that directories will not be stored. The content store only contains things that have content. If you need to store directory information, that should be handled externally to this module.

Store an already existing file in the content store, returning its ObjectDigest. The original file will be left on disk.

Like storeByteString, but uses lazy ByteStrings instead.

Like storeByteStringC, but uses lazy ByteStrings instead.

Like storeByteStringSink, but uses lazy ByteStrings instead.