GI.OSTree.Objects.Repo

Exported types

newtype Repo

Constructors

Repo (ManagedPtr Repo)

Instances

GObject Repo

Methods

gobjectType :: Repo -> IO GType

IsObject Repo

IsRepo Repo

((~) * info (ResolveRepoMethod t Repo), MethodInfo * info Repo p) => IsLabel t (Repo -> p)

Methods

fromLabel :: Proxy# Symbol t -> Repo -> p

((~) * info (ResolveRepoMethod t Repo), MethodInfo * info Repo p) => IsLabelProxy t (Repo -> p)

Methods

fromLabelProxy :: Proxy Symbol t -> Repo -> p

HasAttributeList * Repo

type AttributeList Repo

type AttributeList Repo

type SignalList Repo

type SignalList Repo

class GObject o => IsRepo o

Instances

(GObject a, UnknownAncestorError Constraint Repo a) => IsRepo a

IsRepo Repo

toRepo :: IsRepo o => o -> IO Repo

noRepo :: Maybe Repo

Methods

Unsupported methods

data RepoListCommitObjectsStartingWithMethodInfo

Instances

((~) * p (), (~) * o (MethodResolutionFailed * "listCommitObjectsStartingWith" Repo)) => MethodInfo * RepoListCommitObjectsStartingWithMethodInfo o p

Methods

overloadedMethod :: MethodProxy RepoListCommitObjectsStartingWithMethodInfo o -> p -> s

data RepoListObjectsMethodInfo

Instances

((~) * p (), (~) * o (MethodResolutionFailed * "listObjects" Repo)) => MethodInfo * RepoListObjectsMethodInfo o p

Methods

overloadedMethod :: MethodProxy RepoListObjectsMethodInfo o -> p -> s

data RepoTraverseCommitMethodInfo

Instances

((~) * p (), (~) * o (MethodResolutionFailed * "traverseCommit" Repo)) => MethodInfo * RepoTraverseCommitMethodInfo o p

Methods

overloadedMethod :: MethodProxy RepoTraverseCommitMethodInfo o -> p -> s

data RepoTraverseNewReachableMethodInfo

Instances

((~) * p (), (~) * o (MethodResolutionFailed * "traverseNewReachable" Repo)) => MethodInfo * RepoTraverseNewReachableMethodInfo o p

Methods

overloadedMethod :: MethodProxy RepoTraverseNewReachableMethodInfo o -> p -> s

abortTransaction

data RepoAbortTransactionMethodInfo

Instances

((~) * signature (Maybe b -> m ()), MonadIO m, IsRepo a, IsCancellable b) => MethodInfo * RepoAbortTransactionMethodInfo a signature

Methods

overloadedMethod :: MethodProxy RepoAbortTransactionMethodInfo a -> signature -> s

repoAbortTransaction

Arguments

:: (HasCallStack, MonadIO m, IsRepo a, IsCancellable b)

=> a

-> Maybe b

-> m ()

(Can throw GError)

No description available in the introspection data.

addGpgSignatureSummary

data RepoAddGpgSignatureSummaryMethodInfo

Instances

((~) * signature ([Text] -> Maybe Text -> Maybe b -> m ()), MonadIO m, IsRepo a, IsCancellable b) => MethodInfo * RepoAddGpgSignatureSummaryMethodInfo a signature

Methods

overloadedMethod :: MethodProxy RepoAddGpgSignatureSummaryMethodInfo a -> signature -> s

repoAddGpgSignatureSummary

Arguments

:: (HasCallStack, MonadIO m, IsRepo a, IsCancellable b)

=> a

self: Self

-> [Text]

keyId: NULL-terminated array of GPG keys.

-> Maybe Text

homedir: GPG home directory, or Nothing

-> Maybe b

cancellable: A Cancellable

-> m ()

(Can throw GError)

Add a GPG signature to a static delta.

appendGpgSignature

data RepoAppendGpgSignatureMethodInfo

Instances

((~) * signature (Text -> Bytes -> Maybe b -> m ()), MonadIO m, IsRepo a, IsCancellable b) => MethodInfo * RepoAppendGpgSignatureMethodInfo a signature

Methods

overloadedMethod :: MethodProxy RepoAppendGpgSignatureMethodInfo a -> signature -> s

repoAppendGpgSignature

Arguments

:: (HasCallStack, MonadIO m, IsRepo a, IsCancellable b)

=> a

self: Self

-> Text

commitChecksum: SHA256 of given commit to sign

-> Bytes

signatureBytes: Signature data

-> Maybe b

cancellable: A Cancellable

-> m ()

(Can throw GError)

Append a GPG signature to a commit.

checkoutAt

data RepoCheckoutAtMethodInfo

Instances

((~) * signature (Maybe RepoCheckoutAtOptions -> Int32 -> Text -> Text -> Maybe b -> m ()), MonadIO m, IsRepo a, IsCancellable b) => MethodInfo * RepoCheckoutAtMethodInfo a signature

Methods

overloadedMethod :: MethodProxy RepoCheckoutAtMethodInfo a -> signature -> s

repoCheckoutAt

Arguments

:: (HasCallStack, MonadIO m, IsRepo a, IsCancellable b)

=> a

self: Repo

-> Maybe RepoCheckoutAtOptions

options: Options

-> Int32

destinationDfd: Directory FD for destination

-> Text

destinationPath: Directory for destination

-> Text

commit: Checksum for commit

-> Maybe b

cancellable: Cancellable

-> m ()

(Can throw GError)

Similar to repoCheckoutTree, but uses directory-relative paths for the destination, uses a new OstreeRepoCheckoutAtOptions, and takes a commit checksum and optional subpath pair, rather than requiring use of GFile APIs for the caller.

It also replaces repoCheckoutAt which was not safe to use with GObject introspection.

Note in addition that unlike repoCheckoutTree, the default is not to use the repository-internal uncompressed objects cache.

checkoutGc

data RepoCheckoutGcMethodInfo

Instances

((~) * signature (Maybe b -> m ()), MonadIO m, IsRepo a, IsCancellable b) => MethodInfo * RepoCheckoutGcMethodInfo a signature

Methods

overloadedMethod :: MethodProxy RepoCheckoutGcMethodInfo a -> signature -> s

repoCheckoutGc

Arguments

:: (HasCallStack, MonadIO m, IsRepo a, IsCancellable b)

=> a

self: Repo

-> Maybe b

cancellable: Cancellable

-> m ()

(Can throw GError)

Call this after finishing a succession of checkout operations; it will delete any currently-unused uncompressed objects from the cache.

checkoutTree

data RepoCheckoutTreeMethodInfo

Instances

((~) * signature (RepoCheckoutMode -> RepoCheckoutOverwriteMode -> b -> c -> d -> Maybe e -> m ()), MonadIO m, IsRepo a, IsFile b, IsRepoFile c, IsFileInfo d, IsCancellable e) => MethodInfo * RepoCheckoutTreeMethodInfo a signature

Methods

overloadedMethod :: MethodProxy RepoCheckoutTreeMethodInfo a -> signature -> s

repoCheckoutTree

Arguments

:: (HasCallStack, MonadIO m, IsRepo a, IsFile b, IsRepoFile c, IsFileInfo d, IsCancellable e)

=> a

self: Repo

-> RepoCheckoutMode

mode: Options controlling all files

-> RepoCheckoutOverwriteMode

overwriteMode: Whether or not to overwrite files

-> b

destination: Place tree here

-> c

source: Source tree

-> d

sourceInfo: Source info

-> Maybe e

cancellable: Cancellable

-> m ()

(Can throw GError)

Check out source into destination, which must live on the physical filesystem. source may be any subdirectory of a given commit. The mode and overwriteMode allow control over how the files are checked out.

commitTransaction

data RepoCommitTransactionMethodInfo

Instances

((~) * signature (Maybe b -> m RepoTransactionStats), MonadIO m, IsRepo a, IsCancellable b) => MethodInfo * RepoCommitTransactionMethodInfo a signature

Methods

overloadedMethod :: MethodProxy RepoCommitTransactionMethodInfo a -> signature -> s

repoCommitTransaction

Arguments

:: (HasCallStack, MonadIO m, IsRepo a, IsCancellable b)

=> a

self: An Repo

-> Maybe b

cancellable: Cancellable

-> m RepoTransactionStats

(Can throw GError)

Complete the transaction. Any refs set with repoTransactionSetRef or repoTransactionSetRefspec will be written out.

copyConfig

data RepoCopyConfigMethodInfo

Instances

((~) * signature (m KeyFile), MonadIO m, IsRepo a) => MethodInfo * RepoCopyConfigMethodInfo a signature

Methods

overloadedMethod :: MethodProxy RepoCopyConfigMethodInfo a -> signature -> s

repoCopyConfig

Arguments

:: (HasCallStack, MonadIO m, IsRepo a)

=> a

-> m KeyFile

Returns: A newly-allocated copy of the repository config

No description available in the introspection data.

create

data RepoCreateMethodInfo

Instances

((~) * signature (RepoMode -> Maybe b -> m ()), MonadIO m, IsRepo a, IsCancellable b) => MethodInfo * RepoCreateMethodInfo a signature

Methods

overloadedMethod :: MethodProxy RepoCreateMethodInfo a -> signature -> s

repoCreate

Arguments

:: (HasCallStack, MonadIO m, IsRepo a, IsCancellable b)

=> a

self: An Repo

-> RepoMode

mode: The mode to store the repository in

-> Maybe b

cancellable: Cancellable

-> m ()

(Can throw GError)

Create the underlying structure on disk for the repository, and call repoOpen on the result, preparing it for use.

Since version 2016.8, this function will succeed on an existing repository, and finish creating any necessary files in a partially created repository. However, this function cannot change the mode of an existing repository, and will silently ignore an attempt to do so.

deleteObject

data RepoDeleteObjectMethodInfo

Instances

((~) * signature (ObjectType -> Text -> Maybe b -> m ()), MonadIO m, IsRepo a, IsCancellable b) => MethodInfo * RepoDeleteObjectMethodInfo a signature

Methods

overloadedMethod :: MethodProxy RepoDeleteObjectMethodInfo a -> signature -> s

repoDeleteObject

Arguments

:: (HasCallStack, MonadIO m, IsRepo a, IsCancellable b)

=> a

self: Repo

-> ObjectType

objtype: Object type

-> Text

sha256: Checksum

-> Maybe b

cancellable: Cancellable

-> m ()

(Can throw GError)

Remove the object of type objtype with checksum sha256 from the repository. An error of type IOErrorEnumNotFound is thrown if the object does not exist.

getConfig

data RepoGetConfigMethodInfo

Instances

((~) * signature (m KeyFile), MonadIO m, IsRepo a) => MethodInfo * RepoGetConfigMethodInfo a signature

Methods

overloadedMethod :: MethodProxy RepoGetConfigMethodInfo a -> signature -> s

repoGetConfig

Arguments

:: (HasCallStack, MonadIO m, IsRepo a)

=> a

-> m KeyFile

Returns: The repository configuration; do not modify

No description available in the introspection data.

getDfd

data RepoGetDfdMethodInfo

Instances

((~) * signature (m Int32), MonadIO m, IsRepo a) => MethodInfo * RepoGetDfdMethodInfo a signature

Methods

overloadedMethod :: MethodProxy RepoGetDfdMethodInfo a -> signature -> s

repoGetDfd

Arguments

:: (HasCallStack, MonadIO m, IsRepo a)

=> a

self: Repo

-> m Int32

Returns: File descriptor for repository root - owned by self

In some cases it's useful for applications to access the repository directly; for example, writing content into repo/tmp ensures it's on the same filesystem. Another case is detecting the mtime on the repository (to see whether a ref was written).

