package server import ( "encoding/json" "io" "net/http" "os" "path/filepath" "strings" "gitlab.com/Timfa/bluegit/internal/access" "gitlab.com/Timfa/bluegit/internal/gitrepo" "gitlab.com/Timfa/bluegit/internal/i18n" "gitlab.com/Timfa/bluegit/internal/names" "gitlab.com/Timfa/bluegit/internal/store" "gitlab.com/Timfa/bluegit/internal/webhook" ) type releaseRequest struct { Tag string `json:"tag"` Commit string `json:"commit"` Name string `json:"name"` Body string `json:"body"` Assets []struct { Job string `json:"job"` Path string `json:"path"` Name string `json:"name"` } `json:"assets"` } func (s *Server) createRelease(w http.ResponseWriter, r *http.Request) { if s.StoragePath() == "" { http.Error(w, s.noStorageText(r), http.StatusServiceUnavailable) return } repo, err := s.Store.RepoByPath(r.Context(), r.PathValue("owner"), r.PathValue("repo")) if err != nil { http.NotFound(w, r) return } token := bearer(r) var job store.Job var author int64 var actor store.User if strings.HasPrefix(token, "bgj_") { job, err = s.Store.JobByToken(r.Context(), token) if err != nil || job.RepoID != repo.ID || job.Status != "running" { http.Error(w, s.tr(r, "err.jobToken"), http.StatusUnauthorized) return } } else if strings.HasPrefix(token, "bg_") { u, err := s.Store.UserByToken(r.Context(), token) if err != nil { http.Error(w, s.tr(r, "err.tokenBad"), http.StatusUnauthorized) return } role, err := s.Store.EffectiveRole(r.Context(), u.ID, repo.ID) if err != nil || !role.AtLeast(access.RoleMaintainer) { http.Error(w, s.tr(r, "err.onlyAdmin"), http.StatusForbidden) return } author = u.ID actor = u } else { http.Error(w, s.tr(r, "err.tokenAbsent"), http.StatusUnauthorized) return } var req releaseRequest if err := json.NewDecoder(io.LimitReader(r.Body, 1<<20)).Decode(&req); err != nil { http.Error(w, s.tr(r, "err.json"), http.StatusBadRequest) return } if err := names.ValidTag(req.Tag); err != nil { http.Error(w, s.trErr(r, err), http.StatusBadRequest) return } if !safeSHA(req.Commit) { http.Error(w, s.tr(r, "err.commitAbsent"), http.StatusBadRequest) return } dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name) if !gitrepo.HasCommit(r.Context(), s.Git, dir, req.Commit) { http.Error(w, s.tr(r, "err.commitMissing"), http.StatusBadRequest) return } if req.Name == "" { req.Name = req.Tag } if job.ID == 0 && len(req.Assets) > 0 { http.Error(w, s.tr(r, "err.assetsJob"), http.StatusBadRequest) return } var assets []store.ReleaseAsset for _, a := range req.Assets { if a.Name == "" { a.Name = filepath.Base(a.Path) } if err := names.ValidRepoName(strings.ReplaceAll(a.Name, ".", "x")); err != nil && strings.Contains(a.Name, "..") { http.Error(w, s.tr(r, "err.assetName"), http.StatusBadRequest) return } if strings.Contains(a.Name, "/") || strings.Contains(a.Name, "..") || a.Path == "" { http.Error(w, s.tr(r, "err.assetName"), http.StatusBadRequest) return } src, err := s.Store.ArtifactPath(r.Context(), job.PipelineID, a.Job, a.Path) if err != nil { http.Error(w, s.tr(r, "err.artifactMissing", a.Job, a.Path), http.StatusBadRequest) return } info, err := os.Stat(src) if err != nil { http.Error(w, s.tr(r, "err.assetDisk"), http.StatusBadRequest) return } dst := filepath.Join(s.StoragePath(), "releases", repo.OwnerPath, repo.Name, req.Tag, a.Name) if err := copyRelease(src, dst); err != nil { http.Error(w, s.tr(r, "err.assetCopy"), http.StatusInternalServerError) return } assets = append(assets, store.ReleaseAsset{Name: a.Name, StoragePath: dst, Size: info.Size()}) } if err := s.postReceive(r.Context(), repo, actor, dir, func() error { return gitrepo.Tag(r.Context(), s.Git, dir, req.Tag, req.Commit, req.Name) }); err != nil { http.Error(w, s.tr(r, "err.tagFail", err.Error()), http.StatusBadRequest) return } id, err := s.Store.CreateRelease(r.Context(), repo.ID, req.Tag, req.Commit, req.Name, req.Body, author, job.ID, assets) if err != nil { http.Error(w, s.trErr(r, err), http.StatusBadRequest) return } s.Dispatch(repo.ID, webhook.Event{ Type: webhook.EventRelease, Project: repo.FullPath(), Commit: req.Commit, ReleaseTag: req.Tag, Summary: i18n.T(i18n.EN, "hook.release", req.Tag, repo.FullPath()), URL: strings.TrimRight(s.Cfg.BaseURL, "/") + repoURL(repo) + "/-/releases", }) w.Header().Set("Content-Type", "application/json") w.WriteHeader(http.StatusCreated) _ = json.NewEncoder(w).Encode(map[string]any{"id": id, "tag": req.Tag, "commit": req.Commit}) } func (s *Server) releaseAsset(w http.ResponseWriter, r *http.Request) { _, repo, _, ok := s.guard(w, r, access.RoleReadonly) if !ok { return } rel, err := s.Store.ReleaseByTag(r.Context(), repo.ID, r.PathValue("tag")) if err != nil { http.NotFound(w, r) return } name := r.PathValue("name") for _, a := range rel.Assets { if a.Name == name { w.Header().Set("Content-Disposition", "attachment; filename=\""+strings.ReplaceAll(name, "\"", "")+"\"") http.ServeFile(w, r, a.StoragePath) return } } http.NotFound(w, r) } func bearer(r *http.Request) string { h := r.Header.Get("Authorization") if strings.HasPrefix(strings.ToLower(h), "bearer ") { return strings.TrimSpace(h[7:]) } return "" } func copyRelease(src, dst string) error { if err := os.MkdirAll(filepath.Dir(dst), 0o755); err != nil { return err } in, err := os.Open(src) if err != nil { return err } defer in.Close() out, err := os.OpenFile(dst, os.O_CREATE|os.O_TRUNC|os.O_WRONLY, 0o644) if err != nil { return err } defer out.Close() _, err = io.Copy(out, in) return err }