mirror of
https://codeberg.org/forgejo/forgejo.git
synced 2024-09-08 00:03:28 +00:00
Refactor `modules/indexer` to make it more maintainable. And it can be easier to support more features. I'm trying to solve some of issue searching, this is a precursor to making functional changes. Current supported engines and the index versions: | engines | issues | code | | - | - | - | | db | Just a wrapper for database queries, doesn't need version | - | | bleve | The version of index is **2** | The version of index is **6** | | elasticsearch | The old index has no version, will be treated as version **0** in this PR | The version of index is **1** | | meilisearch | The old index has no version, will be treated as version **0** in this PR | - | ## Changes ### Split Splited it into mutiple packages ```text indexer ├── internal │ ├── bleve │ ├── db │ ├── elasticsearch │ └── meilisearch ├── code │ ├── bleve │ ├── elasticsearch │ └── internal └── issues ├── bleve ├── db ├── elasticsearch ├── internal └── meilisearch ``` - `indexer/interanal`: Internal shared package for indexer. - `indexer/interanal/[engine]`: Internal shared package for each engine (bleve/db/elasticsearch/meilisearch). - `indexer/code`: Implementations for code indexer. - `indexer/code/internal`: Internal shared package for code indexer. - `indexer/code/[engine]`: Implementation via each engine for code indexer. - `indexer/issues`: Implementations for issues indexer. ### Deduplication - Combine `Init/Ping/Close` for code indexer and issues indexer. - ~Combine `issues.indexerHolder` and `code.wrappedIndexer` to `internal.IndexHolder`.~ Remove it, use dummy indexer instead when the indexer is not ready. - Duplicate two copies of creating ES clients. - Duplicate two copies of `indexerID()`. ### Enhancement - [x] Support index version for elasticsearch issues indexer, the old index without version will be treated as version 0. - [x] Fix spell of `elastic_search/ElasticSearch`, it should be `Elasticsearch`. - [x] Improve versioning of ES index. We don't need `Aliases`: - Gitea does't need aliases for "Zero Downtime" because it never delete old indexes. - The old code of issues indexer uses the orignal name to create issue index, so it's tricky to convert it to an alias. - [x] Support index version for meilisearch issues indexer, the old index without version will be treated as version 0. - [x] Do "ping" only when `Ping` has been called, don't ping periodically and cache the status. - [x] Support the context parameter whenever possible. - [x] Fix outdated example config. - [x] Give up the requeue logic of issues indexer: When indexing fails, call Ping to check if it was caused by the engine being unavailable, and only requeue the task if the engine is unavailable. - It is fragile and tricky, could cause data losing (It did happen when I was doing some tests for this PR). And it works for ES only. - Just always requeue the failed task, if it caused by bad data, it's a bug of Gitea which should be fixed. --------- Co-authored-by: Giteabot <teabot@gitea.io>
167 lines
4.9 KiB
Go
167 lines
4.9 KiB
Go
// Copyright 2019 The Gitea Authors. All rights reserved.
|
|
// SPDX-License-Identifier: MIT
|
|
|
|
package code
|
|
|
|
import (
|
|
"context"
|
|
"strconv"
|
|
"strings"
|
|
|
|
repo_model "code.gitea.io/gitea/models/repo"
|
|
"code.gitea.io/gitea/modules/git"
|
|
"code.gitea.io/gitea/modules/indexer/code/internal"
|
|
"code.gitea.io/gitea/modules/log"
|
|
"code.gitea.io/gitea/modules/setting"
|
|
)
|
|
|
|
func getDefaultBranchSha(ctx context.Context, repo *repo_model.Repository) (string, error) {
|
|
stdout, _, err := git.NewCommand(ctx, "show-ref", "-s").AddDynamicArguments(git.BranchPrefix + repo.DefaultBranch).RunStdString(&git.RunOpts{Dir: repo.RepoPath()})
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
return strings.TrimSpace(stdout), nil
|
|
}
|
|
|
|
// getRepoChanges returns changes to repo since last indexer update
|
|
func getRepoChanges(ctx context.Context, repo *repo_model.Repository, revision string) (*internal.RepoChanges, error) {
|
|
status, err := repo_model.GetIndexerStatus(ctx, repo, repo_model.RepoIndexerTypeCode)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
if len(status.CommitSha) == 0 {
|
|
return genesisChanges(ctx, repo, revision)
|
|
}
|
|
return nonGenesisChanges(ctx, repo, revision)
|
|
}
|
|
|
|
func isIndexable(entry *git.TreeEntry) bool {
|
|
if !entry.IsRegular() && !entry.IsExecutable() {
|
|
return false
|
|
}
|
|
name := strings.ToLower(entry.Name())
|
|
for _, g := range setting.Indexer.ExcludePatterns {
|
|
if g.Match(name) {
|
|
return false
|
|
}
|
|
}
|
|
for _, g := range setting.Indexer.IncludePatterns {
|
|
if g.Match(name) {
|
|
return true
|
|
}
|
|
}
|
|
return len(setting.Indexer.IncludePatterns) == 0
|
|
}
|
|
|
|
// parseGitLsTreeOutput parses the output of a `git ls-tree -r --full-name` command
|
|
func parseGitLsTreeOutput(stdout []byte) ([]internal.FileUpdate, error) {
|
|
entries, err := git.ParseTreeEntries(stdout)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
idxCount := 0
|
|
updates := make([]internal.FileUpdate, len(entries))
|
|
for _, entry := range entries {
|
|
if isIndexable(entry) {
|
|
updates[idxCount] = internal.FileUpdate{
|
|
Filename: entry.Name(),
|
|
BlobSha: entry.ID.String(),
|
|
Size: entry.Size(),
|
|
Sized: true,
|
|
}
|
|
idxCount++
|
|
}
|
|
}
|
|
return updates[:idxCount], nil
|
|
}
|
|
|
|
// genesisChanges get changes to add repo to the indexer for the first time
|
|
func genesisChanges(ctx context.Context, repo *repo_model.Repository, revision string) (*internal.RepoChanges, error) {
|
|
var changes internal.RepoChanges
|
|
stdout, _, runErr := git.NewCommand(ctx, "ls-tree", "--full-tree", "-l", "-r").AddDynamicArguments(revision).RunStdBytes(&git.RunOpts{Dir: repo.RepoPath()})
|
|
if runErr != nil {
|
|
return nil, runErr
|
|
}
|
|
|
|
var err error
|
|
changes.Updates, err = parseGitLsTreeOutput(stdout)
|
|
return &changes, err
|
|
}
|
|
|
|
// nonGenesisChanges get changes since the previous indexer update
|
|
func nonGenesisChanges(ctx context.Context, repo *repo_model.Repository, revision string) (*internal.RepoChanges, error) {
|
|
diffCmd := git.NewCommand(ctx, "diff", "--name-status").AddDynamicArguments(repo.CodeIndexerStatus.CommitSha, revision)
|
|
stdout, _, runErr := diffCmd.RunStdString(&git.RunOpts{Dir: repo.RepoPath()})
|
|
if runErr != nil {
|
|
// previous commit sha may have been removed by a force push, so
|
|
// try rebuilding from scratch
|
|
log.Warn("git diff: %v", runErr)
|
|
if err := (*globalIndexer.Load()).Delete(ctx, repo.ID); err != nil {
|
|
return nil, err
|
|
}
|
|
return genesisChanges(ctx, repo, revision)
|
|
}
|
|
|
|
var changes internal.RepoChanges
|
|
var err error
|
|
updatedFilenames := make([]string, 0, 10)
|
|
for _, line := range strings.Split(stdout, "\n") {
|
|
line = strings.TrimSpace(line)
|
|
if len(line) == 0 {
|
|
continue
|
|
}
|
|
fields := strings.Split(line, "\t")
|
|
if len(fields) < 2 {
|
|
log.Warn("Unparseable output for diff --name-status: `%s`)", line)
|
|
continue
|
|
}
|
|
filename := fields[1]
|
|
if len(filename) == 0 {
|
|
continue
|
|
} else if filename[0] == '"' {
|
|
filename, err = strconv.Unquote(filename)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
}
|
|
|
|
switch status := fields[0][0]; status {
|
|
case 'M', 'A':
|
|
updatedFilenames = append(updatedFilenames, filename)
|
|
case 'D':
|
|
changes.RemovedFilenames = append(changes.RemovedFilenames, filename)
|
|
case 'R', 'C':
|
|
if len(fields) < 3 {
|
|
log.Warn("Unparseable output for diff --name-status: `%s`)", line)
|
|
continue
|
|
}
|
|
dest := fields[2]
|
|
if len(dest) == 0 {
|
|
log.Warn("Unparseable output for diff --name-status: `%s`)", line)
|
|
continue
|
|
}
|
|
if dest[0] == '"' {
|
|
dest, err = strconv.Unquote(dest)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
}
|
|
if status == 'R' {
|
|
changes.RemovedFilenames = append(changes.RemovedFilenames, filename)
|
|
}
|
|
updatedFilenames = append(updatedFilenames, dest)
|
|
default:
|
|
log.Warn("Unrecognized status: %c (line=%s)", status, line)
|
|
}
|
|
}
|
|
|
|
cmd := git.NewCommand(ctx, "ls-tree", "--full-tree", "-l").AddDynamicArguments(revision).
|
|
AddDashesAndList(updatedFilenames...)
|
|
lsTreeStdout, _, err := cmd.RunStdBytes(&git.RunOpts{Dir: repo.RepoPath()})
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
changes.Updates, err = parseGitLsTreeOutput(lsTreeStdout)
|
|
return &changes, err
|
|
}
|