syntax = "proto3";

package gitaly;

import "lint.proto";
import "shared.proto";

option go_package = "gitlab.com/gitlab-org/gitaly/v16/proto/go/gitalypb";

// RepositoryService is a service providing RPCs accessing repositories as a whole.
service RepositoryService {

  // This comment is left unintentionally blank.
  rpc RepositoryExists(RepositoryExistsRequest) returns (RepositoryExistsResponse) {
    option (op_type) = {
      op: ACCESSOR
    };
  }

  // RepositorySize returns information on the complete on-disk repository size. If you need more
  // detailed information about the size of various sub-structures you should instead use the
  // RepositoryInfo RPC.
  rpc RepositorySize(RepositorySizeRequest) returns (RepositorySizeResponse) {
    option (op_type) = {
      op: ACCESSOR
    };
  }

  // RepositoryInfo returns detailed information about a repository and its data structures.
  rpc RepositoryInfo(RepositoryInfoRequest) returns (RepositoryInfoResponse) {
    option (op_type) = {
      op: ACCESSOR
    };
  }

  // ObjectsSize calculates the total on-disk object size of reachable objects in bytes. In contrast
  // to RepositorySize and RepositoryInfo, this RPC performs a graph walk of the specified revisions
  // and will thus return an accurate view of how large the accumulated on-disk size of reachable
  // objects is.
  //
  // As this RPC needs to perform a revision walk, it is significantly more expensive than the RPCs
  // which simply check the size of on-disk data structures. On the other hand, it allows the caller
  // to accurately compute the size of objects in a way that is at least somewhat detached from the
  // on-disk representation:
  //
  // - Objects which exist in multiple packfiles will not be double-counted.
  // - Objects which aren't reachable will not be accounted for.
  // - It is possible to only account for a subset of references, e.g. only those that an admin
  //   would have direct control over.
  //
  // It is thus recommended to use this RPC whenever you want to calculate sizes which will end up
  // being shown to the user.
  //
  // Note that the size is still bound to change when repositories are getting repacked and thus
  // cannot be considered to be stable. This is because the on-disk size of any object can change
  // depending on how Git decides to deltify it in a packfile. Thus, when a repack would cause a
  // different delta base to be picked, the actual on-disk size of any given object may change.
  rpc ObjectsSize(stream ObjectsSizeRequest) returns (ObjectsSizeResponse) {
    option (op_type) = {
      op: ACCESSOR
    };
  }

  // ObjectFormat determines the object format that is being used by the repository.
  rpc ObjectFormat(ObjectFormatRequest) returns (ObjectFormatResponse) {
    option (op_type) = {
      op: ACCESSOR
    };
  }

  // This comment is left unintentionally blank.
  rpc ApplyGitattributes(ApplyGitattributesRequest) returns (ApplyGitattributesResponse) {
    option (op_type) = {
      op: MUTATOR
    };
  }

  // FetchRemote fetches references from a remote repository into the local
  // repository.
  rpc FetchRemote(FetchRemoteRequest) returns (FetchRemoteResponse) {
    option (op_type) = {
      op: MUTATOR
    };
  }

  // This comment is left unintentionally blank.
  rpc CreateRepository(CreateRepositoryRequest) returns (CreateRepositoryResponse) {
    option (op_type) = {
      op: MUTATOR
    };
  }

  // This comment is left unintentionally blank.
  rpc GetArchive(GetArchiveRequest) returns (stream GetArchiveResponse) {
    option (op_type) = {
      op: ACCESSOR
    };
  }

  // This comment is left unintentionally blank.
  rpc HasLocalBranches(HasLocalBranchesRequest) returns (HasLocalBranchesResponse) {
    option (op_type) = {
      op: ACCESSOR
    };
  }

  // FetchSourceBranch fetches a branch from a second (potentially remote)
  // repository into the given repository.
  rpc FetchSourceBranch(FetchSourceBranchRequest) returns (FetchSourceBranchResponse) {
    option (op_type) = {
      op: MUTATOR
    };
  }

  // Fsck checks the repository for consistency via git-fsck(1). This can be used to check for
  // repository corruption.
  rpc Fsck(FsckRequest) returns (FsckResponse) {
    option (op_type) = {
      op: ACCESSOR
    };
  }

  // This comment is left unintentionally blank.
  rpc WriteRef(WriteRefRequest) returns (WriteRefResponse) {
    option (op_type) = {
      op: MUTATOR
    };
  }

  // This comment is left unintentionally blank.
  rpc FindMergeBase(FindMergeBaseRequest) returns (FindMergeBaseResponse) {
    option (op_type) = {
      op: ACCESSOR
    };
  }

  // CreateFork creates a new repository from a specific source repository. This new repository will
  // have the same branches and tags as the source repository. Internal references will not be
  // recreated in the forked repository.
  //
  // All objects of the source repository will be duplicated, that is there are no space savings by
  // creating the repository like this. The newly created repository does not join the object pool
  // of the source repository, if there is any.
  rpc CreateFork(CreateForkRequest) returns (CreateForkResponse) {
    option (op_type) = {
      op: MUTATOR
    };
  }

  // This comment is left unintentionally blank.
  rpc CreateRepositoryFromURL(CreateRepositoryFromURLRequest) returns (CreateRepositoryFromURLResponse) {
    option (op_type) = {
      op: MUTATOR
    };
  }

  // CreateBundle creates a bundle from all refs
  rpc CreateBundle(CreateBundleRequest) returns (stream CreateBundleResponse) {
    option (op_type) = {
      op: ACCESSOR
    };
  }

  // CreateBundleFromRefList creates a bundle from a stream of ref patterns.
  // When the bundle would be empty the FailedPrecondition error code is returned.
  rpc CreateBundleFromRefList(stream CreateBundleFromRefListRequest) returns (stream CreateBundleFromRefListResponse) {
    option (op_type) = {
      op: ACCESSOR
    };
  }

  // FetchBundle fetches references from a bundle into the local repository.
  // Refs will be mirrored to the target repository with the refspec
  // "+refs/*:refs/*" and refs that do not exist in the bundle will be removed.
  rpc FetchBundle(stream FetchBundleRequest) returns (FetchBundleResponse) {
    option (op_type) = {
      op: MUTATOR
    };
  }

  // CreateRepositoryFromBundle creates a Git repository at the specified storage and path, if it
  // does not already exist, from the provided Git bundle.
  rpc CreateRepositoryFromBundle(stream CreateRepositoryFromBundleRequest) returns (CreateRepositoryFromBundleResponse) {
    option (op_type) = {
      op: MUTATOR
    };
  }

  // GetConfig reads the target repository's gitconfig and streams its contents
  // back. Returns a NotFound error in case no gitconfig was found.
  rpc GetConfig(GetConfigRequest) returns (stream GetConfigResponse) {
    option (op_type) = {
      op: ACCESSOR
    };
  }

  // FindLicense looks in the given repository and attempts to detect all the
  // details about the license used in the repository.
  rpc FindLicense(FindLicenseRequest) returns (FindLicenseResponse) {
    option (op_type) = {
      op: ACCESSOR
    };
  }

  // This comment is left unintentionally blank.
  rpc GetInfoAttributes(GetInfoAttributesRequest) returns (stream GetInfoAttributesResponse) {
    option (op_type) = {
      op: ACCESSOR
    };
  }

  // This comment is left unintentionally blank.
  rpc CalculateChecksum(CalculateChecksumRequest) returns (CalculateChecksumResponse) {
    option (op_type) = {
      op: ACCESSOR
    };
  }

  // This comment is left unintentionally blank.
  rpc GetSnapshot(GetSnapshotRequest) returns (stream GetSnapshotResponse) {
    option (op_type) = {
      op: ACCESSOR
    };
  }

  // This comment is left unintentionally blank.
  rpc CreateRepositoryFromSnapshot(CreateRepositoryFromSnapshotRequest) returns (CreateRepositoryFromSnapshotResponse) {
    option (op_type) = {
      op: MUTATOR
    };
  }

  // This comment is left unintentionally blank.
  rpc GetRawChanges(GetRawChangesRequest) returns (stream GetRawChangesResponse) {
    option (op_type) = {
      op: ACCESSOR
    };
  }

  // This comment is left unintentionally blank.
  rpc SearchFilesByContent(SearchFilesByContentRequest) returns (stream SearchFilesByContentResponse) {
    option (op_type) = {
      op: ACCESSOR
    };
  }

  // This comment is left unintentionally blank.
  rpc SearchFilesByName(SearchFilesByNameRequest) returns (stream SearchFilesByNameResponse) {
    option (op_type) = {
      op: ACCESSOR
    };
  }

  // RestoreCustomHooks sets the git hooks for a repository. The hooks are sent
  // in a tar archive containing a `custom_hooks` directory. This directory is
  // ultimately extracted to the repository.
  rpc RestoreCustomHooks(stream RestoreCustomHooksRequest) returns (RestoreCustomHooksResponse) {
    option (op_type) = {
      op: MUTATOR
    };
    option deprecated = true;
  }

  // SetCustomHooks sets the git hooks for a repository. The hooks are sent in a
  // tar archive containing a `custom_hooks` directory. This directory is
  // ultimately extracted to the repository.
  rpc SetCustomHooks(stream SetCustomHooksRequest) returns (SetCustomHooksResponse) {
    option (op_type) = {
      op: MUTATOR
    };
  }

  // BackupCustomHooks fetches the git hooks for a repository. The hooks are
  // sent in a tar archive containing a `custom_hooks` directory. If no hooks
  // are present in the repository, the response will have no data.
  rpc BackupCustomHooks(BackupCustomHooksRequest) returns (stream BackupCustomHooksResponse) {
    option (op_type) = {
      op: ACCESSOR
    };
    option deprecated = true;
  }

  // GetCustomHooks fetches the git hooks for a repository. The hooks are sent
  // in a tar archive containing a `custom_hooks` directory. If no hooks are
  // present in the repository, the response will have no data.
  rpc GetCustomHooks(GetCustomHooksRequest) returns (stream GetCustomHooksResponse) {
    option (op_type) = {
      op: ACCESSOR
    };
  }

  // This comment is left unintentionally blank.
  rpc GetObjectDirectorySize(GetObjectDirectorySizeRequest) returns (GetObjectDirectorySizeResponse) {
    option (op_type) = {
      op: ACCESSOR
    };
  }

  // RemoveRepository will move the repository to `+gitaly/tmp/<relative_path>_removed` and
  // eventually remove it. This ensures that even on networked filesystems the
  // data is actually removed even if there's someone still handling the data.
  rpc RemoveRepository(RemoveRepositoryRequest) returns (RemoveRepositoryResponse) {
    option (op_type) = {
      op: MUTATOR
    };
  }

  // This comment is left unintentionally blank.
  rpc RenameRepository(RenameRepositoryRequest) returns (RenameRepositoryResponse) {
    option (op_type) = {
      op: MUTATOR
    };
  }

  // ReplicateRepository replicates data from a source repository to target repository. On the
  // target repository, this operation ensures synchronization of the following components:
  //
  // - Git config
  // - Git attributes
  // - Custom Git hooks,
  // - References and objects
  // - (Optional) Object deduplication network membership
  rpc ReplicateRepository(ReplicateRepositoryRequest) returns (ReplicateRepositoryResponse) {
    option (op_type)  = {
      op: MUTATOR
    };
  }

  // OptimizeRepository performs all maintenance tasks in a repository to keep
  // it in an efficient state. It cleans up stale data, repacks objects,
  // updates auxiliary caches like commit-graphs and packs references. The
  // optimizations performed are based on heuristics and will adapt to the
  // repository's size. This RPC call is designed as a black-box such that
  // Gitaly has complete control of the on-disk state of repositories.
  rpc OptimizeRepository(OptimizeRepositoryRequest) returns (OptimizeRepositoryResponse) {
    option (op_type)  = {
      op: MAINTENANCE
    };
  }

  // PruneUnreachableObjects will prune all objects which aren't reachable from
  // the repository's current set of references. Because pruning can only
  // happen for objects which aren't packed, you are required to first run
  // OptimizeRepository to explode any unreachable objects into loose objects.
  //
  // Furthermore, this RPC call has a grace period of 30 minutes: any
  // unreachable loose objects must not have been accessed or modified in the
  // last 30 minutes. This is a hard requirement to avoid repository corruption.
  //
  // To make proper use of this RPC you thus need to call OptimizeRepository,
  // wait 30 minutes, and then call PruneUnreachableObjects.
  rpc PruneUnreachableObjects(PruneUnreachableObjectsRequest) returns (PruneUnreachableObjectsResponse) {
    option (op_type)  = {
      op: MAINTENANCE
    };
  }

  // SetFullPath writes the "gitlab.fullpath" configuration into the
  // repository's gitconfig. This is mainly to help debugging purposes in case
  // an admin inspects the repository's gitconfig such that he can easily see
  // what the repository name is.
  rpc SetFullPath(SetFullPathRequest) returns (SetFullPathResponse) {
    option deprecated = true;
    option (op_type)  = {
      op: MUTATOR
    };
  }

  // FullPath reads the "gitlab.fullpath" configuration from the repository's
  // gitconfig. Returns an error in case the full path has not been configured.
  rpc FullPath(FullPathRequest) returns (FullPathResponse) {
    option deprecated = true;
    option (op_type) = {
      op: ACCESSOR
    };
  }

  // RemoveAll deletes all repositories on a specified storage.
  rpc RemoveAll(RemoveAllRequest) returns (RemoveAllResponse) {
    option (op_type) = {
      op: MUTATOR
      scope_level: STORAGE
    };
  }

  // BackupRepository creates a full backup streamed directly to
  // object-storage. The backup is created synchronously. The destination must
  // be configured in config.backup.go_cloud_url
  rpc BackupRepository(BackupRepositoryRequest) returns (BackupRepositoryResponse) {
    option (op_type) = {
      op: ACCESSOR
    };
  }

  // RestoreRepository restores a backup streamed directly from object-storage.
  // The repository is restored synchronously. The source object-storage must
  // be configured in config.backup.go_cloud_url
  rpc RestoreRepository(RestoreRepositoryRequest) returns (RestoreRepositoryResponse) {
    option (op_type) = {
      op: MUTATOR
    };
  }
}