getDisableFsync

data RepoGetDisableFsyncMethodInfo

Instances

((~) * signature (m Bool), MonadIO m, IsRepo a) => MethodInfo * RepoGetDisableFsyncMethodInfo a signature

Methods

overloadedMethod :: MethodProxy RepoGetDisableFsyncMethodInfo a -> signature -> s

repoGetDisableFsync

Arguments

:: (HasCallStack, MonadIO m, IsRepo a)

=> a

self: An Repo

-> m Bool

Returns: Whether or not fsync() is enabled for this repo.

For more information see repoSetDisableFsync.

getMode

data RepoGetModeMethodInfo

Instances

((~) * signature (m RepoMode), MonadIO m, IsRepo a) => MethodInfo * RepoGetModeMethodInfo a signature

Methods

overloadedMethod :: MethodProxy RepoGetModeMethodInfo a -> signature -> s

repoGetMode :: (HasCallStack, MonadIO m, IsRepo a) => a -> m RepoMode

No description available in the introspection data.

getParent

data RepoGetParentMethodInfo

Instances

((~) * signature (m Repo), MonadIO m, IsRepo a) => MethodInfo * RepoGetParentMethodInfo a signature

Methods

overloadedMethod :: MethodProxy RepoGetParentMethodInfo a -> signature -> s

repoGetParent

Arguments

:: (HasCallStack, MonadIO m, IsRepo a)

=> a

self: Repo

-> m Repo

Returns: Parent repository, or Nothing if none

Before this function can be used, ostree_repo_init() must have been called.

getPath

data RepoGetPathMethodInfo

Instances

((~) * signature (m File), MonadIO m, IsRepo a) => MethodInfo * RepoGetPathMethodInfo a signature

Methods

overloadedMethod :: MethodProxy RepoGetPathMethodInfo a -> signature -> s

repoGetPath

Arguments

:: (HasCallStack, MonadIO m, IsRepo a)

=> a

-> m File

Returns: Path to repo

No description available in the introspection data.

getRemoteBooleanOption

data RepoGetRemoteBooleanOptionMethodInfo

Instances

((~) * signature (Text -> Text -> Bool -> m Bool), MonadIO m, IsRepo a) => MethodInfo * RepoGetRemoteBooleanOptionMethodInfo a signature

Methods

overloadedMethod :: MethodProxy RepoGetRemoteBooleanOptionMethodInfo a -> signature -> s

repoGetRemoteBooleanOption

Arguments

:: (HasCallStack, MonadIO m, IsRepo a)

=> a

self: A OstreeRepo

-> Text

remoteName: Name

-> Text

optionName: Option

-> Bool

defaultValue: Value returned if optionName is not present

-> m Bool

(Can throw GError)

OSTree remotes are represented by keyfile groups, formatted like: [remote "remotename"]. This function returns a value named optionName underneath that group, and returns it as a boolean. If the option is not set, outValue will be set to defaultValue. If an error is returned, outValue will be set to False.

getRemoteListOption

data RepoGetRemoteListOptionMethodInfo

Instances

((~) * signature (Text -> Text -> m [Text]), MonadIO m, IsRepo a) => MethodInfo * RepoGetRemoteListOptionMethodInfo a signature

Methods

overloadedMethod :: MethodProxy RepoGetRemoteListOptionMethodInfo a -> signature -> s

repoGetRemoteListOption

Arguments

:: (HasCallStack, MonadIO m, IsRepo a)

=> a

self: A OstreeRepo

-> Text

remoteName: Name

-> Text

optionName: Option

-> m [Text]

(Can throw GError)

OSTree remotes are represented by keyfile groups, formatted like: [remote "remotename"]. This function returns a value named optionName underneath that group, and returns it as a zero terminated array of strings. If the option is not set, or if an error is returned, outValue will be set to Nothing.

getRemoteOption

data RepoGetRemoteOptionMethodInfo

Instances

((~) * signature (Text -> Text -> Maybe Text -> m Text), MonadIO m, IsRepo a) => MethodInfo * RepoGetRemoteOptionMethodInfo a signature

Methods

overloadedMethod :: MethodProxy RepoGetRemoteOptionMethodInfo a -> signature -> s

repoGetRemoteOption

Arguments

:: (HasCallStack, MonadIO m, IsRepo a)

=> a

self: A OstreeRepo

-> Text

remoteName: Name

-> Text

optionName: Option

-> Maybe Text

defaultValue: Value returned if optionName is not present

-> m Text

(Can throw GError)

OSTree remotes are represented by keyfile groups, formatted like: [remote "remotename"]. This function returns a value named optionName underneath that group, or defaultValue if the remote exists but not the option name. If an error is returned, outValue will be set to Nothing.

gpgVerifyData

data RepoGpgVerifyDataMethodInfo

Instances

((~) * signature (Maybe Text -> Bytes -> Bytes -> Maybe b -> Maybe c -> Maybe d -> m GpgVerifyResult), MonadIO m, IsRepo a, IsFile b, IsFile c, IsCancellable d) => MethodInfo * RepoGpgVerifyDataMethodInfo a signature

Methods

overloadedMethod :: MethodProxy RepoGpgVerifyDataMethodInfo a -> signature -> s

repoGpgVerifyData

Arguments

:: (HasCallStack, MonadIO m, IsRepo a, IsFile b, IsFile c, IsCancellable d)

=> a

self: Repository

-> Maybe Text

remoteName: Name of remote

-> Bytes

data: Data as a Bytes

-> Bytes

signatures: Signatures as a Bytes

-> Maybe b

keyringdir: Path to directory GPG keyrings; overrides built-in default if given

-> Maybe c

extraKeyring: Path to additional keyring file (not a directory)

-> Maybe d

cancellable: Cancellable

-> m GpgVerifyResult

Returns: an GpgVerifyResult, or Nothing on error (Can throw GError)

Verify signatures for data using GPG keys in the keyring for remoteName, and return an GpgVerifyResult.

The remoteName parameter can be Nothing. In that case it will do the verifications using GPG keys in the keyrings of all remotes.

hasObject

data RepoHasObjectMethodInfo

Instances

((~) * signature (ObjectType -> Text -> Maybe b -> m Bool), MonadIO m, IsRepo a, IsCancellable b) => MethodInfo * RepoHasObjectMethodInfo a signature

Methods

overloadedMethod :: MethodProxy RepoHasObjectMethodInfo a -> signature -> s

repoHasObject

Arguments

:: (HasCallStack, MonadIO m, IsRepo a, IsCancellable b)

=> a

self: Repo

-> ObjectType

objtype: Object type

-> Text

checksum: ASCII SHA256 checksum

-> Maybe b

cancellable: Cancellable

-> m Bool

(Can throw GError)

Set outHaveObject to True if self contains the given object; False otherwise.

importObjectFrom

data RepoImportObjectFromMethodInfo

Instances

((~) * signature (b -> ObjectType -> Text -> Maybe c -> m ()), MonadIO m, IsRepo a, IsRepo b, IsCancellable c) => MethodInfo * RepoImportObjectFromMethodInfo a signature

Methods

overloadedMethod :: MethodProxy RepoImportObjectFromMethodInfo a -> signature -> s

repoImportObjectFrom

Arguments

:: (HasCallStack, MonadIO m, IsRepo a, IsRepo b, IsCancellable c)

=> a

self: Destination repo

-> b

source: Source repo

-> ObjectType

objtype: Object type

-> Text

checksum: checksum

-> Maybe c

cancellable: Cancellable

-> m ()

(Can throw GError)

Copy object named by objtype and checksum into self from the source repository source. If both repositories are of the same type and on the same filesystem, this will simply be a fast Unix hard link operation.

Otherwise, a copy will be performed.

importObjectFromWithTrust

data RepoImportObjectFromWithTrustMethodInfo

Instances

((~) * signature (b -> ObjectType -> Text -> Bool -> Maybe c -> m ()), MonadIO m, IsRepo a, IsRepo b, IsCancellable c) => MethodInfo * RepoImportObjectFromWithTrustMethodInfo a signature

Methods

overloadedMethod :: MethodProxy RepoImportObjectFromWithTrustMethodInfo a -> signature -> s

repoImportObjectFromWithTrust

Arguments

:: (HasCallStack, MonadIO m, IsRepo a, IsRepo b, IsCancellable c)

=> a

self: Destination repo

-> b

source: Source repo

-> ObjectType

objtype: Object type

-> Text

checksum: checksum

-> Bool

trusted: If True, assume the source repo is valid and trusted

-> Maybe c

cancellable: Cancellable

-> m ()

(Can throw GError)

Copy object named by objtype and checksum into self from the source repository source. If both repositories are of the same type and on the same filesystem, this will simply be a fast Unix hard link operation.

Otherwise, a copy will be performed.

isSystem

data RepoIsSystemMethodInfo

Instances

((~) * signature (m Bool), MonadIO m, IsRepo a) => MethodInfo * RepoIsSystemMethodInfo a signature

Methods

overloadedMethod :: MethodProxy RepoIsSystemMethodInfo a -> signature -> s

repoIsSystem

Arguments

:: (HasCallStack, MonadIO m, IsRepo a)

=> a

repo: Repository

-> m Bool

Returns: True if this repository is the root-owned system global repository

No description available in the introspection data.

isWritable

data RepoIsWritableMethodInfo

Instances

((~) * signature (m ()), MonadIO m, IsRepo a) => MethodInfo * RepoIsWritableMethodInfo a signature

Methods

overloadedMethod :: MethodProxy RepoIsWritableMethodInfo a -> signature -> s

repoIsWritable

Arguments

:: (HasCallStack, MonadIO m, IsRepo a)

=> a

self: Repo

-> m ()

(Can throw GError)

Returns whether the repository is writable by the current user. If the repository is not writable, the error indicates why.

listRefs

data RepoListRefsMethodInfo

Instances

((~) * signature (Maybe Text -> Maybe b -> m (Map Text Text)), MonadIO m, IsRepo a, IsCancellable b) => MethodInfo * RepoListRefsMethodInfo a signature

Methods

overloadedMethod :: MethodProxy RepoListRefsMethodInfo a -> signature -> s

repoListRefs

Arguments

:: (HasCallStack, MonadIO m, IsRepo a, IsCancellable b)

=> a

self: Repo

-> Maybe Text

refspecPrefix: Only list refs which match this prefix

-> Maybe b

cancellable: Cancellable

-> m (Map Text Text)

(Can throw GError)

If refspecPrefix is Nothing, list all local and remote refspecs, with their current values in outAllRefs. Otherwise, only list refspecs which have refspecPrefix as a prefix.

listRefsExt

data RepoListRefsExtMethodInfo

Instances

((~) * signature (Maybe Text -> RepoListRefsExtFlags -> Maybe b -> m (Map Text Text)), MonadIO m, IsRepo a, IsCancellable b) => MethodInfo * RepoListRefsExtMethodInfo a signature

Methods

overloadedMethod :: MethodProxy RepoListRefsExtMethodInfo a -> signature -> s

repoListRefsExt

Arguments

:: (HasCallStack, MonadIO m, IsRepo a, IsCancellable b)

=> a

self: Repo

-> Maybe Text

refspecPrefix: Only list refs which match this prefix

-> RepoListRefsExtFlags

flags: Options controlling listing behavior

-> Maybe b

cancellable: Cancellable

-> m (Map Text Text)

(Can throw GError)

If refspecPrefix is Nothing, list all local and remote refspecs, with their current values in outAllRefs. Otherwise, only list refspecs which have refspecPrefix as a prefix. Differently from repoListRefs, the prefix will not be removed from the ref name.

