func Run()

in internal/mode/advanced/advanced.go [45:192]
126 lines of code
24 McCabe index (conditional complexity)

func Run(buildOpts shared.BuildOpts) error {
	closer, err := configureLogger()
	if err != nil {
		_, _ = fmt.Fprintf(os.Stderr, "error initializing logkit %v", err)
		return err
	}
	defer closer.Close() //nolint:errcheck

	flag.Parse()

	if *versionFlag {
		_, _ = fmt.Fprintf(os.Stdout, "%s %s (built at: %s)", os.Args[0], buildOpts.Version, buildOpts.BuildTime)
		os.Exit(0)
	}

	args := flag.Args()

	if len(args) != 1 {
		argsError := errors.New("WrongArguments")
		logkit.WithError(argsError).Fatalf("Usage: %s [ --version | [--blob-type=(blob|wiki_blob)] [--group-id=<ID>] [--project-id=<ID>] [--skip-commits] [--search-curation] [--full-path=<full-path>] [--timeout=<timeout>] [--visbility-level=<visbility-level>] [--repository-access-level=<repository-access-level>] [--wiki-access-level=<wiki-access-level>] <repo-path> ]", os.Args[0])
	}

	projectID := *projectIdFlag
	groupID := *groupIdFlag
	if projectID < 0 && groupID < 0 {
		logkit.WithError(err).WithField("projectID", projectID).WithField("groupID", groupID).Fatalf("Error: Both projectID and groupID are empty")
	}

	repoPath := args[0]

	blobType := *blobTypeFlag
	fromSHA := *fromSHAFlag
	toSHA := *toSHAFlag
	skipCommits := *skipCommitsFlag
	fullPath := *fullPathFlag
	timeoutOption := *timeoutOptionFlag
	searchCurationFlag := *searchCurationFlag
	traversalIds := *traversalIdsFlag
	hashedRootNamespaceId := int16(*hashedRootNamespaceIdFlag) //nolint:gosec
	correlationID := generateCorrelationID()
	archived := *archivedFlag
	schemaVersionBlob := uint16(*schemaVersionBlobFlag)     //nolint:gosec
	schemaVersionCommit := uint16(*schemaVersionCommitFlag) //nolint:gosec
	schemaVersionWiki := uint16(*schemaVersionWikiFlag)     //nolint:gosec

	if traversalIds == "" {
		logkit.WithField("traversalIds", traversalIds).Fatal("Error: traversalIds is empty")
	}

	repo, err := git.NewGitalyClientFromEnv(repoPath, fromSHA, toSHA, correlationID, projectID, fullPath)
	if err != nil {
		logkit.WithFields(
			logkit.Fields{
				"repoPath":      repoPath,
				"fromSHA":       fromSHA,
				"toSHA":         toSHA,
				"correlationID": correlationID,
				"projectID":     projectID,
				"groupID":       groupID,
				"fullPath":      fullPath,
			},
		).WithError(err).Fatal("Error creating gitaly client")
	}

	config, err := loadConfig(projectID, groupID, searchCurationFlag, traversalIds, hashedRootNamespaceId, archived, schemaVersionBlob, schemaVersionCommit, schemaVersionWiki)
	if err != nil {
		logkit.WithError(err).WithFields(
			logkit.Fields{
				"projectID":             projectID,
				"searchCurationFlag":    searchCurationFlag,
				"traversalIds":          traversalIds,
				"hashedRootNamespaceId": hashedRootNamespaceId,
				"archived":              archived,
				"schemaVersionBlob":     schemaVersionBlob,
				"schemaVersionCommit":   schemaVersionCommit,
				"schemaVersionWiki":     schemaVersionWiki,
			}).Fatalf("Error loading config")
	}

	esClient, err := elastic.NewClient(config, correlationID)
	if err != nil {
		logkit.WithError(err).Fatal("Error creating elastic client")
	}

	if esClient.IndexNameWikis != "" && blobType == "wiki_blob" && schemaVersionWiki == 0 {
		logkit.WithField("schemaVersionWiki", schemaVersionWiki).Fatal("Error: schemaVersionWiki is empty")
	}

	if !skipCommits && schemaVersionCommit == 0 {
		logkit.WithField("schemaVersionCommit", schemaVersionCommit).Fatal("Error: schemaVersionCommit is empty")
	}

	if blobType == "blob" && schemaVersionBlob == 0 {
		logkit.WithField("schemaVersionBlob", schemaVersionBlob).Fatal("Error: schemaVersionBlob is empty")
	}

	if timeoutOption != "" {
		timeout, err := time.ParseDuration(timeoutOption)
		if err != nil {
			logkit.WithError(err).WithField("timeoutOption", timeoutOption).Fatalf("Error parsing timeout")
		} else {
			logkit.WithField("timeout", timeout).Info("Setting timeout")

			time.AfterFunc(timeout, func() {
				timedOutErr := errors.New("TimedOut")
				logkit.WithError(timedOutErr).WithField("timeout", timeout).Fatalf("The process has timed out")
			})
		}
	}

	idx := indexer.NewIndexer(repo, esClient)

	logkit.WithFields(
		logkit.Fields{
			"IndexNameDefault":      esClient.IndexNameDefault,
			"IndexNameCommits":      esClient.IndexNameCommits,
			"IndexNameWikis":        esClient.IndexNameWikis,
			"projectID":             esClient.ParentID(),
			"blobType":              blobType,
			"skipCommits":           skipCommits,
			"searchCuration":        config.SearchCuration,
			"Permissions":           config.Permissions,
			"PermissionsWiki":       config.PermissionsWiki,
			"traversalIds":          traversalIds,
			"hashedRootNamespaceId": hashedRootNamespaceId,
			"archived":              archived,
			"schemaVersionBlob":     schemaVersionBlob,
			"schemaVersionCommit":   schemaVersionCommit,
			"schemaVersionWiki":     schemaVersionWiki,
		},
	).Debugf("Indexing from %s to %s", repo.FromHash, repo.ToHash)

	if err := idx.IndexBlobs(blobType); err != nil {
		logkit.WithError(err).Fatalln("Indexing error")
	}

	if !skipCommits && blobType == "blob" {
		if err := idx.IndexCommits(); err != nil {
			logkit.WithError(err).Fatalln("Indexing error")
		}
	}

	if err := idx.Flush(); err != nil {
		logkit.WithError(err).Fatalln("Flushing error")
	}

	return nil
}