// This comment is left unintentionally blank.
message RepositoryExistsRequest {
  // This comment is left unintentionally blank.
  Repository repository = 1 [(target_repository)=true];
}

// This comment is left unintentionally blank.
message RepositoryExistsResponse {
  // This comment is left unintentionally blank.
  bool exists = 1;
}

// RepositorySizeRequest is a request for the RepositorySize RPC.
message RepositorySizeRequest {
  // Repository is the repository for which to determine the repository size.
  Repository repository = 1 [(target_repository)=true];
}

// RepositorySizeResponse is a response for the RepositorySize RPC.
message RepositorySizeResponse {
  // Size is the complete size of the on-disk repository in kilobytes. This will include all data
  // structures and is similar to `du --summarize --bytes $REPO_PATH`.
  int64 size = 1;
}

// RepositoryInfoRequest is a request for the RepositoryInfo RPC.
message RepositoryInfoRequest {
  // Repository is the repository to query for information.
  Repository repository = 1 [(target_repository)=true];
}

// RepositoryInfoResponse is a response for the RepositoryInfo RPC.
message RepositoryInfoResponse {
  // ReferencesInfo hosts information about references.
  message ReferencesInfo {
    // LooseCount is the number of loose references that exist in the repository. These references
    // are written whenever any reference either gets updated or created. Loose references have not
    // yet been compressed into a packed format, which is an action that Gitaly performs regularly
    // during repository maintenance.
    //
    // We do not provide the total size of loose references as it is a constant factor of the count
    // anyway: `$count * $object_hash_length`.
    uint64 loose_count = 1;
    // PackedSize is the size of packed references in bytes. Packed references are a more efficient
    // way to store loose references. Given that determining the exact amount of references stored
    // in packed format would require us to process the complete contents we don't provide the size
    // here. A very rough estimate would be: `$size / 100`.
    uint64 packed_size = 2;
  }

  // ObjectsInfo hosts info about objects contained in a repository. It tries to bridge the gap
  // between the actual on-disk state that is changing over time as Git introduces new ways to
  // perform repository housekeeping and specific classifications of objects.
  //
  // One of the distinctions is between "recent" and "stale" objects. The set of recent objects
  // contains these objects that have either been recently written/accessed or those which are
  // reachable via any of the references. Stale objects on the other hand are those that are older
  // than a certain grace period and which are not reachable via any reference. The exact details
  // when the set of stale and recent objects is updated is an internal implementation detail of
  // Gitaly and subject to change. It is safe to assume though that unreachable objects will
  // eventually be marked stale when repository housekeeping runs on a repository.
  message ObjectsInfo {
    // Size is the total size of all objects in the repository in bytes. It makes no distinction
    // between the way they are stored or whether they are pending deletion.
    uint64 size = 1;
    // RecentSize is the total size of all objects in bytes that are considered to be recent. Recent
    // objects are likely reachable and will not be considered for deletion.
    uint64 recent_size = 2;
    // StaleSize is the total size of all objects in bytes that are considered to be stale. Stale
    // objects are likely unreachable and will eventually be deleted after a grace period. Objects
    // which are part of cruft packs are always considered to be stale.
    uint64 stale_size = 3;
    // KeepSize is the total size of all kept packfiles. Kept packfiles are packfiles that have a
    // `.keep` file accompanying them. Packfiles marked with such a file will never be deleted by
    // Git and will thus stay around forever, even if their objects are part of
    // other packfiles already.
    uint64 keep_size = 4;
  }

  // Size is the total size of all files part of the repository. It does not include the size of
  // directories.
  uint64 size = 1;
  // References contains information about references.
  ReferencesInfo references = 2;
  // ObjectsInfo contains information about objects.
  ObjectsInfo objects = 3;
}

