mirror of https://github.com/harness/drone.git
4304 lines
158 KiB
Go
4304 lines
158 KiB
Go
// Package artifact provides primitives to interact with the openapi HTTP API.
|
|
//
|
|
// Code generated by github.com/deepmap/oapi-codegen/v2 version v2.1.0 DO NOT EDIT.
|
|
package artifact
|
|
|
|
import (
|
|
"bytes"
|
|
"compress/gzip"
|
|
"context"
|
|
"encoding/base64"
|
|
"encoding/json"
|
|
"fmt"
|
|
"net/http"
|
|
"net/url"
|
|
"path"
|
|
"strings"
|
|
|
|
"github.com/getkin/kin-openapi/openapi3"
|
|
"github.com/go-chi/chi/v5"
|
|
"github.com/oapi-codegen/runtime"
|
|
strictnethttp "github.com/oapi-codegen/runtime/strictmiddleware/nethttp"
|
|
)
|
|
|
|
// ServerInterface represents all server handlers.
|
|
type ServerInterface interface {
|
|
// Create Registry.
|
|
// (POST /registry)
|
|
CreateRegistry(w http.ResponseWriter, r *http.Request, params CreateRegistryParams)
|
|
// Delete a Registry
|
|
// (DELETE /registry/{registry_ref})
|
|
DeleteRegistry(w http.ResponseWriter, r *http.Request, registryRef RegistryRefPathParam)
|
|
// Returns Registry Details
|
|
// (GET /registry/{registry_ref})
|
|
GetRegistry(w http.ResponseWriter, r *http.Request, registryRef RegistryRefPathParam)
|
|
// Updates a Registry
|
|
// (PUT /registry/{registry_ref})
|
|
ModifyRegistry(w http.ResponseWriter, r *http.Request, registryRef RegistryRefPathParam)
|
|
// List Artifact Labels
|
|
// (GET /registry/{registry_ref}/artifact/labels)
|
|
ListArtifactLabels(w http.ResponseWriter, r *http.Request, registryRef RegistryRefPathParam, params ListArtifactLabelsParams)
|
|
// Get Artifact Stats
|
|
// (GET /registry/{registry_ref}/artifact/stats)
|
|
GetArtifactStatsForRegistry(w http.ResponseWriter, r *http.Request, registryRef RegistryRefPathParam, params GetArtifactStatsForRegistryParams)
|
|
// Delete Artifact
|
|
// (DELETE /registry/{registry_ref}/artifact/{artifact})
|
|
DeleteArtifact(w http.ResponseWriter, r *http.Request, registryRef RegistryRefPathParam, artifact ArtifactPathParam)
|
|
// Update Artifact Labels
|
|
// (PUT /registry/{registry_ref}/artifact/{artifact}/labels)
|
|
UpdateArtifactLabels(w http.ResponseWriter, r *http.Request, registryRef RegistryRefPathParam, artifact ArtifactPathParam)
|
|
// Get Artifact Stats
|
|
// (GET /registry/{registry_ref}/artifact/{artifact}/stats)
|
|
GetArtifactStats(w http.ResponseWriter, r *http.Request, registryRef RegistryRefPathParam, artifact ArtifactPathParam, params GetArtifactStatsParams)
|
|
// Get Artifact Summary
|
|
// (GET /registry/{registry_ref}/artifact/{artifact}/summary)
|
|
GetArtifactSummary(w http.ResponseWriter, r *http.Request, registryRef RegistryRefPathParam, artifact ArtifactPathParam)
|
|
// Delete an Artifact Version
|
|
// (DELETE /registry/{registry_ref}/artifact/{artifact}/version/{version})
|
|
DeleteArtifactVersion(w http.ResponseWriter, r *http.Request, registryRef RegistryRefPathParam, artifact ArtifactPathParam, version VersionPathParam)
|
|
// Describe Docker Artifact Detail
|
|
// (GET /registry/{registry_ref}/artifact/{artifact}/version/{version}/docker/details)
|
|
GetDockerArtifactDetails(w http.ResponseWriter, r *http.Request, registryRef RegistryRefPathParam, artifact ArtifactPathParam, version VersionPathParam, params GetDockerArtifactDetailsParams)
|
|
// Describe Docker Artifact Layers
|
|
// (GET /registry/{registry_ref}/artifact/{artifact}/version/{version}/docker/layers)
|
|
GetDockerArtifactLayers(w http.ResponseWriter, r *http.Request, registryRef RegistryRefPathParam, artifact ArtifactPathParam, version VersionPathParam, params GetDockerArtifactLayersParams)
|
|
// Describe Docker Artifact Manifest
|
|
// (GET /registry/{registry_ref}/artifact/{artifact}/version/{version}/docker/manifest)
|
|
GetDockerArtifactManifest(w http.ResponseWriter, r *http.Request, registryRef RegistryRefPathParam, artifact ArtifactPathParam, version VersionPathParam, params GetDockerArtifactManifestParams)
|
|
// Describe Docker Artifact Manifests
|
|
// (GET /registry/{registry_ref}/artifact/{artifact}/version/{version}/docker/manifests)
|
|
GetDockerArtifactManifests(w http.ResponseWriter, r *http.Request, registryRef RegistryRefPathParam, artifact ArtifactPathParam, version VersionPathParam)
|
|
// Describe Helm Artifact Detail
|
|
// (GET /registry/{registry_ref}/artifact/{artifact}/version/{version}/helm/details)
|
|
GetHelmArtifactDetails(w http.ResponseWriter, r *http.Request, registryRef RegistryRefPathParam, artifact ArtifactPathParam, version VersionPathParam)
|
|
// Describe Helm Artifact Manifest
|
|
// (GET /registry/{registry_ref}/artifact/{artifact}/version/{version}/helm/manifest)
|
|
GetHelmArtifactManifest(w http.ResponseWriter, r *http.Request, registryRef RegistryRefPathParam, artifact ArtifactPathParam, version VersionPathParam)
|
|
// Get Artifact Version Summary
|
|
// (GET /registry/{registry_ref}/artifact/{artifact}/version/{version}/summary)
|
|
GetArtifactVersionSummary(w http.ResponseWriter, r *http.Request, registryRef RegistryRefPathParam, artifact ArtifactPathParam, version VersionPathParam)
|
|
// List Artifact Versions
|
|
// (GET /registry/{registry_ref}/artifact/{artifact}/versions)
|
|
GetAllArtifactVersions(w http.ResponseWriter, r *http.Request, registryRef RegistryRefPathParam, artifact ArtifactPathParam, params GetAllArtifactVersionsParams)
|
|
// List Artifacts for Registry
|
|
// (GET /registry/{registry_ref}/artifacts)
|
|
GetAllArtifactsByRegistry(w http.ResponseWriter, r *http.Request, registryRef RegistryRefPathParam, params GetAllArtifactsByRegistryParams)
|
|
// Returns CLI Client Setup Details
|
|
// (GET /registry/{registry_ref}/client-setup-details)
|
|
GetClientSetupDetails(w http.ResponseWriter, r *http.Request, registryRef RegistryRefPathParam, params GetClientSetupDetailsParams)
|
|
// Get Artifact Stats
|
|
// (GET /spaces/{space_ref}/artifact/stats)
|
|
GetArtifactStatsForSpace(w http.ResponseWriter, r *http.Request, spaceRef SpaceRefPathParam, params GetArtifactStatsForSpaceParams)
|
|
// List Artifacts
|
|
// (GET /spaces/{space_ref}/artifacts)
|
|
GetAllArtifacts(w http.ResponseWriter, r *http.Request, spaceRef SpaceRefPathParam, params GetAllArtifactsParams)
|
|
// List Registries
|
|
// (GET /spaces/{space_ref}/registries)
|
|
GetAllRegistries(w http.ResponseWriter, r *http.Request, spaceRef SpaceRefPathParam, params GetAllRegistriesParams)
|
|
}
|
|
|
|
// Unimplemented server implementation that returns http.StatusNotImplemented for each endpoint.
|
|
|
|
type Unimplemented struct{}
|
|
|
|
// Create Registry.
|
|
// (POST /registry)
|
|
func (_ Unimplemented) CreateRegistry(w http.ResponseWriter, r *http.Request, params CreateRegistryParams) {
|
|
w.WriteHeader(http.StatusNotImplemented)
|
|
}
|
|
|
|
// Delete a Registry
|
|
// (DELETE /registry/{registry_ref})
|
|
func (_ Unimplemented) DeleteRegistry(w http.ResponseWriter, r *http.Request, registryRef RegistryRefPathParam) {
|
|
w.WriteHeader(http.StatusNotImplemented)
|
|
}
|
|
|
|
// Returns Registry Details
|
|
// (GET /registry/{registry_ref})
|
|
func (_ Unimplemented) GetRegistry(w http.ResponseWriter, r *http.Request, registryRef RegistryRefPathParam) {
|
|
w.WriteHeader(http.StatusNotImplemented)
|
|
}
|
|
|
|
// Updates a Registry
|
|
// (PUT /registry/{registry_ref})
|
|
func (_ Unimplemented) ModifyRegistry(w http.ResponseWriter, r *http.Request, registryRef RegistryRefPathParam) {
|
|
w.WriteHeader(http.StatusNotImplemented)
|
|
}
|
|
|
|
// List Artifact Labels
|
|
// (GET /registry/{registry_ref}/artifact/labels)
|
|
func (_ Unimplemented) ListArtifactLabels(w http.ResponseWriter, r *http.Request, registryRef RegistryRefPathParam, params ListArtifactLabelsParams) {
|
|
w.WriteHeader(http.StatusNotImplemented)
|
|
}
|
|
|
|
// Get Artifact Stats
|
|
// (GET /registry/{registry_ref}/artifact/stats)
|
|
func (_ Unimplemented) GetArtifactStatsForRegistry(w http.ResponseWriter, r *http.Request, registryRef RegistryRefPathParam, params GetArtifactStatsForRegistryParams) {
|
|
w.WriteHeader(http.StatusNotImplemented)
|
|
}
|
|
|
|
// Delete Artifact
|
|
// (DELETE /registry/{registry_ref}/artifact/{artifact})
|
|
func (_ Unimplemented) DeleteArtifact(w http.ResponseWriter, r *http.Request, registryRef RegistryRefPathParam, artifact ArtifactPathParam) {
|
|
w.WriteHeader(http.StatusNotImplemented)
|
|
}
|
|
|
|
// Update Artifact Labels
|
|
// (PUT /registry/{registry_ref}/artifact/{artifact}/labels)
|
|
func (_ Unimplemented) UpdateArtifactLabels(w http.ResponseWriter, r *http.Request, registryRef RegistryRefPathParam, artifact ArtifactPathParam) {
|
|
w.WriteHeader(http.StatusNotImplemented)
|
|
}
|
|
|
|
// Get Artifact Stats
|
|
// (GET /registry/{registry_ref}/artifact/{artifact}/stats)
|
|
func (_ Unimplemented) GetArtifactStats(w http.ResponseWriter, r *http.Request, registryRef RegistryRefPathParam, artifact ArtifactPathParam, params GetArtifactStatsParams) {
|
|
w.WriteHeader(http.StatusNotImplemented)
|
|
}
|
|
|
|
// Get Artifact Summary
|
|
// (GET /registry/{registry_ref}/artifact/{artifact}/summary)
|
|
func (_ Unimplemented) GetArtifactSummary(w http.ResponseWriter, r *http.Request, registryRef RegistryRefPathParam, artifact ArtifactPathParam) {
|
|
w.WriteHeader(http.StatusNotImplemented)
|
|
}
|
|
|
|
// Delete an Artifact Version
|
|
// (DELETE /registry/{registry_ref}/artifact/{artifact}/version/{version})
|
|
func (_ Unimplemented) DeleteArtifactVersion(w http.ResponseWriter, r *http.Request, registryRef RegistryRefPathParam, artifact ArtifactPathParam, version VersionPathParam) {
|
|
w.WriteHeader(http.StatusNotImplemented)
|
|
}
|
|
|
|
// Describe Docker Artifact Detail
|
|
// (GET /registry/{registry_ref}/artifact/{artifact}/version/{version}/docker/details)
|
|
func (_ Unimplemented) GetDockerArtifactDetails(w http.ResponseWriter, r *http.Request, registryRef RegistryRefPathParam, artifact ArtifactPathParam, version VersionPathParam, params GetDockerArtifactDetailsParams) {
|
|
w.WriteHeader(http.StatusNotImplemented)
|
|
}
|
|
|
|
// Describe Docker Artifact Layers
|
|
// (GET /registry/{registry_ref}/artifact/{artifact}/version/{version}/docker/layers)
|
|
func (_ Unimplemented) GetDockerArtifactLayers(w http.ResponseWriter, r *http.Request, registryRef RegistryRefPathParam, artifact ArtifactPathParam, version VersionPathParam, params GetDockerArtifactLayersParams) {
|
|
w.WriteHeader(http.StatusNotImplemented)
|
|
}
|
|
|
|
// Describe Docker Artifact Manifest
|
|
// (GET /registry/{registry_ref}/artifact/{artifact}/version/{version}/docker/manifest)
|
|
func (_ Unimplemented) GetDockerArtifactManifest(w http.ResponseWriter, r *http.Request, registryRef RegistryRefPathParam, artifact ArtifactPathParam, version VersionPathParam, params GetDockerArtifactManifestParams) {
|
|
w.WriteHeader(http.StatusNotImplemented)
|
|
}
|
|
|
|
// Describe Docker Artifact Manifests
|
|
// (GET /registry/{registry_ref}/artifact/{artifact}/version/{version}/docker/manifests)
|
|
func (_ Unimplemented) GetDockerArtifactManifests(w http.ResponseWriter, r *http.Request, registryRef RegistryRefPathParam, artifact ArtifactPathParam, version VersionPathParam) {
|
|
w.WriteHeader(http.StatusNotImplemented)
|
|
}
|
|
|
|
// Describe Helm Artifact Detail
|
|
// (GET /registry/{registry_ref}/artifact/{artifact}/version/{version}/helm/details)
|
|
func (_ Unimplemented) GetHelmArtifactDetails(w http.ResponseWriter, r *http.Request, registryRef RegistryRefPathParam, artifact ArtifactPathParam, version VersionPathParam) {
|
|
w.WriteHeader(http.StatusNotImplemented)
|
|
}
|
|
|
|
// Describe Helm Artifact Manifest
|
|
// (GET /registry/{registry_ref}/artifact/{artifact}/version/{version}/helm/manifest)
|
|
func (_ Unimplemented) GetHelmArtifactManifest(w http.ResponseWriter, r *http.Request, registryRef RegistryRefPathParam, artifact ArtifactPathParam, version VersionPathParam) {
|
|
w.WriteHeader(http.StatusNotImplemented)
|
|
}
|
|
|
|
// Get Artifact Version Summary
|
|
// (GET /registry/{registry_ref}/artifact/{artifact}/version/{version}/summary)
|
|
func (_ Unimplemented) GetArtifactVersionSummary(w http.ResponseWriter, r *http.Request, registryRef RegistryRefPathParam, artifact ArtifactPathParam, version VersionPathParam) {
|
|
w.WriteHeader(http.StatusNotImplemented)
|
|
}
|
|
|
|
// List Artifact Versions
|
|
// (GET /registry/{registry_ref}/artifact/{artifact}/versions)
|
|
func (_ Unimplemented) GetAllArtifactVersions(w http.ResponseWriter, r *http.Request, registryRef RegistryRefPathParam, artifact ArtifactPathParam, params GetAllArtifactVersionsParams) {
|
|
w.WriteHeader(http.StatusNotImplemented)
|
|
}
|
|
|
|
// List Artifacts for Registry
|
|
// (GET /registry/{registry_ref}/artifacts)
|
|
func (_ Unimplemented) GetAllArtifactsByRegistry(w http.ResponseWriter, r *http.Request, registryRef RegistryRefPathParam, params GetAllArtifactsByRegistryParams) {
|
|
w.WriteHeader(http.StatusNotImplemented)
|
|
}
|
|
|
|
// Returns CLI Client Setup Details
|
|
// (GET /registry/{registry_ref}/client-setup-details)
|
|
func (_ Unimplemented) GetClientSetupDetails(w http.ResponseWriter, r *http.Request, registryRef RegistryRefPathParam, params GetClientSetupDetailsParams) {
|
|
w.WriteHeader(http.StatusNotImplemented)
|
|
}
|
|
|
|
// Get Artifact Stats
|
|
// (GET /spaces/{space_ref}/artifact/stats)
|
|
func (_ Unimplemented) GetArtifactStatsForSpace(w http.ResponseWriter, r *http.Request, spaceRef SpaceRefPathParam, params GetArtifactStatsForSpaceParams) {
|
|
w.WriteHeader(http.StatusNotImplemented)
|
|
}
|
|
|
|
// List Artifacts
|
|
// (GET /spaces/{space_ref}/artifacts)
|
|
func (_ Unimplemented) GetAllArtifacts(w http.ResponseWriter, r *http.Request, spaceRef SpaceRefPathParam, params GetAllArtifactsParams) {
|
|
w.WriteHeader(http.StatusNotImplemented)
|
|
}
|
|
|
|
// List Registries
|
|
// (GET /spaces/{space_ref}/registries)
|
|
func (_ Unimplemented) GetAllRegistries(w http.ResponseWriter, r *http.Request, spaceRef SpaceRefPathParam, params GetAllRegistriesParams) {
|
|
w.WriteHeader(http.StatusNotImplemented)
|
|
}
|
|
|
|
// ServerInterfaceWrapper converts contexts to parameters.
|
|
type ServerInterfaceWrapper struct {
|
|
Handler ServerInterface
|
|
HandlerMiddlewares []MiddlewareFunc
|
|
ErrorHandlerFunc func(w http.ResponseWriter, r *http.Request, err error)
|
|
}
|
|
|
|
type MiddlewareFunc func(http.Handler) http.Handler
|
|
|
|
// CreateRegistry operation middleware
|
|
func (siw *ServerInterfaceWrapper) CreateRegistry(w http.ResponseWriter, r *http.Request) {
|
|
ctx := r.Context()
|
|
|
|
var err error
|
|
|
|
// Parameter object where we will unmarshal all parameters from the context
|
|
var params CreateRegistryParams
|
|
|
|
// ------------- Optional query parameter "space_ref" -------------
|
|
|
|
err = runtime.BindQueryParameter("form", true, false, "space_ref", r.URL.Query(), ¶ms.SpaceRef)
|
|
if err != nil {
|
|
siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "space_ref", Err: err})
|
|
return
|
|
}
|
|
|
|
handler := http.Handler(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
siw.Handler.CreateRegistry(w, r, params)
|
|
}))
|
|
|
|
for _, middleware := range siw.HandlerMiddlewares {
|
|
handler = middleware(handler)
|
|
}
|
|
|
|
handler.ServeHTTP(w, r.WithContext(ctx))
|
|
}
|
|
|
|
// DeleteRegistry operation middleware
|
|
func (siw *ServerInterfaceWrapper) DeleteRegistry(w http.ResponseWriter, r *http.Request) {
|
|
ctx := r.Context()
|
|
|
|
var err error
|
|
|
|
// ------------- Path parameter "registry_ref" -------------
|
|
var registryRef RegistryRefPathParam
|
|
|
|
err = runtime.BindStyledParameterWithOptions("simple", "registry_ref", chi.URLParam(r, "registry_ref"), ®istryRef, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true})
|
|
if err != nil {
|
|
siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "registry_ref", Err: err})
|
|
return
|
|
}
|
|
|
|
handler := http.Handler(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
siw.Handler.DeleteRegistry(w, r, registryRef)
|
|
}))
|
|
|
|
for _, middleware := range siw.HandlerMiddlewares {
|
|
handler = middleware(handler)
|
|
}
|
|
|
|
handler.ServeHTTP(w, r.WithContext(ctx))
|
|
}
|
|
|
|
// GetRegistry operation middleware
|
|
func (siw *ServerInterfaceWrapper) GetRegistry(w http.ResponseWriter, r *http.Request) {
|
|
ctx := r.Context()
|
|
|
|
var err error
|
|
|
|
// ------------- Path parameter "registry_ref" -------------
|
|
var registryRef RegistryRefPathParam
|
|
|
|
err = runtime.BindStyledParameterWithOptions("simple", "registry_ref", chi.URLParam(r, "registry_ref"), ®istryRef, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true})
|
|
if err != nil {
|
|
siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "registry_ref", Err: err})
|
|
return
|
|
}
|
|
|
|
handler := http.Handler(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
siw.Handler.GetRegistry(w, r, registryRef)
|
|
}))
|
|
|
|
for _, middleware := range siw.HandlerMiddlewares {
|
|
handler = middleware(handler)
|
|
}
|
|
|
|
handler.ServeHTTP(w, r.WithContext(ctx))
|
|
}
|
|
|
|
// ModifyRegistry operation middleware
|
|
func (siw *ServerInterfaceWrapper) ModifyRegistry(w http.ResponseWriter, r *http.Request) {
|
|
ctx := r.Context()
|
|
|
|
var err error
|
|
|
|
// ------------- Path parameter "registry_ref" -------------
|
|
var registryRef RegistryRefPathParam
|
|
|
|
err = runtime.BindStyledParameterWithOptions("simple", "registry_ref", chi.URLParam(r, "registry_ref"), ®istryRef, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true})
|
|
if err != nil {
|
|
siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "registry_ref", Err: err})
|
|
return
|
|
}
|
|
|
|
handler := http.Handler(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
siw.Handler.ModifyRegistry(w, r, registryRef)
|
|
}))
|
|
|
|
for _, middleware := range siw.HandlerMiddlewares {
|
|
handler = middleware(handler)
|
|
}
|
|
|
|
handler.ServeHTTP(w, r.WithContext(ctx))
|
|
}
|
|
|
|
// ListArtifactLabels operation middleware
|
|
func (siw *ServerInterfaceWrapper) ListArtifactLabels(w http.ResponseWriter, r *http.Request) {
|
|
ctx := r.Context()
|
|
|
|
var err error
|
|
|
|
// ------------- Path parameter "registry_ref" -------------
|
|
var registryRef RegistryRefPathParam
|
|
|
|
err = runtime.BindStyledParameterWithOptions("simple", "registry_ref", chi.URLParam(r, "registry_ref"), ®istryRef, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true})
|
|
if err != nil {
|
|
siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "registry_ref", Err: err})
|
|
return
|
|
}
|
|
|
|
// Parameter object where we will unmarshal all parameters from the context
|
|
var params ListArtifactLabelsParams
|
|
|
|
// ------------- Optional query parameter "page" -------------
|
|
|
|
err = runtime.BindQueryParameter("form", true, false, "page", r.URL.Query(), ¶ms.Page)
|
|
if err != nil {
|
|
siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "page", Err: err})
|
|
return
|
|
}
|
|
|
|
// ------------- Optional query parameter "size" -------------
|
|
|
|
err = runtime.BindQueryParameter("form", true, false, "size", r.URL.Query(), ¶ms.Size)
|
|
if err != nil {
|
|
siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "size", Err: err})
|
|
return
|
|
}
|
|
|
|
// ------------- Optional query parameter "search_term" -------------
|
|
|
|
err = runtime.BindQueryParameter("form", true, false, "search_term", r.URL.Query(), ¶ms.SearchTerm)
|
|
if err != nil {
|
|
siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "search_term", Err: err})
|
|
return
|
|
}
|
|
|
|
handler := http.Handler(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
siw.Handler.ListArtifactLabels(w, r, registryRef, params)
|
|
}))
|
|
|
|
for _, middleware := range siw.HandlerMiddlewares {
|
|
handler = middleware(handler)
|
|
}
|
|
|
|
handler.ServeHTTP(w, r.WithContext(ctx))
|
|
}
|
|
|
|
// GetArtifactStatsForRegistry operation middleware
|
|
func (siw *ServerInterfaceWrapper) GetArtifactStatsForRegistry(w http.ResponseWriter, r *http.Request) {
|
|
ctx := r.Context()
|
|
|
|
var err error
|
|
|
|
// ------------- Path parameter "registry_ref" -------------
|
|
var registryRef RegistryRefPathParam
|
|
|
|
err = runtime.BindStyledParameterWithOptions("simple", "registry_ref", chi.URLParam(r, "registry_ref"), ®istryRef, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true})
|
|
if err != nil {
|
|
siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "registry_ref", Err: err})
|
|
return
|
|
}
|
|
|
|
// Parameter object where we will unmarshal all parameters from the context
|
|
var params GetArtifactStatsForRegistryParams
|
|
|
|
// ------------- Optional query parameter "from" -------------
|
|
|
|
err = runtime.BindQueryParameter("form", true, false, "from", r.URL.Query(), ¶ms.From)
|
|
if err != nil {
|
|
siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "from", Err: err})
|
|
return
|
|
}
|
|
|
|
// ------------- Optional query parameter "to" -------------
|
|
|
|
err = runtime.BindQueryParameter("form", true, false, "to", r.URL.Query(), ¶ms.To)
|
|
if err != nil {
|
|
siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "to", Err: err})
|
|
return
|
|
}
|
|
|
|
handler := http.Handler(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
siw.Handler.GetArtifactStatsForRegistry(w, r, registryRef, params)
|
|
}))
|
|
|
|
for _, middleware := range siw.HandlerMiddlewares {
|
|
handler = middleware(handler)
|
|
}
|
|
|
|
handler.ServeHTTP(w, r.WithContext(ctx))
|
|
}
|
|
|
|
// DeleteArtifact operation middleware
|
|
func (siw *ServerInterfaceWrapper) DeleteArtifact(w http.ResponseWriter, r *http.Request) {
|
|
ctx := r.Context()
|
|
|
|
var err error
|
|
|
|
// ------------- Path parameter "registry_ref" -------------
|
|
var registryRef RegistryRefPathParam
|
|
|
|
err = runtime.BindStyledParameterWithOptions("simple", "registry_ref", chi.URLParam(r, "registry_ref"), ®istryRef, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true})
|
|
if err != nil {
|
|
siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "registry_ref", Err: err})
|
|
return
|
|
}
|
|
|
|
// ------------- Path parameter "artifact" -------------
|
|
var artifact ArtifactPathParam
|
|
|
|
err = runtime.BindStyledParameterWithOptions("simple", "artifact", chi.URLParam(r, "artifact"), &artifact, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true})
|
|
if err != nil {
|
|
siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "artifact", Err: err})
|
|
return
|
|
}
|
|
|
|
handler := http.Handler(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
siw.Handler.DeleteArtifact(w, r, registryRef, artifact)
|
|
}))
|
|
|
|
for _, middleware := range siw.HandlerMiddlewares {
|
|
handler = middleware(handler)
|
|
}
|
|
|
|
handler.ServeHTTP(w, r.WithContext(ctx))
|
|
}
|
|
|
|
// UpdateArtifactLabels operation middleware
|
|
func (siw *ServerInterfaceWrapper) UpdateArtifactLabels(w http.ResponseWriter, r *http.Request) {
|
|
ctx := r.Context()
|
|
|
|
var err error
|
|
|
|
// ------------- Path parameter "registry_ref" -------------
|
|
var registryRef RegistryRefPathParam
|
|
|
|
err = runtime.BindStyledParameterWithOptions("simple", "registry_ref", chi.URLParam(r, "registry_ref"), ®istryRef, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true})
|
|
if err != nil {
|
|
siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "registry_ref", Err: err})
|
|
return
|
|
}
|
|
|
|
// ------------- Path parameter "artifact" -------------
|
|
var artifact ArtifactPathParam
|
|
|
|
err = runtime.BindStyledParameterWithOptions("simple", "artifact", chi.URLParam(r, "artifact"), &artifact, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true})
|
|
if err != nil {
|
|
siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "artifact", Err: err})
|
|
return
|
|
}
|
|
|
|
handler := http.Handler(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
siw.Handler.UpdateArtifactLabels(w, r, registryRef, artifact)
|
|
}))
|
|
|
|
for _, middleware := range siw.HandlerMiddlewares {
|
|
handler = middleware(handler)
|
|
}
|
|
|
|
handler.ServeHTTP(w, r.WithContext(ctx))
|
|
}
|
|
|
|
// GetArtifactStats operation middleware
|
|
func (siw *ServerInterfaceWrapper) GetArtifactStats(w http.ResponseWriter, r *http.Request) {
|
|
ctx := r.Context()
|
|
|
|
var err error
|
|
|
|
// ------------- Path parameter "registry_ref" -------------
|
|
var registryRef RegistryRefPathParam
|
|
|
|
err = runtime.BindStyledParameterWithOptions("simple", "registry_ref", chi.URLParam(r, "registry_ref"), ®istryRef, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true})
|
|
if err != nil {
|
|
siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "registry_ref", Err: err})
|
|
return
|
|
}
|
|
|
|
// ------------- Path parameter "artifact" -------------
|
|
var artifact ArtifactPathParam
|
|
|
|
err = runtime.BindStyledParameterWithOptions("simple", "artifact", chi.URLParam(r, "artifact"), &artifact, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true})
|
|
if err != nil {
|
|
siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "artifact", Err: err})
|
|
return
|
|
}
|
|
|
|
// Parameter object where we will unmarshal all parameters from the context
|
|
var params GetArtifactStatsParams
|
|
|
|
// ------------- Optional query parameter "from" -------------
|
|
|
|
err = runtime.BindQueryParameter("form", true, false, "from", r.URL.Query(), ¶ms.From)
|
|
if err != nil {
|
|
siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "from", Err: err})
|
|
return
|
|
}
|
|
|
|
// ------------- Optional query parameter "to" -------------
|
|
|
|
err = runtime.BindQueryParameter("form", true, false, "to", r.URL.Query(), ¶ms.To)
|
|
if err != nil {
|
|
siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "to", Err: err})
|
|
return
|
|
}
|
|
|
|
handler := http.Handler(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
siw.Handler.GetArtifactStats(w, r, registryRef, artifact, params)
|
|
}))
|
|
|
|
for _, middleware := range siw.HandlerMiddlewares {
|
|
handler = middleware(handler)
|
|
}
|
|
|
|
handler.ServeHTTP(w, r.WithContext(ctx))
|
|
}
|
|
|
|
// GetArtifactSummary operation middleware
|
|
func (siw *ServerInterfaceWrapper) GetArtifactSummary(w http.ResponseWriter, r *http.Request) {
|
|
ctx := r.Context()
|
|
|
|
var err error
|
|
|
|
// ------------- Path parameter "registry_ref" -------------
|
|
var registryRef RegistryRefPathParam
|
|
|
|
err = runtime.BindStyledParameterWithOptions("simple", "registry_ref", chi.URLParam(r, "registry_ref"), ®istryRef, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true})
|
|
if err != nil {
|
|
siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "registry_ref", Err: err})
|
|
return
|
|
}
|
|
|
|
// ------------- Path parameter "artifact" -------------
|
|
var artifact ArtifactPathParam
|
|
|
|
err = runtime.BindStyledParameterWithOptions("simple", "artifact", chi.URLParam(r, "artifact"), &artifact, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true})
|
|
if err != nil {
|
|
siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "artifact", Err: err})
|
|
return
|
|
}
|
|
|
|
handler := http.Handler(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
siw.Handler.GetArtifactSummary(w, r, registryRef, artifact)
|
|
}))
|
|
|
|
for _, middleware := range siw.HandlerMiddlewares {
|
|
handler = middleware(handler)
|
|
}
|
|
|
|
handler.ServeHTTP(w, r.WithContext(ctx))
|
|
}
|
|
|
|
// DeleteArtifactVersion operation middleware
|
|
func (siw *ServerInterfaceWrapper) DeleteArtifactVersion(w http.ResponseWriter, r *http.Request) {
|
|
ctx := r.Context()
|
|
|
|
var err error
|
|
|
|
// ------------- Path parameter "registry_ref" -------------
|
|
var registryRef RegistryRefPathParam
|
|
|
|
err = runtime.BindStyledParameterWithOptions("simple", "registry_ref", chi.URLParam(r, "registry_ref"), ®istryRef, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true})
|
|
if err != nil {
|
|
siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "registry_ref", Err: err})
|
|
return
|
|
}
|
|
|
|
// ------------- Path parameter "artifact" -------------
|
|
var artifact ArtifactPathParam
|
|
|
|
err = runtime.BindStyledParameterWithOptions("simple", "artifact", chi.URLParam(r, "artifact"), &artifact, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true})
|
|
if err != nil {
|
|
siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "artifact", Err: err})
|
|
return
|
|
}
|
|
|
|
// ------------- Path parameter "version" -------------
|
|
var version VersionPathParam
|
|
|
|
err = runtime.BindStyledParameterWithOptions("simple", "version", chi.URLParam(r, "version"), &version, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true})
|
|
if err != nil {
|
|
siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "version", Err: err})
|
|
return
|
|
}
|
|
|
|
handler := http.Handler(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
siw.Handler.DeleteArtifactVersion(w, r, registryRef, artifact, version)
|
|
}))
|
|
|
|
for _, middleware := range siw.HandlerMiddlewares {
|
|
handler = middleware(handler)
|
|
}
|
|
|
|
handler.ServeHTTP(w, r.WithContext(ctx))
|
|
}
|
|
|
|
// GetDockerArtifactDetails operation middleware
|
|
func (siw *ServerInterfaceWrapper) GetDockerArtifactDetails(w http.ResponseWriter, r *http.Request) {
|
|
ctx := r.Context()
|
|
|
|
var err error
|
|
|
|
// ------------- Path parameter "registry_ref" -------------
|
|
var registryRef RegistryRefPathParam
|
|
|
|
err = runtime.BindStyledParameterWithOptions("simple", "registry_ref", chi.URLParam(r, "registry_ref"), ®istryRef, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true})
|
|
if err != nil {
|
|
siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "registry_ref", Err: err})
|
|
return
|
|
}
|
|
|
|
// ------------- Path parameter "artifact" -------------
|
|
var artifact ArtifactPathParam
|
|
|
|
err = runtime.BindStyledParameterWithOptions("simple", "artifact", chi.URLParam(r, "artifact"), &artifact, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true})
|
|
if err != nil {
|
|
siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "artifact", Err: err})
|
|
return
|
|
}
|
|
|
|
// ------------- Path parameter "version" -------------
|
|
var version VersionPathParam
|
|
|
|
err = runtime.BindStyledParameterWithOptions("simple", "version", chi.URLParam(r, "version"), &version, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true})
|
|
if err != nil {
|
|
siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "version", Err: err})
|
|
return
|
|
}
|
|
|
|
// Parameter object where we will unmarshal all parameters from the context
|
|
var params GetDockerArtifactDetailsParams
|
|
|
|
// ------------- Required query parameter "digest" -------------
|
|
|
|
if paramValue := r.URL.Query().Get("digest"); paramValue != "" {
|
|
|
|
} else {
|
|
siw.ErrorHandlerFunc(w, r, &RequiredParamError{ParamName: "digest"})
|
|
return
|
|
}
|
|
|
|
err = runtime.BindQueryParameter("form", true, true, "digest", r.URL.Query(), ¶ms.Digest)
|
|
if err != nil {
|
|
siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "digest", Err: err})
|
|
return
|
|
}
|
|
|
|
handler := http.Handler(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
siw.Handler.GetDockerArtifactDetails(w, r, registryRef, artifact, version, params)
|
|
}))
|
|
|
|
for _, middleware := range siw.HandlerMiddlewares {
|
|
handler = middleware(handler)
|
|
}
|
|
|
|
handler.ServeHTTP(w, r.WithContext(ctx))
|
|
}
|
|
|
|
// GetDockerArtifactLayers operation middleware
|
|
func (siw *ServerInterfaceWrapper) GetDockerArtifactLayers(w http.ResponseWriter, r *http.Request) {
|
|
ctx := r.Context()
|
|
|
|
var err error
|
|
|
|
// ------------- Path parameter "registry_ref" -------------
|
|
var registryRef RegistryRefPathParam
|
|
|
|
err = runtime.BindStyledParameterWithOptions("simple", "registry_ref", chi.URLParam(r, "registry_ref"), ®istryRef, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true})
|
|
if err != nil {
|
|
siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "registry_ref", Err: err})
|
|
return
|
|
}
|
|
|
|
// ------------- Path parameter "artifact" -------------
|
|
var artifact ArtifactPathParam
|
|
|
|
err = runtime.BindStyledParameterWithOptions("simple", "artifact", chi.URLParam(r, "artifact"), &artifact, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true})
|
|
if err != nil {
|
|
siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "artifact", Err: err})
|
|
return
|
|
}
|
|
|
|
// ------------- Path parameter "version" -------------
|
|
var version VersionPathParam
|
|
|
|
err = runtime.BindStyledParameterWithOptions("simple", "version", chi.URLParam(r, "version"), &version, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true})
|
|
if err != nil {
|
|
siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "version", Err: err})
|
|
return
|
|
}
|
|
|
|
// Parameter object where we will unmarshal all parameters from the context
|
|
var params GetDockerArtifactLayersParams
|
|
|
|
// ------------- Required query parameter "digest" -------------
|
|
|
|
if paramValue := r.URL.Query().Get("digest"); paramValue != "" {
|
|
|
|
} else {
|
|
siw.ErrorHandlerFunc(w, r, &RequiredParamError{ParamName: "digest"})
|
|
return
|
|
}
|
|
|
|
err = runtime.BindQueryParameter("form", true, true, "digest", r.URL.Query(), ¶ms.Digest)
|
|
if err != nil {
|
|
siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "digest", Err: err})
|
|
return
|
|
}
|
|
|
|
handler := http.Handler(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
siw.Handler.GetDockerArtifactLayers(w, r, registryRef, artifact, version, params)
|
|
}))
|
|
|
|
for _, middleware := range siw.HandlerMiddlewares {
|
|
handler = middleware(handler)
|
|
}
|
|
|
|
handler.ServeHTTP(w, r.WithContext(ctx))
|
|
}
|
|
|
|
// GetDockerArtifactManifest operation middleware
|
|
func (siw *ServerInterfaceWrapper) GetDockerArtifactManifest(w http.ResponseWriter, r *http.Request) {
|
|
ctx := r.Context()
|
|
|
|
var err error
|
|
|
|
// ------------- Path parameter "registry_ref" -------------
|
|
var registryRef RegistryRefPathParam
|
|
|
|
err = runtime.BindStyledParameterWithOptions("simple", "registry_ref", chi.URLParam(r, "registry_ref"), ®istryRef, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true})
|
|
if err != nil {
|
|
siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "registry_ref", Err: err})
|
|
return
|
|
}
|
|
|
|
// ------------- Path parameter "artifact" -------------
|
|
var artifact ArtifactPathParam
|
|
|
|
err = runtime.BindStyledParameterWithOptions("simple", "artifact", chi.URLParam(r, "artifact"), &artifact, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true})
|
|
if err != nil {
|
|
siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "artifact", Err: err})
|
|
return
|
|
}
|
|
|
|
// ------------- Path parameter "version" -------------
|
|
var version VersionPathParam
|
|
|
|
err = runtime.BindStyledParameterWithOptions("simple", "version", chi.URLParam(r, "version"), &version, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true})
|
|
if err != nil {
|
|
siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "version", Err: err})
|
|
return
|
|
}
|
|
|
|
// Parameter object where we will unmarshal all parameters from the context
|
|
var params GetDockerArtifactManifestParams
|
|
|
|
// ------------- Required query parameter "digest" -------------
|
|
|
|
if paramValue := r.URL.Query().Get("digest"); paramValue != "" {
|
|
|
|
} else {
|
|
siw.ErrorHandlerFunc(w, r, &RequiredParamError{ParamName: "digest"})
|
|
return
|
|
}
|
|
|
|
err = runtime.BindQueryParameter("form", true, true, "digest", r.URL.Query(), ¶ms.Digest)
|
|
if err != nil {
|
|
siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "digest", Err: err})
|
|
return
|
|
}
|
|
|
|
handler := http.Handler(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
siw.Handler.GetDockerArtifactManifest(w, r, registryRef, artifact, version, params)
|
|
}))
|
|
|
|
for _, middleware := range siw.HandlerMiddlewares {
|
|
handler = middleware(handler)
|
|
}
|
|
|
|
handler.ServeHTTP(w, r.WithContext(ctx))
|
|
}
|
|
|
|
// GetDockerArtifactManifests operation middleware
|
|
func (siw *ServerInterfaceWrapper) GetDockerArtifactManifests(w http.ResponseWriter, r *http.Request) {
|
|
ctx := r.Context()
|
|
|
|
var err error
|
|
|
|
// ------------- Path parameter "registry_ref" -------------
|
|
var registryRef RegistryRefPathParam
|
|
|
|
err = runtime.BindStyledParameterWithOptions("simple", "registry_ref", chi.URLParam(r, "registry_ref"), ®istryRef, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true})
|
|
if err != nil {
|
|
siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "registry_ref", Err: err})
|
|
return
|
|
}
|
|
|
|
// ------------- Path parameter "artifact" -------------
|
|
var artifact ArtifactPathParam
|
|
|
|
err = runtime.BindStyledParameterWithOptions("simple", "artifact", chi.URLParam(r, "artifact"), &artifact, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true})
|
|
if err != nil {
|
|
siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "artifact", Err: err})
|
|
return
|
|
}
|
|
|
|
// ------------- Path parameter "version" -------------
|
|
var version VersionPathParam
|
|
|
|
err = runtime.BindStyledParameterWithOptions("simple", "version", chi.URLParam(r, "version"), &version, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true})
|
|
if err != nil {
|
|
siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "version", Err: err})
|
|
return
|
|
}
|
|
|
|
handler := http.Handler(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
siw.Handler.GetDockerArtifactManifests(w, r, registryRef, artifact, version)
|
|
}))
|
|
|
|
for _, middleware := range siw.HandlerMiddlewares {
|
|
handler = middleware(handler)
|
|
}
|
|
|
|
handler.ServeHTTP(w, r.WithContext(ctx))
|
|
}
|
|
|
|
// GetHelmArtifactDetails operation middleware
|
|
func (siw *ServerInterfaceWrapper) GetHelmArtifactDetails(w http.ResponseWriter, r *http.Request) {
|
|
ctx := r.Context()
|
|
|
|
var err error
|
|
|
|
// ------------- Path parameter "registry_ref" -------------
|
|
var registryRef RegistryRefPathParam
|
|
|
|
err = runtime.BindStyledParameterWithOptions("simple", "registry_ref", chi.URLParam(r, "registry_ref"), ®istryRef, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true})
|
|
if err != nil {
|
|
siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "registry_ref", Err: err})
|
|
return
|
|
}
|
|
|
|
// ------------- Path parameter "artifact" -------------
|
|
var artifact ArtifactPathParam
|
|
|
|
err = runtime.BindStyledParameterWithOptions("simple", "artifact", chi.URLParam(r, "artifact"), &artifact, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true})
|
|
if err != nil {
|
|
siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "artifact", Err: err})
|
|
return
|
|
}
|
|
|
|
// ------------- Path parameter "version" -------------
|
|
var version VersionPathParam
|
|
|
|
err = runtime.BindStyledParameterWithOptions("simple", "version", chi.URLParam(r, "version"), &version, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true})
|
|
if err != nil {
|
|
siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "version", Err: err})
|
|
return
|
|
}
|
|
|
|
handler := http.Handler(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
siw.Handler.GetHelmArtifactDetails(w, r, registryRef, artifact, version)
|
|
}))
|
|
|
|
for _, middleware := range siw.HandlerMiddlewares {
|
|
handler = middleware(handler)
|
|
}
|
|
|
|
handler.ServeHTTP(w, r.WithContext(ctx))
|
|
}
|
|
|
|
// GetHelmArtifactManifest operation middleware
|
|
func (siw *ServerInterfaceWrapper) GetHelmArtifactManifest(w http.ResponseWriter, r *http.Request) {
|
|
ctx := r.Context()
|
|
|
|
var err error
|
|
|
|
// ------------- Path parameter "registry_ref" -------------
|
|
var registryRef RegistryRefPathParam
|
|
|
|
err = runtime.BindStyledParameterWithOptions("simple", "registry_ref", chi.URLParam(r, "registry_ref"), ®istryRef, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true})
|
|
if err != nil {
|
|
siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "registry_ref", Err: err})
|
|
return
|
|
}
|
|
|
|
// ------------- Path parameter "artifact" -------------
|
|
var artifact ArtifactPathParam
|
|
|
|
err = runtime.BindStyledParameterWithOptions("simple", "artifact", chi.URLParam(r, "artifact"), &artifact, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true})
|
|
if err != nil {
|
|
siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "artifact", Err: err})
|
|
return
|
|
}
|
|
|
|
// ------------- Path parameter "version" -------------
|
|
var version VersionPathParam
|
|
|
|
err = runtime.BindStyledParameterWithOptions("simple", "version", chi.URLParam(r, "version"), &version, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true})
|
|
if err != nil {
|
|
siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "version", Err: err})
|
|
return
|
|
}
|
|
|
|
handler := http.Handler(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
siw.Handler.GetHelmArtifactManifest(w, r, registryRef, artifact, version)
|
|
}))
|
|
|
|
for _, middleware := range siw.HandlerMiddlewares {
|
|
handler = middleware(handler)
|
|
}
|
|
|
|
handler.ServeHTTP(w, r.WithContext(ctx))
|
|
}
|
|
|
|
// GetArtifactVersionSummary operation middleware
|
|
func (siw *ServerInterfaceWrapper) GetArtifactVersionSummary(w http.ResponseWriter, r *http.Request) {
|
|
ctx := r.Context()
|
|
|
|
var err error
|
|
|
|
// ------------- Path parameter "registry_ref" -------------
|
|
var registryRef RegistryRefPathParam
|
|
|
|
err = runtime.BindStyledParameterWithOptions("simple", "registry_ref", chi.URLParam(r, "registry_ref"), ®istryRef, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true})
|
|
if err != nil {
|
|
siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "registry_ref", Err: err})
|
|
return
|
|
}
|
|
|
|
// ------------- Path parameter "artifact" -------------
|
|
var artifact ArtifactPathParam
|
|
|
|
err = runtime.BindStyledParameterWithOptions("simple", "artifact", chi.URLParam(r, "artifact"), &artifact, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true})
|
|
if err != nil {
|
|
siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "artifact", Err: err})
|
|
return
|
|
}
|
|
|
|
// ------------- Path parameter "version" -------------
|
|
var version VersionPathParam
|
|
|
|
err = runtime.BindStyledParameterWithOptions("simple", "version", chi.URLParam(r, "version"), &version, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true})
|
|
if err != nil {
|
|
siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "version", Err: err})
|
|
return
|
|
}
|
|
|
|
handler := http.Handler(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
siw.Handler.GetArtifactVersionSummary(w, r, registryRef, artifact, version)
|
|
}))
|
|
|
|
for _, middleware := range siw.HandlerMiddlewares {
|
|
handler = middleware(handler)
|
|
}
|
|
|
|
handler.ServeHTTP(w, r.WithContext(ctx))
|
|
}
|
|
|
|
// GetAllArtifactVersions operation middleware
|
|
func (siw *ServerInterfaceWrapper) GetAllArtifactVersions(w http.ResponseWriter, r *http.Request) {
|
|
ctx := r.Context()
|
|
|
|
var err error
|
|
|
|
// ------------- Path parameter "registry_ref" -------------
|
|
var registryRef RegistryRefPathParam
|
|
|
|
err = runtime.BindStyledParameterWithOptions("simple", "registry_ref", chi.URLParam(r, "registry_ref"), ®istryRef, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true})
|
|
if err != nil {
|
|
siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "registry_ref", Err: err})
|
|
return
|
|
}
|
|
|
|
// ------------- Path parameter "artifact" -------------
|
|
var artifact ArtifactPathParam
|
|
|
|
err = runtime.BindStyledParameterWithOptions("simple", "artifact", chi.URLParam(r, "artifact"), &artifact, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true})
|
|
if err != nil {
|
|
siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "artifact", Err: err})
|
|
return
|
|
}
|
|
|
|
// Parameter object where we will unmarshal all parameters from the context
|
|
var params GetAllArtifactVersionsParams
|
|
|
|
// ------------- Optional query parameter "page" -------------
|
|
|
|
err = runtime.BindQueryParameter("form", true, false, "page", r.URL.Query(), ¶ms.Page)
|
|
if err != nil {
|
|
siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "page", Err: err})
|
|
return
|
|
}
|
|
|
|
// ------------- Optional query parameter "size" -------------
|
|
|
|
err = runtime.BindQueryParameter("form", true, false, "size", r.URL.Query(), ¶ms.Size)
|
|
if err != nil {
|
|
siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "size", Err: err})
|
|
return
|
|
}
|
|
|
|
// ------------- Optional query parameter "sort_order" -------------
|
|
|
|
err = runtime.BindQueryParameter("form", true, false, "sort_order", r.URL.Query(), ¶ms.SortOrder)
|
|
if err != nil {
|
|
siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "sort_order", Err: err})
|
|
return
|
|
}
|
|
|
|
// ------------- Optional query parameter "sort_field" -------------
|
|
|
|
err = runtime.BindQueryParameter("form", true, false, "sort_field", r.URL.Query(), ¶ms.SortField)
|
|
if err != nil {
|
|
siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "sort_field", Err: err})
|
|
return
|
|
}
|
|
|
|
// ------------- Optional query parameter "search_term" -------------
|
|
|
|
err = runtime.BindQueryParameter("form", true, false, "search_term", r.URL.Query(), ¶ms.SearchTerm)
|
|
if err != nil {
|
|
siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "search_term", Err: err})
|
|
return
|
|
}
|
|
|
|
handler := http.Handler(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
siw.Handler.GetAllArtifactVersions(w, r, registryRef, artifact, params)
|
|
}))
|
|
|
|
for _, middleware := range siw.HandlerMiddlewares {
|
|
handler = middleware(handler)
|
|
}
|
|
|
|
handler.ServeHTTP(w, r.WithContext(ctx))
|
|
}
|
|
|
|
// GetAllArtifactsByRegistry operation middleware
|
|
func (siw *ServerInterfaceWrapper) GetAllArtifactsByRegistry(w http.ResponseWriter, r *http.Request) {
|
|
ctx := r.Context()
|
|
|
|
var err error
|
|
|
|
// ------------- Path parameter "registry_ref" -------------
|
|
var registryRef RegistryRefPathParam
|
|
|
|
err = runtime.BindStyledParameterWithOptions("simple", "registry_ref", chi.URLParam(r, "registry_ref"), ®istryRef, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true})
|
|
if err != nil {
|
|
siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "registry_ref", Err: err})
|
|
return
|
|
}
|
|
|
|
// Parameter object where we will unmarshal all parameters from the context
|
|
var params GetAllArtifactsByRegistryParams
|
|
|
|
// ------------- Optional query parameter "label" -------------
|
|
|
|
err = runtime.BindQueryParameter("form", true, false, "label", r.URL.Query(), ¶ms.Label)
|
|
if err != nil {
|
|
siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "label", Err: err})
|
|
return
|
|
}
|
|
|
|
// ------------- Optional query parameter "page" -------------
|
|
|
|
err = runtime.BindQueryParameter("form", true, false, "page", r.URL.Query(), ¶ms.Page)
|
|
if err != nil {
|
|
siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "page", Err: err})
|
|
return
|
|
}
|
|
|
|
// ------------- Optional query parameter "size" -------------
|
|
|
|
err = runtime.BindQueryParameter("form", true, false, "size", r.URL.Query(), ¶ms.Size)
|
|
if err != nil {
|
|
siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "size", Err: err})
|
|
return
|
|
}
|
|
|
|
// ------------- Optional query parameter "sort_order" -------------
|
|
|
|
err = runtime.BindQueryParameter("form", true, false, "sort_order", r.URL.Query(), ¶ms.SortOrder)
|
|
if err != nil {
|
|
siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "sort_order", Err: err})
|
|
return
|
|
}
|
|
|
|
// ------------- Optional query parameter "sort_field" -------------
|
|
|
|
err = runtime.BindQueryParameter("form", true, false, "sort_field", r.URL.Query(), ¶ms.SortField)
|
|
if err != nil {
|
|
siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "sort_field", Err: err})
|
|
return
|
|
}
|
|
|
|
// ------------- Optional query parameter "search_term" -------------
|
|
|
|
err = runtime.BindQueryParameter("form", true, false, "search_term", r.URL.Query(), ¶ms.SearchTerm)
|
|
if err != nil {
|
|
siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "search_term", Err: err})
|
|
return
|
|
}
|
|
|
|
handler := http.Handler(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
siw.Handler.GetAllArtifactsByRegistry(w, r, registryRef, params)
|
|
}))
|
|
|
|
for _, middleware := range siw.HandlerMiddlewares {
|
|
handler = middleware(handler)
|
|
}
|
|
|
|
handler.ServeHTTP(w, r.WithContext(ctx))
|
|
}
|
|
|
|
// GetClientSetupDetails operation middleware
|
|
func (siw *ServerInterfaceWrapper) GetClientSetupDetails(w http.ResponseWriter, r *http.Request) {
|
|
ctx := r.Context()
|
|
|
|
var err error
|
|
|
|
// ------------- Path parameter "registry_ref" -------------
|
|
var registryRef RegistryRefPathParam
|
|
|
|
err = runtime.BindStyledParameterWithOptions("simple", "registry_ref", chi.URLParam(r, "registry_ref"), ®istryRef, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true})
|
|
if err != nil {
|
|
siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "registry_ref", Err: err})
|
|
return
|
|
}
|
|
|
|
// Parameter object where we will unmarshal all parameters from the context
|
|
var params GetClientSetupDetailsParams
|
|
|
|
// ------------- Optional query parameter "artifact" -------------
|
|
|
|
err = runtime.BindQueryParameter("form", true, false, "artifact", r.URL.Query(), ¶ms.Artifact)
|
|
if err != nil {
|
|
siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "artifact", Err: err})
|
|
return
|
|
}
|
|
|
|
// ------------- Optional query parameter "version" -------------
|
|
|
|
err = runtime.BindQueryParameter("form", true, false, "version", r.URL.Query(), ¶ms.Version)
|
|
if err != nil {
|
|
siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "version", Err: err})
|
|
return
|
|
}
|
|
|
|
handler := http.Handler(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
siw.Handler.GetClientSetupDetails(w, r, registryRef, params)
|
|
}))
|
|
|
|
for _, middleware := range siw.HandlerMiddlewares {
|
|
handler = middleware(handler)
|
|
}
|
|
|
|
handler.ServeHTTP(w, r.WithContext(ctx))
|
|
}
|
|
|
|
// GetArtifactStatsForSpace operation middleware
|
|
func (siw *ServerInterfaceWrapper) GetArtifactStatsForSpace(w http.ResponseWriter, r *http.Request) {
|
|
ctx := r.Context()
|
|
|
|
var err error
|
|
|
|
// ------------- Path parameter "space_ref" -------------
|
|
var spaceRef SpaceRefPathParam
|
|
|
|
err = runtime.BindStyledParameterWithOptions("simple", "space_ref", chi.URLParam(r, "space_ref"), &spaceRef, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true})
|
|
if err != nil {
|
|
siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "space_ref", Err: err})
|
|
return
|
|
}
|
|
|
|
// Parameter object where we will unmarshal all parameters from the context
|
|
var params GetArtifactStatsForSpaceParams
|
|
|
|
// ------------- Optional query parameter "from" -------------
|
|
|
|
err = runtime.BindQueryParameter("form", true, false, "from", r.URL.Query(), ¶ms.From)
|
|
if err != nil {
|
|
siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "from", Err: err})
|
|
return
|
|
}
|
|
|
|
// ------------- Optional query parameter "to" -------------
|
|
|
|
err = runtime.BindQueryParameter("form", true, false, "to", r.URL.Query(), ¶ms.To)
|
|
if err != nil {
|
|
siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "to", Err: err})
|
|
return
|
|
}
|
|
|
|
handler := http.Handler(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
siw.Handler.GetArtifactStatsForSpace(w, r, spaceRef, params)
|
|
}))
|
|
|
|
for _, middleware := range siw.HandlerMiddlewares {
|
|
handler = middleware(handler)
|
|
}
|
|
|
|
handler.ServeHTTP(w, r.WithContext(ctx))
|
|
}
|
|
|
|
// GetAllArtifacts operation middleware
|
|
func (siw *ServerInterfaceWrapper) GetAllArtifacts(w http.ResponseWriter, r *http.Request) {
|
|
ctx := r.Context()
|
|
|
|
var err error
|
|
|
|
// ------------- Path parameter "space_ref" -------------
|
|
var spaceRef SpaceRefPathParam
|
|
|
|
err = runtime.BindStyledParameterWithOptions("simple", "space_ref", chi.URLParam(r, "space_ref"), &spaceRef, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true})
|
|
if err != nil {
|
|
siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "space_ref", Err: err})
|
|
return
|
|
}
|
|
|
|
// Parameter object where we will unmarshal all parameters from the context
|
|
var params GetAllArtifactsParams
|
|
|
|
// ------------- Optional query parameter "reg_identifier" -------------
|
|
|
|
err = runtime.BindQueryParameter("form", true, false, "reg_identifier", r.URL.Query(), ¶ms.RegIdentifier)
|
|
if err != nil {
|
|
siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "reg_identifier", Err: err})
|
|
return
|
|
}
|
|
|
|
// ------------- Optional query parameter "page" -------------
|
|
|
|
err = runtime.BindQueryParameter("form", true, false, "page", r.URL.Query(), ¶ms.Page)
|
|
if err != nil {
|
|
siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "page", Err: err})
|
|
return
|
|
}
|
|
|
|
// ------------- Optional query parameter "size" -------------
|
|
|
|
err = runtime.BindQueryParameter("form", true, false, "size", r.URL.Query(), ¶ms.Size)
|
|
if err != nil {
|
|
siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "size", Err: err})
|
|
return
|
|
}
|
|
|
|
// ------------- Optional query parameter "sort_order" -------------
|
|
|
|
err = runtime.BindQueryParameter("form", true, false, "sort_order", r.URL.Query(), ¶ms.SortOrder)
|
|
if err != nil {
|
|
siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "sort_order", Err: err})
|
|
return
|
|
}
|
|
|
|
// ------------- Optional query parameter "sort_field" -------------
|
|
|
|
err = runtime.BindQueryParameter("form", true, false, "sort_field", r.URL.Query(), ¶ms.SortField)
|
|
if err != nil {
|
|
siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "sort_field", Err: err})
|
|
return
|
|
}
|
|
|
|
// ------------- Optional query parameter "search_term" -------------
|
|
|
|
err = runtime.BindQueryParameter("form", true, false, "search_term", r.URL.Query(), ¶ms.SearchTerm)
|
|
if err != nil {
|
|
siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "search_term", Err: err})
|
|
return
|
|
}
|
|
|
|
// ------------- Optional query parameter "latest_version" -------------
|
|
|
|
err = runtime.BindQueryParameter("form", true, false, "latest_version", r.URL.Query(), ¶ms.LatestVersion)
|
|
if err != nil {
|
|
siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "latest_version", Err: err})
|
|
return
|
|
}
|
|
|
|
handler := http.Handler(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
siw.Handler.GetAllArtifacts(w, r, spaceRef, params)
|
|
}))
|
|
|
|
for _, middleware := range siw.HandlerMiddlewares {
|
|
handler = middleware(handler)
|
|
}
|
|
|
|
handler.ServeHTTP(w, r.WithContext(ctx))
|
|
}
|
|
|
|
// GetAllRegistries operation middleware
|
|
func (siw *ServerInterfaceWrapper) GetAllRegistries(w http.ResponseWriter, r *http.Request) {
|
|
ctx := r.Context()
|
|
|
|
var err error
|
|
|
|
// ------------- Path parameter "space_ref" -------------
|
|
var spaceRef SpaceRefPathParam
|
|
|
|
err = runtime.BindStyledParameterWithOptions("simple", "space_ref", chi.URLParam(r, "space_ref"), &spaceRef, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true})
|
|
if err != nil {
|
|
siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "space_ref", Err: err})
|
|
return
|
|
}
|
|
|
|
// Parameter object where we will unmarshal all parameters from the context
|
|
var params GetAllRegistriesParams
|
|
|
|
// ------------- Optional query parameter "package_type" -------------
|
|
|
|
err = runtime.BindQueryParameter("form", true, false, "package_type", r.URL.Query(), ¶ms.PackageType)
|
|
if err != nil {
|
|
siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "package_type", Err: err})
|
|
return
|
|
}
|
|
|
|
// ------------- Optional query parameter "type" -------------
|
|
|
|
err = runtime.BindQueryParameter("form", true, false, "type", r.URL.Query(), ¶ms.Type)
|
|
if err != nil {
|
|
siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "type", Err: err})
|
|
return
|
|
}
|
|
|
|
// ------------- Optional query parameter "page" -------------
|
|
|
|
err = runtime.BindQueryParameter("form", true, false, "page", r.URL.Query(), ¶ms.Page)
|
|
if err != nil {
|
|
siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "page", Err: err})
|
|
return
|
|
}
|
|
|
|
// ------------- Optional query parameter "size" -------------
|
|
|
|
err = runtime.BindQueryParameter("form", true, false, "size", r.URL.Query(), ¶ms.Size)
|
|
if err != nil {
|
|
siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "size", Err: err})
|
|
return
|
|
}
|
|
|
|
// ------------- Optional query parameter "sort_order" -------------
|
|
|
|
err = runtime.BindQueryParameter("form", true, false, "sort_order", r.URL.Query(), ¶ms.SortOrder)
|
|
if err != nil {
|
|
siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "sort_order", Err: err})
|
|
return
|
|
}
|
|
|
|
// ------------- Optional query parameter "sort_field" -------------
|
|
|
|
err = runtime.BindQueryParameter("form", true, false, "sort_field", r.URL.Query(), ¶ms.SortField)
|
|
if err != nil {
|
|
siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "sort_field", Err: err})
|
|
return
|
|
}
|
|
|
|
// ------------- Optional query parameter "search_term" -------------
|
|
|
|
err = runtime.BindQueryParameter("form", true, false, "search_term", r.URL.Query(), ¶ms.SearchTerm)
|
|
if err != nil {
|
|
siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "search_term", Err: err})
|
|
return
|
|
}
|
|
|
|
handler := http.Handler(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
siw.Handler.GetAllRegistries(w, r, spaceRef, params)
|
|
}))
|
|
|
|
for _, middleware := range siw.HandlerMiddlewares {
|
|
handler = middleware(handler)
|
|
}
|
|
|
|
handler.ServeHTTP(w, r.WithContext(ctx))
|
|
}
|
|
|
|
type UnescapedCookieParamError struct {
|
|
ParamName string
|
|
Err error
|
|
}
|
|
|
|
func (e *UnescapedCookieParamError) Error() string {
|
|
return fmt.Sprintf("error unescaping cookie parameter '%s'", e.ParamName)
|
|
}
|
|
|
|
func (e *UnescapedCookieParamError) Unwrap() error {
|
|
return e.Err
|
|
}
|
|
|
|
type UnmarshalingParamError struct {
|
|
ParamName string
|
|
Err error
|
|
}
|
|
|
|
func (e *UnmarshalingParamError) Error() string {
|
|
return fmt.Sprintf("Error unmarshaling parameter %s as JSON: %s", e.ParamName, e.Err.Error())
|
|
}
|
|
|
|
func (e *UnmarshalingParamError) Unwrap() error {
|
|
return e.Err
|
|
}
|
|
|
|
type RequiredParamError struct {
|
|
ParamName string
|
|
}
|
|
|
|
func (e *RequiredParamError) Error() string {
|
|
return fmt.Sprintf("Query argument %s is required, but not found", e.ParamName)
|
|
}
|
|
|
|
type RequiredHeaderError struct {
|
|
ParamName string
|
|
Err error
|
|
}
|
|
|
|
func (e *RequiredHeaderError) Error() string {
|
|
return fmt.Sprintf("Header parameter %s is required, but not found", e.ParamName)
|
|
}
|
|
|
|
func (e *RequiredHeaderError) Unwrap() error {
|
|
return e.Err
|
|
}
|
|
|
|
type InvalidParamFormatError struct {
|
|
ParamName string
|
|
Err error
|
|
}
|
|
|
|
func (e *InvalidParamFormatError) Error() string {
|
|
return fmt.Sprintf("Invalid format for parameter %s: %s", e.ParamName, e.Err.Error())
|
|
}
|
|
|
|
func (e *InvalidParamFormatError) Unwrap() error {
|
|
return e.Err
|
|
}
|
|
|
|
type TooManyValuesForParamError struct {
|
|
ParamName string
|
|
Count int
|
|
}
|
|
|
|
func (e *TooManyValuesForParamError) Error() string {
|
|
return fmt.Sprintf("Expected one value for %s, got %d", e.ParamName, e.Count)
|
|
}
|
|
|
|
// Handler creates http.Handler with routing matching OpenAPI spec.
|
|
func Handler(si ServerInterface) http.Handler {
|
|
return HandlerWithOptions(si, ChiServerOptions{})
|
|
}
|
|
|
|
type ChiServerOptions struct {
|
|
BaseURL string
|
|
BaseRouter chi.Router
|
|
Middlewares []MiddlewareFunc
|
|
ErrorHandlerFunc func(w http.ResponseWriter, r *http.Request, err error)
|
|
}
|
|
|
|
// HandlerFromMux creates http.Handler with routing matching OpenAPI spec based on the provided mux.
|
|
func HandlerFromMux(si ServerInterface, r chi.Router) http.Handler {
|
|
return HandlerWithOptions(si, ChiServerOptions{
|
|
BaseRouter: r,
|
|
})
|
|
}
|
|
|
|
func HandlerFromMuxWithBaseURL(si ServerInterface, r chi.Router, baseURL string) http.Handler {
|
|
return HandlerWithOptions(si, ChiServerOptions{
|
|
BaseURL: baseURL,
|
|
BaseRouter: r,
|
|
})
|
|
}
|
|
|
|
// HandlerWithOptions creates http.Handler with additional options
|
|
func HandlerWithOptions(si ServerInterface, options ChiServerOptions) http.Handler {
|
|
r := options.BaseRouter
|
|
|
|
if r == nil {
|
|
r = chi.NewRouter()
|
|
}
|
|
if options.ErrorHandlerFunc == nil {
|
|
options.ErrorHandlerFunc = func(w http.ResponseWriter, r *http.Request, err error) {
|
|
http.Error(w, err.Error(), http.StatusBadRequest)
|
|
}
|
|
}
|
|
wrapper := ServerInterfaceWrapper{
|
|
Handler: si,
|
|
HandlerMiddlewares: options.Middlewares,
|
|
ErrorHandlerFunc: options.ErrorHandlerFunc,
|
|
}
|
|
|
|
r.Group(func(r chi.Router) {
|
|
r.Post(options.BaseURL+"/registry", wrapper.CreateRegistry)
|
|
})
|
|
r.Group(func(r chi.Router) {
|
|
r.Delete(options.BaseURL+"/registry/{registry_ref}", wrapper.DeleteRegistry)
|
|
})
|
|
r.Group(func(r chi.Router) {
|
|
r.Get(options.BaseURL+"/registry/{registry_ref}", wrapper.GetRegistry)
|
|
})
|
|
r.Group(func(r chi.Router) {
|
|
r.Put(options.BaseURL+"/registry/{registry_ref}", wrapper.ModifyRegistry)
|
|
})
|
|
r.Group(func(r chi.Router) {
|
|
r.Get(options.BaseURL+"/registry/{registry_ref}/artifact/labels", wrapper.ListArtifactLabels)
|
|
})
|
|
r.Group(func(r chi.Router) {
|
|
r.Get(options.BaseURL+"/registry/{registry_ref}/artifact/stats", wrapper.GetArtifactStatsForRegistry)
|
|
})
|
|
r.Group(func(r chi.Router) {
|
|
r.Delete(options.BaseURL+"/registry/{registry_ref}/artifact/{artifact}", wrapper.DeleteArtifact)
|
|
})
|
|
r.Group(func(r chi.Router) {
|
|
r.Put(options.BaseURL+"/registry/{registry_ref}/artifact/{artifact}/labels", wrapper.UpdateArtifactLabels)
|
|
})
|
|
r.Group(func(r chi.Router) {
|
|
r.Get(options.BaseURL+"/registry/{registry_ref}/artifact/{artifact}/stats", wrapper.GetArtifactStats)
|
|
})
|
|
r.Group(func(r chi.Router) {
|
|
r.Get(options.BaseURL+"/registry/{registry_ref}/artifact/{artifact}/summary", wrapper.GetArtifactSummary)
|
|
})
|
|
r.Group(func(r chi.Router) {
|
|
r.Delete(options.BaseURL+"/registry/{registry_ref}/artifact/{artifact}/version/{version}", wrapper.DeleteArtifactVersion)
|
|
})
|
|
r.Group(func(r chi.Router) {
|
|
r.Get(options.BaseURL+"/registry/{registry_ref}/artifact/{artifact}/version/{version}/docker/details", wrapper.GetDockerArtifactDetails)
|
|
})
|
|
r.Group(func(r chi.Router) {
|
|
r.Get(options.BaseURL+"/registry/{registry_ref}/artifact/{artifact}/version/{version}/docker/layers", wrapper.GetDockerArtifactLayers)
|
|
})
|
|
r.Group(func(r chi.Router) {
|
|
r.Get(options.BaseURL+"/registry/{registry_ref}/artifact/{artifact}/version/{version}/docker/manifest", wrapper.GetDockerArtifactManifest)
|
|
})
|
|
r.Group(func(r chi.Router) {
|
|
r.Get(options.BaseURL+"/registry/{registry_ref}/artifact/{artifact}/version/{version}/docker/manifests", wrapper.GetDockerArtifactManifests)
|
|
})
|
|
r.Group(func(r chi.Router) {
|
|
r.Get(options.BaseURL+"/registry/{registry_ref}/artifact/{artifact}/version/{version}/helm/details", wrapper.GetHelmArtifactDetails)
|
|
})
|
|
r.Group(func(r chi.Router) {
|
|
r.Get(options.BaseURL+"/registry/{registry_ref}/artifact/{artifact}/version/{version}/helm/manifest", wrapper.GetHelmArtifactManifest)
|
|
})
|
|
r.Group(func(r chi.Router) {
|
|
r.Get(options.BaseURL+"/registry/{registry_ref}/artifact/{artifact}/version/{version}/summary", wrapper.GetArtifactVersionSummary)
|
|
})
|
|
r.Group(func(r chi.Router) {
|
|
r.Get(options.BaseURL+"/registry/{registry_ref}/artifact/{artifact}/versions", wrapper.GetAllArtifactVersions)
|
|
})
|
|
r.Group(func(r chi.Router) {
|
|
r.Get(options.BaseURL+"/registry/{registry_ref}/artifacts", wrapper.GetAllArtifactsByRegistry)
|
|
})
|
|
r.Group(func(r chi.Router) {
|
|
r.Get(options.BaseURL+"/registry/{registry_ref}/client-setup-details", wrapper.GetClientSetupDetails)
|
|
})
|
|
r.Group(func(r chi.Router) {
|
|
r.Get(options.BaseURL+"/spaces/{space_ref}/artifact/stats", wrapper.GetArtifactStatsForSpace)
|
|
})
|
|
r.Group(func(r chi.Router) {
|
|
r.Get(options.BaseURL+"/spaces/{space_ref}/artifacts", wrapper.GetAllArtifacts)
|
|
})
|
|
r.Group(func(r chi.Router) {
|
|
r.Get(options.BaseURL+"/spaces/{space_ref}/registries", wrapper.GetAllRegistries)
|
|
})
|
|
|
|
return r
|
|
}
|
|
|
|
type ArtifactLabelResponseJSONResponse struct {
|
|
// Data Harness Artifact Summary
|
|
Data ArtifactSummary `json:"data"`
|
|
|
|
// Status Indicates if the request was successful or not
|
|
Status Status `json:"status"`
|
|
}
|
|
|
|
type ArtifactStatsResponseJSONResponse struct {
|
|
// Data Harness Artifact Stats
|
|
Data ArtifactStats `json:"data"`
|
|
|
|
// Status Indicates if the request was successful or not
|
|
Status Status `json:"status"`
|
|
}
|
|
|
|
type ArtifactSummaryResponseJSONResponse struct {
|
|
// Data Harness Artifact Summary
|
|
Data ArtifactSummary `json:"data"`
|
|
|
|
// Status Indicates if the request was successful or not
|
|
Status Status `json:"status"`
|
|
}
|
|
|
|
type ArtifactVersionSummaryResponseJSONResponse struct {
|
|
// Data Docker Artifact Version Summary
|
|
Data ArtifactVersionSummary `json:"data"`
|
|
|
|
// Status Indicates if the request was successful or not
|
|
Status Status `json:"status"`
|
|
}
|
|
|
|
type BadRequestJSONResponse Error
|
|
|
|
type ClientSetupDetailsResponseJSONResponse struct {
|
|
// Data Client Setup Details
|
|
Data ClientSetupDetails `json:"data"`
|
|
|
|
// Status Indicates if the request was successful or not
|
|
Status Status `json:"status"`
|
|
}
|
|
|
|
type DockerArtifactDetailResponseJSONResponse struct {
|
|
// Data Docker Artifact Detail
|
|
Data DockerArtifactDetail `json:"data"`
|
|
|
|
// Status Indicates if the request was successful or not
|
|
Status Status `json:"status"`
|
|
}
|
|
|
|
type DockerArtifactManifestResponseJSONResponse struct {
|
|
// Data Docker Artifact Manifest
|
|
Data DockerArtifactManifest `json:"data"`
|
|
|
|
// Status Indicates if the request was successful or not
|
|
Status Status `json:"status"`
|
|
}
|
|
|
|
type DockerLayersResponseJSONResponse struct {
|
|
// Data Harness Layers Summary
|
|
Data DockerLayersSummary `json:"data"`
|
|
|
|
// Status Indicates if the request was successful or not
|
|
Status Status `json:"status"`
|
|
}
|
|
|
|
type DockerManifestsResponseJSONResponse struct {
|
|
// Data Harness Manifests
|
|
Data DockerManifests `json:"data"`
|
|
|
|
// Status Indicates if the request was successful or not
|
|
Status Status `json:"status"`
|
|
}
|
|
|
|
type HelmArtifactDetailResponseJSONResponse struct {
|
|
// Data Helm Artifact Detail
|
|
Data HelmArtifactDetail `json:"data"`
|
|
|
|
// Status Indicates if the request was successful or not
|
|
Status Status `json:"status"`
|
|
}
|
|
|
|
type HelmArtifactManifestResponseJSONResponse struct {
|
|
// Data Helm Artifact Manifest
|
|
Data HelmArtifactManifest `json:"data"`
|
|
|
|
// Status Indicates if the request was successful or not
|
|
Status Status `json:"status"`
|
|
}
|
|
|
|
type InternalServerErrorJSONResponse Error
|
|
|
|
type ListArtifactLabelResponseJSONResponse struct {
|
|
// Data A list of Harness Artifact Labels
|
|
Data ListArtifactLabel `json:"data"`
|
|
|
|
// Status Indicates if the request was successful or not
|
|
Status Status `json:"status"`
|
|
}
|
|
|
|
type ListArtifactResponseJSONResponse struct {
|
|
// Data A list of Artifacts
|
|
Data ListArtifact `json:"data"`
|
|
|
|
// Status Indicates if the request was successful or not
|
|
Status Status `json:"status"`
|
|
}
|
|
|
|
type ListArtifactVersionResponseJSONResponse struct {
|
|
// Data A list of Artifact versions
|
|
Data ListArtifactVersion `json:"data"`
|
|
|
|
// Status Indicates if the request was successful or not
|
|
Status Status `json:"status"`
|
|
}
|
|
|
|
type ListRegistryArtifactResponseJSONResponse struct {
|
|
// Data A list of Artifacts
|
|
Data ListRegistryArtifact `json:"data"`
|
|
|
|
// Status Indicates if the request was successful or not
|
|
Status Status `json:"status"`
|
|
}
|
|
|
|
type ListRegistryResponseJSONResponse struct {
|
|
// Data A list of Harness Artifact Registries
|
|
Data ListRegistry `json:"data"`
|
|
|
|
// Status Indicates if the request was successful or not
|
|
Status Status `json:"status"`
|
|
}
|
|
|
|
type NotFoundJSONResponse Error
|
|
|
|
type RegistryResponseJSONResponse struct {
|
|
// Data Harness Artifact Registry
|
|
Data Registry `json:"data"`
|
|
|
|
// Status Indicates if the request was successful or not
|
|
Status Status `json:"status"`
|
|
}
|
|
|
|
type SuccessJSONResponse struct {
|
|
// Status Indicates if the request was successful or not
|
|
Status Status `json:"status"`
|
|
}
|
|
|
|
type UnauthenticatedJSONResponse Error
|
|
|
|
type UnauthorizedJSONResponse Error
|
|
|
|
type CreateRegistryRequestObject struct {
|
|
Params CreateRegistryParams
|
|
Body *CreateRegistryJSONRequestBody
|
|
}
|
|
|
|
type CreateRegistryResponseObject interface {
|
|
VisitCreateRegistryResponse(w http.ResponseWriter) error
|
|
}
|
|
|
|
type CreateRegistry201JSONResponse struct{ RegistryResponseJSONResponse }
|
|
|
|
func (response CreateRegistry201JSONResponse) VisitCreateRegistryResponse(w http.ResponseWriter) error {
|
|
w.Header().Set("Content-Type", "application/json")
|
|
w.WriteHeader(201)
|
|
|
|
return json.NewEncoder(w).Encode(response)
|
|
}
|
|
|
|
type CreateRegistry400JSONResponse struct{ BadRequestJSONResponse }
|
|
|
|
func (response CreateRegistry400JSONResponse) VisitCreateRegistryResponse(w http.ResponseWriter) error {
|
|
w.Header().Set("Content-Type", "application/json")
|
|
w.WriteHeader(400)
|
|
|
|
return json.NewEncoder(w).Encode(response)
|
|
}
|
|
|
|
type CreateRegistry401JSONResponse struct{ UnauthenticatedJSONResponse }
|
|
|
|
func (response CreateRegistry401JSONResponse) VisitCreateRegistryResponse(w http.ResponseWriter) error {
|
|
w.Header().Set("Content-Type", "application/json")
|
|
w.WriteHeader(401)
|
|
|
|
return json.NewEncoder(w).Encode(response)
|
|
}
|
|
|
|
type CreateRegistry403JSONResponse struct{ UnauthorizedJSONResponse }
|
|
|
|
func (response CreateRegistry403JSONResponse) VisitCreateRegistryResponse(w http.ResponseWriter) error {
|
|
w.Header().Set("Content-Type", "application/json")
|
|
w.WriteHeader(403)
|
|
|
|
return json.NewEncoder(w).Encode(response)
|
|
}
|
|
|
|
type CreateRegistry500JSONResponse struct {
|
|
InternalServerErrorJSONResponse
|
|
}
|
|
|
|
func (response CreateRegistry500JSONResponse) VisitCreateRegistryResponse(w http.ResponseWriter) error {
|
|
w.Header().Set("Content-Type", "application/json")
|
|
w.WriteHeader(500)
|
|
|
|
return json.NewEncoder(w).Encode(response)
|
|
}
|
|
|
|
type DeleteRegistryRequestObject struct {
|
|
RegistryRef RegistryRefPathParam `json:"registry_ref"`
|
|
}
|
|
|
|
type DeleteRegistryResponseObject interface {
|
|
VisitDeleteRegistryResponse(w http.ResponseWriter) error
|
|
}
|
|
|
|
type DeleteRegistry200JSONResponse struct{ SuccessJSONResponse }
|
|
|
|
func (response DeleteRegistry200JSONResponse) VisitDeleteRegistryResponse(w http.ResponseWriter) error {
|
|
w.Header().Set("Content-Type", "application/json")
|
|
w.WriteHeader(200)
|
|
|
|
return json.NewEncoder(w).Encode(response)
|
|
}
|
|
|
|
type DeleteRegistry400JSONResponse struct{ BadRequestJSONResponse }
|
|
|
|
func (response DeleteRegistry400JSONResponse) VisitDeleteRegistryResponse(w http.ResponseWriter) error {
|
|
w.Header().Set("Content-Type", "application/json")
|
|
w.WriteHeader(400)
|
|
|
|
return json.NewEncoder(w).Encode(response)
|
|
}
|
|
|
|
type DeleteRegistry401JSONResponse struct{ UnauthenticatedJSONResponse }
|
|
|
|
func (response DeleteRegistry401JSONResponse) VisitDeleteRegistryResponse(w http.ResponseWriter) error {
|
|
w.Header().Set("Content-Type", "application/json")
|
|
w.WriteHeader(401)
|
|
|
|
return json.NewEncoder(w).Encode(response)
|
|
}
|
|
|
|
type DeleteRegistry403JSONResponse struct{ UnauthorizedJSONResponse }
|
|
|
|
func (response DeleteRegistry403JSONResponse) VisitDeleteRegistryResponse(w http.ResponseWriter) error {
|
|
w.Header().Set("Content-Type", "application/json")
|
|
w.WriteHeader(403)
|
|
|
|
return json.NewEncoder(w).Encode(response)
|
|
}
|
|
|
|
type DeleteRegistry404JSONResponse struct{ NotFoundJSONResponse }
|
|
|
|
func (response DeleteRegistry404JSONResponse) VisitDeleteRegistryResponse(w http.ResponseWriter) error {
|
|
w.Header().Set("Content-Type", "application/json")
|
|
w.WriteHeader(404)
|
|
|
|
return json.NewEncoder(w).Encode(response)
|
|
}
|
|
|
|
type DeleteRegistry500JSONResponse struct {
|
|
InternalServerErrorJSONResponse
|
|
}
|
|
|
|
func (response DeleteRegistry500JSONResponse) VisitDeleteRegistryResponse(w http.ResponseWriter) error {
|
|
w.Header().Set("Content-Type", "application/json")
|
|
w.WriteHeader(500)
|
|
|
|
return json.NewEncoder(w).Encode(response)
|
|
}
|
|
|
|
type GetRegistryRequestObject struct {
|
|
RegistryRef RegistryRefPathParam `json:"registry_ref"`
|
|
}
|
|
|
|
type GetRegistryResponseObject interface {
|
|
VisitGetRegistryResponse(w http.ResponseWriter) error
|
|
}
|
|
|
|
type GetRegistry200JSONResponse struct{ RegistryResponseJSONResponse }
|
|
|
|
func (response GetRegistry200JSONResponse) VisitGetRegistryResponse(w http.ResponseWriter) error {
|
|
w.Header().Set("Content-Type", "application/json")
|
|
w.WriteHeader(200)
|
|
|
|
return json.NewEncoder(w).Encode(response)
|
|
}
|
|
|
|
type GetRegistry400JSONResponse struct{ BadRequestJSONResponse }
|
|
|
|
func (response GetRegistry400JSONResponse) VisitGetRegistryResponse(w http.ResponseWriter) error {
|
|
w.Header().Set("Content-Type", "application/json")
|
|
w.WriteHeader(400)
|
|
|
|
return json.NewEncoder(w).Encode(response)
|
|
}
|
|
|
|
type GetRegistry401JSONResponse struct{ UnauthenticatedJSONResponse }
|
|
|
|
func (response GetRegistry401JSONResponse) VisitGetRegistryResponse(w http.ResponseWriter) error {
|
|
w.Header().Set("Content-Type", "application/json")
|
|
w.WriteHeader(401)
|
|
|
|
return json.NewEncoder(w).Encode(response)
|
|
}
|
|
|
|
type GetRegistry403JSONResponse struct{ UnauthorizedJSONResponse }
|
|
|
|
func (response GetRegistry403JSONResponse) VisitGetRegistryResponse(w http.ResponseWriter) error {
|
|
w.Header().Set("Content-Type", "application/json")
|
|
w.WriteHeader(403)
|
|
|
|
return json.NewEncoder(w).Encode(response)
|
|
}
|
|
|
|
type GetRegistry404JSONResponse struct{ NotFoundJSONResponse }
|
|
|
|
func (response GetRegistry404JSONResponse) VisitGetRegistryResponse(w http.ResponseWriter) error {
|
|
w.Header().Set("Content-Type", "application/json")
|
|
w.WriteHeader(404)
|
|
|
|
return json.NewEncoder(w).Encode(response)
|
|
}
|
|
|
|
type GetRegistry500JSONResponse struct {
|
|
InternalServerErrorJSONResponse
|
|
}
|
|
|
|
func (response GetRegistry500JSONResponse) VisitGetRegistryResponse(w http.ResponseWriter) error {
|
|
w.Header().Set("Content-Type", "application/json")
|
|
w.WriteHeader(500)
|
|
|
|
return json.NewEncoder(w).Encode(response)
|
|
}
|
|
|
|
type ModifyRegistryRequestObject struct {
|
|
RegistryRef RegistryRefPathParam `json:"registry_ref"`
|
|
Body *ModifyRegistryJSONRequestBody
|
|
}
|
|
|
|
type ModifyRegistryResponseObject interface {
|
|
VisitModifyRegistryResponse(w http.ResponseWriter) error
|
|
}
|
|
|
|
type ModifyRegistry200JSONResponse struct{ RegistryResponseJSONResponse }
|
|
|
|
func (response ModifyRegistry200JSONResponse) VisitModifyRegistryResponse(w http.ResponseWriter) error {
|
|
w.Header().Set("Content-Type", "application/json")
|
|
w.WriteHeader(200)
|
|
|
|
return json.NewEncoder(w).Encode(response)
|
|
}
|
|
|
|
type ModifyRegistry400JSONResponse struct{ BadRequestJSONResponse }
|
|
|
|
func (response ModifyRegistry400JSONResponse) VisitModifyRegistryResponse(w http.ResponseWriter) error {
|
|
w.Header().Set("Content-Type", "application/json")
|
|
w.WriteHeader(400)
|
|
|
|
return json.NewEncoder(w).Encode(response)
|
|
}
|
|
|
|
type ModifyRegistry401JSONResponse struct{ UnauthenticatedJSONResponse }
|
|
|
|
func (response ModifyRegistry401JSONResponse) VisitModifyRegistryResponse(w http.ResponseWriter) error {
|
|
w.Header().Set("Content-Type", "application/json")
|
|
w.WriteHeader(401)
|
|
|
|
return json.NewEncoder(w).Encode(response)
|
|
}
|
|
|
|
type ModifyRegistry403JSONResponse struct{ UnauthorizedJSONResponse }
|
|
|
|
func (response ModifyRegistry403JSONResponse) VisitModifyRegistryResponse(w http.ResponseWriter) error {
|
|
w.Header().Set("Content-Type", "application/json")
|
|
w.WriteHeader(403)
|
|
|
|
return json.NewEncoder(w).Encode(response)
|
|
}
|
|
|
|
type ModifyRegistry404JSONResponse struct{ NotFoundJSONResponse }
|
|
|
|
func (response ModifyRegistry404JSONResponse) VisitModifyRegistryResponse(w http.ResponseWriter) error {
|
|
w.Header().Set("Content-Type", "application/json")
|
|
w.WriteHeader(404)
|
|
|
|
return json.NewEncoder(w).Encode(response)
|
|
}
|
|
|
|
type ModifyRegistry500JSONResponse struct {
|
|
InternalServerErrorJSONResponse
|
|
}
|
|
|
|
func (response ModifyRegistry500JSONResponse) VisitModifyRegistryResponse(w http.ResponseWriter) error {
|
|
w.Header().Set("Content-Type", "application/json")
|
|
w.WriteHeader(500)
|
|
|
|
return json.NewEncoder(w).Encode(response)
|
|
}
|
|
|
|
type ListArtifactLabelsRequestObject struct {
|
|
RegistryRef RegistryRefPathParam `json:"registry_ref"`
|
|
Params ListArtifactLabelsParams
|
|
}
|
|
|
|
type ListArtifactLabelsResponseObject interface {
|
|
VisitListArtifactLabelsResponse(w http.ResponseWriter) error
|
|
}
|
|
|
|
type ListArtifactLabels200JSONResponse struct {
|
|
ListArtifactLabelResponseJSONResponse
|
|
}
|
|
|
|
func (response ListArtifactLabels200JSONResponse) VisitListArtifactLabelsResponse(w http.ResponseWriter) error {
|
|
w.Header().Set("Content-Type", "application/json")
|
|
w.WriteHeader(200)
|
|
|
|
return json.NewEncoder(w).Encode(response)
|
|
}
|
|
|
|
type ListArtifactLabels400JSONResponse struct{ BadRequestJSONResponse }
|
|
|
|
func (response ListArtifactLabels400JSONResponse) VisitListArtifactLabelsResponse(w http.ResponseWriter) error {
|
|
w.Header().Set("Content-Type", "application/json")
|
|
w.WriteHeader(400)
|
|
|
|
return json.NewEncoder(w).Encode(response)
|
|
}
|
|
|
|
type ListArtifactLabels401JSONResponse struct{ UnauthenticatedJSONResponse }
|
|
|
|
func (response ListArtifactLabels401JSONResponse) VisitListArtifactLabelsResponse(w http.ResponseWriter) error {
|
|
w.Header().Set("Content-Type", "application/json")
|
|
w.WriteHeader(401)
|
|
|
|
return json.NewEncoder(w).Encode(response)
|
|
}
|
|
|
|
type ListArtifactLabels403JSONResponse struct{ UnauthorizedJSONResponse }
|
|
|
|
func (response ListArtifactLabels403JSONResponse) VisitListArtifactLabelsResponse(w http.ResponseWriter) error {
|
|
w.Header().Set("Content-Type", "application/json")
|
|
w.WriteHeader(403)
|
|
|
|
return json.NewEncoder(w).Encode(response)
|
|
}
|
|
|
|
type ListArtifactLabels404JSONResponse struct{ NotFoundJSONResponse }
|
|
|
|
func (response ListArtifactLabels404JSONResponse) VisitListArtifactLabelsResponse(w http.ResponseWriter) error {
|
|
w.Header().Set("Content-Type", "application/json")
|
|
w.WriteHeader(404)
|
|
|
|
return json.NewEncoder(w).Encode(response)
|
|
}
|
|
|
|
type ListArtifactLabels500JSONResponse struct {
|
|
InternalServerErrorJSONResponse
|
|
}
|
|
|
|
func (response ListArtifactLabels500JSONResponse) VisitListArtifactLabelsResponse(w http.ResponseWriter) error {
|
|
w.Header().Set("Content-Type", "application/json")
|
|
w.WriteHeader(500)
|
|
|
|
return json.NewEncoder(w).Encode(response)
|
|
}
|
|
|
|
type GetArtifactStatsForRegistryRequestObject struct {
|
|
RegistryRef RegistryRefPathParam `json:"registry_ref"`
|
|
Params GetArtifactStatsForRegistryParams
|
|
}
|
|
|
|
type GetArtifactStatsForRegistryResponseObject interface {
|
|
VisitGetArtifactStatsForRegistryResponse(w http.ResponseWriter) error
|
|
}
|
|
|
|
type GetArtifactStatsForRegistry200JSONResponse struct {
|
|
ArtifactStatsResponseJSONResponse
|
|
}
|
|
|
|
func (response GetArtifactStatsForRegistry200JSONResponse) VisitGetArtifactStatsForRegistryResponse(w http.ResponseWriter) error {
|
|
w.Header().Set("Content-Type", "application/json")
|
|
w.WriteHeader(200)
|
|
|
|
return json.NewEncoder(w).Encode(response)
|
|
}
|
|
|
|
type GetArtifactStatsForRegistry400JSONResponse struct{ BadRequestJSONResponse }
|
|
|
|
func (response GetArtifactStatsForRegistry400JSONResponse) VisitGetArtifactStatsForRegistryResponse(w http.ResponseWriter) error {
|
|
w.Header().Set("Content-Type", "application/json")
|
|
w.WriteHeader(400)
|
|
|
|
return json.NewEncoder(w).Encode(response)
|
|
}
|
|
|
|
type GetArtifactStatsForRegistry401JSONResponse struct{ UnauthenticatedJSONResponse }
|
|
|
|
func (response GetArtifactStatsForRegistry401JSONResponse) VisitGetArtifactStatsForRegistryResponse(w http.ResponseWriter) error {
|
|
w.Header().Set("Content-Type", "application/json")
|
|
w.WriteHeader(401)
|
|
|
|
return json.NewEncoder(w).Encode(response)
|
|
}
|
|
|
|
type GetArtifactStatsForRegistry403JSONResponse struct{ UnauthorizedJSONResponse }
|
|
|
|
func (response GetArtifactStatsForRegistry403JSONResponse) VisitGetArtifactStatsForRegistryResponse(w http.ResponseWriter) error {
|
|
w.Header().Set("Content-Type", "application/json")
|
|
w.WriteHeader(403)
|
|
|
|
return json.NewEncoder(w).Encode(response)
|
|
}
|
|
|
|
type GetArtifactStatsForRegistry404JSONResponse struct{ NotFoundJSONResponse }
|
|
|
|
func (response GetArtifactStatsForRegistry404JSONResponse) VisitGetArtifactStatsForRegistryResponse(w http.ResponseWriter) error {
|
|
w.Header().Set("Content-Type", "application/json")
|
|
w.WriteHeader(404)
|
|
|
|
return json.NewEncoder(w).Encode(response)
|
|
}
|
|
|
|
type GetArtifactStatsForRegistry500JSONResponse struct {
|
|
InternalServerErrorJSONResponse
|
|
}
|
|
|
|
func (response GetArtifactStatsForRegistry500JSONResponse) VisitGetArtifactStatsForRegistryResponse(w http.ResponseWriter) error {
|
|
w.Header().Set("Content-Type", "application/json")
|
|
w.WriteHeader(500)
|
|
|
|
return json.NewEncoder(w).Encode(response)
|
|
}
|
|
|
|
type DeleteArtifactRequestObject struct {
|
|
RegistryRef RegistryRefPathParam `json:"registry_ref"`
|
|
Artifact ArtifactPathParam `json:"artifact"`
|
|
}
|
|
|
|
type DeleteArtifactResponseObject interface {
|
|
VisitDeleteArtifactResponse(w http.ResponseWriter) error
|
|
}
|
|
|
|
type DeleteArtifact200JSONResponse struct{ SuccessJSONResponse }
|
|
|
|
func (response DeleteArtifact200JSONResponse) VisitDeleteArtifactResponse(w http.ResponseWriter) error {
|
|
w.Header().Set("Content-Type", "application/json")
|
|
w.WriteHeader(200)
|
|
|
|
return json.NewEncoder(w).Encode(response)
|
|
}
|
|
|
|
type DeleteArtifact400JSONResponse struct{ BadRequestJSONResponse }
|
|
|
|
func (response DeleteArtifact400JSONResponse) VisitDeleteArtifactResponse(w http.ResponseWriter) error {
|
|
w.Header().Set("Content-Type", "application/json")
|
|
w.WriteHeader(400)
|
|
|
|
return json.NewEncoder(w).Encode(response)
|
|
}
|
|
|
|
type DeleteArtifact401JSONResponse struct{ UnauthenticatedJSONResponse }
|
|
|
|
func (response DeleteArtifact401JSONResponse) VisitDeleteArtifactResponse(w http.ResponseWriter) error {
|
|
w.Header().Set("Content-Type", "application/json")
|
|
w.WriteHeader(401)
|
|
|
|
return json.NewEncoder(w).Encode(response)
|
|
}
|
|
|
|
type DeleteArtifact403JSONResponse struct{ UnauthorizedJSONResponse }
|
|
|
|
func (response DeleteArtifact403JSONResponse) VisitDeleteArtifactResponse(w http.ResponseWriter) error {
|
|
w.Header().Set("Content-Type", "application/json")
|
|
w.WriteHeader(403)
|
|
|
|
return json.NewEncoder(w).Encode(response)
|
|
}
|
|
|
|
type DeleteArtifact404JSONResponse struct{ NotFoundJSONResponse }
|
|
|
|
func (response DeleteArtifact404JSONResponse) VisitDeleteArtifactResponse(w http.ResponseWriter) error {
|
|
w.Header().Set("Content-Type", "application/json")
|
|
w.WriteHeader(404)
|
|
|
|
return json.NewEncoder(w).Encode(response)
|
|
}
|
|
|
|
type DeleteArtifact500JSONResponse struct {
|
|
InternalServerErrorJSONResponse
|
|
}
|
|
|
|
func (response DeleteArtifact500JSONResponse) VisitDeleteArtifactResponse(w http.ResponseWriter) error {
|
|
w.Header().Set("Content-Type", "application/json")
|
|
w.WriteHeader(500)
|
|
|
|
return json.NewEncoder(w).Encode(response)
|
|
}
|
|
|
|
type UpdateArtifactLabelsRequestObject struct {
|
|
RegistryRef RegistryRefPathParam `json:"registry_ref"`
|
|
Artifact ArtifactPathParam `json:"artifact"`
|
|
Body *UpdateArtifactLabelsJSONRequestBody
|
|
}
|
|
|
|
type UpdateArtifactLabelsResponseObject interface {
|
|
VisitUpdateArtifactLabelsResponse(w http.ResponseWriter) error
|
|
}
|
|
|
|
type UpdateArtifactLabels200JSONResponse struct {
|
|
ArtifactLabelResponseJSONResponse
|
|
}
|
|
|
|
func (response UpdateArtifactLabels200JSONResponse) VisitUpdateArtifactLabelsResponse(w http.ResponseWriter) error {
|
|
w.Header().Set("Content-Type", "application/json")
|
|
w.WriteHeader(200)
|
|
|
|
return json.NewEncoder(w).Encode(response)
|
|
}
|
|
|
|
type UpdateArtifactLabels400JSONResponse struct{ BadRequestJSONResponse }
|
|
|
|
func (response UpdateArtifactLabels400JSONResponse) VisitUpdateArtifactLabelsResponse(w http.ResponseWriter) error {
|
|
w.Header().Set("Content-Type", "application/json")
|
|
w.WriteHeader(400)
|
|
|
|
return json.NewEncoder(w).Encode(response)
|
|
}
|
|
|
|
type UpdateArtifactLabels401JSONResponse struct{ UnauthenticatedJSONResponse }
|
|
|
|
func (response UpdateArtifactLabels401JSONResponse) VisitUpdateArtifactLabelsResponse(w http.ResponseWriter) error {
|
|
w.Header().Set("Content-Type", "application/json")
|
|
w.WriteHeader(401)
|
|
|
|
return json.NewEncoder(w).Encode(response)
|
|
}
|
|
|
|
type UpdateArtifactLabels403JSONResponse struct{ UnauthorizedJSONResponse }
|
|
|
|
func (response UpdateArtifactLabels403JSONResponse) VisitUpdateArtifactLabelsResponse(w http.ResponseWriter) error {
|
|
w.Header().Set("Content-Type", "application/json")
|
|
w.WriteHeader(403)
|
|
|
|
return json.NewEncoder(w).Encode(response)
|
|
}
|
|
|
|
type UpdateArtifactLabels404JSONResponse struct{ NotFoundJSONResponse }
|
|
|
|
func (response UpdateArtifactLabels404JSONResponse) VisitUpdateArtifactLabelsResponse(w http.ResponseWriter) error {
|
|
w.Header().Set("Content-Type", "application/json")
|
|
w.WriteHeader(404)
|
|
|
|
return json.NewEncoder(w).Encode(response)
|
|
}
|
|
|
|
type UpdateArtifactLabels500JSONResponse struct {
|
|
InternalServerErrorJSONResponse
|
|
}
|
|
|
|
func (response UpdateArtifactLabels500JSONResponse) VisitUpdateArtifactLabelsResponse(w http.ResponseWriter) error {
|
|
w.Header().Set("Content-Type", "application/json")
|
|
w.WriteHeader(500)
|
|
|
|
return json.NewEncoder(w).Encode(response)
|
|
}
|
|
|
|
type GetArtifactStatsRequestObject struct {
|
|
RegistryRef RegistryRefPathParam `json:"registry_ref"`
|
|
Artifact ArtifactPathParam `json:"artifact"`
|
|
Params GetArtifactStatsParams
|
|
}
|
|
|
|
type GetArtifactStatsResponseObject interface {
|
|
VisitGetArtifactStatsResponse(w http.ResponseWriter) error
|
|
}
|
|
|
|
type GetArtifactStats200JSONResponse struct {
|
|
ArtifactStatsResponseJSONResponse
|
|
}
|
|
|
|
func (response GetArtifactStats200JSONResponse) VisitGetArtifactStatsResponse(w http.ResponseWriter) error {
|
|
w.Header().Set("Content-Type", "application/json")
|
|
w.WriteHeader(200)
|
|
|
|
return json.NewEncoder(w).Encode(response)
|
|
}
|
|
|
|
type GetArtifactStats400JSONResponse struct{ BadRequestJSONResponse }
|
|
|
|
func (response GetArtifactStats400JSONResponse) VisitGetArtifactStatsResponse(w http.ResponseWriter) error {
|
|
w.Header().Set("Content-Type", "application/json")
|
|
w.WriteHeader(400)
|
|
|
|
return json.NewEncoder(w).Encode(response)
|
|
}
|
|
|
|
type GetArtifactStats401JSONResponse struct{ UnauthenticatedJSONResponse }
|
|
|
|
func (response GetArtifactStats401JSONResponse) VisitGetArtifactStatsResponse(w http.ResponseWriter) error {
|
|
w.Header().Set("Content-Type", "application/json")
|
|
w.WriteHeader(401)
|
|
|
|
return json.NewEncoder(w).Encode(response)
|
|
}
|
|
|
|
type GetArtifactStats403JSONResponse struct{ UnauthorizedJSONResponse }
|
|
|
|
func (response GetArtifactStats403JSONResponse) VisitGetArtifactStatsResponse(w http.ResponseWriter) error {
|
|
w.Header().Set("Content-Type", "application/json")
|
|
w.WriteHeader(403)
|
|
|
|
return json.NewEncoder(w).Encode(response)
|
|
}
|
|
|
|
type GetArtifactStats404JSONResponse struct{ NotFoundJSONResponse }
|
|
|
|
func (response GetArtifactStats404JSONResponse) VisitGetArtifactStatsResponse(w http.ResponseWriter) error {
|
|
w.Header().Set("Content-Type", "application/json")
|
|
w.WriteHeader(404)
|
|
|
|
return json.NewEncoder(w).Encode(response)
|
|
}
|
|
|
|
type GetArtifactStats500JSONResponse struct {
|
|
InternalServerErrorJSONResponse
|
|
}
|
|
|
|
func (response GetArtifactStats500JSONResponse) VisitGetArtifactStatsResponse(w http.ResponseWriter) error {
|
|
w.Header().Set("Content-Type", "application/json")
|
|
w.WriteHeader(500)
|
|
|
|
return json.NewEncoder(w).Encode(response)
|
|
}
|
|
|
|
type GetArtifactSummaryRequestObject struct {
|
|
RegistryRef RegistryRefPathParam `json:"registry_ref"`
|
|
Artifact ArtifactPathParam `json:"artifact"`
|
|
}
|
|
|
|
type GetArtifactSummaryResponseObject interface {
|
|
VisitGetArtifactSummaryResponse(w http.ResponseWriter) error
|
|
}
|
|
|
|
type GetArtifactSummary200JSONResponse struct {
|
|
ArtifactSummaryResponseJSONResponse
|
|
}
|
|
|
|
func (response GetArtifactSummary200JSONResponse) VisitGetArtifactSummaryResponse(w http.ResponseWriter) error {
|
|
w.Header().Set("Content-Type", "application/json")
|
|
w.WriteHeader(200)
|
|
|
|
return json.NewEncoder(w).Encode(response)
|
|
}
|
|
|
|
type GetArtifactSummary400JSONResponse struct{ BadRequestJSONResponse }
|
|
|
|
func (response GetArtifactSummary400JSONResponse) VisitGetArtifactSummaryResponse(w http.ResponseWriter) error {
|
|
w.Header().Set("Content-Type", "application/json")
|
|
w.WriteHeader(400)
|
|
|
|
return json.NewEncoder(w).Encode(response)
|
|
}
|
|
|
|
type GetArtifactSummary401JSONResponse struct{ UnauthenticatedJSONResponse }
|
|
|
|
func (response GetArtifactSummary401JSONResponse) VisitGetArtifactSummaryResponse(w http.ResponseWriter) error {
|
|
w.Header().Set("Content-Type", "application/json")
|
|
w.WriteHeader(401)
|
|
|
|
return json.NewEncoder(w).Encode(response)
|
|
}
|
|
|
|
type GetArtifactSummary403JSONResponse struct{ UnauthorizedJSONResponse }
|
|
|
|
func (response GetArtifactSummary403JSONResponse) VisitGetArtifactSummaryResponse(w http.ResponseWriter) error {
|
|
w.Header().Set("Content-Type", "application/json")
|
|
w.WriteHeader(403)
|
|
|
|
return json.NewEncoder(w).Encode(response)
|
|
}
|
|
|
|
type GetArtifactSummary404JSONResponse struct{ NotFoundJSONResponse }
|
|
|
|
func (response GetArtifactSummary404JSONResponse) VisitGetArtifactSummaryResponse(w http.ResponseWriter) error {
|
|
w.Header().Set("Content-Type", "application/json")
|
|
w.WriteHeader(404)
|
|
|
|
return json.NewEncoder(w).Encode(response)
|
|
}
|
|
|
|
type GetArtifactSummary500JSONResponse struct {
|
|
InternalServerErrorJSONResponse
|
|
}
|
|
|
|
func (response GetArtifactSummary500JSONResponse) VisitGetArtifactSummaryResponse(w http.ResponseWriter) error {
|
|
w.Header().Set("Content-Type", "application/json")
|
|
w.WriteHeader(500)
|
|
|
|
return json.NewEncoder(w).Encode(response)
|
|
}
|
|
|
|
type DeleteArtifactVersionRequestObject struct {
|
|
RegistryRef RegistryRefPathParam `json:"registry_ref"`
|
|
Artifact ArtifactPathParam `json:"artifact"`
|
|
Version VersionPathParam `json:"version"`
|
|
}
|
|
|
|
type DeleteArtifactVersionResponseObject interface {
|
|
VisitDeleteArtifactVersionResponse(w http.ResponseWriter) error
|
|
}
|
|
|
|
type DeleteArtifactVersion200JSONResponse struct{ SuccessJSONResponse }
|
|
|
|
func (response DeleteArtifactVersion200JSONResponse) VisitDeleteArtifactVersionResponse(w http.ResponseWriter) error {
|
|
w.Header().Set("Content-Type", "application/json")
|
|
w.WriteHeader(200)
|
|
|
|
return json.NewEncoder(w).Encode(response)
|
|
}
|
|
|
|
type DeleteArtifactVersion400JSONResponse struct{ BadRequestJSONResponse }
|
|
|
|
func (response DeleteArtifactVersion400JSONResponse) VisitDeleteArtifactVersionResponse(w http.ResponseWriter) error {
|
|
w.Header().Set("Content-Type", "application/json")
|
|
w.WriteHeader(400)
|
|
|
|
return json.NewEncoder(w).Encode(response)
|
|
}
|
|
|
|
type DeleteArtifactVersion401JSONResponse struct{ UnauthenticatedJSONResponse }
|
|
|
|
func (response DeleteArtifactVersion401JSONResponse) VisitDeleteArtifactVersionResponse(w http.ResponseWriter) error {
|
|
w.Header().Set("Content-Type", "application/json")
|
|
w.WriteHeader(401)
|
|
|
|
return json.NewEncoder(w).Encode(response)
|
|
}
|
|
|
|
type DeleteArtifactVersion403JSONResponse struct{ UnauthorizedJSONResponse }
|
|
|
|
func (response DeleteArtifactVersion403JSONResponse) VisitDeleteArtifactVersionResponse(w http.ResponseWriter) error {
|
|
w.Header().Set("Content-Type", "application/json")
|
|
w.WriteHeader(403)
|
|
|
|
return json.NewEncoder(w).Encode(response)
|
|
}
|
|
|
|
type DeleteArtifactVersion404JSONResponse struct{ NotFoundJSONResponse }
|
|
|
|
func (response DeleteArtifactVersion404JSONResponse) VisitDeleteArtifactVersionResponse(w http.ResponseWriter) error {
|
|
w.Header().Set("Content-Type", "application/json")
|
|
w.WriteHeader(404)
|
|
|
|
return json.NewEncoder(w).Encode(response)
|
|
}
|
|
|
|
type DeleteArtifactVersion500JSONResponse struct {
|
|
InternalServerErrorJSONResponse
|
|
}
|
|
|
|
func (response DeleteArtifactVersion500JSONResponse) VisitDeleteArtifactVersionResponse(w http.ResponseWriter) error {
|
|
w.Header().Set("Content-Type", "application/json")
|
|
w.WriteHeader(500)
|
|
|
|
return json.NewEncoder(w).Encode(response)
|
|
}
|
|
|
|
type GetDockerArtifactDetailsRequestObject struct {
|
|
RegistryRef RegistryRefPathParam `json:"registry_ref"`
|
|
Artifact ArtifactPathParam `json:"artifact"`
|
|
Version VersionPathParam `json:"version"`
|
|
Params GetDockerArtifactDetailsParams
|
|
}
|
|
|
|
type GetDockerArtifactDetailsResponseObject interface {
|
|
VisitGetDockerArtifactDetailsResponse(w http.ResponseWriter) error
|
|
}
|
|
|
|
type GetDockerArtifactDetails200JSONResponse struct {
|
|
DockerArtifactDetailResponseJSONResponse
|
|
}
|
|
|
|
func (response GetDockerArtifactDetails200JSONResponse) VisitGetDockerArtifactDetailsResponse(w http.ResponseWriter) error {
|
|
w.Header().Set("Content-Type", "application/json")
|
|
w.WriteHeader(200)
|
|
|
|
return json.NewEncoder(w).Encode(response)
|
|
}
|
|
|
|
type GetDockerArtifactDetails400JSONResponse struct{ BadRequestJSONResponse }
|
|
|
|
func (response GetDockerArtifactDetails400JSONResponse) VisitGetDockerArtifactDetailsResponse(w http.ResponseWriter) error {
|
|
w.Header().Set("Content-Type", "application/json")
|
|
w.WriteHeader(400)
|
|
|
|
return json.NewEncoder(w).Encode(response)
|
|
}
|
|
|
|
type GetDockerArtifactDetails401JSONResponse struct{ UnauthenticatedJSONResponse }
|
|
|
|
func (response GetDockerArtifactDetails401JSONResponse) VisitGetDockerArtifactDetailsResponse(w http.ResponseWriter) error {
|
|
w.Header().Set("Content-Type", "application/json")
|
|
w.WriteHeader(401)
|
|
|
|
return json.NewEncoder(w).Encode(response)
|
|
}
|
|
|
|
type GetDockerArtifactDetails403JSONResponse struct{ UnauthorizedJSONResponse }
|
|
|
|
func (response GetDockerArtifactDetails403JSONResponse) VisitGetDockerArtifactDetailsResponse(w http.ResponseWriter) error {
|
|
w.Header().Set("Content-Type", "application/json")
|
|
w.WriteHeader(403)
|
|
|
|
return json.NewEncoder(w).Encode(response)
|
|
}
|
|
|
|
type GetDockerArtifactDetails404JSONResponse struct{ NotFoundJSONResponse }
|
|
|
|
func (response GetDockerArtifactDetails404JSONResponse) VisitGetDockerArtifactDetailsResponse(w http.ResponseWriter) error {
|
|
w.Header().Set("Content-Type", "application/json")
|
|
w.WriteHeader(404)
|
|
|
|
return json.NewEncoder(w).Encode(response)
|
|
}
|
|
|
|
type GetDockerArtifactDetails500JSONResponse struct {
|
|
InternalServerErrorJSONResponse
|
|
}
|
|
|
|
func (response GetDockerArtifactDetails500JSONResponse) VisitGetDockerArtifactDetailsResponse(w http.ResponseWriter) error {
|
|
w.Header().Set("Content-Type", "application/json")
|
|
w.WriteHeader(500)
|
|
|
|
return json.NewEncoder(w).Encode(response)
|
|
}
|
|
|
|
type GetDockerArtifactLayersRequestObject struct {
|
|
RegistryRef RegistryRefPathParam `json:"registry_ref"`
|
|
Artifact ArtifactPathParam `json:"artifact"`
|
|
Version VersionPathParam `json:"version"`
|
|
Params GetDockerArtifactLayersParams
|
|
}
|
|
|
|
type GetDockerArtifactLayersResponseObject interface {
|
|
VisitGetDockerArtifactLayersResponse(w http.ResponseWriter) error
|
|
}
|
|
|
|
type GetDockerArtifactLayers200JSONResponse struct {
|
|
DockerLayersResponseJSONResponse
|
|
}
|
|
|
|
func (response GetDockerArtifactLayers200JSONResponse) VisitGetDockerArtifactLayersResponse(w http.ResponseWriter) error {
|
|
w.Header().Set("Content-Type", "application/json")
|
|
w.WriteHeader(200)
|
|
|
|
return json.NewEncoder(w).Encode(response)
|
|
}
|
|
|
|
type GetDockerArtifactLayers400JSONResponse struct{ BadRequestJSONResponse }
|
|
|
|
func (response GetDockerArtifactLayers400JSONResponse) VisitGetDockerArtifactLayersResponse(w http.ResponseWriter) error {
|
|
w.Header().Set("Content-Type", "application/json")
|
|
w.WriteHeader(400)
|
|
|
|
return json.NewEncoder(w).Encode(response)
|
|
}
|
|
|
|
type GetDockerArtifactLayers401JSONResponse struct{ UnauthenticatedJSONResponse }
|
|
|
|
func (response GetDockerArtifactLayers401JSONResponse) VisitGetDockerArtifactLayersResponse(w http.ResponseWriter) error {
|
|
w.Header().Set("Content-Type", "application/json")
|
|
w.WriteHeader(401)
|
|
|
|
return json.NewEncoder(w).Encode(response)
|
|
}
|
|
|
|
type GetDockerArtifactLayers403JSONResponse struct{ UnauthorizedJSONResponse }
|
|
|
|
func (response GetDockerArtifactLayers403JSONResponse) VisitGetDockerArtifactLayersResponse(w http.ResponseWriter) error {
|
|
w.Header().Set("Content-Type", "application/json")
|
|
w.WriteHeader(403)
|
|
|
|
return json.NewEncoder(w).Encode(response)
|
|
}
|
|
|
|
type GetDockerArtifactLayers404JSONResponse struct{ NotFoundJSONResponse }
|
|
|
|
func (response GetDockerArtifactLayers404JSONResponse) VisitGetDockerArtifactLayersResponse(w http.ResponseWriter) error {
|
|
w.Header().Set("Content-Type", "application/json")
|
|
w.WriteHeader(404)
|
|
|
|
return json.NewEncoder(w).Encode(response)
|
|
}
|
|
|
|
type GetDockerArtifactLayers500JSONResponse struct {
|
|
InternalServerErrorJSONResponse
|
|
}
|
|
|
|
func (response GetDockerArtifactLayers500JSONResponse) VisitGetDockerArtifactLayersResponse(w http.ResponseWriter) error {
|
|
w.Header().Set("Content-Type", "application/json")
|
|
w.WriteHeader(500)
|
|
|
|
return json.NewEncoder(w).Encode(response)
|
|
}
|
|
|
|
type GetDockerArtifactManifestRequestObject struct {
|
|
RegistryRef RegistryRefPathParam `json:"registry_ref"`
|
|
Artifact ArtifactPathParam `json:"artifact"`
|
|
Version VersionPathParam `json:"version"`
|
|
Params GetDockerArtifactManifestParams
|
|
}
|
|
|
|
type GetDockerArtifactManifestResponseObject interface {
|
|
VisitGetDockerArtifactManifestResponse(w http.ResponseWriter) error
|
|
}
|
|
|
|
type GetDockerArtifactManifest200JSONResponse struct {
|
|
DockerArtifactManifestResponseJSONResponse
|
|
}
|
|
|
|
func (response GetDockerArtifactManifest200JSONResponse) VisitGetDockerArtifactManifestResponse(w http.ResponseWriter) error {
|
|
w.Header().Set("Content-Type", "application/json")
|
|
w.WriteHeader(200)
|
|
|
|
return json.NewEncoder(w).Encode(response)
|
|
}
|
|
|
|
type GetDockerArtifactManifest400JSONResponse struct{ BadRequestJSONResponse }
|
|
|
|
func (response GetDockerArtifactManifest400JSONResponse) VisitGetDockerArtifactManifestResponse(w http.ResponseWriter) error {
|
|
w.Header().Set("Content-Type", "application/json")
|
|
w.WriteHeader(400)
|
|
|
|
return json.NewEncoder(w).Encode(response)
|
|
}
|
|
|
|
type GetDockerArtifactManifest401JSONResponse struct{ UnauthenticatedJSONResponse }
|
|
|
|
func (response GetDockerArtifactManifest401JSONResponse) VisitGetDockerArtifactManifestResponse(w http.ResponseWriter) error {
|
|
w.Header().Set("Content-Type", "application/json")
|
|
w.WriteHeader(401)
|
|
|
|
return json.NewEncoder(w).Encode(response)
|
|
}
|
|
|
|
type GetDockerArtifactManifest403JSONResponse struct{ UnauthorizedJSONResponse }
|
|
|
|
func (response GetDockerArtifactManifest403JSONResponse) VisitGetDockerArtifactManifestResponse(w http.ResponseWriter) error {
|
|
w.Header().Set("Content-Type", "application/json")
|
|
w.WriteHeader(403)
|
|
|
|
return json.NewEncoder(w).Encode(response)
|
|
}
|
|
|
|
type GetDockerArtifactManifest404JSONResponse struct{ NotFoundJSONResponse }
|
|
|
|
func (response GetDockerArtifactManifest404JSONResponse) VisitGetDockerArtifactManifestResponse(w http.ResponseWriter) error {
|
|
w.Header().Set("Content-Type", "application/json")
|
|
w.WriteHeader(404)
|
|
|
|
return json.NewEncoder(w).Encode(response)
|
|
}
|
|
|
|
type GetDockerArtifactManifest500JSONResponse struct {
|
|
InternalServerErrorJSONResponse
|
|
}
|
|
|
|
func (response GetDockerArtifactManifest500JSONResponse) VisitGetDockerArtifactManifestResponse(w http.ResponseWriter) error {
|
|
w.Header().Set("Content-Type", "application/json")
|
|
w.WriteHeader(500)
|
|
|
|
return json.NewEncoder(w).Encode(response)
|
|
}
|
|
|
|
type GetDockerArtifactManifestsRequestObject struct {
|
|
RegistryRef RegistryRefPathParam `json:"registry_ref"`
|
|
Artifact ArtifactPathParam `json:"artifact"`
|
|
Version VersionPathParam `json:"version"`
|
|
}
|
|
|
|
type GetDockerArtifactManifestsResponseObject interface {
|
|
VisitGetDockerArtifactManifestsResponse(w http.ResponseWriter) error
|
|
}
|
|
|
|
type GetDockerArtifactManifests200JSONResponse struct {
|
|
DockerManifestsResponseJSONResponse
|
|
}
|
|
|
|
func (response GetDockerArtifactManifests200JSONResponse) VisitGetDockerArtifactManifestsResponse(w http.ResponseWriter) error {
|
|
w.Header().Set("Content-Type", "application/json")
|
|
w.WriteHeader(200)
|
|
|
|
return json.NewEncoder(w).Encode(response)
|
|
}
|
|
|
|
type GetDockerArtifactManifests400JSONResponse struct{ BadRequestJSONResponse }
|
|
|
|
func (response GetDockerArtifactManifests400JSONResponse) VisitGetDockerArtifactManifestsResponse(w http.ResponseWriter) error {
|
|
w.Header().Set("Content-Type", "application/json")
|
|
w.WriteHeader(400)
|
|
|
|
return json.NewEncoder(w).Encode(response)
|
|
}
|
|
|
|
type GetDockerArtifactManifests401JSONResponse struct{ UnauthenticatedJSONResponse }
|
|
|
|
func (response GetDockerArtifactManifests401JSONResponse) VisitGetDockerArtifactManifestsResponse(w http.ResponseWriter) error {
|
|
w.Header().Set("Content-Type", "application/json")
|
|
w.WriteHeader(401)
|
|
|
|
return json.NewEncoder(w).Encode(response)
|
|
}
|
|
|
|
type GetDockerArtifactManifests403JSONResponse struct{ UnauthorizedJSONResponse }
|
|
|
|
func (response GetDockerArtifactManifests403JSONResponse) VisitGetDockerArtifactManifestsResponse(w http.ResponseWriter) error {
|
|
w.Header().Set("Content-Type", "application/json")
|
|
w.WriteHeader(403)
|
|
|
|
return json.NewEncoder(w).Encode(response)
|
|
}
|
|
|
|
type GetDockerArtifactManifests404JSONResponse struct{ NotFoundJSONResponse }
|
|
|
|
func (response GetDockerArtifactManifests404JSONResponse) VisitGetDockerArtifactManifestsResponse(w http.ResponseWriter) error {
|
|
w.Header().Set("Content-Type", "application/json")
|
|
w.WriteHeader(404)
|
|
|
|
return json.NewEncoder(w).Encode(response)
|
|
}
|
|
|
|
type GetDockerArtifactManifests500JSONResponse struct {
|
|
InternalServerErrorJSONResponse
|
|
}
|
|
|
|
func (response GetDockerArtifactManifests500JSONResponse) VisitGetDockerArtifactManifestsResponse(w http.ResponseWriter) error {
|
|
w.Header().Set("Content-Type", "application/json")
|
|
w.WriteHeader(500)
|
|
|
|
return json.NewEncoder(w).Encode(response)
|
|
}
|
|
|
|
type GetHelmArtifactDetailsRequestObject struct {
|
|
RegistryRef RegistryRefPathParam `json:"registry_ref"`
|
|
Artifact ArtifactPathParam `json:"artifact"`
|
|
Version VersionPathParam `json:"version"`
|
|
}
|
|
|
|
type GetHelmArtifactDetailsResponseObject interface {
|
|
VisitGetHelmArtifactDetailsResponse(w http.ResponseWriter) error
|
|
}
|
|
|
|
type GetHelmArtifactDetails200JSONResponse struct {
|
|
HelmArtifactDetailResponseJSONResponse
|
|
}
|
|
|
|
func (response GetHelmArtifactDetails200JSONResponse) VisitGetHelmArtifactDetailsResponse(w http.ResponseWriter) error {
|
|
w.Header().Set("Content-Type", "application/json")
|
|
w.WriteHeader(200)
|
|
|
|
return json.NewEncoder(w).Encode(response)
|
|
}
|
|
|
|
type GetHelmArtifactDetails400JSONResponse struct{ BadRequestJSONResponse }
|
|
|
|
func (response GetHelmArtifactDetails400JSONResponse) VisitGetHelmArtifactDetailsResponse(w http.ResponseWriter) error {
|
|
w.Header().Set("Content-Type", "application/json")
|
|
w.WriteHeader(400)
|
|
|
|
return json.NewEncoder(w).Encode(response)
|
|
}
|
|
|
|
type GetHelmArtifactDetails401JSONResponse struct{ UnauthenticatedJSONResponse }
|
|
|
|
func (response GetHelmArtifactDetails401JSONResponse) VisitGetHelmArtifactDetailsResponse(w http.ResponseWriter) error {
|
|
w.Header().Set("Content-Type", "application/json")
|
|
w.WriteHeader(401)
|
|
|
|
return json.NewEncoder(w).Encode(response)
|
|
}
|
|
|
|
type GetHelmArtifactDetails403JSONResponse struct{ UnauthorizedJSONResponse }
|
|
|
|
func (response GetHelmArtifactDetails403JSONResponse) VisitGetHelmArtifactDetailsResponse(w http.ResponseWriter) error {
|
|
w.Header().Set("Content-Type", "application/json")
|
|
w.WriteHeader(403)
|
|
|
|
return json.NewEncoder(w).Encode(response)
|
|
}
|
|
|
|
type GetHelmArtifactDetails404JSONResponse struct{ NotFoundJSONResponse }
|
|
|
|
func (response GetHelmArtifactDetails404JSONResponse) VisitGetHelmArtifactDetailsResponse(w http.ResponseWriter) error {
|
|
w.Header().Set("Content-Type", "application/json")
|
|
w.WriteHeader(404)
|
|
|
|
return json.NewEncoder(w).Encode(response)
|
|
}
|
|
|
|
type GetHelmArtifactDetails500JSONResponse struct {
|
|
InternalServerErrorJSONResponse
|
|
}
|
|
|
|
func (response GetHelmArtifactDetails500JSONResponse) VisitGetHelmArtifactDetailsResponse(w http.ResponseWriter) error {
|
|
w.Header().Set("Content-Type", "application/json")
|
|
w.WriteHeader(500)
|
|
|
|
return json.NewEncoder(w).Encode(response)
|
|
}
|
|
|
|
type GetHelmArtifactManifestRequestObject struct {
|
|
RegistryRef RegistryRefPathParam `json:"registry_ref"`
|
|
Artifact ArtifactPathParam `json:"artifact"`
|
|
Version VersionPathParam `json:"version"`
|
|
}
|
|
|
|
type GetHelmArtifactManifestResponseObject interface {
|
|
VisitGetHelmArtifactManifestResponse(w http.ResponseWriter) error
|
|
}
|
|
|
|
type GetHelmArtifactManifest200JSONResponse struct {
|
|
HelmArtifactManifestResponseJSONResponse
|
|
}
|
|
|
|
func (response GetHelmArtifactManifest200JSONResponse) VisitGetHelmArtifactManifestResponse(w http.ResponseWriter) error {
|
|
w.Header().Set("Content-Type", "application/json")
|
|
w.WriteHeader(200)
|
|
|
|
return json.NewEncoder(w).Encode(response)
|
|
}
|
|
|
|
type GetHelmArtifactManifest400JSONResponse struct{ BadRequestJSONResponse }
|
|
|
|
func (response GetHelmArtifactManifest400JSONResponse) VisitGetHelmArtifactManifestResponse(w http.ResponseWriter) error {
|
|
w.Header().Set("Content-Type", "application/json")
|
|
w.WriteHeader(400)
|
|
|
|
return json.NewEncoder(w).Encode(response)
|
|
}
|
|
|
|
type GetHelmArtifactManifest401JSONResponse struct{ UnauthenticatedJSONResponse }
|
|
|
|
func (response GetHelmArtifactManifest401JSONResponse) VisitGetHelmArtifactManifestResponse(w http.ResponseWriter) error {
|
|
w.Header().Set("Content-Type", "application/json")
|
|
w.WriteHeader(401)
|
|
|
|
return json.NewEncoder(w).Encode(response)
|
|
}
|
|
|
|
type GetHelmArtifactManifest403JSONResponse struct{ UnauthorizedJSONResponse }
|
|
|
|
func (response GetHelmArtifactManifest403JSONResponse) VisitGetHelmArtifactManifestResponse(w http.ResponseWriter) error {
|
|
w.Header().Set("Content-Type", "application/json")
|
|
w.WriteHeader(403)
|
|
|
|
return json.NewEncoder(w).Encode(response)
|
|
}
|
|
|
|
type GetHelmArtifactManifest404JSONResponse struct{ NotFoundJSONResponse }
|
|
|
|
func (response GetHelmArtifactManifest404JSONResponse) VisitGetHelmArtifactManifestResponse(w http.ResponseWriter) error {
|
|
w.Header().Set("Content-Type", "application/json")
|
|
w.WriteHeader(404)
|
|
|
|
return json.NewEncoder(w).Encode(response)
|
|
}
|
|
|
|
type GetHelmArtifactManifest500JSONResponse struct {
|
|
InternalServerErrorJSONResponse
|
|
}
|
|
|
|
func (response GetHelmArtifactManifest500JSONResponse) VisitGetHelmArtifactManifestResponse(w http.ResponseWriter) error {
|
|
w.Header().Set("Content-Type", "application/json")
|
|
w.WriteHeader(500)
|
|
|
|
return json.NewEncoder(w).Encode(response)
|
|
}
|
|
|
|
type GetArtifactVersionSummaryRequestObject struct {
|
|
RegistryRef RegistryRefPathParam `json:"registry_ref"`
|
|
Artifact ArtifactPathParam `json:"artifact"`
|
|
Version VersionPathParam `json:"version"`
|
|
}
|
|
|
|
type GetArtifactVersionSummaryResponseObject interface {
|
|
VisitGetArtifactVersionSummaryResponse(w http.ResponseWriter) error
|
|
}
|
|
|
|
type GetArtifactVersionSummary200JSONResponse struct {
|
|
ArtifactVersionSummaryResponseJSONResponse
|
|
}
|
|
|
|
func (response GetArtifactVersionSummary200JSONResponse) VisitGetArtifactVersionSummaryResponse(w http.ResponseWriter) error {
|
|
w.Header().Set("Content-Type", "application/json")
|
|
w.WriteHeader(200)
|
|
|
|
return json.NewEncoder(w).Encode(response)
|
|
}
|
|
|
|
type GetArtifactVersionSummary400JSONResponse struct{ BadRequestJSONResponse }
|
|
|
|
func (response GetArtifactVersionSummary400JSONResponse) VisitGetArtifactVersionSummaryResponse(w http.ResponseWriter) error {
|
|
w.Header().Set("Content-Type", "application/json")
|
|
w.WriteHeader(400)
|
|
|
|
return json.NewEncoder(w).Encode(response)
|
|
}
|
|
|
|
type GetArtifactVersionSummary401JSONResponse struct{ UnauthenticatedJSONResponse }
|
|
|
|
func (response GetArtifactVersionSummary401JSONResponse) VisitGetArtifactVersionSummaryResponse(w http.ResponseWriter) error {
|
|
w.Header().Set("Content-Type", "application/json")
|
|
w.WriteHeader(401)
|
|
|
|
return json.NewEncoder(w).Encode(response)
|
|
}
|
|
|
|
type GetArtifactVersionSummary403JSONResponse struct{ UnauthorizedJSONResponse }
|
|
|
|
func (response GetArtifactVersionSummary403JSONResponse) VisitGetArtifactVersionSummaryResponse(w http.ResponseWriter) error {
|
|
w.Header().Set("Content-Type", "application/json")
|
|
w.WriteHeader(403)
|
|
|
|
return json.NewEncoder(w).Encode(response)
|
|
}
|
|
|
|
type GetArtifactVersionSummary404JSONResponse struct{ NotFoundJSONResponse }
|
|
|
|
func (response GetArtifactVersionSummary404JSONResponse) VisitGetArtifactVersionSummaryResponse(w http.ResponseWriter) error {
|
|
w.Header().Set("Content-Type", "application/json")
|
|
w.WriteHeader(404)
|
|
|
|
return json.NewEncoder(w).Encode(response)
|
|
}
|
|
|
|
type GetArtifactVersionSummary500JSONResponse struct {
|
|
InternalServerErrorJSONResponse
|
|
}
|
|
|
|
func (response GetArtifactVersionSummary500JSONResponse) VisitGetArtifactVersionSummaryResponse(w http.ResponseWriter) error {
|
|
w.Header().Set("Content-Type", "application/json")
|
|
w.WriteHeader(500)
|
|
|
|
return json.NewEncoder(w).Encode(response)
|
|
}
|
|
|
|
type GetAllArtifactVersionsRequestObject struct {
|
|
RegistryRef RegistryRefPathParam `json:"registry_ref"`
|
|
Artifact ArtifactPathParam `json:"artifact"`
|
|
Params GetAllArtifactVersionsParams
|
|
}
|
|
|
|
type GetAllArtifactVersionsResponseObject interface {
|
|
VisitGetAllArtifactVersionsResponse(w http.ResponseWriter) error
|
|
}
|
|
|
|
type GetAllArtifactVersions200JSONResponse struct {
|
|
ListArtifactVersionResponseJSONResponse
|
|
}
|
|
|
|
func (response GetAllArtifactVersions200JSONResponse) VisitGetAllArtifactVersionsResponse(w http.ResponseWriter) error {
|
|
w.Header().Set("Content-Type", "application/json")
|
|
w.WriteHeader(200)
|
|
|
|
return json.NewEncoder(w).Encode(response)
|
|
}
|
|
|
|
type GetAllArtifactVersions400JSONResponse struct{ BadRequestJSONResponse }
|
|
|
|
func (response GetAllArtifactVersions400JSONResponse) VisitGetAllArtifactVersionsResponse(w http.ResponseWriter) error {
|
|
w.Header().Set("Content-Type", "application/json")
|
|
w.WriteHeader(400)
|
|
|
|
return json.NewEncoder(w).Encode(response)
|
|
}
|
|
|
|
type GetAllArtifactVersions401JSONResponse struct{ UnauthenticatedJSONResponse }
|
|
|
|
func (response GetAllArtifactVersions401JSONResponse) VisitGetAllArtifactVersionsResponse(w http.ResponseWriter) error {
|
|
w.Header().Set("Content-Type", "application/json")
|
|
w.WriteHeader(401)
|
|
|
|
return json.NewEncoder(w).Encode(response)
|
|
}
|
|
|
|
type GetAllArtifactVersions403JSONResponse struct{ UnauthorizedJSONResponse }
|
|
|
|
func (response GetAllArtifactVersions403JSONResponse) VisitGetAllArtifactVersionsResponse(w http.ResponseWriter) error {
|
|
w.Header().Set("Content-Type", "application/json")
|
|
w.WriteHeader(403)
|
|
|
|
return json.NewEncoder(w).Encode(response)
|
|
}
|
|
|
|
type GetAllArtifactVersions404JSONResponse struct{ NotFoundJSONResponse }
|
|
|
|
func (response GetAllArtifactVersions404JSONResponse) VisitGetAllArtifactVersionsResponse(w http.ResponseWriter) error {
|
|
w.Header().Set("Content-Type", "application/json")
|
|
w.WriteHeader(404)
|
|
|
|
return json.NewEncoder(w).Encode(response)
|
|
}
|
|
|
|
type GetAllArtifactVersions500JSONResponse struct {
|
|
InternalServerErrorJSONResponse
|
|
}
|
|
|
|
func (response GetAllArtifactVersions500JSONResponse) VisitGetAllArtifactVersionsResponse(w http.ResponseWriter) error {
|
|
w.Header().Set("Content-Type", "application/json")
|
|
w.WriteHeader(500)
|
|
|
|
return json.NewEncoder(w).Encode(response)
|
|
}
|
|
|
|
type GetAllArtifactsByRegistryRequestObject struct {
|
|
RegistryRef RegistryRefPathParam `json:"registry_ref"`
|
|
Params GetAllArtifactsByRegistryParams
|
|
}
|
|
|
|
type GetAllArtifactsByRegistryResponseObject interface {
|
|
VisitGetAllArtifactsByRegistryResponse(w http.ResponseWriter) error
|
|
}
|
|
|
|
type GetAllArtifactsByRegistry200JSONResponse struct {
|
|
ListRegistryArtifactResponseJSONResponse
|
|
}
|
|
|
|
func (response GetAllArtifactsByRegistry200JSONResponse) VisitGetAllArtifactsByRegistryResponse(w http.ResponseWriter) error {
|
|
w.Header().Set("Content-Type", "application/json")
|
|
w.WriteHeader(200)
|
|
|
|
return json.NewEncoder(w).Encode(response)
|
|
}
|
|
|
|
type GetAllArtifactsByRegistry400JSONResponse struct{ BadRequestJSONResponse }
|
|
|
|
func (response GetAllArtifactsByRegistry400JSONResponse) VisitGetAllArtifactsByRegistryResponse(w http.ResponseWriter) error {
|
|
w.Header().Set("Content-Type", "application/json")
|
|
w.WriteHeader(400)
|
|
|
|
return json.NewEncoder(w).Encode(response)
|
|
}
|
|
|
|
type GetAllArtifactsByRegistry401JSONResponse struct{ UnauthenticatedJSONResponse }
|
|
|
|
func (response GetAllArtifactsByRegistry401JSONResponse) VisitGetAllArtifactsByRegistryResponse(w http.ResponseWriter) error {
|
|
w.Header().Set("Content-Type", "application/json")
|
|
w.WriteHeader(401)
|
|
|
|
return json.NewEncoder(w).Encode(response)
|
|
}
|
|
|
|
type GetAllArtifactsByRegistry403JSONResponse struct{ UnauthorizedJSONResponse }
|
|
|
|
func (response GetAllArtifactsByRegistry403JSONResponse) VisitGetAllArtifactsByRegistryResponse(w http.ResponseWriter) error {
|
|
w.Header().Set("Content-Type", "application/json")
|
|
w.WriteHeader(403)
|
|
|
|
return json.NewEncoder(w).Encode(response)
|
|
}
|
|
|
|
type GetAllArtifactsByRegistry404JSONResponse struct{ NotFoundJSONResponse }
|
|
|
|
func (response GetAllArtifactsByRegistry404JSONResponse) VisitGetAllArtifactsByRegistryResponse(w http.ResponseWriter) error {
|
|
w.Header().Set("Content-Type", "application/json")
|
|
w.WriteHeader(404)
|
|
|
|
return json.NewEncoder(w).Encode(response)
|
|
}
|
|
|
|
type GetAllArtifactsByRegistry500JSONResponse struct {
|
|
InternalServerErrorJSONResponse
|
|
}
|
|
|
|
func (response GetAllArtifactsByRegistry500JSONResponse) VisitGetAllArtifactsByRegistryResponse(w http.ResponseWriter) error {
|
|
w.Header().Set("Content-Type", "application/json")
|
|
w.WriteHeader(500)
|
|
|
|
return json.NewEncoder(w).Encode(response)
|
|
}
|
|
|
|
type GetClientSetupDetailsRequestObject struct {
|
|
RegistryRef RegistryRefPathParam `json:"registry_ref"`
|
|
Params GetClientSetupDetailsParams
|
|
}
|
|
|
|
type GetClientSetupDetailsResponseObject interface {
|
|
VisitGetClientSetupDetailsResponse(w http.ResponseWriter) error
|
|
}
|
|
|
|
type GetClientSetupDetails200JSONResponse struct {
|
|
ClientSetupDetailsResponseJSONResponse
|
|
}
|
|
|
|
func (response GetClientSetupDetails200JSONResponse) VisitGetClientSetupDetailsResponse(w http.ResponseWriter) error {
|
|
w.Header().Set("Content-Type", "application/json")
|
|
w.WriteHeader(200)
|
|
|
|
return json.NewEncoder(w).Encode(response)
|
|
}
|
|
|
|
type GetClientSetupDetails400JSONResponse struct{ BadRequestJSONResponse }
|
|
|
|
func (response GetClientSetupDetails400JSONResponse) VisitGetClientSetupDetailsResponse(w http.ResponseWriter) error {
|
|
w.Header().Set("Content-Type", "application/json")
|
|
w.WriteHeader(400)
|
|
|
|
return json.NewEncoder(w).Encode(response)
|
|
}
|
|
|
|
type GetClientSetupDetails401JSONResponse struct{ UnauthenticatedJSONResponse }
|
|
|
|
func (response GetClientSetupDetails401JSONResponse) VisitGetClientSetupDetailsResponse(w http.ResponseWriter) error {
|
|
w.Header().Set("Content-Type", "application/json")
|
|
w.WriteHeader(401)
|
|
|
|
return json.NewEncoder(w).Encode(response)
|
|
}
|
|
|
|
type GetClientSetupDetails403JSONResponse struct{ UnauthorizedJSONResponse }
|
|
|
|
func (response GetClientSetupDetails403JSONResponse) VisitGetClientSetupDetailsResponse(w http.ResponseWriter) error {
|
|
w.Header().Set("Content-Type", "application/json")
|
|
w.WriteHeader(403)
|
|
|
|
return json.NewEncoder(w).Encode(response)
|
|
}
|
|
|
|
type GetClientSetupDetails404JSONResponse struct{ NotFoundJSONResponse }
|
|
|
|
func (response GetClientSetupDetails404JSONResponse) VisitGetClientSetupDetailsResponse(w http.ResponseWriter) error {
|
|
w.Header().Set("Content-Type", "application/json")
|
|
w.WriteHeader(404)
|
|
|
|
return json.NewEncoder(w).Encode(response)
|
|
}
|
|
|
|
type GetClientSetupDetails500JSONResponse struct {
|
|
InternalServerErrorJSONResponse
|
|
}
|
|
|
|
func (response GetClientSetupDetails500JSONResponse) VisitGetClientSetupDetailsResponse(w http.ResponseWriter) error {
|
|
w.Header().Set("Content-Type", "application/json")
|
|
w.WriteHeader(500)
|
|
|
|
return json.NewEncoder(w).Encode(response)
|
|
}
|
|
|
|
type GetArtifactStatsForSpaceRequestObject struct {
|
|
SpaceRef SpaceRefPathParam `json:"space_ref"`
|
|
Params GetArtifactStatsForSpaceParams
|
|
}
|
|
|
|
type GetArtifactStatsForSpaceResponseObject interface {
|
|
VisitGetArtifactStatsForSpaceResponse(w http.ResponseWriter) error
|
|
}
|
|
|
|
type GetArtifactStatsForSpace200JSONResponse struct {
|
|
ArtifactStatsResponseJSONResponse
|
|
}
|
|
|
|
func (response GetArtifactStatsForSpace200JSONResponse) VisitGetArtifactStatsForSpaceResponse(w http.ResponseWriter) error {
|
|
w.Header().Set("Content-Type", "application/json")
|
|
w.WriteHeader(200)
|
|
|
|
return json.NewEncoder(w).Encode(response)
|
|
}
|
|
|
|
type GetArtifactStatsForSpace400JSONResponse struct{ BadRequestJSONResponse }
|
|
|
|
func (response GetArtifactStatsForSpace400JSONResponse) VisitGetArtifactStatsForSpaceResponse(w http.ResponseWriter) error {
|
|
w.Header().Set("Content-Type", "application/json")
|
|
w.WriteHeader(400)
|
|
|
|
return json.NewEncoder(w).Encode(response)
|
|
}
|
|
|
|
type GetArtifactStatsForSpace401JSONResponse struct{ UnauthenticatedJSONResponse }
|
|
|
|
func (response GetArtifactStatsForSpace401JSONResponse) VisitGetArtifactStatsForSpaceResponse(w http.ResponseWriter) error {
|
|
w.Header().Set("Content-Type", "application/json")
|
|
w.WriteHeader(401)
|
|
|
|
return json.NewEncoder(w).Encode(response)
|
|
}
|
|
|
|
type GetArtifactStatsForSpace403JSONResponse struct{ UnauthorizedJSONResponse }
|
|
|
|
func (response GetArtifactStatsForSpace403JSONResponse) VisitGetArtifactStatsForSpaceResponse(w http.ResponseWriter) error {
|
|
w.Header().Set("Content-Type", "application/json")
|
|
w.WriteHeader(403)
|
|
|
|
return json.NewEncoder(w).Encode(response)
|
|
}
|
|
|
|
type GetArtifactStatsForSpace404JSONResponse struct{ NotFoundJSONResponse }
|
|
|
|
func (response GetArtifactStatsForSpace404JSONResponse) VisitGetArtifactStatsForSpaceResponse(w http.ResponseWriter) error {
|
|
w.Header().Set("Content-Type", "application/json")
|
|
w.WriteHeader(404)
|
|
|
|
return json.NewEncoder(w).Encode(response)
|
|
}
|
|
|
|
type GetArtifactStatsForSpace500JSONResponse struct {
|
|
InternalServerErrorJSONResponse
|
|
}
|
|
|
|
func (response GetArtifactStatsForSpace500JSONResponse) VisitGetArtifactStatsForSpaceResponse(w http.ResponseWriter) error {
|
|
w.Header().Set("Content-Type", "application/json")
|
|
w.WriteHeader(500)
|
|
|
|
return json.NewEncoder(w).Encode(response)
|
|
}
|
|
|
|
type GetAllArtifactsRequestObject struct {
|
|
SpaceRef SpaceRefPathParam `json:"space_ref"`
|
|
Params GetAllArtifactsParams
|
|
}
|
|
|
|
type GetAllArtifactsResponseObject interface {
|
|
VisitGetAllArtifactsResponse(w http.ResponseWriter) error
|
|
}
|
|
|
|
type GetAllArtifacts200JSONResponse struct {
|
|
ListArtifactResponseJSONResponse
|
|
}
|
|
|
|
func (response GetAllArtifacts200JSONResponse) VisitGetAllArtifactsResponse(w http.ResponseWriter) error {
|
|
w.Header().Set("Content-Type", "application/json")
|
|
w.WriteHeader(200)
|
|
|
|
return json.NewEncoder(w).Encode(response)
|
|
}
|
|
|
|
type GetAllArtifacts400JSONResponse struct{ BadRequestJSONResponse }
|
|
|
|
func (response GetAllArtifacts400JSONResponse) VisitGetAllArtifactsResponse(w http.ResponseWriter) error {
|
|
w.Header().Set("Content-Type", "application/json")
|
|
w.WriteHeader(400)
|
|
|
|
return json.NewEncoder(w).Encode(response)
|
|
}
|
|
|
|
type GetAllArtifacts401JSONResponse struct{ UnauthenticatedJSONResponse }
|
|
|
|
func (response GetAllArtifacts401JSONResponse) VisitGetAllArtifactsResponse(w http.ResponseWriter) error {
|
|
w.Header().Set("Content-Type", "application/json")
|
|
w.WriteHeader(401)
|
|
|
|
return json.NewEncoder(w).Encode(response)
|
|
}
|
|
|
|
type GetAllArtifacts403JSONResponse struct{ UnauthorizedJSONResponse }
|
|
|
|
func (response GetAllArtifacts403JSONResponse) VisitGetAllArtifactsResponse(w http.ResponseWriter) error {
|
|
w.Header().Set("Content-Type", "application/json")
|
|
w.WriteHeader(403)
|
|
|
|
return json.NewEncoder(w).Encode(response)
|
|
}
|
|
|
|
type GetAllArtifacts404JSONResponse struct{ NotFoundJSONResponse }
|
|
|
|
func (response GetAllArtifacts404JSONResponse) VisitGetAllArtifactsResponse(w http.ResponseWriter) error {
|
|
w.Header().Set("Content-Type", "application/json")
|
|
w.WriteHeader(404)
|
|
|
|
return json.NewEncoder(w).Encode(response)
|
|
}
|
|
|
|
type GetAllArtifacts500JSONResponse struct {
|
|
InternalServerErrorJSONResponse
|
|
}
|
|
|
|
func (response GetAllArtifacts500JSONResponse) VisitGetAllArtifactsResponse(w http.ResponseWriter) error {
|
|
w.Header().Set("Content-Type", "application/json")
|
|
w.WriteHeader(500)
|
|
|
|
return json.NewEncoder(w).Encode(response)
|
|
}
|
|
|
|
type GetAllRegistriesRequestObject struct {
|
|
SpaceRef SpaceRefPathParam `json:"space_ref"`
|
|
Params GetAllRegistriesParams
|
|
}
|
|
|
|
type GetAllRegistriesResponseObject interface {
|
|
VisitGetAllRegistriesResponse(w http.ResponseWriter) error
|
|
}
|
|
|
|
type GetAllRegistries200JSONResponse struct {
|
|
ListRegistryResponseJSONResponse
|
|
}
|
|
|
|
func (response GetAllRegistries200JSONResponse) VisitGetAllRegistriesResponse(w http.ResponseWriter) error {
|
|
w.Header().Set("Content-Type", "application/json")
|
|
w.WriteHeader(200)
|
|
|
|
return json.NewEncoder(w).Encode(response)
|
|
}
|
|
|
|
type GetAllRegistries400JSONResponse struct{ BadRequestJSONResponse }
|
|
|
|
func (response GetAllRegistries400JSONResponse) VisitGetAllRegistriesResponse(w http.ResponseWriter) error {
|
|
w.Header().Set("Content-Type", "application/json")
|
|
w.WriteHeader(400)
|
|
|
|
return json.NewEncoder(w).Encode(response)
|
|
}
|
|
|
|
type GetAllRegistries401JSONResponse struct{ UnauthenticatedJSONResponse }
|
|
|
|
func (response GetAllRegistries401JSONResponse) VisitGetAllRegistriesResponse(w http.ResponseWriter) error {
|
|
w.Header().Set("Content-Type", "application/json")
|
|
w.WriteHeader(401)
|
|
|
|
return json.NewEncoder(w).Encode(response)
|
|
}
|
|
|
|
type GetAllRegistries403JSONResponse struct{ UnauthorizedJSONResponse }
|
|
|
|
func (response GetAllRegistries403JSONResponse) VisitGetAllRegistriesResponse(w http.ResponseWriter) error {
|
|
w.Header().Set("Content-Type", "application/json")
|
|
w.WriteHeader(403)
|
|
|
|
return json.NewEncoder(w).Encode(response)
|
|
}
|
|
|
|
type GetAllRegistries404JSONResponse struct{ NotFoundJSONResponse }
|
|
|
|
func (response GetAllRegistries404JSONResponse) VisitGetAllRegistriesResponse(w http.ResponseWriter) error {
|
|
w.Header().Set("Content-Type", "application/json")
|
|
w.WriteHeader(404)
|
|
|
|
return json.NewEncoder(w).Encode(response)
|
|
}
|
|
|
|
type GetAllRegistries500JSONResponse struct {
|
|
InternalServerErrorJSONResponse
|
|
}
|
|
|
|
func (response GetAllRegistries500JSONResponse) VisitGetAllRegistriesResponse(w http.ResponseWriter) error {
|
|
w.Header().Set("Content-Type", "application/json")
|
|
w.WriteHeader(500)
|
|
|
|
return json.NewEncoder(w).Encode(response)
|
|
}
|
|
|
|
// StrictServerInterface represents all server handlers.
|
|
type StrictServerInterface interface {
|
|
// Create Registry.
|
|
// (POST /registry)
|
|
CreateRegistry(ctx context.Context, request CreateRegistryRequestObject) (CreateRegistryResponseObject, error)
|
|
// Delete a Registry
|
|
// (DELETE /registry/{registry_ref})
|
|
DeleteRegistry(ctx context.Context, request DeleteRegistryRequestObject) (DeleteRegistryResponseObject, error)
|
|
// Returns Registry Details
|
|
// (GET /registry/{registry_ref})
|
|
GetRegistry(ctx context.Context, request GetRegistryRequestObject) (GetRegistryResponseObject, error)
|
|
// Updates a Registry
|
|
// (PUT /registry/{registry_ref})
|
|
ModifyRegistry(ctx context.Context, request ModifyRegistryRequestObject) (ModifyRegistryResponseObject, error)
|
|
// List Artifact Labels
|
|
// (GET /registry/{registry_ref}/artifact/labels)
|
|
ListArtifactLabels(ctx context.Context, request ListArtifactLabelsRequestObject) (ListArtifactLabelsResponseObject, error)
|
|
// Get Artifact Stats
|
|
// (GET /registry/{registry_ref}/artifact/stats)
|
|
GetArtifactStatsForRegistry(ctx context.Context, request GetArtifactStatsForRegistryRequestObject) (GetArtifactStatsForRegistryResponseObject, error)
|
|
// Delete Artifact
|
|
// (DELETE /registry/{registry_ref}/artifact/{artifact})
|
|
DeleteArtifact(ctx context.Context, request DeleteArtifactRequestObject) (DeleteArtifactResponseObject, error)
|
|
// Update Artifact Labels
|
|
// (PUT /registry/{registry_ref}/artifact/{artifact}/labels)
|
|
UpdateArtifactLabels(ctx context.Context, request UpdateArtifactLabelsRequestObject) (UpdateArtifactLabelsResponseObject, error)
|
|
// Get Artifact Stats
|
|
// (GET /registry/{registry_ref}/artifact/{artifact}/stats)
|
|
GetArtifactStats(ctx context.Context, request GetArtifactStatsRequestObject) (GetArtifactStatsResponseObject, error)
|
|
// Get Artifact Summary
|
|
// (GET /registry/{registry_ref}/artifact/{artifact}/summary)
|
|
GetArtifactSummary(ctx context.Context, request GetArtifactSummaryRequestObject) (GetArtifactSummaryResponseObject, error)
|
|
// Delete an Artifact Version
|
|
// (DELETE /registry/{registry_ref}/artifact/{artifact}/version/{version})
|
|
DeleteArtifactVersion(ctx context.Context, request DeleteArtifactVersionRequestObject) (DeleteArtifactVersionResponseObject, error)
|
|
// Describe Docker Artifact Detail
|
|
// (GET /registry/{registry_ref}/artifact/{artifact}/version/{version}/docker/details)
|
|
GetDockerArtifactDetails(ctx context.Context, request GetDockerArtifactDetailsRequestObject) (GetDockerArtifactDetailsResponseObject, error)
|
|
// Describe Docker Artifact Layers
|
|
// (GET /registry/{registry_ref}/artifact/{artifact}/version/{version}/docker/layers)
|
|
GetDockerArtifactLayers(ctx context.Context, request GetDockerArtifactLayersRequestObject) (GetDockerArtifactLayersResponseObject, error)
|
|
// Describe Docker Artifact Manifest
|
|
// (GET /registry/{registry_ref}/artifact/{artifact}/version/{version}/docker/manifest)
|
|
GetDockerArtifactManifest(ctx context.Context, request GetDockerArtifactManifestRequestObject) (GetDockerArtifactManifestResponseObject, error)
|
|
// Describe Docker Artifact Manifests
|
|
// (GET /registry/{registry_ref}/artifact/{artifact}/version/{version}/docker/manifests)
|
|
GetDockerArtifactManifests(ctx context.Context, request GetDockerArtifactManifestsRequestObject) (GetDockerArtifactManifestsResponseObject, error)
|
|
// Describe Helm Artifact Detail
|
|
// (GET /registry/{registry_ref}/artifact/{artifact}/version/{version}/helm/details)
|
|
GetHelmArtifactDetails(ctx context.Context, request GetHelmArtifactDetailsRequestObject) (GetHelmArtifactDetailsResponseObject, error)
|
|
// Describe Helm Artifact Manifest
|
|
// (GET /registry/{registry_ref}/artifact/{artifact}/version/{version}/helm/manifest)
|
|
GetHelmArtifactManifest(ctx context.Context, request GetHelmArtifactManifestRequestObject) (GetHelmArtifactManifestResponseObject, error)
|
|
// Get Artifact Version Summary
|
|
// (GET /registry/{registry_ref}/artifact/{artifact}/version/{version}/summary)
|
|
GetArtifactVersionSummary(ctx context.Context, request GetArtifactVersionSummaryRequestObject) (GetArtifactVersionSummaryResponseObject, error)
|
|
// List Artifact Versions
|
|
// (GET /registry/{registry_ref}/artifact/{artifact}/versions)
|
|
GetAllArtifactVersions(ctx context.Context, request GetAllArtifactVersionsRequestObject) (GetAllArtifactVersionsResponseObject, error)
|
|
// List Artifacts for Registry
|
|
// (GET /registry/{registry_ref}/artifacts)
|
|
GetAllArtifactsByRegistry(ctx context.Context, request GetAllArtifactsByRegistryRequestObject) (GetAllArtifactsByRegistryResponseObject, error)
|
|
// Returns CLI Client Setup Details
|
|
// (GET /registry/{registry_ref}/client-setup-details)
|
|
GetClientSetupDetails(ctx context.Context, request GetClientSetupDetailsRequestObject) (GetClientSetupDetailsResponseObject, error)
|
|
// Get Artifact Stats
|
|
// (GET /spaces/{space_ref}/artifact/stats)
|
|
GetArtifactStatsForSpace(ctx context.Context, request GetArtifactStatsForSpaceRequestObject) (GetArtifactStatsForSpaceResponseObject, error)
|
|
// List Artifacts
|
|
// (GET /spaces/{space_ref}/artifacts)
|
|
GetAllArtifacts(ctx context.Context, request GetAllArtifactsRequestObject) (GetAllArtifactsResponseObject, error)
|
|
// List Registries
|
|
// (GET /spaces/{space_ref}/registries)
|
|
GetAllRegistries(ctx context.Context, request GetAllRegistriesRequestObject) (GetAllRegistriesResponseObject, error)
|
|
}
|
|
|
|
type StrictHandlerFunc = strictnethttp.StrictHTTPHandlerFunc
|
|
type StrictMiddlewareFunc = strictnethttp.StrictHTTPMiddlewareFunc
|
|
|
|
type StrictHTTPServerOptions struct {
|
|
RequestErrorHandlerFunc func(w http.ResponseWriter, r *http.Request, err error)
|
|
ResponseErrorHandlerFunc func(w http.ResponseWriter, r *http.Request, err error)
|
|
}
|
|
|
|
func NewStrictHandler(ssi StrictServerInterface, middlewares []StrictMiddlewareFunc) ServerInterface {
|
|
return &strictHandler{ssi: ssi, middlewares: middlewares, options: StrictHTTPServerOptions{
|
|
RequestErrorHandlerFunc: func(w http.ResponseWriter, r *http.Request, err error) {
|
|
http.Error(w, err.Error(), http.StatusBadRequest)
|
|
},
|
|
ResponseErrorHandlerFunc: func(w http.ResponseWriter, r *http.Request, err error) {
|
|
http.Error(w, err.Error(), http.StatusInternalServerError)
|
|
},
|
|
}}
|
|
}
|
|
|
|
func NewStrictHandlerWithOptions(ssi StrictServerInterface, middlewares []StrictMiddlewareFunc, options StrictHTTPServerOptions) ServerInterface {
|
|
return &strictHandler{ssi: ssi, middlewares: middlewares, options: options}
|
|
}
|
|
|
|
type strictHandler struct {
|
|
ssi StrictServerInterface
|
|
middlewares []StrictMiddlewareFunc
|
|
options StrictHTTPServerOptions
|
|
}
|
|
|
|
// CreateRegistry operation middleware
|
|
func (sh *strictHandler) CreateRegistry(w http.ResponseWriter, r *http.Request, params CreateRegistryParams) {
|
|
var request CreateRegistryRequestObject
|
|
|
|
request.Params = params
|
|
|
|
var body CreateRegistryJSONRequestBody
|
|
if err := json.NewDecoder(r.Body).Decode(&body); err != nil {
|
|
sh.options.RequestErrorHandlerFunc(w, r, fmt.Errorf("can't decode JSON body: %w", err))
|
|
return
|
|
}
|
|
request.Body = &body
|
|
|
|
handler := func(ctx context.Context, w http.ResponseWriter, r *http.Request, request interface{}) (interface{}, error) {
|
|
return sh.ssi.CreateRegistry(ctx, request.(CreateRegistryRequestObject))
|
|
}
|
|
for _, middleware := range sh.middlewares {
|
|
handler = middleware(handler, "CreateRegistry")
|
|
}
|
|
|
|
response, err := handler(r.Context(), w, r, request)
|
|
|
|
if err != nil {
|
|
sh.options.ResponseErrorHandlerFunc(w, r, err)
|
|
} else if validResponse, ok := response.(CreateRegistryResponseObject); ok {
|
|
if err := validResponse.VisitCreateRegistryResponse(w); err != nil {
|
|
sh.options.ResponseErrorHandlerFunc(w, r, err)
|
|
}
|
|
} else if response != nil {
|
|
sh.options.ResponseErrorHandlerFunc(w, r, fmt.Errorf("unexpected response type: %T", response))
|
|
}
|
|
}
|
|
|
|
// DeleteRegistry operation middleware
|
|
func (sh *strictHandler) DeleteRegistry(w http.ResponseWriter, r *http.Request, registryRef RegistryRefPathParam) {
|
|
var request DeleteRegistryRequestObject
|
|
|
|
request.RegistryRef = registryRef
|
|
|
|
handler := func(ctx context.Context, w http.ResponseWriter, r *http.Request, request interface{}) (interface{}, error) {
|
|
return sh.ssi.DeleteRegistry(ctx, request.(DeleteRegistryRequestObject))
|
|
}
|
|
for _, middleware := range sh.middlewares {
|
|
handler = middleware(handler, "DeleteRegistry")
|
|
}
|
|
|
|
response, err := handler(r.Context(), w, r, request)
|
|
|
|
if err != nil {
|
|
sh.options.ResponseErrorHandlerFunc(w, r, err)
|
|
} else if validResponse, ok := response.(DeleteRegistryResponseObject); ok {
|
|
if err := validResponse.VisitDeleteRegistryResponse(w); err != nil {
|
|
sh.options.ResponseErrorHandlerFunc(w, r, err)
|
|
}
|
|
} else if response != nil {
|
|
sh.options.ResponseErrorHandlerFunc(w, r, fmt.Errorf("unexpected response type: %T", response))
|
|
}
|
|
}
|
|
|
|
// GetRegistry operation middleware
|
|
func (sh *strictHandler) GetRegistry(w http.ResponseWriter, r *http.Request, registryRef RegistryRefPathParam) {
|
|
var request GetRegistryRequestObject
|
|
|
|
request.RegistryRef = registryRef
|
|
|
|
handler := func(ctx context.Context, w http.ResponseWriter, r *http.Request, request interface{}) (interface{}, error) {
|
|
return sh.ssi.GetRegistry(ctx, request.(GetRegistryRequestObject))
|
|
}
|
|
for _, middleware := range sh.middlewares {
|
|
handler = middleware(handler, "GetRegistry")
|
|
}
|
|
|
|
response, err := handler(r.Context(), w, r, request)
|
|
|
|
if err != nil {
|
|
sh.options.ResponseErrorHandlerFunc(w, r, err)
|
|
} else if validResponse, ok := response.(GetRegistryResponseObject); ok {
|
|
if err := validResponse.VisitGetRegistryResponse(w); err != nil {
|
|
sh.options.ResponseErrorHandlerFunc(w, r, err)
|
|
}
|
|
} else if response != nil {
|
|
sh.options.ResponseErrorHandlerFunc(w, r, fmt.Errorf("unexpected response type: %T", response))
|
|
}
|
|
}
|
|
|
|
// ModifyRegistry operation middleware
|
|
func (sh *strictHandler) ModifyRegistry(w http.ResponseWriter, r *http.Request, registryRef RegistryRefPathParam) {
|
|
var request ModifyRegistryRequestObject
|
|
|
|
request.RegistryRef = registryRef
|
|
|
|
var body ModifyRegistryJSONRequestBody
|
|
if err := json.NewDecoder(r.Body).Decode(&body); err != nil {
|
|
sh.options.RequestErrorHandlerFunc(w, r, fmt.Errorf("can't decode JSON body: %w", err))
|
|
return
|
|
}
|
|
request.Body = &body
|
|
|
|
handler := func(ctx context.Context, w http.ResponseWriter, r *http.Request, request interface{}) (interface{}, error) {
|
|
return sh.ssi.ModifyRegistry(ctx, request.(ModifyRegistryRequestObject))
|
|
}
|
|
for _, middleware := range sh.middlewares {
|
|
handler = middleware(handler, "ModifyRegistry")
|
|
}
|
|
|
|
response, err := handler(r.Context(), w, r, request)
|
|
|
|
if err != nil {
|
|
sh.options.ResponseErrorHandlerFunc(w, r, err)
|
|
} else if validResponse, ok := response.(ModifyRegistryResponseObject); ok {
|
|
if err := validResponse.VisitModifyRegistryResponse(w); err != nil {
|
|
sh.options.ResponseErrorHandlerFunc(w, r, err)
|
|
}
|
|
} else if response != nil {
|
|
sh.options.ResponseErrorHandlerFunc(w, r, fmt.Errorf("unexpected response type: %T", response))
|
|
}
|
|
}
|
|
|
|
// ListArtifactLabels operation middleware
|
|
func (sh *strictHandler) ListArtifactLabels(w http.ResponseWriter, r *http.Request, registryRef RegistryRefPathParam, params ListArtifactLabelsParams) {
|
|
var request ListArtifactLabelsRequestObject
|
|
|
|
request.RegistryRef = registryRef
|
|
request.Params = params
|
|
|
|
handler := func(ctx context.Context, w http.ResponseWriter, r *http.Request, request interface{}) (interface{}, error) {
|
|
return sh.ssi.ListArtifactLabels(ctx, request.(ListArtifactLabelsRequestObject))
|
|
}
|
|
for _, middleware := range sh.middlewares {
|
|
handler = middleware(handler, "ListArtifactLabels")
|
|
}
|
|
|
|
response, err := handler(r.Context(), w, r, request)
|
|
|
|
if err != nil {
|
|
sh.options.ResponseErrorHandlerFunc(w, r, err)
|
|
} else if validResponse, ok := response.(ListArtifactLabelsResponseObject); ok {
|
|
if err := validResponse.VisitListArtifactLabelsResponse(w); err != nil {
|
|
sh.options.ResponseErrorHandlerFunc(w, r, err)
|
|
}
|
|
} else if response != nil {
|
|
sh.options.ResponseErrorHandlerFunc(w, r, fmt.Errorf("unexpected response type: %T", response))
|
|
}
|
|
}
|
|
|
|
// GetArtifactStatsForRegistry operation middleware
|
|
func (sh *strictHandler) GetArtifactStatsForRegistry(w http.ResponseWriter, r *http.Request, registryRef RegistryRefPathParam, params GetArtifactStatsForRegistryParams) {
|
|
var request GetArtifactStatsForRegistryRequestObject
|
|
|
|
request.RegistryRef = registryRef
|
|
request.Params = params
|
|
|
|
handler := func(ctx context.Context, w http.ResponseWriter, r *http.Request, request interface{}) (interface{}, error) {
|
|
return sh.ssi.GetArtifactStatsForRegistry(ctx, request.(GetArtifactStatsForRegistryRequestObject))
|
|
}
|
|
for _, middleware := range sh.middlewares {
|
|
handler = middleware(handler, "GetArtifactStatsForRegistry")
|
|
}
|
|
|
|
response, err := handler(r.Context(), w, r, request)
|
|
|
|
if err != nil {
|
|
sh.options.ResponseErrorHandlerFunc(w, r, err)
|
|
} else if validResponse, ok := response.(GetArtifactStatsForRegistryResponseObject); ok {
|
|
if err := validResponse.VisitGetArtifactStatsForRegistryResponse(w); err != nil {
|
|
sh.options.ResponseErrorHandlerFunc(w, r, err)
|
|
}
|
|
} else if response != nil {
|
|
sh.options.ResponseErrorHandlerFunc(w, r, fmt.Errorf("unexpected response type: %T", response))
|
|
}
|
|
}
|
|
|
|
// DeleteArtifact operation middleware
|
|
func (sh *strictHandler) DeleteArtifact(w http.ResponseWriter, r *http.Request, registryRef RegistryRefPathParam, artifact ArtifactPathParam) {
|
|
var request DeleteArtifactRequestObject
|
|
|
|
request.RegistryRef = registryRef
|
|
request.Artifact = artifact
|
|
|
|
handler := func(ctx context.Context, w http.ResponseWriter, r *http.Request, request interface{}) (interface{}, error) {
|
|
return sh.ssi.DeleteArtifact(ctx, request.(DeleteArtifactRequestObject))
|
|
}
|
|
for _, middleware := range sh.middlewares {
|
|
handler = middleware(handler, "DeleteArtifact")
|
|
}
|
|
|
|
response, err := handler(r.Context(), w, r, request)
|
|
|
|
if err != nil {
|
|
sh.options.ResponseErrorHandlerFunc(w, r, err)
|
|
} else if validResponse, ok := response.(DeleteArtifactResponseObject); ok {
|
|
if err := validResponse.VisitDeleteArtifactResponse(w); err != nil {
|
|
sh.options.ResponseErrorHandlerFunc(w, r, err)
|
|
}
|
|
} else if response != nil {
|
|
sh.options.ResponseErrorHandlerFunc(w, r, fmt.Errorf("unexpected response type: %T", response))
|
|
}
|
|
}
|
|
|
|
// UpdateArtifactLabels operation middleware
|
|
func (sh *strictHandler) UpdateArtifactLabels(w http.ResponseWriter, r *http.Request, registryRef RegistryRefPathParam, artifact ArtifactPathParam) {
|
|
var request UpdateArtifactLabelsRequestObject
|
|
|
|
request.RegistryRef = registryRef
|
|
request.Artifact = artifact
|
|
|
|
var body UpdateArtifactLabelsJSONRequestBody
|
|
if err := json.NewDecoder(r.Body).Decode(&body); err != nil {
|
|
sh.options.RequestErrorHandlerFunc(w, r, fmt.Errorf("can't decode JSON body: %w", err))
|
|
return
|
|
}
|
|
request.Body = &body
|
|
|
|
handler := func(ctx context.Context, w http.ResponseWriter, r *http.Request, request interface{}) (interface{}, error) {
|
|
return sh.ssi.UpdateArtifactLabels(ctx, request.(UpdateArtifactLabelsRequestObject))
|
|
}
|
|
for _, middleware := range sh.middlewares {
|
|
handler = middleware(handler, "UpdateArtifactLabels")
|
|
}
|
|
|
|
response, err := handler(r.Context(), w, r, request)
|
|
|
|
if err != nil {
|
|
sh.options.ResponseErrorHandlerFunc(w, r, err)
|
|
} else if validResponse, ok := response.(UpdateArtifactLabelsResponseObject); ok {
|
|
if err := validResponse.VisitUpdateArtifactLabelsResponse(w); err != nil {
|
|
sh.options.ResponseErrorHandlerFunc(w, r, err)
|
|
}
|
|
} else if response != nil {
|
|
sh.options.ResponseErrorHandlerFunc(w, r, fmt.Errorf("unexpected response type: %T", response))
|
|
}
|
|
}
|
|
|
|
// GetArtifactStats operation middleware
|
|
func (sh *strictHandler) GetArtifactStats(w http.ResponseWriter, r *http.Request, registryRef RegistryRefPathParam, artifact ArtifactPathParam, params GetArtifactStatsParams) {
|
|
var request GetArtifactStatsRequestObject
|
|
|
|
request.RegistryRef = registryRef
|
|
request.Artifact = artifact
|
|
request.Params = params
|
|
|
|
handler := func(ctx context.Context, w http.ResponseWriter, r *http.Request, request interface{}) (interface{}, error) {
|
|
return sh.ssi.GetArtifactStats(ctx, request.(GetArtifactStatsRequestObject))
|
|
}
|
|
for _, middleware := range sh.middlewares {
|
|
handler = middleware(handler, "GetArtifactStats")
|
|
}
|
|
|
|
response, err := handler(r.Context(), w, r, request)
|
|
|
|
if err != nil {
|
|
sh.options.ResponseErrorHandlerFunc(w, r, err)
|
|
} else if validResponse, ok := response.(GetArtifactStatsResponseObject); ok {
|
|
if err := validResponse.VisitGetArtifactStatsResponse(w); err != nil {
|
|
sh.options.ResponseErrorHandlerFunc(w, r, err)
|
|
}
|
|
} else if response != nil {
|
|
sh.options.ResponseErrorHandlerFunc(w, r, fmt.Errorf("unexpected response type: %T", response))
|
|
}
|
|
}
|
|
|
|
// GetArtifactSummary operation middleware
|
|
func (sh *strictHandler) GetArtifactSummary(w http.ResponseWriter, r *http.Request, registryRef RegistryRefPathParam, artifact ArtifactPathParam) {
|
|
var request GetArtifactSummaryRequestObject
|
|
|
|
request.RegistryRef = registryRef
|
|
request.Artifact = artifact
|
|
|
|
handler := func(ctx context.Context, w http.ResponseWriter, r *http.Request, request interface{}) (interface{}, error) {
|
|
return sh.ssi.GetArtifactSummary(ctx, request.(GetArtifactSummaryRequestObject))
|
|
}
|
|
for _, middleware := range sh.middlewares {
|
|
handler = middleware(handler, "GetArtifactSummary")
|
|
}
|
|
|
|
response, err := handler(r.Context(), w, r, request)
|
|
|
|
if err != nil {
|
|
sh.options.ResponseErrorHandlerFunc(w, r, err)
|
|
} else if validResponse, ok := response.(GetArtifactSummaryResponseObject); ok {
|
|
if err := validResponse.VisitGetArtifactSummaryResponse(w); err != nil {
|
|
sh.options.ResponseErrorHandlerFunc(w, r, err)
|
|
}
|
|
} else if response != nil {
|
|
sh.options.ResponseErrorHandlerFunc(w, r, fmt.Errorf("unexpected response type: %T", response))
|
|
}
|
|
}
|
|
|
|
// DeleteArtifactVersion operation middleware
|
|
func (sh *strictHandler) DeleteArtifactVersion(w http.ResponseWriter, r *http.Request, registryRef RegistryRefPathParam, artifact ArtifactPathParam, version VersionPathParam) {
|
|
var request DeleteArtifactVersionRequestObject
|
|
|
|
request.RegistryRef = registryRef
|
|
request.Artifact = artifact
|
|
request.Version = version
|
|
|
|
handler := func(ctx context.Context, w http.ResponseWriter, r *http.Request, request interface{}) (interface{}, error) {
|
|
return sh.ssi.DeleteArtifactVersion(ctx, request.(DeleteArtifactVersionRequestObject))
|
|
}
|
|
for _, middleware := range sh.middlewares {
|
|
handler = middleware(handler, "DeleteArtifactVersion")
|
|
}
|
|
|
|
response, err := handler(r.Context(), w, r, request)
|
|
|
|
if err != nil {
|
|
sh.options.ResponseErrorHandlerFunc(w, r, err)
|
|
} else if validResponse, ok := response.(DeleteArtifactVersionResponseObject); ok {
|
|
if err := validResponse.VisitDeleteArtifactVersionResponse(w); err != nil {
|
|
sh.options.ResponseErrorHandlerFunc(w, r, err)
|
|
}
|
|
} else if response != nil {
|
|
sh.options.ResponseErrorHandlerFunc(w, r, fmt.Errorf("unexpected response type: %T", response))
|
|
}
|
|
}
|
|
|
|
// GetDockerArtifactDetails operation middleware
|
|
func (sh *strictHandler) GetDockerArtifactDetails(w http.ResponseWriter, r *http.Request, registryRef RegistryRefPathParam, artifact ArtifactPathParam, version VersionPathParam, params GetDockerArtifactDetailsParams) {
|
|
var request GetDockerArtifactDetailsRequestObject
|
|
|
|
request.RegistryRef = registryRef
|
|
request.Artifact = artifact
|
|
request.Version = version
|
|
request.Params = params
|
|
|
|
handler := func(ctx context.Context, w http.ResponseWriter, r *http.Request, request interface{}) (interface{}, error) {
|
|
return sh.ssi.GetDockerArtifactDetails(ctx, request.(GetDockerArtifactDetailsRequestObject))
|
|
}
|
|
for _, middleware := range sh.middlewares {
|
|
handler = middleware(handler, "GetDockerArtifactDetails")
|
|
}
|
|
|
|
response, err := handler(r.Context(), w, r, request)
|
|
|
|
if err != nil {
|
|
sh.options.ResponseErrorHandlerFunc(w, r, err)
|
|
} else if validResponse, ok := response.(GetDockerArtifactDetailsResponseObject); ok {
|
|
if err := validResponse.VisitGetDockerArtifactDetailsResponse(w); err != nil {
|
|
sh.options.ResponseErrorHandlerFunc(w, r, err)
|
|
}
|
|
} else if response != nil {
|
|
sh.options.ResponseErrorHandlerFunc(w, r, fmt.Errorf("unexpected response type: %T", response))
|
|
}
|
|
}
|
|
|
|
// GetDockerArtifactLayers operation middleware
|
|
func (sh *strictHandler) GetDockerArtifactLayers(w http.ResponseWriter, r *http.Request, registryRef RegistryRefPathParam, artifact ArtifactPathParam, version VersionPathParam, params GetDockerArtifactLayersParams) {
|
|
var request GetDockerArtifactLayersRequestObject
|
|
|
|
request.RegistryRef = registryRef
|
|
request.Artifact = artifact
|
|
request.Version = version
|
|
request.Params = params
|
|
|
|
handler := func(ctx context.Context, w http.ResponseWriter, r *http.Request, request interface{}) (interface{}, error) {
|
|
return sh.ssi.GetDockerArtifactLayers(ctx, request.(GetDockerArtifactLayersRequestObject))
|
|
}
|
|
for _, middleware := range sh.middlewares {
|
|
handler = middleware(handler, "GetDockerArtifactLayers")
|
|
}
|
|
|
|
response, err := handler(r.Context(), w, r, request)
|
|
|
|
if err != nil {
|
|
sh.options.ResponseErrorHandlerFunc(w, r, err)
|
|
} else if validResponse, ok := response.(GetDockerArtifactLayersResponseObject); ok {
|
|
if err := validResponse.VisitGetDockerArtifactLayersResponse(w); err != nil {
|
|
sh.options.ResponseErrorHandlerFunc(w, r, err)
|
|
}
|
|
} else if response != nil {
|
|
sh.options.ResponseErrorHandlerFunc(w, r, fmt.Errorf("unexpected response type: %T", response))
|
|
}
|
|
}
|
|
|
|
// GetDockerArtifactManifest operation middleware
|
|
func (sh *strictHandler) GetDockerArtifactManifest(w http.ResponseWriter, r *http.Request, registryRef RegistryRefPathParam, artifact ArtifactPathParam, version VersionPathParam, params GetDockerArtifactManifestParams) {
|
|
var request GetDockerArtifactManifestRequestObject
|
|
|
|
request.RegistryRef = registryRef
|
|
request.Artifact = artifact
|
|
request.Version = version
|
|
request.Params = params
|
|
|
|
handler := func(ctx context.Context, w http.ResponseWriter, r *http.Request, request interface{}) (interface{}, error) {
|
|
return sh.ssi.GetDockerArtifactManifest(ctx, request.(GetDockerArtifactManifestRequestObject))
|
|
}
|
|
for _, middleware := range sh.middlewares {
|
|
handler = middleware(handler, "GetDockerArtifactManifest")
|
|
}
|
|
|
|
response, err := handler(r.Context(), w, r, request)
|
|
|
|
if err != nil {
|
|
sh.options.ResponseErrorHandlerFunc(w, r, err)
|
|
} else if validResponse, ok := response.(GetDockerArtifactManifestResponseObject); ok {
|
|
if err := validResponse.VisitGetDockerArtifactManifestResponse(w); err != nil {
|
|
sh.options.ResponseErrorHandlerFunc(w, r, err)
|
|
}
|
|
} else if response != nil {
|
|
sh.options.ResponseErrorHandlerFunc(w, r, fmt.Errorf("unexpected response type: %T", response))
|
|
}
|
|
}
|
|
|
|
// GetDockerArtifactManifests operation middleware
|
|
func (sh *strictHandler) GetDockerArtifactManifests(w http.ResponseWriter, r *http.Request, registryRef RegistryRefPathParam, artifact ArtifactPathParam, version VersionPathParam) {
|
|
var request GetDockerArtifactManifestsRequestObject
|
|
|
|
request.RegistryRef = registryRef
|
|
request.Artifact = artifact
|
|
request.Version = version
|
|
|
|
handler := func(ctx context.Context, w http.ResponseWriter, r *http.Request, request interface{}) (interface{}, error) {
|
|
return sh.ssi.GetDockerArtifactManifests(ctx, request.(GetDockerArtifactManifestsRequestObject))
|
|
}
|
|
for _, middleware := range sh.middlewares {
|
|
handler = middleware(handler, "GetDockerArtifactManifests")
|
|
}
|
|
|
|
response, err := handler(r.Context(), w, r, request)
|
|
|
|
if err != nil {
|
|
sh.options.ResponseErrorHandlerFunc(w, r, err)
|
|
} else if validResponse, ok := response.(GetDockerArtifactManifestsResponseObject); ok {
|
|
if err := validResponse.VisitGetDockerArtifactManifestsResponse(w); err != nil {
|
|
sh.options.ResponseErrorHandlerFunc(w, r, err)
|
|
}
|
|
} else if response != nil {
|
|
sh.options.ResponseErrorHandlerFunc(w, r, fmt.Errorf("unexpected response type: %T", response))
|
|
}
|
|
}
|
|
|
|
// GetHelmArtifactDetails operation middleware
|
|
func (sh *strictHandler) GetHelmArtifactDetails(w http.ResponseWriter, r *http.Request, registryRef RegistryRefPathParam, artifact ArtifactPathParam, version VersionPathParam) {
|
|
var request GetHelmArtifactDetailsRequestObject
|
|
|
|
request.RegistryRef = registryRef
|
|
request.Artifact = artifact
|
|
request.Version = version
|
|
|
|
handler := func(ctx context.Context, w http.ResponseWriter, r *http.Request, request interface{}) (interface{}, error) {
|
|
return sh.ssi.GetHelmArtifactDetails(ctx, request.(GetHelmArtifactDetailsRequestObject))
|
|
}
|
|
for _, middleware := range sh.middlewares {
|
|
handler = middleware(handler, "GetHelmArtifactDetails")
|
|
}
|
|
|
|
response, err := handler(r.Context(), w, r, request)
|
|
|
|
if err != nil {
|
|
sh.options.ResponseErrorHandlerFunc(w, r, err)
|
|
} else if validResponse, ok := response.(GetHelmArtifactDetailsResponseObject); ok {
|
|
if err := validResponse.VisitGetHelmArtifactDetailsResponse(w); err != nil {
|
|
sh.options.ResponseErrorHandlerFunc(w, r, err)
|
|
}
|
|
} else if response != nil {
|
|
sh.options.ResponseErrorHandlerFunc(w, r, fmt.Errorf("unexpected response type: %T", response))
|
|
}
|
|
}
|
|
|
|
// GetHelmArtifactManifest operation middleware
|
|
func (sh *strictHandler) GetHelmArtifactManifest(w http.ResponseWriter, r *http.Request, registryRef RegistryRefPathParam, artifact ArtifactPathParam, version VersionPathParam) {
|
|
var request GetHelmArtifactManifestRequestObject
|
|
|
|
request.RegistryRef = registryRef
|
|
request.Artifact = artifact
|
|
request.Version = version
|
|
|
|
handler := func(ctx context.Context, w http.ResponseWriter, r *http.Request, request interface{}) (interface{}, error) {
|
|
return sh.ssi.GetHelmArtifactManifest(ctx, request.(GetHelmArtifactManifestRequestObject))
|
|
}
|
|
for _, middleware := range sh.middlewares {
|
|
handler = middleware(handler, "GetHelmArtifactManifest")
|
|
}
|
|
|
|
response, err := handler(r.Context(), w, r, request)
|
|
|
|
if err != nil {
|
|
sh.options.ResponseErrorHandlerFunc(w, r, err)
|
|
} else if validResponse, ok := response.(GetHelmArtifactManifestResponseObject); ok {
|
|
if err := validResponse.VisitGetHelmArtifactManifestResponse(w); err != nil {
|
|
sh.options.ResponseErrorHandlerFunc(w, r, err)
|
|
}
|
|
} else if response != nil {
|
|
sh.options.ResponseErrorHandlerFunc(w, r, fmt.Errorf("unexpected response type: %T", response))
|
|
}
|
|
}
|
|
|
|
// GetArtifactVersionSummary operation middleware
|
|
func (sh *strictHandler) GetArtifactVersionSummary(w http.ResponseWriter, r *http.Request, registryRef RegistryRefPathParam, artifact ArtifactPathParam, version VersionPathParam) {
|
|
var request GetArtifactVersionSummaryRequestObject
|
|
|
|
request.RegistryRef = registryRef
|
|
request.Artifact = artifact
|
|
request.Version = version
|
|
|
|
handler := func(ctx context.Context, w http.ResponseWriter, r *http.Request, request interface{}) (interface{}, error) {
|
|
return sh.ssi.GetArtifactVersionSummary(ctx, request.(GetArtifactVersionSummaryRequestObject))
|
|
}
|
|
for _, middleware := range sh.middlewares {
|
|
handler = middleware(handler, "GetArtifactVersionSummary")
|
|
}
|
|
|
|
response, err := handler(r.Context(), w, r, request)
|
|
|
|
if err != nil {
|
|
sh.options.ResponseErrorHandlerFunc(w, r, err)
|
|
} else if validResponse, ok := response.(GetArtifactVersionSummaryResponseObject); ok {
|
|
if err := validResponse.VisitGetArtifactVersionSummaryResponse(w); err != nil {
|
|
sh.options.ResponseErrorHandlerFunc(w, r, err)
|
|
}
|
|
} else if response != nil {
|
|
sh.options.ResponseErrorHandlerFunc(w, r, fmt.Errorf("unexpected response type: %T", response))
|
|
}
|
|
}
|
|
|
|
// GetAllArtifactVersions operation middleware
|
|
func (sh *strictHandler) GetAllArtifactVersions(w http.ResponseWriter, r *http.Request, registryRef RegistryRefPathParam, artifact ArtifactPathParam, params GetAllArtifactVersionsParams) {
|
|
var request GetAllArtifactVersionsRequestObject
|
|
|
|
request.RegistryRef = registryRef
|
|
request.Artifact = artifact
|
|
request.Params = params
|
|
|
|
handler := func(ctx context.Context, w http.ResponseWriter, r *http.Request, request interface{}) (interface{}, error) {
|
|
return sh.ssi.GetAllArtifactVersions(ctx, request.(GetAllArtifactVersionsRequestObject))
|
|
}
|
|
for _, middleware := range sh.middlewares {
|
|
handler = middleware(handler, "GetAllArtifactVersions")
|
|
}
|
|
|
|
response, err := handler(r.Context(), w, r, request)
|
|
|
|
if err != nil {
|
|
sh.options.ResponseErrorHandlerFunc(w, r, err)
|
|
} else if validResponse, ok := response.(GetAllArtifactVersionsResponseObject); ok {
|
|
if err := validResponse.VisitGetAllArtifactVersionsResponse(w); err != nil {
|
|
sh.options.ResponseErrorHandlerFunc(w, r, err)
|
|
}
|
|
} else if response != nil {
|
|
sh.options.ResponseErrorHandlerFunc(w, r, fmt.Errorf("unexpected response type: %T", response))
|
|
}
|
|
}
|
|
|
|
// GetAllArtifactsByRegistry operation middleware
|
|
func (sh *strictHandler) GetAllArtifactsByRegistry(w http.ResponseWriter, r *http.Request, registryRef RegistryRefPathParam, params GetAllArtifactsByRegistryParams) {
|
|
var request GetAllArtifactsByRegistryRequestObject
|
|
|
|
request.RegistryRef = registryRef
|
|
request.Params = params
|
|
|
|
handler := func(ctx context.Context, w http.ResponseWriter, r *http.Request, request interface{}) (interface{}, error) {
|
|
return sh.ssi.GetAllArtifactsByRegistry(ctx, request.(GetAllArtifactsByRegistryRequestObject))
|
|
}
|
|
for _, middleware := range sh.middlewares {
|
|
handler = middleware(handler, "GetAllArtifactsByRegistry")
|
|
}
|
|
|
|
response, err := handler(r.Context(), w, r, request)
|
|
|
|
if err != nil {
|
|
sh.options.ResponseErrorHandlerFunc(w, r, err)
|
|
} else if validResponse, ok := response.(GetAllArtifactsByRegistryResponseObject); ok {
|
|
if err := validResponse.VisitGetAllArtifactsByRegistryResponse(w); err != nil {
|
|
sh.options.ResponseErrorHandlerFunc(w, r, err)
|
|
}
|
|
} else if response != nil {
|
|
sh.options.ResponseErrorHandlerFunc(w, r, fmt.Errorf("unexpected response type: %T", response))
|
|
}
|
|
}
|
|
|
|
// GetClientSetupDetails operation middleware
|
|
func (sh *strictHandler) GetClientSetupDetails(w http.ResponseWriter, r *http.Request, registryRef RegistryRefPathParam, params GetClientSetupDetailsParams) {
|
|
var request GetClientSetupDetailsRequestObject
|
|
|
|
request.RegistryRef = registryRef
|
|
request.Params = params
|
|
|
|
handler := func(ctx context.Context, w http.ResponseWriter, r *http.Request, request interface{}) (interface{}, error) {
|
|
return sh.ssi.GetClientSetupDetails(ctx, request.(GetClientSetupDetailsRequestObject))
|
|
}
|
|
for _, middleware := range sh.middlewares {
|
|
handler = middleware(handler, "GetClientSetupDetails")
|
|
}
|
|
|
|
response, err := handler(r.Context(), w, r, request)
|
|
|
|
if err != nil {
|
|
sh.options.ResponseErrorHandlerFunc(w, r, err)
|
|
} else if validResponse, ok := response.(GetClientSetupDetailsResponseObject); ok {
|
|
if err := validResponse.VisitGetClientSetupDetailsResponse(w); err != nil {
|
|
sh.options.ResponseErrorHandlerFunc(w, r, err)
|
|
}
|
|
} else if response != nil {
|
|
sh.options.ResponseErrorHandlerFunc(w, r, fmt.Errorf("unexpected response type: %T", response))
|
|
}
|
|
}
|
|
|
|
// GetArtifactStatsForSpace operation middleware
|
|
func (sh *strictHandler) GetArtifactStatsForSpace(w http.ResponseWriter, r *http.Request, spaceRef SpaceRefPathParam, params GetArtifactStatsForSpaceParams) {
|
|
var request GetArtifactStatsForSpaceRequestObject
|
|
|
|
request.SpaceRef = spaceRef
|
|
request.Params = params
|
|
|
|
handler := func(ctx context.Context, w http.ResponseWriter, r *http.Request, request interface{}) (interface{}, error) {
|
|
return sh.ssi.GetArtifactStatsForSpace(ctx, request.(GetArtifactStatsForSpaceRequestObject))
|
|
}
|
|
for _, middleware := range sh.middlewares {
|
|
handler = middleware(handler, "GetArtifactStatsForSpace")
|
|
}
|
|
|
|
response, err := handler(r.Context(), w, r, request)
|
|
|
|
if err != nil {
|
|
sh.options.ResponseErrorHandlerFunc(w, r, err)
|
|
} else if validResponse, ok := response.(GetArtifactStatsForSpaceResponseObject); ok {
|
|
if err := validResponse.VisitGetArtifactStatsForSpaceResponse(w); err != nil {
|
|
sh.options.ResponseErrorHandlerFunc(w, r, err)
|
|
}
|
|
} else if response != nil {
|
|
sh.options.ResponseErrorHandlerFunc(w, r, fmt.Errorf("unexpected response type: %T", response))
|
|
}
|
|
}
|
|
|
|
// GetAllArtifacts operation middleware
|
|
func (sh *strictHandler) GetAllArtifacts(w http.ResponseWriter, r *http.Request, spaceRef SpaceRefPathParam, params GetAllArtifactsParams) {
|
|
var request GetAllArtifactsRequestObject
|
|
|
|
request.SpaceRef = spaceRef
|
|
request.Params = params
|
|
|
|
handler := func(ctx context.Context, w http.ResponseWriter, r *http.Request, request interface{}) (interface{}, error) {
|
|
return sh.ssi.GetAllArtifacts(ctx, request.(GetAllArtifactsRequestObject))
|
|
}
|
|
for _, middleware := range sh.middlewares {
|
|
handler = middleware(handler, "GetAllArtifacts")
|
|
}
|
|
|
|
response, err := handler(r.Context(), w, r, request)
|
|
|
|
if err != nil {
|
|
sh.options.ResponseErrorHandlerFunc(w, r, err)
|
|
} else if validResponse, ok := response.(GetAllArtifactsResponseObject); ok {
|
|
if err := validResponse.VisitGetAllArtifactsResponse(w); err != nil {
|
|
sh.options.ResponseErrorHandlerFunc(w, r, err)
|
|
}
|
|
} else if response != nil {
|
|
sh.options.ResponseErrorHandlerFunc(w, r, fmt.Errorf("unexpected response type: %T", response))
|
|
}
|
|
}
|
|
|
|
// GetAllRegistries operation middleware
|
|
func (sh *strictHandler) GetAllRegistries(w http.ResponseWriter, r *http.Request, spaceRef SpaceRefPathParam, params GetAllRegistriesParams) {
|
|
var request GetAllRegistriesRequestObject
|
|
|
|
request.SpaceRef = spaceRef
|
|
request.Params = params
|
|
|
|
handler := func(ctx context.Context, w http.ResponseWriter, r *http.Request, request interface{}) (interface{}, error) {
|
|
return sh.ssi.GetAllRegistries(ctx, request.(GetAllRegistriesRequestObject))
|
|
}
|
|
for _, middleware := range sh.middlewares {
|
|
handler = middleware(handler, "GetAllRegistries")
|
|
}
|
|
|
|
response, err := handler(r.Context(), w, r, request)
|
|
|
|
if err != nil {
|
|
sh.options.ResponseErrorHandlerFunc(w, r, err)
|
|
} else if validResponse, ok := response.(GetAllRegistriesResponseObject); ok {
|
|
if err := validResponse.VisitGetAllRegistriesResponse(w); err != nil {
|
|
sh.options.ResponseErrorHandlerFunc(w, r, err)
|
|
}
|
|
} else if response != nil {
|
|
sh.options.ResponseErrorHandlerFunc(w, r, fmt.Errorf("unexpected response type: %T", response))
|
|
}
|
|
}
|
|
|
|
// Base64 encoded, gzipped, json marshaled Swagger object
|
|
var swaggerSpec = []string{
|
|
|
|
"H4sIAAAAAAAC/+xdXXPUuNL+Ky6976XJhF3OuZi7kARInQRyMoQqaouiFLtnxou/VpITslT++ylJlq2x",
|
|
"JVuezBeLrwjjlrqtfrrVklrtHyjIkjxLIWUUTX+gHBOcAAMi/neJ7yCm1/w3/t8QaECinEVZiqby4RHy",
|
|
"UcT/91cB5BH5KMUJoCmK+UPkIxosIcG8ccQgEZ2yx5xTUEaidIGefPUDJgQ/oqcnH93AIqKMPF6EkLJo",
|
|
"HgGxiKAIvZrSIg+BxddIJ3qWYB8fc+gTidNYhGHyUS0CpEWCpn+gTxc3H29PLpGPbq9nH2/OT67QF78p",
|
|
"15OPMGHRHAfMIsOJeMws3FXjFQm6eLClhc97nICXzT1FWoEhx2xpZEjgryIiEKIpIwV0CxBGC6C2VzwT",
|
|
"D23ok00H8puTLDnDzKZY/ujIe5ORBDPvhXd1NTk7m3z+/PmzRQbeXc8Qx5gBZZ+AUMGibWD8sVc+995E",
|
|
"MQNiNzhO/PW+7MzA+C7LYsCp4Jzj4BtegAuOryVpF57L3r62cD3AtHK8gPdFcgekLctpQQikzOM0XiqJ",
|
|
"bJIsViUIYY6LmKHpSx/Nhe7QFEUp+/crVAkRpQwWQCoxZtHfYAC74MvhLt7Ky4F4JTuTJJR3YpTkt2M3",
|
|
"UUipgRuYd9jgbRr9VYCniD1uehY7VDRfCcwH2gYFTILlRyAGCeQzjz+0gVOSfGW8fQ+jjLA3EcShgU/1",
|
|
"yMIkI+zrvCTo4/GBhCak1Y86eGQlQSePHAfgpDlB2aU2QbCOzkoR/stfwVUG23trMnTxZNkGPSjLeriV",
|
|
"zs7C7lPlCk2ddzhKE4feOfCknOSUu7Yos2brrsonSQyUvc7CCIRDVexEEHYjn/LfgyxlkIo/cZ7HUYC5",
|
|
"nJM/qZxgaib/z5U5Rf83qeO/iXxKJ8bOhRyr715K5bHMK/IQM6giAU/EfxRpMdOmhWz22yHfPCNeQEAI",
|
|
"mIZKVuUOS2dL8yylxsGVTwYJnpMsB8JKZYWYOY/5rEgSzIXyEWWYFbSv4UxSKZRISP2hGvuSeR1FZnd/",
|
|
"QmAZLfmiXJ0LYA1deuoxl6wSlmFGdz1AnOchDQ/vipqHR+pyRBCtRVJSlm5yP0O0yvwARirMgm9A6gEr",
|
|
"pwl94F7jcNMu9JyQjJjEe41Djyi/6qPTOIKUzYAV+RkwHMW7svk2433qSkwjQiKPcpG8sJbpTChQ4UsK",
|
|
"u6NBMrE+QEiHlWCrAl/hNJoDZXsZLcX8AMcr0USTQl/iRyB0p+MkWR5kTMIFq8dGKXK3w1NxPcyheQdx",
|
|
"sheX1GZ8AAO0hDgxuSNd2B07IxPrgxsp3RFdpAxIiuMZkHsgMn7YejSimHpUcPVAEvroMqJsH2u1Ft99",
|
|
"RyVxRJlp7a0LuoexOahhaY5HuQbYw7CojalDGJ1yoUH1Yxw1UmqHZQ8IarI+SCTVO1A7H5eDGA+iCfM+",
|
|
"Y2+yIg23Pxt8XIJHcwiieQR8lUqzggTgPWDqpRnz5kKKlX3HnWjnUDQj9zl9GRKaNjt9NCuCACh9xoBs",
|
|
"4gVd3qyU1LvRNtduU1ywJaSMCws7AFyTYSVDRqK/dydAyU2c7MgWYqs6zdLHJBPK0HbXmscCq+orA4Rh",
|
|
"B7S6CssO2iqsJbgChpXdmLITAuZVJH7T3rKHNM5wSE+zQo5q73mpv8ZL8TaUXWWhcCXGBvLUxvBAO0Dv",
|
|
"0+u1RspbFnF8miUJTs0sSSv5pZPsGrOlkeC+Titon2vpyhTvaOTbzFBocO1Sv9ylb+n+HSYpN+gKA5LO",
|
|
"BoAh+ldt1Om9QxOWMRzPWEa0Q3+HZkU+iM9T1zCVOysOA1VSNodK+vvwhBlBsJYlRQlewHsb8texs6S0",
|
|
"MYuU6xpTA8i13KtdduG0hLaDt1JpOHavJZKOqoG2I3SYMmgrS6iZz/PP9mO0tLM9OLHGMVE7oUFu2bYg",
|
|
"YrPVbsOK6GW/ptfXl/N8oJtRna7Qa1AFWyqpGhZUR098cMokMZXyeEuBXGNKHzISIl+LZ9qJjz465cNQ",
|
|
"5NdZHAUGfZSPPflchMMtP1rG6VwjTfXA9zwicIYfqdl++4zomsA8+j7MM6oEk8FNTbOK4bjMMEbiAEsQ",
|
|
"eYqqORIJjtJ3gEOLzVIIup9yXqtThOMp30y27Q1ANQF1cTTmX7rHRzHqHh9F1RyfZcfbM8jXe3UG+WA1",
|
|
"i0Y978BJWlGDdNwDp/GO12YODqkhdzWH972g2a0YiJq+hQeXUYB89BZSIJjBx+wbpEbPYjxE7XX4Jd3e",
|
|
"YzKnqWNLQZh7JDB0ivdRQeLnrW3Mc9mKQJJL/wRnOTjuxUhF2XaydRfdb1FR2uUSB7XnKXNaS8hTXZtT",
|
|
"eEYUpnrokZP2LnskmTWQKvP7zcuTx/LyipMDbo2ewe1l9IQEy/63L6Wyv7yCgnVydtZUt4Oxj471VVw1",
|
|
"XN2siJVkZZf9b93xvjXJFkLmROc/ABRNbdmjt/X8kGnEqhPVpmWGhhnw4xK8JWO5PBD1BJGP4DtO8hjQ",
|
|
"9NXxK8NEF9qwdxKGEf8TxyqvycN3WcE8toTyyNUgcAKU4oVFOAKY8ohf/Fmm4uIohhD5vY5EvIvq3TRU",
|
|
"hhyDNr4gTnpn6+pYx4SwbUzl42S99cnamFjRA49tT9QrJ+Nt85NnatpNAmpFKnVpjnw3Z9fasDf4Od5R",
|
|
"BfG2nYt91PJiVnVBSndFLpev5N2rAVw4+SqX42NnPhdpCN/NfALttpnevXvn5gtkvO/UfolMHyzjbbAa",
|
|
"ZjUO+nAms1M60GKIOMT2bmse3gkC1tlbHlHjiJqOQztTdoqDi6myR6ye6pMiGNjbIM/V3MMfHdjP78Cq",
|
|
"dIohvqtjb3cEwH4BUMVxagW/lk6d3IKCjt0fNNCoSdYHxwOM35qijW7wH+IGr1fXeM2crzkQ6rHMK5dC",
|
|
"2rb32YfT/5zfIB9dnXw6f4989Pb8/fnNxSny0bvzyyvj/rfd39ossr0rh+M4e4DwGjMGJB0Wxd3FWfBt",
|
|
"zbZB81TQ8ehFb2XqNkvn0cLV/E4ldf+WgT64pi2t7uPyA8q+sK34zSfzK8V3ynMat7W81cH91JlltqyO",
|
|
"reZsbCYnY5upFw1zaql4VtzJRyoHOBDH/J8iwgocexnxbnPKCOBE91NhxPtIohQzub2a4Dzn7zL9UVda",
|
|
"sgyh6q+UyK+KNFnoS1Fqf1Ai8PG9VvzpyUdZCh/maPpHtwKbvXVTN2R9+tLEv8sxrV7kqqVs1melduu0",
|
|
"TiR2c60myEGJgD0edr1N28275V4X8YxNXtvmrbK/mW0TdzhAHKeB0uXr79SYFHg3XciypjOPcce+Iovn",
|
|
"IJTH5jecvvdYwBA5uMYMfcEzb8ij+Kp8VnQE3n09mRSlQzXNIRa/PqiWn49m1VWK5qXHUNw3oF40XzlB",
|
|
"e8DUo/JexLwQQqYZ05Nebk9Pz2cz5KM3JxeXtzfnyEfnNzcfbozsGzNGO8tG/F4QmbtnzKhTXVyT7Ltp",
|
|
"6wUX0hm5TXgr+YB9812dLfj05ckXnFywWOUqimJgBQlAL8IoT3+XxR3y0WlBWZYYR87J61UStUDqo+8v",
|
|
"ViD14h7HBSeo4MLVo49G+xoOBARYTzAniWY5DuAiNCc2aiTWY7+CArGcwzfeuaLkZlqKzrWzGsoMQJoK",
|
|
"7lz2+YoGGJ+VUcl/itJ5pq74lBs/ZSkvezzzwgvhHmIuFy0ntilaMpbT6WTy8PBwtJRNj6JMiBGxuLvD",
|
|
"k+sL7Ux0il4eHR8diyAyhxTnEZqi38VPcuoXbzsh2pI+z0znn6dlTayK0RESXUodcLSUJPqSXysQazHl",
|
|
"mmRiqEHHg9K6nNmjzVZXKp61i301Knb9dvzS3lFJN2ndCHzy0avj4/6GWukd0cSBl+HS2Kvj313bqbte",
|
|
"PvqXi3ymW/ninphKs1Ka1vXM8IKrEGnG9IU3qnAz+aEXjHyS8ImBGSbUM/G7BiQvkmkfOAh4kC3Mmf9/",
|
|
"Ed1D6n2DxxbQZBdrA81YLFNCbQUmDqOprkf+BOh4dfyqv1F1NXdzcGrp24YnHy2AmYrLsoKktIZLmWM1",
|
|
"HDZvgR0CZn5G17Iv8NiUb8dQXhgwdCsuNtNnOR2x/H7cBoA2Pr+NINwoCNvoWWNKnKj9qUm9eDb6u8uI",
|
|
"smaKTTvWaiXu0A0h0u9tp1XfdqQWO0gOtFrl6PVcq73IzwhvK7xNgNMAXh9RO+KbquvcRni/Bda40X1k",
|
|
"mqhX7oa/yciG/W4/Flcr/Ds00MtZr4dec6XcEblW5Lax9Bzc/lB/uSxfTrTPWJgWJ1pmxm7w2v4Ex7ii",
|
|
"2e6KRlPxBjCnhQUdIWx/YCDp9hQa2EA4MMI115R/jksdg4FBse4mwwEN4puPDPaJ7DGGGGOILrDX91Yd",
|
|
"4C6JuwFfX3D9qSIK2xcORlA6grLS+yZgWR4MTX6UfwwJdvXv1XQFvZ+0SjAH65xbn+sZ4+UtnwCkLSBt",
|
|
"C9MTWSB/ol1gtvpgc50OavLEpsIf9GdDeX8b/WOK6xlF5xcuRkvpsBSOzjvwrMVjlLk0CDZqNXVZDGej",
|
|
"qWpP9NhMXaNiNBmTyTQ+2zGaynBTqSC2C1PRr/s7G4tWPKDHXPQyA6PBdM0xrY9xjKYz3HQ0uO3SeOha",
|
|
"1kPdzYf+EisR28eNRktY3xK2Po8sIU6climm8kRGE2jXOvo14N/xAavRAvotwFL+SoF/5fEGoe8UQFlr",
|
|
"L3WC/2cNnp6N/jEWejb+DZHQFixg0BFBo2B451FBoxj5r2AAPd8KHk3A7bChXZZ+gxu03UmP1MNxLJJw",
|
|
"m9JYDoLj+KRZOuqgkb7FxMmMsA8kdOuYE7+JIA53npLZ/IzeaJSOSZkavtc1x6G2R0VKvJZ22WV/9PXj",
|
|
"zhM0ZWbKaHx9xmf9MuNofW7W17KEwan/8kPwL8SH4F/0LfbVlZfTywvP9AEO7w5TCL0sVdWc1JcMWgZq",
|
|
"+MTH7ufHoVHg+hFg+3VHqLvfsLLBrQvv4sYunfwQ/+7iFoC4dr72xeIxd+9Xzt3rAOvg2KhvPUJ3g9Gb",
|
|
"VhmtXyYc6qdeLSf2/MXLaJBD4ybNGIXj7rDE1YKvDqZYz0U2W1wt/LF9Y9TKDA024EGNfvmVzGiJjpa4",
|
|
"YgJtUxTVfHgH0iiay5BqvSNr0kxwHk3uXwr9lX21ampeX4hKWeq74vJ74v7KF+ClMGVZHE1ADiJzbwtg",
|
|
"/upH9bUeamfT2UH1mZps7snsA1NnrRNe5z6XECemHhuHBk9fnv4XAAD//+yPry5FnQAA",
|
|
}
|
|
|
|
// GetSwagger returns the content of the embedded swagger specification file
|
|
// or error if failed to decode
|
|
func decodeSpec() ([]byte, error) {
|
|
zipped, err := base64.StdEncoding.DecodeString(strings.Join(swaggerSpec, ""))
|
|
if err != nil {
|
|
return nil, fmt.Errorf("error base64 decoding spec: %w", err)
|
|
}
|
|
zr, err := gzip.NewReader(bytes.NewReader(zipped))
|
|
if err != nil {
|
|
return nil, fmt.Errorf("error decompressing spec: %w", err)
|
|
}
|
|
var buf bytes.Buffer
|
|
_, err = buf.ReadFrom(zr)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("error decompressing spec: %w", err)
|
|
}
|
|
|
|
return buf.Bytes(), nil
|
|
}
|
|
|
|
var rawSpec = decodeSpecCached()
|
|
|
|
// a naive cached of a decoded swagger spec
|
|
func decodeSpecCached() func() ([]byte, error) {
|
|
data, err := decodeSpec()
|
|
return func() ([]byte, error) {
|
|
return data, err
|
|
}
|
|
}
|
|
|
|
// Constructs a synthetic filesystem for resolving external references when loading openapi specifications.
|
|
func PathToRawSpec(pathToFile string) map[string]func() ([]byte, error) {
|
|
res := make(map[string]func() ([]byte, error))
|
|
if len(pathToFile) > 0 {
|
|
res[pathToFile] = rawSpec
|
|
}
|
|
|
|
return res
|
|
}
|
|
|
|
// GetSwagger returns the Swagger specification corresponding to the generated code
|
|
// in this file. The external references of Swagger specification are resolved.
|
|
// The logic of resolving external references is tightly connected to "import-mapping" feature.
|
|
// Externally referenced files must be embedded in the corresponding golang packages.
|
|
// Urls can be supported but this task was out of the scope.
|
|
func GetSwagger() (swagger *openapi3.T, err error) {
|
|
resolvePath := PathToRawSpec("")
|
|
|
|
loader := openapi3.NewLoader()
|
|
loader.IsExternalRefsAllowed = true
|
|
loader.ReadFromURIFunc = func(loader *openapi3.Loader, url *url.URL) ([]byte, error) {
|
|
pathToFile := url.String()
|
|
pathToFile = path.Clean(pathToFile)
|
|
getSpec, ok := resolvePath[pathToFile]
|
|
if !ok {
|
|
err1 := fmt.Errorf("path not found: %s", pathToFile)
|
|
return nil, err1
|
|
}
|
|
return getSpec()
|
|
}
|
|
var specData []byte
|
|
specData, err = rawSpec()
|
|
if err != nil {
|
|
return
|
|
}
|
|
swagger, err = loader.LoadFromData(specData)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|