diff --git a/apiserver/controllers/common.go b/apiserver/controllers/common.go new file mode 100644 index 000000000..621644078 --- /dev/null +++ b/apiserver/controllers/common.go @@ -0,0 +1,57 @@ +package controllers + +import ( + "encoding/json" + "log/slog" + "net/http" + + apiParams "github.com/cloudbase/garm/apiserver/params" + "github.com/cloudbase/garm/params" + "github.com/gorilla/mux" +) + +func (a *APIController) GetRepository(w http.ResponseWriter, r *http.Request) (params.Repository, bool) { + vars := mux.Vars(r) + owner, hasOwner := vars["owner"] + repo, hasRepo := vars["repo"] + if !(hasOwner && hasRepo) { + w.WriteHeader(http.StatusBadRequest) + if err := json.NewEncoder(w).Encode(apiParams.APIErrorResponse{ + Error: "Bad Request", + Details: "No repo ID specified", + }); err != nil { + slog.With(slog.Any("error", err)).ErrorContext(r.Context(), "failed to encode response") + } + return params.Repository{}, false + } + repoObj, err := a.r.ResolveRepository(r.Context(), owner, repo, r.URL.Query().Get("endpointName")) + if err != nil { + slog.With(slog.Any("error", err)).ErrorContext(r.Context(), "resolving repository") + handleError(r.Context(), w, err) + return params.Repository{}, false + } + return repoObj, true +} + +func (a *APIController) GetRepositoryID(w http.ResponseWriter, r *http.Request) (string, bool) { + vars := mux.Vars(r) + owner, hasOwner := vars["owner"] + repo, hasRepo := vars["repo"] + if !(hasOwner && hasRepo) { + w.WriteHeader(http.StatusBadRequest) + if err := json.NewEncoder(w).Encode(apiParams.APIErrorResponse{ + Error: "Bad Request", + Details: "No repo ID specified", + }); err != nil { + slog.With(slog.Any("error", err)).ErrorContext(r.Context(), "failed to encode response") + } + return "", false + } + repoObj, err := a.r.ResolveRepository(r.Context(), owner, repo, r.URL.Query().Get("endpointName")) + if err != nil { + slog.With(slog.Any("error", err)).ErrorContext(r.Context(), "resolving repository") + handleError(r.Context(), w, err) + return "", false + } + return repoObj.ID, true +} diff --git a/apiserver/controllers/instances.go b/apiserver/controllers/instances.go index 3209a5c2b..e4bff8a89 100644 --- a/apiserver/controllers/instances.go +++ b/apiserver/controllers/instances.go @@ -254,6 +254,52 @@ func (a *APIController) ListRepoInstancesHandler(w http.ResponseWriter, r *http. } } +// swagger:route GET /repositories/{owner}/{repo}/instances repositories instances ListRepoInstancesByFriendlyName +// +// List repository instances. +// +// Parameters: +// + name: owner +// description: Repository owner. +// type: string +// in: path +// required: true +// +// + name: repo +// description: Repository name. +// type: string +// in: path +// required: true +// +// + name: endpointName +// description: Repository endpointName. +// type: string +// in: query +// +// Responses: +// 200: Instances +// default: APIErrorResponse +func (a *APIController) ListRepoInstancesByFriendlyNameHandler(w http.ResponseWriter, r *http.Request) { + ctx := r.Context() + + repoID, ok := a.GetRepositoryID(w, r) + if !ok { + return + } + + instances, err := a.r.ListRepoInstances(ctx, repoID) + if err != nil { + slog.With(slog.Any("error", err)).ErrorContext(ctx, "listing pools") + handleError(ctx, w, err) + return + } + + w.Header().Set("Content-Type", "application/json") + if err := json.NewEncoder(w).Encode(instances); err != nil { + slog.With(slog.Any("error", err)).ErrorContext(ctx, "failed to encode response") + } +} + // swagger:route GET /organizations/{orgID}/instances organizations instances ListOrgInstances // // List organization instances. diff --git a/apiserver/controllers/repositories.go b/apiserver/controllers/repositories.go index 2eea0001a..c1f8457a8 100644 --- a/apiserver/controllers/repositories.go +++ b/apiserver/controllers/repositories.go @@ -722,3 +722,710 @@ func (a *APIController) GetRepoWebhookInfoHandler(w http.ResponseWriter, r *http slog.With(slog.Any("error", err)).ErrorContext(ctx, "failed to encode response") } } + +// swagger:route GET /repositories/{owner}/{repo} Repositories GetRepoByFriendlyName +// +// Get repository by name. +// +// Parameters: +// + name: owner +// description: owner of the repository to fetch. +// type: string +// in: path +// required: true +// +// + name: repo +// description: name of the repository to fetch. +// type: string +// in: path +// required: true +// +// + name: endpointName +// description: endpointName of the repository to fetch. +// type: string +// in: query +// +// Responses: +// 200: Repository +// default: APIErrorResponse +func (a *APIController) GetRepoByFriendlyNameHandler(w http.ResponseWriter, r *http.Request) { + ctx := r.Context() + + repo, ok := a.GetRepository(w, r) + if !ok { + return + } + + w.Header().Set("Content-Type", "application/json") + if err := json.NewEncoder(w).Encode(repo); err != nil { + slog.With(slog.Any("error", err)).ErrorContext(ctx, "failed to encode response") + } +} + +// swagger:route DELETE /repositories/{owner}/{repo} Repositories DeleteRepoByFriendlyName +// +// Delete repository by ID. +// +// Parameters: +// + name: owner +// description: owner of the repository to delete. +// type: string +// in: path +// required: true +// +// + name: repo +// description: name of the repository to delete. +// type: string +// in: path +// required: true +// +// + name: endpointName +// description: endpointName of the repository to delete. +// type: string +// in: query +// +// + name: keepWebhook +// description: If true and a webhook is installed for this repo, it will not be removed. +// type: boolean +// in: query +// required: false +// +// Responses: +// default: APIErrorResponse +func (a *APIController) DeleteRepoByFriendlyNameHandler(w http.ResponseWriter, r *http.Request) { + ctx := r.Context() + + repoID, ok := a.GetRepositoryID(w, r) + if !ok { + return + } + + keepWebhook, _ := strconv.ParseBool(r.URL.Query().Get("keepWebhook")) + if err := a.r.DeleteRepository(ctx, repoID, keepWebhook); err != nil { + slog.With(slog.Any("error", err)).ErrorContext(ctx, "fetching repository") + handleError(ctx, w, err) + return + } + + w.Header().Set("Content-Type", "application/json") + w.WriteHeader(http.StatusOK) +} + +// swagger:route PUT /repositories/{owner}/{repo} Repositories UpdateRepoByFriendlyName +// +// Update repository with the parameters given. +// +// Parameters: +// + name: owner +// description: owner of the repository to update. +// type: string +// in: path +// required: true +// +// + name: repo +// description: name of the repository to update. +// type: string +// in: path +// required: true +// +// + name: endpointName +// description: endpointName of the repository to update. +// type: string +// in: query +// +// + name: Body +// description: Parameters used when updating the repository. +// type: UpdateEntityParams +// in: body +// required: true +// +// Responses: +// 200: Repository +// default: APIErrorResponse +func (a *APIController) UpdateRepoByFriendlyNameHandler(w http.ResponseWriter, r *http.Request) { + ctx := r.Context() + + var updatePayload runnerParams.UpdateEntityParams + if err := json.NewDecoder(r.Body).Decode(&updatePayload); err != nil { + handleError(ctx, w, gErrors.ErrBadRequest) + return + } + + repoID, ok := a.GetRepositoryID(w, r) + if !ok { + return + } + + repo, err := a.r.UpdateRepository(ctx, repoID, updatePayload) + if err != nil { + slog.With(slog.Any("error", err)).ErrorContext(ctx, "error updating repository") + handleError(ctx, w, err) + return + } + + w.Header().Set("Content-Type", "application/json") + if err := json.NewEncoder(w).Encode(repo); err != nil { + slog.With(slog.Any("error", err)).ErrorContext(ctx, "failed to encode response") + } +} + +// swagger:route POST /repositories/{owner}/{repo}/pools Repositories pools CreateRepoPoolByFriendlyName +// +// Create repository pool with the parameters given. +// +// Parameters: +// + name: owner +// description: Repository owner. +// type: string +// in: path +// required: true +// +// + name: repo +// description: Repository name. +// type: string +// in: path +// required: true +// +// + name: endpointName +// description: Repository endpointName. +// type: string +// in: query +// +// + name: Body +// description: Parameters used when creating the repository pool. +// type: CreatePoolParams +// in: body +// required: true +// +// Responses: +// 200: Pool +// default: APIErrorResponse +func (a *APIController) CreateRepoPoolByFriendlyNameHandler(w http.ResponseWriter, r *http.Request) { + ctx := r.Context() + + var poolData runnerParams.CreatePoolParams + if err := json.NewDecoder(r.Body).Decode(&poolData); err != nil { + slog.With(slog.Any("error", err)).ErrorContext(ctx, "failed to decode") + handleError(ctx, w, gErrors.ErrBadRequest) + return + } + + repoID, ok := a.GetRepositoryID(w, r) + if !ok { + return + } + + pool, err := a.r.CreateRepoPool(ctx, repoID, poolData) + if err != nil { + slog.With(slog.Any("error", err)).ErrorContext(ctx, "error creating repository pool") + handleError(ctx, w, err) + return + } + + w.Header().Set("Content-Type", "application/json") + if err := json.NewEncoder(w).Encode(pool); err != nil { + slog.With(slog.Any("error", err)).ErrorContext(ctx, "failed to encode response") + } +} + +// swagger:route POST /repositories/{owner}/{repo}/scalesets Repositories scalesets CreateRepoScaleSetByFriendlyName +// +// Create repository scale set with the parameters given. +// +// Parameters: +// + name: owner +// description: Repository owner. +// type: string +// in: path +// required: true +// +// + name: repo +// description: Repository name. +// type: string +// in: path +// required: true +// +// + name: endpointName +// description: Repository endpointName. +// type: string +// in: query +// +// + name: Body +// description: Parameters used when creating the repository scale set. +// type: CreateScaleSetParams +// in: body +// required: true +// +// Responses: +// 200: ScaleSet +// default: APIErrorResponse +func (a *APIController) CreateRepoScaleSetByFriendlyNameHandler(w http.ResponseWriter, r *http.Request) { + ctx := r.Context() + + var scaleSetData runnerParams.CreateScaleSetParams + if err := json.NewDecoder(r.Body).Decode(&scaleSetData); err != nil { + slog.With(slog.Any("error", err)).ErrorContext(ctx, "failed to decode") + handleError(ctx, w, gErrors.ErrBadRequest) + return + } + + repoID, ok := a.GetRepositoryID(w, r) + if !ok { + return + } + + scaleSet, err := a.r.CreateEntityScaleSet(ctx, runnerParams.ForgeEntityTypeRepository, repoID, scaleSetData) + if err != nil { + slog.With(slog.Any("error", err)).ErrorContext(ctx, "error creating repository scale set") + handleError(ctx, w, err) + return + } + + w.Header().Set("Content-Type", "application/json") + if err := json.NewEncoder(w).Encode(scaleSet); err != nil { + slog.With(slog.Any("error", err)).ErrorContext(ctx, "failed to encode response") + } +} + +// swagger:route GET /repositories/{owner}/{repo}/pools Repositories pools ListRepoPoolsByFriendlyName +// +// List repository pools. +// +// Parameters: +// + name: owner +// description: Repository owner. +// type: string +// in: path +// required: true +// +// + name: repo +// description: Repository name. +// type: string +// in: path +// required: true +// +// + name: endpointName +// description: Repository endpointName. +// type: string +// in: query +// +// Responses: +// 200: Pools +// default: APIErrorResponse +func (a *APIController) ListRepoPoolsByFriendlyNameHandler(w http.ResponseWriter, r *http.Request) { + ctx := r.Context() + + repo, ok := a.GetRepository(w, r) + if !ok { + return + } + + pools, err := a.r.ListRepoPools(ctx, repo.ID) + if err != nil { + slog.With(slog.Any("error", err)).ErrorContext(ctx, "listing pools") + handleError(ctx, w, err) + return + } + + w.Header().Set("Content-Type", "application/json") + if err := json.NewEncoder(w).Encode(pools); err != nil { + slog.With(slog.Any("error", err)).ErrorContext(ctx, "failed to encode response") + } +} + +// swagger:route GET /repositories/{owner}/{repo}/scalesets Repositories scalesets ListRepoScaleSetsByFriendlyName +// +// List repository scale sets. +// +// Parameters: +// + name: owner +// description: Repository owner. +// type: string +// in: path +// required: true +// +// + name: repo +// description: Repository name. +// type: string +// in: path +// required: true +// +// + name: endpointName +// description: Repository endpointName. +// type: string +// in: query +// +// Responses: +// 200: ScaleSets +// default: APIErrorResponse +func (a *APIController) ListRepoScaleSetsByFriendlyNameHandler(w http.ResponseWriter, r *http.Request) { + ctx := r.Context() + + repo, ok := a.GetRepository(w, r) + if !ok { + return + } + + scaleSets, err := a.r.ListEntityScaleSets(ctx, runnerParams.ForgeEntityTypeRepository, repo.ID) + if err != nil { + slog.With(slog.Any("error", err)).ErrorContext(ctx, "listing scale sets") + handleError(ctx, w, err) + return + } + + w.Header().Set("Content-Type", "application/json") + if err := json.NewEncoder(w).Encode(scaleSets); err != nil { + slog.With(slog.Any("error", err)).ErrorContext(ctx, "failed to encode response") + } +} + +// swagger:route GET /repositories/{owner}/{repo}/pools/{poolID} Repositories pools GetRepoPoolByFriendlyName +// +// Get repository pool by ID. +// +// Parameters: +// + name: owner +// description: Repository owner. +// type: string +// in: path +// required: true +// +// + name: repo +// description: Repository name. +// type: string +// in: path +// required: true +// +// + name: endpointName +// description: Repository endpointName. +// type: string +// in: query +// +// + name: poolID +// description: Pool ID. +// type: string +// in: path +// required: true +// +// Responses: +// 200: Pool +// default: APIErrorResponse +func (a *APIController) GetRepoPoolByFriendlyNameHandler(w http.ResponseWriter, r *http.Request) { + ctx := r.Context() + vars := mux.Vars(r) + poolID, poolOk := vars["poolID"] + if !poolOk { + w.WriteHeader(http.StatusBadRequest) + if err := json.NewEncoder(w).Encode(params.APIErrorResponse{ + Error: "Bad Request", + Details: "No pool ID specified", + }); err != nil { + slog.With(slog.Any("error", err)).ErrorContext(ctx, "failed to encode response") + } + return + } + + repoID, ok := a.GetRepositoryID(w, r) + if !ok { + return + } + + pool, err := a.r.GetRepoPoolByID(ctx, repoID, poolID) + if err != nil { + slog.With(slog.Any("error", err)).ErrorContext(ctx, "listing pools") + handleError(ctx, w, err) + return + } + + w.Header().Set("Content-Type", "application/json") + if err := json.NewEncoder(w).Encode(pool); err != nil { + slog.With(slog.Any("error", err)).ErrorContext(ctx, "failed to encode response") + } +} + +// swagger:route DELETE /repositories/{owner}/{repo}/pools/{poolID} Repositories pools DeleteRepoPoolByFriendlyName +// +// Delete repository pool by ID. +// +// Parameters: +// + name: owner +// description: Repository owner. +// type: string +// in: path +// required: true +// +// + name: repo +// description: Repository name. +// type: string +// in: path +// required: true +// +// + name: endpointName +// description: Repository endpointName. +// type: string +// in: query +// +// + name: poolID +// description: ID of the repository pool to delete. +// type: string +// in: path +// required: true +// +// Responses: +// default: APIErrorResponse +func (a *APIController) DeleteRepoPoolByFriendlyNameHandler(w http.ResponseWriter, r *http.Request) { + ctx := r.Context() + + vars := mux.Vars(r) + poolID, poolOk := vars["poolID"] + if !poolOk { + w.WriteHeader(http.StatusBadRequest) + if err := json.NewEncoder(w).Encode(params.APIErrorResponse{ + Error: "Bad Request", + Details: "No pool ID specified", + }); err != nil { + slog.With(slog.Any("error", err)).ErrorContext(ctx, "failed to encode response") + } + return + } + + repoID, ok := a.GetRepositoryID(w, r) + if !ok { + return + } + + if err := a.r.DeleteRepoPool(ctx, repoID, poolID); err != nil { + slog.With(slog.Any("error", err)).ErrorContext(ctx, "removing pool") + handleError(ctx, w, err) + return + } + + w.Header().Set("Content-Type", "application/json") + w.WriteHeader(http.StatusOK) +} + +// swagger:route PUT /repositories/{owner}/{repo}/pools/{poolID} repositories pools UpdateRepoPoolByFriendlyName +// +// Update repository pool with the parameters given. +// +// Parameters: +// + name: owner +// description: Repository owner. +// type: string +// in: path +// required: true +// +// + name: repo +// description: Repository name. +// type: string +// in: path +// required: true +// +// + name: endpointName +// description: Repository endpointName. +// type: string +// in: query +// +// + name: poolID +// description: ID of the repository pool to update. +// type: string +// in: path +// required: true +// +// + name: Body +// description: Parameters used when updating the repository pool. +// type: UpdatePoolParams +// in: body +// required: true +// +// Responses: +// 200: Pool +// default: APIErrorResponse +func (a *APIController) UpdateRepoPoolByFriendlyNameHandler(w http.ResponseWriter, r *http.Request) { + ctx := r.Context() + + vars := mux.Vars(r) + poolID, poolOk := vars["poolID"] + if !poolOk { + w.WriteHeader(http.StatusBadRequest) + if err := json.NewEncoder(w).Encode(params.APIErrorResponse{ + Error: "Bad Request", + Details: "No pool ID specified", + }); err != nil { + slog.With(slog.Any("error", err)).ErrorContext(ctx, "failed to encode response") + } + return + } + + var poolData runnerParams.UpdatePoolParams + if err := json.NewDecoder(r.Body).Decode(&poolData); err != nil { + slog.With(slog.Any("error", err)).ErrorContext(ctx, "failed to decode") + handleError(ctx, w, gErrors.ErrBadRequest) + return + } + + repoID, ok := a.GetRepositoryID(w, r) + if !ok { + return + } + + pool, err := a.r.UpdateRepoPool(ctx, repoID, poolID, poolData) + if err != nil { + slog.With(slog.Any("error", err)).ErrorContext(ctx, "error creating repository pool") + handleError(ctx, w, err) + return + } + + w.Header().Set("Content-Type", "application/json") + if err := json.NewEncoder(w).Encode(pool); err != nil { + slog.With(slog.Any("error", err)).ErrorContext(ctx, "failed to encode response") + } +} + +// swagger:route POST /repositories/{owner}/{repo}/webhook Repositories hooks InstallRepoWebhookByFriendlyName +// +// Install the GARM webhook for an organization. The secret configured on the organization will +// be used to validate the requests. +// +// Parameters: +// + name: owner +// description: Repository owner. +// type: string +// in: path +// required: true +// +// + name: repo +// description: Repository name. +// type: string +// in: path +// required: true +// +// + name: endpointName +// description: Repository endpointName. +// type: string +// in: query +// +// + name: Body +// description: Parameters used when creating the repository webhook. +// type: InstallWebhookParams +// in: body +// required: true +// +// Responses: +// 200: HookInfo +// default: APIErrorResponse +func (a *APIController) InstallRepoWebhookByFriendlyNameHandler(w http.ResponseWriter, r *http.Request) { + ctx := r.Context() + + var hookParam runnerParams.InstallWebhookParams + if err := json.NewDecoder(r.Body).Decode(&hookParam); err != nil { + slog.With(slog.Any("error", err)).ErrorContext(ctx, "failed to decode") + handleError(ctx, w, gErrors.ErrBadRequest) + return + } + + repoID, ok := a.GetRepositoryID(w, r) + if !ok { + return + } + + info, err := a.r.InstallRepoWebhook(ctx, repoID, hookParam) + if err != nil { + slog.With(slog.Any("error", err)).ErrorContext(ctx, "installing webhook") + handleError(ctx, w, err) + return + } + + w.Header().Set("Content-Type", "application/json") + if err := json.NewEncoder(w).Encode(info); err != nil { + slog.With(slog.Any("error", err)).ErrorContext(ctx, "failed to encode response") + } +} + +// swagger:route DELETE /repositories/{owner}/{repo}/webhook Repositories hooks UninstallRepoWebhookByFriendlyName +// +// Uninstall organization webhook. +// +// Parameters: +// + name: owner +// description: Repository owner. +// type: string +// in: path +// required: true +// +// + name: repo +// description: Repository name. +// type: string +// in: path +// required: true +// +// + name: endpointName +// description: Repository endpointName. +// type: string +// in: query +// +// Responses: +// default: APIErrorResponse +func (a *APIController) UninstallRepoWebhookByFriendlyNameHandler(w http.ResponseWriter, r *http.Request) { + ctx := r.Context() + + repo, ok := a.GetRepository(w, r) + if !ok { + return + } + + if err := a.r.UninstallRepoWebhook(ctx, repo.ID); err != nil { + slog.With(slog.Any("error", err)).ErrorContext(ctx, "removing webhook") + handleError(ctx, w, err) + return + } + + w.Header().Set("Content-Type", "application/json") + w.WriteHeader(http.StatusOK) +} + +// swagger:route GET /repositories/{owner}/{repo}/webhook Repositories hooks GetRepoWebhookInfoByFriendlyName +// +// Get information about the GARM installed webhook on a repository. +// +// Parameters: +// + name: owner +// description: Repository owner. +// type: string +// in: path +// required: true +// +// + name: repo +// description: Repository name. +// type: string +// in: path +// required: true +// +// + name: endpointName +// description: Repository endpointName. +// type: string +// in: query +// +// Responses: +// 200: HookInfo +// default: APIErrorResponse +func (a *APIController) GetRepoWebhookInfoByFriendlyNameHandler(w http.ResponseWriter, r *http.Request) { + ctx := r.Context() + + repo, ok := a.GetRepository(w, r) + if !ok { + return + } + + info, err := a.r.GetRepoWebhookInfo(ctx, repo.ID) + if err != nil { + slog.With(slog.Any("error", err)).ErrorContext(ctx, "getting webhook info") + handleError(ctx, w, err) + return + } + + w.Header().Set("Content-Type", "application/json") + if err := json.NewEncoder(w).Encode(info); err != nil { + slog.With(slog.Any("error", err)).ErrorContext(ctx, "failed to encode response") + } +} diff --git a/apiserver/routers/routers.go b/apiserver/routers/routers.go index 2036b5f14..7bf376d3c 100644 --- a/apiserver/routers/routers.go +++ b/apiserver/routers/routers.go @@ -251,41 +251,81 @@ func NewAPIRouter(han *controllers.APIController, authMiddleware, initMiddleware ///////////////////// // Get pool apiRouter.Handle("/repositories/{repoID}/pools/{poolID}/", http.HandlerFunc(han.GetRepoPoolHandler)).Methods("GET", "OPTIONS") + apiRouter.Handle("/repositories/{owner}/{repo}/pools/{poolID}/", http.HandlerFunc(han.GetRepoPoolByFriendlyNameHandler)).Methods("GET", "OPTIONS") apiRouter.Handle("/repositories/{repoID}/pools/{poolID}", http.HandlerFunc(han.GetRepoPoolHandler)).Methods("GET", "OPTIONS") + apiRouter.Handle("/repositories/{owner}/{repo}/pools/{poolID}", http.HandlerFunc(han.GetRepoPoolByFriendlyNameHandler)).Methods("GET", "OPTIONS") // Delete pool apiRouter.Handle("/repositories/{repoID}/pools/{poolID}/", http.HandlerFunc(han.DeleteRepoPoolHandler)).Methods("DELETE", "OPTIONS") + apiRouter.Handle("/repositories/{owner}/{repo}/pools/{poolID}/", http.HandlerFunc(han.DeleteRepoPoolByFriendlyNameHandler)).Methods("DELETE", "OPTIONS") apiRouter.Handle("/repositories/{repoID}/pools/{poolID}", http.HandlerFunc(han.DeleteRepoPoolHandler)).Methods("DELETE", "OPTIONS") + apiRouter.Handle("/repositories/{owner}/{repo}/pools/{poolID}", http.HandlerFunc(han.DeleteRepoPoolByFriendlyNameHandler)).Methods("DELETE", "OPTIONS") // Update pool apiRouter.Handle("/repositories/{repoID}/pools/{poolID}/", http.HandlerFunc(han.UpdateRepoPoolHandler)).Methods("PUT", "OPTIONS") + apiRouter.Handle("/repositories/{owner}/{repo}/pools/{poolID}/", http.HandlerFunc(han.UpdateRepoPoolByFriendlyNameHandler)).Methods("PUT", "OPTIONS") apiRouter.Handle("/repositories/{repoID}/pools/{poolID}", http.HandlerFunc(han.UpdateRepoPoolHandler)).Methods("PUT", "OPTIONS") + apiRouter.Handle("/repositories/{owner}/{repo}/pools/{poolID}", http.HandlerFunc(han.UpdateRepoPoolByFriendlyNameHandler)).Methods("PUT", "OPTIONS") // List pools apiRouter.Handle("/repositories/{repoID}/pools/", http.HandlerFunc(han.ListRepoPoolsHandler)).Methods("GET", "OPTIONS") + apiRouter.Handle("/repositories/{owner}/{repo}/pools/", http.HandlerFunc(han.ListRepoPoolsByFriendlyNameHandler)).Methods("GET", "OPTIONS") apiRouter.Handle("/repositories/{repoID}/pools", http.HandlerFunc(han.ListRepoPoolsHandler)).Methods("GET", "OPTIONS") + apiRouter.Handle("/repositories/{owner}/{repo}/pools", http.HandlerFunc(han.ListRepoPoolsByFriendlyNameHandler)).Methods("GET", "OPTIONS") // Create pool apiRouter.Handle("/repositories/{repoID}/pools/", http.HandlerFunc(han.CreateRepoPoolHandler)).Methods("POST", "OPTIONS") + apiRouter.Handle("/repositories/{owner}/{repo}/pools/", http.HandlerFunc(han.CreateRepoPoolByFriendlyNameHandler)).Methods("POST", "OPTIONS") apiRouter.Handle("/repositories/{repoID}/pools", http.HandlerFunc(han.CreateRepoPoolHandler)).Methods("POST", "OPTIONS") + apiRouter.Handle("/repositories/{owner}/{repo}/pools", http.HandlerFunc(han.CreateRepoPoolByFriendlyNameHandler)).Methods("POST", "OPTIONS") // Create scale set apiRouter.Handle("/repositories/{repoID}/scalesets/", http.HandlerFunc(han.CreateRepoScaleSetHandler)).Methods("POST", "OPTIONS") + apiRouter.Handle("/repositories/{owner}/{repo}/scalesets/", http.HandlerFunc(han.CreateRepoScaleSetByFriendlyNameHandler)).Methods("POST", "OPTIONS") apiRouter.Handle("/repositories/{repoID}/scalesets", http.HandlerFunc(han.CreateRepoScaleSetHandler)).Methods("POST", "OPTIONS") + apiRouter.Handle("/repositories/{owner}/{repo}/scalesets", http.HandlerFunc(han.CreateRepoScaleSetByFriendlyNameHandler)).Methods("POST", "OPTIONS") // List scale sets apiRouter.Handle("/repositories/{repoID}/scalesets/", http.HandlerFunc(han.ListRepoScaleSetsHandler)).Methods("GET", "OPTIONS") + apiRouter.Handle("/repositories/{owner}/{repo}/scalesets/", http.HandlerFunc(han.ListRepoScaleSetsByFriendlyNameHandler)).Methods("GET", "OPTIONS") apiRouter.Handle("/repositories/{repoID}/scalesets", http.HandlerFunc(han.ListRepoScaleSetsHandler)).Methods("GET", "OPTIONS") + apiRouter.Handle("/repositories/{owner}/{repo}/scalesets", http.HandlerFunc(han.ListRepoScaleSetsByFriendlyNameHandler)).Methods("GET", "OPTIONS") // Repo instances list apiRouter.Handle("/repositories/{repoID}/instances/", http.HandlerFunc(han.ListRepoInstancesHandler)).Methods("GET", "OPTIONS") + apiRouter.Handle("/repositories/{owner}/{repo}/instances/", http.HandlerFunc(han.ListRepoInstancesByFriendlyNameHandler)).Methods("GET", "OPTIONS") apiRouter.Handle("/repositories/{repoID}/instances", http.HandlerFunc(han.ListRepoInstancesHandler)).Methods("GET", "OPTIONS") + apiRouter.Handle("/repositories/{owner}/{repo}/instances", http.HandlerFunc(han.ListRepoInstancesByFriendlyNameHandler)).Methods("GET", "OPTIONS") + + if manageWebhooks { + // Install Webhook + apiRouter.Handle("/repositories/{repoID}/webhook/", http.HandlerFunc(han.InstallRepoWebhookHandler)).Methods("POST", "OPTIONS") + apiRouter.Handle("/repositories/{owner}/{repo}/webhook/", http.HandlerFunc(han.InstallRepoWebhookByFriendlyNameHandler)).Methods("POST", "OPTIONS") + apiRouter.Handle("/repositories/{repoID}/webhook", http.HandlerFunc(han.InstallRepoWebhookHandler)).Methods("POST", "OPTIONS") + apiRouter.Handle("/repositories/{owner}/{repo}/webhook", http.HandlerFunc(han.InstallRepoWebhookByFriendlyNameHandler)).Methods("POST", "OPTIONS") + // Uninstall Webhook + apiRouter.Handle("/repositories/{repoID}/webhook/", http.HandlerFunc(han.UninstallRepoWebhookHandler)).Methods("DELETE", "OPTIONS") + apiRouter.Handle("/repositories/{owner}/{repo}/webhook/", http.HandlerFunc(han.UninstallRepoWebhookByFriendlyNameHandler)).Methods("DELETE", "OPTIONS") + apiRouter.Handle("/repositories/{repoID}/webhook", http.HandlerFunc(han.UninstallRepoWebhookHandler)).Methods("DELETE", "OPTIONS") + apiRouter.Handle("/repositories/{owner}/{repo}/webhook", http.HandlerFunc(han.UninstallRepoWebhookByFriendlyNameHandler)).Methods("DELETE", "OPTIONS") + // Get webhook info + apiRouter.Handle("/repositories/{repoID}/webhook/", http.HandlerFunc(han.GetRepoWebhookInfoHandler)).Methods("GET", "OPTIONS") + apiRouter.Handle("/repositories/{owner}/{repo}/webhook/", http.HandlerFunc(han.GetRepoWebhookInfoByFriendlyNameHandler)).Methods("GET", "OPTIONS") + apiRouter.Handle("/repositories/{repoID}/webhook", http.HandlerFunc(han.GetRepoWebhookInfoHandler)).Methods("GET", "OPTIONS") + apiRouter.Handle("/repositories/{owner}/{repo}/webhook", http.HandlerFunc(han.GetRepoWebhookInfoByFriendlyNameHandler)).Methods("GET", "OPTIONS") + } // Get repo - apiRouter.Handle("/repositories/{repoID}/", http.HandlerFunc(han.GetRepoByIDHandler)).Methods("GET", "OPTIONS") + apiRouter.Handle("/repositories/{repoID}/", http.HandlerFunc(han.GetRepoByFriendlyNameHandler)).Methods("GET", "OPTIONS") + apiRouter.Handle("/repositories/{owner}/{repo}/", http.HandlerFunc(han.GetRepoByIDHandler)).Methods("GET", "OPTIONS") apiRouter.Handle("/repositories/{repoID}", http.HandlerFunc(han.GetRepoByIDHandler)).Methods("GET", "OPTIONS") + apiRouter.Handle("/repositories/{owner}/{repo}", http.HandlerFunc(han.GetRepoByFriendlyNameHandler)).Methods("GET", "OPTIONS") // Update repo apiRouter.Handle("/repositories/{repoID}/", http.HandlerFunc(han.UpdateRepoHandler)).Methods("PUT", "OPTIONS") + apiRouter.Handle("/repositories/{owner}/{repo}/", http.HandlerFunc(han.UpdateRepoByFriendlyNameHandler)).Methods("PUT", "OPTIONS") apiRouter.Handle("/repositories/{repoID}", http.HandlerFunc(han.UpdateRepoHandler)).Methods("PUT", "OPTIONS") + apiRouter.Handle("/repositories/{owner}/{repo}", http.HandlerFunc(han.UpdateRepoByFriendlyNameHandler)).Methods("PUT", "OPTIONS") // Delete repo apiRouter.Handle("/repositories/{repoID}/", http.HandlerFunc(han.DeleteRepoHandler)).Methods("DELETE", "OPTIONS") + apiRouter.Handle("/repositories/{owner}/{repo}/", http.HandlerFunc(han.DeleteRepoByFriendlyNameHandler)).Methods("DELETE", "OPTIONS") apiRouter.Handle("/repositories/{repoID}", http.HandlerFunc(han.DeleteRepoHandler)).Methods("DELETE", "OPTIONS") + apiRouter.Handle("/repositories/{owner}/{repo}", http.HandlerFunc(han.DeleteRepoByFriendlyNameHandler)).Methods("DELETE", "OPTIONS") // List repos apiRouter.Handle("/repositories/", http.HandlerFunc(han.ListReposHandler)).Methods("GET", "OPTIONS") apiRouter.Handle("/repositories", http.HandlerFunc(han.ListReposHandler)).Methods("GET", "OPTIONS") @@ -293,17 +333,6 @@ func NewAPIRouter(han *controllers.APIController, authMiddleware, initMiddleware apiRouter.Handle("/repositories/", http.HandlerFunc(han.CreateRepoHandler)).Methods("POST", "OPTIONS") apiRouter.Handle("/repositories", http.HandlerFunc(han.CreateRepoHandler)).Methods("POST", "OPTIONS") - if manageWebhooks { - // Install Webhook - apiRouter.Handle("/repositories/{repoID}/webhook/", http.HandlerFunc(han.InstallRepoWebhookHandler)).Methods("POST", "OPTIONS") - apiRouter.Handle("/repositories/{repoID}/webhook", http.HandlerFunc(han.InstallRepoWebhookHandler)).Methods("POST", "OPTIONS") - // Uninstall Webhook - apiRouter.Handle("/repositories/{repoID}/webhook/", http.HandlerFunc(han.UninstallRepoWebhookHandler)).Methods("DELETE", "OPTIONS") - apiRouter.Handle("/repositories/{repoID}/webhook", http.HandlerFunc(han.UninstallRepoWebhookHandler)).Methods("DELETE", "OPTIONS") - // Get webhook info - apiRouter.Handle("/repositories/{repoID}/webhook/", http.HandlerFunc(han.GetRepoWebhookInfoHandler)).Methods("GET", "OPTIONS") - apiRouter.Handle("/repositories/{repoID}/webhook", http.HandlerFunc(han.GetRepoWebhookInfoHandler)).Methods("GET", "OPTIONS") - } ///////////////////////////// // Organizations and pools // ///////////////////////////// diff --git a/apiserver/swagger.yaml b/apiserver/swagger.yaml index 66e7a655a..6b0353fc7 100644 --- a/apiserver/swagger.yaml +++ b/apiserver/swagger.yaml @@ -1789,6 +1789,479 @@ paths: summary: Create repository with the parameters given. tags: - repositories + /repositories/{owner}/{repo}: + delete: + operationId: DeleteRepoByName + parameters: + - description: owner of the repository to delete. + in: path + name: owner + required: true + type: string + - description: name of the repository to delete. + in: path + name: repo + required: true + type: string + - description: endpointName of the repository to delete. + in: query + name: endpointName + type: string + - description: If true and a webhook is installed for this repo, it will not be removed. + in: query + name: keepWebhook + type: boolean + responses: + default: + description: APIErrorResponse + schema: + $ref: '#/definitions/APIErrorResponse' + summary: Delete repository by ID. + tags: + - Repositories + get: + operationId: GetRepoByName + parameters: + - description: owner of the repository to fetch. + in: path + name: owner + required: true + type: string + - description: name of the repository to fetch. + in: path + name: repo + required: true + type: string + - description: endpointName of the repository to fetch. + in: query + name: endpointName + type: string + responses: + "200": + description: Repository + schema: + $ref: '#/definitions/Repository' + default: + description: APIErrorResponse + schema: + $ref: '#/definitions/APIErrorResponse' + summary: Get repository by name. + tags: + - Repositories + put: + operationId: UpdateRepoByName + parameters: + - description: owner of the repository to update. + in: path + name: owner + required: true + type: string + - description: name of the repository to update. + in: path + name: repo + required: true + type: string + - description: endpointName of the repository to update. + in: query + name: endpointName + type: string + - description: Parameters used when updating the repository. + in: body + name: Body + required: true + schema: + $ref: '#/definitions/UpdateEntityParams' + description: Parameters used when updating the repository. + type: object + responses: + "200": + description: Repository + schema: + $ref: '#/definitions/Repository' + default: + description: APIErrorResponse + schema: + $ref: '#/definitions/APIErrorResponse' + summary: Update repository with the parameters given. + tags: + - Repositories + /repositories/{owner}/{repo}/instances: + get: + operationId: ListRepoByNameInstances + parameters: + - description: Repository owner. + in: path + name: owner + required: true + type: string + - description: Repository name. + in: path + name: repo + required: true + type: string + - description: Repository endpointName. + in: query + name: endpointName + type: string + responses: + "200": + description: Instances + schema: + $ref: '#/definitions/Instances' + default: + description: APIErrorResponse + schema: + $ref: '#/definitions/APIErrorResponse' + summary: List repository instances. + tags: + - repositories + - instances + /repositories/{owner}/{repo}/pools: + get: + operationId: ListRepoByNamePools + parameters: + - description: Repository owner. + in: path + name: owner + required: true + type: string + - description: Repository name. + in: path + name: repo + required: true + type: string + - description: Repository endpointName. + in: query + name: endpointName + type: string + responses: + "200": + description: Pools + schema: + $ref: '#/definitions/Pools' + default: + description: APIErrorResponse + schema: + $ref: '#/definitions/APIErrorResponse' + summary: List repository pools. + tags: + - Repositories + - pools + post: + operationId: CreateRepoByNamePool + parameters: + - description: Repository owner. + in: path + name: owner + required: true + type: string + - description: Repository name. + in: path + name: repo + required: true + type: string + - description: Repository endpointName. + in: query + name: endpointName + type: string + - description: Parameters used when creating the repository pool. + in: body + name: Body + required: true + schema: + $ref: '#/definitions/CreatePoolParams' + description: Parameters used when creating the repository pool. + type: object + responses: + "200": + description: Pool + schema: + $ref: '#/definitions/Pool' + default: + description: APIErrorResponse + schema: + $ref: '#/definitions/APIErrorResponse' + summary: Create repository pool with the parameters given. + tags: + - Repositories + - pools + /repositories/{owner}/{repo}/pools/{poolID}: + delete: + operationId: DeleteRepoByNamePool + parameters: + - description: Repository owner. + in: path + name: owner + required: true + type: string + - description: Repository name. + in: path + name: repo + required: true + type: string + - description: Repository endpointName. + in: query + name: endpointName + type: string + - description: ID of the repository pool to delete. + in: path + name: poolID + required: true + type: string + responses: + default: + description: APIErrorResponse + schema: + $ref: '#/definitions/APIErrorResponse' + summary: Delete repository pool by ID. + tags: + - Repositories + - pools + get: + operationId: GetRepoByNamePool + parameters: + - description: Repository owner. + in: path + name: owner + required: true + type: string + - description: Repository name. + in: path + name: repo + required: true + type: string + - description: Repository endpointName. + in: query + name: endpointName + type: string + - description: Pool ID. + in: path + name: poolID + required: true + type: string + responses: + "200": + description: Pool + schema: + $ref: '#/definitions/Pool' + default: + description: APIErrorResponse + schema: + $ref: '#/definitions/APIErrorResponse' + summary: Get repository pool by ID. + tags: + - Repositories + - pools + /repositories/{owner}/{repo}/scalesets: + get: + operationId: ListRepoByNameScaleSets + parameters: + - description: Repository owner. + in: path + name: owner + required: true + type: string + - description: Repository name. + in: path + name: repo + required: true + type: string + - description: Repository endpointName. + in: query + name: endpointName + type: string + responses: + "200": + description: ScaleSets + schema: + $ref: '#/definitions/ScaleSets' + default: + description: APIErrorResponse + schema: + $ref: '#/definitions/APIErrorResponse' + summary: List repository scale sets. + tags: + - Repositories + - scalesets + post: + operationId: CreateRepoByNameScaleSet + parameters: + - description: Repository owner. + in: path + name: owner + required: true + type: string + - description: Repository name. + in: path + name: repo + required: true + type: string + - description: Repository endpointName. + in: query + name: endpointName + type: string + - description: Parameters used when creating the repository scale set. + in: body + name: Body + required: true + schema: + $ref: '#/definitions/CreateScaleSetParams' + description: Parameters used when creating the repository scale set. + type: object + responses: + "200": + description: ScaleSet + schema: + $ref: '#/definitions/ScaleSet' + default: + description: APIErrorResponse + schema: + $ref: '#/definitions/APIErrorResponse' + summary: Create repository scale set with the parameters given. + tags: + - Repositories + - scalesets + /repositories/{owner}/{repo}/webhook: + delete: + operationId: UninstallRepoByNameWebhook + parameters: + - description: Repository owner. + in: path + name: owner + required: true + type: string + - description: Repository name. + in: path + name: repo + required: true + type: string + - description: Repository endpointName. + in: query + name: endpointName + type: string + responses: + default: + description: APIErrorResponse + schema: + $ref: '#/definitions/APIErrorResponse' + summary: Uninstall organization webhook. + tags: + - Repositories + - hooks + get: + operationId: GetRepoByNameWebhookInfo + parameters: + - description: Repository owner. + in: path + name: owner + required: true + type: string + - description: Repository name. + in: path + name: repo + required: true + type: string + - description: Repository endpointName. + in: query + name: endpointName + type: string + responses: + "200": + description: HookInfo + schema: + $ref: '#/definitions/HookInfo' + default: + description: APIErrorResponse + schema: + $ref: '#/definitions/APIErrorResponse' + summary: Get information about the GARM installed webhook on a repository. + tags: + - Repositories + - hooks + post: + description: |- + Install the GARM webhook for an organization. The secret configured on the organization will + be used to validate the requests. + operationId: InstallRepoByNameWebhook + parameters: + - description: Repository owner. + in: path + name: owner + required: true + type: string + - description: Repository name. + in: path + name: repo + required: true + type: string + - description: Repository endpointName. + in: query + name: endpointName + type: string + - description: Parameters used when creating the repository webhook. + in: body + name: Body + required: true + schema: + $ref: '#/definitions/InstallWebhookParams' + description: Parameters used when creating the repository webhook. + type: object + responses: + "200": + description: HookInfo + schema: + $ref: '#/definitions/HookInfo' + default: + description: APIErrorResponse + schema: + $ref: '#/definitions/APIErrorResponse' + tags: + - Repositories + - hooks + /repositories/{owner}{repo}/pools/{poolID}: + put: + operationId: UpdateRepoByNamePool + parameters: + - description: Repository owner. + in: path + name: owner + required: true + type: string + - description: Repository name. + in: path + name: repo + required: true + type: string + - description: Repository endpointName. + in: query + name: endpointName + type: string + - description: ID of the repository pool to update. + in: path + name: poolID + required: true + type: string + - description: Parameters used when updating the repository pool. + in: body + name: Body + required: true + schema: + $ref: '#/definitions/UpdatePoolParams' + description: Parameters used when updating the repository pool. + type: object + responses: + "200": + description: Pool + schema: + $ref: '#/definitions/Pool' + default: + description: APIErrorResponse + schema: + $ref: '#/definitions/APIErrorResponse' + summary: Update repository pool with the parameters given. + tags: + - repositories + - pools /repositories/{repoID}: delete: operationId: DeleteRepo diff --git a/client/repositories/create_repo_pool_by_friendly_name_parameters.go b/client/repositories/create_repo_pool_by_friendly_name_parameters.go new file mode 100644 index 000000000..83ee61ef9 --- /dev/null +++ b/client/repositories/create_repo_pool_by_friendly_name_parameters.go @@ -0,0 +1,229 @@ +// Code generated by go-swagger; DO NOT EDIT. + +package repositories + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "context" + "net/http" + "time" + + "github.com/go-openapi/errors" + "github.com/go-openapi/runtime" + cr "github.com/go-openapi/runtime/client" + "github.com/go-openapi/strfmt" + + garm_params "github.com/cloudbase/garm/params" +) + +// NewCreateRepoPoolByFriendlyNameParams creates a new CreateRepoPoolByFriendlyNameParams object, +// with the default timeout for this client. +// +// Default values are not hydrated, since defaults are normally applied by the API server side. +// +// To enforce default values in parameter, use SetDefaults or WithDefaults. +func NewCreateRepoPoolByFriendlyNameParams() *CreateRepoPoolByFriendlyNameParams { + return &CreateRepoPoolByFriendlyNameParams{ + timeout: cr.DefaultTimeout, + } +} + +// NewCreateRepoPoolByFriendlyNameParamsWithTimeout creates a new CreateRepoPoolByFriendlyNameParams object +// with the ability to set a timeout on a request. +func NewCreateRepoPoolByFriendlyNameParamsWithTimeout(timeout time.Duration) *CreateRepoPoolByFriendlyNameParams { + return &CreateRepoPoolByFriendlyNameParams{ + timeout: timeout, + } +} + +// NewCreateRepoPoolByFriendlyNameParamsWithContext creates a new CreateRepoPoolByFriendlyNameParams object +// with the ability to set a context for a request. +func NewCreateRepoPoolByFriendlyNameParamsWithContext(ctx context.Context) *CreateRepoPoolByFriendlyNameParams { + return &CreateRepoPoolByFriendlyNameParams{ + Context: ctx, + } +} + +// NewCreateRepoPoolByFriendlyNameParamsWithHTTPClient creates a new CreateRepoPoolByFriendlyNameParams object +// with the ability to set a custom HTTPClient for a request. +func NewCreateRepoPoolByFriendlyNameParamsWithHTTPClient(client *http.Client) *CreateRepoPoolByFriendlyNameParams { + return &CreateRepoPoolByFriendlyNameParams{ + HTTPClient: client, + } +} + +/* +CreateRepoPoolByFriendlyNameParams contains all the parameters to send to the API endpoint + + for the create repo pool by friendly name operation. + + Typically these are written to a http.Request. +*/ +type CreateRepoPoolByFriendlyNameParams struct { + + /* Body. + + Parameters used when creating the repository pool. + */ + Body garm_params.CreatePoolParams + + /* EndpointName. + + Repository endpointName. + */ + EndpointName *string + + /* Owner. + + Repository owner. + */ + Owner string + + /* Repo. + + Repository name. + */ + Repo string + + timeout time.Duration + Context context.Context + HTTPClient *http.Client +} + +// WithDefaults hydrates default values in the create repo pool by friendly name params (not the query body). +// +// All values with no default are reset to their zero value. +func (o *CreateRepoPoolByFriendlyNameParams) WithDefaults() *CreateRepoPoolByFriendlyNameParams { + o.SetDefaults() + return o +} + +// SetDefaults hydrates default values in the create repo pool by friendly name params (not the query body). +// +// All values with no default are reset to their zero value. +func (o *CreateRepoPoolByFriendlyNameParams) SetDefaults() { + // no default values defined for this parameter +} + +// WithTimeout adds the timeout to the create repo pool by friendly name params +func (o *CreateRepoPoolByFriendlyNameParams) WithTimeout(timeout time.Duration) *CreateRepoPoolByFriendlyNameParams { + o.SetTimeout(timeout) + return o +} + +// SetTimeout adds the timeout to the create repo pool by friendly name params +func (o *CreateRepoPoolByFriendlyNameParams) SetTimeout(timeout time.Duration) { + o.timeout = timeout +} + +// WithContext adds the context to the create repo pool by friendly name params +func (o *CreateRepoPoolByFriendlyNameParams) WithContext(ctx context.Context) *CreateRepoPoolByFriendlyNameParams { + o.SetContext(ctx) + return o +} + +// SetContext adds the context to the create repo pool by friendly name params +func (o *CreateRepoPoolByFriendlyNameParams) SetContext(ctx context.Context) { + o.Context = ctx +} + +// WithHTTPClient adds the HTTPClient to the create repo pool by friendly name params +func (o *CreateRepoPoolByFriendlyNameParams) WithHTTPClient(client *http.Client) *CreateRepoPoolByFriendlyNameParams { + o.SetHTTPClient(client) + return o +} + +// SetHTTPClient adds the HTTPClient to the create repo pool by friendly name params +func (o *CreateRepoPoolByFriendlyNameParams) SetHTTPClient(client *http.Client) { + o.HTTPClient = client +} + +// WithBody adds the body to the create repo pool by friendly name params +func (o *CreateRepoPoolByFriendlyNameParams) WithBody(body garm_params.CreatePoolParams) *CreateRepoPoolByFriendlyNameParams { + o.SetBody(body) + return o +} + +// SetBody adds the body to the create repo pool by friendly name params +func (o *CreateRepoPoolByFriendlyNameParams) SetBody(body garm_params.CreatePoolParams) { + o.Body = body +} + +// WithEndpointName adds the endpointName to the create repo pool by friendly name params +func (o *CreateRepoPoolByFriendlyNameParams) WithEndpointName(endpointName *string) *CreateRepoPoolByFriendlyNameParams { + o.SetEndpointName(endpointName) + return o +} + +// SetEndpointName adds the endpointName to the create repo pool by friendly name params +func (o *CreateRepoPoolByFriendlyNameParams) SetEndpointName(endpointName *string) { + o.EndpointName = endpointName +} + +// WithOwner adds the owner to the create repo pool by friendly name params +func (o *CreateRepoPoolByFriendlyNameParams) WithOwner(owner string) *CreateRepoPoolByFriendlyNameParams { + o.SetOwner(owner) + return o +} + +// SetOwner adds the owner to the create repo pool by friendly name params +func (o *CreateRepoPoolByFriendlyNameParams) SetOwner(owner string) { + o.Owner = owner +} + +// WithRepo adds the repo to the create repo pool by friendly name params +func (o *CreateRepoPoolByFriendlyNameParams) WithRepo(repo string) *CreateRepoPoolByFriendlyNameParams { + o.SetRepo(repo) + return o +} + +// SetRepo adds the repo to the create repo pool by friendly name params +func (o *CreateRepoPoolByFriendlyNameParams) SetRepo(repo string) { + o.Repo = repo +} + +// WriteToRequest writes these params to a swagger request +func (o *CreateRepoPoolByFriendlyNameParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error { + + if err := r.SetTimeout(o.timeout); err != nil { + return err + } + var res []error + if err := r.SetBodyParam(o.Body); err != nil { + return err + } + + if o.EndpointName != nil { + + // query param endpointName + var qrEndpointName string + + if o.EndpointName != nil { + qrEndpointName = *o.EndpointName + } + qEndpointName := qrEndpointName + if qEndpointName != "" { + + if err := r.SetQueryParam("endpointName", qEndpointName); err != nil { + return err + } + } + } + + // path param owner + if err := r.SetPathParam("owner", o.Owner); err != nil { + return err + } + + // path param repo + if err := r.SetPathParam("repo", o.Repo); err != nil { + return err + } + + if len(res) > 0 { + return errors.CompositeValidationError(res...) + } + return nil +} diff --git a/client/repositories/create_repo_pool_by_friendly_name_responses.go b/client/repositories/create_repo_pool_by_friendly_name_responses.go new file mode 100644 index 000000000..66c9cae41 --- /dev/null +++ b/client/repositories/create_repo_pool_by_friendly_name_responses.go @@ -0,0 +1,184 @@ +// Code generated by go-swagger; DO NOT EDIT. + +package repositories + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "encoding/json" + "fmt" + "io" + + "github.com/go-openapi/runtime" + "github.com/go-openapi/strfmt" + + apiserver_params "github.com/cloudbase/garm/apiserver/params" + garm_params "github.com/cloudbase/garm/params" +) + +// CreateRepoPoolByFriendlyNameReader is a Reader for the CreateRepoPoolByFriendlyName structure. +type CreateRepoPoolByFriendlyNameReader struct { + formats strfmt.Registry +} + +// ReadResponse reads a server response into the received o. +func (o *CreateRepoPoolByFriendlyNameReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error) { + switch response.Code() { + case 200: + result := NewCreateRepoPoolByFriendlyNameOK() + if err := result.readResponse(response, consumer, o.formats); err != nil { + return nil, err + } + return result, nil + default: + result := NewCreateRepoPoolByFriendlyNameDefault(response.Code()) + if err := result.readResponse(response, consumer, o.formats); err != nil { + return nil, err + } + if response.Code()/100 == 2 { + return result, nil + } + return nil, result + } +} + +// NewCreateRepoPoolByFriendlyNameOK creates a CreateRepoPoolByFriendlyNameOK with default headers values +func NewCreateRepoPoolByFriendlyNameOK() *CreateRepoPoolByFriendlyNameOK { + return &CreateRepoPoolByFriendlyNameOK{} +} + +/* +CreateRepoPoolByFriendlyNameOK describes a response with status code 200, with default header values. + +Pool +*/ +type CreateRepoPoolByFriendlyNameOK struct { + Payload garm_params.Pool +} + +// IsSuccess returns true when this create repo pool by friendly name o k response has a 2xx status code +func (o *CreateRepoPoolByFriendlyNameOK) IsSuccess() bool { + return true +} + +// IsRedirect returns true when this create repo pool by friendly name o k response has a 3xx status code +func (o *CreateRepoPoolByFriendlyNameOK) IsRedirect() bool { + return false +} + +// IsClientError returns true when this create repo pool by friendly name o k response has a 4xx status code +func (o *CreateRepoPoolByFriendlyNameOK) IsClientError() bool { + return false +} + +// IsServerError returns true when this create repo pool by friendly name o k response has a 5xx status code +func (o *CreateRepoPoolByFriendlyNameOK) IsServerError() bool { + return false +} + +// IsCode returns true when this create repo pool by friendly name o k response a status code equal to that given +func (o *CreateRepoPoolByFriendlyNameOK) IsCode(code int) bool { + return code == 200 +} + +// Code gets the status code for the create repo pool by friendly name o k response +func (o *CreateRepoPoolByFriendlyNameOK) Code() int { + return 200 +} + +func (o *CreateRepoPoolByFriendlyNameOK) Error() string { + payload, _ := json.Marshal(o.Payload) + return fmt.Sprintf("[POST /repositories/{owner}/{repo}/pools][%d] createRepoPoolByFriendlyNameOK %s", 200, payload) +} + +func (o *CreateRepoPoolByFriendlyNameOK) String() string { + payload, _ := json.Marshal(o.Payload) + return fmt.Sprintf("[POST /repositories/{owner}/{repo}/pools][%d] createRepoPoolByFriendlyNameOK %s", 200, payload) +} + +func (o *CreateRepoPoolByFriendlyNameOK) GetPayload() garm_params.Pool { + return o.Payload +} + +func (o *CreateRepoPoolByFriendlyNameOK) readResponse(response runtime.ClientResponse, consumer runtime.Consumer, formats strfmt.Registry) error { + + // response payload + if err := consumer.Consume(response.Body(), &o.Payload); err != nil && err != io.EOF { + return err + } + + return nil +} + +// NewCreateRepoPoolByFriendlyNameDefault creates a CreateRepoPoolByFriendlyNameDefault with default headers values +func NewCreateRepoPoolByFriendlyNameDefault(code int) *CreateRepoPoolByFriendlyNameDefault { + return &CreateRepoPoolByFriendlyNameDefault{ + _statusCode: code, + } +} + +/* +CreateRepoPoolByFriendlyNameDefault describes a response with status code -1, with default header values. + +APIErrorResponse +*/ +type CreateRepoPoolByFriendlyNameDefault struct { + _statusCode int + + Payload apiserver_params.APIErrorResponse +} + +// IsSuccess returns true when this create repo pool by friendly name default response has a 2xx status code +func (o *CreateRepoPoolByFriendlyNameDefault) IsSuccess() bool { + return o._statusCode/100 == 2 +} + +// IsRedirect returns true when this create repo pool by friendly name default response has a 3xx status code +func (o *CreateRepoPoolByFriendlyNameDefault) IsRedirect() bool { + return o._statusCode/100 == 3 +} + +// IsClientError returns true when this create repo pool by friendly name default response has a 4xx status code +func (o *CreateRepoPoolByFriendlyNameDefault) IsClientError() bool { + return o._statusCode/100 == 4 +} + +// IsServerError returns true when this create repo pool by friendly name default response has a 5xx status code +func (o *CreateRepoPoolByFriendlyNameDefault) IsServerError() bool { + return o._statusCode/100 == 5 +} + +// IsCode returns true when this create repo pool by friendly name default response a status code equal to that given +func (o *CreateRepoPoolByFriendlyNameDefault) IsCode(code int) bool { + return o._statusCode == code +} + +// Code gets the status code for the create repo pool by friendly name default response +func (o *CreateRepoPoolByFriendlyNameDefault) Code() int { + return o._statusCode +} + +func (o *CreateRepoPoolByFriendlyNameDefault) Error() string { + payload, _ := json.Marshal(o.Payload) + return fmt.Sprintf("[POST /repositories/{owner}/{repo}/pools][%d] CreateRepoPoolByFriendlyName default %s", o._statusCode, payload) +} + +func (o *CreateRepoPoolByFriendlyNameDefault) String() string { + payload, _ := json.Marshal(o.Payload) + return fmt.Sprintf("[POST /repositories/{owner}/{repo}/pools][%d] CreateRepoPoolByFriendlyName default %s", o._statusCode, payload) +} + +func (o *CreateRepoPoolByFriendlyNameDefault) GetPayload() apiserver_params.APIErrorResponse { + return o.Payload +} + +func (o *CreateRepoPoolByFriendlyNameDefault) readResponse(response runtime.ClientResponse, consumer runtime.Consumer, formats strfmt.Registry) error { + + // response payload + if err := consumer.Consume(response.Body(), &o.Payload); err != nil && err != io.EOF { + return err + } + + return nil +} diff --git a/client/repositories/create_repo_scale_set_by_friendly_name_parameters.go b/client/repositories/create_repo_scale_set_by_friendly_name_parameters.go new file mode 100644 index 000000000..9f003f97a --- /dev/null +++ b/client/repositories/create_repo_scale_set_by_friendly_name_parameters.go @@ -0,0 +1,229 @@ +// Code generated by go-swagger; DO NOT EDIT. + +package repositories + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "context" + "net/http" + "time" + + "github.com/go-openapi/errors" + "github.com/go-openapi/runtime" + cr "github.com/go-openapi/runtime/client" + "github.com/go-openapi/strfmt" + + garm_params "github.com/cloudbase/garm/params" +) + +// NewCreateRepoScaleSetByFriendlyNameParams creates a new CreateRepoScaleSetByFriendlyNameParams object, +// with the default timeout for this client. +// +// Default values are not hydrated, since defaults are normally applied by the API server side. +// +// To enforce default values in parameter, use SetDefaults or WithDefaults. +func NewCreateRepoScaleSetByFriendlyNameParams() *CreateRepoScaleSetByFriendlyNameParams { + return &CreateRepoScaleSetByFriendlyNameParams{ + timeout: cr.DefaultTimeout, + } +} + +// NewCreateRepoScaleSetByFriendlyNameParamsWithTimeout creates a new CreateRepoScaleSetByFriendlyNameParams object +// with the ability to set a timeout on a request. +func NewCreateRepoScaleSetByFriendlyNameParamsWithTimeout(timeout time.Duration) *CreateRepoScaleSetByFriendlyNameParams { + return &CreateRepoScaleSetByFriendlyNameParams{ + timeout: timeout, + } +} + +// NewCreateRepoScaleSetByFriendlyNameParamsWithContext creates a new CreateRepoScaleSetByFriendlyNameParams object +// with the ability to set a context for a request. +func NewCreateRepoScaleSetByFriendlyNameParamsWithContext(ctx context.Context) *CreateRepoScaleSetByFriendlyNameParams { + return &CreateRepoScaleSetByFriendlyNameParams{ + Context: ctx, + } +} + +// NewCreateRepoScaleSetByFriendlyNameParamsWithHTTPClient creates a new CreateRepoScaleSetByFriendlyNameParams object +// with the ability to set a custom HTTPClient for a request. +func NewCreateRepoScaleSetByFriendlyNameParamsWithHTTPClient(client *http.Client) *CreateRepoScaleSetByFriendlyNameParams { + return &CreateRepoScaleSetByFriendlyNameParams{ + HTTPClient: client, + } +} + +/* +CreateRepoScaleSetByFriendlyNameParams contains all the parameters to send to the API endpoint + + for the create repo scale set by friendly name operation. + + Typically these are written to a http.Request. +*/ +type CreateRepoScaleSetByFriendlyNameParams struct { + + /* Body. + + Parameters used when creating the repository scale set. + */ + Body garm_params.CreateScaleSetParams + + /* EndpointName. + + Repository endpointName. + */ + EndpointName *string + + /* Owner. + + Repository owner. + */ + Owner string + + /* Repo. + + Repository name. + */ + Repo string + + timeout time.Duration + Context context.Context + HTTPClient *http.Client +} + +// WithDefaults hydrates default values in the create repo scale set by friendly name params (not the query body). +// +// All values with no default are reset to their zero value. +func (o *CreateRepoScaleSetByFriendlyNameParams) WithDefaults() *CreateRepoScaleSetByFriendlyNameParams { + o.SetDefaults() + return o +} + +// SetDefaults hydrates default values in the create repo scale set by friendly name params (not the query body). +// +// All values with no default are reset to their zero value. +func (o *CreateRepoScaleSetByFriendlyNameParams) SetDefaults() { + // no default values defined for this parameter +} + +// WithTimeout adds the timeout to the create repo scale set by friendly name params +func (o *CreateRepoScaleSetByFriendlyNameParams) WithTimeout(timeout time.Duration) *CreateRepoScaleSetByFriendlyNameParams { + o.SetTimeout(timeout) + return o +} + +// SetTimeout adds the timeout to the create repo scale set by friendly name params +func (o *CreateRepoScaleSetByFriendlyNameParams) SetTimeout(timeout time.Duration) { + o.timeout = timeout +} + +// WithContext adds the context to the create repo scale set by friendly name params +func (o *CreateRepoScaleSetByFriendlyNameParams) WithContext(ctx context.Context) *CreateRepoScaleSetByFriendlyNameParams { + o.SetContext(ctx) + return o +} + +// SetContext adds the context to the create repo scale set by friendly name params +func (o *CreateRepoScaleSetByFriendlyNameParams) SetContext(ctx context.Context) { + o.Context = ctx +} + +// WithHTTPClient adds the HTTPClient to the create repo scale set by friendly name params +func (o *CreateRepoScaleSetByFriendlyNameParams) WithHTTPClient(client *http.Client) *CreateRepoScaleSetByFriendlyNameParams { + o.SetHTTPClient(client) + return o +} + +// SetHTTPClient adds the HTTPClient to the create repo scale set by friendly name params +func (o *CreateRepoScaleSetByFriendlyNameParams) SetHTTPClient(client *http.Client) { + o.HTTPClient = client +} + +// WithBody adds the body to the create repo scale set by friendly name params +func (o *CreateRepoScaleSetByFriendlyNameParams) WithBody(body garm_params.CreateScaleSetParams) *CreateRepoScaleSetByFriendlyNameParams { + o.SetBody(body) + return o +} + +// SetBody adds the body to the create repo scale set by friendly name params +func (o *CreateRepoScaleSetByFriendlyNameParams) SetBody(body garm_params.CreateScaleSetParams) { + o.Body = body +} + +// WithEndpointName adds the endpointName to the create repo scale set by friendly name params +func (o *CreateRepoScaleSetByFriendlyNameParams) WithEndpointName(endpointName *string) *CreateRepoScaleSetByFriendlyNameParams { + o.SetEndpointName(endpointName) + return o +} + +// SetEndpointName adds the endpointName to the create repo scale set by friendly name params +func (o *CreateRepoScaleSetByFriendlyNameParams) SetEndpointName(endpointName *string) { + o.EndpointName = endpointName +} + +// WithOwner adds the owner to the create repo scale set by friendly name params +func (o *CreateRepoScaleSetByFriendlyNameParams) WithOwner(owner string) *CreateRepoScaleSetByFriendlyNameParams { + o.SetOwner(owner) + return o +} + +// SetOwner adds the owner to the create repo scale set by friendly name params +func (o *CreateRepoScaleSetByFriendlyNameParams) SetOwner(owner string) { + o.Owner = owner +} + +// WithRepo adds the repo to the create repo scale set by friendly name params +func (o *CreateRepoScaleSetByFriendlyNameParams) WithRepo(repo string) *CreateRepoScaleSetByFriendlyNameParams { + o.SetRepo(repo) + return o +} + +// SetRepo adds the repo to the create repo scale set by friendly name params +func (o *CreateRepoScaleSetByFriendlyNameParams) SetRepo(repo string) { + o.Repo = repo +} + +// WriteToRequest writes these params to a swagger request +func (o *CreateRepoScaleSetByFriendlyNameParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error { + + if err := r.SetTimeout(o.timeout); err != nil { + return err + } + var res []error + if err := r.SetBodyParam(o.Body); err != nil { + return err + } + + if o.EndpointName != nil { + + // query param endpointName + var qrEndpointName string + + if o.EndpointName != nil { + qrEndpointName = *o.EndpointName + } + qEndpointName := qrEndpointName + if qEndpointName != "" { + + if err := r.SetQueryParam("endpointName", qEndpointName); err != nil { + return err + } + } + } + + // path param owner + if err := r.SetPathParam("owner", o.Owner); err != nil { + return err + } + + // path param repo + if err := r.SetPathParam("repo", o.Repo); err != nil { + return err + } + + if len(res) > 0 { + return errors.CompositeValidationError(res...) + } + return nil +} diff --git a/client/repositories/create_repo_scale_set_by_friendly_name_responses.go b/client/repositories/create_repo_scale_set_by_friendly_name_responses.go new file mode 100644 index 000000000..fa7044e50 --- /dev/null +++ b/client/repositories/create_repo_scale_set_by_friendly_name_responses.go @@ -0,0 +1,184 @@ +// Code generated by go-swagger; DO NOT EDIT. + +package repositories + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "encoding/json" + "fmt" + "io" + + "github.com/go-openapi/runtime" + "github.com/go-openapi/strfmt" + + apiserver_params "github.com/cloudbase/garm/apiserver/params" + garm_params "github.com/cloudbase/garm/params" +) + +// CreateRepoScaleSetByFriendlyNameReader is a Reader for the CreateRepoScaleSetByFriendlyName structure. +type CreateRepoScaleSetByFriendlyNameReader struct { + formats strfmt.Registry +} + +// ReadResponse reads a server response into the received o. +func (o *CreateRepoScaleSetByFriendlyNameReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error) { + switch response.Code() { + case 200: + result := NewCreateRepoScaleSetByFriendlyNameOK() + if err := result.readResponse(response, consumer, o.formats); err != nil { + return nil, err + } + return result, nil + default: + result := NewCreateRepoScaleSetByFriendlyNameDefault(response.Code()) + if err := result.readResponse(response, consumer, o.formats); err != nil { + return nil, err + } + if response.Code()/100 == 2 { + return result, nil + } + return nil, result + } +} + +// NewCreateRepoScaleSetByFriendlyNameOK creates a CreateRepoScaleSetByFriendlyNameOK with default headers values +func NewCreateRepoScaleSetByFriendlyNameOK() *CreateRepoScaleSetByFriendlyNameOK { + return &CreateRepoScaleSetByFriendlyNameOK{} +} + +/* +CreateRepoScaleSetByFriendlyNameOK describes a response with status code 200, with default header values. + +ScaleSet +*/ +type CreateRepoScaleSetByFriendlyNameOK struct { + Payload garm_params.ScaleSet +} + +// IsSuccess returns true when this create repo scale set by friendly name o k response has a 2xx status code +func (o *CreateRepoScaleSetByFriendlyNameOK) IsSuccess() bool { + return true +} + +// IsRedirect returns true when this create repo scale set by friendly name o k response has a 3xx status code +func (o *CreateRepoScaleSetByFriendlyNameOK) IsRedirect() bool { + return false +} + +// IsClientError returns true when this create repo scale set by friendly name o k response has a 4xx status code +func (o *CreateRepoScaleSetByFriendlyNameOK) IsClientError() bool { + return false +} + +// IsServerError returns true when this create repo scale set by friendly name o k response has a 5xx status code +func (o *CreateRepoScaleSetByFriendlyNameOK) IsServerError() bool { + return false +} + +// IsCode returns true when this create repo scale set by friendly name o k response a status code equal to that given +func (o *CreateRepoScaleSetByFriendlyNameOK) IsCode(code int) bool { + return code == 200 +} + +// Code gets the status code for the create repo scale set by friendly name o k response +func (o *CreateRepoScaleSetByFriendlyNameOK) Code() int { + return 200 +} + +func (o *CreateRepoScaleSetByFriendlyNameOK) Error() string { + payload, _ := json.Marshal(o.Payload) + return fmt.Sprintf("[POST /repositories/{owner}/{repo}/scalesets][%d] createRepoScaleSetByFriendlyNameOK %s", 200, payload) +} + +func (o *CreateRepoScaleSetByFriendlyNameOK) String() string { + payload, _ := json.Marshal(o.Payload) + return fmt.Sprintf("[POST /repositories/{owner}/{repo}/scalesets][%d] createRepoScaleSetByFriendlyNameOK %s", 200, payload) +} + +func (o *CreateRepoScaleSetByFriendlyNameOK) GetPayload() garm_params.ScaleSet { + return o.Payload +} + +func (o *CreateRepoScaleSetByFriendlyNameOK) readResponse(response runtime.ClientResponse, consumer runtime.Consumer, formats strfmt.Registry) error { + + // response payload + if err := consumer.Consume(response.Body(), &o.Payload); err != nil && err != io.EOF { + return err + } + + return nil +} + +// NewCreateRepoScaleSetByFriendlyNameDefault creates a CreateRepoScaleSetByFriendlyNameDefault with default headers values +func NewCreateRepoScaleSetByFriendlyNameDefault(code int) *CreateRepoScaleSetByFriendlyNameDefault { + return &CreateRepoScaleSetByFriendlyNameDefault{ + _statusCode: code, + } +} + +/* +CreateRepoScaleSetByFriendlyNameDefault describes a response with status code -1, with default header values. + +APIErrorResponse +*/ +type CreateRepoScaleSetByFriendlyNameDefault struct { + _statusCode int + + Payload apiserver_params.APIErrorResponse +} + +// IsSuccess returns true when this create repo scale set by friendly name default response has a 2xx status code +func (o *CreateRepoScaleSetByFriendlyNameDefault) IsSuccess() bool { + return o._statusCode/100 == 2 +} + +// IsRedirect returns true when this create repo scale set by friendly name default response has a 3xx status code +func (o *CreateRepoScaleSetByFriendlyNameDefault) IsRedirect() bool { + return o._statusCode/100 == 3 +} + +// IsClientError returns true when this create repo scale set by friendly name default response has a 4xx status code +func (o *CreateRepoScaleSetByFriendlyNameDefault) IsClientError() bool { + return o._statusCode/100 == 4 +} + +// IsServerError returns true when this create repo scale set by friendly name default response has a 5xx status code +func (o *CreateRepoScaleSetByFriendlyNameDefault) IsServerError() bool { + return o._statusCode/100 == 5 +} + +// IsCode returns true when this create repo scale set by friendly name default response a status code equal to that given +func (o *CreateRepoScaleSetByFriendlyNameDefault) IsCode(code int) bool { + return o._statusCode == code +} + +// Code gets the status code for the create repo scale set by friendly name default response +func (o *CreateRepoScaleSetByFriendlyNameDefault) Code() int { + return o._statusCode +} + +func (o *CreateRepoScaleSetByFriendlyNameDefault) Error() string { + payload, _ := json.Marshal(o.Payload) + return fmt.Sprintf("[POST /repositories/{owner}/{repo}/scalesets][%d] CreateRepoScaleSetByFriendlyName default %s", o._statusCode, payload) +} + +func (o *CreateRepoScaleSetByFriendlyNameDefault) String() string { + payload, _ := json.Marshal(o.Payload) + return fmt.Sprintf("[POST /repositories/{owner}/{repo}/scalesets][%d] CreateRepoScaleSetByFriendlyName default %s", o._statusCode, payload) +} + +func (o *CreateRepoScaleSetByFriendlyNameDefault) GetPayload() apiserver_params.APIErrorResponse { + return o.Payload +} + +func (o *CreateRepoScaleSetByFriendlyNameDefault) readResponse(response runtime.ClientResponse, consumer runtime.Consumer, formats strfmt.Registry) error { + + // response payload + if err := consumer.Consume(response.Body(), &o.Payload); err != nil && err != io.EOF { + return err + } + + return nil +} diff --git a/client/repositories/delete_repo_by_friendly_name_parameters.go b/client/repositories/delete_repo_by_friendly_name_parameters.go new file mode 100644 index 000000000..563824d0b --- /dev/null +++ b/client/repositories/delete_repo_by_friendly_name_parameters.go @@ -0,0 +1,242 @@ +// Code generated by go-swagger; DO NOT EDIT. + +package repositories + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "context" + "net/http" + "time" + + "github.com/go-openapi/errors" + "github.com/go-openapi/runtime" + cr "github.com/go-openapi/runtime/client" + "github.com/go-openapi/strfmt" + "github.com/go-openapi/swag" +) + +// NewDeleteRepoByFriendlyNameParams creates a new DeleteRepoByFriendlyNameParams object, +// with the default timeout for this client. +// +// Default values are not hydrated, since defaults are normally applied by the API server side. +// +// To enforce default values in parameter, use SetDefaults or WithDefaults. +func NewDeleteRepoByFriendlyNameParams() *DeleteRepoByFriendlyNameParams { + return &DeleteRepoByFriendlyNameParams{ + timeout: cr.DefaultTimeout, + } +} + +// NewDeleteRepoByFriendlyNameParamsWithTimeout creates a new DeleteRepoByFriendlyNameParams object +// with the ability to set a timeout on a request. +func NewDeleteRepoByFriendlyNameParamsWithTimeout(timeout time.Duration) *DeleteRepoByFriendlyNameParams { + return &DeleteRepoByFriendlyNameParams{ + timeout: timeout, + } +} + +// NewDeleteRepoByFriendlyNameParamsWithContext creates a new DeleteRepoByFriendlyNameParams object +// with the ability to set a context for a request. +func NewDeleteRepoByFriendlyNameParamsWithContext(ctx context.Context) *DeleteRepoByFriendlyNameParams { + return &DeleteRepoByFriendlyNameParams{ + Context: ctx, + } +} + +// NewDeleteRepoByFriendlyNameParamsWithHTTPClient creates a new DeleteRepoByFriendlyNameParams object +// with the ability to set a custom HTTPClient for a request. +func NewDeleteRepoByFriendlyNameParamsWithHTTPClient(client *http.Client) *DeleteRepoByFriendlyNameParams { + return &DeleteRepoByFriendlyNameParams{ + HTTPClient: client, + } +} + +/* +DeleteRepoByFriendlyNameParams contains all the parameters to send to the API endpoint + + for the delete repo by friendly name operation. + + Typically these are written to a http.Request. +*/ +type DeleteRepoByFriendlyNameParams struct { + + /* EndpointName. + + endpointName of the repository to delete. + */ + EndpointName *string + + /* KeepWebhook. + + If true and a webhook is installed for this repo, it will not be removed. + */ + KeepWebhook *bool + + /* Owner. + + owner of the repository to delete. + */ + Owner string + + /* Repo. + + name of the repository to delete. + */ + Repo string + + timeout time.Duration + Context context.Context + HTTPClient *http.Client +} + +// WithDefaults hydrates default values in the delete repo by friendly name params (not the query body). +// +// All values with no default are reset to their zero value. +func (o *DeleteRepoByFriendlyNameParams) WithDefaults() *DeleteRepoByFriendlyNameParams { + o.SetDefaults() + return o +} + +// SetDefaults hydrates default values in the delete repo by friendly name params (not the query body). +// +// All values with no default are reset to their zero value. +func (o *DeleteRepoByFriendlyNameParams) SetDefaults() { + // no default values defined for this parameter +} + +// WithTimeout adds the timeout to the delete repo by friendly name params +func (o *DeleteRepoByFriendlyNameParams) WithTimeout(timeout time.Duration) *DeleteRepoByFriendlyNameParams { + o.SetTimeout(timeout) + return o +} + +// SetTimeout adds the timeout to the delete repo by friendly name params +func (o *DeleteRepoByFriendlyNameParams) SetTimeout(timeout time.Duration) { + o.timeout = timeout +} + +// WithContext adds the context to the delete repo by friendly name params +func (o *DeleteRepoByFriendlyNameParams) WithContext(ctx context.Context) *DeleteRepoByFriendlyNameParams { + o.SetContext(ctx) + return o +} + +// SetContext adds the context to the delete repo by friendly name params +func (o *DeleteRepoByFriendlyNameParams) SetContext(ctx context.Context) { + o.Context = ctx +} + +// WithHTTPClient adds the HTTPClient to the delete repo by friendly name params +func (o *DeleteRepoByFriendlyNameParams) WithHTTPClient(client *http.Client) *DeleteRepoByFriendlyNameParams { + o.SetHTTPClient(client) + return o +} + +// SetHTTPClient adds the HTTPClient to the delete repo by friendly name params +func (o *DeleteRepoByFriendlyNameParams) SetHTTPClient(client *http.Client) { + o.HTTPClient = client +} + +// WithEndpointName adds the endpointName to the delete repo by friendly name params +func (o *DeleteRepoByFriendlyNameParams) WithEndpointName(endpointName *string) *DeleteRepoByFriendlyNameParams { + o.SetEndpointName(endpointName) + return o +} + +// SetEndpointName adds the endpointName to the delete repo by friendly name params +func (o *DeleteRepoByFriendlyNameParams) SetEndpointName(endpointName *string) { + o.EndpointName = endpointName +} + +// WithKeepWebhook adds the keepWebhook to the delete repo by friendly name params +func (o *DeleteRepoByFriendlyNameParams) WithKeepWebhook(keepWebhook *bool) *DeleteRepoByFriendlyNameParams { + o.SetKeepWebhook(keepWebhook) + return o +} + +// SetKeepWebhook adds the keepWebhook to the delete repo by friendly name params +func (o *DeleteRepoByFriendlyNameParams) SetKeepWebhook(keepWebhook *bool) { + o.KeepWebhook = keepWebhook +} + +// WithOwner adds the owner to the delete repo by friendly name params +func (o *DeleteRepoByFriendlyNameParams) WithOwner(owner string) *DeleteRepoByFriendlyNameParams { + o.SetOwner(owner) + return o +} + +// SetOwner adds the owner to the delete repo by friendly name params +func (o *DeleteRepoByFriendlyNameParams) SetOwner(owner string) { + o.Owner = owner +} + +// WithRepo adds the repo to the delete repo by friendly name params +func (o *DeleteRepoByFriendlyNameParams) WithRepo(repo string) *DeleteRepoByFriendlyNameParams { + o.SetRepo(repo) + return o +} + +// SetRepo adds the repo to the delete repo by friendly name params +func (o *DeleteRepoByFriendlyNameParams) SetRepo(repo string) { + o.Repo = repo +} + +// WriteToRequest writes these params to a swagger request +func (o *DeleteRepoByFriendlyNameParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error { + + if err := r.SetTimeout(o.timeout); err != nil { + return err + } + var res []error + + if o.EndpointName != nil { + + // query param endpointName + var qrEndpointName string + + if o.EndpointName != nil { + qrEndpointName = *o.EndpointName + } + qEndpointName := qrEndpointName + if qEndpointName != "" { + + if err := r.SetQueryParam("endpointName", qEndpointName); err != nil { + return err + } + } + } + + if o.KeepWebhook != nil { + + // query param keepWebhook + var qrKeepWebhook bool + + if o.KeepWebhook != nil { + qrKeepWebhook = *o.KeepWebhook + } + qKeepWebhook := swag.FormatBool(qrKeepWebhook) + if qKeepWebhook != "" { + + if err := r.SetQueryParam("keepWebhook", qKeepWebhook); err != nil { + return err + } + } + } + + // path param owner + if err := r.SetPathParam("owner", o.Owner); err != nil { + return err + } + + // path param repo + if err := r.SetPathParam("repo", o.Repo); err != nil { + return err + } + + if len(res) > 0 { + return errors.CompositeValidationError(res...) + } + return nil +} diff --git a/client/repositories/delete_repo_by_friendly_name_responses.go b/client/repositories/delete_repo_by_friendly_name_responses.go new file mode 100644 index 000000000..80b2fddad --- /dev/null +++ b/client/repositories/delete_repo_by_friendly_name_responses.go @@ -0,0 +1,106 @@ +// Code generated by go-swagger; DO NOT EDIT. + +package repositories + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "encoding/json" + "fmt" + "io" + + "github.com/go-openapi/runtime" + "github.com/go-openapi/strfmt" + + apiserver_params "github.com/cloudbase/garm/apiserver/params" +) + +// DeleteRepoByFriendlyNameReader is a Reader for the DeleteRepoByFriendlyName structure. +type DeleteRepoByFriendlyNameReader struct { + formats strfmt.Registry +} + +// ReadResponse reads a server response into the received o. +func (o *DeleteRepoByFriendlyNameReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error) { + result := NewDeleteRepoByFriendlyNameDefault(response.Code()) + if err := result.readResponse(response, consumer, o.formats); err != nil { + return nil, err + } + if response.Code()/100 == 2 { + return result, nil + } + return nil, result +} + +// NewDeleteRepoByFriendlyNameDefault creates a DeleteRepoByFriendlyNameDefault with default headers values +func NewDeleteRepoByFriendlyNameDefault(code int) *DeleteRepoByFriendlyNameDefault { + return &DeleteRepoByFriendlyNameDefault{ + _statusCode: code, + } +} + +/* +DeleteRepoByFriendlyNameDefault describes a response with status code -1, with default header values. + +APIErrorResponse +*/ +type DeleteRepoByFriendlyNameDefault struct { + _statusCode int + + Payload apiserver_params.APIErrorResponse +} + +// IsSuccess returns true when this delete repo by friendly name default response has a 2xx status code +func (o *DeleteRepoByFriendlyNameDefault) IsSuccess() bool { + return o._statusCode/100 == 2 +} + +// IsRedirect returns true when this delete repo by friendly name default response has a 3xx status code +func (o *DeleteRepoByFriendlyNameDefault) IsRedirect() bool { + return o._statusCode/100 == 3 +} + +// IsClientError returns true when this delete repo by friendly name default response has a 4xx status code +func (o *DeleteRepoByFriendlyNameDefault) IsClientError() bool { + return o._statusCode/100 == 4 +} + +// IsServerError returns true when this delete repo by friendly name default response has a 5xx status code +func (o *DeleteRepoByFriendlyNameDefault) IsServerError() bool { + return o._statusCode/100 == 5 +} + +// IsCode returns true when this delete repo by friendly name default response a status code equal to that given +func (o *DeleteRepoByFriendlyNameDefault) IsCode(code int) bool { + return o._statusCode == code +} + +// Code gets the status code for the delete repo by friendly name default response +func (o *DeleteRepoByFriendlyNameDefault) Code() int { + return o._statusCode +} + +func (o *DeleteRepoByFriendlyNameDefault) Error() string { + payload, _ := json.Marshal(o.Payload) + return fmt.Sprintf("[DELETE /repositories/{owner}/{repo}][%d] DeleteRepoByFriendlyName default %s", o._statusCode, payload) +} + +func (o *DeleteRepoByFriendlyNameDefault) String() string { + payload, _ := json.Marshal(o.Payload) + return fmt.Sprintf("[DELETE /repositories/{owner}/{repo}][%d] DeleteRepoByFriendlyName default %s", o._statusCode, payload) +} + +func (o *DeleteRepoByFriendlyNameDefault) GetPayload() apiserver_params.APIErrorResponse { + return o.Payload +} + +func (o *DeleteRepoByFriendlyNameDefault) readResponse(response runtime.ClientResponse, consumer runtime.Consumer, formats strfmt.Registry) error { + + // response payload + if err := consumer.Consume(response.Body(), &o.Payload); err != nil && err != io.EOF { + return err + } + + return nil +} diff --git a/client/repositories/delete_repo_pool_by_friendly_name_parameters.go b/client/repositories/delete_repo_pool_by_friendly_name_parameters.go new file mode 100644 index 000000000..48d206108 --- /dev/null +++ b/client/repositories/delete_repo_pool_by_friendly_name_parameters.go @@ -0,0 +1,229 @@ +// Code generated by go-swagger; DO NOT EDIT. + +package repositories + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "context" + "net/http" + "time" + + "github.com/go-openapi/errors" + "github.com/go-openapi/runtime" + cr "github.com/go-openapi/runtime/client" + "github.com/go-openapi/strfmt" +) + +// NewDeleteRepoPoolByFriendlyNameParams creates a new DeleteRepoPoolByFriendlyNameParams object, +// with the default timeout for this client. +// +// Default values are not hydrated, since defaults are normally applied by the API server side. +// +// To enforce default values in parameter, use SetDefaults or WithDefaults. +func NewDeleteRepoPoolByFriendlyNameParams() *DeleteRepoPoolByFriendlyNameParams { + return &DeleteRepoPoolByFriendlyNameParams{ + timeout: cr.DefaultTimeout, + } +} + +// NewDeleteRepoPoolByFriendlyNameParamsWithTimeout creates a new DeleteRepoPoolByFriendlyNameParams object +// with the ability to set a timeout on a request. +func NewDeleteRepoPoolByFriendlyNameParamsWithTimeout(timeout time.Duration) *DeleteRepoPoolByFriendlyNameParams { + return &DeleteRepoPoolByFriendlyNameParams{ + timeout: timeout, + } +} + +// NewDeleteRepoPoolByFriendlyNameParamsWithContext creates a new DeleteRepoPoolByFriendlyNameParams object +// with the ability to set a context for a request. +func NewDeleteRepoPoolByFriendlyNameParamsWithContext(ctx context.Context) *DeleteRepoPoolByFriendlyNameParams { + return &DeleteRepoPoolByFriendlyNameParams{ + Context: ctx, + } +} + +// NewDeleteRepoPoolByFriendlyNameParamsWithHTTPClient creates a new DeleteRepoPoolByFriendlyNameParams object +// with the ability to set a custom HTTPClient for a request. +func NewDeleteRepoPoolByFriendlyNameParamsWithHTTPClient(client *http.Client) *DeleteRepoPoolByFriendlyNameParams { + return &DeleteRepoPoolByFriendlyNameParams{ + HTTPClient: client, + } +} + +/* +DeleteRepoPoolByFriendlyNameParams contains all the parameters to send to the API endpoint + + for the delete repo pool by friendly name operation. + + Typically these are written to a http.Request. +*/ +type DeleteRepoPoolByFriendlyNameParams struct { + + /* EndpointName. + + Repository endpointName. + */ + EndpointName *string + + /* Owner. + + Repository owner. + */ + Owner string + + /* PoolID. + + ID of the repository pool to delete. + */ + PoolID string + + /* Repo. + + Repository name. + */ + Repo string + + timeout time.Duration + Context context.Context + HTTPClient *http.Client +} + +// WithDefaults hydrates default values in the delete repo pool by friendly name params (not the query body). +// +// All values with no default are reset to their zero value. +func (o *DeleteRepoPoolByFriendlyNameParams) WithDefaults() *DeleteRepoPoolByFriendlyNameParams { + o.SetDefaults() + return o +} + +// SetDefaults hydrates default values in the delete repo pool by friendly name params (not the query body). +// +// All values with no default are reset to their zero value. +func (o *DeleteRepoPoolByFriendlyNameParams) SetDefaults() { + // no default values defined for this parameter +} + +// WithTimeout adds the timeout to the delete repo pool by friendly name params +func (o *DeleteRepoPoolByFriendlyNameParams) WithTimeout(timeout time.Duration) *DeleteRepoPoolByFriendlyNameParams { + o.SetTimeout(timeout) + return o +} + +// SetTimeout adds the timeout to the delete repo pool by friendly name params +func (o *DeleteRepoPoolByFriendlyNameParams) SetTimeout(timeout time.Duration) { + o.timeout = timeout +} + +// WithContext adds the context to the delete repo pool by friendly name params +func (o *DeleteRepoPoolByFriendlyNameParams) WithContext(ctx context.Context) *DeleteRepoPoolByFriendlyNameParams { + o.SetContext(ctx) + return o +} + +// SetContext adds the context to the delete repo pool by friendly name params +func (o *DeleteRepoPoolByFriendlyNameParams) SetContext(ctx context.Context) { + o.Context = ctx +} + +// WithHTTPClient adds the HTTPClient to the delete repo pool by friendly name params +func (o *DeleteRepoPoolByFriendlyNameParams) WithHTTPClient(client *http.Client) *DeleteRepoPoolByFriendlyNameParams { + o.SetHTTPClient(client) + return o +} + +// SetHTTPClient adds the HTTPClient to the delete repo pool by friendly name params +func (o *DeleteRepoPoolByFriendlyNameParams) SetHTTPClient(client *http.Client) { + o.HTTPClient = client +} + +// WithEndpointName adds the endpointName to the delete repo pool by friendly name params +func (o *DeleteRepoPoolByFriendlyNameParams) WithEndpointName(endpointName *string) *DeleteRepoPoolByFriendlyNameParams { + o.SetEndpointName(endpointName) + return o +} + +// SetEndpointName adds the endpointName to the delete repo pool by friendly name params +func (o *DeleteRepoPoolByFriendlyNameParams) SetEndpointName(endpointName *string) { + o.EndpointName = endpointName +} + +// WithOwner adds the owner to the delete repo pool by friendly name params +func (o *DeleteRepoPoolByFriendlyNameParams) WithOwner(owner string) *DeleteRepoPoolByFriendlyNameParams { + o.SetOwner(owner) + return o +} + +// SetOwner adds the owner to the delete repo pool by friendly name params +func (o *DeleteRepoPoolByFriendlyNameParams) SetOwner(owner string) { + o.Owner = owner +} + +// WithPoolID adds the poolID to the delete repo pool by friendly name params +func (o *DeleteRepoPoolByFriendlyNameParams) WithPoolID(poolID string) *DeleteRepoPoolByFriendlyNameParams { + o.SetPoolID(poolID) + return o +} + +// SetPoolID adds the poolId to the delete repo pool by friendly name params +func (o *DeleteRepoPoolByFriendlyNameParams) SetPoolID(poolID string) { + o.PoolID = poolID +} + +// WithRepo adds the repo to the delete repo pool by friendly name params +func (o *DeleteRepoPoolByFriendlyNameParams) WithRepo(repo string) *DeleteRepoPoolByFriendlyNameParams { + o.SetRepo(repo) + return o +} + +// SetRepo adds the repo to the delete repo pool by friendly name params +func (o *DeleteRepoPoolByFriendlyNameParams) SetRepo(repo string) { + o.Repo = repo +} + +// WriteToRequest writes these params to a swagger request +func (o *DeleteRepoPoolByFriendlyNameParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error { + + if err := r.SetTimeout(o.timeout); err != nil { + return err + } + var res []error + + if o.EndpointName != nil { + + // query param endpointName + var qrEndpointName string + + if o.EndpointName != nil { + qrEndpointName = *o.EndpointName + } + qEndpointName := qrEndpointName + if qEndpointName != "" { + + if err := r.SetQueryParam("endpointName", qEndpointName); err != nil { + return err + } + } + } + + // path param owner + if err := r.SetPathParam("owner", o.Owner); err != nil { + return err + } + + // path param poolID + if err := r.SetPathParam("poolID", o.PoolID); err != nil { + return err + } + + // path param repo + if err := r.SetPathParam("repo", o.Repo); err != nil { + return err + } + + if len(res) > 0 { + return errors.CompositeValidationError(res...) + } + return nil +} diff --git a/client/repositories/delete_repo_pool_by_friendly_name_responses.go b/client/repositories/delete_repo_pool_by_friendly_name_responses.go new file mode 100644 index 000000000..b9c78ce4f --- /dev/null +++ b/client/repositories/delete_repo_pool_by_friendly_name_responses.go @@ -0,0 +1,106 @@ +// Code generated by go-swagger; DO NOT EDIT. + +package repositories + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "encoding/json" + "fmt" + "io" + + "github.com/go-openapi/runtime" + "github.com/go-openapi/strfmt" + + apiserver_params "github.com/cloudbase/garm/apiserver/params" +) + +// DeleteRepoPoolByFriendlyNameReader is a Reader for the DeleteRepoPoolByFriendlyName structure. +type DeleteRepoPoolByFriendlyNameReader struct { + formats strfmt.Registry +} + +// ReadResponse reads a server response into the received o. +func (o *DeleteRepoPoolByFriendlyNameReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error) { + result := NewDeleteRepoPoolByFriendlyNameDefault(response.Code()) + if err := result.readResponse(response, consumer, o.formats); err != nil { + return nil, err + } + if response.Code()/100 == 2 { + return result, nil + } + return nil, result +} + +// NewDeleteRepoPoolByFriendlyNameDefault creates a DeleteRepoPoolByFriendlyNameDefault with default headers values +func NewDeleteRepoPoolByFriendlyNameDefault(code int) *DeleteRepoPoolByFriendlyNameDefault { + return &DeleteRepoPoolByFriendlyNameDefault{ + _statusCode: code, + } +} + +/* +DeleteRepoPoolByFriendlyNameDefault describes a response with status code -1, with default header values. + +APIErrorResponse +*/ +type DeleteRepoPoolByFriendlyNameDefault struct { + _statusCode int + + Payload apiserver_params.APIErrorResponse +} + +// IsSuccess returns true when this delete repo pool by friendly name default response has a 2xx status code +func (o *DeleteRepoPoolByFriendlyNameDefault) IsSuccess() bool { + return o._statusCode/100 == 2 +} + +// IsRedirect returns true when this delete repo pool by friendly name default response has a 3xx status code +func (o *DeleteRepoPoolByFriendlyNameDefault) IsRedirect() bool { + return o._statusCode/100 == 3 +} + +// IsClientError returns true when this delete repo pool by friendly name default response has a 4xx status code +func (o *DeleteRepoPoolByFriendlyNameDefault) IsClientError() bool { + return o._statusCode/100 == 4 +} + +// IsServerError returns true when this delete repo pool by friendly name default response has a 5xx status code +func (o *DeleteRepoPoolByFriendlyNameDefault) IsServerError() bool { + return o._statusCode/100 == 5 +} + +// IsCode returns true when this delete repo pool by friendly name default response a status code equal to that given +func (o *DeleteRepoPoolByFriendlyNameDefault) IsCode(code int) bool { + return o._statusCode == code +} + +// Code gets the status code for the delete repo pool by friendly name default response +func (o *DeleteRepoPoolByFriendlyNameDefault) Code() int { + return o._statusCode +} + +func (o *DeleteRepoPoolByFriendlyNameDefault) Error() string { + payload, _ := json.Marshal(o.Payload) + return fmt.Sprintf("[DELETE /repositories/{owner}/{repo}/pools/{poolID}][%d] DeleteRepoPoolByFriendlyName default %s", o._statusCode, payload) +} + +func (o *DeleteRepoPoolByFriendlyNameDefault) String() string { + payload, _ := json.Marshal(o.Payload) + return fmt.Sprintf("[DELETE /repositories/{owner}/{repo}/pools/{poolID}][%d] DeleteRepoPoolByFriendlyName default %s", o._statusCode, payload) +} + +func (o *DeleteRepoPoolByFriendlyNameDefault) GetPayload() apiserver_params.APIErrorResponse { + return o.Payload +} + +func (o *DeleteRepoPoolByFriendlyNameDefault) readResponse(response runtime.ClientResponse, consumer runtime.Consumer, formats strfmt.Registry) error { + + // response payload + if err := consumer.Consume(response.Body(), &o.Payload); err != nil && err != io.EOF { + return err + } + + return nil +} diff --git a/client/repositories/get_repo_by_friendly_name_parameters.go b/client/repositories/get_repo_by_friendly_name_parameters.go new file mode 100644 index 000000000..147fce393 --- /dev/null +++ b/client/repositories/get_repo_by_friendly_name_parameters.go @@ -0,0 +1,207 @@ +// Code generated by go-swagger; DO NOT EDIT. + +package repositories + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "context" + "net/http" + "time" + + "github.com/go-openapi/errors" + "github.com/go-openapi/runtime" + cr "github.com/go-openapi/runtime/client" + "github.com/go-openapi/strfmt" +) + +// NewGetRepoByFriendlyNameParams creates a new GetRepoByFriendlyNameParams object, +// with the default timeout for this client. +// +// Default values are not hydrated, since defaults are normally applied by the API server side. +// +// To enforce default values in parameter, use SetDefaults or WithDefaults. +func NewGetRepoByFriendlyNameParams() *GetRepoByFriendlyNameParams { + return &GetRepoByFriendlyNameParams{ + timeout: cr.DefaultTimeout, + } +} + +// NewGetRepoByFriendlyNameParamsWithTimeout creates a new GetRepoByFriendlyNameParams object +// with the ability to set a timeout on a request. +func NewGetRepoByFriendlyNameParamsWithTimeout(timeout time.Duration) *GetRepoByFriendlyNameParams { + return &GetRepoByFriendlyNameParams{ + timeout: timeout, + } +} + +// NewGetRepoByFriendlyNameParamsWithContext creates a new GetRepoByFriendlyNameParams object +// with the ability to set a context for a request. +func NewGetRepoByFriendlyNameParamsWithContext(ctx context.Context) *GetRepoByFriendlyNameParams { + return &GetRepoByFriendlyNameParams{ + Context: ctx, + } +} + +// NewGetRepoByFriendlyNameParamsWithHTTPClient creates a new GetRepoByFriendlyNameParams object +// with the ability to set a custom HTTPClient for a request. +func NewGetRepoByFriendlyNameParamsWithHTTPClient(client *http.Client) *GetRepoByFriendlyNameParams { + return &GetRepoByFriendlyNameParams{ + HTTPClient: client, + } +} + +/* +GetRepoByFriendlyNameParams contains all the parameters to send to the API endpoint + + for the get repo by friendly name operation. + + Typically these are written to a http.Request. +*/ +type GetRepoByFriendlyNameParams struct { + + /* EndpointName. + + endpointName of the repository to fetch. + */ + EndpointName *string + + /* Owner. + + owner of the repository to fetch. + */ + Owner string + + /* Repo. + + name of the repository to fetch. + */ + Repo string + + timeout time.Duration + Context context.Context + HTTPClient *http.Client +} + +// WithDefaults hydrates default values in the get repo by friendly name params (not the query body). +// +// All values with no default are reset to their zero value. +func (o *GetRepoByFriendlyNameParams) WithDefaults() *GetRepoByFriendlyNameParams { + o.SetDefaults() + return o +} + +// SetDefaults hydrates default values in the get repo by friendly name params (not the query body). +// +// All values with no default are reset to their zero value. +func (o *GetRepoByFriendlyNameParams) SetDefaults() { + // no default values defined for this parameter +} + +// WithTimeout adds the timeout to the get repo by friendly name params +func (o *GetRepoByFriendlyNameParams) WithTimeout(timeout time.Duration) *GetRepoByFriendlyNameParams { + o.SetTimeout(timeout) + return o +} + +// SetTimeout adds the timeout to the get repo by friendly name params +func (o *GetRepoByFriendlyNameParams) SetTimeout(timeout time.Duration) { + o.timeout = timeout +} + +// WithContext adds the context to the get repo by friendly name params +func (o *GetRepoByFriendlyNameParams) WithContext(ctx context.Context) *GetRepoByFriendlyNameParams { + o.SetContext(ctx) + return o +} + +// SetContext adds the context to the get repo by friendly name params +func (o *GetRepoByFriendlyNameParams) SetContext(ctx context.Context) { + o.Context = ctx +} + +// WithHTTPClient adds the HTTPClient to the get repo by friendly name params +func (o *GetRepoByFriendlyNameParams) WithHTTPClient(client *http.Client) *GetRepoByFriendlyNameParams { + o.SetHTTPClient(client) + return o +} + +// SetHTTPClient adds the HTTPClient to the get repo by friendly name params +func (o *GetRepoByFriendlyNameParams) SetHTTPClient(client *http.Client) { + o.HTTPClient = client +} + +// WithEndpointName adds the endpointName to the get repo by friendly name params +func (o *GetRepoByFriendlyNameParams) WithEndpointName(endpointName *string) *GetRepoByFriendlyNameParams { + o.SetEndpointName(endpointName) + return o +} + +// SetEndpointName adds the endpointName to the get repo by friendly name params +func (o *GetRepoByFriendlyNameParams) SetEndpointName(endpointName *string) { + o.EndpointName = endpointName +} + +// WithOwner adds the owner to the get repo by friendly name params +func (o *GetRepoByFriendlyNameParams) WithOwner(owner string) *GetRepoByFriendlyNameParams { + o.SetOwner(owner) + return o +} + +// SetOwner adds the owner to the get repo by friendly name params +func (o *GetRepoByFriendlyNameParams) SetOwner(owner string) { + o.Owner = owner +} + +// WithRepo adds the repo to the get repo by friendly name params +func (o *GetRepoByFriendlyNameParams) WithRepo(repo string) *GetRepoByFriendlyNameParams { + o.SetRepo(repo) + return o +} + +// SetRepo adds the repo to the get repo by friendly name params +func (o *GetRepoByFriendlyNameParams) SetRepo(repo string) { + o.Repo = repo +} + +// WriteToRequest writes these params to a swagger request +func (o *GetRepoByFriendlyNameParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error { + + if err := r.SetTimeout(o.timeout); err != nil { + return err + } + var res []error + + if o.EndpointName != nil { + + // query param endpointName + var qrEndpointName string + + if o.EndpointName != nil { + qrEndpointName = *o.EndpointName + } + qEndpointName := qrEndpointName + if qEndpointName != "" { + + if err := r.SetQueryParam("endpointName", qEndpointName); err != nil { + return err + } + } + } + + // path param owner + if err := r.SetPathParam("owner", o.Owner); err != nil { + return err + } + + // path param repo + if err := r.SetPathParam("repo", o.Repo); err != nil { + return err + } + + if len(res) > 0 { + return errors.CompositeValidationError(res...) + } + return nil +} diff --git a/client/repositories/get_repo_by_friendly_name_responses.go b/client/repositories/get_repo_by_friendly_name_responses.go new file mode 100644 index 000000000..1d5321ff3 --- /dev/null +++ b/client/repositories/get_repo_by_friendly_name_responses.go @@ -0,0 +1,184 @@ +// Code generated by go-swagger; DO NOT EDIT. + +package repositories + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "encoding/json" + "fmt" + "io" + + "github.com/go-openapi/runtime" + "github.com/go-openapi/strfmt" + + apiserver_params "github.com/cloudbase/garm/apiserver/params" + garm_params "github.com/cloudbase/garm/params" +) + +// GetRepoByFriendlyNameReader is a Reader for the GetRepoByFriendlyName structure. +type GetRepoByFriendlyNameReader struct { + formats strfmt.Registry +} + +// ReadResponse reads a server response into the received o. +func (o *GetRepoByFriendlyNameReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error) { + switch response.Code() { + case 200: + result := NewGetRepoByFriendlyNameOK() + if err := result.readResponse(response, consumer, o.formats); err != nil { + return nil, err + } + return result, nil + default: + result := NewGetRepoByFriendlyNameDefault(response.Code()) + if err := result.readResponse(response, consumer, o.formats); err != nil { + return nil, err + } + if response.Code()/100 == 2 { + return result, nil + } + return nil, result + } +} + +// NewGetRepoByFriendlyNameOK creates a GetRepoByFriendlyNameOK with default headers values +func NewGetRepoByFriendlyNameOK() *GetRepoByFriendlyNameOK { + return &GetRepoByFriendlyNameOK{} +} + +/* +GetRepoByFriendlyNameOK describes a response with status code 200, with default header values. + +Repository +*/ +type GetRepoByFriendlyNameOK struct { + Payload garm_params.Repository +} + +// IsSuccess returns true when this get repo by friendly name o k response has a 2xx status code +func (o *GetRepoByFriendlyNameOK) IsSuccess() bool { + return true +} + +// IsRedirect returns true when this get repo by friendly name o k response has a 3xx status code +func (o *GetRepoByFriendlyNameOK) IsRedirect() bool { + return false +} + +// IsClientError returns true when this get repo by friendly name o k response has a 4xx status code +func (o *GetRepoByFriendlyNameOK) IsClientError() bool { + return false +} + +// IsServerError returns true when this get repo by friendly name o k response has a 5xx status code +func (o *GetRepoByFriendlyNameOK) IsServerError() bool { + return false +} + +// IsCode returns true when this get repo by friendly name o k response a status code equal to that given +func (o *GetRepoByFriendlyNameOK) IsCode(code int) bool { + return code == 200 +} + +// Code gets the status code for the get repo by friendly name o k response +func (o *GetRepoByFriendlyNameOK) Code() int { + return 200 +} + +func (o *GetRepoByFriendlyNameOK) Error() string { + payload, _ := json.Marshal(o.Payload) + return fmt.Sprintf("[GET /repositories/{owner}/{repo}][%d] getRepoByFriendlyNameOK %s", 200, payload) +} + +func (o *GetRepoByFriendlyNameOK) String() string { + payload, _ := json.Marshal(o.Payload) + return fmt.Sprintf("[GET /repositories/{owner}/{repo}][%d] getRepoByFriendlyNameOK %s", 200, payload) +} + +func (o *GetRepoByFriendlyNameOK) GetPayload() garm_params.Repository { + return o.Payload +} + +func (o *GetRepoByFriendlyNameOK) readResponse(response runtime.ClientResponse, consumer runtime.Consumer, formats strfmt.Registry) error { + + // response payload + if err := consumer.Consume(response.Body(), &o.Payload); err != nil && err != io.EOF { + return err + } + + return nil +} + +// NewGetRepoByFriendlyNameDefault creates a GetRepoByFriendlyNameDefault with default headers values +func NewGetRepoByFriendlyNameDefault(code int) *GetRepoByFriendlyNameDefault { + return &GetRepoByFriendlyNameDefault{ + _statusCode: code, + } +} + +/* +GetRepoByFriendlyNameDefault describes a response with status code -1, with default header values. + +APIErrorResponse +*/ +type GetRepoByFriendlyNameDefault struct { + _statusCode int + + Payload apiserver_params.APIErrorResponse +} + +// IsSuccess returns true when this get repo by friendly name default response has a 2xx status code +func (o *GetRepoByFriendlyNameDefault) IsSuccess() bool { + return o._statusCode/100 == 2 +} + +// IsRedirect returns true when this get repo by friendly name default response has a 3xx status code +func (o *GetRepoByFriendlyNameDefault) IsRedirect() bool { + return o._statusCode/100 == 3 +} + +// IsClientError returns true when this get repo by friendly name default response has a 4xx status code +func (o *GetRepoByFriendlyNameDefault) IsClientError() bool { + return o._statusCode/100 == 4 +} + +// IsServerError returns true when this get repo by friendly name default response has a 5xx status code +func (o *GetRepoByFriendlyNameDefault) IsServerError() bool { + return o._statusCode/100 == 5 +} + +// IsCode returns true when this get repo by friendly name default response a status code equal to that given +func (o *GetRepoByFriendlyNameDefault) IsCode(code int) bool { + return o._statusCode == code +} + +// Code gets the status code for the get repo by friendly name default response +func (o *GetRepoByFriendlyNameDefault) Code() int { + return o._statusCode +} + +func (o *GetRepoByFriendlyNameDefault) Error() string { + payload, _ := json.Marshal(o.Payload) + return fmt.Sprintf("[GET /repositories/{owner}/{repo}][%d] GetRepoByFriendlyName default %s", o._statusCode, payload) +} + +func (o *GetRepoByFriendlyNameDefault) String() string { + payload, _ := json.Marshal(o.Payload) + return fmt.Sprintf("[GET /repositories/{owner}/{repo}][%d] GetRepoByFriendlyName default %s", o._statusCode, payload) +} + +func (o *GetRepoByFriendlyNameDefault) GetPayload() apiserver_params.APIErrorResponse { + return o.Payload +} + +func (o *GetRepoByFriendlyNameDefault) readResponse(response runtime.ClientResponse, consumer runtime.Consumer, formats strfmt.Registry) error { + + // response payload + if err := consumer.Consume(response.Body(), &o.Payload); err != nil && err != io.EOF { + return err + } + + return nil +} diff --git a/client/repositories/get_repo_pool_by_friendly_name_parameters.go b/client/repositories/get_repo_pool_by_friendly_name_parameters.go new file mode 100644 index 000000000..85d41cb36 --- /dev/null +++ b/client/repositories/get_repo_pool_by_friendly_name_parameters.go @@ -0,0 +1,229 @@ +// Code generated by go-swagger; DO NOT EDIT. + +package repositories + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "context" + "net/http" + "time" + + "github.com/go-openapi/errors" + "github.com/go-openapi/runtime" + cr "github.com/go-openapi/runtime/client" + "github.com/go-openapi/strfmt" +) + +// NewGetRepoPoolByFriendlyNameParams creates a new GetRepoPoolByFriendlyNameParams object, +// with the default timeout for this client. +// +// Default values are not hydrated, since defaults are normally applied by the API server side. +// +// To enforce default values in parameter, use SetDefaults or WithDefaults. +func NewGetRepoPoolByFriendlyNameParams() *GetRepoPoolByFriendlyNameParams { + return &GetRepoPoolByFriendlyNameParams{ + timeout: cr.DefaultTimeout, + } +} + +// NewGetRepoPoolByFriendlyNameParamsWithTimeout creates a new GetRepoPoolByFriendlyNameParams object +// with the ability to set a timeout on a request. +func NewGetRepoPoolByFriendlyNameParamsWithTimeout(timeout time.Duration) *GetRepoPoolByFriendlyNameParams { + return &GetRepoPoolByFriendlyNameParams{ + timeout: timeout, + } +} + +// NewGetRepoPoolByFriendlyNameParamsWithContext creates a new GetRepoPoolByFriendlyNameParams object +// with the ability to set a context for a request. +func NewGetRepoPoolByFriendlyNameParamsWithContext(ctx context.Context) *GetRepoPoolByFriendlyNameParams { + return &GetRepoPoolByFriendlyNameParams{ + Context: ctx, + } +} + +// NewGetRepoPoolByFriendlyNameParamsWithHTTPClient creates a new GetRepoPoolByFriendlyNameParams object +// with the ability to set a custom HTTPClient for a request. +func NewGetRepoPoolByFriendlyNameParamsWithHTTPClient(client *http.Client) *GetRepoPoolByFriendlyNameParams { + return &GetRepoPoolByFriendlyNameParams{ + HTTPClient: client, + } +} + +/* +GetRepoPoolByFriendlyNameParams contains all the parameters to send to the API endpoint + + for the get repo pool by friendly name operation. + + Typically these are written to a http.Request. +*/ +type GetRepoPoolByFriendlyNameParams struct { + + /* EndpointName. + + Repository endpointName. + */ + EndpointName *string + + /* Owner. + + Repository owner. + */ + Owner string + + /* PoolID. + + Pool ID. + */ + PoolID string + + /* Repo. + + Repository name. + */ + Repo string + + timeout time.Duration + Context context.Context + HTTPClient *http.Client +} + +// WithDefaults hydrates default values in the get repo pool by friendly name params (not the query body). +// +// All values with no default are reset to their zero value. +func (o *GetRepoPoolByFriendlyNameParams) WithDefaults() *GetRepoPoolByFriendlyNameParams { + o.SetDefaults() + return o +} + +// SetDefaults hydrates default values in the get repo pool by friendly name params (not the query body). +// +// All values with no default are reset to their zero value. +func (o *GetRepoPoolByFriendlyNameParams) SetDefaults() { + // no default values defined for this parameter +} + +// WithTimeout adds the timeout to the get repo pool by friendly name params +func (o *GetRepoPoolByFriendlyNameParams) WithTimeout(timeout time.Duration) *GetRepoPoolByFriendlyNameParams { + o.SetTimeout(timeout) + return o +} + +// SetTimeout adds the timeout to the get repo pool by friendly name params +func (o *GetRepoPoolByFriendlyNameParams) SetTimeout(timeout time.Duration) { + o.timeout = timeout +} + +// WithContext adds the context to the get repo pool by friendly name params +func (o *GetRepoPoolByFriendlyNameParams) WithContext(ctx context.Context) *GetRepoPoolByFriendlyNameParams { + o.SetContext(ctx) + return o +} + +// SetContext adds the context to the get repo pool by friendly name params +func (o *GetRepoPoolByFriendlyNameParams) SetContext(ctx context.Context) { + o.Context = ctx +} + +// WithHTTPClient adds the HTTPClient to the get repo pool by friendly name params +func (o *GetRepoPoolByFriendlyNameParams) WithHTTPClient(client *http.Client) *GetRepoPoolByFriendlyNameParams { + o.SetHTTPClient(client) + return o +} + +// SetHTTPClient adds the HTTPClient to the get repo pool by friendly name params +func (o *GetRepoPoolByFriendlyNameParams) SetHTTPClient(client *http.Client) { + o.HTTPClient = client +} + +// WithEndpointName adds the endpointName to the get repo pool by friendly name params +func (o *GetRepoPoolByFriendlyNameParams) WithEndpointName(endpointName *string) *GetRepoPoolByFriendlyNameParams { + o.SetEndpointName(endpointName) + return o +} + +// SetEndpointName adds the endpointName to the get repo pool by friendly name params +func (o *GetRepoPoolByFriendlyNameParams) SetEndpointName(endpointName *string) { + o.EndpointName = endpointName +} + +// WithOwner adds the owner to the get repo pool by friendly name params +func (o *GetRepoPoolByFriendlyNameParams) WithOwner(owner string) *GetRepoPoolByFriendlyNameParams { + o.SetOwner(owner) + return o +} + +// SetOwner adds the owner to the get repo pool by friendly name params +func (o *GetRepoPoolByFriendlyNameParams) SetOwner(owner string) { + o.Owner = owner +} + +// WithPoolID adds the poolID to the get repo pool by friendly name params +func (o *GetRepoPoolByFriendlyNameParams) WithPoolID(poolID string) *GetRepoPoolByFriendlyNameParams { + o.SetPoolID(poolID) + return o +} + +// SetPoolID adds the poolId to the get repo pool by friendly name params +func (o *GetRepoPoolByFriendlyNameParams) SetPoolID(poolID string) { + o.PoolID = poolID +} + +// WithRepo adds the repo to the get repo pool by friendly name params +func (o *GetRepoPoolByFriendlyNameParams) WithRepo(repo string) *GetRepoPoolByFriendlyNameParams { + o.SetRepo(repo) + return o +} + +// SetRepo adds the repo to the get repo pool by friendly name params +func (o *GetRepoPoolByFriendlyNameParams) SetRepo(repo string) { + o.Repo = repo +} + +// WriteToRequest writes these params to a swagger request +func (o *GetRepoPoolByFriendlyNameParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error { + + if err := r.SetTimeout(o.timeout); err != nil { + return err + } + var res []error + + if o.EndpointName != nil { + + // query param endpointName + var qrEndpointName string + + if o.EndpointName != nil { + qrEndpointName = *o.EndpointName + } + qEndpointName := qrEndpointName + if qEndpointName != "" { + + if err := r.SetQueryParam("endpointName", qEndpointName); err != nil { + return err + } + } + } + + // path param owner + if err := r.SetPathParam("owner", o.Owner); err != nil { + return err + } + + // path param poolID + if err := r.SetPathParam("poolID", o.PoolID); err != nil { + return err + } + + // path param repo + if err := r.SetPathParam("repo", o.Repo); err != nil { + return err + } + + if len(res) > 0 { + return errors.CompositeValidationError(res...) + } + return nil +} diff --git a/client/repositories/get_repo_pool_by_friendly_name_responses.go b/client/repositories/get_repo_pool_by_friendly_name_responses.go new file mode 100644 index 000000000..95604c2c1 --- /dev/null +++ b/client/repositories/get_repo_pool_by_friendly_name_responses.go @@ -0,0 +1,184 @@ +// Code generated by go-swagger; DO NOT EDIT. + +package repositories + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "encoding/json" + "fmt" + "io" + + "github.com/go-openapi/runtime" + "github.com/go-openapi/strfmt" + + apiserver_params "github.com/cloudbase/garm/apiserver/params" + garm_params "github.com/cloudbase/garm/params" +) + +// GetRepoPoolByFriendlyNameReader is a Reader for the GetRepoPoolByFriendlyName structure. +type GetRepoPoolByFriendlyNameReader struct { + formats strfmt.Registry +} + +// ReadResponse reads a server response into the received o. +func (o *GetRepoPoolByFriendlyNameReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error) { + switch response.Code() { + case 200: + result := NewGetRepoPoolByFriendlyNameOK() + if err := result.readResponse(response, consumer, o.formats); err != nil { + return nil, err + } + return result, nil + default: + result := NewGetRepoPoolByFriendlyNameDefault(response.Code()) + if err := result.readResponse(response, consumer, o.formats); err != nil { + return nil, err + } + if response.Code()/100 == 2 { + return result, nil + } + return nil, result + } +} + +// NewGetRepoPoolByFriendlyNameOK creates a GetRepoPoolByFriendlyNameOK with default headers values +func NewGetRepoPoolByFriendlyNameOK() *GetRepoPoolByFriendlyNameOK { + return &GetRepoPoolByFriendlyNameOK{} +} + +/* +GetRepoPoolByFriendlyNameOK describes a response with status code 200, with default header values. + +Pool +*/ +type GetRepoPoolByFriendlyNameOK struct { + Payload garm_params.Pool +} + +// IsSuccess returns true when this get repo pool by friendly name o k response has a 2xx status code +func (o *GetRepoPoolByFriendlyNameOK) IsSuccess() bool { + return true +} + +// IsRedirect returns true when this get repo pool by friendly name o k response has a 3xx status code +func (o *GetRepoPoolByFriendlyNameOK) IsRedirect() bool { + return false +} + +// IsClientError returns true when this get repo pool by friendly name o k response has a 4xx status code +func (o *GetRepoPoolByFriendlyNameOK) IsClientError() bool { + return false +} + +// IsServerError returns true when this get repo pool by friendly name o k response has a 5xx status code +func (o *GetRepoPoolByFriendlyNameOK) IsServerError() bool { + return false +} + +// IsCode returns true when this get repo pool by friendly name o k response a status code equal to that given +func (o *GetRepoPoolByFriendlyNameOK) IsCode(code int) bool { + return code == 200 +} + +// Code gets the status code for the get repo pool by friendly name o k response +func (o *GetRepoPoolByFriendlyNameOK) Code() int { + return 200 +} + +func (o *GetRepoPoolByFriendlyNameOK) Error() string { + payload, _ := json.Marshal(o.Payload) + return fmt.Sprintf("[GET /repositories/{owner}/{repo}/pools/{poolID}][%d] getRepoPoolByFriendlyNameOK %s", 200, payload) +} + +func (o *GetRepoPoolByFriendlyNameOK) String() string { + payload, _ := json.Marshal(o.Payload) + return fmt.Sprintf("[GET /repositories/{owner}/{repo}/pools/{poolID}][%d] getRepoPoolByFriendlyNameOK %s", 200, payload) +} + +func (o *GetRepoPoolByFriendlyNameOK) GetPayload() garm_params.Pool { + return o.Payload +} + +func (o *GetRepoPoolByFriendlyNameOK) readResponse(response runtime.ClientResponse, consumer runtime.Consumer, formats strfmt.Registry) error { + + // response payload + if err := consumer.Consume(response.Body(), &o.Payload); err != nil && err != io.EOF { + return err + } + + return nil +} + +// NewGetRepoPoolByFriendlyNameDefault creates a GetRepoPoolByFriendlyNameDefault with default headers values +func NewGetRepoPoolByFriendlyNameDefault(code int) *GetRepoPoolByFriendlyNameDefault { + return &GetRepoPoolByFriendlyNameDefault{ + _statusCode: code, + } +} + +/* +GetRepoPoolByFriendlyNameDefault describes a response with status code -1, with default header values. + +APIErrorResponse +*/ +type GetRepoPoolByFriendlyNameDefault struct { + _statusCode int + + Payload apiserver_params.APIErrorResponse +} + +// IsSuccess returns true when this get repo pool by friendly name default response has a 2xx status code +func (o *GetRepoPoolByFriendlyNameDefault) IsSuccess() bool { + return o._statusCode/100 == 2 +} + +// IsRedirect returns true when this get repo pool by friendly name default response has a 3xx status code +func (o *GetRepoPoolByFriendlyNameDefault) IsRedirect() bool { + return o._statusCode/100 == 3 +} + +// IsClientError returns true when this get repo pool by friendly name default response has a 4xx status code +func (o *GetRepoPoolByFriendlyNameDefault) IsClientError() bool { + return o._statusCode/100 == 4 +} + +// IsServerError returns true when this get repo pool by friendly name default response has a 5xx status code +func (o *GetRepoPoolByFriendlyNameDefault) IsServerError() bool { + return o._statusCode/100 == 5 +} + +// IsCode returns true when this get repo pool by friendly name default response a status code equal to that given +func (o *GetRepoPoolByFriendlyNameDefault) IsCode(code int) bool { + return o._statusCode == code +} + +// Code gets the status code for the get repo pool by friendly name default response +func (o *GetRepoPoolByFriendlyNameDefault) Code() int { + return o._statusCode +} + +func (o *GetRepoPoolByFriendlyNameDefault) Error() string { + payload, _ := json.Marshal(o.Payload) + return fmt.Sprintf("[GET /repositories/{owner}/{repo}/pools/{poolID}][%d] GetRepoPoolByFriendlyName default %s", o._statusCode, payload) +} + +func (o *GetRepoPoolByFriendlyNameDefault) String() string { + payload, _ := json.Marshal(o.Payload) + return fmt.Sprintf("[GET /repositories/{owner}/{repo}/pools/{poolID}][%d] GetRepoPoolByFriendlyName default %s", o._statusCode, payload) +} + +func (o *GetRepoPoolByFriendlyNameDefault) GetPayload() apiserver_params.APIErrorResponse { + return o.Payload +} + +func (o *GetRepoPoolByFriendlyNameDefault) readResponse(response runtime.ClientResponse, consumer runtime.Consumer, formats strfmt.Registry) error { + + // response payload + if err := consumer.Consume(response.Body(), &o.Payload); err != nil && err != io.EOF { + return err + } + + return nil +} diff --git a/client/repositories/get_repo_webhook_info_by_friendly_name_parameters.go b/client/repositories/get_repo_webhook_info_by_friendly_name_parameters.go new file mode 100644 index 000000000..ec2f7d6a6 --- /dev/null +++ b/client/repositories/get_repo_webhook_info_by_friendly_name_parameters.go @@ -0,0 +1,207 @@ +// Code generated by go-swagger; DO NOT EDIT. + +package repositories + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "context" + "net/http" + "time" + + "github.com/go-openapi/errors" + "github.com/go-openapi/runtime" + cr "github.com/go-openapi/runtime/client" + "github.com/go-openapi/strfmt" +) + +// NewGetRepoWebhookInfoByFriendlyNameParams creates a new GetRepoWebhookInfoByFriendlyNameParams object, +// with the default timeout for this client. +// +// Default values are not hydrated, since defaults are normally applied by the API server side. +// +// To enforce default values in parameter, use SetDefaults or WithDefaults. +func NewGetRepoWebhookInfoByFriendlyNameParams() *GetRepoWebhookInfoByFriendlyNameParams { + return &GetRepoWebhookInfoByFriendlyNameParams{ + timeout: cr.DefaultTimeout, + } +} + +// NewGetRepoWebhookInfoByFriendlyNameParamsWithTimeout creates a new GetRepoWebhookInfoByFriendlyNameParams object +// with the ability to set a timeout on a request. +func NewGetRepoWebhookInfoByFriendlyNameParamsWithTimeout(timeout time.Duration) *GetRepoWebhookInfoByFriendlyNameParams { + return &GetRepoWebhookInfoByFriendlyNameParams{ + timeout: timeout, + } +} + +// NewGetRepoWebhookInfoByFriendlyNameParamsWithContext creates a new GetRepoWebhookInfoByFriendlyNameParams object +// with the ability to set a context for a request. +func NewGetRepoWebhookInfoByFriendlyNameParamsWithContext(ctx context.Context) *GetRepoWebhookInfoByFriendlyNameParams { + return &GetRepoWebhookInfoByFriendlyNameParams{ + Context: ctx, + } +} + +// NewGetRepoWebhookInfoByFriendlyNameParamsWithHTTPClient creates a new GetRepoWebhookInfoByFriendlyNameParams object +// with the ability to set a custom HTTPClient for a request. +func NewGetRepoWebhookInfoByFriendlyNameParamsWithHTTPClient(client *http.Client) *GetRepoWebhookInfoByFriendlyNameParams { + return &GetRepoWebhookInfoByFriendlyNameParams{ + HTTPClient: client, + } +} + +/* +GetRepoWebhookInfoByFriendlyNameParams contains all the parameters to send to the API endpoint + + for the get repo webhook info by friendly name operation. + + Typically these are written to a http.Request. +*/ +type GetRepoWebhookInfoByFriendlyNameParams struct { + + /* EndpointName. + + Repository endpointName. + */ + EndpointName *string + + /* Owner. + + Repository owner. + */ + Owner string + + /* Repo. + + Repository name. + */ + Repo string + + timeout time.Duration + Context context.Context + HTTPClient *http.Client +} + +// WithDefaults hydrates default values in the get repo webhook info by friendly name params (not the query body). +// +// All values with no default are reset to their zero value. +func (o *GetRepoWebhookInfoByFriendlyNameParams) WithDefaults() *GetRepoWebhookInfoByFriendlyNameParams { + o.SetDefaults() + return o +} + +// SetDefaults hydrates default values in the get repo webhook info by friendly name params (not the query body). +// +// All values with no default are reset to their zero value. +func (o *GetRepoWebhookInfoByFriendlyNameParams) SetDefaults() { + // no default values defined for this parameter +} + +// WithTimeout adds the timeout to the get repo webhook info by friendly name params +func (o *GetRepoWebhookInfoByFriendlyNameParams) WithTimeout(timeout time.Duration) *GetRepoWebhookInfoByFriendlyNameParams { + o.SetTimeout(timeout) + return o +} + +// SetTimeout adds the timeout to the get repo webhook info by friendly name params +func (o *GetRepoWebhookInfoByFriendlyNameParams) SetTimeout(timeout time.Duration) { + o.timeout = timeout +} + +// WithContext adds the context to the get repo webhook info by friendly name params +func (o *GetRepoWebhookInfoByFriendlyNameParams) WithContext(ctx context.Context) *GetRepoWebhookInfoByFriendlyNameParams { + o.SetContext(ctx) + return o +} + +// SetContext adds the context to the get repo webhook info by friendly name params +func (o *GetRepoWebhookInfoByFriendlyNameParams) SetContext(ctx context.Context) { + o.Context = ctx +} + +// WithHTTPClient adds the HTTPClient to the get repo webhook info by friendly name params +func (o *GetRepoWebhookInfoByFriendlyNameParams) WithHTTPClient(client *http.Client) *GetRepoWebhookInfoByFriendlyNameParams { + o.SetHTTPClient(client) + return o +} + +// SetHTTPClient adds the HTTPClient to the get repo webhook info by friendly name params +func (o *GetRepoWebhookInfoByFriendlyNameParams) SetHTTPClient(client *http.Client) { + o.HTTPClient = client +} + +// WithEndpointName adds the endpointName to the get repo webhook info by friendly name params +func (o *GetRepoWebhookInfoByFriendlyNameParams) WithEndpointName(endpointName *string) *GetRepoWebhookInfoByFriendlyNameParams { + o.SetEndpointName(endpointName) + return o +} + +// SetEndpointName adds the endpointName to the get repo webhook info by friendly name params +func (o *GetRepoWebhookInfoByFriendlyNameParams) SetEndpointName(endpointName *string) { + o.EndpointName = endpointName +} + +// WithOwner adds the owner to the get repo webhook info by friendly name params +func (o *GetRepoWebhookInfoByFriendlyNameParams) WithOwner(owner string) *GetRepoWebhookInfoByFriendlyNameParams { + o.SetOwner(owner) + return o +} + +// SetOwner adds the owner to the get repo webhook info by friendly name params +func (o *GetRepoWebhookInfoByFriendlyNameParams) SetOwner(owner string) { + o.Owner = owner +} + +// WithRepo adds the repo to the get repo webhook info by friendly name params +func (o *GetRepoWebhookInfoByFriendlyNameParams) WithRepo(repo string) *GetRepoWebhookInfoByFriendlyNameParams { + o.SetRepo(repo) + return o +} + +// SetRepo adds the repo to the get repo webhook info by friendly name params +func (o *GetRepoWebhookInfoByFriendlyNameParams) SetRepo(repo string) { + o.Repo = repo +} + +// WriteToRequest writes these params to a swagger request +func (o *GetRepoWebhookInfoByFriendlyNameParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error { + + if err := r.SetTimeout(o.timeout); err != nil { + return err + } + var res []error + + if o.EndpointName != nil { + + // query param endpointName + var qrEndpointName string + + if o.EndpointName != nil { + qrEndpointName = *o.EndpointName + } + qEndpointName := qrEndpointName + if qEndpointName != "" { + + if err := r.SetQueryParam("endpointName", qEndpointName); err != nil { + return err + } + } + } + + // path param owner + if err := r.SetPathParam("owner", o.Owner); err != nil { + return err + } + + // path param repo + if err := r.SetPathParam("repo", o.Repo); err != nil { + return err + } + + if len(res) > 0 { + return errors.CompositeValidationError(res...) + } + return nil +} diff --git a/client/repositories/get_repo_webhook_info_by_friendly_name_responses.go b/client/repositories/get_repo_webhook_info_by_friendly_name_responses.go new file mode 100644 index 000000000..16ba5b8df --- /dev/null +++ b/client/repositories/get_repo_webhook_info_by_friendly_name_responses.go @@ -0,0 +1,184 @@ +// Code generated by go-swagger; DO NOT EDIT. + +package repositories + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "encoding/json" + "fmt" + "io" + + "github.com/go-openapi/runtime" + "github.com/go-openapi/strfmt" + + apiserver_params "github.com/cloudbase/garm/apiserver/params" + garm_params "github.com/cloudbase/garm/params" +) + +// GetRepoWebhookInfoByFriendlyNameReader is a Reader for the GetRepoWebhookInfoByFriendlyName structure. +type GetRepoWebhookInfoByFriendlyNameReader struct { + formats strfmt.Registry +} + +// ReadResponse reads a server response into the received o. +func (o *GetRepoWebhookInfoByFriendlyNameReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error) { + switch response.Code() { + case 200: + result := NewGetRepoWebhookInfoByFriendlyNameOK() + if err := result.readResponse(response, consumer, o.formats); err != nil { + return nil, err + } + return result, nil + default: + result := NewGetRepoWebhookInfoByFriendlyNameDefault(response.Code()) + if err := result.readResponse(response, consumer, o.formats); err != nil { + return nil, err + } + if response.Code()/100 == 2 { + return result, nil + } + return nil, result + } +} + +// NewGetRepoWebhookInfoByFriendlyNameOK creates a GetRepoWebhookInfoByFriendlyNameOK with default headers values +func NewGetRepoWebhookInfoByFriendlyNameOK() *GetRepoWebhookInfoByFriendlyNameOK { + return &GetRepoWebhookInfoByFriendlyNameOK{} +} + +/* +GetRepoWebhookInfoByFriendlyNameOK describes a response with status code 200, with default header values. + +HookInfo +*/ +type GetRepoWebhookInfoByFriendlyNameOK struct { + Payload garm_params.HookInfo +} + +// IsSuccess returns true when this get repo webhook info by friendly name o k response has a 2xx status code +func (o *GetRepoWebhookInfoByFriendlyNameOK) IsSuccess() bool { + return true +} + +// IsRedirect returns true when this get repo webhook info by friendly name o k response has a 3xx status code +func (o *GetRepoWebhookInfoByFriendlyNameOK) IsRedirect() bool { + return false +} + +// IsClientError returns true when this get repo webhook info by friendly name o k response has a 4xx status code +func (o *GetRepoWebhookInfoByFriendlyNameOK) IsClientError() bool { + return false +} + +// IsServerError returns true when this get repo webhook info by friendly name o k response has a 5xx status code +func (o *GetRepoWebhookInfoByFriendlyNameOK) IsServerError() bool { + return false +} + +// IsCode returns true when this get repo webhook info by friendly name o k response a status code equal to that given +func (o *GetRepoWebhookInfoByFriendlyNameOK) IsCode(code int) bool { + return code == 200 +} + +// Code gets the status code for the get repo webhook info by friendly name o k response +func (o *GetRepoWebhookInfoByFriendlyNameOK) Code() int { + return 200 +} + +func (o *GetRepoWebhookInfoByFriendlyNameOK) Error() string { + payload, _ := json.Marshal(o.Payload) + return fmt.Sprintf("[GET /repositories/{owner}/{repo}/webhook][%d] getRepoWebhookInfoByFriendlyNameOK %s", 200, payload) +} + +func (o *GetRepoWebhookInfoByFriendlyNameOK) String() string { + payload, _ := json.Marshal(o.Payload) + return fmt.Sprintf("[GET /repositories/{owner}/{repo}/webhook][%d] getRepoWebhookInfoByFriendlyNameOK %s", 200, payload) +} + +func (o *GetRepoWebhookInfoByFriendlyNameOK) GetPayload() garm_params.HookInfo { + return o.Payload +} + +func (o *GetRepoWebhookInfoByFriendlyNameOK) readResponse(response runtime.ClientResponse, consumer runtime.Consumer, formats strfmt.Registry) error { + + // response payload + if err := consumer.Consume(response.Body(), &o.Payload); err != nil && err != io.EOF { + return err + } + + return nil +} + +// NewGetRepoWebhookInfoByFriendlyNameDefault creates a GetRepoWebhookInfoByFriendlyNameDefault with default headers values +func NewGetRepoWebhookInfoByFriendlyNameDefault(code int) *GetRepoWebhookInfoByFriendlyNameDefault { + return &GetRepoWebhookInfoByFriendlyNameDefault{ + _statusCode: code, + } +} + +/* +GetRepoWebhookInfoByFriendlyNameDefault describes a response with status code -1, with default header values. + +APIErrorResponse +*/ +type GetRepoWebhookInfoByFriendlyNameDefault struct { + _statusCode int + + Payload apiserver_params.APIErrorResponse +} + +// IsSuccess returns true when this get repo webhook info by friendly name default response has a 2xx status code +func (o *GetRepoWebhookInfoByFriendlyNameDefault) IsSuccess() bool { + return o._statusCode/100 == 2 +} + +// IsRedirect returns true when this get repo webhook info by friendly name default response has a 3xx status code +func (o *GetRepoWebhookInfoByFriendlyNameDefault) IsRedirect() bool { + return o._statusCode/100 == 3 +} + +// IsClientError returns true when this get repo webhook info by friendly name default response has a 4xx status code +func (o *GetRepoWebhookInfoByFriendlyNameDefault) IsClientError() bool { + return o._statusCode/100 == 4 +} + +// IsServerError returns true when this get repo webhook info by friendly name default response has a 5xx status code +func (o *GetRepoWebhookInfoByFriendlyNameDefault) IsServerError() bool { + return o._statusCode/100 == 5 +} + +// IsCode returns true when this get repo webhook info by friendly name default response a status code equal to that given +func (o *GetRepoWebhookInfoByFriendlyNameDefault) IsCode(code int) bool { + return o._statusCode == code +} + +// Code gets the status code for the get repo webhook info by friendly name default response +func (o *GetRepoWebhookInfoByFriendlyNameDefault) Code() int { + return o._statusCode +} + +func (o *GetRepoWebhookInfoByFriendlyNameDefault) Error() string { + payload, _ := json.Marshal(o.Payload) + return fmt.Sprintf("[GET /repositories/{owner}/{repo}/webhook][%d] GetRepoWebhookInfoByFriendlyName default %s", o._statusCode, payload) +} + +func (o *GetRepoWebhookInfoByFriendlyNameDefault) String() string { + payload, _ := json.Marshal(o.Payload) + return fmt.Sprintf("[GET /repositories/{owner}/{repo}/webhook][%d] GetRepoWebhookInfoByFriendlyName default %s", o._statusCode, payload) +} + +func (o *GetRepoWebhookInfoByFriendlyNameDefault) GetPayload() apiserver_params.APIErrorResponse { + return o.Payload +} + +func (o *GetRepoWebhookInfoByFriendlyNameDefault) readResponse(response runtime.ClientResponse, consumer runtime.Consumer, formats strfmt.Registry) error { + + // response payload + if err := consumer.Consume(response.Body(), &o.Payload); err != nil && err != io.EOF { + return err + } + + return nil +} diff --git a/client/repositories/install_repo_webhook_by_friendly_name_parameters.go b/client/repositories/install_repo_webhook_by_friendly_name_parameters.go new file mode 100644 index 000000000..cd8037b99 --- /dev/null +++ b/client/repositories/install_repo_webhook_by_friendly_name_parameters.go @@ -0,0 +1,229 @@ +// Code generated by go-swagger; DO NOT EDIT. + +package repositories + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "context" + "net/http" + "time" + + "github.com/go-openapi/errors" + "github.com/go-openapi/runtime" + cr "github.com/go-openapi/runtime/client" + "github.com/go-openapi/strfmt" + + garm_params "github.com/cloudbase/garm/params" +) + +// NewInstallRepoWebhookByFriendlyNameParams creates a new InstallRepoWebhookByFriendlyNameParams object, +// with the default timeout for this client. +// +// Default values are not hydrated, since defaults are normally applied by the API server side. +// +// To enforce default values in parameter, use SetDefaults or WithDefaults. +func NewInstallRepoWebhookByFriendlyNameParams() *InstallRepoWebhookByFriendlyNameParams { + return &InstallRepoWebhookByFriendlyNameParams{ + timeout: cr.DefaultTimeout, + } +} + +// NewInstallRepoWebhookByFriendlyNameParamsWithTimeout creates a new InstallRepoWebhookByFriendlyNameParams object +// with the ability to set a timeout on a request. +func NewInstallRepoWebhookByFriendlyNameParamsWithTimeout(timeout time.Duration) *InstallRepoWebhookByFriendlyNameParams { + return &InstallRepoWebhookByFriendlyNameParams{ + timeout: timeout, + } +} + +// NewInstallRepoWebhookByFriendlyNameParamsWithContext creates a new InstallRepoWebhookByFriendlyNameParams object +// with the ability to set a context for a request. +func NewInstallRepoWebhookByFriendlyNameParamsWithContext(ctx context.Context) *InstallRepoWebhookByFriendlyNameParams { + return &InstallRepoWebhookByFriendlyNameParams{ + Context: ctx, + } +} + +// NewInstallRepoWebhookByFriendlyNameParamsWithHTTPClient creates a new InstallRepoWebhookByFriendlyNameParams object +// with the ability to set a custom HTTPClient for a request. +func NewInstallRepoWebhookByFriendlyNameParamsWithHTTPClient(client *http.Client) *InstallRepoWebhookByFriendlyNameParams { + return &InstallRepoWebhookByFriendlyNameParams{ + HTTPClient: client, + } +} + +/* +InstallRepoWebhookByFriendlyNameParams contains all the parameters to send to the API endpoint + + for the install repo webhook by friendly name operation. + + Typically these are written to a http.Request. +*/ +type InstallRepoWebhookByFriendlyNameParams struct { + + /* Body. + + Parameters used when creating the repository webhook. + */ + Body garm_params.InstallWebhookParams + + /* EndpointName. + + Repository endpointName. + */ + EndpointName *string + + /* Owner. + + Repository owner. + */ + Owner string + + /* Repo. + + Repository name. + */ + Repo string + + timeout time.Duration + Context context.Context + HTTPClient *http.Client +} + +// WithDefaults hydrates default values in the install repo webhook by friendly name params (not the query body). +// +// All values with no default are reset to their zero value. +func (o *InstallRepoWebhookByFriendlyNameParams) WithDefaults() *InstallRepoWebhookByFriendlyNameParams { + o.SetDefaults() + return o +} + +// SetDefaults hydrates default values in the install repo webhook by friendly name params (not the query body). +// +// All values with no default are reset to their zero value. +func (o *InstallRepoWebhookByFriendlyNameParams) SetDefaults() { + // no default values defined for this parameter +} + +// WithTimeout adds the timeout to the install repo webhook by friendly name params +func (o *InstallRepoWebhookByFriendlyNameParams) WithTimeout(timeout time.Duration) *InstallRepoWebhookByFriendlyNameParams { + o.SetTimeout(timeout) + return o +} + +// SetTimeout adds the timeout to the install repo webhook by friendly name params +func (o *InstallRepoWebhookByFriendlyNameParams) SetTimeout(timeout time.Duration) { + o.timeout = timeout +} + +// WithContext adds the context to the install repo webhook by friendly name params +func (o *InstallRepoWebhookByFriendlyNameParams) WithContext(ctx context.Context) *InstallRepoWebhookByFriendlyNameParams { + o.SetContext(ctx) + return o +} + +// SetContext adds the context to the install repo webhook by friendly name params +func (o *InstallRepoWebhookByFriendlyNameParams) SetContext(ctx context.Context) { + o.Context = ctx +} + +// WithHTTPClient adds the HTTPClient to the install repo webhook by friendly name params +func (o *InstallRepoWebhookByFriendlyNameParams) WithHTTPClient(client *http.Client) *InstallRepoWebhookByFriendlyNameParams { + o.SetHTTPClient(client) + return o +} + +// SetHTTPClient adds the HTTPClient to the install repo webhook by friendly name params +func (o *InstallRepoWebhookByFriendlyNameParams) SetHTTPClient(client *http.Client) { + o.HTTPClient = client +} + +// WithBody adds the body to the install repo webhook by friendly name params +func (o *InstallRepoWebhookByFriendlyNameParams) WithBody(body garm_params.InstallWebhookParams) *InstallRepoWebhookByFriendlyNameParams { + o.SetBody(body) + return o +} + +// SetBody adds the body to the install repo webhook by friendly name params +func (o *InstallRepoWebhookByFriendlyNameParams) SetBody(body garm_params.InstallWebhookParams) { + o.Body = body +} + +// WithEndpointName adds the endpointName to the install repo webhook by friendly name params +func (o *InstallRepoWebhookByFriendlyNameParams) WithEndpointName(endpointName *string) *InstallRepoWebhookByFriendlyNameParams { + o.SetEndpointName(endpointName) + return o +} + +// SetEndpointName adds the endpointName to the install repo webhook by friendly name params +func (o *InstallRepoWebhookByFriendlyNameParams) SetEndpointName(endpointName *string) { + o.EndpointName = endpointName +} + +// WithOwner adds the owner to the install repo webhook by friendly name params +func (o *InstallRepoWebhookByFriendlyNameParams) WithOwner(owner string) *InstallRepoWebhookByFriendlyNameParams { + o.SetOwner(owner) + return o +} + +// SetOwner adds the owner to the install repo webhook by friendly name params +func (o *InstallRepoWebhookByFriendlyNameParams) SetOwner(owner string) { + o.Owner = owner +} + +// WithRepo adds the repo to the install repo webhook by friendly name params +func (o *InstallRepoWebhookByFriendlyNameParams) WithRepo(repo string) *InstallRepoWebhookByFriendlyNameParams { + o.SetRepo(repo) + return o +} + +// SetRepo adds the repo to the install repo webhook by friendly name params +func (o *InstallRepoWebhookByFriendlyNameParams) SetRepo(repo string) { + o.Repo = repo +} + +// WriteToRequest writes these params to a swagger request +func (o *InstallRepoWebhookByFriendlyNameParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error { + + if err := r.SetTimeout(o.timeout); err != nil { + return err + } + var res []error + if err := r.SetBodyParam(o.Body); err != nil { + return err + } + + if o.EndpointName != nil { + + // query param endpointName + var qrEndpointName string + + if o.EndpointName != nil { + qrEndpointName = *o.EndpointName + } + qEndpointName := qrEndpointName + if qEndpointName != "" { + + if err := r.SetQueryParam("endpointName", qEndpointName); err != nil { + return err + } + } + } + + // path param owner + if err := r.SetPathParam("owner", o.Owner); err != nil { + return err + } + + // path param repo + if err := r.SetPathParam("repo", o.Repo); err != nil { + return err + } + + if len(res) > 0 { + return errors.CompositeValidationError(res...) + } + return nil +} diff --git a/client/repositories/install_repo_webhook_by_friendly_name_responses.go b/client/repositories/install_repo_webhook_by_friendly_name_responses.go new file mode 100644 index 000000000..3eedd2fff --- /dev/null +++ b/client/repositories/install_repo_webhook_by_friendly_name_responses.go @@ -0,0 +1,184 @@ +// Code generated by go-swagger; DO NOT EDIT. + +package repositories + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "encoding/json" + "fmt" + "io" + + "github.com/go-openapi/runtime" + "github.com/go-openapi/strfmt" + + apiserver_params "github.com/cloudbase/garm/apiserver/params" + garm_params "github.com/cloudbase/garm/params" +) + +// InstallRepoWebhookByFriendlyNameReader is a Reader for the InstallRepoWebhookByFriendlyName structure. +type InstallRepoWebhookByFriendlyNameReader struct { + formats strfmt.Registry +} + +// ReadResponse reads a server response into the received o. +func (o *InstallRepoWebhookByFriendlyNameReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error) { + switch response.Code() { + case 200: + result := NewInstallRepoWebhookByFriendlyNameOK() + if err := result.readResponse(response, consumer, o.formats); err != nil { + return nil, err + } + return result, nil + default: + result := NewInstallRepoWebhookByFriendlyNameDefault(response.Code()) + if err := result.readResponse(response, consumer, o.formats); err != nil { + return nil, err + } + if response.Code()/100 == 2 { + return result, nil + } + return nil, result + } +} + +// NewInstallRepoWebhookByFriendlyNameOK creates a InstallRepoWebhookByFriendlyNameOK with default headers values +func NewInstallRepoWebhookByFriendlyNameOK() *InstallRepoWebhookByFriendlyNameOK { + return &InstallRepoWebhookByFriendlyNameOK{} +} + +/* +InstallRepoWebhookByFriendlyNameOK describes a response with status code 200, with default header values. + +HookInfo +*/ +type InstallRepoWebhookByFriendlyNameOK struct { + Payload garm_params.HookInfo +} + +// IsSuccess returns true when this install repo webhook by friendly name o k response has a 2xx status code +func (o *InstallRepoWebhookByFriendlyNameOK) IsSuccess() bool { + return true +} + +// IsRedirect returns true when this install repo webhook by friendly name o k response has a 3xx status code +func (o *InstallRepoWebhookByFriendlyNameOK) IsRedirect() bool { + return false +} + +// IsClientError returns true when this install repo webhook by friendly name o k response has a 4xx status code +func (o *InstallRepoWebhookByFriendlyNameOK) IsClientError() bool { + return false +} + +// IsServerError returns true when this install repo webhook by friendly name o k response has a 5xx status code +func (o *InstallRepoWebhookByFriendlyNameOK) IsServerError() bool { + return false +} + +// IsCode returns true when this install repo webhook by friendly name o k response a status code equal to that given +func (o *InstallRepoWebhookByFriendlyNameOK) IsCode(code int) bool { + return code == 200 +} + +// Code gets the status code for the install repo webhook by friendly name o k response +func (o *InstallRepoWebhookByFriendlyNameOK) Code() int { + return 200 +} + +func (o *InstallRepoWebhookByFriendlyNameOK) Error() string { + payload, _ := json.Marshal(o.Payload) + return fmt.Sprintf("[POST /repositories/{owner}/{repo}/webhook][%d] installRepoWebhookByFriendlyNameOK %s", 200, payload) +} + +func (o *InstallRepoWebhookByFriendlyNameOK) String() string { + payload, _ := json.Marshal(o.Payload) + return fmt.Sprintf("[POST /repositories/{owner}/{repo}/webhook][%d] installRepoWebhookByFriendlyNameOK %s", 200, payload) +} + +func (o *InstallRepoWebhookByFriendlyNameOK) GetPayload() garm_params.HookInfo { + return o.Payload +} + +func (o *InstallRepoWebhookByFriendlyNameOK) readResponse(response runtime.ClientResponse, consumer runtime.Consumer, formats strfmt.Registry) error { + + // response payload + if err := consumer.Consume(response.Body(), &o.Payload); err != nil && err != io.EOF { + return err + } + + return nil +} + +// NewInstallRepoWebhookByFriendlyNameDefault creates a InstallRepoWebhookByFriendlyNameDefault with default headers values +func NewInstallRepoWebhookByFriendlyNameDefault(code int) *InstallRepoWebhookByFriendlyNameDefault { + return &InstallRepoWebhookByFriendlyNameDefault{ + _statusCode: code, + } +} + +/* +InstallRepoWebhookByFriendlyNameDefault describes a response with status code -1, with default header values. + +APIErrorResponse +*/ +type InstallRepoWebhookByFriendlyNameDefault struct { + _statusCode int + + Payload apiserver_params.APIErrorResponse +} + +// IsSuccess returns true when this install repo webhook by friendly name default response has a 2xx status code +func (o *InstallRepoWebhookByFriendlyNameDefault) IsSuccess() bool { + return o._statusCode/100 == 2 +} + +// IsRedirect returns true when this install repo webhook by friendly name default response has a 3xx status code +func (o *InstallRepoWebhookByFriendlyNameDefault) IsRedirect() bool { + return o._statusCode/100 == 3 +} + +// IsClientError returns true when this install repo webhook by friendly name default response has a 4xx status code +func (o *InstallRepoWebhookByFriendlyNameDefault) IsClientError() bool { + return o._statusCode/100 == 4 +} + +// IsServerError returns true when this install repo webhook by friendly name default response has a 5xx status code +func (o *InstallRepoWebhookByFriendlyNameDefault) IsServerError() bool { + return o._statusCode/100 == 5 +} + +// IsCode returns true when this install repo webhook by friendly name default response a status code equal to that given +func (o *InstallRepoWebhookByFriendlyNameDefault) IsCode(code int) bool { + return o._statusCode == code +} + +// Code gets the status code for the install repo webhook by friendly name default response +func (o *InstallRepoWebhookByFriendlyNameDefault) Code() int { + return o._statusCode +} + +func (o *InstallRepoWebhookByFriendlyNameDefault) Error() string { + payload, _ := json.Marshal(o.Payload) + return fmt.Sprintf("[POST /repositories/{owner}/{repo}/webhook][%d] InstallRepoWebhookByFriendlyName default %s", o._statusCode, payload) +} + +func (o *InstallRepoWebhookByFriendlyNameDefault) String() string { + payload, _ := json.Marshal(o.Payload) + return fmt.Sprintf("[POST /repositories/{owner}/{repo}/webhook][%d] InstallRepoWebhookByFriendlyName default %s", o._statusCode, payload) +} + +func (o *InstallRepoWebhookByFriendlyNameDefault) GetPayload() apiserver_params.APIErrorResponse { + return o.Payload +} + +func (o *InstallRepoWebhookByFriendlyNameDefault) readResponse(response runtime.ClientResponse, consumer runtime.Consumer, formats strfmt.Registry) error { + + // response payload + if err := consumer.Consume(response.Body(), &o.Payload); err != nil && err != io.EOF { + return err + } + + return nil +} diff --git a/client/repositories/list_repo_instances_by_friendly_name_parameters.go b/client/repositories/list_repo_instances_by_friendly_name_parameters.go new file mode 100644 index 000000000..f6ce0ecdc --- /dev/null +++ b/client/repositories/list_repo_instances_by_friendly_name_parameters.go @@ -0,0 +1,207 @@ +// Code generated by go-swagger; DO NOT EDIT. + +package repositories + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "context" + "net/http" + "time" + + "github.com/go-openapi/errors" + "github.com/go-openapi/runtime" + cr "github.com/go-openapi/runtime/client" + "github.com/go-openapi/strfmt" +) + +// NewListRepoInstancesByFriendlyNameParams creates a new ListRepoInstancesByFriendlyNameParams object, +// with the default timeout for this client. +// +// Default values are not hydrated, since defaults are normally applied by the API server side. +// +// To enforce default values in parameter, use SetDefaults or WithDefaults. +func NewListRepoInstancesByFriendlyNameParams() *ListRepoInstancesByFriendlyNameParams { + return &ListRepoInstancesByFriendlyNameParams{ + timeout: cr.DefaultTimeout, + } +} + +// NewListRepoInstancesByFriendlyNameParamsWithTimeout creates a new ListRepoInstancesByFriendlyNameParams object +// with the ability to set a timeout on a request. +func NewListRepoInstancesByFriendlyNameParamsWithTimeout(timeout time.Duration) *ListRepoInstancesByFriendlyNameParams { + return &ListRepoInstancesByFriendlyNameParams{ + timeout: timeout, + } +} + +// NewListRepoInstancesByFriendlyNameParamsWithContext creates a new ListRepoInstancesByFriendlyNameParams object +// with the ability to set a context for a request. +func NewListRepoInstancesByFriendlyNameParamsWithContext(ctx context.Context) *ListRepoInstancesByFriendlyNameParams { + return &ListRepoInstancesByFriendlyNameParams{ + Context: ctx, + } +} + +// NewListRepoInstancesByFriendlyNameParamsWithHTTPClient creates a new ListRepoInstancesByFriendlyNameParams object +// with the ability to set a custom HTTPClient for a request. +func NewListRepoInstancesByFriendlyNameParamsWithHTTPClient(client *http.Client) *ListRepoInstancesByFriendlyNameParams { + return &ListRepoInstancesByFriendlyNameParams{ + HTTPClient: client, + } +} + +/* +ListRepoInstancesByFriendlyNameParams contains all the parameters to send to the API endpoint + + for the list repo instances by friendly name operation. + + Typically these are written to a http.Request. +*/ +type ListRepoInstancesByFriendlyNameParams struct { + + /* EndpointName. + + Repository endpointName. + */ + EndpointName *string + + /* Owner. + + Repository owner. + */ + Owner string + + /* Repo. + + Repository name. + */ + Repo string + + timeout time.Duration + Context context.Context + HTTPClient *http.Client +} + +// WithDefaults hydrates default values in the list repo instances by friendly name params (not the query body). +// +// All values with no default are reset to their zero value. +func (o *ListRepoInstancesByFriendlyNameParams) WithDefaults() *ListRepoInstancesByFriendlyNameParams { + o.SetDefaults() + return o +} + +// SetDefaults hydrates default values in the list repo instances by friendly name params (not the query body). +// +// All values with no default are reset to their zero value. +func (o *ListRepoInstancesByFriendlyNameParams) SetDefaults() { + // no default values defined for this parameter +} + +// WithTimeout adds the timeout to the list repo instances by friendly name params +func (o *ListRepoInstancesByFriendlyNameParams) WithTimeout(timeout time.Duration) *ListRepoInstancesByFriendlyNameParams { + o.SetTimeout(timeout) + return o +} + +// SetTimeout adds the timeout to the list repo instances by friendly name params +func (o *ListRepoInstancesByFriendlyNameParams) SetTimeout(timeout time.Duration) { + o.timeout = timeout +} + +// WithContext adds the context to the list repo instances by friendly name params +func (o *ListRepoInstancesByFriendlyNameParams) WithContext(ctx context.Context) *ListRepoInstancesByFriendlyNameParams { + o.SetContext(ctx) + return o +} + +// SetContext adds the context to the list repo instances by friendly name params +func (o *ListRepoInstancesByFriendlyNameParams) SetContext(ctx context.Context) { + o.Context = ctx +} + +// WithHTTPClient adds the HTTPClient to the list repo instances by friendly name params +func (o *ListRepoInstancesByFriendlyNameParams) WithHTTPClient(client *http.Client) *ListRepoInstancesByFriendlyNameParams { + o.SetHTTPClient(client) + return o +} + +// SetHTTPClient adds the HTTPClient to the list repo instances by friendly name params +func (o *ListRepoInstancesByFriendlyNameParams) SetHTTPClient(client *http.Client) { + o.HTTPClient = client +} + +// WithEndpointName adds the endpointName to the list repo instances by friendly name params +func (o *ListRepoInstancesByFriendlyNameParams) WithEndpointName(endpointName *string) *ListRepoInstancesByFriendlyNameParams { + o.SetEndpointName(endpointName) + return o +} + +// SetEndpointName adds the endpointName to the list repo instances by friendly name params +func (o *ListRepoInstancesByFriendlyNameParams) SetEndpointName(endpointName *string) { + o.EndpointName = endpointName +} + +// WithOwner adds the owner to the list repo instances by friendly name params +func (o *ListRepoInstancesByFriendlyNameParams) WithOwner(owner string) *ListRepoInstancesByFriendlyNameParams { + o.SetOwner(owner) + return o +} + +// SetOwner adds the owner to the list repo instances by friendly name params +func (o *ListRepoInstancesByFriendlyNameParams) SetOwner(owner string) { + o.Owner = owner +} + +// WithRepo adds the repo to the list repo instances by friendly name params +func (o *ListRepoInstancesByFriendlyNameParams) WithRepo(repo string) *ListRepoInstancesByFriendlyNameParams { + o.SetRepo(repo) + return o +} + +// SetRepo adds the repo to the list repo instances by friendly name params +func (o *ListRepoInstancesByFriendlyNameParams) SetRepo(repo string) { + o.Repo = repo +} + +// WriteToRequest writes these params to a swagger request +func (o *ListRepoInstancesByFriendlyNameParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error { + + if err := r.SetTimeout(o.timeout); err != nil { + return err + } + var res []error + + if o.EndpointName != nil { + + // query param endpointName + var qrEndpointName string + + if o.EndpointName != nil { + qrEndpointName = *o.EndpointName + } + qEndpointName := qrEndpointName + if qEndpointName != "" { + + if err := r.SetQueryParam("endpointName", qEndpointName); err != nil { + return err + } + } + } + + // path param owner + if err := r.SetPathParam("owner", o.Owner); err != nil { + return err + } + + // path param repo + if err := r.SetPathParam("repo", o.Repo); err != nil { + return err + } + + if len(res) > 0 { + return errors.CompositeValidationError(res...) + } + return nil +} diff --git a/client/repositories/list_repo_instances_by_friendly_name_responses.go b/client/repositories/list_repo_instances_by_friendly_name_responses.go new file mode 100644 index 000000000..b4aa451fc --- /dev/null +++ b/client/repositories/list_repo_instances_by_friendly_name_responses.go @@ -0,0 +1,184 @@ +// Code generated by go-swagger; DO NOT EDIT. + +package repositories + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "encoding/json" + "fmt" + "io" + + "github.com/go-openapi/runtime" + "github.com/go-openapi/strfmt" + + apiserver_params "github.com/cloudbase/garm/apiserver/params" + garm_params "github.com/cloudbase/garm/params" +) + +// ListRepoInstancesByFriendlyNameReader is a Reader for the ListRepoInstancesByFriendlyName structure. +type ListRepoInstancesByFriendlyNameReader struct { + formats strfmt.Registry +} + +// ReadResponse reads a server response into the received o. +func (o *ListRepoInstancesByFriendlyNameReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error) { + switch response.Code() { + case 200: + result := NewListRepoInstancesByFriendlyNameOK() + if err := result.readResponse(response, consumer, o.formats); err != nil { + return nil, err + } + return result, nil + default: + result := NewListRepoInstancesByFriendlyNameDefault(response.Code()) + if err := result.readResponse(response, consumer, o.formats); err != nil { + return nil, err + } + if response.Code()/100 == 2 { + return result, nil + } + return nil, result + } +} + +// NewListRepoInstancesByFriendlyNameOK creates a ListRepoInstancesByFriendlyNameOK with default headers values +func NewListRepoInstancesByFriendlyNameOK() *ListRepoInstancesByFriendlyNameOK { + return &ListRepoInstancesByFriendlyNameOK{} +} + +/* +ListRepoInstancesByFriendlyNameOK describes a response with status code 200, with default header values. + +Instances +*/ +type ListRepoInstancesByFriendlyNameOK struct { + Payload garm_params.Instances +} + +// IsSuccess returns true when this list repo instances by friendly name o k response has a 2xx status code +func (o *ListRepoInstancesByFriendlyNameOK) IsSuccess() bool { + return true +} + +// IsRedirect returns true when this list repo instances by friendly name o k response has a 3xx status code +func (o *ListRepoInstancesByFriendlyNameOK) IsRedirect() bool { + return false +} + +// IsClientError returns true when this list repo instances by friendly name o k response has a 4xx status code +func (o *ListRepoInstancesByFriendlyNameOK) IsClientError() bool { + return false +} + +// IsServerError returns true when this list repo instances by friendly name o k response has a 5xx status code +func (o *ListRepoInstancesByFriendlyNameOK) IsServerError() bool { + return false +} + +// IsCode returns true when this list repo instances by friendly name o k response a status code equal to that given +func (o *ListRepoInstancesByFriendlyNameOK) IsCode(code int) bool { + return code == 200 +} + +// Code gets the status code for the list repo instances by friendly name o k response +func (o *ListRepoInstancesByFriendlyNameOK) Code() int { + return 200 +} + +func (o *ListRepoInstancesByFriendlyNameOK) Error() string { + payload, _ := json.Marshal(o.Payload) + return fmt.Sprintf("[GET /repositories/{owner}/{repo}/instances][%d] listRepoInstancesByFriendlyNameOK %s", 200, payload) +} + +func (o *ListRepoInstancesByFriendlyNameOK) String() string { + payload, _ := json.Marshal(o.Payload) + return fmt.Sprintf("[GET /repositories/{owner}/{repo}/instances][%d] listRepoInstancesByFriendlyNameOK %s", 200, payload) +} + +func (o *ListRepoInstancesByFriendlyNameOK) GetPayload() garm_params.Instances { + return o.Payload +} + +func (o *ListRepoInstancesByFriendlyNameOK) readResponse(response runtime.ClientResponse, consumer runtime.Consumer, formats strfmt.Registry) error { + + // response payload + if err := consumer.Consume(response.Body(), &o.Payload); err != nil && err != io.EOF { + return err + } + + return nil +} + +// NewListRepoInstancesByFriendlyNameDefault creates a ListRepoInstancesByFriendlyNameDefault with default headers values +func NewListRepoInstancesByFriendlyNameDefault(code int) *ListRepoInstancesByFriendlyNameDefault { + return &ListRepoInstancesByFriendlyNameDefault{ + _statusCode: code, + } +} + +/* +ListRepoInstancesByFriendlyNameDefault describes a response with status code -1, with default header values. + +APIErrorResponse +*/ +type ListRepoInstancesByFriendlyNameDefault struct { + _statusCode int + + Payload apiserver_params.APIErrorResponse +} + +// IsSuccess returns true when this list repo instances by friendly name default response has a 2xx status code +func (o *ListRepoInstancesByFriendlyNameDefault) IsSuccess() bool { + return o._statusCode/100 == 2 +} + +// IsRedirect returns true when this list repo instances by friendly name default response has a 3xx status code +func (o *ListRepoInstancesByFriendlyNameDefault) IsRedirect() bool { + return o._statusCode/100 == 3 +} + +// IsClientError returns true when this list repo instances by friendly name default response has a 4xx status code +func (o *ListRepoInstancesByFriendlyNameDefault) IsClientError() bool { + return o._statusCode/100 == 4 +} + +// IsServerError returns true when this list repo instances by friendly name default response has a 5xx status code +func (o *ListRepoInstancesByFriendlyNameDefault) IsServerError() bool { + return o._statusCode/100 == 5 +} + +// IsCode returns true when this list repo instances by friendly name default response a status code equal to that given +func (o *ListRepoInstancesByFriendlyNameDefault) IsCode(code int) bool { + return o._statusCode == code +} + +// Code gets the status code for the list repo instances by friendly name default response +func (o *ListRepoInstancesByFriendlyNameDefault) Code() int { + return o._statusCode +} + +func (o *ListRepoInstancesByFriendlyNameDefault) Error() string { + payload, _ := json.Marshal(o.Payload) + return fmt.Sprintf("[GET /repositories/{owner}/{repo}/instances][%d] ListRepoInstancesByFriendlyName default %s", o._statusCode, payload) +} + +func (o *ListRepoInstancesByFriendlyNameDefault) String() string { + payload, _ := json.Marshal(o.Payload) + return fmt.Sprintf("[GET /repositories/{owner}/{repo}/instances][%d] ListRepoInstancesByFriendlyName default %s", o._statusCode, payload) +} + +func (o *ListRepoInstancesByFriendlyNameDefault) GetPayload() apiserver_params.APIErrorResponse { + return o.Payload +} + +func (o *ListRepoInstancesByFriendlyNameDefault) readResponse(response runtime.ClientResponse, consumer runtime.Consumer, formats strfmt.Registry) error { + + // response payload + if err := consumer.Consume(response.Body(), &o.Payload); err != nil && err != io.EOF { + return err + } + + return nil +} diff --git a/client/repositories/list_repo_pools_by_friendly_name_parameters.go b/client/repositories/list_repo_pools_by_friendly_name_parameters.go new file mode 100644 index 000000000..a168aceb5 --- /dev/null +++ b/client/repositories/list_repo_pools_by_friendly_name_parameters.go @@ -0,0 +1,207 @@ +// Code generated by go-swagger; DO NOT EDIT. + +package repositories + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "context" + "net/http" + "time" + + "github.com/go-openapi/errors" + "github.com/go-openapi/runtime" + cr "github.com/go-openapi/runtime/client" + "github.com/go-openapi/strfmt" +) + +// NewListRepoPoolsByFriendlyNameParams creates a new ListRepoPoolsByFriendlyNameParams object, +// with the default timeout for this client. +// +// Default values are not hydrated, since defaults are normally applied by the API server side. +// +// To enforce default values in parameter, use SetDefaults or WithDefaults. +func NewListRepoPoolsByFriendlyNameParams() *ListRepoPoolsByFriendlyNameParams { + return &ListRepoPoolsByFriendlyNameParams{ + timeout: cr.DefaultTimeout, + } +} + +// NewListRepoPoolsByFriendlyNameParamsWithTimeout creates a new ListRepoPoolsByFriendlyNameParams object +// with the ability to set a timeout on a request. +func NewListRepoPoolsByFriendlyNameParamsWithTimeout(timeout time.Duration) *ListRepoPoolsByFriendlyNameParams { + return &ListRepoPoolsByFriendlyNameParams{ + timeout: timeout, + } +} + +// NewListRepoPoolsByFriendlyNameParamsWithContext creates a new ListRepoPoolsByFriendlyNameParams object +// with the ability to set a context for a request. +func NewListRepoPoolsByFriendlyNameParamsWithContext(ctx context.Context) *ListRepoPoolsByFriendlyNameParams { + return &ListRepoPoolsByFriendlyNameParams{ + Context: ctx, + } +} + +// NewListRepoPoolsByFriendlyNameParamsWithHTTPClient creates a new ListRepoPoolsByFriendlyNameParams object +// with the ability to set a custom HTTPClient for a request. +func NewListRepoPoolsByFriendlyNameParamsWithHTTPClient(client *http.Client) *ListRepoPoolsByFriendlyNameParams { + return &ListRepoPoolsByFriendlyNameParams{ + HTTPClient: client, + } +} + +/* +ListRepoPoolsByFriendlyNameParams contains all the parameters to send to the API endpoint + + for the list repo pools by friendly name operation. + + Typically these are written to a http.Request. +*/ +type ListRepoPoolsByFriendlyNameParams struct { + + /* EndpointName. + + Repository endpointName. + */ + EndpointName *string + + /* Owner. + + Repository owner. + */ + Owner string + + /* Repo. + + Repository name. + */ + Repo string + + timeout time.Duration + Context context.Context + HTTPClient *http.Client +} + +// WithDefaults hydrates default values in the list repo pools by friendly name params (not the query body). +// +// All values with no default are reset to their zero value. +func (o *ListRepoPoolsByFriendlyNameParams) WithDefaults() *ListRepoPoolsByFriendlyNameParams { + o.SetDefaults() + return o +} + +// SetDefaults hydrates default values in the list repo pools by friendly name params (not the query body). +// +// All values with no default are reset to their zero value. +func (o *ListRepoPoolsByFriendlyNameParams) SetDefaults() { + // no default values defined for this parameter +} + +// WithTimeout adds the timeout to the list repo pools by friendly name params +func (o *ListRepoPoolsByFriendlyNameParams) WithTimeout(timeout time.Duration) *ListRepoPoolsByFriendlyNameParams { + o.SetTimeout(timeout) + return o +} + +// SetTimeout adds the timeout to the list repo pools by friendly name params +func (o *ListRepoPoolsByFriendlyNameParams) SetTimeout(timeout time.Duration) { + o.timeout = timeout +} + +// WithContext adds the context to the list repo pools by friendly name params +func (o *ListRepoPoolsByFriendlyNameParams) WithContext(ctx context.Context) *ListRepoPoolsByFriendlyNameParams { + o.SetContext(ctx) + return o +} + +// SetContext adds the context to the list repo pools by friendly name params +func (o *ListRepoPoolsByFriendlyNameParams) SetContext(ctx context.Context) { + o.Context = ctx +} + +// WithHTTPClient adds the HTTPClient to the list repo pools by friendly name params +func (o *ListRepoPoolsByFriendlyNameParams) WithHTTPClient(client *http.Client) *ListRepoPoolsByFriendlyNameParams { + o.SetHTTPClient(client) + return o +} + +// SetHTTPClient adds the HTTPClient to the list repo pools by friendly name params +func (o *ListRepoPoolsByFriendlyNameParams) SetHTTPClient(client *http.Client) { + o.HTTPClient = client +} + +// WithEndpointName adds the endpointName to the list repo pools by friendly name params +func (o *ListRepoPoolsByFriendlyNameParams) WithEndpointName(endpointName *string) *ListRepoPoolsByFriendlyNameParams { + o.SetEndpointName(endpointName) + return o +} + +// SetEndpointName adds the endpointName to the list repo pools by friendly name params +func (o *ListRepoPoolsByFriendlyNameParams) SetEndpointName(endpointName *string) { + o.EndpointName = endpointName +} + +// WithOwner adds the owner to the list repo pools by friendly name params +func (o *ListRepoPoolsByFriendlyNameParams) WithOwner(owner string) *ListRepoPoolsByFriendlyNameParams { + o.SetOwner(owner) + return o +} + +// SetOwner adds the owner to the list repo pools by friendly name params +func (o *ListRepoPoolsByFriendlyNameParams) SetOwner(owner string) { + o.Owner = owner +} + +// WithRepo adds the repo to the list repo pools by friendly name params +func (o *ListRepoPoolsByFriendlyNameParams) WithRepo(repo string) *ListRepoPoolsByFriendlyNameParams { + o.SetRepo(repo) + return o +} + +// SetRepo adds the repo to the list repo pools by friendly name params +func (o *ListRepoPoolsByFriendlyNameParams) SetRepo(repo string) { + o.Repo = repo +} + +// WriteToRequest writes these params to a swagger request +func (o *ListRepoPoolsByFriendlyNameParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error { + + if err := r.SetTimeout(o.timeout); err != nil { + return err + } + var res []error + + if o.EndpointName != nil { + + // query param endpointName + var qrEndpointName string + + if o.EndpointName != nil { + qrEndpointName = *o.EndpointName + } + qEndpointName := qrEndpointName + if qEndpointName != "" { + + if err := r.SetQueryParam("endpointName", qEndpointName); err != nil { + return err + } + } + } + + // path param owner + if err := r.SetPathParam("owner", o.Owner); err != nil { + return err + } + + // path param repo + if err := r.SetPathParam("repo", o.Repo); err != nil { + return err + } + + if len(res) > 0 { + return errors.CompositeValidationError(res...) + } + return nil +} diff --git a/client/repositories/list_repo_pools_by_friendly_name_responses.go b/client/repositories/list_repo_pools_by_friendly_name_responses.go new file mode 100644 index 000000000..10e38fc62 --- /dev/null +++ b/client/repositories/list_repo_pools_by_friendly_name_responses.go @@ -0,0 +1,184 @@ +// Code generated by go-swagger; DO NOT EDIT. + +package repositories + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "encoding/json" + "fmt" + "io" + + "github.com/go-openapi/runtime" + "github.com/go-openapi/strfmt" + + apiserver_params "github.com/cloudbase/garm/apiserver/params" + garm_params "github.com/cloudbase/garm/params" +) + +// ListRepoPoolsByFriendlyNameReader is a Reader for the ListRepoPoolsByFriendlyName structure. +type ListRepoPoolsByFriendlyNameReader struct { + formats strfmt.Registry +} + +// ReadResponse reads a server response into the received o. +func (o *ListRepoPoolsByFriendlyNameReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error) { + switch response.Code() { + case 200: + result := NewListRepoPoolsByFriendlyNameOK() + if err := result.readResponse(response, consumer, o.formats); err != nil { + return nil, err + } + return result, nil + default: + result := NewListRepoPoolsByFriendlyNameDefault(response.Code()) + if err := result.readResponse(response, consumer, o.formats); err != nil { + return nil, err + } + if response.Code()/100 == 2 { + return result, nil + } + return nil, result + } +} + +// NewListRepoPoolsByFriendlyNameOK creates a ListRepoPoolsByFriendlyNameOK with default headers values +func NewListRepoPoolsByFriendlyNameOK() *ListRepoPoolsByFriendlyNameOK { + return &ListRepoPoolsByFriendlyNameOK{} +} + +/* +ListRepoPoolsByFriendlyNameOK describes a response with status code 200, with default header values. + +Pools +*/ +type ListRepoPoolsByFriendlyNameOK struct { + Payload garm_params.Pools +} + +// IsSuccess returns true when this list repo pools by friendly name o k response has a 2xx status code +func (o *ListRepoPoolsByFriendlyNameOK) IsSuccess() bool { + return true +} + +// IsRedirect returns true when this list repo pools by friendly name o k response has a 3xx status code +func (o *ListRepoPoolsByFriendlyNameOK) IsRedirect() bool { + return false +} + +// IsClientError returns true when this list repo pools by friendly name o k response has a 4xx status code +func (o *ListRepoPoolsByFriendlyNameOK) IsClientError() bool { + return false +} + +// IsServerError returns true when this list repo pools by friendly name o k response has a 5xx status code +func (o *ListRepoPoolsByFriendlyNameOK) IsServerError() bool { + return false +} + +// IsCode returns true when this list repo pools by friendly name o k response a status code equal to that given +func (o *ListRepoPoolsByFriendlyNameOK) IsCode(code int) bool { + return code == 200 +} + +// Code gets the status code for the list repo pools by friendly name o k response +func (o *ListRepoPoolsByFriendlyNameOK) Code() int { + return 200 +} + +func (o *ListRepoPoolsByFriendlyNameOK) Error() string { + payload, _ := json.Marshal(o.Payload) + return fmt.Sprintf("[GET /repositories/{owner}/{repo}/pools][%d] listRepoPoolsByFriendlyNameOK %s", 200, payload) +} + +func (o *ListRepoPoolsByFriendlyNameOK) String() string { + payload, _ := json.Marshal(o.Payload) + return fmt.Sprintf("[GET /repositories/{owner}/{repo}/pools][%d] listRepoPoolsByFriendlyNameOK %s", 200, payload) +} + +func (o *ListRepoPoolsByFriendlyNameOK) GetPayload() garm_params.Pools { + return o.Payload +} + +func (o *ListRepoPoolsByFriendlyNameOK) readResponse(response runtime.ClientResponse, consumer runtime.Consumer, formats strfmt.Registry) error { + + // response payload + if err := consumer.Consume(response.Body(), &o.Payload); err != nil && err != io.EOF { + return err + } + + return nil +} + +// NewListRepoPoolsByFriendlyNameDefault creates a ListRepoPoolsByFriendlyNameDefault with default headers values +func NewListRepoPoolsByFriendlyNameDefault(code int) *ListRepoPoolsByFriendlyNameDefault { + return &ListRepoPoolsByFriendlyNameDefault{ + _statusCode: code, + } +} + +/* +ListRepoPoolsByFriendlyNameDefault describes a response with status code -1, with default header values. + +APIErrorResponse +*/ +type ListRepoPoolsByFriendlyNameDefault struct { + _statusCode int + + Payload apiserver_params.APIErrorResponse +} + +// IsSuccess returns true when this list repo pools by friendly name default response has a 2xx status code +func (o *ListRepoPoolsByFriendlyNameDefault) IsSuccess() bool { + return o._statusCode/100 == 2 +} + +// IsRedirect returns true when this list repo pools by friendly name default response has a 3xx status code +func (o *ListRepoPoolsByFriendlyNameDefault) IsRedirect() bool { + return o._statusCode/100 == 3 +} + +// IsClientError returns true when this list repo pools by friendly name default response has a 4xx status code +func (o *ListRepoPoolsByFriendlyNameDefault) IsClientError() bool { + return o._statusCode/100 == 4 +} + +// IsServerError returns true when this list repo pools by friendly name default response has a 5xx status code +func (o *ListRepoPoolsByFriendlyNameDefault) IsServerError() bool { + return o._statusCode/100 == 5 +} + +// IsCode returns true when this list repo pools by friendly name default response a status code equal to that given +func (o *ListRepoPoolsByFriendlyNameDefault) IsCode(code int) bool { + return o._statusCode == code +} + +// Code gets the status code for the list repo pools by friendly name default response +func (o *ListRepoPoolsByFriendlyNameDefault) Code() int { + return o._statusCode +} + +func (o *ListRepoPoolsByFriendlyNameDefault) Error() string { + payload, _ := json.Marshal(o.Payload) + return fmt.Sprintf("[GET /repositories/{owner}/{repo}/pools][%d] ListRepoPoolsByFriendlyName default %s", o._statusCode, payload) +} + +func (o *ListRepoPoolsByFriendlyNameDefault) String() string { + payload, _ := json.Marshal(o.Payload) + return fmt.Sprintf("[GET /repositories/{owner}/{repo}/pools][%d] ListRepoPoolsByFriendlyName default %s", o._statusCode, payload) +} + +func (o *ListRepoPoolsByFriendlyNameDefault) GetPayload() apiserver_params.APIErrorResponse { + return o.Payload +} + +func (o *ListRepoPoolsByFriendlyNameDefault) readResponse(response runtime.ClientResponse, consumer runtime.Consumer, formats strfmt.Registry) error { + + // response payload + if err := consumer.Consume(response.Body(), &o.Payload); err != nil && err != io.EOF { + return err + } + + return nil +} diff --git a/client/repositories/list_repo_scale_sets_by_friendly_name_parameters.go b/client/repositories/list_repo_scale_sets_by_friendly_name_parameters.go new file mode 100644 index 000000000..d5f27a980 --- /dev/null +++ b/client/repositories/list_repo_scale_sets_by_friendly_name_parameters.go @@ -0,0 +1,207 @@ +// Code generated by go-swagger; DO NOT EDIT. + +package repositories + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "context" + "net/http" + "time" + + "github.com/go-openapi/errors" + "github.com/go-openapi/runtime" + cr "github.com/go-openapi/runtime/client" + "github.com/go-openapi/strfmt" +) + +// NewListRepoScaleSetsByFriendlyNameParams creates a new ListRepoScaleSetsByFriendlyNameParams object, +// with the default timeout for this client. +// +// Default values are not hydrated, since defaults are normally applied by the API server side. +// +// To enforce default values in parameter, use SetDefaults or WithDefaults. +func NewListRepoScaleSetsByFriendlyNameParams() *ListRepoScaleSetsByFriendlyNameParams { + return &ListRepoScaleSetsByFriendlyNameParams{ + timeout: cr.DefaultTimeout, + } +} + +// NewListRepoScaleSetsByFriendlyNameParamsWithTimeout creates a new ListRepoScaleSetsByFriendlyNameParams object +// with the ability to set a timeout on a request. +func NewListRepoScaleSetsByFriendlyNameParamsWithTimeout(timeout time.Duration) *ListRepoScaleSetsByFriendlyNameParams { + return &ListRepoScaleSetsByFriendlyNameParams{ + timeout: timeout, + } +} + +// NewListRepoScaleSetsByFriendlyNameParamsWithContext creates a new ListRepoScaleSetsByFriendlyNameParams object +// with the ability to set a context for a request. +func NewListRepoScaleSetsByFriendlyNameParamsWithContext(ctx context.Context) *ListRepoScaleSetsByFriendlyNameParams { + return &ListRepoScaleSetsByFriendlyNameParams{ + Context: ctx, + } +} + +// NewListRepoScaleSetsByFriendlyNameParamsWithHTTPClient creates a new ListRepoScaleSetsByFriendlyNameParams object +// with the ability to set a custom HTTPClient for a request. +func NewListRepoScaleSetsByFriendlyNameParamsWithHTTPClient(client *http.Client) *ListRepoScaleSetsByFriendlyNameParams { + return &ListRepoScaleSetsByFriendlyNameParams{ + HTTPClient: client, + } +} + +/* +ListRepoScaleSetsByFriendlyNameParams contains all the parameters to send to the API endpoint + + for the list repo scale sets by friendly name operation. + + Typically these are written to a http.Request. +*/ +type ListRepoScaleSetsByFriendlyNameParams struct { + + /* EndpointName. + + Repository endpointName. + */ + EndpointName *string + + /* Owner. + + Repository owner. + */ + Owner string + + /* Repo. + + Repository name. + */ + Repo string + + timeout time.Duration + Context context.Context + HTTPClient *http.Client +} + +// WithDefaults hydrates default values in the list repo scale sets by friendly name params (not the query body). +// +// All values with no default are reset to their zero value. +func (o *ListRepoScaleSetsByFriendlyNameParams) WithDefaults() *ListRepoScaleSetsByFriendlyNameParams { + o.SetDefaults() + return o +} + +// SetDefaults hydrates default values in the list repo scale sets by friendly name params (not the query body). +// +// All values with no default are reset to their zero value. +func (o *ListRepoScaleSetsByFriendlyNameParams) SetDefaults() { + // no default values defined for this parameter +} + +// WithTimeout adds the timeout to the list repo scale sets by friendly name params +func (o *ListRepoScaleSetsByFriendlyNameParams) WithTimeout(timeout time.Duration) *ListRepoScaleSetsByFriendlyNameParams { + o.SetTimeout(timeout) + return o +} + +// SetTimeout adds the timeout to the list repo scale sets by friendly name params +func (o *ListRepoScaleSetsByFriendlyNameParams) SetTimeout(timeout time.Duration) { + o.timeout = timeout +} + +// WithContext adds the context to the list repo scale sets by friendly name params +func (o *ListRepoScaleSetsByFriendlyNameParams) WithContext(ctx context.Context) *ListRepoScaleSetsByFriendlyNameParams { + o.SetContext(ctx) + return o +} + +// SetContext adds the context to the list repo scale sets by friendly name params +func (o *ListRepoScaleSetsByFriendlyNameParams) SetContext(ctx context.Context) { + o.Context = ctx +} + +// WithHTTPClient adds the HTTPClient to the list repo scale sets by friendly name params +func (o *ListRepoScaleSetsByFriendlyNameParams) WithHTTPClient(client *http.Client) *ListRepoScaleSetsByFriendlyNameParams { + o.SetHTTPClient(client) + return o +} + +// SetHTTPClient adds the HTTPClient to the list repo scale sets by friendly name params +func (o *ListRepoScaleSetsByFriendlyNameParams) SetHTTPClient(client *http.Client) { + o.HTTPClient = client +} + +// WithEndpointName adds the endpointName to the list repo scale sets by friendly name params +func (o *ListRepoScaleSetsByFriendlyNameParams) WithEndpointName(endpointName *string) *ListRepoScaleSetsByFriendlyNameParams { + o.SetEndpointName(endpointName) + return o +} + +// SetEndpointName adds the endpointName to the list repo scale sets by friendly name params +func (o *ListRepoScaleSetsByFriendlyNameParams) SetEndpointName(endpointName *string) { + o.EndpointName = endpointName +} + +// WithOwner adds the owner to the list repo scale sets by friendly name params +func (o *ListRepoScaleSetsByFriendlyNameParams) WithOwner(owner string) *ListRepoScaleSetsByFriendlyNameParams { + o.SetOwner(owner) + return o +} + +// SetOwner adds the owner to the list repo scale sets by friendly name params +func (o *ListRepoScaleSetsByFriendlyNameParams) SetOwner(owner string) { + o.Owner = owner +} + +// WithRepo adds the repo to the list repo scale sets by friendly name params +func (o *ListRepoScaleSetsByFriendlyNameParams) WithRepo(repo string) *ListRepoScaleSetsByFriendlyNameParams { + o.SetRepo(repo) + return o +} + +// SetRepo adds the repo to the list repo scale sets by friendly name params +func (o *ListRepoScaleSetsByFriendlyNameParams) SetRepo(repo string) { + o.Repo = repo +} + +// WriteToRequest writes these params to a swagger request +func (o *ListRepoScaleSetsByFriendlyNameParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error { + + if err := r.SetTimeout(o.timeout); err != nil { + return err + } + var res []error + + if o.EndpointName != nil { + + // query param endpointName + var qrEndpointName string + + if o.EndpointName != nil { + qrEndpointName = *o.EndpointName + } + qEndpointName := qrEndpointName + if qEndpointName != "" { + + if err := r.SetQueryParam("endpointName", qEndpointName); err != nil { + return err + } + } + } + + // path param owner + if err := r.SetPathParam("owner", o.Owner); err != nil { + return err + } + + // path param repo + if err := r.SetPathParam("repo", o.Repo); err != nil { + return err + } + + if len(res) > 0 { + return errors.CompositeValidationError(res...) + } + return nil +} diff --git a/client/repositories/list_repo_scale_sets_by_friendly_name_responses.go b/client/repositories/list_repo_scale_sets_by_friendly_name_responses.go new file mode 100644 index 000000000..ecc550f2f --- /dev/null +++ b/client/repositories/list_repo_scale_sets_by_friendly_name_responses.go @@ -0,0 +1,184 @@ +// Code generated by go-swagger; DO NOT EDIT. + +package repositories + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "encoding/json" + "fmt" + "io" + + "github.com/go-openapi/runtime" + "github.com/go-openapi/strfmt" + + apiserver_params "github.com/cloudbase/garm/apiserver/params" + garm_params "github.com/cloudbase/garm/params" +) + +// ListRepoScaleSetsByFriendlyNameReader is a Reader for the ListRepoScaleSetsByFriendlyName structure. +type ListRepoScaleSetsByFriendlyNameReader struct { + formats strfmt.Registry +} + +// ReadResponse reads a server response into the received o. +func (o *ListRepoScaleSetsByFriendlyNameReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error) { + switch response.Code() { + case 200: + result := NewListRepoScaleSetsByFriendlyNameOK() + if err := result.readResponse(response, consumer, o.formats); err != nil { + return nil, err + } + return result, nil + default: + result := NewListRepoScaleSetsByFriendlyNameDefault(response.Code()) + if err := result.readResponse(response, consumer, o.formats); err != nil { + return nil, err + } + if response.Code()/100 == 2 { + return result, nil + } + return nil, result + } +} + +// NewListRepoScaleSetsByFriendlyNameOK creates a ListRepoScaleSetsByFriendlyNameOK with default headers values +func NewListRepoScaleSetsByFriendlyNameOK() *ListRepoScaleSetsByFriendlyNameOK { + return &ListRepoScaleSetsByFriendlyNameOK{} +} + +/* +ListRepoScaleSetsByFriendlyNameOK describes a response with status code 200, with default header values. + +ScaleSets +*/ +type ListRepoScaleSetsByFriendlyNameOK struct { + Payload garm_params.ScaleSets +} + +// IsSuccess returns true when this list repo scale sets by friendly name o k response has a 2xx status code +func (o *ListRepoScaleSetsByFriendlyNameOK) IsSuccess() bool { + return true +} + +// IsRedirect returns true when this list repo scale sets by friendly name o k response has a 3xx status code +func (o *ListRepoScaleSetsByFriendlyNameOK) IsRedirect() bool { + return false +} + +// IsClientError returns true when this list repo scale sets by friendly name o k response has a 4xx status code +func (o *ListRepoScaleSetsByFriendlyNameOK) IsClientError() bool { + return false +} + +// IsServerError returns true when this list repo scale sets by friendly name o k response has a 5xx status code +func (o *ListRepoScaleSetsByFriendlyNameOK) IsServerError() bool { + return false +} + +// IsCode returns true when this list repo scale sets by friendly name o k response a status code equal to that given +func (o *ListRepoScaleSetsByFriendlyNameOK) IsCode(code int) bool { + return code == 200 +} + +// Code gets the status code for the list repo scale sets by friendly name o k response +func (o *ListRepoScaleSetsByFriendlyNameOK) Code() int { + return 200 +} + +func (o *ListRepoScaleSetsByFriendlyNameOK) Error() string { + payload, _ := json.Marshal(o.Payload) + return fmt.Sprintf("[GET /repositories/{owner}/{repo}/scalesets][%d] listRepoScaleSetsByFriendlyNameOK %s", 200, payload) +} + +func (o *ListRepoScaleSetsByFriendlyNameOK) String() string { + payload, _ := json.Marshal(o.Payload) + return fmt.Sprintf("[GET /repositories/{owner}/{repo}/scalesets][%d] listRepoScaleSetsByFriendlyNameOK %s", 200, payload) +} + +func (o *ListRepoScaleSetsByFriendlyNameOK) GetPayload() garm_params.ScaleSets { + return o.Payload +} + +func (o *ListRepoScaleSetsByFriendlyNameOK) readResponse(response runtime.ClientResponse, consumer runtime.Consumer, formats strfmt.Registry) error { + + // response payload + if err := consumer.Consume(response.Body(), &o.Payload); err != nil && err != io.EOF { + return err + } + + return nil +} + +// NewListRepoScaleSetsByFriendlyNameDefault creates a ListRepoScaleSetsByFriendlyNameDefault with default headers values +func NewListRepoScaleSetsByFriendlyNameDefault(code int) *ListRepoScaleSetsByFriendlyNameDefault { + return &ListRepoScaleSetsByFriendlyNameDefault{ + _statusCode: code, + } +} + +/* +ListRepoScaleSetsByFriendlyNameDefault describes a response with status code -1, with default header values. + +APIErrorResponse +*/ +type ListRepoScaleSetsByFriendlyNameDefault struct { + _statusCode int + + Payload apiserver_params.APIErrorResponse +} + +// IsSuccess returns true when this list repo scale sets by friendly name default response has a 2xx status code +func (o *ListRepoScaleSetsByFriendlyNameDefault) IsSuccess() bool { + return o._statusCode/100 == 2 +} + +// IsRedirect returns true when this list repo scale sets by friendly name default response has a 3xx status code +func (o *ListRepoScaleSetsByFriendlyNameDefault) IsRedirect() bool { + return o._statusCode/100 == 3 +} + +// IsClientError returns true when this list repo scale sets by friendly name default response has a 4xx status code +func (o *ListRepoScaleSetsByFriendlyNameDefault) IsClientError() bool { + return o._statusCode/100 == 4 +} + +// IsServerError returns true when this list repo scale sets by friendly name default response has a 5xx status code +func (o *ListRepoScaleSetsByFriendlyNameDefault) IsServerError() bool { + return o._statusCode/100 == 5 +} + +// IsCode returns true when this list repo scale sets by friendly name default response a status code equal to that given +func (o *ListRepoScaleSetsByFriendlyNameDefault) IsCode(code int) bool { + return o._statusCode == code +} + +// Code gets the status code for the list repo scale sets by friendly name default response +func (o *ListRepoScaleSetsByFriendlyNameDefault) Code() int { + return o._statusCode +} + +func (o *ListRepoScaleSetsByFriendlyNameDefault) Error() string { + payload, _ := json.Marshal(o.Payload) + return fmt.Sprintf("[GET /repositories/{owner}/{repo}/scalesets][%d] ListRepoScaleSetsByFriendlyName default %s", o._statusCode, payload) +} + +func (o *ListRepoScaleSetsByFriendlyNameDefault) String() string { + payload, _ := json.Marshal(o.Payload) + return fmt.Sprintf("[GET /repositories/{owner}/{repo}/scalesets][%d] ListRepoScaleSetsByFriendlyName default %s", o._statusCode, payload) +} + +func (o *ListRepoScaleSetsByFriendlyNameDefault) GetPayload() apiserver_params.APIErrorResponse { + return o.Payload +} + +func (o *ListRepoScaleSetsByFriendlyNameDefault) readResponse(response runtime.ClientResponse, consumer runtime.Consumer, formats strfmt.Registry) error { + + // response payload + if err := consumer.Consume(response.Body(), &o.Payload); err != nil && err != io.EOF { + return err + } + + return nil +} diff --git a/client/repositories/repositories_client.go b/client/repositories/repositories_client.go index 017bf0f83..06c22c1f0 100644 --- a/client/repositories/repositories_client.go +++ b/client/repositories/repositories_client.go @@ -58,34 +58,62 @@ type ClientService interface { CreateRepoPool(params *CreateRepoPoolParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*CreateRepoPoolOK, error) + CreateRepoPoolByFriendlyName(params *CreateRepoPoolByFriendlyNameParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*CreateRepoPoolByFriendlyNameOK, error) + CreateRepoScaleSet(params *CreateRepoScaleSetParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*CreateRepoScaleSetOK, error) + CreateRepoScaleSetByFriendlyName(params *CreateRepoScaleSetByFriendlyNameParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*CreateRepoScaleSetByFriendlyNameOK, error) + DeleteRepo(params *DeleteRepoParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) error + DeleteRepoByFriendlyName(params *DeleteRepoByFriendlyNameParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) error + DeleteRepoPool(params *DeleteRepoPoolParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) error + DeleteRepoPoolByFriendlyName(params *DeleteRepoPoolByFriendlyNameParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) error + GetRepo(params *GetRepoParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetRepoOK, error) + GetRepoByFriendlyName(params *GetRepoByFriendlyNameParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetRepoByFriendlyNameOK, error) + GetRepoPool(params *GetRepoPoolParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetRepoPoolOK, error) + GetRepoPoolByFriendlyName(params *GetRepoPoolByFriendlyNameParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetRepoPoolByFriendlyNameOK, error) + GetRepoWebhookInfo(params *GetRepoWebhookInfoParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetRepoWebhookInfoOK, error) + GetRepoWebhookInfoByFriendlyName(params *GetRepoWebhookInfoByFriendlyNameParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetRepoWebhookInfoByFriendlyNameOK, error) + InstallRepoWebhook(params *InstallRepoWebhookParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*InstallRepoWebhookOK, error) + InstallRepoWebhookByFriendlyName(params *InstallRepoWebhookByFriendlyNameParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*InstallRepoWebhookByFriendlyNameOK, error) + ListRepoInstances(params *ListRepoInstancesParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ListRepoInstancesOK, error) + ListRepoInstancesByFriendlyName(params *ListRepoInstancesByFriendlyNameParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ListRepoInstancesByFriendlyNameOK, error) + ListRepoPools(params *ListRepoPoolsParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ListRepoPoolsOK, error) + ListRepoPoolsByFriendlyName(params *ListRepoPoolsByFriendlyNameParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ListRepoPoolsByFriendlyNameOK, error) + ListRepoScaleSets(params *ListRepoScaleSetsParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ListRepoScaleSetsOK, error) + ListRepoScaleSetsByFriendlyName(params *ListRepoScaleSetsByFriendlyNameParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ListRepoScaleSetsByFriendlyNameOK, error) + ListRepos(params *ListReposParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ListReposOK, error) UninstallRepoWebhook(params *UninstallRepoWebhookParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) error + UninstallRepoWebhookByFriendlyName(params *UninstallRepoWebhookByFriendlyNameParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) error + UpdateRepo(params *UpdateRepoParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*UpdateRepoOK, error) + UpdateRepoByFriendlyName(params *UpdateRepoByFriendlyNameParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*UpdateRepoByFriendlyNameOK, error) + UpdateRepoPool(params *UpdateRepoPoolParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*UpdateRepoPoolOK, error) + UpdateRepoPoolByFriendlyName(params *UpdateRepoPoolByFriendlyNameParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*UpdateRepoPoolByFriendlyNameOK, error) + SetTransport(transport runtime.ClientTransport) } @@ -165,6 +193,44 @@ func (a *Client) CreateRepoPool(params *CreateRepoPoolParams, authInfo runtime.C return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code()) } +/* +CreateRepoPoolByFriendlyName creates repository pool with the parameters given +*/ +func (a *Client) CreateRepoPoolByFriendlyName(params *CreateRepoPoolByFriendlyNameParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*CreateRepoPoolByFriendlyNameOK, error) { + // TODO: Validate the params before sending + if params == nil { + params = NewCreateRepoPoolByFriendlyNameParams() + } + op := &runtime.ClientOperation{ + ID: "CreateRepoPoolByFriendlyName", + Method: "POST", + PathPattern: "/repositories/{owner}/{repo}/pools", + ProducesMediaTypes: []string{"application/json"}, + ConsumesMediaTypes: []string{"application/json"}, + Schemes: []string{"http"}, + Params: params, + Reader: &CreateRepoPoolByFriendlyNameReader{formats: a.formats}, + AuthInfo: authInfo, + Context: params.Context, + Client: params.HTTPClient, + } + for _, opt := range opts { + opt(op) + } + + result, err := a.transport.Submit(op) + if err != nil { + return nil, err + } + success, ok := result.(*CreateRepoPoolByFriendlyNameOK) + if ok { + return success, nil + } + // unexpected success response + unexpectedSuccess := result.(*CreateRepoPoolByFriendlyNameDefault) + return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code()) +} + /* CreateRepoScaleSet creates repository scale set with the parameters given */ @@ -203,6 +269,44 @@ func (a *Client) CreateRepoScaleSet(params *CreateRepoScaleSetParams, authInfo r return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code()) } +/* +CreateRepoScaleSetByFriendlyName creates repository scale set with the parameters given +*/ +func (a *Client) CreateRepoScaleSetByFriendlyName(params *CreateRepoScaleSetByFriendlyNameParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*CreateRepoScaleSetByFriendlyNameOK, error) { + // TODO: Validate the params before sending + if params == nil { + params = NewCreateRepoScaleSetByFriendlyNameParams() + } + op := &runtime.ClientOperation{ + ID: "CreateRepoScaleSetByFriendlyName", + Method: "POST", + PathPattern: "/repositories/{owner}/{repo}/scalesets", + ProducesMediaTypes: []string{"application/json"}, + ConsumesMediaTypes: []string{"application/json"}, + Schemes: []string{"http"}, + Params: params, + Reader: &CreateRepoScaleSetByFriendlyNameReader{formats: a.formats}, + AuthInfo: authInfo, + Context: params.Context, + Client: params.HTTPClient, + } + for _, opt := range opts { + opt(op) + } + + result, err := a.transport.Submit(op) + if err != nil { + return nil, err + } + success, ok := result.(*CreateRepoScaleSetByFriendlyNameOK) + if ok { + return success, nil + } + // unexpected success response + unexpectedSuccess := result.(*CreateRepoScaleSetByFriendlyNameDefault) + return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code()) +} + /* DeleteRepo deletes repository by ID */ @@ -235,6 +339,38 @@ func (a *Client) DeleteRepo(params *DeleteRepoParams, authInfo runtime.ClientAut return nil } +/* +DeleteRepoByFriendlyName deletes repository by ID +*/ +func (a *Client) DeleteRepoByFriendlyName(params *DeleteRepoByFriendlyNameParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) error { + // TODO: Validate the params before sending + if params == nil { + params = NewDeleteRepoByFriendlyNameParams() + } + op := &runtime.ClientOperation{ + ID: "DeleteRepoByFriendlyName", + Method: "DELETE", + PathPattern: "/repositories/{owner}/{repo}", + ProducesMediaTypes: []string{"application/json"}, + ConsumesMediaTypes: []string{"application/json"}, + Schemes: []string{"http"}, + Params: params, + Reader: &DeleteRepoByFriendlyNameReader{formats: a.formats}, + AuthInfo: authInfo, + Context: params.Context, + Client: params.HTTPClient, + } + for _, opt := range opts { + opt(op) + } + + _, err := a.transport.Submit(op) + if err != nil { + return err + } + return nil +} + /* DeleteRepoPool deletes repository pool by ID */ @@ -267,6 +403,38 @@ func (a *Client) DeleteRepoPool(params *DeleteRepoPoolParams, authInfo runtime.C return nil } +/* +DeleteRepoPoolByFriendlyName deletes repository pool by ID +*/ +func (a *Client) DeleteRepoPoolByFriendlyName(params *DeleteRepoPoolByFriendlyNameParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) error { + // TODO: Validate the params before sending + if params == nil { + params = NewDeleteRepoPoolByFriendlyNameParams() + } + op := &runtime.ClientOperation{ + ID: "DeleteRepoPoolByFriendlyName", + Method: "DELETE", + PathPattern: "/repositories/{owner}/{repo}/pools/{poolID}", + ProducesMediaTypes: []string{"application/json"}, + ConsumesMediaTypes: []string{"application/json"}, + Schemes: []string{"http"}, + Params: params, + Reader: &DeleteRepoPoolByFriendlyNameReader{formats: a.formats}, + AuthInfo: authInfo, + Context: params.Context, + Client: params.HTTPClient, + } + for _, opt := range opts { + opt(op) + } + + _, err := a.transport.Submit(op) + if err != nil { + return err + } + return nil +} + /* GetRepo gets repository by ID */ @@ -305,6 +473,44 @@ func (a *Client) GetRepo(params *GetRepoParams, authInfo runtime.ClientAuthInfoW return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code()) } +/* +GetRepoByFriendlyName gets repository by name +*/ +func (a *Client) GetRepoByFriendlyName(params *GetRepoByFriendlyNameParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetRepoByFriendlyNameOK, error) { + // TODO: Validate the params before sending + if params == nil { + params = NewGetRepoByFriendlyNameParams() + } + op := &runtime.ClientOperation{ + ID: "GetRepoByFriendlyName", + Method: "GET", + PathPattern: "/repositories/{owner}/{repo}", + ProducesMediaTypes: []string{"application/json"}, + ConsumesMediaTypes: []string{"application/json"}, + Schemes: []string{"http"}, + Params: params, + Reader: &GetRepoByFriendlyNameReader{formats: a.formats}, + AuthInfo: authInfo, + Context: params.Context, + Client: params.HTTPClient, + } + for _, opt := range opts { + opt(op) + } + + result, err := a.transport.Submit(op) + if err != nil { + return nil, err + } + success, ok := result.(*GetRepoByFriendlyNameOK) + if ok { + return success, nil + } + // unexpected success response + unexpectedSuccess := result.(*GetRepoByFriendlyNameDefault) + return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code()) +} + /* GetRepoPool gets repository pool by ID */ @@ -343,6 +549,44 @@ func (a *Client) GetRepoPool(params *GetRepoPoolParams, authInfo runtime.ClientA return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code()) } +/* +GetRepoPoolByFriendlyName gets repository pool by ID +*/ +func (a *Client) GetRepoPoolByFriendlyName(params *GetRepoPoolByFriendlyNameParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetRepoPoolByFriendlyNameOK, error) { + // TODO: Validate the params before sending + if params == nil { + params = NewGetRepoPoolByFriendlyNameParams() + } + op := &runtime.ClientOperation{ + ID: "GetRepoPoolByFriendlyName", + Method: "GET", + PathPattern: "/repositories/{owner}/{repo}/pools/{poolID}", + ProducesMediaTypes: []string{"application/json"}, + ConsumesMediaTypes: []string{"application/json"}, + Schemes: []string{"http"}, + Params: params, + Reader: &GetRepoPoolByFriendlyNameReader{formats: a.formats}, + AuthInfo: authInfo, + Context: params.Context, + Client: params.HTTPClient, + } + for _, opt := range opts { + opt(op) + } + + result, err := a.transport.Submit(op) + if err != nil { + return nil, err + } + success, ok := result.(*GetRepoPoolByFriendlyNameOK) + if ok { + return success, nil + } + // unexpected success response + unexpectedSuccess := result.(*GetRepoPoolByFriendlyNameDefault) + return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code()) +} + /* GetRepoWebhookInfo gets information about the g a r m installed webhook on a repository */ @@ -381,6 +625,44 @@ func (a *Client) GetRepoWebhookInfo(params *GetRepoWebhookInfoParams, authInfo r return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code()) } +/* +GetRepoWebhookInfoByFriendlyName gets information about the g a r m installed webhook on a repository +*/ +func (a *Client) GetRepoWebhookInfoByFriendlyName(params *GetRepoWebhookInfoByFriendlyNameParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetRepoWebhookInfoByFriendlyNameOK, error) { + // TODO: Validate the params before sending + if params == nil { + params = NewGetRepoWebhookInfoByFriendlyNameParams() + } + op := &runtime.ClientOperation{ + ID: "GetRepoWebhookInfoByFriendlyName", + Method: "GET", + PathPattern: "/repositories/{owner}/{repo}/webhook", + ProducesMediaTypes: []string{"application/json"}, + ConsumesMediaTypes: []string{"application/json"}, + Schemes: []string{"http"}, + Params: params, + Reader: &GetRepoWebhookInfoByFriendlyNameReader{formats: a.formats}, + AuthInfo: authInfo, + Context: params.Context, + Client: params.HTTPClient, + } + for _, opt := range opts { + opt(op) + } + + result, err := a.transport.Submit(op) + if err != nil { + return nil, err + } + success, ok := result.(*GetRepoWebhookInfoByFriendlyNameOK) + if ok { + return success, nil + } + // unexpected success response + unexpectedSuccess := result.(*GetRepoWebhookInfoByFriendlyNameDefault) + return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code()) +} + /* InstallRepoWebhook Install the GARM webhook for an organization. The secret configured on the organization will @@ -421,6 +703,46 @@ func (a *Client) InstallRepoWebhook(params *InstallRepoWebhookParams, authInfo r return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code()) } +/* + InstallRepoWebhookByFriendlyName Install the GARM webhook for an organization. The secret configured on the organization will + +be used to validate the requests. +*/ +func (a *Client) InstallRepoWebhookByFriendlyName(params *InstallRepoWebhookByFriendlyNameParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*InstallRepoWebhookByFriendlyNameOK, error) { + // TODO: Validate the params before sending + if params == nil { + params = NewInstallRepoWebhookByFriendlyNameParams() + } + op := &runtime.ClientOperation{ + ID: "InstallRepoWebhookByFriendlyName", + Method: "POST", + PathPattern: "/repositories/{owner}/{repo}/webhook", + ProducesMediaTypes: []string{"application/json"}, + ConsumesMediaTypes: []string{"application/json"}, + Schemes: []string{"http"}, + Params: params, + Reader: &InstallRepoWebhookByFriendlyNameReader{formats: a.formats}, + AuthInfo: authInfo, + Context: params.Context, + Client: params.HTTPClient, + } + for _, opt := range opts { + opt(op) + } + + result, err := a.transport.Submit(op) + if err != nil { + return nil, err + } + success, ok := result.(*InstallRepoWebhookByFriendlyNameOK) + if ok { + return success, nil + } + // unexpected success response + unexpectedSuccess := result.(*InstallRepoWebhookByFriendlyNameDefault) + return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code()) +} + /* ListRepoInstances lists repository instances */ @@ -459,6 +781,44 @@ func (a *Client) ListRepoInstances(params *ListRepoInstancesParams, authInfo run return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code()) } +/* +ListRepoInstancesByFriendlyName lists repository instances +*/ +func (a *Client) ListRepoInstancesByFriendlyName(params *ListRepoInstancesByFriendlyNameParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ListRepoInstancesByFriendlyNameOK, error) { + // TODO: Validate the params before sending + if params == nil { + params = NewListRepoInstancesByFriendlyNameParams() + } + op := &runtime.ClientOperation{ + ID: "ListRepoInstancesByFriendlyName", + Method: "GET", + PathPattern: "/repositories/{owner}/{repo}/instances", + ProducesMediaTypes: []string{"application/json"}, + ConsumesMediaTypes: []string{"application/json"}, + Schemes: []string{"http"}, + Params: params, + Reader: &ListRepoInstancesByFriendlyNameReader{formats: a.formats}, + AuthInfo: authInfo, + Context: params.Context, + Client: params.HTTPClient, + } + for _, opt := range opts { + opt(op) + } + + result, err := a.transport.Submit(op) + if err != nil { + return nil, err + } + success, ok := result.(*ListRepoInstancesByFriendlyNameOK) + if ok { + return success, nil + } + // unexpected success response + unexpectedSuccess := result.(*ListRepoInstancesByFriendlyNameDefault) + return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code()) +} + /* ListRepoPools lists repository pools */ @@ -497,6 +857,44 @@ func (a *Client) ListRepoPools(params *ListRepoPoolsParams, authInfo runtime.Cli return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code()) } +/* +ListRepoPoolsByFriendlyName lists repository pools +*/ +func (a *Client) ListRepoPoolsByFriendlyName(params *ListRepoPoolsByFriendlyNameParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ListRepoPoolsByFriendlyNameOK, error) { + // TODO: Validate the params before sending + if params == nil { + params = NewListRepoPoolsByFriendlyNameParams() + } + op := &runtime.ClientOperation{ + ID: "ListRepoPoolsByFriendlyName", + Method: "GET", + PathPattern: "/repositories/{owner}/{repo}/pools", + ProducesMediaTypes: []string{"application/json"}, + ConsumesMediaTypes: []string{"application/json"}, + Schemes: []string{"http"}, + Params: params, + Reader: &ListRepoPoolsByFriendlyNameReader{formats: a.formats}, + AuthInfo: authInfo, + Context: params.Context, + Client: params.HTTPClient, + } + for _, opt := range opts { + opt(op) + } + + result, err := a.transport.Submit(op) + if err != nil { + return nil, err + } + success, ok := result.(*ListRepoPoolsByFriendlyNameOK) + if ok { + return success, nil + } + // unexpected success response + unexpectedSuccess := result.(*ListRepoPoolsByFriendlyNameDefault) + return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code()) +} + /* ListRepoScaleSets lists repository scale sets */ @@ -535,6 +933,44 @@ func (a *Client) ListRepoScaleSets(params *ListRepoScaleSetsParams, authInfo run return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code()) } +/* +ListRepoScaleSetsByFriendlyName lists repository scale sets +*/ +func (a *Client) ListRepoScaleSetsByFriendlyName(params *ListRepoScaleSetsByFriendlyNameParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ListRepoScaleSetsByFriendlyNameOK, error) { + // TODO: Validate the params before sending + if params == nil { + params = NewListRepoScaleSetsByFriendlyNameParams() + } + op := &runtime.ClientOperation{ + ID: "ListRepoScaleSetsByFriendlyName", + Method: "GET", + PathPattern: "/repositories/{owner}/{repo}/scalesets", + ProducesMediaTypes: []string{"application/json"}, + ConsumesMediaTypes: []string{"application/json"}, + Schemes: []string{"http"}, + Params: params, + Reader: &ListRepoScaleSetsByFriendlyNameReader{formats: a.formats}, + AuthInfo: authInfo, + Context: params.Context, + Client: params.HTTPClient, + } + for _, opt := range opts { + opt(op) + } + + result, err := a.transport.Submit(op) + if err != nil { + return nil, err + } + success, ok := result.(*ListRepoScaleSetsByFriendlyNameOK) + if ok { + return success, nil + } + // unexpected success response + unexpectedSuccess := result.(*ListRepoScaleSetsByFriendlyNameDefault) + return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code()) +} + /* ListRepos lists repositories */ @@ -605,6 +1041,38 @@ func (a *Client) UninstallRepoWebhook(params *UninstallRepoWebhookParams, authIn return nil } +/* +UninstallRepoWebhookByFriendlyName uninstalls organization webhook +*/ +func (a *Client) UninstallRepoWebhookByFriendlyName(params *UninstallRepoWebhookByFriendlyNameParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) error { + // TODO: Validate the params before sending + if params == nil { + params = NewUninstallRepoWebhookByFriendlyNameParams() + } + op := &runtime.ClientOperation{ + ID: "UninstallRepoWebhookByFriendlyName", + Method: "DELETE", + PathPattern: "/repositories/{owner}/{repo}/webhook", + ProducesMediaTypes: []string{"application/json"}, + ConsumesMediaTypes: []string{"application/json"}, + Schemes: []string{"http"}, + Params: params, + Reader: &UninstallRepoWebhookByFriendlyNameReader{formats: a.formats}, + AuthInfo: authInfo, + Context: params.Context, + Client: params.HTTPClient, + } + for _, opt := range opts { + opt(op) + } + + _, err := a.transport.Submit(op) + if err != nil { + return err + } + return nil +} + /* UpdateRepo updates repository with the parameters given */ @@ -643,6 +1111,44 @@ func (a *Client) UpdateRepo(params *UpdateRepoParams, authInfo runtime.ClientAut return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code()) } +/* +UpdateRepoByFriendlyName updates repository with the parameters given +*/ +func (a *Client) UpdateRepoByFriendlyName(params *UpdateRepoByFriendlyNameParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*UpdateRepoByFriendlyNameOK, error) { + // TODO: Validate the params before sending + if params == nil { + params = NewUpdateRepoByFriendlyNameParams() + } + op := &runtime.ClientOperation{ + ID: "UpdateRepoByFriendlyName", + Method: "PUT", + PathPattern: "/repositories/{owner}/{repo}", + ProducesMediaTypes: []string{"application/json"}, + ConsumesMediaTypes: []string{"application/json"}, + Schemes: []string{"http"}, + Params: params, + Reader: &UpdateRepoByFriendlyNameReader{formats: a.formats}, + AuthInfo: authInfo, + Context: params.Context, + Client: params.HTTPClient, + } + for _, opt := range opts { + opt(op) + } + + result, err := a.transport.Submit(op) + if err != nil { + return nil, err + } + success, ok := result.(*UpdateRepoByFriendlyNameOK) + if ok { + return success, nil + } + // unexpected success response + unexpectedSuccess := result.(*UpdateRepoByFriendlyNameDefault) + return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code()) +} + /* UpdateRepoPool updates repository pool with the parameters given */ @@ -681,6 +1187,44 @@ func (a *Client) UpdateRepoPool(params *UpdateRepoPoolParams, authInfo runtime.C return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code()) } +/* +UpdateRepoPoolByFriendlyName updates repository pool with the parameters given +*/ +func (a *Client) UpdateRepoPoolByFriendlyName(params *UpdateRepoPoolByFriendlyNameParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*UpdateRepoPoolByFriendlyNameOK, error) { + // TODO: Validate the params before sending + if params == nil { + params = NewUpdateRepoPoolByFriendlyNameParams() + } + op := &runtime.ClientOperation{ + ID: "UpdateRepoPoolByFriendlyName", + Method: "PUT", + PathPattern: "/repositories/{owner}/{repo}/pools/{poolID}", + ProducesMediaTypes: []string{"application/json"}, + ConsumesMediaTypes: []string{"application/json"}, + Schemes: []string{"http"}, + Params: params, + Reader: &UpdateRepoPoolByFriendlyNameReader{formats: a.formats}, + AuthInfo: authInfo, + Context: params.Context, + Client: params.HTTPClient, + } + for _, opt := range opts { + opt(op) + } + + result, err := a.transport.Submit(op) + if err != nil { + return nil, err + } + success, ok := result.(*UpdateRepoPoolByFriendlyNameOK) + if ok { + return success, nil + } + // unexpected success response + unexpectedSuccess := result.(*UpdateRepoPoolByFriendlyNameDefault) + return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code()) +} + // SetTransport changes the transport on the client func (a *Client) SetTransport(transport runtime.ClientTransport) { a.transport = transport diff --git a/client/repositories/uninstall_repo_webhook_by_friendly_name_parameters.go b/client/repositories/uninstall_repo_webhook_by_friendly_name_parameters.go new file mode 100644 index 000000000..49166b296 --- /dev/null +++ b/client/repositories/uninstall_repo_webhook_by_friendly_name_parameters.go @@ -0,0 +1,207 @@ +// Code generated by go-swagger; DO NOT EDIT. + +package repositories + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "context" + "net/http" + "time" + + "github.com/go-openapi/errors" + "github.com/go-openapi/runtime" + cr "github.com/go-openapi/runtime/client" + "github.com/go-openapi/strfmt" +) + +// NewUninstallRepoWebhookByFriendlyNameParams creates a new UninstallRepoWebhookByFriendlyNameParams object, +// with the default timeout for this client. +// +// Default values are not hydrated, since defaults are normally applied by the API server side. +// +// To enforce default values in parameter, use SetDefaults or WithDefaults. +func NewUninstallRepoWebhookByFriendlyNameParams() *UninstallRepoWebhookByFriendlyNameParams { + return &UninstallRepoWebhookByFriendlyNameParams{ + timeout: cr.DefaultTimeout, + } +} + +// NewUninstallRepoWebhookByFriendlyNameParamsWithTimeout creates a new UninstallRepoWebhookByFriendlyNameParams object +// with the ability to set a timeout on a request. +func NewUninstallRepoWebhookByFriendlyNameParamsWithTimeout(timeout time.Duration) *UninstallRepoWebhookByFriendlyNameParams { + return &UninstallRepoWebhookByFriendlyNameParams{ + timeout: timeout, + } +} + +// NewUninstallRepoWebhookByFriendlyNameParamsWithContext creates a new UninstallRepoWebhookByFriendlyNameParams object +// with the ability to set a context for a request. +func NewUninstallRepoWebhookByFriendlyNameParamsWithContext(ctx context.Context) *UninstallRepoWebhookByFriendlyNameParams { + return &UninstallRepoWebhookByFriendlyNameParams{ + Context: ctx, + } +} + +// NewUninstallRepoWebhookByFriendlyNameParamsWithHTTPClient creates a new UninstallRepoWebhookByFriendlyNameParams object +// with the ability to set a custom HTTPClient for a request. +func NewUninstallRepoWebhookByFriendlyNameParamsWithHTTPClient(client *http.Client) *UninstallRepoWebhookByFriendlyNameParams { + return &UninstallRepoWebhookByFriendlyNameParams{ + HTTPClient: client, + } +} + +/* +UninstallRepoWebhookByFriendlyNameParams contains all the parameters to send to the API endpoint + + for the uninstall repo webhook by friendly name operation. + + Typically these are written to a http.Request. +*/ +type UninstallRepoWebhookByFriendlyNameParams struct { + + /* EndpointName. + + Repository endpointName. + */ + EndpointName *string + + /* Owner. + + Repository owner. + */ + Owner string + + /* Repo. + + Repository name. + */ + Repo string + + timeout time.Duration + Context context.Context + HTTPClient *http.Client +} + +// WithDefaults hydrates default values in the uninstall repo webhook by friendly name params (not the query body). +// +// All values with no default are reset to their zero value. +func (o *UninstallRepoWebhookByFriendlyNameParams) WithDefaults() *UninstallRepoWebhookByFriendlyNameParams { + o.SetDefaults() + return o +} + +// SetDefaults hydrates default values in the uninstall repo webhook by friendly name params (not the query body). +// +// All values with no default are reset to their zero value. +func (o *UninstallRepoWebhookByFriendlyNameParams) SetDefaults() { + // no default values defined for this parameter +} + +// WithTimeout adds the timeout to the uninstall repo webhook by friendly name params +func (o *UninstallRepoWebhookByFriendlyNameParams) WithTimeout(timeout time.Duration) *UninstallRepoWebhookByFriendlyNameParams { + o.SetTimeout(timeout) + return o +} + +// SetTimeout adds the timeout to the uninstall repo webhook by friendly name params +func (o *UninstallRepoWebhookByFriendlyNameParams) SetTimeout(timeout time.Duration) { + o.timeout = timeout +} + +// WithContext adds the context to the uninstall repo webhook by friendly name params +func (o *UninstallRepoWebhookByFriendlyNameParams) WithContext(ctx context.Context) *UninstallRepoWebhookByFriendlyNameParams { + o.SetContext(ctx) + return o +} + +// SetContext adds the context to the uninstall repo webhook by friendly name params +func (o *UninstallRepoWebhookByFriendlyNameParams) SetContext(ctx context.Context) { + o.Context = ctx +} + +// WithHTTPClient adds the HTTPClient to the uninstall repo webhook by friendly name params +func (o *UninstallRepoWebhookByFriendlyNameParams) WithHTTPClient(client *http.Client) *UninstallRepoWebhookByFriendlyNameParams { + o.SetHTTPClient(client) + return o +} + +// SetHTTPClient adds the HTTPClient to the uninstall repo webhook by friendly name params +func (o *UninstallRepoWebhookByFriendlyNameParams) SetHTTPClient(client *http.Client) { + o.HTTPClient = client +} + +// WithEndpointName adds the endpointName to the uninstall repo webhook by friendly name params +func (o *UninstallRepoWebhookByFriendlyNameParams) WithEndpointName(endpointName *string) *UninstallRepoWebhookByFriendlyNameParams { + o.SetEndpointName(endpointName) + return o +} + +// SetEndpointName adds the endpointName to the uninstall repo webhook by friendly name params +func (o *UninstallRepoWebhookByFriendlyNameParams) SetEndpointName(endpointName *string) { + o.EndpointName = endpointName +} + +// WithOwner adds the owner to the uninstall repo webhook by friendly name params +func (o *UninstallRepoWebhookByFriendlyNameParams) WithOwner(owner string) *UninstallRepoWebhookByFriendlyNameParams { + o.SetOwner(owner) + return o +} + +// SetOwner adds the owner to the uninstall repo webhook by friendly name params +func (o *UninstallRepoWebhookByFriendlyNameParams) SetOwner(owner string) { + o.Owner = owner +} + +// WithRepo adds the repo to the uninstall repo webhook by friendly name params +func (o *UninstallRepoWebhookByFriendlyNameParams) WithRepo(repo string) *UninstallRepoWebhookByFriendlyNameParams { + o.SetRepo(repo) + return o +} + +// SetRepo adds the repo to the uninstall repo webhook by friendly name params +func (o *UninstallRepoWebhookByFriendlyNameParams) SetRepo(repo string) { + o.Repo = repo +} + +// WriteToRequest writes these params to a swagger request +func (o *UninstallRepoWebhookByFriendlyNameParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error { + + if err := r.SetTimeout(o.timeout); err != nil { + return err + } + var res []error + + if o.EndpointName != nil { + + // query param endpointName + var qrEndpointName string + + if o.EndpointName != nil { + qrEndpointName = *o.EndpointName + } + qEndpointName := qrEndpointName + if qEndpointName != "" { + + if err := r.SetQueryParam("endpointName", qEndpointName); err != nil { + return err + } + } + } + + // path param owner + if err := r.SetPathParam("owner", o.Owner); err != nil { + return err + } + + // path param repo + if err := r.SetPathParam("repo", o.Repo); err != nil { + return err + } + + if len(res) > 0 { + return errors.CompositeValidationError(res...) + } + return nil +} diff --git a/client/repositories/uninstall_repo_webhook_by_friendly_name_responses.go b/client/repositories/uninstall_repo_webhook_by_friendly_name_responses.go new file mode 100644 index 000000000..5c60804c3 --- /dev/null +++ b/client/repositories/uninstall_repo_webhook_by_friendly_name_responses.go @@ -0,0 +1,106 @@ +// Code generated by go-swagger; DO NOT EDIT. + +package repositories + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "encoding/json" + "fmt" + "io" + + "github.com/go-openapi/runtime" + "github.com/go-openapi/strfmt" + + apiserver_params "github.com/cloudbase/garm/apiserver/params" +) + +// UninstallRepoWebhookByFriendlyNameReader is a Reader for the UninstallRepoWebhookByFriendlyName structure. +type UninstallRepoWebhookByFriendlyNameReader struct { + formats strfmt.Registry +} + +// ReadResponse reads a server response into the received o. +func (o *UninstallRepoWebhookByFriendlyNameReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error) { + result := NewUninstallRepoWebhookByFriendlyNameDefault(response.Code()) + if err := result.readResponse(response, consumer, o.formats); err != nil { + return nil, err + } + if response.Code()/100 == 2 { + return result, nil + } + return nil, result +} + +// NewUninstallRepoWebhookByFriendlyNameDefault creates a UninstallRepoWebhookByFriendlyNameDefault with default headers values +func NewUninstallRepoWebhookByFriendlyNameDefault(code int) *UninstallRepoWebhookByFriendlyNameDefault { + return &UninstallRepoWebhookByFriendlyNameDefault{ + _statusCode: code, + } +} + +/* +UninstallRepoWebhookByFriendlyNameDefault describes a response with status code -1, with default header values. + +APIErrorResponse +*/ +type UninstallRepoWebhookByFriendlyNameDefault struct { + _statusCode int + + Payload apiserver_params.APIErrorResponse +} + +// IsSuccess returns true when this uninstall repo webhook by friendly name default response has a 2xx status code +func (o *UninstallRepoWebhookByFriendlyNameDefault) IsSuccess() bool { + return o._statusCode/100 == 2 +} + +// IsRedirect returns true when this uninstall repo webhook by friendly name default response has a 3xx status code +func (o *UninstallRepoWebhookByFriendlyNameDefault) IsRedirect() bool { + return o._statusCode/100 == 3 +} + +// IsClientError returns true when this uninstall repo webhook by friendly name default response has a 4xx status code +func (o *UninstallRepoWebhookByFriendlyNameDefault) IsClientError() bool { + return o._statusCode/100 == 4 +} + +// IsServerError returns true when this uninstall repo webhook by friendly name default response has a 5xx status code +func (o *UninstallRepoWebhookByFriendlyNameDefault) IsServerError() bool { + return o._statusCode/100 == 5 +} + +// IsCode returns true when this uninstall repo webhook by friendly name default response a status code equal to that given +func (o *UninstallRepoWebhookByFriendlyNameDefault) IsCode(code int) bool { + return o._statusCode == code +} + +// Code gets the status code for the uninstall repo webhook by friendly name default response +func (o *UninstallRepoWebhookByFriendlyNameDefault) Code() int { + return o._statusCode +} + +func (o *UninstallRepoWebhookByFriendlyNameDefault) Error() string { + payload, _ := json.Marshal(o.Payload) + return fmt.Sprintf("[DELETE /repositories/{owner}/{repo}/webhook][%d] UninstallRepoWebhookByFriendlyName default %s", o._statusCode, payload) +} + +func (o *UninstallRepoWebhookByFriendlyNameDefault) String() string { + payload, _ := json.Marshal(o.Payload) + return fmt.Sprintf("[DELETE /repositories/{owner}/{repo}/webhook][%d] UninstallRepoWebhookByFriendlyName default %s", o._statusCode, payload) +} + +func (o *UninstallRepoWebhookByFriendlyNameDefault) GetPayload() apiserver_params.APIErrorResponse { + return o.Payload +} + +func (o *UninstallRepoWebhookByFriendlyNameDefault) readResponse(response runtime.ClientResponse, consumer runtime.Consumer, formats strfmt.Registry) error { + + // response payload + if err := consumer.Consume(response.Body(), &o.Payload); err != nil && err != io.EOF { + return err + } + + return nil +} diff --git a/client/repositories/update_repo_by_friendly_name_parameters.go b/client/repositories/update_repo_by_friendly_name_parameters.go new file mode 100644 index 000000000..ec191b411 --- /dev/null +++ b/client/repositories/update_repo_by_friendly_name_parameters.go @@ -0,0 +1,229 @@ +// Code generated by go-swagger; DO NOT EDIT. + +package repositories + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "context" + "net/http" + "time" + + "github.com/go-openapi/errors" + "github.com/go-openapi/runtime" + cr "github.com/go-openapi/runtime/client" + "github.com/go-openapi/strfmt" + + garm_params "github.com/cloudbase/garm/params" +) + +// NewUpdateRepoByFriendlyNameParams creates a new UpdateRepoByFriendlyNameParams object, +// with the default timeout for this client. +// +// Default values are not hydrated, since defaults are normally applied by the API server side. +// +// To enforce default values in parameter, use SetDefaults or WithDefaults. +func NewUpdateRepoByFriendlyNameParams() *UpdateRepoByFriendlyNameParams { + return &UpdateRepoByFriendlyNameParams{ + timeout: cr.DefaultTimeout, + } +} + +// NewUpdateRepoByFriendlyNameParamsWithTimeout creates a new UpdateRepoByFriendlyNameParams object +// with the ability to set a timeout on a request. +func NewUpdateRepoByFriendlyNameParamsWithTimeout(timeout time.Duration) *UpdateRepoByFriendlyNameParams { + return &UpdateRepoByFriendlyNameParams{ + timeout: timeout, + } +} + +// NewUpdateRepoByFriendlyNameParamsWithContext creates a new UpdateRepoByFriendlyNameParams object +// with the ability to set a context for a request. +func NewUpdateRepoByFriendlyNameParamsWithContext(ctx context.Context) *UpdateRepoByFriendlyNameParams { + return &UpdateRepoByFriendlyNameParams{ + Context: ctx, + } +} + +// NewUpdateRepoByFriendlyNameParamsWithHTTPClient creates a new UpdateRepoByFriendlyNameParams object +// with the ability to set a custom HTTPClient for a request. +func NewUpdateRepoByFriendlyNameParamsWithHTTPClient(client *http.Client) *UpdateRepoByFriendlyNameParams { + return &UpdateRepoByFriendlyNameParams{ + HTTPClient: client, + } +} + +/* +UpdateRepoByFriendlyNameParams contains all the parameters to send to the API endpoint + + for the update repo by friendly name operation. + + Typically these are written to a http.Request. +*/ +type UpdateRepoByFriendlyNameParams struct { + + /* Body. + + Parameters used when updating the repository. + */ + Body garm_params.UpdateEntityParams + + /* EndpointName. + + endpointName of the repository to update. + */ + EndpointName *string + + /* Owner. + + owner of the repository to update. + */ + Owner string + + /* Repo. + + name of the repository to update. + */ + Repo string + + timeout time.Duration + Context context.Context + HTTPClient *http.Client +} + +// WithDefaults hydrates default values in the update repo by friendly name params (not the query body). +// +// All values with no default are reset to their zero value. +func (o *UpdateRepoByFriendlyNameParams) WithDefaults() *UpdateRepoByFriendlyNameParams { + o.SetDefaults() + return o +} + +// SetDefaults hydrates default values in the update repo by friendly name params (not the query body). +// +// All values with no default are reset to their zero value. +func (o *UpdateRepoByFriendlyNameParams) SetDefaults() { + // no default values defined for this parameter +} + +// WithTimeout adds the timeout to the update repo by friendly name params +func (o *UpdateRepoByFriendlyNameParams) WithTimeout(timeout time.Duration) *UpdateRepoByFriendlyNameParams { + o.SetTimeout(timeout) + return o +} + +// SetTimeout adds the timeout to the update repo by friendly name params +func (o *UpdateRepoByFriendlyNameParams) SetTimeout(timeout time.Duration) { + o.timeout = timeout +} + +// WithContext adds the context to the update repo by friendly name params +func (o *UpdateRepoByFriendlyNameParams) WithContext(ctx context.Context) *UpdateRepoByFriendlyNameParams { + o.SetContext(ctx) + return o +} + +// SetContext adds the context to the update repo by friendly name params +func (o *UpdateRepoByFriendlyNameParams) SetContext(ctx context.Context) { + o.Context = ctx +} + +// WithHTTPClient adds the HTTPClient to the update repo by friendly name params +func (o *UpdateRepoByFriendlyNameParams) WithHTTPClient(client *http.Client) *UpdateRepoByFriendlyNameParams { + o.SetHTTPClient(client) + return o +} + +// SetHTTPClient adds the HTTPClient to the update repo by friendly name params +func (o *UpdateRepoByFriendlyNameParams) SetHTTPClient(client *http.Client) { + o.HTTPClient = client +} + +// WithBody adds the body to the update repo by friendly name params +func (o *UpdateRepoByFriendlyNameParams) WithBody(body garm_params.UpdateEntityParams) *UpdateRepoByFriendlyNameParams { + o.SetBody(body) + return o +} + +// SetBody adds the body to the update repo by friendly name params +func (o *UpdateRepoByFriendlyNameParams) SetBody(body garm_params.UpdateEntityParams) { + o.Body = body +} + +// WithEndpointName adds the endpointName to the update repo by friendly name params +func (o *UpdateRepoByFriendlyNameParams) WithEndpointName(endpointName *string) *UpdateRepoByFriendlyNameParams { + o.SetEndpointName(endpointName) + return o +} + +// SetEndpointName adds the endpointName to the update repo by friendly name params +func (o *UpdateRepoByFriendlyNameParams) SetEndpointName(endpointName *string) { + o.EndpointName = endpointName +} + +// WithOwner adds the owner to the update repo by friendly name params +func (o *UpdateRepoByFriendlyNameParams) WithOwner(owner string) *UpdateRepoByFriendlyNameParams { + o.SetOwner(owner) + return o +} + +// SetOwner adds the owner to the update repo by friendly name params +func (o *UpdateRepoByFriendlyNameParams) SetOwner(owner string) { + o.Owner = owner +} + +// WithRepo adds the repo to the update repo by friendly name params +func (o *UpdateRepoByFriendlyNameParams) WithRepo(repo string) *UpdateRepoByFriendlyNameParams { + o.SetRepo(repo) + return o +} + +// SetRepo adds the repo to the update repo by friendly name params +func (o *UpdateRepoByFriendlyNameParams) SetRepo(repo string) { + o.Repo = repo +} + +// WriteToRequest writes these params to a swagger request +func (o *UpdateRepoByFriendlyNameParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error { + + if err := r.SetTimeout(o.timeout); err != nil { + return err + } + var res []error + if err := r.SetBodyParam(o.Body); err != nil { + return err + } + + if o.EndpointName != nil { + + // query param endpointName + var qrEndpointName string + + if o.EndpointName != nil { + qrEndpointName = *o.EndpointName + } + qEndpointName := qrEndpointName + if qEndpointName != "" { + + if err := r.SetQueryParam("endpointName", qEndpointName); err != nil { + return err + } + } + } + + // path param owner + if err := r.SetPathParam("owner", o.Owner); err != nil { + return err + } + + // path param repo + if err := r.SetPathParam("repo", o.Repo); err != nil { + return err + } + + if len(res) > 0 { + return errors.CompositeValidationError(res...) + } + return nil +} diff --git a/client/repositories/update_repo_by_friendly_name_responses.go b/client/repositories/update_repo_by_friendly_name_responses.go new file mode 100644 index 000000000..70a5a57f5 --- /dev/null +++ b/client/repositories/update_repo_by_friendly_name_responses.go @@ -0,0 +1,184 @@ +// Code generated by go-swagger; DO NOT EDIT. + +package repositories + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "encoding/json" + "fmt" + "io" + + "github.com/go-openapi/runtime" + "github.com/go-openapi/strfmt" + + apiserver_params "github.com/cloudbase/garm/apiserver/params" + garm_params "github.com/cloudbase/garm/params" +) + +// UpdateRepoByFriendlyNameReader is a Reader for the UpdateRepoByFriendlyName structure. +type UpdateRepoByFriendlyNameReader struct { + formats strfmt.Registry +} + +// ReadResponse reads a server response into the received o. +func (o *UpdateRepoByFriendlyNameReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error) { + switch response.Code() { + case 200: + result := NewUpdateRepoByFriendlyNameOK() + if err := result.readResponse(response, consumer, o.formats); err != nil { + return nil, err + } + return result, nil + default: + result := NewUpdateRepoByFriendlyNameDefault(response.Code()) + if err := result.readResponse(response, consumer, o.formats); err != nil { + return nil, err + } + if response.Code()/100 == 2 { + return result, nil + } + return nil, result + } +} + +// NewUpdateRepoByFriendlyNameOK creates a UpdateRepoByFriendlyNameOK with default headers values +func NewUpdateRepoByFriendlyNameOK() *UpdateRepoByFriendlyNameOK { + return &UpdateRepoByFriendlyNameOK{} +} + +/* +UpdateRepoByFriendlyNameOK describes a response with status code 200, with default header values. + +Repository +*/ +type UpdateRepoByFriendlyNameOK struct { + Payload garm_params.Repository +} + +// IsSuccess returns true when this update repo by friendly name o k response has a 2xx status code +func (o *UpdateRepoByFriendlyNameOK) IsSuccess() bool { + return true +} + +// IsRedirect returns true when this update repo by friendly name o k response has a 3xx status code +func (o *UpdateRepoByFriendlyNameOK) IsRedirect() bool { + return false +} + +// IsClientError returns true when this update repo by friendly name o k response has a 4xx status code +func (o *UpdateRepoByFriendlyNameOK) IsClientError() bool { + return false +} + +// IsServerError returns true when this update repo by friendly name o k response has a 5xx status code +func (o *UpdateRepoByFriendlyNameOK) IsServerError() bool { + return false +} + +// IsCode returns true when this update repo by friendly name o k response a status code equal to that given +func (o *UpdateRepoByFriendlyNameOK) IsCode(code int) bool { + return code == 200 +} + +// Code gets the status code for the update repo by friendly name o k response +func (o *UpdateRepoByFriendlyNameOK) Code() int { + return 200 +} + +func (o *UpdateRepoByFriendlyNameOK) Error() string { + payload, _ := json.Marshal(o.Payload) + return fmt.Sprintf("[PUT /repositories/{owner}/{repo}][%d] updateRepoByFriendlyNameOK %s", 200, payload) +} + +func (o *UpdateRepoByFriendlyNameOK) String() string { + payload, _ := json.Marshal(o.Payload) + return fmt.Sprintf("[PUT /repositories/{owner}/{repo}][%d] updateRepoByFriendlyNameOK %s", 200, payload) +} + +func (o *UpdateRepoByFriendlyNameOK) GetPayload() garm_params.Repository { + return o.Payload +} + +func (o *UpdateRepoByFriendlyNameOK) readResponse(response runtime.ClientResponse, consumer runtime.Consumer, formats strfmt.Registry) error { + + // response payload + if err := consumer.Consume(response.Body(), &o.Payload); err != nil && err != io.EOF { + return err + } + + return nil +} + +// NewUpdateRepoByFriendlyNameDefault creates a UpdateRepoByFriendlyNameDefault with default headers values +func NewUpdateRepoByFriendlyNameDefault(code int) *UpdateRepoByFriendlyNameDefault { + return &UpdateRepoByFriendlyNameDefault{ + _statusCode: code, + } +} + +/* +UpdateRepoByFriendlyNameDefault describes a response with status code -1, with default header values. + +APIErrorResponse +*/ +type UpdateRepoByFriendlyNameDefault struct { + _statusCode int + + Payload apiserver_params.APIErrorResponse +} + +// IsSuccess returns true when this update repo by friendly name default response has a 2xx status code +func (o *UpdateRepoByFriendlyNameDefault) IsSuccess() bool { + return o._statusCode/100 == 2 +} + +// IsRedirect returns true when this update repo by friendly name default response has a 3xx status code +func (o *UpdateRepoByFriendlyNameDefault) IsRedirect() bool { + return o._statusCode/100 == 3 +} + +// IsClientError returns true when this update repo by friendly name default response has a 4xx status code +func (o *UpdateRepoByFriendlyNameDefault) IsClientError() bool { + return o._statusCode/100 == 4 +} + +// IsServerError returns true when this update repo by friendly name default response has a 5xx status code +func (o *UpdateRepoByFriendlyNameDefault) IsServerError() bool { + return o._statusCode/100 == 5 +} + +// IsCode returns true when this update repo by friendly name default response a status code equal to that given +func (o *UpdateRepoByFriendlyNameDefault) IsCode(code int) bool { + return o._statusCode == code +} + +// Code gets the status code for the update repo by friendly name default response +func (o *UpdateRepoByFriendlyNameDefault) Code() int { + return o._statusCode +} + +func (o *UpdateRepoByFriendlyNameDefault) Error() string { + payload, _ := json.Marshal(o.Payload) + return fmt.Sprintf("[PUT /repositories/{owner}/{repo}][%d] UpdateRepoByFriendlyName default %s", o._statusCode, payload) +} + +func (o *UpdateRepoByFriendlyNameDefault) String() string { + payload, _ := json.Marshal(o.Payload) + return fmt.Sprintf("[PUT /repositories/{owner}/{repo}][%d] UpdateRepoByFriendlyName default %s", o._statusCode, payload) +} + +func (o *UpdateRepoByFriendlyNameDefault) GetPayload() apiserver_params.APIErrorResponse { + return o.Payload +} + +func (o *UpdateRepoByFriendlyNameDefault) readResponse(response runtime.ClientResponse, consumer runtime.Consumer, formats strfmt.Registry) error { + + // response payload + if err := consumer.Consume(response.Body(), &o.Payload); err != nil && err != io.EOF { + return err + } + + return nil +} diff --git a/client/repositories/update_repo_pool_by_friendly_name_parameters.go b/client/repositories/update_repo_pool_by_friendly_name_parameters.go new file mode 100644 index 000000000..4a5c43f65 --- /dev/null +++ b/client/repositories/update_repo_pool_by_friendly_name_parameters.go @@ -0,0 +1,251 @@ +// Code generated by go-swagger; DO NOT EDIT. + +package repositories + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "context" + "net/http" + "time" + + "github.com/go-openapi/errors" + "github.com/go-openapi/runtime" + cr "github.com/go-openapi/runtime/client" + "github.com/go-openapi/strfmt" + + garm_params "github.com/cloudbase/garm/params" +) + +// NewUpdateRepoPoolByFriendlyNameParams creates a new UpdateRepoPoolByFriendlyNameParams object, +// with the default timeout for this client. +// +// Default values are not hydrated, since defaults are normally applied by the API server side. +// +// To enforce default values in parameter, use SetDefaults or WithDefaults. +func NewUpdateRepoPoolByFriendlyNameParams() *UpdateRepoPoolByFriendlyNameParams { + return &UpdateRepoPoolByFriendlyNameParams{ + timeout: cr.DefaultTimeout, + } +} + +// NewUpdateRepoPoolByFriendlyNameParamsWithTimeout creates a new UpdateRepoPoolByFriendlyNameParams object +// with the ability to set a timeout on a request. +func NewUpdateRepoPoolByFriendlyNameParamsWithTimeout(timeout time.Duration) *UpdateRepoPoolByFriendlyNameParams { + return &UpdateRepoPoolByFriendlyNameParams{ + timeout: timeout, + } +} + +// NewUpdateRepoPoolByFriendlyNameParamsWithContext creates a new UpdateRepoPoolByFriendlyNameParams object +// with the ability to set a context for a request. +func NewUpdateRepoPoolByFriendlyNameParamsWithContext(ctx context.Context) *UpdateRepoPoolByFriendlyNameParams { + return &UpdateRepoPoolByFriendlyNameParams{ + Context: ctx, + } +} + +// NewUpdateRepoPoolByFriendlyNameParamsWithHTTPClient creates a new UpdateRepoPoolByFriendlyNameParams object +// with the ability to set a custom HTTPClient for a request. +func NewUpdateRepoPoolByFriendlyNameParamsWithHTTPClient(client *http.Client) *UpdateRepoPoolByFriendlyNameParams { + return &UpdateRepoPoolByFriendlyNameParams{ + HTTPClient: client, + } +} + +/* +UpdateRepoPoolByFriendlyNameParams contains all the parameters to send to the API endpoint + + for the update repo pool by friendly name operation. + + Typically these are written to a http.Request. +*/ +type UpdateRepoPoolByFriendlyNameParams struct { + + /* Body. + + Parameters used when updating the repository pool. + */ + Body garm_params.UpdatePoolParams + + /* EndpointName. + + Repository endpointName. + */ + EndpointName *string + + /* Owner. + + Repository owner. + */ + Owner string + + /* PoolID. + + ID of the repository pool to update. + */ + PoolID string + + /* Repo. + + Repository name. + */ + Repo string + + timeout time.Duration + Context context.Context + HTTPClient *http.Client +} + +// WithDefaults hydrates default values in the update repo pool by friendly name params (not the query body). +// +// All values with no default are reset to their zero value. +func (o *UpdateRepoPoolByFriendlyNameParams) WithDefaults() *UpdateRepoPoolByFriendlyNameParams { + o.SetDefaults() + return o +} + +// SetDefaults hydrates default values in the update repo pool by friendly name params (not the query body). +// +// All values with no default are reset to their zero value. +func (o *UpdateRepoPoolByFriendlyNameParams) SetDefaults() { + // no default values defined for this parameter +} + +// WithTimeout adds the timeout to the update repo pool by friendly name params +func (o *UpdateRepoPoolByFriendlyNameParams) WithTimeout(timeout time.Duration) *UpdateRepoPoolByFriendlyNameParams { + o.SetTimeout(timeout) + return o +} + +// SetTimeout adds the timeout to the update repo pool by friendly name params +func (o *UpdateRepoPoolByFriendlyNameParams) SetTimeout(timeout time.Duration) { + o.timeout = timeout +} + +// WithContext adds the context to the update repo pool by friendly name params +func (o *UpdateRepoPoolByFriendlyNameParams) WithContext(ctx context.Context) *UpdateRepoPoolByFriendlyNameParams { + o.SetContext(ctx) + return o +} + +// SetContext adds the context to the update repo pool by friendly name params +func (o *UpdateRepoPoolByFriendlyNameParams) SetContext(ctx context.Context) { + o.Context = ctx +} + +// WithHTTPClient adds the HTTPClient to the update repo pool by friendly name params +func (o *UpdateRepoPoolByFriendlyNameParams) WithHTTPClient(client *http.Client) *UpdateRepoPoolByFriendlyNameParams { + o.SetHTTPClient(client) + return o +} + +// SetHTTPClient adds the HTTPClient to the update repo pool by friendly name params +func (o *UpdateRepoPoolByFriendlyNameParams) SetHTTPClient(client *http.Client) { + o.HTTPClient = client +} + +// WithBody adds the body to the update repo pool by friendly name params +func (o *UpdateRepoPoolByFriendlyNameParams) WithBody(body garm_params.UpdatePoolParams) *UpdateRepoPoolByFriendlyNameParams { + o.SetBody(body) + return o +} + +// SetBody adds the body to the update repo pool by friendly name params +func (o *UpdateRepoPoolByFriendlyNameParams) SetBody(body garm_params.UpdatePoolParams) { + o.Body = body +} + +// WithEndpointName adds the endpointName to the update repo pool by friendly name params +func (o *UpdateRepoPoolByFriendlyNameParams) WithEndpointName(endpointName *string) *UpdateRepoPoolByFriendlyNameParams { + o.SetEndpointName(endpointName) + return o +} + +// SetEndpointName adds the endpointName to the update repo pool by friendly name params +func (o *UpdateRepoPoolByFriendlyNameParams) SetEndpointName(endpointName *string) { + o.EndpointName = endpointName +} + +// WithOwner adds the owner to the update repo pool by friendly name params +func (o *UpdateRepoPoolByFriendlyNameParams) WithOwner(owner string) *UpdateRepoPoolByFriendlyNameParams { + o.SetOwner(owner) + return o +} + +// SetOwner adds the owner to the update repo pool by friendly name params +func (o *UpdateRepoPoolByFriendlyNameParams) SetOwner(owner string) { + o.Owner = owner +} + +// WithPoolID adds the poolID to the update repo pool by friendly name params +func (o *UpdateRepoPoolByFriendlyNameParams) WithPoolID(poolID string) *UpdateRepoPoolByFriendlyNameParams { + o.SetPoolID(poolID) + return o +} + +// SetPoolID adds the poolId to the update repo pool by friendly name params +func (o *UpdateRepoPoolByFriendlyNameParams) SetPoolID(poolID string) { + o.PoolID = poolID +} + +// WithRepo adds the repo to the update repo pool by friendly name params +func (o *UpdateRepoPoolByFriendlyNameParams) WithRepo(repo string) *UpdateRepoPoolByFriendlyNameParams { + o.SetRepo(repo) + return o +} + +// SetRepo adds the repo to the update repo pool by friendly name params +func (o *UpdateRepoPoolByFriendlyNameParams) SetRepo(repo string) { + o.Repo = repo +} + +// WriteToRequest writes these params to a swagger request +func (o *UpdateRepoPoolByFriendlyNameParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error { + + if err := r.SetTimeout(o.timeout); err != nil { + return err + } + var res []error + if err := r.SetBodyParam(o.Body); err != nil { + return err + } + + if o.EndpointName != nil { + + // query param endpointName + var qrEndpointName string + + if o.EndpointName != nil { + qrEndpointName = *o.EndpointName + } + qEndpointName := qrEndpointName + if qEndpointName != "" { + + if err := r.SetQueryParam("endpointName", qEndpointName); err != nil { + return err + } + } + } + + // path param owner + if err := r.SetPathParam("owner", o.Owner); err != nil { + return err + } + + // path param poolID + if err := r.SetPathParam("poolID", o.PoolID); err != nil { + return err + } + + // path param repo + if err := r.SetPathParam("repo", o.Repo); err != nil { + return err + } + + if len(res) > 0 { + return errors.CompositeValidationError(res...) + } + return nil +} diff --git a/client/repositories/update_repo_pool_by_friendly_name_responses.go b/client/repositories/update_repo_pool_by_friendly_name_responses.go new file mode 100644 index 000000000..43d363fd2 --- /dev/null +++ b/client/repositories/update_repo_pool_by_friendly_name_responses.go @@ -0,0 +1,184 @@ +// Code generated by go-swagger; DO NOT EDIT. + +package repositories + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "encoding/json" + "fmt" + "io" + + "github.com/go-openapi/runtime" + "github.com/go-openapi/strfmt" + + apiserver_params "github.com/cloudbase/garm/apiserver/params" + garm_params "github.com/cloudbase/garm/params" +) + +// UpdateRepoPoolByFriendlyNameReader is a Reader for the UpdateRepoPoolByFriendlyName structure. +type UpdateRepoPoolByFriendlyNameReader struct { + formats strfmt.Registry +} + +// ReadResponse reads a server response into the received o. +func (o *UpdateRepoPoolByFriendlyNameReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error) { + switch response.Code() { + case 200: + result := NewUpdateRepoPoolByFriendlyNameOK() + if err := result.readResponse(response, consumer, o.formats); err != nil { + return nil, err + } + return result, nil + default: + result := NewUpdateRepoPoolByFriendlyNameDefault(response.Code()) + if err := result.readResponse(response, consumer, o.formats); err != nil { + return nil, err + } + if response.Code()/100 == 2 { + return result, nil + } + return nil, result + } +} + +// NewUpdateRepoPoolByFriendlyNameOK creates a UpdateRepoPoolByFriendlyNameOK with default headers values +func NewUpdateRepoPoolByFriendlyNameOK() *UpdateRepoPoolByFriendlyNameOK { + return &UpdateRepoPoolByFriendlyNameOK{} +} + +/* +UpdateRepoPoolByFriendlyNameOK describes a response with status code 200, with default header values. + +Pool +*/ +type UpdateRepoPoolByFriendlyNameOK struct { + Payload garm_params.Pool +} + +// IsSuccess returns true when this update repo pool by friendly name o k response has a 2xx status code +func (o *UpdateRepoPoolByFriendlyNameOK) IsSuccess() bool { + return true +} + +// IsRedirect returns true when this update repo pool by friendly name o k response has a 3xx status code +func (o *UpdateRepoPoolByFriendlyNameOK) IsRedirect() bool { + return false +} + +// IsClientError returns true when this update repo pool by friendly name o k response has a 4xx status code +func (o *UpdateRepoPoolByFriendlyNameOK) IsClientError() bool { + return false +} + +// IsServerError returns true when this update repo pool by friendly name o k response has a 5xx status code +func (o *UpdateRepoPoolByFriendlyNameOK) IsServerError() bool { + return false +} + +// IsCode returns true when this update repo pool by friendly name o k response a status code equal to that given +func (o *UpdateRepoPoolByFriendlyNameOK) IsCode(code int) bool { + return code == 200 +} + +// Code gets the status code for the update repo pool by friendly name o k response +func (o *UpdateRepoPoolByFriendlyNameOK) Code() int { + return 200 +} + +func (o *UpdateRepoPoolByFriendlyNameOK) Error() string { + payload, _ := json.Marshal(o.Payload) + return fmt.Sprintf("[PUT /repositories/{owner}/{repo}/pools/{poolID}][%d] updateRepoPoolByFriendlyNameOK %s", 200, payload) +} + +func (o *UpdateRepoPoolByFriendlyNameOK) String() string { + payload, _ := json.Marshal(o.Payload) + return fmt.Sprintf("[PUT /repositories/{owner}/{repo}/pools/{poolID}][%d] updateRepoPoolByFriendlyNameOK %s", 200, payload) +} + +func (o *UpdateRepoPoolByFriendlyNameOK) GetPayload() garm_params.Pool { + return o.Payload +} + +func (o *UpdateRepoPoolByFriendlyNameOK) readResponse(response runtime.ClientResponse, consumer runtime.Consumer, formats strfmt.Registry) error { + + // response payload + if err := consumer.Consume(response.Body(), &o.Payload); err != nil && err != io.EOF { + return err + } + + return nil +} + +// NewUpdateRepoPoolByFriendlyNameDefault creates a UpdateRepoPoolByFriendlyNameDefault with default headers values +func NewUpdateRepoPoolByFriendlyNameDefault(code int) *UpdateRepoPoolByFriendlyNameDefault { + return &UpdateRepoPoolByFriendlyNameDefault{ + _statusCode: code, + } +} + +/* +UpdateRepoPoolByFriendlyNameDefault describes a response with status code -1, with default header values. + +APIErrorResponse +*/ +type UpdateRepoPoolByFriendlyNameDefault struct { + _statusCode int + + Payload apiserver_params.APIErrorResponse +} + +// IsSuccess returns true when this update repo pool by friendly name default response has a 2xx status code +func (o *UpdateRepoPoolByFriendlyNameDefault) IsSuccess() bool { + return o._statusCode/100 == 2 +} + +// IsRedirect returns true when this update repo pool by friendly name default response has a 3xx status code +func (o *UpdateRepoPoolByFriendlyNameDefault) IsRedirect() bool { + return o._statusCode/100 == 3 +} + +// IsClientError returns true when this update repo pool by friendly name default response has a 4xx status code +func (o *UpdateRepoPoolByFriendlyNameDefault) IsClientError() bool { + return o._statusCode/100 == 4 +} + +// IsServerError returns true when this update repo pool by friendly name default response has a 5xx status code +func (o *UpdateRepoPoolByFriendlyNameDefault) IsServerError() bool { + return o._statusCode/100 == 5 +} + +// IsCode returns true when this update repo pool by friendly name default response a status code equal to that given +func (o *UpdateRepoPoolByFriendlyNameDefault) IsCode(code int) bool { + return o._statusCode == code +} + +// Code gets the status code for the update repo pool by friendly name default response +func (o *UpdateRepoPoolByFriendlyNameDefault) Code() int { + return o._statusCode +} + +func (o *UpdateRepoPoolByFriendlyNameDefault) Error() string { + payload, _ := json.Marshal(o.Payload) + return fmt.Sprintf("[PUT /repositories/{owner}/{repo}/pools/{poolID}][%d] UpdateRepoPoolByFriendlyName default %s", o._statusCode, payload) +} + +func (o *UpdateRepoPoolByFriendlyNameDefault) String() string { + payload, _ := json.Marshal(o.Payload) + return fmt.Sprintf("[PUT /repositories/{owner}/{repo}/pools/{poolID}][%d] UpdateRepoPoolByFriendlyName default %s", o._statusCode, payload) +} + +func (o *UpdateRepoPoolByFriendlyNameDefault) GetPayload() apiserver_params.APIErrorResponse { + return o.Payload +} + +func (o *UpdateRepoPoolByFriendlyNameDefault) readResponse(response runtime.ClientResponse, consumer runtime.Consumer, formats strfmt.Registry) error { + + // response payload + if err := consumer.Consume(response.Body(), &o.Payload); err != nil && err != io.EOF { + return err + } + + return nil +} diff --git a/database/sql/repositories.go b/database/sql/repositories.go index 03452df68..9a3c2954f 100644 --- a/database/sql/repositories.go +++ b/database/sql/repositories.go @@ -236,13 +236,32 @@ func (s *sqlDatabase) GetRepositoryByID(ctx context.Context, repoID string) (par func (s *sqlDatabase) getRepo(_ context.Context, owner, name, endpointName string) (Repository, error) { var repo Repository - q := s.conn.Where("name = ? COLLATE NOCASE and owner = ? COLLATE NOCASE and endpoint_name = ? COLLATE NOCASE", name, owner, endpointName). - Preload("Credentials"). + q := s.conn.Where("name = ? COLLATE NOCASE and owner = ? COLLATE NOCASE", name, owner) + + if endpointName != "" { + q = q.Where("endpoint_name = ? COLLATE NOCASE", endpointName) + } + + q = q.Preload("Credentials"). Preload("Credentials.Endpoint"). Preload("GiteaCredentials"). Preload("GiteaCredentials.Endpoint"). - Preload("Endpoint"). - First(&repo) + Preload("Endpoint") + + if endpointName == "" && q.Error == nil { + var cnt int64 + q = q.Model(&Repository{}) + q = q.Count(&cnt) + + if q.Error != nil { + return Repository{}, errors.Wrap(q.Error, "fetching repository from database") + } + if cnt > 1 { + return Repository{}, errors.Wrap(runnerErrors.ErrBadRequest, "multiple repositories with the same name and owner found") + } else if cnt == 0 { + return Repository{}, runnerErrors.ErrNotFound + } + } q = q.First(&repo) diff --git a/database/sql/repositories_test.go b/database/sql/repositories_test.go index f593ddce6..b870ed78f 100644 --- a/database/sql/repositories_test.go +++ b/database/sql/repositories_test.go @@ -360,11 +360,7 @@ func (s *RepoTestSuite) TestGetRepositoryNotFound() { func (s *RepoTestSuite) TestGetRepositoryDBDecryptingErr() { s.Fixtures.SQLMock. - ExpectQuery(regexp.QuoteMeta("SELECT * FROM `repositories` WHERE (name = ? COLLATE NOCASE and owner = ? COLLATE NOCASE and endpoint_name = ? COLLATE NOCASE) AND `repositories`.`deleted_at` IS NULL ORDER BY `repositories`.`id` LIMIT ?")). - WithArgs(s.Fixtures.Repos[0].Name, s.Fixtures.Repos[0].Owner, s.Fixtures.Repos[0].Endpoint.Name, 1). - WillReturnRows(sqlmock.NewRows([]string{"name", "owner"}).AddRow(s.Fixtures.Repos[0].Name, s.Fixtures.Repos[0].Owner)) - s.Fixtures.SQLMock. - ExpectQuery(regexp.QuoteMeta("SELECT * FROM `repositories` WHERE (name = ? COLLATE NOCASE and owner = ? COLLATE NOCASE and endpoint_name = ? COLLATE NOCASE) AND `repositories`.`deleted_at` IS NULL ORDER BY `repositories`.`id`,`repositories`.`id` LIMIT ?")). + ExpectQuery(regexp.QuoteMeta("SELECT * FROM `repositories` WHERE (name = ? COLLATE NOCASE and owner = ? COLLATE NOCASE) AND endpoint_name = ? COLLATE NOCASE AND `repositories`.`deleted_at` IS NULL ORDER BY `repositories`.`id` LIMIT ?")). WithArgs(s.Fixtures.Repos[0].Name, s.Fixtures.Repos[0].Owner, s.Fixtures.Repos[0].Endpoint.Name, 1). WillReturnRows(sqlmock.NewRows([]string{"name", "owner"}).AddRow(s.Fixtures.Repos[0].Name, s.Fixtures.Repos[0].Owner)) diff --git a/runner/common.go b/runner/common.go index 63d4887c8..03e7c3f7b 100644 --- a/runner/common.go +++ b/runner/common.go @@ -29,3 +29,14 @@ func (r *Runner) ResolveForgeCredentialByName(ctx context.Context, credentialsNa } return params.ForgeCredentials{}, runnerErrors.NewBadRequestError("credentials %s not found", credentialsName) } + +func (r *Runner) ResolveRepository(ctx context.Context, owner, repo, endpointName string) (params.Repository, error) { + repoObj, err := r.store.GetRepository(ctx, owner, repo, endpointName) + if err != nil { + if errors.Is(err, runnerErrors.ErrNotFound) { + return params.Repository{}, runnerErrors.NewNotFoundError("repository %s/%s (%s) not found", owner, repo, endpointName) + } + return params.Repository{}, errors.Wrapf(err, "fetching repository %s/%s (%s)", owner, repo, endpointName) + } + return repoObj, nil +} diff --git a/test/integration/client_utils.go b/test/integration/client_utils.go index e423c107b..1f68300ba 100644 --- a/test/integration/client_utils.go +++ b/test/integration/client_utils.go @@ -214,6 +214,16 @@ func updateRepo(apiCli *client.GarmAPI, apiAuthToken runtime.ClientAuthInfoWrite return &updateRepoResponse.Payload, nil } +func updateRepoByFriendlyName(apiCli *client.GarmAPI, apiAuthToken runtime.ClientAuthInfoWriter, owner, repo string, repoParams params.UpdateEntityParams) (*params.Repository, error) { + updateRepoResponse, err := apiCli.Repositories.UpdateRepoByFriendlyName( + clientRepositories.NewUpdateRepoByFriendlyNameParams().WithOwner(owner).WithRepo(repo).WithBody(repoParams), + apiAuthToken) + if err != nil { + return nil, err + } + return &updateRepoResponse.Payload, nil +} + func getRepo(apiCli *client.GarmAPI, apiAuthToken runtime.ClientAuthInfoWriter, repoID string) (*params.Repository, error) { getRepoResponse, err := apiCli.Repositories.GetRepo( clientRepositories.NewGetRepoParams().WithRepoID(repoID), @@ -224,6 +234,16 @@ func getRepo(apiCli *client.GarmAPI, apiAuthToken runtime.ClientAuthInfoWriter, return &getRepoResponse.Payload, nil } +func getRepoByFriendlyName(apiCli *client.GarmAPI, apiAuthToken runtime.ClientAuthInfoWriter, owner, repo string) (*params.Repository, error) { + getRepoResponse, err := apiCli.Repositories.GetRepoByFriendlyName( + clientRepositories.NewGetRepoByFriendlyNameParams().WithOwner(owner).WithRepo(repo), + apiAuthToken) + if err != nil { + return nil, err + } + return &getRepoResponse.Payload, nil +} + func installRepoWebhook(apiCli *client.GarmAPI, apiAuthToken runtime.ClientAuthInfoWriter, repoID string, webhookParams params.InstallWebhookParams) (*params.HookInfo, error) { installRepoWebhookResponse, err := apiCli.Repositories.InstallRepoWebhook( clientRepositories.NewInstallRepoWebhookParams().WithRepoID(repoID).WithBody(webhookParams), @@ -234,6 +254,16 @@ func installRepoWebhook(apiCli *client.GarmAPI, apiAuthToken runtime.ClientAuthI return &installRepoWebhookResponse.Payload, nil } +func installRepoWebhookByFriendlyName(apiCli *client.GarmAPI, apiAuthToken runtime.ClientAuthInfoWriter, owner, repo string, webhookParams params.InstallWebhookParams) (*params.HookInfo, error) { + installRepoWebhookResponse, err := apiCli.Repositories.InstallRepoWebhookByFriendlyName( + clientRepositories.NewInstallRepoWebhookByFriendlyNameParams().WithOwner(owner).WithRepo(repo).WithBody(webhookParams), + apiAuthToken) + if err != nil { + return nil, err + } + return &installRepoWebhookResponse.Payload, nil +} + func getRepoWebhook(apiCli *client.GarmAPI, apiAuthToken runtime.ClientAuthInfoWriter, repoID string) (*params.HookInfo, error) { getRepoWebhookResponse, err := apiCli.Repositories.GetRepoWebhookInfo( clientRepositories.NewGetRepoWebhookInfoParams().WithRepoID(repoID), @@ -244,12 +274,28 @@ func getRepoWebhook(apiCli *client.GarmAPI, apiAuthToken runtime.ClientAuthInfoW return &getRepoWebhookResponse.Payload, nil } +func getRepoWebhookByFriendlyName(apiCli *client.GarmAPI, apiAuthToken runtime.ClientAuthInfoWriter, owner, repo string) (*params.HookInfo, error) { + getRepoWebhookResponse, err := apiCli.Repositories.GetRepoWebhookInfoByFriendlyName( + clientRepositories.NewGetRepoWebhookInfoByFriendlyNameParams().WithOwner(owner).WithRepo(repo), + apiAuthToken) + if err != nil { + return nil, err + } + return &getRepoWebhookResponse.Payload, nil +} + func uninstallRepoWebhook(apiCli *client.GarmAPI, apiAuthToken runtime.ClientAuthInfoWriter, repoID string) error { return apiCli.Repositories.UninstallRepoWebhook( clientRepositories.NewUninstallRepoWebhookParams().WithRepoID(repoID), apiAuthToken) } +func uninstallRepoWebhookByFriendlyName(apiCli *client.GarmAPI, apiAuthToken runtime.ClientAuthInfoWriter, owner, repo string) error { + return apiCli.Repositories.UninstallRepoWebhookByFriendlyName( + clientRepositories.NewUninstallRepoWebhookByFriendlyNameParams().WithOwner(owner).WithRepo(repo), + apiAuthToken) +} + func createRepoPool(apiCli *client.GarmAPI, apiAuthToken runtime.ClientAuthInfoWriter, repoID string, poolParams params.CreatePoolParams) (*params.Pool, error) { createRepoPoolResponse, err := apiCli.Repositories.CreateRepoPool( clientRepositories.NewCreateRepoPoolParams().WithRepoID(repoID).WithBody(poolParams), @@ -260,6 +306,16 @@ func createRepoPool(apiCli *client.GarmAPI, apiAuthToken runtime.ClientAuthInfoW return &createRepoPoolResponse.Payload, nil } +func createRepoPoolByFriendlyName(apiCli *client.GarmAPI, apiAuthToken runtime.ClientAuthInfoWriter, owner, repo string, poolParams params.CreatePoolParams) (*params.Pool, error) { + createRepoPoolResponse, err := apiCli.Repositories.CreateRepoPoolByFriendlyName( + clientRepositories.NewCreateRepoPoolByFriendlyNameParams().WithOwner(owner).WithRepo(repo).WithBody(poolParams), + apiAuthToken) + if err != nil { + return nil, err + } + return &createRepoPoolResponse.Payload, nil +} + func listRepoPools(apiCli *client.GarmAPI, apiAuthToken runtime.ClientAuthInfoWriter, repoID string) (params.Pools, error) { listRepoPoolsResponse, err := apiCli.Repositories.ListRepoPools( clientRepositories.NewListRepoPoolsParams().WithRepoID(repoID), @@ -270,6 +326,16 @@ func listRepoPools(apiCli *client.GarmAPI, apiAuthToken runtime.ClientAuthInfoWr return listRepoPoolsResponse.Payload, nil } +func listRepoPoolsByFriendlyName(apiCli *client.GarmAPI, apiAuthToken runtime.ClientAuthInfoWriter, owner, repo string) (params.Pools, error) { + listRepoPoolsResponse, err := apiCli.Repositories.ListRepoPoolsByFriendlyName( + clientRepositories.NewListRepoPoolsByFriendlyNameParams().WithOwner(owner).WithRepo(repo), + apiAuthToken) + if err != nil { + return nil, err + } + return listRepoPoolsResponse.Payload, nil +} + func getRepoPool(apiCli *client.GarmAPI, apiAuthToken runtime.ClientAuthInfoWriter, repoID, poolID string) (*params.Pool, error) { getRepoPoolResponse, err := apiCli.Repositories.GetRepoPool( clientRepositories.NewGetRepoPoolParams().WithRepoID(repoID).WithPoolID(poolID), @@ -280,6 +346,16 @@ func getRepoPool(apiCli *client.GarmAPI, apiAuthToken runtime.ClientAuthInfoWrit return &getRepoPoolResponse.Payload, nil } +func getRepoPoolByFriendlyName(apiCli *client.GarmAPI, apiAuthToken runtime.ClientAuthInfoWriter, owner, repo, poolID string) (*params.Pool, error) { + getRepoPoolResponse, err := apiCli.Repositories.GetRepoPoolByFriendlyName( + clientRepositories.NewGetRepoPoolByFriendlyNameParams().WithOwner(owner).WithRepo(repo).WithPoolID(poolID), + apiAuthToken) + if err != nil { + return nil, err + } + return &getRepoPoolResponse.Payload, nil +} + func updateRepoPool(apiCli *client.GarmAPI, apiAuthToken runtime.ClientAuthInfoWriter, repoID, poolID string, poolParams params.UpdatePoolParams) (*params.Pool, error) { updateRepoPoolResponse, err := apiCli.Repositories.UpdateRepoPool( clientRepositories.NewUpdateRepoPoolParams().WithRepoID(repoID).WithPoolID(poolID).WithBody(poolParams), @@ -290,6 +366,16 @@ func updateRepoPool(apiCli *client.GarmAPI, apiAuthToken runtime.ClientAuthInfoW return &updateRepoPoolResponse.Payload, nil } +func updateRepoPoolByFriendlyName(apiCli *client.GarmAPI, apiAuthToken runtime.ClientAuthInfoWriter, owner, repo, poolID string, poolParams params.UpdatePoolParams) (*params.Pool, error) { + updateRepoPoolResponse, err := apiCli.Repositories.UpdateRepoPoolByFriendlyName( + clientRepositories.NewUpdateRepoPoolByFriendlyNameParams().WithOwner(owner).WithRepo(repo).WithPoolID(poolID).WithBody(poolParams), + apiAuthToken) + if err != nil { + return nil, err + } + return &updateRepoPoolResponse.Payload, nil +} + func listRepoInstances(apiCli *client.GarmAPI, apiAuthToken runtime.ClientAuthInfoWriter, repoID string) (params.Instances, error) { listRepoInstancesResponse, err := apiCli.Repositories.ListRepoInstances( clientRepositories.NewListRepoInstancesParams().WithRepoID(repoID), @@ -300,6 +386,16 @@ func listRepoInstances(apiCli *client.GarmAPI, apiAuthToken runtime.ClientAuthIn return listRepoInstancesResponse.Payload, nil } +func listRepoInstancesByFriendlyName(apiCli *client.GarmAPI, apiAuthToken runtime.ClientAuthInfoWriter, owner, repo string) (params.Instances, error) { + listRepoInstancesResponse, err := apiCli.Repositories.ListRepoInstancesByFriendlyName( + clientRepositories.NewListRepoInstancesByFriendlyNameParams().WithOwner(owner).WithRepo(repo), + apiAuthToken) + if err != nil { + return nil, err + } + return listRepoInstancesResponse.Payload, nil +} + func deleteRepo(apiCli *client.GarmAPI, apiAuthToken runtime.ClientAuthInfoWriter, repoID string) error { return apiCli.Repositories.DeleteRepo( clientRepositories.NewDeleteRepoParams().WithRepoID(repoID), @@ -312,6 +408,12 @@ func deleteRepoPool(apiCli *client.GarmAPI, apiAuthToken runtime.ClientAuthInfoW apiAuthToken) } +func deleteRepoPoolByFriendlyName(apiCli *client.GarmAPI, apiAuthToken runtime.ClientAuthInfoWriter, owner, repo, poolID string) error { + return apiCli.Repositories.DeleteRepoPoolByFriendlyName( + clientRepositories.NewDeleteRepoPoolByFriendlyNameParams().WithOwner(owner).WithRepo(repo).WithPoolID(poolID), + apiAuthToken) +} + // //////////////// // Organizations // // //////////////// diff --git a/test/integration/repositories_test.go b/test/integration/repositories_test.go index 43a5d8ec6..0fc4cd16f 100644 --- a/test/integration/repositories_test.go +++ b/test/integration/repositories_test.go @@ -94,6 +94,54 @@ func (suite *GarmSuite) TestRepositories() { suite.WaitRepoRunningIdleInstances(suite.repo.ID, 6*time.Minute) } +func (suite *GarmSuite) TestRepositoriesByName() { + t := suite.T() + + t.Logf("Update repo with repo %s/%s", suite.repo.Owner, suite.repo.Name) + updateParams := params.UpdateEntityParams{ + CredentialsName: fmt.Sprintf("%s-clone", suite.credentialsName), + } + repo, err := updateRepoByFriendlyName(suite.cli, suite.authToken, suite.repo.Owner, suite.repo.Name, updateParams) + suite.NoError(err, "error updating repository") + suite.Equal(fmt.Sprintf("%s-clone", suite.credentialsName), repo.CredentialsName, "credentials name mismatch") + suite.repo = repo + + hookRepoInfo := suite.InstallRepoWebhookByFriendlyName(suite.repo.Owner, suite.repo.Name) + suite.ValidateRepoWebhookInstalled(suite.ghToken, hookRepoInfo.URL, orgName, repoName) + suite.UninstallRepoWebhookByFriendlyName(suite.repo.Owner, suite.repo.Name) + suite.ValidateRepoWebhookUninstalled(suite.ghToken, hookRepoInfo.URL, orgName, repoName) + + suite.InstallRepoWebhookByFriendlyName(suite.repo.Owner, suite.repo.Name) + suite.ValidateRepoWebhookInstalled(suite.ghToken, hookRepoInfo.URL, orgName, repoName) + + repoPoolParams := params.CreatePoolParams{ + MaxRunners: 2, + MinIdleRunners: 0, + Flavor: "default", + Image: "ubuntu:24.04", + OSType: commonParams.Linux, + OSArch: commonParams.Amd64, + ProviderName: "lxd_local", + Tags: []string{"repo-runner"}, + Enabled: true, + } + + repoPool := suite.CreateRepoPoolByFriendlyName(suite.repo.Owner, suite.repo.Name, repoPoolParams) + suite.Equal(repoPool.MaxRunners, repoPoolParams.MaxRunners, "max runners mismatch") + suite.Equal(repoPool.MinIdleRunners, repoPoolParams.MinIdleRunners, "min idle runners mismatch") + + repoPoolGet := suite.GetRepoPoolByFriendlyName(suite.repo.Owner, suite.repo.Name, repoPool.ID) + suite.Equal(*repoPool, *repoPoolGet, "pool get mismatch") + + suite.DeleteRepoPoolByFriendlyName(suite.repo.Owner, suite.repo.Name, repoPool.ID) + + repoPool = suite.CreateRepoPoolByFriendlyName(suite.repo.Owner, suite.repo.Name, repoPoolParams) + updatedRepoPool := suite.UpdateRepoPoolByFriendlyName(suite.repo.Owner, suite.repo.Name, repoPool.ID, repoPoolParams.MaxRunners, 1) + suite.NotEqual(updatedRepoPool.MinIdleRunners, repoPool.MinIdleRunners, "min idle runners mismatch") + + suite.WaitRepoRunningIdleInstances(suite.repo.ID, 6*time.Minute) +} + func (suite *GarmSuite) InstallRepoWebhook(id string) *params.HookInfo { t := suite.T() t.Logf("Install repo webhook with repo_id %s", id) @@ -108,6 +156,20 @@ func (suite *GarmSuite) InstallRepoWebhook(id string) *params.HookInfo { return webhookInfo } +func (suite *GarmSuite) InstallRepoWebhookByFriendlyName(owner, name string) *params.HookInfo { + t := suite.T() + t.Logf("Install repo webhook with repo %s/%s", owner, name) + webhookParams := params.InstallWebhookParams{ + WebhookEndpointType: params.WebhookEndpointDirect, + } + _, err := installRepoWebhookByFriendlyName(suite.cli, suite.authToken, owner, name, webhookParams) + suite.NoError(err, "error installing repository webhook") + + webhookInfo, err := getRepoWebhookByFriendlyName(suite.cli, suite.authToken, owner, name) + suite.NoError(err, "error getting repository webhook") + return webhookInfo +} + func (suite *GarmSuite) ValidateRepoWebhookInstalled(ghToken, url, orgName, repoName string) { hook, err := getGhRepoWebhook(url, ghToken, orgName, repoName) suite.NoError(err, "error getting github webhook") @@ -144,6 +206,13 @@ func (suite *GarmSuite) UninstallRepoWebhook(id string) { suite.NoError(err, "error uninstalling repository webhook") } +func (suite *GarmSuite) UninstallRepoWebhookByFriendlyName(owner, repo string) { + t := suite.T() + t.Logf("Uninstall repo webhook with repo %s/%s", owner, repo) + err := uninstallRepoWebhookByFriendlyName(suite.cli, suite.authToken, owner, repo) + suite.NoError(err, "error uninstalling repository webhook") +} + func (suite *GarmSuite) ValidateRepoWebhookUninstalled(ghToken, url, orgName, repoName string) { hook, err := getGhRepoWebhook(url, ghToken, orgName, repoName) suite.NoError(err, "error getting github webhook") @@ -158,6 +227,14 @@ func (suite *GarmSuite) CreateRepoPool(repoID string, poolParams params.CreatePo return pool } +func (suite *GarmSuite) CreateRepoPoolByFriendlyName(owner, repo string, poolParams params.CreatePoolParams) *params.Pool { + t := suite.T() + t.Logf("Create repo pool with repo %s/%s and pool_params %+v", owner, repo, poolParams) + pool, err := createRepoPoolByFriendlyName(suite.cli, suite.authToken, owner, repo, poolParams) + suite.NoError(err, "error creating repository pool") + return pool +} + func (suite *GarmSuite) GetRepoPool(repoID, repoPoolID string) *params.Pool { t := suite.T() t.Logf("Get repo pool repo_id %s and pool_id %s", repoID, repoPoolID) @@ -166,6 +243,14 @@ func (suite *GarmSuite) GetRepoPool(repoID, repoPoolID string) *params.Pool { return pool } +func (suite *GarmSuite) GetRepoPoolByFriendlyName(owner, repo, repoPoolID string) *params.Pool { + t := suite.T() + t.Logf("Get repo pool repo %s/%s and pool_id %s", owner, repo, repoPoolID) + pool, err := getRepoPoolByFriendlyName(suite.cli, suite.authToken, owner, repo, repoPoolID) + suite.NoError(err, "error getting repository pool") + return pool +} + func (suite *GarmSuite) DeleteRepoPool(repoID, repoPoolID string) { t := suite.T() t.Logf("Delete repo pool with repo_id %s and pool_id %s", repoID, repoPoolID) @@ -173,6 +258,13 @@ func (suite *GarmSuite) DeleteRepoPool(repoID, repoPoolID string) { suite.NoError(err, "error deleting repository pool") } +func (suite *GarmSuite) DeleteRepoPoolByFriendlyName(owner, repo, repoPoolID string) { + t := suite.T() + t.Logf("Delete repo pool with repo %s/%s and pool_id %s", owner, repo, repoPoolID) + err := deleteRepoPoolByFriendlyName(suite.cli, suite.authToken, owner, repo, repoPoolID) + suite.NoError(err, "error deleting repository pool") +} + func (suite *GarmSuite) UpdateRepoPool(repoID, repoPoolID string, maxRunners, minIdleRunners uint) *params.Pool { t := suite.T() t.Logf("Update repo pool with repo_id %s and pool_id %s", repoID, repoPoolID) @@ -185,6 +277,18 @@ func (suite *GarmSuite) UpdateRepoPool(repoID, repoPoolID string, maxRunners, mi return pool } +func (suite *GarmSuite) UpdateRepoPoolByFriendlyName(owner, repo, repoPoolID string, maxRunners, minIdleRunners uint) *params.Pool { + t := suite.T() + t.Logf("Update repo pool with repo %s/%s and pool_id %s", owner, repo, repoPoolID) + poolParams := params.UpdatePoolParams{ + MinIdleRunners: &minIdleRunners, + MaxRunners: &maxRunners, + } + pool, err := updateRepoPoolByFriendlyName(suite.cli, suite.authToken, owner, repo, repoPoolID, poolParams) + suite.NoError(err, "error updating repository pool") + return pool +} + func (suite *GarmSuite) WaitRepoRunningIdleInstances(repoID string, timeout time.Duration) { t := suite.T() repoPools, err := listRepoPools(suite.cli, suite.authToken, repoID) @@ -198,6 +302,19 @@ func (suite *GarmSuite) WaitRepoRunningIdleInstances(repoID string, timeout time } } +func (suite *GarmSuite) WaitRepoRunningIdleInstancesByFriendlyName(owner, repo string, timeout time.Duration) { + t := suite.T() + repoPools, err := listRepoPoolsByFriendlyName(suite.cli, suite.authToken, owner, repo) + suite.NoError(err, "error listing repo pools") + for _, pool := range repoPools { + err := suite.WaitPoolInstances(pool.ID, commonParams.InstanceRunning, params.RunnerIdle, timeout) + if err != nil { + suite.dumpRepoInstancesDetailsByFriendlyName(owner, repo) + t.Errorf("error waiting for pool instances to be running idle: %v", err) + } + } +} + func (suite *GarmSuite) dumpRepoInstancesDetails(repoID string) { t := suite.T() // print repo details @@ -219,3 +336,25 @@ func (suite *GarmSuite) dumpRepoInstancesDetails(repoID string) { suite.NoError(err, "error printing instance") } } + +func (suite *GarmSuite) dumpRepoInstancesDetailsByFriendlyName(owner, repo string) { + t := suite.T() + // print repo details + t.Logf("Dumping repo details for repo %s/%s", owner, repo) + repoObj, err := getRepoByFriendlyName(suite.cli, suite.authToken, owner, repo) + suite.NoError(err, "error getting repo") + err = printJSONResponse(repoObj) + suite.NoError(err, "error printing repo") + + // print repo instances details + t.Logf("Dumping repo instances details for repo %s/%s", owner, repo) + instances, err := listRepoInstancesByFriendlyName(suite.cli, suite.authToken, owner, repo) + suite.NoError(err, "error listing repo instances") + for _, instance := range instances { + instance, err := getInstance(suite.cli, suite.authToken, instance.Name) + suite.NoError(err, "error getting instance") + t.Logf("Instance info for instance %s", instance.Name) + err = printJSONResponse(instance) + suite.NoError(err, "error printing instance") + } +}