// ObjectsSizeRequest is a request for the ObjectsSize RPC. The RPC is defined as a streaming RPC given that a client
// may theoretically specify an unbounded number of revisions. Only the first request may have fields other than the
// revisions set.
message ObjectsSizeRequest {
  // Repository is the repository for which to determine the object size.
  Repository repository = 1 [(target_repository)=true];
  // Revisions is the set of revisions that shall be used to compute the object size for. Supports normal revisions as
  // well as pseudo-revisions like `--not`, `--all`, `--branches[=pattern]`, `--tags[=pattern]` and `--glob=pattern`.
  // Please refer to the man pages gitrevisions(7) as well as git-rev-list(1) for more information.
  //
  // Note: due to a restriction in Git v2.41 and older all arguments need to be passed via command line parameters. So
  // even though you can send multiple requests, the actual number of revisions that can be passed is limited by the
  // maximum command line length. This limitation will be lifted once Gitaly has upgraded to Git v2.42 and later.
  repeated bytes revisions = 2;
}

// ObjectsSizeResponse is a response for the ObjectsSize RPC.
message ObjectsSizeResponse {
  // Size is the total size of all objects reachable via the given set of revisions. The size is
  // specified in bytes.
  uint64 size = 1;
}

// ObjectFormatRequest is a request for the ObjectFormat RPC.
message ObjectFormatRequest {
  // Repository is the repository for which to determine the object format.
  Repository repository = 1 [(target_repository)=true];
}

