package gitea import ( "bytes" "context" "encoding/json" "errors" "fmt" "io" "net/http" "os" "os/exec" "regexp" "strings" "text/template" "time" "git.unistack.org/unistack-org/pkgdash/internal/configcli" "git.unistack.org/unistack-org/pkgdash/internal/modules" "github.com/go-git/go-git/v5" gitconfig "github.com/go-git/go-git/v5/config" "github.com/go-git/go-git/v5/plumbing" "github.com/go-git/go-git/v5/plumbing/object" httpauth "github.com/go-git/go-git/v5/plumbing/transport/http" "go.unistack.org/micro/v4/logger" ) var ( ErrPRExist = errors.New("pull request exists") ErrPRNotExist = errors.New("pull request does not exist") ) type Gitea struct { URL string Token string PRTitle string PRBody string Repository string Owner string } func NewGitea(cfg configcli.Config) *Gitea { return &Gitea{ URL: cfg.Source.APIURL, Token: os.Getenv("gitea_token"), PRTitle: cfg.PullRequestTitle, PRBody: cfg.PullRequestBody, Repository: cfg.Source.Repository, Owner: cfg.Source.Owner, } } type giteaPull struct { URL string `json:"url"` Title string `json:"title"` Base struct { Ref string `json:"ref"` } `json:"base"` Head struct { Ref string `json:"ref"` } `json:"head"` ID int64 `json:"id"` } func (g *Gitea) RequestOpen(ctx context.Context, branch string, path string, mod modules.Update) error { logger.Debugf(ctx, "RequestOpen start, mod title: %s", path) var buf []byte var err error // создания шаблона названия для пулл реквеста tplTitle, err := template.New("pull_request_title").Parse(g.PRTitle) if err != nil { logger.Fatal(ctx, "failed to parse template: %v", err) } wTitle := bytes.NewBuffer(nil) // создания шаблона тела для пулл реквеста tplBody, err := template.New("pull_request_body").Parse(g.PRTitle) if err != nil { logger.Fatal(ctx, "failed to parse template: %v", err) } wBody := bytes.NewBuffer(nil) data := map[string]string{ "Name": path, "VersionOld": mod.Module.Version, "VersionNew": mod.Version, } if err = tplTitle.Execute(wTitle, data); err != nil { logger.Fatal(ctx, "failed to execute template: %v", err) } if err = tplBody.Execute(wBody, data); err != nil { logger.Fatal(ctx, "failed to execute template: %v", err) } // открытие гит репозитория с опцией обхода репозитория для нахождения .git repo, err := git.PlainOpenWithOptions(".", &git.PlainOpenOptions{DetectDotGit: true}) if err != nil { logger.Fatal(ctx, "failed to open repo: %v", err) } //извлекаем ссылки с объектами из удаленного объекта?? if err = repo.FetchContext(ctx, &git.FetchOptions{ Auth: &httpauth.BasicAuth{Username: g.Token, Password: g.Token}, Force: true, }); err != nil && err != git.NoErrAlreadyUpToDate { logger.Fatal(ctx, "failed to fetch repo: %v", err) } //обновляем репозиторий var headRef *plumbing.Reference // вроде ссылка на гит refIter, err := repo.Branches() //получение веток if err != nil { logger.Fatal(ctx, "failed to get branches: %v", err) } for { ref, err := refIter.Next() if err != nil { break } if strings.Contains(ref.Name().String(), branch) { //todo вот тут возможно нужно переделать headRef = ref break } } //перебираем получение ветки и когда находим нужную выходим из цикла записав ветку в headRef refIter.Close() if headRef == nil { logger.Fatal(ctx, "failed to get repo branch head") } // Не получили нужную ветку logger.Info(ctx, "repo head %s", headRef) wtree, err := repo.Worktree() //todo вроде рабочее дерево не нужно if err != nil { logger.Fatal(ctx, "failed to get worktree: %v", err) } pulls, err := GetPulls(ctx, g.URL, g.Owner, g.Repository, g.Token) if err != nil && err != ErrPRNotExist { logger.Error(ctx, "GetPulls error: %s", err) return err } for _, pull := range pulls { if strings.Contains(pull.Title, path) && strings.Contains(pull.Base.Ref, branch) { logger.Info(ctx, "skip %s as pr already exists %s", path, pull.URL) return ErrPRExist } // хотим проверить есть ли пулл реквест для этой ветки, если есть то выходим } logger.Info(ctx, "update %s from %s to %s", path, mod.Module.Version, mod.Version) logger.Info(ctx, "reset worktree") if err = wtree.Reset(&git.ResetOptions{Mode: git.HardReset}); err != nil { logger.Fatal(ctx, "failed to reset repo branch: %v", err) } //вроде меняем ветку todo вроде можно удалить if err = wtree.PullContext(ctx, &git.PullOptions{ Auth: &httpauth.BasicAuth{Username: g.Token, Password: g.Token}, Depth: 1, // RemoteURL : Force: true, RemoteName: "origin", }); err != nil && err != git.NoErrAlreadyUpToDate { logger.Fatal(ctx, "failed to pull repo: %v", err) //подтягиваем изменения с удаленого репозитория } logger.Info(ctx, "checkout ref %s", headRef) if err = wtree.Checkout(&git.CheckoutOptions{ Hash: headRef.Hash(), Branch: plumbing.NewBranchReferenceName(fmt.Sprintf("pkgdash/go_modules/%s-%s", path, mod.Version)), Create: true, Force: true, }); err != nil { logger.Fatal(ctx, "failed to checkout tree: %v", err) } //создаем новую ветку epath, err := exec.LookPath("go") if errors.Is(err, exec.ErrDot) { err = nil } if err != nil { logger.Fatal(ctx, "failed to find go command: %v", err) } // ищем go файл var cmd *exec.Cmd var out []byte cmd = exec.CommandContext(ctx, epath, "mod", "edit", fmt.Sprintf("-droprequire=%s", mod.Module.Path)) if out, err = cmd.CombinedOutput(); err != nil { logger.Fatal(ctx, "failed to run go mod edit: %s err: %v", out, err) } cmd = exec.CommandContext(ctx, epath, "mod", "edit", fmt.Sprintf("-require=%s@%s", path, mod.Version)) if out, err = cmd.CombinedOutput(); err != nil { logger.Fatal(ctx, "failed to run go mod edit: %s err: %v", out, err) } // пытаемся выполнить команду go mod edit с новой версией модуля cmd = exec.CommandContext(ctx, epath, "mod", "tidy") if out, err = cmd.CombinedOutput(); err != nil { logger.Fatal(ctx, "failed to run go mod tidy: %s err: %v", out, err) } // пытаемся выполнить команду go mod tidy пытаемся подтянуть новую версию модуля logger.Info(ctx, "worktree add go.mod") if _, err = wtree.Add("go.mod"); err != nil { logger.Fatal(ctx, "failed to add file: %v", err) } logger.Info(ctx, "worktree add go.sum") if _, err = wtree.Add("go.sum"); err != nil { logger.Fatal(ctx, "failed to add file: %v", err) } logger.Info(ctx, "worktree commit") _, err = wtree.Commit(wTitle.String(), &git.CommitOptions{ Parents: []plumbing.Hash{headRef.Hash()}, Author: &object.Signature{ Name: "gitea-actions", Email: "info@unistack.org", When: time.Now(), }, }) // хотим за коммитить изменения if err != nil { logger.Fatal(ctx, "failed to commit: %v", err) } refspec := gitconfig.RefSpec(fmt.Sprintf("+refs/heads/pkgdash/go_modules/%s-%s:refs/heads/pkgdash/go_modules/%s-%s", path, mod.Version, path, mod.Version)) //todo как будто нужно переделать logger.Info(ctx, "try to push refspec %s", refspec) if err = repo.PushContext(ctx, &git.PushOptions{ RefSpecs: []gitconfig.RefSpec{refspec}, Auth: &httpauth.BasicAuth{Username: g.Token, Password: g.Token}, Force: true, }); err != nil { logger.Fatal(ctx, "failed to push repo branch: %v", err) } // пытаемся за пушить изменения body := map[string]string{ "base": branch, "body": wBody.String(), "head": fmt.Sprintf("pkgdash/go_modules/%s-%s", path, mod.Version), "title": wTitle.String(), } logger.Info(ctx, "raw body: %#+v", body) buf, err = json.Marshal(body) if err != nil { return err } logger.Info(ctx, "marshal body: %s", buf) req, err := http.NewRequestWithContext( ctx, http.MethodPost, fmt.Sprintf("%s/repos/%s/%s/pulls?token=%s", g.URL, g.Owner, g.Repository, g.Token), bytes.NewReader(buf), ) if err != nil { return err } req.Header.Add("Accept", "application/json") req.Header.Add("Content-Type", "application/json") rsp, err := http.DefaultClient.Do(req) if err != nil { return err } //Вроде создаем новый реквест на создание пулл реквеста if rsp.StatusCode != http.StatusCreated { buf, _ = io.ReadAll(rsp.Body) return fmt.Errorf("unknown error: %s", buf) } logger.Info(ctx, "PR create for %s-%s", path, mod.Version) return nil } func (g *Gitea) RequestClose(ctx context.Context, branch string, path string) error { logger.Debugf(ctx, "RequestClose start, mod title: %s", path) pulls, err := GetPulls(ctx, g.URL, g.Owner, g.Repository, g.Token) if err != nil { logger.Error(ctx, "GetPulls error: %s", err) return err } prExist := false var b string // Name of the branch to be deleted for _, pull := range pulls { if strings.Contains(pull.Title, path) && pull.Base.Ref == branch { logger.Info(ctx, "PR for %s exists: %s", path, pull.URL) prExist = true b = pull.Head.Ref } } if !prExist { logger.Error(ctx, " skip %s since pr does not exist", path) return ErrPRNotExist } req, err := DeleteBranch(ctx, g.URL, g.Owner, g.Repository, b, g.Token) if err != nil { logger.Error(ctx, "failed to create request for delete the branch: %s, err: %s", branch, err) return err } rsp, err := http.DefaultClient.Do(req) if err != nil { logger.Error(ctx, "failed to do request for delete the branch: %s, err: %s, code: %s", branch, err, rsp.StatusCode) return err } logger.Info(ctx, "Delete branch for %s successful", path) return nil } func (g *Gitea) RequestUpdate(ctx context.Context, branch string, path string, mod modules.Update) error { logger.Debugf(ctx, "RequestUpdate start, mod title: %s", path) pulls, err := GetPulls(ctx, g.URL, g.Owner, g.Repository, g.Token) if err != nil { logger.Error(ctx, "GetPulls error: %s", err) return err } prExist := false for _, pull := range pulls { if strings.Contains(pull.Title, path) && pull.Base.Ref == branch { logger.Info(ctx, "don't skip %s since pr exist %s", path, pull.URL) //todo tVersion := getVersions(pull.Head.Ref) //Надо взять просто из названия ветки последнюю версию if modules.IsNewerVersion(tVersion, mod.Version, false) { reqDel, err := DeleteBranch(ctx, g.URL, g.Owner, g.Repository, pull.Head.Ref, g.Token) if err != nil { logger.Error(ctx, "Error with create request for branch: %s, err: %s", branch, err) continue } rsp, err := http.DefaultClient.Do(reqDel) if err != nil { logger.Error(ctx, "Error with do request for branch: %s, err: %s, code: %v", branch, err, rsp.StatusCode) continue //думаю что если не можем удалить ветку не стоит заканчивать работу, а перейти к следующей итерации } logger.Info(ctx, "Old pr %s successful delete", pull.Head.Ref) } prExist = true } } if !prExist { logger.Error(ctx, " skip %s since pr does not exist", path) return ErrPRNotExist } logger.Info(ctx, "update %s from %s to %s", path, mod.Module.Version, mod.Version) return g.RequestOpen(ctx, branch, path, mod) } func getVersions(s string) string { re := regexp.MustCompile("[vV][0-9]+\\.[0-9]+\\.[0-9]+") version := re.FindString(s) return version } func DeleteBranch(ctx context.Context, url, owner, repo, branch, token string) (*http.Request, error) { var buf []byte req, err := http.NewRequestWithContext(ctx, http.MethodDelete, fmt.Sprintf("%s/repos/%s/%s/branches/%s?token=%s", url, owner, repo, branch, token), bytes.NewReader(buf)) if err != nil { return nil, err } req.Header.Add("Accept", "application/json") req.Header.Add("Content-Type", "application/json") return req, err } func GetPulls(ctx context.Context, url, owner, repo, token string) ([]*giteaPull, error) { var pulls []*giteaPull var err error req, err := http.NewRequestWithContext( ctx, http.MethodGet, fmt.Sprintf("%s/repos/%s/%s/pulls?state=open&token=%s", url, owner, repo, token), nil) if err != nil { return nil, err } //вроде запроса к репозиторию req.Header.Add("Accept", "application/json") req.Header.Add("Content-Type", "application/json") rsp, err := http.DefaultClient.Do(req) // выполнение запроса if err != nil { return nil, err } buf, _ := io.ReadAll(rsp.Body) switch rsp.StatusCode { case http.StatusOK: if err = json.Unmarshal(buf, &pulls); err != nil { logger.Fatal(ctx, "failed to decode response %s err: %v", buf, err) return nil, err } return pulls, nil case http.StatusNotFound: logger.Info(ctx, "PL is not exist for %s", repo) return nil, ErrPRNotExist default: return nil, fmt.Errorf("unknown error: %s", buf) } }