package dune-private-libs

  1. Overview
  2. Docs
package dune-private-libs
Legend:
Library
Module
Module type
Parameter
Class
Class type
type t
val set_build_dir : t -> Stdune.Path.t -> (t, string) Stdune.Result.t

Set the absolute path to the build directory for interpreting relative paths when promoting files.

val with_repositories : t -> Cache__.Cache_intf.repository list -> (t, string) Stdune.Result.t

Set all the version controlled repositories in the workspace to be referred to when promoting files.

val promote : t -> (Stdune.Path.Build.t * Stdune.Digest.t) list -> Key.t -> Stdune.Sexp.t list -> repository:int option -> duplication:Cache__.Cache_intf.Duplication_mode.t option -> (unit, string) Stdune.Result.t

Promote files produced by a build rule into the cache.

Find a build rule in the cache by its key.

val retrieve : t -> Cache__.Cache_intf.File.t -> Stdune.Path.t

Materialise a cached file in the build directory (using Copy or Hardlink as per the duplication mode) and return the path to it.

val deduplicate : t -> Cache__.Cache_intf.File.t -> unit

Deduplicate a file, i.e. replace the file in_the_build_directory with a hardlink to the one in_the_cache if the deduplication mode is set to Hardlink (or do nothing if the mode is Copy).

val teardown : t -> unit

Remove the local cache and disconnect with a distributed cache client if any.

val hint : t -> Key.t list -> (unit, string) Stdune.Result.t
val default_root : unit -> Stdune.Path.t

The default root directory of the local cache.

module Metadata_file : sig ... end

A matadata file contains a list of files produced by a cached build rule, along with some metadata that can be empty.

val promote_sync : t -> (Stdune.Path.Build.t * Stdune.Digest.t) list -> Key.t -> Stdune.Sexp.t list -> repository:int option -> duplication:Cache__.Cache_intf.Duplication_mode.t option -> (Metadata_file.t * Cache__.Cache_intf.promotion list, string) Stdune.Result.t

Like promote but also returns the resulting metadata and promotions.

val make : ?root:Stdune.Path.t -> ?duplication_mode:Cache__.Cache_intf.Duplication_mode.t -> ?log:(Stdune.User_message.Style.t Stdune.Pp.t list -> unit) -> ?warn:(Stdune.User_message.Style.t Stdune.Pp.t list -> unit) -> command_handler:(Cache__.Cache_intf.command -> unit) -> unit -> (t, string) Stdune.Result.t

Create a local cache. The only required argument is a handler for commands from the cache, such as Dedup that tell Dune that some files can be replaced with hardlinks to their cached versions. The root argument defaults to the default_root. If duplication_mode is omitted, we attempt to detect whether hardlinks are supported and use Hardlink if they are, falling back to Copy otherwise.

val duplication_mode : t -> Cache__.Cache_intf.Duplication_mode.t

The deduplication mode that was set or detected automatically (if omitted) during the local cache creation with the function make.

val overhead_size : t -> int64

The overhead size of the cache, that is, the total size of files in the cache that are not linked from any build directory.

module Trimming_result : sig ... end
val detect_unexpected_dirs_under_cache_root : t -> (Stdune.Path.t list, Unix.error) Stdune.result

Return a list of unexpected paths that exist in the root directory of the cache. A non-empty result suggests that the cache directory contains multiple versions of the cache, making trim and garbage_collect less effective.

val trim : t -> goal:int64 -> Trimming_result.t

Trim the cache by removing a set of unused files from it so that the total freed space is greater or equal to the specificed goal, in bytes. We call a cached file "unused" if there are currently no hard links to it from build directories.

Unused files are removed in the order of last access, i.e. we first remove the least recently accessed one.

We also remove all metadata files whose file references got broken during the trimming.

val garbage_collect : t -> Trimming_result.t

Purge cache metadata files that can't be read or contain references to non-existing files.

val metadata_path : t -> Key.t -> Stdune.Path.t

Path to a metadata file

val file_path : t -> Key.t -> Stdune.Path.t

Path to a data file

val tmp_path : t -> string -> Stdune.Path.t

Path to a safe, instance specific temporary directory