// ObjectFormatResponse is a response for the ObjectFormat RPC.
message ObjectFormatResponse {
  // Format is the object format that the repository uses.
  ObjectFormat format = 1;
}

// This comment is left unintentionally blank.
message ApplyGitattributesRequest {
  // This comment is left unintentionally blank.
  Repository repository = 1 [(target_repository)=true];
  // This comment is left unintentionally blank.
  bytes revision = 2;
}

// This comment is left unintentionally blank.
message ApplyGitattributesResponse {
}

// This comment is left unintentionally blank.
message FetchBundleRequest {
  // Repository into which the reference shall be fetched.
  Repository repository = 1 [(target_repository)=true];

  // Data is the bundle file stream.
  bytes data = 2;

  // UpdateHead will update HEAD if there is a HEAD reference listed in the bundle
  bool update_head = 3;
}

// This comment is left unintentionally blank.
message FetchBundleResponse {
}

// This comment is left unintentionally blank.
message FetchRemoteRequest {
  // This comment is left unintentionally blank.
  Repository repository = 1 [(target_repository)=true];
  // force determines if references should be force-updated in case they have
  // diverged.
  bool force = 3;
  // no_tags determines whether tags should be fetched.
  bool no_tags = 4;
  // timeout specifies a timeout for the fetch.
  int32 timeout = 5;
  // This comment is left unintentionally blank.
  string ssh_key = 6;
  // This comment is left unintentionally blank.
  string known_hosts = 7;
  reserved 8;
  // no_prune will the fetch to not prune remote references which do not exist
  // in the remote repository anymore.
  bool no_prune = 9;
  // remote_params specifies the remote repository which should be fetched
  // from.
  Remote remote_params = 10;
  // If check_tags_changed is true, the FetchRemote RPC will check whether any
  // tags were modified, returning the result in the tags_changed field of
  // FetchRemoteResponse
  bool check_tags_changed = 11;

  reserved 2;
  reserved "remote";
}

// This comment is left unintentionally blank.
message FetchRemoteResponse {
  // If check_tags_changed was set in the FetchRemoteRequest, the FetchRemote
  // RPC will return false when no tags were changed, and true if tags were
  // changed or answer cannot be determined.
  bool tags_changed = 1;
}

// This comment is left unintentionally blank.
message CreateRepositoryRequest {
  // This comment is left unintentionally blank.
  Repository repository = 1 [(target_repository)=true];
  // Provide a branch name to set as the default branch of a newly created
  // repository. Note, this will be treated as the branch name and not a
  // fully qualified reference.
  bytes default_branch = 2;
  // ObjectFormat is the object format the repository should be created with. Note that this is
  // experimental and should not be used by callers yet. It is mostly intended for internal testing
  // purposes in Gitaly right now.
  ObjectFormat object_format = 3;
}

// This comment is left unintentionally blank.
message CreateRepositoryResponse {
}

// This comment is left unintentionally blank.
message GetArchiveRequest {
  // This comment is left unintentionally blank.
  enum Format {
    // This comment is left unintentionally blank.
    ZIP = 0; // protolint:disable:this ENUM_FIELD_NAMES_PREFIX ENUM_FIELD_NAMES_ZERO_VALUE_END_WITH
    // This comment is left unintentionally blank.
    TAR = 1; // protolint:disable:this ENUM_FIELD_NAMES_PREFIX
    // This comment is left unintentionally blank.
    TAR_GZ = 2; // protolint:disable:this ENUM_FIELD_NAMES_PREFIX
    // This comment is left unintentionally blank.
    TAR_BZ2 = 3; // protolint:disable:this ENUM_FIELD_NAMES_PREFIX
  }

  // This comment is left unintentionally blank.
  Repository repository = 1 [(target_repository)=true];
  // This comment is left unintentionally blank.
  string commit_id = 2;
  // This comment is left unintentionally blank.
  string prefix = 3;
  // This comment is left unintentionally blank.
  Format format = 4;
  // This comment is left unintentionally blank.
  bytes path = 5;
  // This comment is left unintentionally blank.
  repeated bytes exclude = 6; // protolint:disable:this REPEATED_FIELD_NAMES_PLURALIZED
  // If `elide_path` is true and `path` refers to a subdirectory, that
  // subdirectory will be elided from archive entries. For example, if `dir`
  // contains `README.md`, with `elide_path = false` the corresponding entry
  // will be `dir/README.md`; with `elide_path = true`, the entry will be
  // `README.md`. `elide_path` has no effect if `path` refers to the repository
  // root. `elide_path = true` is not supported if `path` refers to a file.
  bool elide_path = 7;
  // This comment is left unintentionally blank.
  bool include_lfs_blobs = 8;
}

