syntax = "proto3";

package gitaly;

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

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

service PraefectInfoService {
  option (intercepted) = true;

  rpc RepositoryReplicas(RepositoryReplicasRequest) returns (RepositoryReplicasResponse);
  // ConsistencyCheck will perform a consistency check on the requested
  // virtual storage backend. A stream of repository statuses will be sent
  // back indicating which repos are consistent with the primary and which ones
  // need repair.
  rpc ConsistencyCheck(ConsistencyCheckRequest) returns (stream ConsistencyCheckResponse);

  // DatalossCheck checks for outdated repository replicas.
  rpc DatalossCheck(DatalossCheckRequest) returns (DatalossCheckResponse);

  // SetAuthoritativeStorage sets the authoritative storage for a repository on a given virtual storage.
  // This causes the current version of the repository on the authoritative storage to be considered the
  // latest and overwrite any other version on the virtual storage.
  rpc SetAuthoritativeStorage(SetAuthoritativeStorageRequest) returns (SetAuthoritativeStorageResponse);

  // SetReplicationFactor assigns or unassigns host nodes from the repository to meet the desired replication factor.
  // SetReplicationFactor returns an error when trying to set a replication factor that exceeds the storage node count
  // in the virtual storage. An error is also returned when trying to set a replication factor below one. The primary node
  // won't be unassigned as it needs a copy of the repository to accept writes. Likewise, the primary is the first storage
  // that gets assigned when setting a replication factor for a repository. Assignments of unconfigured storages are ignored.
  // This might cause the actual replication factor to be higher than desired if the replication factor is set during an upgrade
  // from a Praefect node that does not yet know about a new node. As assignments of unconfigured storages are ignored, replication
  // factor of repositories assigned to a storage node removed from the cluster is effectively decreased.
  rpc SetReplicationFactor(SetReplicationFactorRequest) returns (SetReplicationFactorResponse);
}

// SetReplicationFactorRequest sets the desired replication factor for a repository.
message SetReplicationFactorRequest {
  // virtual_storage is the virtual storage the repository is located in
  string virtual_storage = 1;
  // relative_path is the relative path of the repository
  string relative_path = 2;
  // replication_factor is the desired replication factor. Replication must be equal or greater than 1.
  int32 replication_factor = 3;
}

// SetReplicationFactorResponse returns the assigned hosts after setting the desired replication factor.
message SetReplicationFactorResponse {
  // storages are the storages assigned to host the repository.
  repeated string storages = 1;
}

message SetAuthoritativeStorageRequest {
  string virtual_storage = 1;
  string relative_path = 2;
  string authoritative_storage = 3;
}

message SetAuthoritativeStorageResponse {}

message DatalossCheckRequest {
  string virtual_storage = 1;
  // include_partially_replicated decides whether to include repositories which are fully up to date
  // on the primary but are outdated on some secondaries. Such repositories are still writable and do
  // not suffer from data loss. The data on the primary is not fully replicated which increases the
  // chances of data loss following a failover.
  bool include_partially_replicated = 2;
}

message DatalossCheckResponse {
  message Repository {
    message Storage {
      // name of the storage
      string name = 1;
      // behind_by indicates how many generations this storage is behind.
      int64 behind_by = 2;
      // assigned indicates whether the storage is assigned to host the repository.
      bool assigned = 3;
    }

    // relative path of the repository with outdated replicas
    string relative_path = 1;
    // storages on which the repository is outdated
    repeated Storage storages = 2;
    // read_only indicates whether the repository is in read-only mode.
    bool read_only = 3;

    // current primary storage of the repository
    string primary = 4;
  }

  // repositories with data loss
  repeated Repository repositories = 2;
}

message RepositoryReplicasRequest{
  Repository repository = 1;
}

message RepositoryReplicasResponse{
  message RepositoryDetails {
    Repository repository = 1;
    string checksum = 2;
  };

  RepositoryDetails primary = 1;
  repeated RepositoryDetails replicas = 2;
}

message ConsistencyCheckRequest {
  string virtual_storage = 1;
  // The target storage is the storage you wish to check for inconsistencies
  // against a reference storage (typically the current primary).
  string target_storage = 2;
  // Optionally provide a reference storage to compare the target storage
  // against. If a reference storage is omitted, the current primary will be
  // used.
  string reference_storage = 3;
  // Be default, reconcilliation is enabled. Disabling reconcilliation will
  // make the request side-effect free.
  bool disable_reconcilliation = 4;
}

message ConsistencyCheckResponse {
  string repo_relative_path = 1;
  string target_checksum = 2;
  string reference_checksum = 3;
  // If resync was enabled, then each inconsistency will schedule a replication
  // job. A replication ID is returned to track the corresponding job.
  uint64 repl_job_id = 4;
  // If the reference storage was not specified, reply with the reference used
  string reference_storage = 5;
  // The list of errors that appeared during the operation execution for the current repository.
  repeated string errors = 6;
}