listStaticDeltaNames

data RepoListStaticDeltaNamesMethodInfo

Instances

((~) * signature (Maybe b -> m [Text]), MonadIO m, IsRepo a, IsCancellable b) => MethodInfo * RepoListStaticDeltaNamesMethodInfo a signature

Methods

overloadedMethod :: MethodProxy RepoListStaticDeltaNamesMethodInfo a -> signature -> s

repoListStaticDeltaNames

Arguments

:: (HasCallStack, MonadIO m, IsRepo a, IsCancellable b)

=> a

self: Repo

-> Maybe b

cancellable: Cancellable

-> m [Text]

(Can throw GError)

This function synchronously enumerates all static deltas in the repository, returning its result in outDeltas.

loadCommit

data RepoLoadCommitMethodInfo

Instances

((~) * signature (Text -> m (GVariant, [RepoCommitState])), MonadIO m, IsRepo a) => MethodInfo * RepoLoadCommitMethodInfo a signature

Methods

overloadedMethod :: MethodProxy RepoLoadCommitMethodInfo a -> signature -> s

repoLoadCommit

Arguments

:: (HasCallStack, MonadIO m, IsRepo a)

=> a

self: Repo

-> Text

checksum: Commit checksum

-> m (GVariant, [RepoCommitState])

(Can throw GError)

A version of repoLoadVariant specialized to commits, capable of returning extended state information. Currently the only extended state is RepoCommitStateRepoCommitStatePartial, which means that only a sub-path of the commit is available.

loadFile

data RepoLoadFileMethodInfo

Instances

((~) * signature (Text -> Maybe b -> m (InputStream, FileInfo, GVariant)), MonadIO m, IsRepo a, IsCancellable b) => MethodInfo * RepoLoadFileMethodInfo a signature

Methods

overloadedMethod :: MethodProxy RepoLoadFileMethodInfo a -> signature -> s

repoLoadFile

Arguments

:: (HasCallStack, MonadIO m, IsRepo a, IsCancellable b)

=> a

self: Repo

-> Text

checksum: ASCII SHA256 checksum

-> Maybe b

cancellable: Cancellable

-> m (InputStream, FileInfo, GVariant)

(Can throw GError)

Load content object, decomposing it into three parts: the actual content (for regular files), the metadata, and extended attributes.

loadObjectStream

data RepoLoadObjectStreamMethodInfo

Instances

((~) * signature (ObjectType -> Text -> Maybe b -> m (InputStream, Word64)), MonadIO m, IsRepo a, IsCancellable b) => MethodInfo * RepoLoadObjectStreamMethodInfo a signature

Methods

overloadedMethod :: MethodProxy RepoLoadObjectStreamMethodInfo a -> signature -> s

repoLoadObjectStream

Arguments

:: (HasCallStack, MonadIO m, IsRepo a, IsCancellable b)

=> a

self: Repo

-> ObjectType

objtype: Object type

-> Text

checksum: ASCII SHA256 checksum

-> Maybe b

cancellable: Cancellable

-> m (InputStream, Word64)

(Can throw GError)

Load object as a stream; useful when copying objects between repositories.

loadVariant

data RepoLoadVariantMethodInfo

Instances

((~) * signature (ObjectType -> Text -> m GVariant), MonadIO m, IsRepo a) => MethodInfo * RepoLoadVariantMethodInfo a signature

Methods

overloadedMethod :: MethodProxy RepoLoadVariantMethodInfo a -> signature -> s

repoLoadVariant

Arguments

:: (HasCallStack, MonadIO m, IsRepo a)

=> a

self: Repo

-> ObjectType

objtype: Expected object type

-> Text

sha256: Checksum string

-> m GVariant

(Can throw GError)

Load the metadata object sha256 of type objtype, storing the result in outVariant.

loadVariantIfExists

data RepoLoadVariantIfExistsMethodInfo

Instances

((~) * signature (ObjectType -> Text -> m GVariant), MonadIO m, IsRepo a) => MethodInfo * RepoLoadVariantIfExistsMethodInfo a signature

Methods

overloadedMethod :: MethodProxy RepoLoadVariantIfExistsMethodInfo a -> signature -> s

repoLoadVariantIfExists

Arguments

:: (HasCallStack, MonadIO m, IsRepo a)

=> a

self: Repo

-> ObjectType

objtype: Object type

-> Text

sha256: ASCII checksum

-> m GVariant

(Can throw GError)

Attempt to load the metadata object sha256 of type objtype if it exists, storing the result in outVariant. If it doesn't exist, Nothing is returned.

modeFromString

repoModeFromString

Arguments

:: (HasCallStack, MonadIO m)

=> Text

-> RepoMode

-> m ()

(Can throw GError)

No description available in the introspection data.

new

repoNew

Arguments

:: (HasCallStack, MonadIO m, IsFile a)

=> a

path: Path to a repository

-> m Repo

Returns: An accessor object for an OSTree repository located at path

No description available in the introspection data.

newDefault

repoNewDefault

Arguments

:: (HasCallStack, MonadIO m)

=> m Repo

Returns: An accessor object for an OSTree repository located at /ostree/repo

If the current working directory appears to be an OSTree repository, create a new Repo object for accessing it. Otherwise use the path in the OSTREE_REPO environment variable (if defined) or else the default system repository located at /ostree/repo.

newForSysrootPath

repoNewForSysrootPath

Arguments

:: (HasCallStack, MonadIO m, IsFile a, IsFile b)

=> a

repoPath: Path to a repository

-> b

sysrootPath: Path to the system root

-> m Repo

Returns: An accessor object for the OSTree repository located at repoPath.

Creates a new Repo instance, taking the system root path explicitly instead of assuming "/".

open

data RepoOpenMethodInfo

Instances

((~) * signature (Maybe b -> m ()), MonadIO m, IsRepo a, IsCancellable b) => MethodInfo * RepoOpenMethodInfo a signature

Methods

overloadedMethod :: MethodProxy RepoOpenMethodInfo a -> signature -> s

repoOpen

Arguments

:: (HasCallStack, MonadIO m, IsRepo a, IsCancellable b)

=> a

-> Maybe b

-> m ()

(Can throw GError)

No description available in the introspection data.

prepareTransaction

data RepoPrepareTransactionMethodInfo

Instances

((~) * signature (Maybe b -> m Bool), MonadIO m, IsRepo a, IsCancellable b) => MethodInfo * RepoPrepareTransactionMethodInfo a signature

Methods

overloadedMethod :: MethodProxy RepoPrepareTransactionMethodInfo a -> signature -> s

repoPrepareTransaction

Arguments

:: (HasCallStack, MonadIO m, IsRepo a, IsCancellable b)

=> a

self: An Repo

-> Maybe b

cancellable: Cancellable

-> m Bool

(Can throw GError)

Starts or resumes a transaction. In order to write to a repo, you need to start a transaction. You can complete the transaction with repoCommitTransaction, or abort the transaction with repoAbortTransaction.

Currently, transactions are not atomic, and aborting a transaction will not erase any data you write during the transaction.

prune

data RepoPruneMethodInfo

Instances

((~) * signature (RepoPruneFlags -> Int32 -> Maybe b -> m (Int32, Int32, Word64)), MonadIO m, IsRepo a, IsCancellable b) => MethodInfo * RepoPruneMethodInfo a signature

Methods

overloadedMethod :: MethodProxy RepoPruneMethodInfo a -> signature -> s

repoPrune

Arguments

:: (HasCallStack, MonadIO m, IsRepo a, IsCancellable b)

=> a

self: Repo

-> RepoPruneFlags

flags: Options controlling prune process

-> Int32

depth: Stop traversal after this many iterations (-1 for unlimited)

-> Maybe b

cancellable: Cancellable

-> m (Int32, Int32, Word64)

(Can throw GError)

Delete content from the repository. By default, this function will only delete "orphaned" objects not referred to by any commit. This can happen during a local commit operation, when we have written content objects but not saved the commit referencing them.

However, if RepoPruneFlagsRefsOnly is provided, instead of traversing all commits, only refs will be used. Particularly when combined with depth, this is a convenient way to delete history from the repository.

Use the RepoPruneFlagsNoPrune to just determine statistics on objects that would be deleted, without actually deleting them.

pruneFromReachable

data RepoPruneFromReachableMethodInfo

Instances

((~) * signature (RepoPruneOptions -> Maybe b -> m (Int32, Int32, Word64)), MonadIO m, IsRepo a, IsCancellable b) => MethodInfo * RepoPruneFromReachableMethodInfo a signature

Methods

overloadedMethod :: MethodProxy RepoPruneFromReachableMethodInfo a -> signature -> s

repoPruneFromReachable

Arguments

:: (HasCallStack, MonadIO m, IsRepo a, IsCancellable b)

=> a

self: Repo

-> RepoPruneOptions

options: Options controlling prune process

-> Maybe b

cancellable: Cancellable

-> m (Int32, Int32, Word64)

(Can throw GError)

Delete content from the repository. This function is the "backend" half of the higher level repoPrune. To use this function, you determine the root set yourself, and this function finds all other unreferenced objects and deletes them.

Use this API when you want to perform more selective pruning - for example, retain all commits from a production branch, but just GC some history from your dev branch.

The RepoPruneFlagsNoPrune flag may be specified to just determine statistics on objects that would be deleted, without actually deleting them.

pruneStaticDeltas

data RepoPruneStaticDeltasMethodInfo

Instances

((~) * signature (Maybe Text -> Maybe b -> m ()), MonadIO m, IsRepo a, IsCancellable b) => MethodInfo * RepoPruneStaticDeltasMethodInfo a signature

Methods

overloadedMethod :: MethodProxy RepoPruneStaticDeltasMethodInfo a -> signature -> s

repoPruneStaticDeltas

Arguments

:: (HasCallStack, MonadIO m, IsRepo a, IsCancellable b)

=> a

self: Repo

-> Maybe Text

commit: ASCII SHA256 checksum for commit, or Nothing for each non existing commit

-> Maybe b

cancellable: Cancellable

-> m ()

(Can throw GError)

Prune static deltas, if COMMIT is specified then delete static delta files only targeting that commit; otherwise any static delta of non existing commits are deleted.

pull

data RepoPullMethodInfo

Instances

((~) * signature (Text -> Maybe [Text] -> [RepoPullFlags] -> Maybe b -> Maybe c -> m ()), MonadIO m, IsRepo a, IsAsyncProgress b, IsCancellable c) => MethodInfo * RepoPullMethodInfo a signature

Methods

overloadedMethod :: MethodProxy RepoPullMethodInfo a -> signature -> s

repoPull

Arguments

:: (HasCallStack, MonadIO m, IsRepo a, IsAsyncProgress b, IsCancellable c)

=> a

self: Repo

-> Text

remoteName: Name of remote

-> Maybe [Text]

refsToFetch: Optional list of refs; if Nothing, fetch all configured refs

-> [RepoPullFlags]

flags: Options controlling fetch behavior

-> Maybe b

progress: Progress

-> Maybe c

cancellable: Cancellable

-> m ()

(Can throw GError)

Connect to the remote repository, fetching the specified set of refs refsToFetch. For each ref that is changed, download the commit, all metadata, and all content objects, storing them safely on disk in self.

If flags contains RepoPullFlagsMirror, and the refsToFetch is Nothing, and the remote repository contains a summary file, then all refs will be fetched.

If flags contains RepoPullFlagsCommitOnly, then only the metadata for the commits in refsToFetch is pulled.

Warning: This API will iterate the thread default main context, which is a bug, but kept for compatibility reasons. If you want to avoid this, use mainContextPushThreadDefault to push a new one around this call.