// This comment is left unintentionally blank.
message GetArchiveResponse {
  // This comment is left unintentionally blank.
  bytes data = 1;
}

// This comment is left unintentionally blank.
message HasLocalBranchesRequest {
  // This comment is left unintentionally blank.
  Repository repository = 1 [(target_repository)=true];
}

// This comment is left unintentionally blank.
message HasLocalBranchesResponse {
  // This comment is left unintentionally blank.
  bool value = 1;
}

// This comment is left unintentionally blank.
message FetchSourceBranchRequest {
  // Repository into which the reference shall be fetched. After a successful
  // call, it should contain the target reference which points to the same
  // commit as the source repository's source branch.
  Repository repository = 1 [(target_repository)=true];
  // Repository from which to fetch the source branch from.
  Repository source_repository = 2;
  // Name of the branch in the source repository which should be fetched.
  bytes source_branch = 3;
  // Name of the reference which shall be newly created in the target
  // repository.
  bytes target_ref = 4;
}

// This comment is left unintentionally blank.
message FetchSourceBranchResponse {
  // True if the source branch was successfully fetched into the target
  // repository, false if resolving the remote reference or fetching it failed.
  bool result = 1;
}

// FsckRequest is a request for the Fsck RPC.
message FsckRequest {
  // Repository is the repository that shall be checked for consistency.
  Repository repository = 1 [(target_repository)=true];
}

// FsckResponse is a response for the Fsck RPC.
message FsckResponse {
  // Error contains both stdout and stderr of git-fsck(1) in case it returned an error.
  bytes error = 1;
}

// This comment is left unintentionally blank.
message WriteRefRequest {
  // This comment is left unintentionally blank.
  Repository repository = 1 [(target_repository)=true];
  // This comment is left unintentionally blank.
  bytes ref = 2;
  // This comment is left unintentionally blank.
  bytes revision = 3;
  // This comment is left unintentionally blank.
  bytes old_revision = 4;
  // This comment is left unintentionally blank.
  bool force = 5;
  // This used to be a boolean indicating whether or not to shell out or use
  // the rugged implementation
  reserved 6;
}

// This comment is left unintentionally blank.
message WriteRefResponse {
  // This used to contain an error message. Since we're shelling out
  // all exceptions are wrapped in GRPC errors.
  reserved 1;
}

// This comment is left unintentionally blank.
message FindMergeBaseRequest {
  // This comment is left unintentionally blank.
  Repository repository = 1 [(target_repository)=true];
  // We use a repeated field because rugged supports finding a base
  // for more than 2 revisions, so if we needed that in the future we don't
  // need to change the protocol.
  repeated bytes revisions = 2;
}

// This comment is left unintentionally blank.
message FindMergeBaseResponse {
  // This comment is left unintentionally blank.
  string base = 1;
}

// CreateForkRequest is a request for the CreateFork RPC.
message CreateForkRequest {
  // Repository is the repository that shall be created.
  Repository repository = 1 [(target_repository)=true];
  // SourceRepository is the repository that shall be forked.
  //
  // Note that the source repository is intentionally not marked as an additional repository that is
  // to be rewritten by Praefect. This is because Gitaly will use the source repository to perform a
  // gRPC call, which must use the original non-rewritten repository.
  Repository source_repository = 2;
  // Revision to create the fork from. If set, the resulting fork will only have a single branch
  // that matches the upstream revision. This revision will be the default branch of the repository.
  // This field should be set to the unqualified revision, not the full reference name.
  bytes revision = 3;
}

// CreateForkResponse is a response for the CreateFork RPC.
message CreateForkResponse {
}

// This comment is left unintentionally blank.
message CreateRepositoryFromURLRequest {
  // This comment is left unintentionally blank.
  Repository repository = 1 [(target_repository)=true];
  // This comment is left unintentionally blank.
  string url = 2;
  // http_authorization_header is the HTTP header which can be added to
  // the request in order to authenticate against the repository.
  string http_authorization_header = 4;
  // Mirror defines whether to clone with `--mirror` flag or `--bare`. The default
  // value `false` will cause us to use `--bare`, which results in a clone that
  // contains only branches (`refs/heads/`) and tags (`refs/tags/`) of the remote
  // repository. If set to `true`, create a complete mirror-clone which maps all
  // remote references into the local repository.
  bool mirror = 5;
  // ResolvedAddress holds the resolved IP address of the remote_url. This is
  // used to avoid DNS rebinding by mapping the url to the resolved address.
  // Only IPv4 dotted decimal ("192.0.2.1"), IPv6 ("2001:db8::68"), or IPv4-mapped
  // IPv6 ("::ffff:192.0.2.1") forms are supported.
  // Works with HTTP/HTTPS/Git/SSH protocols.
  // Optional.
  string resolved_address = 6;

  // HttpHost has been removed in favor of ResolvedAddress.
  reserved 3;
  reserved "http_host";
}

// This comment is left unintentionally blank.
message CreateRepositoryFromURLResponse {
}

// This comment is left unintentionally blank.
message CreateBundleRequest {
  // This comment is left unintentionally blank.
  Repository repository = 1 [(target_repository)=true];
}

// This comment is left unintentionally blank.
message CreateBundleResponse {
  // This comment is left unintentionally blank.
  bytes data = 1;
}

