mirror of
https://github.com/containers/podman.git
synced 2026-03-16 05:40:19 -04:00
8a7e70919f
* Update method/function signatures use the manifest list name and
images associated with the operation explicitly, in general
func f(ctx context.Context, manifestListName string,
ImageNames []string, options *fOptions)
* Leverage gorilla/mux Subrouters to support API v3.x and v4.x for
manifests
* Make manifest API endpoints more RESTful
* Add PUT /manifest/{id} to update existing manifests
* Add manifests.Annotate to go bindings, uncommented unit test
* Add DELETE /manifest/{Id} to remove existing manifest list, use
PUT /manifest/{id} to remove images from a list
* Deprecated POST /manifest/{id}/add and /manifest/{id}/remove, use
PUT /manifest/{id} instead
* Corrected swagger godoc and updated to cover API changes
* Update podman manifest commands to use registry.Context()
* Expose utils.GetVar() to obtain query parameters by name
* Unexpose server.registerSwaggerHandlers, not sure why this was ever
exposed.
* Refactored code to use http.Header instead of map[string]string when
operating on HTTP headers.
* Add API-Version header support in bindings to allow calling explicate
versions of the API. Header is _NOT_ forwarded to the API service.
Signed-off-by: Jhon Honce <jhonce@redhat.com>
60 lines
1.6 KiB
Go
60 lines
1.6 KiB
Go
package bindings
|
|
|
|
import (
|
|
"encoding/json"
|
|
"io/ioutil"
|
|
|
|
"github.com/containers/podman/v3/pkg/errorhandling"
|
|
"github.com/pkg/errors"
|
|
)
|
|
|
|
var (
|
|
ErrNotImplemented = errors.New("function not implemented")
|
|
)
|
|
|
|
func handleError(data []byte, unmarshalErrorInto interface{}) error {
|
|
if err := json.Unmarshal(data, unmarshalErrorInto); err != nil {
|
|
return err
|
|
}
|
|
return unmarshalErrorInto.(error)
|
|
}
|
|
|
|
// Process drains the response body, and processes the HTTP status code
|
|
// Note: Closing the response.Body is left to the caller
|
|
func (h APIResponse) Process(unmarshalInto interface{}) error {
|
|
return h.ProcessWithError(unmarshalInto, &errorhandling.ErrorModel{})
|
|
}
|
|
|
|
// ProcessWithError drains the response body, and processes the HTTP status code
|
|
// Note: Closing the response.Body is left to the caller
|
|
func (h APIResponse) ProcessWithError(unmarshalInto interface{}, unmarshalErrorInto interface{}) error {
|
|
data, err := ioutil.ReadAll(h.Response.Body)
|
|
if err != nil {
|
|
return errors.Wrap(err, "unable to process API response")
|
|
}
|
|
if h.IsSuccess() || h.IsRedirection() {
|
|
if unmarshalInto != nil {
|
|
return json.Unmarshal(data, unmarshalInto)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
if h.IsConflictError() {
|
|
return handleError(data, unmarshalErrorInto)
|
|
}
|
|
|
|
// TODO should we add a debug here with the response code?
|
|
return handleError(data, &errorhandling.ErrorModel{})
|
|
}
|
|
|
|
func CheckResponseCode(inError error) (int, error) {
|
|
switch e := inError.(type) {
|
|
case *errorhandling.ErrorModel:
|
|
return e.Code(), nil
|
|
case *errorhandling.PodConflictErrorModel:
|
|
return e.Code(), nil
|
|
default:
|
|
return -1, errors.New("error is not type ErrorModel")
|
|
}
|
|
}
|