pullDefaultConsoleProgressChanged

repoPullDefaultConsoleProgressChanged

Arguments

:: (HasCallStack, MonadIO m, IsAsyncProgress a)

=> a

progress: Async progress

-> Ptr ()

userData: User data

-> m ()

Convenient "changed" callback for use with asyncProgressNewAndConnect when pulling from a remote repository.

Depending on the state of the AsyncProgress, either displays a custom status message, or else outstanding fetch progress in bytes/sec, or else outstanding content or metadata writes to the repository in number of objects.

Compatibility note: this function previously assumed that userData was a pointer to a GSConsole instance. This is no longer the case, and userData is ignored.

pullOneDir

data RepoPullOneDirMethodInfo

Instances

((~) * signature (Text -> Text -> Maybe [Text] -> [RepoPullFlags] -> Maybe b -> Maybe c -> m ()), MonadIO m, IsRepo a, IsAsyncProgress b, IsCancellable c) => MethodInfo * RepoPullOneDirMethodInfo a signature

Methods

overloadedMethod :: MethodProxy RepoPullOneDirMethodInfo a -> signature -> s

repoPullOneDir

Arguments

:: (HasCallStack, MonadIO m, IsRepo a, IsAsyncProgress b, IsCancellable c)

=> a

self: Repo

-> Text

remoteName: Name of remote

-> Text

dirToPull: Subdirectory path

-> Maybe [Text]

refsToFetch: Optional list of refs; if Nothing, fetch all configured refs

-> [RepoPullFlags]

flags: Options controlling fetch behavior

-> Maybe b

progress: Progress

-> Maybe c

cancellable: Cancellable

-> m ()

(Can throw GError)

This is similar to repoPull, but only fetches a single subpath.

pullWithOptions

data RepoPullWithOptionsMethodInfo

Instances

((~) * signature (Text -> GVariant -> Maybe b -> Maybe c -> m ()), MonadIO m, IsRepo a, IsAsyncProgress b, IsCancellable c) => MethodInfo * RepoPullWithOptionsMethodInfo a signature

Methods

overloadedMethod :: MethodProxy RepoPullWithOptionsMethodInfo a -> signature -> s

repoPullWithOptions

Arguments

:: (HasCallStack, MonadIO m, IsRepo a, IsAsyncProgress b, IsCancellable c)

=> a

self: Repo

-> Text

remoteNameOrBaseurl: Name of remote or file:// url

-> GVariant

options: A GVariant a{sv} with an extensible set of flags.

-> Maybe b

progress: Progress

-> Maybe c

cancellable: Cancellable

-> m ()

(Can throw GError)

Like repoPull, but supports an extensible set of flags. The following are currently defined:

• refs (as): Array of string refs
• flags (i): An instance of RepoPullFlags
• subdir (s): Pull just this subdirectory
• subdirs (as): Pull just these subdirectories
• override-remote-name (s): If local, add this remote to refspec
• gpg-verify (b): GPG verify commits
• gpg-verify-summary (b): GPG verify summary
• depth (i): How far in the history to traverse; default is 0, -1 means infinite
• disable-static-deltas (b): Do not use static deltas
• require-static-deltas (b): Require static deltas
• override-commit-ids (as): Array of specific commit IDs to fetch for refs
• dry-run (b): Only print information on what will be downloaded (requires static deltas)
• override-url (s): Fetch objects from this URL if remote specifies no metalink in options
• inherit-transaction (b): Don't initiate, finish or abort a transaction, usefult to do mutliple pulls in one transaction.
• http-headers (a(ss)): Additional headers to add to all HTTP requests
• update-frequency (u): Frequency to call the async progress callback in milliseconds, if any; only values higher than 0 are valid

queryObjectStorageSize

data RepoQueryObjectStorageSizeMethodInfo

Instances

((~) * signature (ObjectType -> Text -> Maybe b -> m Word64), MonadIO m, IsRepo a, IsCancellable b) => MethodInfo * RepoQueryObjectStorageSizeMethodInfo a signature

Methods

overloadedMethod :: MethodProxy RepoQueryObjectStorageSizeMethodInfo a -> signature -> s

repoQueryObjectStorageSize

Arguments

:: (HasCallStack, MonadIO m, IsRepo a, IsCancellable b)

=> a

self: Repo

-> ObjectType

objtype: Object type

-> Text

sha256: Checksum

-> Maybe b

cancellable: Cancellable

-> m Word64

(Can throw GError)

Return the size in bytes of object with checksum sha256, after any compression has been applied.

readCommit

data RepoReadCommitMethodInfo

Instances

((~) * signature (Text -> Maybe b -> m (File, Text)), MonadIO m, IsRepo a, IsCancellable b) => MethodInfo * RepoReadCommitMethodInfo a signature

Methods

overloadedMethod :: MethodProxy RepoReadCommitMethodInfo a -> signature -> s

repoReadCommit

Arguments

:: (HasCallStack, MonadIO m, IsRepo a, IsCancellable b)

=> a

self: Repo

-> Text

ref: Ref or ASCII checksum

-> Maybe b

cancellable: Cancellable

-> m (File, Text)

(Can throw GError)

Load the content for rev into outRoot.

readCommitDetachedMetadata

data RepoReadCommitDetachedMetadataMethodInfo

Instances

((~) * signature (Text -> Maybe b -> m GVariant), MonadIO m, IsRepo a, IsCancellable b) => MethodInfo * RepoReadCommitDetachedMetadataMethodInfo a signature

Methods

overloadedMethod :: MethodProxy RepoReadCommitDetachedMetadataMethodInfo a -> signature -> s

repoReadCommitDetachedMetadata

Arguments

:: (HasCallStack, MonadIO m, IsRepo a, IsCancellable b)

=> a

self: Repo

-> Text

checksum: ASCII SHA256 commit checksum

-> Maybe b

cancellable: Cancellable

-> m GVariant

(Can throw GError)

OSTree commits can have arbitrary metadata associated; this function retrieves them. If none exists, outMetadata will be set to Nothing.

regenerateSummary

data RepoRegenerateSummaryMethodInfo

Instances

((~) * signature (Maybe GVariant -> Maybe b -> m ()), MonadIO m, IsRepo a, IsCancellable b) => MethodInfo * RepoRegenerateSummaryMethodInfo a signature

Methods

overloadedMethod :: MethodProxy RepoRegenerateSummaryMethodInfo a -> signature -> s

repoRegenerateSummary

Arguments

:: (HasCallStack, MonadIO m, IsRepo a, IsCancellable b)

=> a

self: Repo

-> Maybe GVariant

additionalMetadata: A GVariant of type a{sv}, or Nothing

-> Maybe b

cancellable: Cancellable

-> m ()

(Can throw GError)

An OSTree repository can contain a high level "summary" file that describes the available branches and other metadata.

It is regenerated automatically after a commit if core/commit-update-summary is set.

reloadConfig

data RepoReloadConfigMethodInfo

Instances

((~) * signature (Maybe b -> m ()), MonadIO m, IsRepo a, IsCancellable b) => MethodInfo * RepoReloadConfigMethodInfo a signature

Methods

overloadedMethod :: MethodProxy RepoReloadConfigMethodInfo a -> signature -> s

repoReloadConfig

Arguments

:: (HasCallStack, MonadIO m, IsRepo a, IsCancellable b)

=> a

self: repo

-> Maybe b

cancellable: cancellable

-> m ()

(Can throw GError)

By default, an Repo will cache the remote configuration and its own repo/config data. This API can be used to reload it.

remoteAdd

data RepoRemoteAddMethodInfo

Instances

((~) * signature (Text -> Text -> Maybe GVariant -> Maybe b -> m ()), MonadIO m, IsRepo a, IsCancellable b) => MethodInfo * RepoRemoteAddMethodInfo a signature

Methods

overloadedMethod :: MethodProxy RepoRemoteAddMethodInfo a -> signature -> s

repoRemoteAdd

Arguments

:: (HasCallStack, MonadIO m, IsRepo a, IsCancellable b)

=> a

self: Repo

-> Text

name: Name of remote

-> Text

url: URL for remote (if URL begins with metalink=, it will be used as such)

-> Maybe GVariant

options: GVariant of type a{sv}

-> Maybe b

cancellable: Cancellable

-> m ()

(Can throw GError)

Create a new remote named name pointing to url. If options is provided, then it will be mapped to KeyFile entries, where the GVariant dictionary key is an option string, and the value is mapped as follows: * s: keyFileSetString * b: keyFileSetBoolean * as: keyFileSetStringList

remoteChange

data RepoRemoteChangeMethodInfo

Instances

((~) * signature (Maybe b -> RepoRemoteChange -> Text -> Text -> Maybe GVariant -> Maybe c -> m ()), MonadIO m, IsRepo a, IsFile b, IsCancellable c) => MethodInfo * RepoRemoteChangeMethodInfo a signature

Methods

overloadedMethod :: MethodProxy RepoRemoteChangeMethodInfo a -> signature -> s

repoRemoteChange

Arguments

:: (HasCallStack, MonadIO m, IsRepo a, IsFile b, IsCancellable c)

=> a

self: Repo

-> Maybe b

sysroot: System root

-> RepoRemoteChange

changeop: Operation to perform

-> Text

name: Name of remote

-> Text

url: URL for remote (if URL begins with metalink=, it will be used as such)

-> Maybe GVariant

options: GVariant of type a{sv}

-> Maybe c

cancellable: Cancellable

-> m ()

(Can throw GError)

A combined function handling the equivalent of repoRemoteAdd, repoRemoteDelete, with more options.

remoteDelete

data RepoRemoteDeleteMethodInfo

Instances

((~) * signature (Text -> Maybe b -> m ()), MonadIO m, IsRepo a, IsCancellable b) => MethodInfo * RepoRemoteDeleteMethodInfo a signature

Methods

overloadedMethod :: MethodProxy RepoRemoteDeleteMethodInfo a -> signature -> s

repoRemoteDelete

Arguments

:: (HasCallStack, MonadIO m, IsRepo a, IsCancellable b)

=> a

self: Repo

-> Text

name: Name of remote

-> Maybe b

cancellable: Cancellable

-> m ()

(Can throw GError)

Delete the remote named name. It is an error if the provided remote does not exist.

remoteFetchSummary

data RepoRemoteFetchSummaryMethodInfo

Instances

((~) * signature (Text -> Maybe b -> m (Bytes, Bytes)), MonadIO m, IsRepo a, IsCancellable b) => MethodInfo * RepoRemoteFetchSummaryMethodInfo a signature

Methods

overloadedMethod :: MethodProxy RepoRemoteFetchSummaryMethodInfo a -> signature -> s

repoRemoteFetchSummary

Arguments

:: (HasCallStack, MonadIO m, IsRepo a, IsCancellable b)

=> a

self: Self

-> Text

name: name of a remote

-> Maybe b

cancellable: a Cancellable

-> m (Bytes, Bytes)

(Can throw GError)

Tries to fetch the summary file and any GPG signatures on the summary file over HTTP, and returns the binary data in outSummary and outSignatures respectively.

If no summary file exists on the remote server, outSummary is set to nULL. Likewise if the summary file is not signed, outSignatures is set to nULL. In either case the function still returns True.

Parse the summary data into a GVariant using variantNewFromBytes with OSTREE_SUMMARY_GVARIANT_FORMAT as the format string.

remoteFetchSummaryWithOptions

data RepoRemoteFetchSummaryWithOptionsMethodInfo

Instances

((~) * signature (Text -> Maybe GVariant -> Maybe b -> m (Bytes, Bytes)), MonadIO m, IsRepo a, IsCancellable b) => MethodInfo * RepoRemoteFetchSummaryWithOptionsMethodInfo a signature