// This comment is left unintentionally blank.
message CreateBundleFromRefListRequest {
  // Repository is the repository that the bundle is created from.
  Repository repository = 1 [(target_repository)=true];

  // Patterns contains all patterns which shall be bundled. Patterns should be
  // in the format accepted by git-rev-list(1). Patterns which don't match any
  // reference will be silently ignored.
  repeated bytes patterns = 2;
}

// This comment is left unintentionally blank.
message CreateBundleFromRefListResponse {
  // This comment is left unintentionally blank.
  bytes data = 1;
}

// GetConfigRequest is a request for the GetConfig RPC.
message GetConfigRequest {
  // Repository is the repository from which the configuration should be read
  // from.
  Repository repository = 1 [(target_repository)=true];
}

// GetConfigResponse is a response for the GetConfig RPC.
message GetConfigResponse {
  // Data contains contents of the gitconfig.
  bytes data = 1;
}

// This comment is left unintentionally blank.
message  RestoreCustomHooksRequest {
  // This comment is left unintentionally blank.
  Repository repository = 1 [(target_repository)=true];
  // This comment is left unintentionally blank.
  bytes data = 2;
}

// This comment is left unintentionally blank.
message  SetCustomHooksRequest {
  // This comment is left unintentionally blank.
  Repository repository = 1 [(target_repository)=true];
  // This comment is left unintentionally blank.
  bytes data = 2;
}

// This comment is left unintentionally blank.
message RestoreCustomHooksResponse {
}

// This comment is left unintentionally blank.
message SetCustomHooksResponse {
}

// This comment is left unintentionally blank.
message BackupCustomHooksRequest {
  // This comment is left unintentionally blank.
  Repository repository = 1 [(target_repository)=true];
}

// This comment is left unintentionally blank.
message GetCustomHooksRequest {
  // This comment is left unintentionally blank.
  Repository repository = 1 [(target_repository)=true];
}

// This comment is left unintentionally blank.
message BackupCustomHooksResponse {
  // This comment is left unintentionally blank.
  bytes data = 1;
}

// This comment is left unintentionally blank.
message GetCustomHooksResponse {
  // This comment is left unintentionally blank.
  bytes data = 1;
}

// CreateRepositoryFromBundleRequest is a request for the CreateRepositoryFromBundle RPC.
message CreateRepositoryFromBundleRequest {
  // Repository is the repository to be created from the Git bundle. Repository should only be
  // present in the first message of the stream.
  Repository repository = 1 [(target_repository)=true];
  // Data contains bytes of the Git bundle file being streamed.
  bytes data = 2;
}

// CreateRepositoryFromBundleResponse is a response for the CreateRepositoryFromBundle RPC.
message CreateRepositoryFromBundleResponse {
}

// FindLicenseRequest asks to detect the license for the given repository.
message FindLicenseRequest {
  // Repository is repository where to detect the license.
  Repository repository = 1 [(target_repository)=true];
}

// FindLicenseResponse contains the result of detecting the license used in the repository.
// If there is nothing that looks like a license file, the empty response is returned.
// If there is something that looks like a license, but that license can't be found in the
// list of known licenses, we return a pre-defined response with "Other" license.
message FindLicenseResponse {
  // LicenseShortName is the license unique SPDX identifier or a short name.
  // It is always returned lower-cased.
  string license_short_name = 1;
  // LicenseName is the license full name.
  string license_name = 2;
  // LicenseUrl is a URL to the license on the internet.
  string license_url = 3;
  // LicensePath is a path to the file that contains the text of the license.
  // When a LICENSE file is found containing the filename of another file,
  // that filename will be returned, for example "mit.txt".
  string license_path = 4;
  // LicenseNickname is a shortened full name for better readability.
  // It exists only for a small set of licenses and an empty value is returned in most cases.
  string license_nickname = 5;
}

// This comment is left unintentionally blank.
message GetInfoAttributesRequest {
  // This comment is left unintentionally blank.
  Repository repository = 1 [(target_repository)=true];
}

// This comment is left unintentionally blank.
message GetInfoAttributesResponse {
  // This comment is left unintentionally blank.
  bytes attributes = 1;
}

// This comment is left unintentionally blank.
message CalculateChecksumRequest {
  // This comment is left unintentionally blank.
  Repository repository = 1 [(target_repository)=true];
}

// This comment is left unintentionally blank.
message CalculateChecksumResponse {
  // This comment is left unintentionally blank.
  string checksum = 1;
}

// This comment is left unintentionally blank.
message GetSnapshotRequest {
  // This comment is left unintentionally blank.
  Repository repository = 1 [(target_repository)=true];
}

// This comment is left unintentionally blank.
message GetSnapshotResponse {
  // This comment is left unintentionally blank.
  bytes data = 1;
}

// This comment is left unintentionally blank.
message CreateRepositoryFromSnapshotRequest {
  // This comment is left unintentionally blank.
  Repository repository = 1 [(target_repository)=true];
  // This comment is left unintentionally blank.
  string http_url = 2;
  // This comment is left unintentionally blank.
  string http_auth = 3;
  // ResolvedAddress holds the resolved IP address of the remote_url. This is
  // used to avoid DNS rebinding by mapping the url to the resolved address.
  // Only IPv4 dotted decimal ("192.0.2.1"), IPv6 ("2001:db8::68"), or IPv4-mapped
  // IPv6 ("::ffff:192.0.2.1") forms are supported.
  // Works with HTTP/HTTPS protocols.
  // Optional.
  string resolved_address = 5;

  // HttpHost has been removed in favor of ResolvedAddress.
  reserved 4;
  reserved "http_host";
}

// This comment is left unintentionally blank.
message CreateRepositoryFromSnapshotResponse {
}

