Merge branch 'ps-consistencycheck-at-most' into 'master'

Reconciliation sub-command performs as much as possible

Closes #3032

See merge request gitlab-org/gitaly!3142

7 files changed, 332 insertions, 161 deletions

diff --git a/changelogs/unreleased/ps-consistencycheck-at-most.yml b/changelogs/unreleased/ps-consistencycheck-at-most.yml
new file mode 100644
index 000000000..c2f2ff17c
--- /dev/null
+++ b/changelogs/unreleased/ps-consistencycheck-at-most.yml
@@ -0,0 +1,5 @@
+---
+title: Reconciliation sub-command performs as much as possible
+merge_request: 3142
+author:
+type: changed
diff --git a/cmd/praefect/subcmd_reconcile.go b/cmd/praefect/subcmd_reconcile.go
index d9431fe41..1f9a62435 100644
--- a/cmd/praefect/subcmd_reconcile.go
+++ b/cmd/praefect/subcmd_reconcile.go
@@ -1,6 +1,7 @@
 package main
 
 import (
+	"bytes"
 	"context"
 	"errors"
 	"flag"
@@ -163,6 +164,17 @@ func (nr nodeReconciler) consumeStream(stream gitalypb.PraefectInfoService_Consi
 			log.Print("Reference storage being used: " + rStorage)
 		}
 
+		if len(resp.Errors) > 0 {
+			var composedErrMsg bytes.Buffer
+			for _, errMsg := range resp.Errors {
+				composedErrMsg.WriteString("\t")
+				composedErrMsg.WriteString(errMsg)
+				composedErrMsg.WriteString("\n")
+			}
+			log.Printf("FAILURE: Internal error(s) occurred for the repo %s: %s", resp.GetRepoRelativePath(), composedErrMsg.String())
+			continue
+		}
+
 		if resp.GetReferenceChecksum() == resp.GetTargetChecksum() {
 			log.Print("CONSISTENT: " + resp.GetRepoRelativePath())
 			continue
diff --git a/internal/praefect/service/info/consistencycheck.go b/internal/praefect/service/info/consistencycheck.go
index 12493802c..1f1b0c399 100644
--- a/internal/praefect/service/info/consistencycheck.go
+++ b/internal/praefect/service/info/consistencycheck.go
@@ -2,8 +2,10 @@ package info
 
 import (
 	"context"
+	"errors"
 	"io"
 
+	"gitlab.com/gitlab-org/gitaly/internal/helper"
 	"gitlab.com/gitlab-org/gitaly/internal/middleware/metadatahandler"
 	"gitlab.com/gitlab-org/gitaly/internal/praefect/datastore"
 	"gitlab.com/gitlab-org/gitaly/internal/praefect/nodes"
@@ -14,6 +16,8 @@ import (
 	"google.golang.org/grpc/status"
 )
 
+var errReconciliationInternal = errors.New("internal error(s) occurred during execution")
+
 func (s *Server) validateConsistencyCheckRequest(req *gitalypb.ConsistencyCheckRequest) error {
 	if req.GetTargetStorage() == "" {
 		return status.Error(codes.InvalidArgument, "missing target storage")
@@ -134,6 +138,7 @@ type checksumResult struct {
 	reference        string
 	targetStorage    string
 	referenceStorage string
+	errs             []error
 }
 
 func checksumRepos(ctx context.Context, relpathQ <-chan string, checksumResultQ chan<- checksumResult, target, reference nodes.Node, virtualStorage string) error {
@@ -160,23 +165,34 @@ func checksumRepos(ctx context.Context, relpathQ <-chan string, checksumResultQ
 
 		g, gctx := errgroup.WithContext(ctx)
 
-		g.Go(func() (err error) {
-			cs.target, err = checksumRepo(gctx, repoRelPath, target)
-			if status.Code(err) == codes.NotFound {
+		var targetErr error
+		g.Go(func() error {
+			cs.target, targetErr = checksumRepo(gctx, repoRelPath, target)
+			if status.Code(targetErr) == codes.NotFound {
 				// missing repo on target is okay, we need to
 				// replicate from reference
+				targetErr = nil
 				return nil
 			}
-			return err
+			return targetErr
 		})
 
-		g.Go(func() (err error) {
-			cs.reference, err = checksumRepo(gctx, repoRelPath, reference)
-			return err
+		var referenceErr error
+		g.Go(func() error {
+			cs.reference, referenceErr = checksumRepo(gctx, repoRelPath, reference)
+			return referenceErr
 		})
 
 		if err := g.Wait(); err != nil {
-			return err
+			// we don't care about err as it is one of the targetErr or referenceErr
+			// and we return it back to the caller to make the opeartion execution more verbose
+			if targetErr != nil {
+				cs.errs = append(cs.errs, targetErr)
+			}
+
+			if referenceErr != nil {
+				cs.errs = append(cs.errs, referenceErr)
+			}
 		}
 
 		select {
@@ -209,11 +225,15 @@ func scheduleReplication(ctx context.Context, csr checksumResult, q datastore.Re
 }
 
 func ensureConsistency(ctx context.Context, disableReconcile bool, checksumResultQ <-chan checksumResult, q datastore.ReplicationEventQueue, stream gitalypb.PraefectInfoService_ConsistencyCheckServer) error {
+	var erroneous bool
 	for {
 		var csr checksumResult
 		select {
 		case res, ok := <-checksumResultQ:
 			if !ok {
+				if erroneous {
+					return helper.ErrInternal(errReconciliationInternal)
+				}
 				return nil
 			}
 			csr = res
@@ -227,10 +247,15 @@ func ensureConsistency(ctx context.Context, disableReconcile bool, checksumResul
 			TargetChecksum:    csr.target,
 			ReferenceStorage:  csr.referenceStorage,
 		}
+		for _, err := range csr.errs {
+			resp.Errors = append(resp.Errors, err.Error())
+			erroneous = true
+		}
 
 		if csr.reference != csr.target && !disableReconcile {
 			if err := scheduleReplication(ctx, csr, q, resp); err != nil {
-				return err
+				resp.Errors = append(resp.Errors, err.Error())
+				erroneous = true
 			}
 		}
 
diff --git a/internal/praefect/service/info/consistencycheck_test.go b/internal/praefect/service/info/consistencycheck_test.go
index 699045d68..e54ce8a0c 100644
--- a/internal/praefect/service/info/consistencycheck_test.go
+++ b/internal/praefect/service/info/consistencycheck_test.go
@@ -2,12 +2,14 @@ package info
 
 import (
 	"context"
+	"fmt"
 	"io"
 	"net"
 	"os"
 	"path/filepath"
 	"testing"
 
+	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 	"gitlab.com/gitlab-org/gitaly/client"
 	"gitlab.com/gitlab-org/gitaly/internal/git"
@@ -26,63 +28,75 @@ import (
 )
 
 func TestServer_ConsistencyCheck(t *testing.T) {
-	defer func(old gconfig.Cfg) { gconfig.Config = old }(gconfig.Config)
+	cfg := gconfig.Config
+
+	const (
+		firstRepoPath  = "1.git"
+		secondRepoPath = "2.git"
+		thirdRepoPath  = "3.git"
+
+		checksum = "06c4db1a33b2e48dac0bf940c7c20429d00a04ea"
+
+		targetStorageName    = "target"
+		referenceStorageName = "reference"
+
+		virtualStorage = "virtualStorage"
+	)
 
 	primaryStorageDir, cleanupPrim := testhelper.TempDir(t)
 	defer cleanupPrim()
 	secondaryStorageDir, cleanupSec := testhelper.TempDir(t)
 	defer cleanupSec()
 
-	// 1.git exists on both storages and it is the same
-	testhelper.NewTestRepoTo(t, primaryStorageDir, "1.git")
-	testhelper.NewTestRepoTo(t, secondaryStorageDir, "1.git")
-	// 2.git exists only on target storage (where traversal happens)
-	testhelper.NewTestRepoTo(t, secondaryStorageDir, "2.git")
-	// not.git is a folder on target storage that should be skipped as it is not a git repository
-	require.NoError(t, os.MkdirAll(filepath.Join(secondaryStorageDir, "not.git"), os.ModePerm))
+	// firstRepoPath exists on both storages and has same state
+	testhelper.NewTestRepoTo(t, primaryStorageDir, firstRepoPath)
+	testhelper.NewTestRepoTo(t, secondaryStorageDir, firstRepoPath)
 
-	gconfig.Config.Storages = []gconfig.Storage{{
-		Name: "target",
+	cfg.Storages = []gconfig.Storage{{
+		Name: referenceStorageName,
 		Path: secondaryStorageDir,
 	}, {
-		Name: "reference",
+		Name: targetStorageName,
 		Path: primaryStorageDir,
 	}}
 
-	conf := config.Config{
-		VirtualStorages: []*config.VirtualStorage{{
-			Name: "vs",
-			Nodes: []*config.Node{{
-				Storage: "reference",
-				Address: testhelper.GetTemporaryGitalySocketFileName(t),
-			}, {
-				Storage: "target",
-				Address: testhelper.GetTemporaryGitalySocketFileName(t),
-			}},
-		}},
+	conf := config.Config{VirtualStorages: []*config.VirtualStorage{{Name: virtualStorage}}}
+	for _, storage := range cfg.Storages {
+		conf.VirtualStorages[0].Nodes = append(conf.VirtualStorages[0].Nodes, &config.Node{
+			Storage: storage.Name,
+			Address: testhelper.GetTemporaryGitalySocketFileName(t),
+		})
 	}
 
-	for _, node := range conf.VirtualStorages[0].Nodes {
+	ctx, cancel := testhelper.Context()
+	defer cancel()
+
+	var toTerminate *grpc.Server
+	var addr string
+	var conns []*grpc.ClientConn
+	for i, node := range conf.VirtualStorages[0].Nodes {
 		gitalyListener, err := net.Listen("unix", node.Address)
 		require.NoError(t, err)
 
 		gitalySrv := grpc.NewServer()
 		defer gitalySrv.Stop()
-		gitalypb.RegisterRepositoryServiceServer(gitalySrv, repository.NewServer(gconfig.Config, nil, gconfig.NewLocator(gconfig.Config), transaction.NewManager(gconfig.Config), git.NewExecCommandFactory(gconfig.Config)))
-		gitalypb.RegisterInternalGitalyServer(gitalySrv, internalgitaly.NewServer(gconfig.Config.Storages))
+
+		gitalypb.RegisterRepositoryServiceServer(gitalySrv, repository.NewServer(cfg, nil, gconfig.NewLocator(cfg), transaction.NewManager(cfg), git.NewExecCommandFactory(cfg)))
+		gitalypb.RegisterInternalGitalyServer(gitalySrv, internalgitaly.NewServer(cfg.Storages))
+
 		go func() { gitalySrv.Serve(gitalyListener) }()
-	}
 
-	ctx, cancel := testhelper.Context()
-	defer cancel()
+		if i+1 == len(conf.VirtualStorages[0].Nodes) {
+			toTerminate = gitalySrv
+			addr = node.Address
+		}
 
-	referenceConn, err := client.DialContext(ctx, "unix://"+conf.VirtualStorages[0].Nodes[0].Address, nil)
-	require.NoError(t, err)
-	defer referenceConn.Close()
+		conn, err := client.DialContext(ctx, "unix://"+node.Address, nil)
+		require.NoError(t, err)
+		defer conn.Close()
 
-	targetConn, err := client.DialContext(ctx, "unix://"+conf.VirtualStorages[0].Nodes[1].Address, nil)
-	require.NoError(t, err)
-	defer targetConn.Close()
+		conns = append(conns, conn)
+	}
 
 	nm := &nodes.MockManager{
 		GetShardFunc: func(s string) (nodes.Shard, error) {
@@ -91,13 +105,13 @@ func TestServer_ConsistencyCheck(t *testing.T) {
 			}
 			return nodes.Shard{
 				Primary: &nodes.MockNode{
-					GetStorageMethod: func() string { return gconfig.Config.Storages[0].Name },
-					Conn:             referenceConn,
+					GetStorageMethod: func() string { return cfg.Storages[0].Name },
+					Conn:             conns[0],
 					Healthy:          true,
 				},
 				Secondaries: []nodes.Node{&nodes.MockNode{
-					GetStorageMethod: func() string { return gconfig.Config.Storages[1].Name },
-					Conn:             targetConn,
+					GetStorageMethod: func() string { return cfg.Storages[1].Name },
+					Conn:             conns[1],
 					Healthy:          true,
 				}},
 			}, nil
@@ -111,20 +125,75 @@ func TestServer_ConsistencyCheck(t *testing.T) {
 
 	queue := datastore.NewReplicationEventQueueInterceptor(datastore.NewMemoryReplicationEventQueue(conf))
 	queue.OnEnqueue(func(ctx context.Context, e datastore.ReplicationEvent, q datastore.ReplicationEventQueue) (datastore.ReplicationEvent, error) {
+		if e.Job.RelativePath == secondRepoPath {
+			return datastore.ReplicationEvent{}, assert.AnError
+		}
 		return datastore.ReplicationEvent{ID: 1}, nil
 	})
 
-	grpcSrv := grpc.NewServer()
-	defer grpcSrv.Stop()
+	// praefect instance setup
+	praefectSrv := grpc.NewServer()
+	defer praefectSrv.Stop()
 
-	gitalypb.RegisterPraefectInfoServiceServer(grpcSrv, NewServer(nm, conf, queue, nil, nil))
-	go grpcSrv.Serve(praefectListener)
+	gitalypb.RegisterPraefectInfoServiceServer(praefectSrv, NewServer(nm, conf, queue, nil, nil))
+	go praefectSrv.Serve(praefectListener)
 
-	infoConn, err := client.Dial("unix://"+praefectAddr, nil)
+	praefectConn, err := client.Dial("unix://"+praefectAddr, nil)
 	require.NoError(t, err)
-	defer infoConn.Close()
+	defer praefectConn.Close()
+
+	infoClient := gitalypb.NewPraefectInfoServiceClient(praefectConn)
+
+	execAndVerify := func(t *testing.T, req gitalypb.ConsistencyCheckRequest, verify func(*testing.T, []*gitalypb.ConsistencyCheckResponse, error)) {
+		response, err := infoClient.ConsistencyCheck(ctx, &req)
+		require.NoError(t, err)
+
+		var results []*gitalypb.ConsistencyCheckResponse
+		var result *gitalypb.ConsistencyCheckResponse
+		for {
+			result, err = response.Recv()
+			if err != nil {
+				break
+			}
+			results = append(results, result)
+		}
+
+		if err == io.EOF {
+			err = nil
+		}
+		verify(t, results, err)
+	}
+
+	t.Run("all in sync", func(t *testing.T) {
+		req := gitalypb.ConsistencyCheckRequest{
+			VirtualStorage:         virtualStorage,
+			TargetStorage:          targetStorageName,
+			ReferenceStorage:       referenceStorageName,
+			DisableReconcilliation: true,
+		}
 
-	infoClient := gitalypb.NewPraefectInfoServiceClient(infoConn)
+		execAndVerify(t, req, func(t *testing.T, responses []*gitalypb.ConsistencyCheckResponse, err error) {
+			require.NoError(t, err)
+			require.Equal(t, []*gitalypb.ConsistencyCheckResponse{
+				{
+					RepoRelativePath:  firstRepoPath,
+					ReferenceStorage:  referenceStorageName,
+					TargetChecksum:    checksum,
+					ReferenceChecksum: checksum,
+				},
+			}, responses)
+		})
+	})
+
+	// secondRepoPath generates an error, but it should not stop other repositories from being processed.
+	// Order does matter for the test to verify the flow.
+	testhelper.NewTestRepoTo(t, secondaryStorageDir, secondRepoPath)
+	// thirdRepoPath exists only on the reference storage (where traversal happens).
+	testhelper.NewTestRepoTo(t, secondaryStorageDir, thirdRepoPath)
+	// not.git is a folder on the reference storage that should be skipped as it is not a git repository.
+	require.NoError(t, os.MkdirAll(filepath.Join(secondaryStorageDir, "not.git"), os.ModePerm))
+
+	expErrStatus := status.Error(codes.Internal, errReconciliationInternal.Error())
 
 	for _, tc := range []struct {
 		desc   string
@@ -134,27 +203,35 @@ func TestServer_ConsistencyCheck(t *testing.T) {
 		{
 			desc: "with replication event created",
 			req: gitalypb.ConsistencyCheckRequest{
-				VirtualStorage:         "vs",
-				TargetStorage:          "reference",
-				ReferenceStorage:       "target",
+				VirtualStorage:         virtualStorage,
+				TargetStorage:          targetStorageName,
+				ReferenceStorage:       referenceStorageName,
 				DisableReconcilliation: false,
 			},
 			verify: func(t *testing.T, resp []*gitalypb.ConsistencyCheckResponse, err error) {
-				require.NoError(t, err)
+				require.Equal(t, expErrStatus, err)
 				require.Equal(t, []*gitalypb.ConsistencyCheckResponse{
 					{
-						RepoRelativePath:  "1.git",
-						TargetChecksum:    "06c4db1a33b2e48dac0bf940c7c20429d00a04ea",
-						ReferenceChecksum: "06c4db1a33b2e48dac0bf940c7c20429d00a04ea",
+						RepoRelativePath:  firstRepoPath,
+						TargetChecksum:    checksum,
+						ReferenceChecksum: checksum,
+						ReplJobId:         0,
+						ReferenceStorage:  referenceStorageName,
+					},
+					{
+						RepoRelativePath:  secondRepoPath,
+						TargetChecksum:    "",
+						ReferenceChecksum: checksum,
 						ReplJobId:         0,
-						ReferenceStorage:  "target",
+						ReferenceStorage:  referenceStorageName,
+						Errors:            []string{assert.AnError.Error()},
 					},
 					{
-						RepoRelativePath:  "2.git",
+						RepoRelativePath:  thirdRepoPath,
 						TargetChecksum:    "",
-						ReferenceChecksum: "06c4db1a33b2e48dac0bf940c7c20429d00a04ea",
+						ReferenceChecksum: checksum,
 						ReplJobId:         1,
-						ReferenceStorage:  "target",
+						ReferenceStorage:  referenceStorageName,
 					},
 				}, resp)
 			},
@@ -162,27 +239,34 @@ func TestServer_ConsistencyCheck(t *testing.T) {
 		{
 			desc: "without replication event",
 			req: gitalypb.ConsistencyCheckRequest{
-				VirtualStorage:         "vs",
-				TargetStorage:          "reference",
-				ReferenceStorage:       "target",
+				VirtualStorage:         virtualStorage,
+				TargetStorage:          targetStorageName,
+				ReferenceStorage:       referenceStorageName,
 				DisableReconcilliation: true,
 			},
 			verify: func(t *testing.T, resp []*gitalypb.ConsistencyCheckResponse, err error) {
 				require.NoError(t, err)
 				require.Equal(t, []*gitalypb.ConsistencyCheckResponse{
 					{
-						RepoRelativePath:  "1.git",
-						TargetChecksum:    "06c4db1a33b2e48dac0bf940c7c20429d00a04ea",
-						ReferenceChecksum: "06c4db1a33b2e48dac0bf940c7c20429d00a04ea",
+						RepoRelativePath:  firstRepoPath,
+						TargetChecksum:    checksum,
+						ReferenceChecksum: checksum,
+						ReplJobId:         0,
+						ReferenceStorage:  referenceStorageName,
+					},
+					{
+						RepoRelativePath:  secondRepoPath,
+						TargetChecksum:    "",
+						ReferenceChecksum: checksum,
 						ReplJobId:         0,
-						ReferenceStorage:  "target",
+						ReferenceStorage:  referenceStorageName,
 					},
 					{
-						RepoRelativePath:  "2.git",
+						RepoRelativePath:  thirdRepoPath,
 						TargetChecksum:    "",
-						ReferenceChecksum: "06c4db1a33b2e48dac0bf940c7c20429d00a04ea",
+						ReferenceChecksum: checksum,
 						ReplJobId:         0,
-						ReferenceStorage:  "target",
+						ReferenceStorage:  referenceStorageName,
 					},
 				}, resp)
 			},
@@ -190,9 +274,9 @@ func TestServer_ConsistencyCheck(t *testing.T) {
 		{
 			desc: "no target",
 			req: gitalypb.ConsistencyCheckRequest{
-				VirtualStorage:   "vs",
+				VirtualStorage:   virtualStorage,
 				TargetStorage:    "",
-				ReferenceStorage: "reference",
+				ReferenceStorage: targetStorageName,
 			},
 			verify: func(t *testing.T, resp []*gitalypb.ConsistencyCheckResponse, err error) {
 				require.Equal(t, status.Error(codes.InvalidArgument, "missing target storage"), err)
@@ -201,9 +285,9 @@ func TestServer_ConsistencyCheck(t *testing.T) {
 		{
 			desc: "unknown target",
 			req: gitalypb.ConsistencyCheckRequest{
-				VirtualStorage:   "vs",
+				VirtualStorage:   virtualStorage,
 				TargetStorage:    "unknown",
-				ReferenceStorage: "reference",
+				ReferenceStorage: targetStorageName,
 			},
 			verify: func(t *testing.T, resp []*gitalypb.ConsistencyCheckResponse, err error) {
 				require.Equal(t, status.Error(codes.NotFound, `unable to find target storage "unknown"`), err)
@@ -212,42 +296,54 @@ func TestServer_ConsistencyCheck(t *testing.T) {
 		{
 			desc: "no reference",
 			req: gitalypb.ConsistencyCheckRequest{
-				VirtualStorage:   "vs",
-				TargetStorage:    "target",
+				VirtualStorage:   virtualStorage,
+				TargetStorage:    referenceStorageName,
 				ReferenceStorage: "",
 			},
 			verify: func(t *testing.T, resp []*gitalypb.ConsistencyCheckResponse, err error) {
-				require.Equal(t, status.Error(codes.InvalidArgument, `target storage "target" is same as current primary, must provide alternate reference`), err)
+				expErr := status.Error(
+					codes.InvalidArgument,
+					fmt.Sprintf(`target storage %q is same as current primary, must provide alternate reference`, referenceStorageName),
+				)
+				require.Equal(t, expErr, err)
 			},
 		},
 		{
 			desc: "unknown reference",
 			req: gitalypb.ConsistencyCheckRequest{
-				VirtualStorage:   "vs",
-				TargetStorage:    "target",
+				VirtualStorage:   virtualStorage,
+				TargetStorage:    referenceStorageName,
 				ReferenceStorage: "unknown",
 			},
 			verify: func(t *testing.T, resp []*gitalypb.ConsistencyCheckResponse, err error) {
-				require.Equal(t, status.Error(codes.NotFound, `unable to find reference storage "unknown" in nodes for shard "vs"`), err)
+				expErr := status.Error(
+					codes.NotFound,
+					fmt.Sprintf(`unable to find reference storage "unknown" in nodes for shard %q`, virtualStorage),
+				)
+				require.Equal(t, expErr, err)
 			},
 		},
 		{
 			desc: "same storage",
 			req: gitalypb.ConsistencyCheckRequest{
-				VirtualStorage:   "vs",
-				TargetStorage:    "target",
-				ReferenceStorage: "target",
+				VirtualStorage:   virtualStorage,
+				TargetStorage:    referenceStorageName,
+				ReferenceStorage: referenceStorageName,
 			},
 			verify: func(t *testing.T, resp []*gitalypb.ConsistencyCheckResponse, err error) {
-				require.Equal(t, status.Error(codes.InvalidArgument, `target storage "target" cannot match reference storage "target"`), err)
+				expErr := status.Error(
+					codes.InvalidArgument,
+					fmt.Sprintf(`target storage %q cannot match reference storage %q`, referenceStorageName, referenceStorageName),
+				)
+				require.Equal(t, expErr, err)
 			},
 		},
 		{
 			desc: "no virtual",
 			req: gitalypb.ConsistencyCheckRequest{
 				VirtualStorage:   "",
-				TargetStorage:    "target",
-				ReferenceStorage: "reference",
+				TargetStorage:    referenceStorageName,
+				ReferenceStorage: targetStorageName,
 			},
 			verify: func(t *testing.T, resp []*gitalypb.ConsistencyCheckResponse, err error) {
 				require.Equal(t, status.Error(codes.InvalidArgument, "missing virtual storage"), err)
@@ -257,7 +353,7 @@ func TestServer_ConsistencyCheck(t *testing.T) {
 			desc: "unknown virtual",
 			req: gitalypb.ConsistencyCheckRequest{
 				VirtualStorage:   "unknown",
-				TargetStorage:    "target",
+				TargetStorage:    referenceStorageName,
 				ReferenceStorage: "unknown",
 			},
 			verify: func(t *testing.T, resp []*gitalypb.ConsistencyCheckResponse, err error) {
@@ -266,23 +362,44 @@ func TestServer_ConsistencyCheck(t *testing.T) {
 		},
 	} {
 		t.Run(tc.desc, func(t *testing.T) {
-			response, err := infoClient.ConsistencyCheck(ctx, &tc.req)
-			require.NoError(t, err)
+			execAndVerify(t, tc.req, tc.verify)
+		})
+	}
 
-			var results []*gitalypb.ConsistencyCheckResponse
-			var result *gitalypb.ConsistencyCheckResponse
-			for {
-				result, err = response.Recv()
-				if err != nil {
-					break
-				}
-				results = append(results, result)
-			}
+	// this case needs to be the last as it terminates one of the gitaly instances
+	t.Run("one of gitalies is unreachable", func(t *testing.T) {
+		toTerminate.Stop()
 
-			if err == io.EOF {
-				err = nil
+		req := gitalypb.ConsistencyCheckRequest{
+			VirtualStorage:         virtualStorage,
+			TargetStorage:          targetStorageName,
+			ReferenceStorage:       referenceStorageName,
+			DisableReconcilliation: true,
+		}
+
+		execAndVerify(t, req, func(t *testing.T, responses []*gitalypb.ConsistencyCheckResponse, err error) {
+			require.Equal(t, expErrStatus, err)
+			errs := []string{
+				fmt.Sprintf("rpc error: code = Unavailable desc = connection error: desc = \"transport: Error while dialing dial unix //%s: connect: no such file or directory\"", addr),
+				"rpc error: code = Canceled desc = context canceled",
 			}
-			tc.verify(t, results, err)
+			require.Equal(t, []*gitalypb.ConsistencyCheckResponse{
+				{
+					RepoRelativePath: firstRepoPath,
+					ReferenceStorage: referenceStorageName,
+					Errors:           errs,
+				},
+				{
+					RepoRelativePath: secondRepoPath,
+					ReferenceStorage: referenceStorageName,
+					Errors:           errs,
+				},
+				{
+					RepoRelativePath: thirdRepoPath,
+					ReferenceStorage: referenceStorageName,
+					Errors:           errs,
+				},
+			}, responses)
 		})
-	}
+	})
 }
diff --git a/proto/go/gitalypb/praefect.pb.go b/proto/go/gitalypb/praefect.pb.go
index f47e84d3e..dd02606e6 100644
--- a/proto/go/gitalypb/praefect.pb.go
+++ b/proto/go/gitalypb/praefect.pb.go
@@ -643,7 +643,9 @@ type ConsistencyCheckResponse struct {
 	// job. A replication ID is returned to track the corresponding job.
 	ReplJobId uint64 `protobuf:"varint,4,opt,name=repl_job_id,json=replJobId,proto3" json:"repl_job_id,omitempty"`
 	// If the reference storage was not specified, reply with the reference used
-	ReferenceStorage     string   `protobuf:"bytes,5,opt,name=reference_storage,json=referenceStorage,proto3" json:"reference_storage,omitempty"`
+	ReferenceStorage string `protobuf:"bytes,5,opt,name=reference_storage,json=referenceStorage,proto3" json:"reference_storage,omitempty"`
+	// The list of errors that appeared during the operation execution for the current repository.
+	Errors               []string `protobuf:"bytes,6,rep,name=errors,proto3" json:"errors,omitempty"`
 	XXX_NoUnkeyedLiteral struct{} `json:"-"`
 	XXX_unrecognized     []byte   `json:"-"`
 	XXX_sizecache        int32    `json:"-"`
@@ -709,6 +711,13 @@ func (m *ConsistencyCheckResponse) GetReferenceStorage() string {
 	return ""
 }
 
+func (m *ConsistencyCheckResponse) GetErrors() []string {
+	if m != nil {
+		return m.Errors
+	}
+	return nil
+}
+
 func init() {
 	proto.RegisterType((*SetReplicationFactorRequest)(nil), "gitaly.SetReplicationFactorRequest")
 	proto.RegisterType((*SetReplicationFactorResponse)(nil), "gitaly.SetReplicationFactorResponse")
@@ -728,60 +737,60 @@ func init() {
 func init() { proto.RegisterFile("praefect.proto", fileDescriptor_d32bf44842ead735) }
 
 var fileDescriptor_d32bf44842ead735 = []byte{
-	// 834 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x56, 0x4f, 0x6f, 0xdc, 0x44,
-	0x14, 0x97, 0x77, 0xd3, 0x76, 0xf3, 0xf2, 0xa7, 0xc9, 0x90, 0x12, 0xe3, 0x86, 0x76, 0xeb, 0x02,
+	// 847 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x56, 0xcd, 0x6f, 0xdc, 0x44,
+	0x14, 0x97, 0x77, 0xd3, 0x74, 0xf3, 0xf2, 0xd1, 0x64, 0x48, 0x1b, 0xe3, 0x86, 0x76, 0xeb, 0x02,
 	0x59, 0x09, 0xba, 0x89, 0x52, 0x24, 0x24, 0x4e, 0xd0, 0x54, 0x48, 0x45, 0x11, 0x8d, 0x1c, 0x09,
-	0x24, 0x38, 0x58, 0x63, 0x7b, 0xb2, 0x3b, 0x65, 0xd6, 0x63, 0x66, 0x66, 0x23, 0xf9, 0xc8, 0x17,
-	0xe0, 0x8a, 0xc4, 0xb5, 0x1f, 0x88, 0x4f, 0x02, 0xe2, 0xc4, 0x19, 0x79, 0xfe, 0x78, 0x9d, 0x5d,
-	0xef, 0x06, 0x22, 0x71, 0xf3, 0xbc, 0xf7, 0x7b, 0xff, 0x7e, 0xef, 0xcd, 0x1b, 0xc3, 0x76, 0x21,
-	0x30, 0xb9, 0x24, 0xa9, 0x1a, 0x16, 0x82, 0x2b, 0x8e, 0xee, 0x8e, 0xa8, 0xc2, 0xac, 0x0c, 0x80,
-	0xd1, 0xdc, 0xca, 0x82, 0x4d, 0x39, 0xc6, 0x82, 0x64, 0xe6, 0x14, 0xfe, 0xe6, 0xc1, 0xc3, 0x0b,
-	0xa2, 0x22, 0x52, 0x30, 0x9a, 0x62, 0x45, 0x79, 0xfe, 0x15, 0x4e, 0x15, 0x17, 0x11, 0xf9, 0x69,
-	0x4a, 0xa4, 0x42, 0x87, 0x70, 0xff, 0x8a, 0x0a, 0x35, 0xc5, 0x2c, 0x96, 0x8a, 0x0b, 0x3c, 0x22,
-	0xbe, 0xd7, 0xf7, 0x06, 0xeb, 0xd1, 0xb6, 0x15, 0x5f, 0x18, 0x29, 0x7a, 0x0a, 0x5b, 0x82, 0x30,
-	0xac, 0xe8, 0x15, 0x89, 0x0b, 0xac, 0xc6, 0x7e, 0x47, 0xc3, 0x36, 0x9d, 0xf0, 0x1c, 0xab, 0x31,
-	0x7a, 0x06, 0x48, 0xcc, 0x22, 0xc5, 0x97, 0x3a, 0x94, 0xdf, 0xed, 0x7b, 0x83, 0x3b, 0xd1, 0xae,
-	0x98, 0xcf, 0x21, 0xfc, 0x1c, 0x0e, 0xda, 0x73, 0x93, 0x05, 0xcf, 0x25, 0x41, 0x01, 0xf4, 0x6c,
-	0x52, 0xd2, 0xf7, 0xfa, 0xdd, 0xc1, 0x7a, 0x54, 0x9f, 0xc3, 0xb7, 0x1e, 0x3c, 0xba, 0x20, 0xea,
-	0xcb, 0xa9, 0x1a, 0x73, 0x41, 0x95, 0xce, 0xc1, 0xe6, 0xfa, 0xff, 0xd4, 0xf6, 0x1c, 0x1e, 0xe0,
-	0x66, 0xb0, 0xda, 0x67, 0x57, 0x83, 0xf7, 0x70, 0x4b, 0x26, 0xe1, 0x13, 0x78, 0xbc, 0x34, 0x49,
-	0x53, 0x64, 0xf8, 0xb3, 0x07, 0x7b, 0x2f, 0xb1, 0xc2, 0x8c, 0x4b, 0x79, 0x3a, 0x26, 0xe9, 0x8f,
-	0xff, 0x39, 0xfd, 0x2f, 0xe0, 0x80, 0xe6, 0x29, 0x9b, 0x66, 0x55, 0xf6, 0x42, 0x51, 0xcc, 0x58,
-	0x19, 0x3b, 0xb6, 0x49, 0xa6, 0xab, 0xe9, 0x45, 0x81, 0xc5, 0x9c, 0x3b, 0x48, 0x54, 0x23, 0xc2,
-	0xbf, 0x3b, 0xf0, 0x60, 0x2e, 0x07, 0xdb, 0x82, 0x33, 0xd8, 0x14, 0xa4, 0xe0, 0x92, 0x2a, 0x2e,
-	0x28, 0x91, 0x7e, 0xa7, 0xdf, 0x1d, 0x6c, 0x9c, 0x0c, 0x86, 0x66, 0xf0, 0x86, 0xad, 0x46, 0xc3,
-	0xc8, 0x59, 0x94, 0xd1, 0x35, 0xeb, 0xe0, 0x97, 0x0e, 0xc0, 0x4c, 0xb9, 0xc8, 0xbb, 0xd7, 0xc2,
-	0xfb, 0x59, 0x63, 0x08, 0x4c, 0xf4, 0xe3, 0x7f, 0x1b, 0x7d, 0xe8, 0xb8, 0xae, 0x3d, 0xa0, 0x87,
-	0xb0, 0x2e, 0x08, 0xce, 0x62, 0x9e, 0xb3, 0x52, 0x77, 0xae, 0x17, 0xf5, 0x2a, 0xc1, 0xeb, 0x9c,
-	0x95, 0xc8, 0x87, 0x7b, 0x85, 0xa0, 0x13, 0x2c, 0x4a, 0x7f, 0x4d, 0x67, 0xe2, 0x8e, 0xc1, 0xb7,
-	0x70, 0xcf, 0xb1, 0x8d, 0x60, 0x2d, 0xc7, 0x13, 0xd7, 0x0b, 0xfd, 0x5d, 0x79, 0x4d, 0xc8, 0x98,
-	0xe6, 0x59, 0x9c, 0x94, 0x9a, 0xee, 0x6e, 0xd4, 0x33, 0x82, 0x17, 0x65, 0x35, 0xc5, 0x58, 0x4a,
-	0x3a, 0xca, 0x49, 0xe6, 0x22, 0xba, 0x73, 0xf8, 0x1a, 0xde, 0x6b, 0x90, 0x65, 0x1a, 0x22, 0xdd,
-	0x00, 0x9c, 0x00, 0xd4, 0xec, 0x95, 0x3a, 0xde, 0xc6, 0x09, 0x72, 0xb5, 0x37, 0xcc, 0x1a, 0xa8,
-	0xf0, 0x6d, 0x07, 0x82, 0x36, 0x8f, 0xb6, 0x9d, 0xdf, 0xcc, 0x2a, 0x34, 0xfe, 0x3e, 0x6d, 0xf1,
-	0x37, 0x67, 0xd4, 0x50, 0xbd, 0x24, 0x0a, 0x53, 0x26, 0x6b, 0x5e, 0xd0, 0x39, 0xf4, 0xec, 0xa0,
-	0xb9, 0xe6, 0xdc, 0xce, 0x61, 0xed, 0x25, 0x48, 0x61, 0x77, 0x41, 0x7d, 0x1b, 0x26, 0x2a, 0xda,
-	0xd3, 0x6a, 0x2e, 0xe4, 0x74, 0x62, 0xef, 0x73, 0x7d, 0x0e, 0x7f, 0xf7, 0x60, 0xff, 0x94, 0xe7,
-	0x92, 0x4a, 0x45, 0xf2, 0xb4, 0xbc, 0xdd, 0xb5, 0xfb, 0x10, 0xb6, 0x15, 0x16, 0x23, 0xa2, 0x6a,
-	0x9c, 0x09, 0xb3, 0x65, 0xa4, 0x0e, 0xf6, 0x31, 0xec, 0x0a, 0x72, 0x49, 0x04, 0xc9, 0xd3, 0xf9,
-	0x9d, 0xb1, 0x53, 0x2b, 0x1c, 0xf8, 0x33, 0xd8, 0xcf, 0xa8, 0xc4, 0x09, 0x23, 0xb1, 0x20, 0x29,
-	0xcf, 0x53, 0xca, 0x18, 0xd5, 0xab, 0x51, 0x4f, 0x64, 0x2f, 0x7a, 0xd7, 0xaa, 0xa3, 0xeb, 0xda,
-	0xf0, 0x0f, 0x0f, 0xfc, 0xc5, 0x8a, 0x6c, 0xd7, 0x3f, 0xd1, 0x6b, 0x99, 0xc7, 0x6d, 0x97, 0x6d,
-	0xa7, 0xd2, 0x44, 0xcd, 0x0b, 0x77, 0x08, 0xf7, 0x6d, 0x5d, 0x73, 0xfc, 0xd9, 0x72, 0x4f, 0xad,
-	0xd4, 0x6c, 0x7b, 0x57, 0x59, 0x8d, 0x35, 0xa5, 0xcd, 0x6a, 0xae, 0xe1, 0x8f, 0x60, 0xa3, 0xea,
-	0x72, 0xfc, 0x86, 0x27, 0x31, 0xcd, 0x74, 0x3d, 0x6b, 0xd1, 0x7a, 0x25, 0xfa, 0x9a, 0x27, 0xaf,
-	0xb2, 0x76, 0xa2, 0xee, 0xb4, 0x13, 0x75, 0xf2, 0x67, 0x17, 0xde, 0x39, 0xb7, 0x8f, 0xe1, 0xab,
-	0xfc, 0x92, 0x5f, 0x10, 0x71, 0x45, 0x53, 0x82, 0x7e, 0x00, 0xb4, 0x38, 0x78, 0xe8, 0xc9, 0xaa,
-	0xa1, 0xd4, 0x6d, 0x0f, 0xc2, 0x9b, 0xe7, 0x16, 0x7d, 0x07, 0x3b, 0xf3, 0x1c, 0xa3, 0xc7, 0xce,
-	0x6e, 0xc9, 0x3c, 0x05, 0xfd, 0xe5, 0x00, 0xe3, 0xf6, 0xd8, 0x43, 0x67, 0xb0, 0x75, 0x6d, 0x97,
-	0xa1, 0x83, 0x25, 0x2b, 0xce, 0xb8, 0x7c, 0x7f, 0xe5, 0x02, 0x44, 0x6f, 0x60, 0x7f, 0xc9, 0xa3,
-	0x83, 0x3e, 0x72, 0x96, 0xab, 0x9f, 0xce, 0xe0, 0xf0, 0x46, 0x9c, 0x8d, 0x85, 0x61, 0xaf, 0xed,
-	0x09, 0x47, 0x4f, 0x1b, 0x0e, 0x96, 0xfd, 0x7c, 0x04, 0x1f, 0xac, 0x06, 0x99, 0x10, 0xc1, 0xda,
-	0x5f, 0xbf, 0x0e, 0xbc, 0x17, 0xc7, 0xdf, 0x57, 0x60, 0x86, 0x93, 0x61, 0xca, 0x27, 0x47, 0xe6,
-	0xf3, 0x19, 0x17, 0xa3, 0x23, 0xe3, 0xe2, 0x48, 0xff, 0xee, 0x1c, 0x8d, 0xb8, 0x3d, 0x17, 0x49,
-	0x72, 0x57, 0x8b, 0x9e, 0xff, 0x13, 0x00, 0x00, 0xff, 0xff, 0x99, 0x51, 0xfc, 0x0b, 0x35, 0x09,
-	0x00, 0x00,
+	0x24, 0x38, 0x58, 0x63, 0x7b, 0xb2, 0x3b, 0x65, 0xe2, 0x31, 0x33, 0xb3, 0x91, 0x7c, 0xe4, 0xc0,
+	0x95, 0x2b, 0x12, 0xd7, 0xfe, 0x41, 0xfc, 0x27, 0x88, 0x13, 0x67, 0xe4, 0xf9, 0xf0, 0x3a, 0xbb,
+	0xde, 0x0d, 0x44, 0xea, 0xcd, 0xf3, 0xde, 0xef, 0x7d, 0xfd, 0xde, 0x9b, 0x37, 0x86, 0xad, 0x42,
+	0x60, 0x72, 0x41, 0x52, 0x35, 0x2c, 0x04, 0x57, 0x1c, 0xad, 0x8e, 0xa8, 0xc2, 0xac, 0x0c, 0x80,
+	0xd1, 0xdc, 0xca, 0x82, 0x0d, 0x39, 0xc6, 0x82, 0x64, 0xe6, 0x14, 0xfe, 0xe1, 0xc1, 0xc3, 0x73,
+	0xa2, 0x22, 0x52, 0x30, 0x9a, 0x62, 0x45, 0x79, 0xfe, 0x35, 0x4e, 0x15, 0x17, 0x11, 0xf9, 0x79,
+	0x42, 0xa4, 0x42, 0x07, 0x70, 0xef, 0x8a, 0x0a, 0x35, 0xc1, 0x2c, 0x96, 0x8a, 0x0b, 0x3c, 0x22,
+	0xbe, 0xd7, 0xf7, 0x06, 0x6b, 0xd1, 0x96, 0x15, 0x9f, 0x1b, 0x29, 0x7a, 0x0a, 0x9b, 0x82, 0x30,
+	0xac, 0xe8, 0x15, 0x89, 0x0b, 0xac, 0xc6, 0x7e, 0x47, 0xc3, 0x36, 0x9c, 0xf0, 0x0c, 0xab, 0x31,
+	0x7a, 0x06, 0x48, 0x4c, 0x23, 0xc5, 0x17, 0x3a, 0x94, 0xdf, 0xed, 0x7b, 0x83, 0x3b, 0xd1, 0x8e,
+	0x98, 0xcd, 0x21, 0xfc, 0x02, 0xf6, 0xdb, 0x73, 0x93, 0x05, 0xcf, 0x25, 0x41, 0x01, 0xf4, 0x6c,
+	0x52, 0xd2, 0xf7, 0xfa, 0xdd, 0xc1, 0x5a, 0x54, 0x9f, 0xc3, 0xb7, 0x1e, 0x3c, 0x3a, 0x27, 0xea,
+	0xab, 0x89, 0x1a, 0x73, 0x41, 0x95, 0xce, 0xc1, 0xe6, 0xfa, 0x6e, 0x6a, 0x7b, 0x0e, 0xf7, 0x71,
+	0x33, 0x58, 0xed, 0xb3, 0xab, 0xc1, 0xbb, 0xb8, 0x25, 0x93, 0xf0, 0x09, 0x3c, 0x5e, 0x98, 0xa4,
+	0x29, 0x32, 0xfc, 0xc5, 0x83, 0xdd, 0x97, 0x58, 0x61, 0xc6, 0xa5, 0x3c, 0x19, 0x93, 0xf4, 0xa7,
+	0xff, 0x9d, 0xfe, 0x97, 0xb0, 0x4f, 0xf3, 0x94, 0x4d, 0xb2, 0x2a, 0x7b, 0xa1, 0x28, 0x66, 0xac,
+	0x8c, 0x1d, 0xdb, 0x24, 0xd3, 0xd5, 0xf4, 0xa2, 0xc0, 0x62, 0xce, 0x1c, 0x24, 0xaa, 0x11, 0xe1,
+	0x3f, 0x1d, 0xb8, 0x3f, 0x93, 0x83, 0x6d, 0xc1, 0x29, 0x6c, 0x08, 0x52, 0x70, 0x49, 0x15, 0x17,
+	0x94, 0x48, 0xbf, 0xd3, 0xef, 0x0e, 0xd6, 0x8f, 0x07, 0x43, 0x33, 0x78, 0xc3, 0x56, 0xa3, 0x61,
+	0xe4, 0x2c, 0xca, 0xe8, 0x9a, 0x75, 0xf0, 0x5b, 0x07, 0x60, 0xaa, 0x9c, 0xe7, 0xdd, 0x6b, 0xe1,
+	0xfd, 0xb4, 0x31, 0x04, 0x26, 0xfa, 0xd1, 0x7f, 0x8d, 0x3e, 0x74, 0x5c, 0xd7, 0x1e, 0xd0, 0x43,
+	0x58, 0x13, 0x04, 0x67, 0x31, 0xcf, 0x59, 0xa9, 0x3b, 0xd7, 0x8b, 0x7a, 0x95, 0xe0, 0x75, 0xce,
+	0x4a, 0xe4, 0xc3, 0xdd, 0x42, 0xd0, 0x4b, 0x2c, 0x4a, 0x7f, 0x45, 0x67, 0xe2, 0x8e, 0xc1, 0x77,
+	0x70, 0xd7, 0xb1, 0x8d, 0x60, 0x25, 0xc7, 0x97, 0xae, 0x17, 0xfa, 0xbb, 0xf2, 0x9a, 0x90, 0x31,
+	0xcd, 0xb3, 0x38, 0x29, 0x35, 0xdd, 0xdd, 0xa8, 0x67, 0x04, 0x2f, 0xca, 0x6a, 0x8a, 0xb1, 0x94,
+	0x74, 0x94, 0x93, 0xcc, 0x45, 0x74, 0xe7, 0xf0, 0x35, 0xbc, 0xdf, 0x20, 0xcb, 0x34, 0x44, 0xba,
+	0x01, 0x38, 0x06, 0xa8, 0xd9, 0x2b, 0x75, 0xbc, 0xf5, 0x63, 0xe4, 0x6a, 0x6f, 0x98, 0x35, 0x50,
+	0xe1, 0xdb, 0x0e, 0x04, 0x6d, 0x1e, 0x6d, 0x3b, 0xbf, 0x9d, 0x56, 0x68, 0xfc, 0x7d, 0xd6, 0xe2,
+	0x6f, 0xc6, 0xa8, 0xa1, 0x7a, 0x49, 0x14, 0xa6, 0x4c, 0xd6, 0xbc, 0xa0, 0x33, 0xe8, 0xd9, 0x41,
+	0x73, 0xcd, 0xb9, 0x9d, 0xc3, 0xda, 0x4b, 0x90, 0xc2, 0xce, 0x9c, 0xfa, 0x36, 0x4c, 0x54, 0xb4,
+	0xa7, 0xd5, 0x5c, 0xc8, 0xc9, 0xa5, 0xbd, 0xcf, 0xf5, 0x39, 0xfc, 0xd3, 0x83, 0xbd, 0x13, 0x9e,
+	0x4b, 0x2a, 0x15, 0xc9, 0xd3, 0xf2, 0x76, 0xd7, 0xee, 0x23, 0xd8, 0x52, 0x58, 0x8c, 0x88, 0xaa,
+	0x71, 0x26, 0xcc, 0xa6, 0x91, 0x3a, 0xd8, 0x27, 0xb0, 0x23, 0xc8, 0x05, 0x11, 0x24, 0x4f, 0x67,
+	0x77, 0xc6, 0x76, 0xad, 0x70, 0xe0, 0xcf, 0x61, 0x2f, 0xa3, 0x12, 0x27, 0x8c, 0xc4, 0x82, 0xa4,
+	0x3c, 0x4f, 0x29, 0x63, 0x54, 0xaf, 0x46, 0x3d, 0x91, 0xbd, 0xe8, 0x81, 0x55, 0x47, 0xd7, 0xb5,
+	0xe1, 0xaf, 0x1d, 0xf0, 0xe7, 0x2b, 0xb2, 0x5d, 0xff, 0x54, 0xaf, 0x65, 0x1e, 0xb7, 0x5d, 0xb6,
+	0xed, 0x4a, 0x13, 0x35, 0x2f, 0xdc, 0x01, 0xdc, 0xb3, 0x75, 0xcd, 0xf0, 0x67, 0xcb, 0x3d, 0xb1,
+	0x52, 0xb3, 0xed, 0x5d, 0x65, 0x35, 0xd6, 0x94, 0x36, 0xad, 0xb9, 0x86, 0x3f, 0x82, 0xf5, 0xaa,
+	0xcb, 0xf1, 0x1b, 0x9e, 0xc4, 0x34, 0xd3, 0xf5, 0xac, 0x44, 0x6b, 0x95, 0xe8, 0x1b, 0x9e, 0xbc,
+	0xca, 0xda, 0x89, 0xba, 0xb3, 0x80, 0xa8, 0x07, 0xb0, 0x4a, 0x84, 0xe0, 0x42, 0xfa, 0xab, 0xfa,
+	0x61, 0xb0, 0xa7, 0xe3, 0xbf, 0xba, 0xf0, 0xde, 0x99, 0x7d, 0x24, 0x5f, 0xe5, 0x17, 0xfc, 0x9c,
+	0x88, 0x2b, 0x9a, 0x12, 0xf4, 0x23, 0xa0, 0xf9, 0x81, 0x44, 0x4f, 0x96, 0x0d, 0xab, 0x1e, 0x87,
+	0x20, 0xbc, 0x79, 0x9e, 0xd1, 0xf7, 0xb0, 0x3d, 0xcb, 0x3d, 0x7a, 0xec, 0xec, 0x16, 0xcc, 0x59,
+	0xd0, 0x5f, 0x0c, 0x30, 0x6e, 0x8f, 0x3c, 0x74, 0x0a, 0x9b, 0xd7, 0x76, 0x1c, 0xda, 0x5f, 0xb0,
+	0xfa, 0x8c, 0xcb, 0x0f, 0x96, 0x2e, 0x46, 0xf4, 0x06, 0xf6, 0x16, 0x3c, 0x46, 0xe8, 0x63, 0x67,
+	0xb9, 0xfc, 0x49, 0x0d, 0x0e, 0x6e, 0xc4, 0xd9, 0x58, 0x18, 0x76, 0xdb, 0x9e, 0x76, 0xf4, 0xb4,
+	0xe1, 0x60, 0xd1, 0x4f, 0x49, 0xf0, 0xe1, 0x72, 0x90, 0x09, 0x11, 0xac, 0xfc, 0xfd, 0xfb, 0xc0,
+	0x7b, 0x71, 0xf4, 0x43, 0x05, 0x66, 0x38, 0x19, 0xa6, 0xfc, 0xf2, 0xd0, 0x7c, 0x3e, 0xe3, 0x62,
+	0x74, 0x68, 0x5c, 0x1c, 0xea, 0xdf, 0xa0, 0xc3, 0x11, 0xb7, 0xe7, 0x22, 0x49, 0x56, 0xb5, 0xe8,
+	0xf9, 0xbf, 0x01, 0x00, 0x00, 0xff, 0xff, 0xb1, 0x8e, 0xb6, 0xc1, 0x4d, 0x09, 0x00, 0x00,
 }
 
 // Reference imports to suppress errors if they are not otherwise used.
diff --git a/proto/praefect.proto b/proto/praefect.proto
index e9676d20c..60d857233 100644
--- a/proto/praefect.proto
+++ b/proto/praefect.proto
@@ -132,4 +132,6 @@ message ConsistencyCheckResponse {
   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;
 }
diff --git a/ruby/proto/gitaly/praefect_pb.rb b/ruby/proto/gitaly/praefect_pb.rb
index b5f5da567..8439cc121 100644
--- a/ruby/proto/gitaly/praefect_pb.rb
+++ b/ruby/proto/gitaly/praefect_pb.rb
@@ -63,6 +63,7 @@ Google::Protobuf::DescriptorPool.generated_pool.build do
       optional :reference_checksum, :string, 3
       optional :repl_job_id, :uint64, 4
       optional :reference_storage, :string, 5
+      repeated :errors, :string, 6
     end
   end
 end