Methods

overloadedMethod :: MethodProxy RepoRemoteFetchSummaryWithOptionsMethodInfo a -> signature -> s

repoRemoteFetchSummaryWithOptions

Arguments

:: (HasCallStack, MonadIO m, IsRepo a, IsCancellable b)

=> a

self: Self

-> Text

name: name of a remote

-> Maybe GVariant

options: A GVariant a{sv} with an extensible set of flags

-> Maybe b

cancellable: a Cancellable

-> m (Bytes, Bytes)

(Can throw GError)

Like repoRemoteFetchSummary, but supports an extensible set of flags. The following are currently defined:

• override-url (s): Fetch summary from this URL if remote specifies no metalink in options

remoteGetGpgVerify

data RepoRemoteGetGpgVerifyMethodInfo

Instances

((~) * signature (Text -> m Bool), MonadIO m, IsRepo a) => MethodInfo * RepoRemoteGetGpgVerifyMethodInfo a signature

Methods

overloadedMethod :: MethodProxy RepoRemoteGetGpgVerifyMethodInfo a -> signature -> s

repoRemoteGetGpgVerify

Arguments

:: (HasCallStack, MonadIO m, IsRepo a)

=> a

self: Repo

-> Text

name: Name of remote

-> m Bool

(Can throw GError)

Return whether GPG verification is enabled for the remote named name through outGpgVerify. It is an error if the provided remote does not exist.

remoteGetGpgVerifySummary

data RepoRemoteGetGpgVerifySummaryMethodInfo

Instances

((~) * signature (Text -> m Bool), MonadIO m, IsRepo a) => MethodInfo * RepoRemoteGetGpgVerifySummaryMethodInfo a signature

Methods

overloadedMethod :: MethodProxy RepoRemoteGetGpgVerifySummaryMethodInfo a -> signature -> s

repoRemoteGetGpgVerifySummary

Arguments

:: (HasCallStack, MonadIO m, IsRepo a)

=> a

self: Repo

-> Text

name: Name of remote

-> m Bool

(Can throw GError)

Return whether GPG verification of the summary is enabled for the remote named name through outGpgVerifySummary. It is an error if the provided remote does not exist.

remoteGetUrl

data RepoRemoteGetUrlMethodInfo

Instances

((~) * signature (Text -> m Text), MonadIO m, IsRepo a) => MethodInfo * RepoRemoteGetUrlMethodInfo a signature

Methods

overloadedMethod :: MethodProxy RepoRemoteGetUrlMethodInfo a -> signature -> s

repoRemoteGetUrl

Arguments

:: (HasCallStack, MonadIO m, IsRepo a)

=> a

self: Repo

-> Text

name: Name of remote

-> m Text

(Can throw GError)

Return the URL of the remote named name through outUrl. It is an error if the provided remote does not exist.

remoteGpgImport

data RepoRemoteGpgImportMethodInfo

Instances

((~) * signature (Text -> Maybe b -> Maybe [Text] -> Word32 -> Maybe c -> m ()), MonadIO m, IsRepo a, IsInputStream b, IsCancellable c) => MethodInfo * RepoRemoteGpgImportMethodInfo a signature

Methods

overloadedMethod :: MethodProxy RepoRemoteGpgImportMethodInfo a -> signature -> s

repoRemoteGpgImport

Arguments

:: (HasCallStack, MonadIO m, IsRepo a, IsInputStream b, IsCancellable c)

=> a

self: Self

-> Text

name: name of a remote

-> Maybe b

sourceStream: a InputStream, or Nothing

-> Maybe [Text]

keyIds: a Nothing-terminated array of GPG key IDs, or Nothing

-> Word32

outImported: return location for the number of imported keys, or Nothing

-> Maybe c

cancellable: a Cancellable

-> m ()

(Can throw GError)

Imports one or more GPG keys from the open sourceStream, or from the user's personal keyring if sourceStream is Nothing. The keyIds array can optionally restrict which keys are imported. If keyIds is Nothing, then all keys are imported.

The imported keys will be used to conduct GPG verification when pulling from the remote named name.

remoteList

data RepoRemoteListMethodInfo

Instances

((~) * signature (m [Text]), MonadIO m, IsRepo a) => MethodInfo * RepoRemoteListMethodInfo a signature

Methods

overloadedMethod :: MethodProxy RepoRemoteListMethodInfo a -> signature -> s

repoRemoteList

Arguments

:: (HasCallStack, MonadIO m, IsRepo a)

=> a

self: Repo

-> m [Text]

Returns: a Nothing-terminated array of remote names

List available remote names in an Repo. Remote names are sorted alphabetically. If no remotes are available the function returns Nothing.

remoteListRefs

data RepoRemoteListRefsMethodInfo

Instances

((~) * signature (Text -> Maybe b -> m (Map Text Text)), MonadIO m, IsRepo a, IsCancellable b) => MethodInfo * RepoRemoteListRefsMethodInfo a signature

Methods

overloadedMethod :: MethodProxy RepoRemoteListRefsMethodInfo a -> signature -> s

repoRemoteListRefs

Arguments

:: (HasCallStack, MonadIO m, IsRepo a, IsCancellable b)

=> a

self: Repo

-> Text

remoteName: Name of the remote.

-> Maybe b

cancellable: Cancellable

-> m (Map Text Text)

(Can throw GError)

No description available in the introspection data.

resolveRev

data RepoResolveRevMethodInfo

Instances

((~) * signature (Text -> Bool -> m Text), MonadIO m, IsRepo a) => MethodInfo * RepoResolveRevMethodInfo a signature

Methods

overloadedMethod :: MethodProxy RepoResolveRevMethodInfo a -> signature -> s

repoResolveRev

Arguments

:: (HasCallStack, MonadIO m, IsRepo a)

=> a

self: Repo

-> Text

refspec: A refspec

-> Bool

allowNoent: Do not throw an error if refspec does not exist

-> m Text

(Can throw GError)

Look up the given refspec, returning the checksum it references in the parameter outRev. Will fall back on remote directory if cannot find the given refspec in local.

resolveRevExt

data RepoResolveRevExtMethodInfo

Instances

((~) * signature (Text -> Bool -> RepoResolveRevExtFlags -> m Text), MonadIO m, IsRepo a) => MethodInfo * RepoResolveRevExtMethodInfo a signature

Methods

overloadedMethod :: MethodProxy RepoResolveRevExtMethodInfo a -> signature -> s

repoResolveRevExt

Arguments

:: (HasCallStack, MonadIO m, IsRepo a)

=> a

self: Repo

-> Text

refspec: A refspec

-> Bool

allowNoent: Do not throw an error if refspec does not exist

-> RepoResolveRevExtFlags

flags: Options controlling behavior

-> m Text

(Can throw GError)

Look up the given refspec, returning the checksum it references in the parameter outRev. Differently from repoResolveRev, this will not fall back to searching through remote repos if a local ref is specified but not found.

scanHardlinks

data RepoScanHardlinksMethodInfo

Instances

((~) * signature (Maybe b -> m ()), MonadIO m, IsRepo a, IsCancellable b) => MethodInfo * RepoScanHardlinksMethodInfo a signature

Methods

overloadedMethod :: MethodProxy RepoScanHardlinksMethodInfo a -> signature -> s

repoScanHardlinks

Arguments

:: (HasCallStack, MonadIO m, IsRepo a, IsCancellable b)

=> a

self: An Repo

-> Maybe b

cancellable: Cancellable

-> m ()

(Can throw GError)

When ostree builds a mutable tree from directory like in repoWriteDirectoryToMtree, it has to scan all files that you pass in and compute their checksums. If your commit contains hardlinks from ostree's existing repo, ostree can build a mapping of device numbers and inodes to their checksum.

There is an upfront cost to creating this mapping, as this will scan the entire objects directory. If your commit is composed of mostly hardlinks to existing ostree objects, then this will speed up considerably, so call it before you call ostree_write_directory_to_mtree() or similar.

setCacheDir

data RepoSetCacheDirMethodInfo

Instances

((~) * signature (Int32 -> Text -> Maybe b -> m ()), MonadIO m, IsRepo a, IsCancellable b) => MethodInfo * RepoSetCacheDirMethodInfo a signature

Methods

overloadedMethod :: MethodProxy RepoSetCacheDirMethodInfo a -> signature -> s

repoSetCacheDir

Arguments

:: (HasCallStack, MonadIO m, IsRepo a, IsCancellable b)

=> a

self: An Repo

-> Int32

dfd: directory fd

-> Text

path: subpath in dfd

-> Maybe b

cancellable: a Cancellable

-> m ()

(Can throw GError)

Set a custom location for the cache directory used for e.g. per-remote summary caches. Setting this manually is useful when doing operations on a system repo as a user because you don't have write permissions in the repo, where the cache is normally stored.

setDisableFsync

data RepoSetDisableFsyncMethodInfo

Instances

((~) * signature (Bool -> m ()), MonadIO m, IsRepo a) => MethodInfo * RepoSetDisableFsyncMethodInfo a signature

Methods

overloadedMethod :: MethodProxy RepoSetDisableFsyncMethodInfo a -> signature -> s

repoSetDisableFsync

Arguments

:: (HasCallStack, MonadIO m, IsRepo a)

=> a

self: An Repo

-> Bool

disableFsync: If True, do not fsync

-> m ()

Disable requests to fsync() to stable storage during commits. This option should only be used by build system tools which are creating disposable virtual machines, or have higher level mechanisms for ensuring data consistency.

setRefImmediate

data RepoSetRefImmediateMethodInfo

Instances

((~) * signature (Maybe Text -> Text -> Maybe Text -> Maybe b -> m ()), MonadIO m, IsRepo a, IsCancellable b) => MethodInfo * RepoSetRefImmediateMethodInfo a signature

Methods

overloadedMethod :: MethodProxy RepoSetRefImmediateMethodInfo a -> signature -> s

repoSetRefImmediate

Arguments

:: (HasCallStack, MonadIO m, IsRepo a, IsCancellable b)

=> a

self: An Repo

-> Maybe Text

remote: A remote for the ref

-> Text

ref: The ref to write

-> Maybe Text

checksum: The checksum to point it to, or Nothing to unset

-> Maybe b

cancellable: GCancellable

-> m ()

(Can throw GError)

This is like repoTransactionSetRef, except it may be invoked outside of a transaction. This is presently safe for the case where we're creating or overwriting an existing ref.

signCommit

data RepoSignCommitMethodInfo

Instances

((~) * signature (Text -> Text -> Maybe Text -> Maybe b -> m ()), MonadIO m, IsRepo a, IsCancellable b) => MethodInfo * RepoSignCommitMethodInfo a signature

Methods

overloadedMethod :: MethodProxy RepoSignCommitMethodInfo a -> signature -> s

repoSignCommit

Arguments

:: (HasCallStack, MonadIO m, IsRepo a, IsCancellable b)

=> a

self: Self

-> Text

commitChecksum: SHA256 of given commit to sign

-> Text

keyId: Use this GPG key id

-> Maybe Text

homedir: GPG home directory, or Nothing

-> Maybe b

cancellable: A Cancellable

-> m ()

(Can throw GError)

Add a GPG signature to a commit.

signDelta

data RepoSignDeltaMethodInfo

Instances

((~) * signature (Text -> Text -> Text -> Text -> Maybe b -> m ()), MonadIO m, IsRepo a, IsCancellable b) => MethodInfo * RepoSignDeltaMethodInfo a signature

Methods

overloadedMethod :: MethodProxy RepoSignDeltaMethodInfo a -> signature -> s

repoSignDelta