// This comment is left unintentionally blank.
message GetRawChangesRequest {
  // This comment is left unintentionally blank.
  Repository repository = 1 [(target_repository)=true];
  // This comment is left unintentionally blank.
  string from_revision = 2;
  // This comment is left unintentionally blank.
  string to_revision = 3;
}

// This comment is left unintentionally blank.
message GetRawChangesResponse {
  // This comment is left unintentionally blank.
  message RawChange {
    // This comment is left unintentionally blank.
    enum Operation {
      // This comment is left unintentionally blank.
      UNKNOWN = 0; // protolint:disable:this ENUM_FIELD_NAMES_PREFIX ENUM_FIELD_NAMES_ZERO_VALUE_END_WITH
      // This comment is left unintentionally blank.
      ADDED = 1; // protolint:disable:this ENUM_FIELD_NAMES_PREFIX
      // This comment is left unintentionally blank.
      COPIED = 2; // protolint:disable:this ENUM_FIELD_NAMES_PREFIX
      // This comment is left unintentionally blank.
      DELETED = 3; // protolint:disable:this ENUM_FIELD_NAMES_PREFIX
      // This comment is left unintentionally blank.
      MODIFIED = 4; // protolint:disable:this ENUM_FIELD_NAMES_PREFIX
      // This comment is left unintentionally blank.
      RENAMED = 5; // protolint:disable:this ENUM_FIELD_NAMES_PREFIX
      // This comment is left unintentionally blank.
      TYPE_CHANGED = 6; // protolint:disable:this ENUM_FIELD_NAMES_PREFIX
    }

    // This comment is left unintentionally blank.
    string blob_id = 1;
    // This comment is left unintentionally blank.
    int64 size= 2;

    // This used to be a string that is now represented by the field 9 as byte array.
    reserved 3;
    reserved "new_path";
    // This used to be a string that is now represented by the field 10 as byte array.
    reserved 4;
    reserved "old_path";

    // This comment is left unintentionally blank.
    Operation operation= 5;
    // This comment is left unintentionally blank.
    string raw_operation = 6;
    // This comment is left unintentionally blank.
    int32 old_mode = 7;
    // This comment is left unintentionally blank.
    int32 new_mode = 8;

    // the following fields, 9 and 10, will eventually replace 3 and 4
    bytes new_path_bytes = 9;
    // This comment is left unintentionally blank.
    bytes old_path_bytes = 10;
  }

  // This comment is left unintentionally blank.
  repeated RawChange raw_changes = 1;
}

// This comment is left unintentionally blank.
message SearchFilesByNameRequest {
  // This comment is left unintentionally blank.
  Repository repository = 1 [(target_repository)=true];
  // This comment is left unintentionally blank.
  string query = 2;
  // This comment is left unintentionally blank.
  bytes ref = 3;
  // If `filter` is specified and non-empty, it will be parsed as a regular
  // expression and used to filter the result set before it is transmitted. It is
  // parsed using Go's `regexp` package, which is closely related to PCRE,
  // excluding backreferences, atomic/possesive operators, and some other
  // features. It has a maximum length of 1000 bytes.
  string filter = 4;
  // Limit the number of returned files. Gitaly does not enforce a limit by default.
  // Clients should always set a value for this field. limit = 0 means unlimited files.
  uint32 limit = 5;
  // `offset` says to skip that many files before beginning to return files.
  // offset = 0 means starting to return files from beginning.
  uint32 offset = 6;
}

// This comment is left unintentionally blank.
message SearchFilesByNameResponse {
  // Files contains the paths of files that have been found to match the query.
  repeated bytes files = 1;
}

// This comment is left unintentionally blank.
message SearchFilesByContentRequest {
  // This comment is left unintentionally blank.
  Repository repository = 1 [(target_repository)=true];
  // This comment is left unintentionally blank.
  string query = 2;
  // This comment is left unintentionally blank.
  bytes ref = 3;
  // This comment is left unintentionally blank.
  bool chunked_response = 4;
}

// This comment is left unintentionally blank.
message SearchFilesByContentResponse {
  // This comment is left unintentionally blank.
  repeated bytes matches = 1;
  // This comment is left unintentionally blank.
  bytes match_data = 2;
  // This comment is left unintentionally blank.
  bool end_of_match = 3;
}

// Remote represents a git remote repository.
message Remote {
  // url is the URL of the remote repository.
  string url = 1;
  // http_authorization_header is the HTTP header which should be added to
  // the request in order to authenticate against the repository.
  string http_authorization_header = 3;
  // mirror_refmaps contains the refspecs which shall be fetched. Some special
  // refspecs are accepted:
  //
  // - "all_refs" gets translated to "+refs/*:refs/*", which mirrors all
  //   references of the source repository.
  // - "heads" gets translated to "+refs/heads/*:refs/heads/*", which mirrors
  //   all branches of the source repository.
  // - "tags" gets translated to "+refs/tags/*:refs/tags/*", which mirrors all
  //   tags of the source repository.
  //
  // If no refspecs are given, this defaults to "all_refs".
  repeated string mirror_refmaps = 4;
  // ResolvedAddress holds the resolved IP address of the remote_url. This is
  // used to avoid DNS rebinding by mapping the url to the resolved address.
  // Only IPv4 dotted decimal ("192.0.2.1"), IPv6 ("2001:db8::68"), or IPv4-mapped
  // IPv6 ("::ffff:192.0.2.1") forms are supported.
  // Works with HTTP/HTTPS/Git/SSH protocols.
  // Optional.
  string resolved_address = 6;

  // Previously, it was possible to specify a remote name. This was quite a
  // dangerous field to set though: the name was simply used to create an ad-hoc
  // remote which got deleted afterwards again. So unexpectedly, the remote
  // isn't retained. And second, if the user chose the name of an existing
  // remote, then it would've been deleted after the call. So in effect, the
  // field was at best confusing and useless and at worst actively harmful.
  reserved 2;
  reserved "name";
  // HttpHost has been removed in favor of ResolvedAddress.
  reserved 5;
  reserved "http_host";
}

// This comment is left unintentionally blank.
message GetObjectDirectorySizeRequest {
  // This comment is left unintentionally blank.
  Repository repository = 1 [(target_repository)=true];
}

// This comment is left unintentionally blank.
message GetObjectDirectorySizeResponse {
  // Object directory size in kilobytes
  int64 size = 1;
}

// This comment is left unintentionally blank.
message RemoveRepositoryRequest {
  // This comment is left unintentionally blank.
  Repository repository = 1 [(target_repository)=true];
}

// This comment is left unintentionally blank.
message RemoveRepositoryResponse {
}

// This comment is left unintentionally blank.
message RenameRepositoryRequest {
  // This comment is left unintentionally blank.
  Repository repository = 1 [(target_repository)=true];
  // This comment is left unintentionally blank.
  string relative_path = 2;
}

// This comment is left unintentionally blank.
message RenameRepositoryResponse{
}

// ReplicateRepositoryRequest is a request for the ReplicateRepository RPC.
message ReplicateRepositoryRequest {
  // Repository is the target repository that the RPC replicates to.
  Repository repository = 1 [(target_repository)=true];
  // Source is the source repository that the RPC replicates from. This repository can sit on a
  // different storage node. The information for how to connect to this storage node needs to be
  // injected into the gRPC context by the caller by setting the `gitaly-servers` metadata.
  Repository source = 2;
  // ReplicateObjectDeduplicationNetworkMembership enables replication of the source repository's
  // object pool to the target repository's storage and recreates the Git `alternates` link. If the
  // source repository is not linked to an object pool, no linking or additional replication is
  // performed. In the event the target repository is linked to an object pool, but the source
  // repository is not part of an object deduplication network, the target repository is
  // disconnected from its object pool.
  bool replicate_object_deduplication_network_membership = 3;
}

// ReplicateRepositoryResponse is a response for the ReplicateRepository RPC.
message ReplicateRepositoryResponse{
}

// OptimizeRepositoryRequest is a request for the OptimizeRepository RPC.
message OptimizeRepositoryRequest {
  // Strategy determines how the repository shall be optimized.
  enum Strategy {
    // STRATEGY_UNSPECIFIED indicates that the strategy has not been explicitly set by the
    // caller. The default will be STRATEGY_HEURISTICAL in that case.
    STRATEGY_UNSPECIFIED = 0;
    // STRATEGY_HEURISTICAL performs heuristical optimizations in the repository. The server will
    // decide on a set of heuristics which parts need optimization and which ones don't to avoid
    // performing unnecessary optimization tasks.
    STRATEGY_HEURISTICAL = 1;
    // STRATEGY_EAGER performs eager optimizations in the repository. The server will optimize all
    // data structures regardless of whether they are well-optimized already.
    STRATEGY_EAGER = 2;
  }

  // Repository is the repository that should be optimized.
  Repository repository = 1 [(target_repository)=true];
  // Strategy is the strategy that determines which parts of the repository shall be optimized.
  Strategy strategy = 2;
}

// OptimizeRepositoryResponse is a response for the OptimizeRepository RPC.
message OptimizeRepositoryResponse {
}

// PruneUnreachableObjectsRequest is a request for the PruneUnreachableObjects
// RPC call.
message PruneUnreachableObjectsRequest {
  // This comment is left unintentionally blank.
  Repository repository = 1 [(target_repository)=true];
}

// PruneUnreachableObjectsResponse is a response for the
// PruneUnreachableObjects RPC call.
message PruneUnreachableObjectsResponse {
}

// SetFullPathRequest is a request for the SetFullPath RPC.
message SetFullPathRequest {
  // Repository is the repository whose gitconfig should be written to.
  Repository repository = 1 [(target_repository)=true];
  // Path is the path that shall be written into the "gitlab.fullpath" config key.
  string path = 2;
}

// SetFullPathResponse is a response fqor the SetFullPath RPC.
message SetFullPathResponse {
}

// FullPathRequest is a request for the FullPath RPC.
message FullPathRequest {
  // Repository is the repository whose gitconfig should be read.
  Repository repository = 1 [(target_repository)=true];
}

// SetFullPathResponse is a response for the SetFullPath RPC.
message FullPathResponse {
  // Path read from the "gitlab.fullpath" config key.
  string path = 1;
}

// RemoveAll is a request for the RemoveAll RPC.
message RemoveAllRequest {
  // StorageName of the storage to have all repositories removed from.
  string storage_name = 1 [(storage)=true];;
}

// RemoveAllResponse is a response for the RemoveAll RPC.
message RemoveAllResponse {
}

// BackupRepository is a request for the BackupRepository RPC.
message BackupRepositoryRequest {
  // Repository is the repository to be backed up.
  Repository repository = 1 [(target_repository)=true];
  // VanityRepository is used to determine the backup path.
  Repository vanity_repository = 2;
  // BackupId is the label used to identify this backup when restoring.
  string backup_id = 3;
}

// BackupRepositoryResponse is a response for the BackupRepository RPC.
message BackupRepositoryResponse {
  // SkippedError is returned when the repository backup has been skipped.
  message SkippedError {
  }
}

// RestoreRepository is a request for the RestoreRepository RPC.
message RestoreRepositoryRequest {
  // Repository is the repository to be restored.
  Repository repository = 1 [(target_repository)=true];
  // VanityRepository is used to determine the backup path.
  Repository vanity_repository = 2;
  // BackupId is the label used to identify the backup to restore from. If
  // empty, the latest available backup is used.
  string backup_id = 3;
  // AlwaysCreate will force the repository to exist even if no bundle is
  // found. See https://gitlab.com/gitlab-org/gitlab/-/issues/357044
  bool always_create = 4;
}

// RestoreRepositoryResponse is a response for the RestoreRepository RPC.
message RestoreRepositoryResponse {
  // SkippedError is returned when the repository restore has been skipped.
  message SkippedError {
  }
}