Arguments

:: (HasCallStack, MonadIO m, IsRepo a, IsCancellable b)

=> a

-> Text

-> Text

-> Text

-> Text

-> Maybe b

-> m ()

(Can throw GError)

This function is deprecated, sign the summary file instead. Add a GPG signature to a static delta.

staticDeltaExecuteOffline

data RepoStaticDeltaExecuteOfflineMethodInfo

Instances

((~) * signature (b -> Bool -> Maybe c -> m ()), MonadIO m, IsRepo a, IsFile b, IsCancellable c) => MethodInfo * RepoStaticDeltaExecuteOfflineMethodInfo a signature

Methods

overloadedMethod :: MethodProxy RepoStaticDeltaExecuteOfflineMethodInfo a -> signature -> s

repoStaticDeltaExecuteOffline

Arguments

:: (HasCallStack, MonadIO m, IsRepo a, IsFile b, IsCancellable c)

=> a

self: Repo

-> b

dirOrFile: Path to a directory containing static delta data, or directly to the superblock

-> Bool

skipValidation: If True, assume data integrity

-> Maybe c

cancellable: Cancellable

-> m ()

(Can throw GError)

Given a directory representing an already-downloaded static delta on disk, apply it, generating a new commit. The directory must be named with the form "FROM-TO", where both are checksums, and it must contain a file named "superblock", along with at least one part.

staticDeltaGenerate

data RepoStaticDeltaGenerateMethodInfo

Instances

((~) * signature (StaticDeltaGenerateOpt -> Text -> Text -> Maybe GVariant -> Maybe GVariant -> Maybe b -> m ()), MonadIO m, IsRepo a, IsCancellable b) => MethodInfo * RepoStaticDeltaGenerateMethodInfo a signature

Methods

overloadedMethod :: MethodProxy RepoStaticDeltaGenerateMethodInfo a -> signature -> s

repoStaticDeltaGenerate

Arguments

:: (HasCallStack, MonadIO m, IsRepo a, IsCancellable b)

=> a

self: Repo

-> StaticDeltaGenerateOpt

opt: High level optimization choice

-> Text

from: ASCII SHA256 checksum of origin, or Nothing

-> Text

to: ASCII SHA256 checksum of target

-> Maybe GVariant

metadata: Optional metadata

-> Maybe GVariant

params: Parameters, see below

-> Maybe b

cancellable: Cancellable

-> m ()

(Can throw GError)

Generate a lookaside "static delta" from from (Nothing means from-empty) which can generate the objects in to. This delta is an optimization over fetching individual objects, and can be conveniently stored and applied offline.

The params argument should be an a{sv}. The following attributes are known: - min-fallback-size: u: Minimum uncompressed size in megabytes to use fallback, 0 to disable fallbacks - max-chunk-size: u: Maximum size in megabytes of a delta part - max-bsdiff-size: u: Maximum size in megabytes to consider bsdiff compression for input files - compression: y: Compression type: 0=none, x=lzma, g=gzip - bsdiff-enabled: b: Enable bsdiff compression. Default TRUE. - inline-parts: b: Put part data in header, to get a single file delta. Default FALSE. - verbose: b: Print diagnostic messages. Default FALSE. - endianness: b: Deltas use host byte order by default; this option allows choosing (G_BIG_ENDIAN or G_LITTLE_ENDIAN) - filename: ay: Save delta superblock to this filename, and parts in the same directory. Default saves to repository.

transactionSetRef

data RepoTransactionSetRefMethodInfo

Instances

((~) * signature (Maybe Text -> Text -> Text -> m ()), MonadIO m, IsRepo a) => MethodInfo * RepoTransactionSetRefMethodInfo a signature

Methods

overloadedMethod :: MethodProxy RepoTransactionSetRefMethodInfo a -> signature -> s

repoTransactionSetRef

Arguments

:: (HasCallStack, MonadIO m, IsRepo a)

=> a

self: An Repo

-> Maybe Text

remote: A remote for the ref

-> Text

ref: The ref to write

-> Text

checksum: The checksum to point it to

-> m ()

If checksum is not Nothing, then record it as the target of ref named ref; if remote is provided, the ref will appear to originate from that remote.

Otherwise, if checksum is Nothing, then record that the ref should be deleted.

The change will not be written out immediately, but when the transaction is completed with repoCommitTransaction. If the transaction is instead aborted with repoAbortTransaction, no changes will be made to the repository.

transactionSetRefspec

data RepoTransactionSetRefspecMethodInfo

Instances

((~) * signature (Text -> Text -> m ()), MonadIO m, IsRepo a) => MethodInfo * RepoTransactionSetRefspecMethodInfo a signature

Methods

overloadedMethod :: MethodProxy RepoTransactionSetRefspecMethodInfo a -> signature -> s

repoTransactionSetRefspec

Arguments

:: (HasCallStack, MonadIO m, IsRepo a)

=> a

self: An Repo

-> Text

refspec: The refspec to write

-> Text

checksum: The checksum to point it to

-> m ()

Like repoTransactionSetRef, but takes concatenated refspec format as input instead of separate remote and name arguments.

verifyCommit

data RepoVerifyCommitMethodInfo

Instances

((~) * signature (Text -> Maybe b -> Maybe c -> Maybe d -> m ()), MonadIO m, IsRepo a, IsFile b, IsFile c, IsCancellable d) => MethodInfo * RepoVerifyCommitMethodInfo a signature

Methods

overloadedMethod :: MethodProxy RepoVerifyCommitMethodInfo a -> signature -> s

repoVerifyCommit

Arguments

:: (HasCallStack, MonadIO m, IsRepo a, IsFile b, IsFile c, IsCancellable d)

=> a

self: Repository

-> Text

commitChecksum: ASCII SHA256 checksum

-> Maybe b

keyringdir: Path to directory GPG keyrings; overrides built-in default if given

-> Maybe c

extraKeyring: Path to additional keyring file (not a directory)

-> Maybe d

cancellable: Cancellable

-> m ()

(Can throw GError)

Check for a valid GPG signature on commit named by the ASCII checksum commitChecksum.

verifyCommitExt

data RepoVerifyCommitExtMethodInfo

Instances

((~) * signature (Text -> Maybe b -> Maybe c -> Maybe d -> m GpgVerifyResult), MonadIO m, IsRepo a, IsFile b, IsFile c, IsCancellable d) => MethodInfo * RepoVerifyCommitExtMethodInfo a signature

Methods

overloadedMethod :: MethodProxy RepoVerifyCommitExtMethodInfo a -> signature -> s

repoVerifyCommitExt

Arguments

:: (HasCallStack, MonadIO m, IsRepo a, IsFile b, IsFile c, IsCancellable d)

=> a

self: Repository

-> Text

commitChecksum: ASCII SHA256 checksum

-> Maybe b

keyringdir: Path to directory GPG keyrings; overrides built-in default if given

-> Maybe c

extraKeyring: Path to additional keyring file (not a directory)

-> Maybe d

cancellable: Cancellable

-> m GpgVerifyResult

Returns: an GpgVerifyResult, or Nothing on error (Can throw GError)

Read GPG signature(s) on the commit named by the ASCII checksum commitChecksum and return detailed results.

verifyCommitForRemote

data RepoVerifyCommitForRemoteMethodInfo

Instances

((~) * signature (Text -> Text -> Maybe b -> m GpgVerifyResult), MonadIO m, IsRepo a, IsCancellable b) => MethodInfo * RepoVerifyCommitForRemoteMethodInfo a signature

Methods

overloadedMethod :: MethodProxy RepoVerifyCommitForRemoteMethodInfo a -> signature -> s

repoVerifyCommitForRemote

Arguments

:: (HasCallStack, MonadIO m, IsRepo a, IsCancellable b)

=> a

self: Repository

-> Text

commitChecksum: ASCII SHA256 checksum

-> Text

remoteName: OSTree remote to use for configuration

-> Maybe b

cancellable: Cancellable

-> m GpgVerifyResult

Returns: an GpgVerifyResult, or Nothing on error (Can throw GError)

Read GPG signature(s) on the commit named by the ASCII checksum commitChecksum and return detailed results, based on the keyring configured for remote.

verifySummary

data RepoVerifySummaryMethodInfo

Instances

((~) * signature (Text -> Bytes -> Bytes -> Maybe b -> m GpgVerifyResult), MonadIO m, IsRepo a, IsCancellable b) => MethodInfo * RepoVerifySummaryMethodInfo a signature

Methods

overloadedMethod :: MethodProxy RepoVerifySummaryMethodInfo a -> signature -> s

repoVerifySummary

Arguments

:: (HasCallStack, MonadIO m, IsRepo a, IsCancellable b)

=> a

self: Repo

-> Text

remoteName: Name of remote

-> Bytes

summary: Summary data as a Bytes

-> Bytes

signatures: Summary signatures as a Bytes

-> Maybe b

cancellable: Cancellable

-> m GpgVerifyResult

Returns: an GpgVerifyResult, or Nothing on error (Can throw GError)

Verify signatures for summary data using GPG keys in the keyring for remoteName, and return an GpgVerifyResult.

writeArchiveToMtree

data RepoWriteArchiveToMtreeMethodInfo

Instances

((~) * signature (b -> c -> Maybe RepoCommitModifier -> Bool -> Maybe d -> m ()), MonadIO m, IsRepo a, IsFile b, IsMutableTree c, IsCancellable d) => MethodInfo * RepoWriteArchiveToMtreeMethodInfo a signature

Methods

overloadedMethod :: MethodProxy RepoWriteArchiveToMtreeMethodInfo a -> signature -> s

repoWriteArchiveToMtree

Arguments

:: (HasCallStack, MonadIO m, IsRepo a, IsFile b, IsMutableTree c, IsCancellable d)

=> a

self: An Repo

-> b

archive: A path to an archive file

-> c

mtree: The MutableTree to write to

-> Maybe RepoCommitModifier

modifier: Optional commit modifier

-> Bool

autocreateParents: Autocreate parent directories

-> Maybe d

cancellable: Cancellable

-> m ()

(Can throw GError)

Import an archive file archive into the repository, and write its file structure to mtree.

writeCommit

data RepoWriteCommitMethodInfo

Instances

((~) * signature (Maybe Text -> Maybe Text -> Maybe Text -> Maybe GVariant -> b -> Maybe c -> m Text), MonadIO m, IsRepo a, IsRepoFile b, IsCancellable c) => MethodInfo * RepoWriteCommitMethodInfo a signature

Methods

overloadedMethod :: MethodProxy RepoWriteCommitMethodInfo a -> signature -> s

repoWriteCommit

Arguments

:: (HasCallStack, MonadIO m, IsRepo a, IsRepoFile b, IsCancellable c)

=> a

self: Repo

-> Maybe Text

parent: ASCII SHA256 checksum for parent, or Nothing for none

-> Maybe Text

subject: Subject

-> Maybe Text

body: Body

-> Maybe GVariant

metadata: GVariant of type a{sv}, or Nothing for none

-> b

root: The tree to point the commit to

-> Maybe c

cancellable: Cancellable

-> m Text

(Can throw GError)

Write a commit metadata object, referencing rootContentsChecksum and rootMetadataChecksum.

writeCommitDetachedMetadata

data RepoWriteCommitDetachedMetadataMethodInfo

Instances

((~) * signature (Text -> Maybe GVariant -> Maybe b -> m ()), MonadIO m, IsRepo a, IsCancellable b) => MethodInfo * RepoWriteCommitDetachedMetadataMethodInfo a signature

Methods

overloadedMethod :: MethodProxy RepoWriteCommitDetachedMetadataMethodInfo a -> signature -> s

repoWriteCommitDetachedMetadata

Arguments

:: (HasCallStack, MonadIO m, IsRepo a, IsCancellable b)

=> a

self: Repo

-> Text

checksum: ASCII SHA256 commit checksum

-> Maybe GVariant

metadata: Metadata to associate with commit in with format "a{sv}", or Nothing to delete

-> Maybe b

cancellable: Cancellable

-> m ()

(Can throw GError)

Replace any existing metadata associated with commit referred to by checksum with metadata. If metadata is Nothing, then existing data will be deleted.

writeCommitWithTime

data RepoWriteCommitWithTimeMethodInfo

Instances

((~) * signature (Maybe Text -> Maybe Text -> Maybe Text -> Maybe GVariant -> b -> Word64 -> Maybe c -> m Text), MonadIO m, IsRepo a, IsRepoFile b, IsCancellable c) => MethodInfo * RepoWriteCommitWithTimeMethodInfo a signature

Methods

overloadedMethod :: MethodProxy RepoWriteCommitWithTimeMethodInfo a -> signature -> s

repoWriteCommitWithTime

Arguments

:: (HasCallStack, MonadIO m, IsRepo a, IsRepoFile b, IsCancellable c)

=> a

self: Repo

-> Maybe Text

parent: ASCII SHA256 checksum for parent, or Nothing for none

-> Maybe Text

subject: Subject

-> Maybe Text

body: Body

-> Maybe GVariant

metadata: GVariant of type a{sv}, or Nothing for none

-> b

root: The tree to point the commit to

-> Word64

time: The time to use to stamp the commit

-> Maybe c

cancellable: Cancellable

-> m Text

(Can throw GError)

Write a commit metadata object, referencing rootContentsChecksum and rootMetadataChecksum.

writeConfig

data RepoWriteConfigMethodInfo

Instances

((~) * signature (KeyFile -> m ()), MonadIO m, IsRepo a) => MethodInfo * RepoWriteConfigMethodInfo a signature

Methods

overloadedMethod :: MethodProxy RepoWriteConfigMethodInfo a -> signature -> s

repoWriteConfig

Arguments

:: (HasCallStack, MonadIO m, IsRepo a)

=> a

self: Repo

-> KeyFile

newConfig: Overwrite the config file with this data. Do not change later!

-> m ()

(Can throw GError)

Save newConfig in place of this repository's config file. Note that newConfig should not be modified after - this function simply adds a reference.

writeContent

data RepoWriteContentMethodInfo

Instances

((~) * signature (Maybe Text -> b -> Word64 -> Maybe c -> m ByteString), MonadIO m, IsRepo a, IsInputStream b, IsCancellable c) => MethodInfo * RepoWriteContentMethodInfo a signature

Methods

overloadedMethod :: MethodProxy RepoWriteContentMethodInfo a -> signature -> s

repoWriteContent

Arguments

:: (HasCallStack, MonadIO m, IsRepo a, IsInputStream b, IsCancellable c)

=> a

self: Repo

-> Maybe Text

expectedChecksum: If provided, validate content against this checksum

-> b

objectInput: Content object stream

-> Word64

length: Length of objectInput

-> Maybe c

cancellable: Cancellable

-> m ByteString

(Can throw GError)

Store the content object streamed as objectInput, with total length length. The actual checksum will be returned as outCsum.

writeContentAsync

data RepoWriteContentAsyncMethodInfo

Instances

((~) * signature (Maybe Text -> b -> Word64 -> Maybe c -> Maybe AsyncReadyCallback -> m ()), MonadIO m, IsRepo a, IsInputStream b, IsCancellable c) => MethodInfo * RepoWriteContentAsyncMethodInfo a signature

Methods

overloadedMethod :: MethodProxy RepoWriteContentAsyncMethodInfo a -> signature -> s

repoWriteContentAsync

Arguments

:: (HasCallStack, MonadIO m, IsRepo a, IsInputStream b, IsCancellable c)

=> a

self: Repo

-> Maybe Text

expectedChecksum: If provided, validate content against this checksum

-> b

object: Input

-> Word64

length: Length of object

-> Maybe c

cancellable: Cancellable

-> Maybe AsyncReadyCallback

callback: Invoked when content is writed

-> m ()

Asynchronously store the content object object. If provided, the checksum expectedChecksum will be verified.

writeContentFinish

data RepoWriteContentFinishMethodInfo

Instances

((~) * signature (b -> m Word8), MonadIO m, IsRepo a, IsAsyncResult b) => MethodInfo * RepoWriteContentFinishMethodInfo a signature

Methods

overloadedMethod :: MethodProxy RepoWriteContentFinishMethodInfo a -> signature -> s

repoWriteContentFinish

Arguments

:: (HasCallStack, MonadIO m, IsRepo a, IsAsyncResult b)

=> a

self: a Repo

-> b

result: a AsyncResult

-> m Word8

(Can throw GError)

Completes an invocation of repoWriteContentAsync.

writeContentTrusted

data RepoWriteContentTrustedMethodInfo

Instances

((~) * signature (Text -> b -> Word64 -> Maybe c -> m ()), MonadIO m, IsRepo a, IsInputStream b, IsCancellable c) => MethodInfo * RepoWriteContentTrustedMethodInfo a signature

Methods

overloadedMethod :: MethodProxy RepoWriteContentTrustedMethodInfo a -> signature -> s

repoWriteContentTrusted

Arguments

:: (HasCallStack, MonadIO m, IsRepo a, IsInputStream b, IsCancellable c)

=> a

self: Repo

-> Text

checksum: Store content using this ASCII SHA256 checksum

-> b

objectInput: Content stream

-> Word64

length: Length of objectInput

-> Maybe c

cancellable: Cancellable

-> m ()

(Can throw GError)

Store the content object streamed as objectInput, with total length length. The given checksum will be treated as trusted.

This function should be used when importing file objects from local disk, for example.

writeDfdToMtree

data RepoWriteDfdToMtreeMethodInfo

Instances

((~) * signature (Int32 -> Text -> b -> Maybe RepoCommitModifier -> Maybe c -> m ()), MonadIO m, IsRepo a, IsMutableTree b, IsCancellable c) => MethodInfo * RepoWriteDfdToMtreeMethodInfo a signature

Methods

overloadedMethod :: MethodProxy RepoWriteDfdToMtreeMethodInfo a -> signature -> s

repoWriteDfdToMtree

Arguments

:: (HasCallStack, MonadIO m, IsRepo a, IsMutableTree b, IsCancellable c)

=> a

self: Repo

-> Int32

dfd: Directory file descriptor

-> Text

path: Path

-> b

mtree: Overlay directory contents into this tree

-> Maybe RepoCommitModifier

modifier: Optional modifier

-> Maybe c

cancellable: Cancellable

-> m ()

(Can throw GError)

Store as objects all contents of the directory referred to by dfd and path all children into the repository self, overlaying the resulting filesystem hierarchy into mtree.

writeDirectoryToMtree

data RepoWriteDirectoryToMtreeMethodInfo

Instances

((~) * signature (b -> c -> Maybe RepoCommitModifier -> Maybe d -> m ()), MonadIO m, IsRepo a, IsFile b, IsMutableTree c, IsCancellable d) => MethodInfo * RepoWriteDirectoryToMtreeMethodInfo a signature

Methods

overloadedMethod :: MethodProxy RepoWriteDirectoryToMtreeMethodInfo a -> signature -> s

repoWriteDirectoryToMtree

Arguments

:: (HasCallStack, MonadIO m, IsRepo a, IsFile b, IsMutableTree c, IsCancellable d)

=> a

self: Repo

-> b

dir: Path to a directory

-> c

mtree: Overlay directory contents into this tree

-> Maybe RepoCommitModifier

modifier: Optional modifier

-> Maybe d

cancellable: Cancellable

-> m ()

(Can throw GError)

Store objects for dir and all children into the repository self, overlaying the resulting filesystem hierarchy into mtree.

writeMetadata

data RepoWriteMetadataMethodInfo

Instances

((~) * signature (ObjectType -> Maybe Text -> GVariant -> Maybe b -> m ByteString), MonadIO m, IsRepo a, IsCancellable b) => MethodInfo * RepoWriteMetadataMethodInfo a signature

Methods

overloadedMethod :: MethodProxy RepoWriteMetadataMethodInfo a -> signature -> s

repoWriteMetadata

Arguments

:: (HasCallStack, MonadIO m, IsRepo a, IsCancellable b)

=> a

self: Repo

-> ObjectType

objtype: Object type

-> Maybe Text

expectedChecksum: If provided, validate content against this checksum

-> GVariant

object: Metadata

-> Maybe b

cancellable: Cancellable

-> m ByteString

(Can throw GError)

Store the metadata object variant. Return the checksum as outCsum.

If expectedChecksum is not Nothing, verify it against the computed checksum.

writeMetadataAsync

data RepoWriteMetadataAsyncMethodInfo

Instances

((~) * signature (ObjectType -> Maybe Text -> GVariant -> Maybe b -> Maybe AsyncReadyCallback -> m ()), MonadIO m, IsRepo a, IsCancellable b) => MethodInfo * RepoWriteMetadataAsyncMethodInfo a signature

Methods

overloadedMethod :: MethodProxy RepoWriteMetadataAsyncMethodInfo a -> signature -> s

repoWriteMetadataAsync

Arguments

:: (HasCallStack, MonadIO m, IsRepo a, IsCancellable b)

=> a

self: Repo

-> ObjectType

objtype: Object type

-> Maybe Text

expectedChecksum: If provided, validate content against this checksum

-> GVariant

object: Metadata

-> Maybe b

cancellable: Cancellable

-> Maybe AsyncReadyCallback

callback: Invoked when metadata is writed

-> m ()

Asynchronously store the metadata object variant. If provided, the checksum expectedChecksum will be verified.

writeMetadataFinish

data RepoWriteMetadataFinishMethodInfo

Instances

((~) * signature (b -> Word8 -> m ()), MonadIO m, IsRepo a, IsAsyncResult b) => MethodInfo * RepoWriteMetadataFinishMethodInfo a signature

Methods

overloadedMethod :: MethodProxy RepoWriteMetadataFinishMethodInfo a -> signature -> s

repoWriteMetadataFinish

Arguments

:: (HasCallStack, MonadIO m, IsRepo a, IsAsyncResult b)

=> a

-> b

-> Word8

-> m ()

(Can throw GError)

No description available in the introspection data.

writeMetadataStreamTrusted

data RepoWriteMetadataStreamTrustedMethodInfo

Instances

((~) * signature (ObjectType -> Text -> b -> Word64 -> Maybe c -> m ()), MonadIO m, IsRepo a, IsInputStream b, IsCancellable c) => MethodInfo * RepoWriteMetadataStreamTrustedMethodInfo a signature

Methods

overloadedMethod :: MethodProxy RepoWriteMetadataStreamTrustedMethodInfo a -> signature -> s

repoWriteMetadataStreamTrusted

Arguments

:: (HasCallStack, MonadIO m, IsRepo a, IsInputStream b, IsCancellable c)

=> a

self: Repo

-> ObjectType

objtype: Object type

-> Text

checksum: Store object with this ASCII SHA256 checksum

-> b

objectInput: Metadata object stream

-> Word64

length: Length, may be 0 for unknown

-> Maybe c

cancellable: Cancellable

-> m ()

(Can throw GError)

Store the metadata object variant; the provided checksum is trusted.

writeMetadataTrusted

data RepoWriteMetadataTrustedMethodInfo

Instances

((~) * signature (ObjectType -> Text -> GVariant -> Maybe b -> m ()), MonadIO m, IsRepo a, IsCancellable b) => MethodInfo * RepoWriteMetadataTrustedMethodInfo a signature

Methods

overloadedMethod :: MethodProxy RepoWriteMetadataTrustedMethodInfo a -> signature -> s

repoWriteMetadataTrusted

Arguments

:: (HasCallStack, MonadIO m, IsRepo a, IsCancellable b)

=> a

self: Repo

-> ObjectType

objtype: Object type

-> Text

checksum: Store object with this ASCII SHA256 checksum

-> GVariant

variant: Metadata object

-> Maybe b

cancellable: Cancellable

-> m ()

(Can throw GError)

Store the metadata object variant; the provided checksum is trusted.

writeMtree

data RepoWriteMtreeMethodInfo

Instances

((~) * signature (b -> Maybe c -> m File), MonadIO m, IsRepo a, IsMutableTree b, IsCancellable c) => MethodInfo * RepoWriteMtreeMethodInfo a signature

Methods

overloadedMethod :: MethodProxy RepoWriteMtreeMethodInfo a -> signature -> s

repoWriteMtree

Arguments

:: (HasCallStack, MonadIO m, IsRepo a, IsMutableTree b, IsCancellable c)

=> a

self: Repo

-> b

mtree: Mutable tree

-> Maybe c

cancellable: Cancellable

-> m File

(Can throw GError)

Write all metadata objects for mtree to repo; the resulting outFile points to the ObjectTypeDirTree object that the mtree represented.

Properties

path

data RepoPathPropertyInfo

Instances

AttrInfo RepoPathPropertyInfo

Associated Types

type AttrAllowedOps RepoPathPropertyInfo :: [AttrOpTag]

type AttrSetTypeConstraint RepoPathPropertyInfo :: * -> Constraint

type AttrBaseTypeConstraint RepoPathPropertyInfo :: * -> Constraint

type AttrGetType RepoPathPropertyInfo :: *

type AttrLabel RepoPathPropertyInfo :: Symbol

type AttrOrigin RepoPathPropertyInfo :: *

Methods

attrGet :: AttrBaseTypeConstraint RepoPathPropertyInfo o => Proxy * RepoPathPropertyInfo -> o -> IO (AttrGetType RepoPathPropertyInfo)

attrSet :: (AttrBaseTypeConstraint RepoPathPropertyInfo o, AttrSetTypeConstraint RepoPathPropertyInfo b) => Proxy * RepoPathPropertyInfo -> o -> b -> IO ()

attrClear :: AttrBaseTypeConstraint RepoPathPropertyInfo o => Proxy * RepoPathPropertyInfo -> o -> IO ()

attrConstruct :: (AttrBaseTypeConstraint RepoPathPropertyInfo o, AttrSetTypeConstraint RepoPathPropertyInfo b) => Proxy * RepoPathPropertyInfo -> b -> IO (GValueConstruct o)

type AttrOrigin RepoPathPropertyInfo

type AttrOrigin RepoPathPropertyInfo = Repo

type AttrLabel RepoPathPropertyInfo

type AttrLabel RepoPathPropertyInfo = "path"

type AttrGetType RepoPathPropertyInfo

type AttrGetType RepoPathPropertyInfo = File

type AttrBaseTypeConstraint RepoPathPropertyInfo

type AttrBaseTypeConstraint RepoPathPropertyInfo = IsRepo

type AttrSetTypeConstraint RepoPathPropertyInfo

type AttrSetTypeConstraint RepoPathPropertyInfo = IsFile

type AttrAllowedOps RepoPathPropertyInfo

type AttrAllowedOps RepoPathPropertyInfo = (:) AttrOpTag AttrConstruct ((:) AttrOpTag AttrGet ((:) AttrOpTag AttrClear ([] AttrOpTag)))

constructRepoPath :: (IsRepo o, IsFile a) => a -> IO (GValueConstruct o)

getRepoPath :: (MonadIO m, IsRepo o) => o -> m File

repoPath :: AttrLabelProxy "path"

remotesConfigDir

data RepoRemotesConfigDirPropertyInfo

Instances

AttrInfo RepoRemotesConfigDirPropertyInfo

Associated Types

type AttrAllowedOps RepoRemotesConfigDirPropertyInfo :: [AttrOpTag]

type AttrSetTypeConstraint RepoRemotesConfigDirPropertyInfo :: * -> Constraint

type AttrBaseTypeConstraint RepoRemotesConfigDirPropertyInfo :: * -> Constraint

type AttrGetType RepoRemotesConfigDirPropertyInfo :: *

type AttrLabel RepoRemotesConfigDirPropertyInfo :: Symbol

type AttrOrigin RepoRemotesConfigDirPropertyInfo :: *

Methods

attrGet :: AttrBaseTypeConstraint RepoRemotesConfigDirPropertyInfo o => Proxy * RepoRemotesConfigDirPropertyInfo -> o -> IO (AttrGetType RepoRemotesConfigDirPropertyInfo)

attrSet :: (AttrBaseTypeConstraint RepoRemotesConfigDirPropertyInfo o, AttrSetTypeConstraint RepoRemotesConfigDirPropertyInfo b) => Proxy * RepoRemotesConfigDirPropertyInfo -> o -> b -> IO ()

attrClear :: AttrBaseTypeConstraint RepoRemotesConfigDirPropertyInfo o => Proxy * RepoRemotesConfigDirPropertyInfo -> o -> IO ()

attrConstruct :: (AttrBaseTypeConstraint RepoRemotesConfigDirPropertyInfo o, AttrSetTypeConstraint RepoRemotesConfigDirPropertyInfo b) => Proxy * RepoRemotesConfigDirPropertyInfo -> b -> IO (GValueConstruct o)

type AttrOrigin RepoRemotesConfigDirPropertyInfo

type AttrOrigin RepoRemotesConfigDirPropertyInfo = Repo

type AttrLabel RepoRemotesConfigDirPropertyInfo

type AttrLabel RepoRemotesConfigDirPropertyInfo = "remotes-config-dir"

type AttrGetType RepoRemotesConfigDirPropertyInfo

type AttrGetType RepoRemotesConfigDirPropertyInfo = Maybe Text

type AttrBaseTypeConstraint RepoRemotesConfigDirPropertyInfo

type AttrBaseTypeConstraint RepoRemotesConfigDirPropertyInfo = IsRepo

type AttrSetTypeConstraint RepoRemotesConfigDirPropertyInfo

type AttrSetTypeConstraint RepoRemotesConfigDirPropertyInfo = * ~ Text

type AttrAllowedOps RepoRemotesConfigDirPropertyInfo

type AttrAllowedOps RepoRemotesConfigDirPropertyInfo = (:) AttrOpTag AttrConstruct ((:) AttrOpTag AttrGet ((:) AttrOpTag AttrClear ([] AttrOpTag)))

constructRepoRemotesConfigDir :: IsRepo o => Text -> IO (GValueConstruct o)

getRepoRemotesConfigDir :: (MonadIO m, IsRepo o) => o -> m (Maybe Text)

repoRemotesConfigDir :: AttrLabelProxy "remotesConfigDir"

sysrootPath

data RepoSysrootPathPropertyInfo

Instances

AttrInfo RepoSysrootPathPropertyInfo

Associated Types

type AttrAllowedOps RepoSysrootPathPropertyInfo :: [AttrOpTag]

type AttrSetTypeConstraint RepoSysrootPathPropertyInfo :: * -> Constraint

type AttrBaseTypeConstraint RepoSysrootPathPropertyInfo :: * -> Constraint

type AttrGetType RepoSysrootPathPropertyInfo :: *

type AttrLabel RepoSysrootPathPropertyInfo :: Symbol

type AttrOrigin RepoSysrootPathPropertyInfo :: *

Methods

attrGet :: AttrBaseTypeConstraint RepoSysrootPathPropertyInfo o => Proxy * RepoSysrootPathPropertyInfo -> o -> IO (AttrGetType RepoSysrootPathPropertyInfo)

attrSet :: (AttrBaseTypeConstraint RepoSysrootPathPropertyInfo o, AttrSetTypeConstraint RepoSysrootPathPropertyInfo b) => Proxy * RepoSysrootPathPropertyInfo -> o -> b -> IO ()

attrClear :: AttrBaseTypeConstraint RepoSysrootPathPropertyInfo o => Proxy * RepoSysrootPathPropertyInfo -> o -> IO ()

attrConstruct :: (AttrBaseTypeConstraint RepoSysrootPathPropertyInfo o, AttrSetTypeConstraint RepoSysrootPathPropertyInfo b) => Proxy * RepoSysrootPathPropertyInfo -> b -> IO (GValueConstruct o)

type AttrOrigin RepoSysrootPathPropertyInfo

type AttrOrigin RepoSysrootPathPropertyInfo = Repo

type AttrLabel RepoSysrootPathPropertyInfo

type AttrLabel RepoSysrootPathPropertyInfo = "sysroot-path"

type AttrGetType RepoSysrootPathPropertyInfo

type AttrGetType RepoSysrootPathPropertyInfo = Maybe File

type AttrBaseTypeConstraint RepoSysrootPathPropertyInfo

type AttrBaseTypeConstraint RepoSysrootPathPropertyInfo = IsRepo

type AttrSetTypeConstraint RepoSysrootPathPropertyInfo

type AttrSetTypeConstraint RepoSysrootPathPropertyInfo = IsFile

type AttrAllowedOps RepoSysrootPathPropertyInfo

type AttrAllowedOps RepoSysrootPathPropertyInfo = (:) AttrOpTag AttrConstruct ((:) AttrOpTag AttrGet ((:) AttrOpTag AttrClear ([] AttrOpTag)))

constructRepoSysrootPath :: (IsRepo o, IsFile a) => a -> IO (GValueConstruct o)

getRepoSysrootPath :: (MonadIO m, IsRepo o) => o -> m (Maybe File)

repoSysrootPath :: AttrLabelProxy "sysrootPath"

Signals

gpgVerifyResult

type C_RepoGpgVerifyResultCallback = Ptr () -> CString -> Ptr GpgVerifyResult -> Ptr () -> IO ()

type RepoGpgVerifyResultCallback = Text -> GpgVerifyResult -> IO ()

data RepoGpgVerifyResultSignalInfo

Instances

SignalInfo RepoGpgVerifyResultSignalInfo

Associated Types

type HaskellCallbackType RepoGpgVerifyResultSignalInfo :: *

Methods

connectSignal :: GObject o => SignalProxy o RepoGpgVerifyResultSignalInfo -> o -> HaskellCallbackType RepoGpgVerifyResultSignalInfo -> SignalConnectMode -> IO SignalHandlerId

type HaskellCallbackType RepoGpgVerifyResultSignalInfo

type HaskellCallbackType RepoGpgVerifyResultSignalInfo = RepoGpgVerifyResultCallback

afterRepoGpgVerifyResult :: (IsRepo a, MonadIO m) => a -> RepoGpgVerifyResultCallback -> m SignalHandlerId

genClosure_RepoGpgVerifyResult :: RepoGpgVerifyResultCallback -> IO Closure

mk_RepoGpgVerifyResultCallback :: C_RepoGpgVerifyResultCallback -> IO (FunPtr C_RepoGpgVerifyResultCallback)

noRepoGpgVerifyResultCallback :: Maybe RepoGpgVerifyResultCallback

onRepoGpgVerifyResult :: (IsRepo a, MonadIO m) => a -> RepoGpgVerifyResultCallback -> m SignalHandlerId

wrap_RepoGpgVerifyResultCallback :: RepoGpgVerifyResultCallback -> Ptr () -> CString -> Ptr GpgVerifyResult -> Ptr () -> IO ()