mirror of
https://github.com/hanzo-go/sdk.git
synced 2026-11-20 20:13:42 +00:00
1667 lines
60 KiB
Go
1667 lines
60 KiB
Go
/*
|
|
Hanzo Cloud API
|
|
|
|
The Hanzo Cloud API as a customer calls it: every operation under /v1/ except the operator's admin product, relay routes, legacy spellings and capabilities still reached by flag. Tagged by product: the first path segment after /v1/.
|
|
|
|
API version: v1
|
|
*/
|
|
|
|
// Code generated by OpenAPI Generator (https://openapi-generator.tech); DO NOT EDIT.
|
|
|
|
package hanzoai
|
|
|
|
import (
|
|
"bytes"
|
|
"context"
|
|
"io"
|
|
"net/http"
|
|
"net/url"
|
|
"strings"
|
|
)
|
|
|
|
// S3APIService S3API service
|
|
type S3APIService service
|
|
|
|
type S3APIDeleteS3BucketsByBucketRequest struct {
|
|
ctx context.Context
|
|
ApiService *S3APIService
|
|
bucket string
|
|
}
|
|
|
|
func (r S3APIDeleteS3BucketsByBucketRequest) Execute() (*http.Response, error) {
|
|
return r.ApiService.DeleteS3BucketsByBucketExecute(r)
|
|
}
|
|
|
|
/*
|
|
DeleteS3BucketsByBucket Removes an EMPTY bucket and answers 204.
|
|
|
|
Removes an EMPTY bucket and answers 204.
|
|
|
|
It requires an admin of the org, or a SuperAdmin, as creating one does; anyone
|
|
else is refused 403 with nothing deleted.
|
|
|
|
A non-empty bucket is 409 rather than a cascade: deleting a tenant's objects
|
|
behind a single bucket call is not a thing this surface will do silently. A
|
|
bucket the caller's org does not own is the same 404 an unknown name gives.
|
|
|
|
Billed per call: the balance is checked BEFORE anything is touched, so an
|
|
unfunded org is refused with nothing deleted, and the debit lands only once the
|
|
bucket is gone.
|
|
|
|
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
|
@param bucket Bucket is the bucket's friendly name, from the path.
|
|
@return S3APIDeleteS3BucketsByBucketRequest
|
|
*/
|
|
func (a *S3APIService) DeleteS3BucketsByBucket(ctx context.Context, bucket string) S3APIDeleteS3BucketsByBucketRequest {
|
|
return S3APIDeleteS3BucketsByBucketRequest{
|
|
ApiService: a,
|
|
ctx: ctx,
|
|
bucket: bucket,
|
|
}
|
|
}
|
|
|
|
// Execute executes the request
|
|
func (a *S3APIService) DeleteS3BucketsByBucketExecute(r S3APIDeleteS3BucketsByBucketRequest) (*http.Response, error) {
|
|
var (
|
|
localVarHTTPMethod = http.MethodDelete
|
|
localVarPostBody interface{}
|
|
formFiles []formFile
|
|
)
|
|
|
|
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "S3APIService.DeleteS3BucketsByBucket")
|
|
if err != nil {
|
|
return nil, &GenericOpenAPIError{error: err.Error()}
|
|
}
|
|
|
|
localVarPath := localBasePath + "/v1/s3/buckets/{bucket}"
|
|
localVarPath = strings.Replace(localVarPath, "{"+"bucket"+"}", url.PathEscape(parameterValueToString(r.bucket, "bucket")), -1)
|
|
|
|
localVarHeaderParams := make(map[string]string)
|
|
localVarQueryParams := url.Values{}
|
|
localVarFormParams := url.Values{}
|
|
|
|
// to determine the Content-Type header
|
|
localVarHTTPContentTypes := []string{}
|
|
|
|
// set Content-Type header
|
|
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
|
|
if localVarHTTPContentType != "" {
|
|
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
|
|
}
|
|
|
|
// to determine the Accept header
|
|
localVarHTTPHeaderAccepts := []string{"application/problem+json"}
|
|
|
|
// set Accept header
|
|
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
|
|
if localVarHTTPHeaderAccept != "" {
|
|
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
|
|
}
|
|
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
localVarHTTPResponse, err := a.client.callAPI(req)
|
|
if err != nil || localVarHTTPResponse == nil {
|
|
return localVarHTTPResponse, err
|
|
}
|
|
|
|
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
|
|
localVarHTTPResponse.Body.Close()
|
|
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
|
|
if err != nil {
|
|
return localVarHTTPResponse, err
|
|
}
|
|
|
|
if localVarHTTPResponse.StatusCode >= 300 {
|
|
newErr := &GenericOpenAPIError{
|
|
body: localVarBody,
|
|
error: localVarHTTPResponse.Status,
|
|
}
|
|
var v ProblemDetails
|
|
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
newErr.error = err.Error()
|
|
return localVarHTTPResponse, newErr
|
|
}
|
|
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
|
|
newErr.model = v
|
|
return localVarHTTPResponse, newErr
|
|
}
|
|
|
|
return localVarHTTPResponse, nil
|
|
}
|
|
|
|
type S3APIDeleteS3BucketsByBucketObjectsByWildcard1Request struct {
|
|
ctx context.Context
|
|
ApiService *S3APIService
|
|
bucket string
|
|
wildcard1 string
|
|
}
|
|
|
|
func (r S3APIDeleteS3BucketsByBucketObjectsByWildcard1Request) Execute() (*http.Response, error) {
|
|
return r.ApiService.DeleteS3BucketsByBucketObjectsByWildcard1Execute(r)
|
|
}
|
|
|
|
/*
|
|
DeleteS3BucketsByBucketObjectsByWildcard1 Removes one object and answers 204.
|
|
|
|
Removes one object and answers 204.
|
|
|
|
It removes ONE object and never a prefix: a key that looks like a folder deletes
|
|
the placeholder at that key, not the objects beneath it. The key is path-cleaned
|
|
first, so the delete cannot reach outside the bucket it names, and a bucket the
|
|
caller's org does not own is the same 404 an unknown name gives.
|
|
|
|
Billed per call: the balance is checked BEFORE anything is touched, so an
|
|
unfunded org is refused with nothing deleted, and the debit lands only once the
|
|
object is gone.
|
|
|
|
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
|
@param bucket Bucket is the bucket's friendly name, from the path.
|
|
@param wildcard1 Key is the object's key within the bucket — everything after that bucket's /objects/. It MAY contain \"/\", because a key is a path and this segment is captured whole: \"2019/summer/a.jpg\" is one key, not three. It is path-cleaned before use, so \"../\" reaches nothing outside the bucket, and a key that is empty, absolute or a bare folder marker is refused 400.
|
|
@return S3APIDeleteS3BucketsByBucketObjectsByWildcard1Request
|
|
*/
|
|
func (a *S3APIService) DeleteS3BucketsByBucketObjectsByWildcard1(ctx context.Context, bucket string, wildcard1 string) S3APIDeleteS3BucketsByBucketObjectsByWildcard1Request {
|
|
return S3APIDeleteS3BucketsByBucketObjectsByWildcard1Request{
|
|
ApiService: a,
|
|
ctx: ctx,
|
|
bucket: bucket,
|
|
wildcard1: wildcard1,
|
|
}
|
|
}
|
|
|
|
// Execute executes the request
|
|
func (a *S3APIService) DeleteS3BucketsByBucketObjectsByWildcard1Execute(r S3APIDeleteS3BucketsByBucketObjectsByWildcard1Request) (*http.Response, error) {
|
|
var (
|
|
localVarHTTPMethod = http.MethodDelete
|
|
localVarPostBody interface{}
|
|
formFiles []formFile
|
|
)
|
|
|
|
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "S3APIService.DeleteS3BucketsByBucketObjectsByWildcard1")
|
|
if err != nil {
|
|
return nil, &GenericOpenAPIError{error: err.Error()}
|
|
}
|
|
|
|
localVarPath := localBasePath + "/v1/s3/buckets/{bucket}/objects/{wildcard1}"
|
|
localVarPath = strings.Replace(localVarPath, "{"+"bucket"+"}", url.PathEscape(parameterValueToString(r.bucket, "bucket")), -1)
|
|
localVarPath = strings.Replace(localVarPath, "{"+"wildcard1"+"}", url.PathEscape(parameterValueToString(r.wildcard1, "wildcard1")), -1)
|
|
|
|
localVarHeaderParams := make(map[string]string)
|
|
localVarQueryParams := url.Values{}
|
|
localVarFormParams := url.Values{}
|
|
|
|
// to determine the Content-Type header
|
|
localVarHTTPContentTypes := []string{}
|
|
|
|
// set Content-Type header
|
|
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
|
|
if localVarHTTPContentType != "" {
|
|
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
|
|
}
|
|
|
|
// to determine the Accept header
|
|
localVarHTTPHeaderAccepts := []string{"application/problem+json"}
|
|
|
|
// set Accept header
|
|
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
|
|
if localVarHTTPHeaderAccept != "" {
|
|
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
|
|
}
|
|
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
localVarHTTPResponse, err := a.client.callAPI(req)
|
|
if err != nil || localVarHTTPResponse == nil {
|
|
return localVarHTTPResponse, err
|
|
}
|
|
|
|
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
|
|
localVarHTTPResponse.Body.Close()
|
|
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
|
|
if err != nil {
|
|
return localVarHTTPResponse, err
|
|
}
|
|
|
|
if localVarHTTPResponse.StatusCode >= 300 {
|
|
newErr := &GenericOpenAPIError{
|
|
body: localVarBody,
|
|
error: localVarHTTPResponse.Status,
|
|
}
|
|
var v ProblemDetails
|
|
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
newErr.error = err.Error()
|
|
return localVarHTTPResponse, newErr
|
|
}
|
|
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
|
|
newErr.model = v
|
|
return localVarHTTPResponse, newErr
|
|
}
|
|
|
|
return localVarHTTPResponse, nil
|
|
}
|
|
|
|
type S3APIDeleteS3BucketsByBucketUploadsByUploadRequest struct {
|
|
ctx context.Context
|
|
ApiService *S3APIService
|
|
bucket string
|
|
upload string
|
|
key *string
|
|
}
|
|
|
|
// Key is the object key the upload was started on. In the query for a read or an abandon, in the body to complete.
|
|
func (r S3APIDeleteS3BucketsByBucketUploadsByUploadRequest) Key(key string) S3APIDeleteS3BucketsByBucketUploadsByUploadRequest {
|
|
r.key = &key
|
|
return r
|
|
}
|
|
|
|
func (r S3APIDeleteS3BucketsByBucketUploadsByUploadRequest) Execute() (*S3UploadGone, *http.Response, error) {
|
|
return r.ApiService.DeleteS3BucketsByBucketUploadsByUploadExecute(r)
|
|
}
|
|
|
|
/*
|
|
DeleteS3BucketsByBucketUploadsByUpload Aborts a multipart upload and deletes the parts it stored.
|
|
|
|
Aborts a multipart upload and deletes the parts it stored. The
|
|
object it would have become is never created.
|
|
|
|
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
|
@param bucket Bucket is the bucket, from the path.
|
|
@param upload Upload is the upload's id, from the path.
|
|
@return S3APIDeleteS3BucketsByBucketUploadsByUploadRequest
|
|
*/
|
|
func (a *S3APIService) DeleteS3BucketsByBucketUploadsByUpload(ctx context.Context, bucket string, upload string) S3APIDeleteS3BucketsByBucketUploadsByUploadRequest {
|
|
return S3APIDeleteS3BucketsByBucketUploadsByUploadRequest{
|
|
ApiService: a,
|
|
ctx: ctx,
|
|
bucket: bucket,
|
|
upload: upload,
|
|
}
|
|
}
|
|
|
|
// Execute executes the request
|
|
//
|
|
// @return S3UploadGone
|
|
func (a *S3APIService) DeleteS3BucketsByBucketUploadsByUploadExecute(r S3APIDeleteS3BucketsByBucketUploadsByUploadRequest) (*S3UploadGone, *http.Response, error) {
|
|
var (
|
|
localVarHTTPMethod = http.MethodDelete
|
|
localVarPostBody interface{}
|
|
formFiles []formFile
|
|
localVarReturnValue *S3UploadGone
|
|
)
|
|
|
|
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "S3APIService.DeleteS3BucketsByBucketUploadsByUpload")
|
|
if err != nil {
|
|
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
|
}
|
|
|
|
localVarPath := localBasePath + "/v1/s3/buckets/{bucket}/uploads/{upload}"
|
|
localVarPath = strings.Replace(localVarPath, "{"+"bucket"+"}", url.PathEscape(parameterValueToString(r.bucket, "bucket")), -1)
|
|
localVarPath = strings.Replace(localVarPath, "{"+"upload"+"}", url.PathEscape(parameterValueToString(r.upload, "upload")), -1)
|
|
|
|
localVarHeaderParams := make(map[string]string)
|
|
localVarQueryParams := url.Values{}
|
|
localVarFormParams := url.Values{}
|
|
|
|
if r.key != nil {
|
|
parameterAddToHeaderOrQuery(localVarQueryParams, "key", r.key, "form", "")
|
|
}
|
|
// to determine the Content-Type header
|
|
localVarHTTPContentTypes := []string{}
|
|
|
|
// set Content-Type header
|
|
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
|
|
if localVarHTTPContentType != "" {
|
|
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
|
|
}
|
|
|
|
// to determine the Accept header
|
|
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
|
|
|
|
// set Accept header
|
|
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
|
|
if localVarHTTPHeaderAccept != "" {
|
|
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
|
|
}
|
|
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
|
|
if err != nil {
|
|
return localVarReturnValue, nil, err
|
|
}
|
|
|
|
localVarHTTPResponse, err := a.client.callAPI(req)
|
|
if err != nil || localVarHTTPResponse == nil {
|
|
return localVarReturnValue, localVarHTTPResponse, err
|
|
}
|
|
|
|
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
|
|
localVarHTTPResponse.Body.Close()
|
|
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
|
|
if err != nil {
|
|
return localVarReturnValue, localVarHTTPResponse, err
|
|
}
|
|
|
|
if localVarHTTPResponse.StatusCode >= 300 {
|
|
newErr := &GenericOpenAPIError{
|
|
body: localVarBody,
|
|
error: localVarHTTPResponse.Status,
|
|
}
|
|
var v ProblemDetails
|
|
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
newErr.error = err.Error()
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
|
|
newErr.model = v
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
|
|
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
newErr := &GenericOpenAPIError{
|
|
body: localVarBody,
|
|
error: err.Error(),
|
|
}
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
|
|
return localVarReturnValue, localVarHTTPResponse, nil
|
|
}
|
|
|
|
type S3APIGetS3BucketsRequest struct {
|
|
ctx context.Context
|
|
ApiService *S3APIService
|
|
}
|
|
|
|
func (r S3APIGetS3BucketsRequest) Execute() (*S3BucketList, *http.Response, error) {
|
|
return r.ApiService.GetS3BucketsExecute(r)
|
|
}
|
|
|
|
/*
|
|
GetS3Buckets Lists the caller org's own buckets.
|
|
|
|
Lists the caller org's own buckets.
|
|
|
|
Only the caller's: every bucket is physically named under a per-org prefix and
|
|
the listing strips that prefix, so a tenant sees friendly names and another
|
|
tenant's buckets are not in the answer at all. Another org's bucket is not
|
|
refused but INVISIBLE, so this cannot be used to learn that a name is taken
|
|
elsewhere.
|
|
|
|
Billed per call: the balance is checked BEFORE anything is touched, so an
|
|
unfunded org is refused with nothing done, and the debit lands only once the
|
|
work has succeeded.
|
|
|
|
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
|
@return S3APIGetS3BucketsRequest
|
|
*/
|
|
func (a *S3APIService) GetS3Buckets(ctx context.Context) S3APIGetS3BucketsRequest {
|
|
return S3APIGetS3BucketsRequest{
|
|
ApiService: a,
|
|
ctx: ctx,
|
|
}
|
|
}
|
|
|
|
// Execute executes the request
|
|
//
|
|
// @return S3BucketList
|
|
func (a *S3APIService) GetS3BucketsExecute(r S3APIGetS3BucketsRequest) (*S3BucketList, *http.Response, error) {
|
|
var (
|
|
localVarHTTPMethod = http.MethodGet
|
|
localVarPostBody interface{}
|
|
formFiles []formFile
|
|
localVarReturnValue *S3BucketList
|
|
)
|
|
|
|
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "S3APIService.GetS3Buckets")
|
|
if err != nil {
|
|
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
|
}
|
|
|
|
localVarPath := localBasePath + "/v1/s3/buckets"
|
|
|
|
localVarHeaderParams := make(map[string]string)
|
|
localVarQueryParams := url.Values{}
|
|
localVarFormParams := url.Values{}
|
|
|
|
// to determine the Content-Type header
|
|
localVarHTTPContentTypes := []string{}
|
|
|
|
// set Content-Type header
|
|
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
|
|
if localVarHTTPContentType != "" {
|
|
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
|
|
}
|
|
|
|
// to determine the Accept header
|
|
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
|
|
|
|
// set Accept header
|
|
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
|
|
if localVarHTTPHeaderAccept != "" {
|
|
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
|
|
}
|
|
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
|
|
if err != nil {
|
|
return localVarReturnValue, nil, err
|
|
}
|
|
|
|
localVarHTTPResponse, err := a.client.callAPI(req)
|
|
if err != nil || localVarHTTPResponse == nil {
|
|
return localVarReturnValue, localVarHTTPResponse, err
|
|
}
|
|
|
|
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
|
|
localVarHTTPResponse.Body.Close()
|
|
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
|
|
if err != nil {
|
|
return localVarReturnValue, localVarHTTPResponse, err
|
|
}
|
|
|
|
if localVarHTTPResponse.StatusCode >= 300 {
|
|
newErr := &GenericOpenAPIError{
|
|
body: localVarBody,
|
|
error: localVarHTTPResponse.Status,
|
|
}
|
|
var v ProblemDetails
|
|
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
newErr.error = err.Error()
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
|
|
newErr.model = v
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
|
|
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
newErr := &GenericOpenAPIError{
|
|
body: localVarBody,
|
|
error: err.Error(),
|
|
}
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
|
|
return localVarReturnValue, localVarHTTPResponse, nil
|
|
}
|
|
|
|
type S3APIGetS3BucketsByBucketObjectsRequest struct {
|
|
ctx context.Context
|
|
ApiService *S3APIService
|
|
bucket string
|
|
prefix *string
|
|
recursive *string
|
|
}
|
|
|
|
func (r S3APIGetS3BucketsByBucketObjectsRequest) Prefix(prefix string) S3APIGetS3BucketsByBucketObjectsRequest {
|
|
r.prefix = &prefix
|
|
return r
|
|
}
|
|
|
|
func (r S3APIGetS3BucketsByBucketObjectsRequest) Recursive(recursive string) S3APIGetS3BucketsByBucketObjectsRequest {
|
|
r.recursive = &recursive
|
|
return r
|
|
}
|
|
|
|
func (r S3APIGetS3BucketsByBucketObjectsRequest) Execute() (*S3ObjectList, *http.Response, error) {
|
|
return r.ApiService.GetS3BucketsByBucketObjectsExecute(r)
|
|
}
|
|
|
|
/*
|
|
GetS3BucketsByBucketObjects Lists one folder level of a bucket.
|
|
|
|
Lists one folder level of a bucket.
|
|
|
|
Folder-style by default: sub-prefixes come back as directory entries, which is
|
|
the file-manager view. `?recursive=true` lists every key flat under the prefix
|
|
instead. Keys are RELATIVE to `?prefix=`, and the listing is bounded so a huge
|
|
bucket cannot exhaust memory — Total is what came back, not what the bucket
|
|
holds.
|
|
|
|
Billed per call: the balance is checked BEFORE anything is touched, so an
|
|
unfunded org is refused with nothing read, and the debit lands only once the
|
|
listing has succeeded.
|
|
|
|
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
|
@param bucket Bucket is the bucket to list, from the path.
|
|
@return S3APIGetS3BucketsByBucketObjectsRequest
|
|
*/
|
|
func (a *S3APIService) GetS3BucketsByBucketObjects(ctx context.Context, bucket string) S3APIGetS3BucketsByBucketObjectsRequest {
|
|
return S3APIGetS3BucketsByBucketObjectsRequest{
|
|
ApiService: a,
|
|
ctx: ctx,
|
|
bucket: bucket,
|
|
}
|
|
}
|
|
|
|
// Execute executes the request
|
|
//
|
|
// @return S3ObjectList
|
|
func (a *S3APIService) GetS3BucketsByBucketObjectsExecute(r S3APIGetS3BucketsByBucketObjectsRequest) (*S3ObjectList, *http.Response, error) {
|
|
var (
|
|
localVarHTTPMethod = http.MethodGet
|
|
localVarPostBody interface{}
|
|
formFiles []formFile
|
|
localVarReturnValue *S3ObjectList
|
|
)
|
|
|
|
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "S3APIService.GetS3BucketsByBucketObjects")
|
|
if err != nil {
|
|
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
|
}
|
|
|
|
localVarPath := localBasePath + "/v1/s3/buckets/{bucket}/objects"
|
|
localVarPath = strings.Replace(localVarPath, "{"+"bucket"+"}", url.PathEscape(parameterValueToString(r.bucket, "bucket")), -1)
|
|
|
|
localVarHeaderParams := make(map[string]string)
|
|
localVarQueryParams := url.Values{}
|
|
localVarFormParams := url.Values{}
|
|
|
|
if r.prefix != nil {
|
|
parameterAddToHeaderOrQuery(localVarQueryParams, "prefix", r.prefix, "form", "")
|
|
}
|
|
if r.recursive != nil {
|
|
parameterAddToHeaderOrQuery(localVarQueryParams, "recursive", r.recursive, "form", "")
|
|
}
|
|
// to determine the Content-Type header
|
|
localVarHTTPContentTypes := []string{}
|
|
|
|
// set Content-Type header
|
|
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
|
|
if localVarHTTPContentType != "" {
|
|
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
|
|
}
|
|
|
|
// to determine the Accept header
|
|
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
|
|
|
|
// set Accept header
|
|
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
|
|
if localVarHTTPHeaderAccept != "" {
|
|
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
|
|
}
|
|
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
|
|
if err != nil {
|
|
return localVarReturnValue, nil, err
|
|
}
|
|
|
|
localVarHTTPResponse, err := a.client.callAPI(req)
|
|
if err != nil || localVarHTTPResponse == nil {
|
|
return localVarReturnValue, localVarHTTPResponse, err
|
|
}
|
|
|
|
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
|
|
localVarHTTPResponse.Body.Close()
|
|
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
|
|
if err != nil {
|
|
return localVarReturnValue, localVarHTTPResponse, err
|
|
}
|
|
|
|
if localVarHTTPResponse.StatusCode >= 300 {
|
|
newErr := &GenericOpenAPIError{
|
|
body: localVarBody,
|
|
error: localVarHTTPResponse.Status,
|
|
}
|
|
var v ProblemDetails
|
|
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
newErr.error = err.Error()
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
|
|
newErr.model = v
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
|
|
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
newErr := &GenericOpenAPIError{
|
|
body: localVarBody,
|
|
error: err.Error(),
|
|
}
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
|
|
return localVarReturnValue, localVarHTTPResponse, nil
|
|
}
|
|
|
|
type S3APIGetS3BucketsByBucketObjectsByWildcard1Request struct {
|
|
ctx context.Context
|
|
ApiService *S3APIService
|
|
bucket string
|
|
wildcard1 string
|
|
}
|
|
|
|
func (r S3APIGetS3BucketsByBucketObjectsByWildcard1Request) Execute() (*S3PresignResponse, *http.Response, error) {
|
|
return r.ApiService.GetS3BucketsByBucketObjectsByWildcard1Execute(r)
|
|
}
|
|
|
|
/*
|
|
GetS3BucketsByBucketObjectsByWildcard1 Mints a presigned GET URL the caller downloads from DIRECTLY.
|
|
|
|
Mints a presigned GET URL the caller downloads from DIRECTLY.
|
|
|
|
The bytes never pass through this binary and the admin credential never leaves
|
|
the server: the URL is signed against the PUBLIC host, scoped to exactly this
|
|
bucket and key, and expires. It carries a content disposition of attachment
|
|
naming the object's file name, so a browser following it saves the object rather
|
|
than rendering it in place. A deployment with no public endpoint configured
|
|
cannot mint one and answers 503 rather than a URL that will not work.
|
|
|
|
Billed per call — for MINTING the URL, which is the work this operation does;
|
|
the download that follows it comes straight from the store and is not seen here.
|
|
The balance is checked BEFORE anything is touched, so an unfunded org is refused
|
|
with no URL issued.
|
|
|
|
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
|
@param bucket Bucket is the bucket's friendly name, from the path.
|
|
@param wildcard1 Key is the object's key within the bucket — everything after that bucket's /objects/. It MAY contain \"/\", because a key is a path and this segment is captured whole: \"2019/summer/a.jpg\" is one key, not three. It is path-cleaned before use, so \"../\" reaches nothing outside the bucket, and a key that is empty, absolute or a bare folder marker is refused 400.
|
|
@return S3APIGetS3BucketsByBucketObjectsByWildcard1Request
|
|
*/
|
|
func (a *S3APIService) GetS3BucketsByBucketObjectsByWildcard1(ctx context.Context, bucket string, wildcard1 string) S3APIGetS3BucketsByBucketObjectsByWildcard1Request {
|
|
return S3APIGetS3BucketsByBucketObjectsByWildcard1Request{
|
|
ApiService: a,
|
|
ctx: ctx,
|
|
bucket: bucket,
|
|
wildcard1: wildcard1,
|
|
}
|
|
}
|
|
|
|
// Execute executes the request
|
|
//
|
|
// @return S3PresignResponse
|
|
func (a *S3APIService) GetS3BucketsByBucketObjectsByWildcard1Execute(r S3APIGetS3BucketsByBucketObjectsByWildcard1Request) (*S3PresignResponse, *http.Response, error) {
|
|
var (
|
|
localVarHTTPMethod = http.MethodGet
|
|
localVarPostBody interface{}
|
|
formFiles []formFile
|
|
localVarReturnValue *S3PresignResponse
|
|
)
|
|
|
|
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "S3APIService.GetS3BucketsByBucketObjectsByWildcard1")
|
|
if err != nil {
|
|
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
|
}
|
|
|
|
localVarPath := localBasePath + "/v1/s3/buckets/{bucket}/objects/{wildcard1}"
|
|
localVarPath = strings.Replace(localVarPath, "{"+"bucket"+"}", url.PathEscape(parameterValueToString(r.bucket, "bucket")), -1)
|
|
localVarPath = strings.Replace(localVarPath, "{"+"wildcard1"+"}", url.PathEscape(parameterValueToString(r.wildcard1, "wildcard1")), -1)
|
|
|
|
localVarHeaderParams := make(map[string]string)
|
|
localVarQueryParams := url.Values{}
|
|
localVarFormParams := url.Values{}
|
|
|
|
// to determine the Content-Type header
|
|
localVarHTTPContentTypes := []string{}
|
|
|
|
// set Content-Type header
|
|
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
|
|
if localVarHTTPContentType != "" {
|
|
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
|
|
}
|
|
|
|
// to determine the Accept header
|
|
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
|
|
|
|
// set Accept header
|
|
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
|
|
if localVarHTTPHeaderAccept != "" {
|
|
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
|
|
}
|
|
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
|
|
if err != nil {
|
|
return localVarReturnValue, nil, err
|
|
}
|
|
|
|
localVarHTTPResponse, err := a.client.callAPI(req)
|
|
if err != nil || localVarHTTPResponse == nil {
|
|
return localVarReturnValue, localVarHTTPResponse, err
|
|
}
|
|
|
|
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
|
|
localVarHTTPResponse.Body.Close()
|
|
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
|
|
if err != nil {
|
|
return localVarReturnValue, localVarHTTPResponse, err
|
|
}
|
|
|
|
if localVarHTTPResponse.StatusCode >= 300 {
|
|
newErr := &GenericOpenAPIError{
|
|
body: localVarBody,
|
|
error: localVarHTTPResponse.Status,
|
|
}
|
|
var v ProblemDetails
|
|
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
newErr.error = err.Error()
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
|
|
newErr.model = v
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
|
|
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
newErr := &GenericOpenAPIError{
|
|
body: localVarBody,
|
|
error: err.Error(),
|
|
}
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
|
|
return localVarReturnValue, localVarHTTPResponse, nil
|
|
}
|
|
|
|
type S3APIGetS3BucketsByBucketUploadsByUploadRequest struct {
|
|
ctx context.Context
|
|
ApiService *S3APIService
|
|
bucket string
|
|
upload string
|
|
key *string
|
|
}
|
|
|
|
// Key is the object key the upload was started on. In the query for a read or an abandon, in the body to complete.
|
|
func (r S3APIGetS3BucketsByBucketUploadsByUploadRequest) Key(key string) S3APIGetS3BucketsByBucketUploadsByUploadRequest {
|
|
r.key = &key
|
|
return r
|
|
}
|
|
|
|
func (r S3APIGetS3BucketsByBucketUploadsByUploadRequest) Execute() (*S3StoredParts, *http.Response, error) {
|
|
return r.ApiService.GetS3BucketsByBucketUploadsByUploadExecute(r)
|
|
}
|
|
|
|
/*
|
|
GetS3BucketsByBucketUploadsByUpload Answers the parts a multipart upload already holds, in order: what a client resuming after a dropped connection reads to send only the rest.
|
|
|
|
Answers the parts a multipart upload already holds, in order: what
|
|
a client resuming after a dropped connection reads to send only the rest.
|
|
|
|
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
|
@param bucket Bucket is the bucket, from the path.
|
|
@param upload Upload is the upload's id, from the path.
|
|
@return S3APIGetS3BucketsByBucketUploadsByUploadRequest
|
|
*/
|
|
func (a *S3APIService) GetS3BucketsByBucketUploadsByUpload(ctx context.Context, bucket string, upload string) S3APIGetS3BucketsByBucketUploadsByUploadRequest {
|
|
return S3APIGetS3BucketsByBucketUploadsByUploadRequest{
|
|
ApiService: a,
|
|
ctx: ctx,
|
|
bucket: bucket,
|
|
upload: upload,
|
|
}
|
|
}
|
|
|
|
// Execute executes the request
|
|
//
|
|
// @return S3StoredParts
|
|
func (a *S3APIService) GetS3BucketsByBucketUploadsByUploadExecute(r S3APIGetS3BucketsByBucketUploadsByUploadRequest) (*S3StoredParts, *http.Response, error) {
|
|
var (
|
|
localVarHTTPMethod = http.MethodGet
|
|
localVarPostBody interface{}
|
|
formFiles []formFile
|
|
localVarReturnValue *S3StoredParts
|
|
)
|
|
|
|
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "S3APIService.GetS3BucketsByBucketUploadsByUpload")
|
|
if err != nil {
|
|
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
|
}
|
|
|
|
localVarPath := localBasePath + "/v1/s3/buckets/{bucket}/uploads/{upload}"
|
|
localVarPath = strings.Replace(localVarPath, "{"+"bucket"+"}", url.PathEscape(parameterValueToString(r.bucket, "bucket")), -1)
|
|
localVarPath = strings.Replace(localVarPath, "{"+"upload"+"}", url.PathEscape(parameterValueToString(r.upload, "upload")), -1)
|
|
|
|
localVarHeaderParams := make(map[string]string)
|
|
localVarQueryParams := url.Values{}
|
|
localVarFormParams := url.Values{}
|
|
|
|
if r.key != nil {
|
|
parameterAddToHeaderOrQuery(localVarQueryParams, "key", r.key, "form", "")
|
|
}
|
|
// to determine the Content-Type header
|
|
localVarHTTPContentTypes := []string{}
|
|
|
|
// set Content-Type header
|
|
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
|
|
if localVarHTTPContentType != "" {
|
|
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
|
|
}
|
|
|
|
// to determine the Accept header
|
|
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
|
|
|
|
// set Accept header
|
|
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
|
|
if localVarHTTPHeaderAccept != "" {
|
|
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
|
|
}
|
|
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
|
|
if err != nil {
|
|
return localVarReturnValue, nil, err
|
|
}
|
|
|
|
localVarHTTPResponse, err := a.client.callAPI(req)
|
|
if err != nil || localVarHTTPResponse == nil {
|
|
return localVarReturnValue, localVarHTTPResponse, err
|
|
}
|
|
|
|
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
|
|
localVarHTTPResponse.Body.Close()
|
|
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
|
|
if err != nil {
|
|
return localVarReturnValue, localVarHTTPResponse, err
|
|
}
|
|
|
|
if localVarHTTPResponse.StatusCode >= 300 {
|
|
newErr := &GenericOpenAPIError{
|
|
body: localVarBody,
|
|
error: localVarHTTPResponse.Status,
|
|
}
|
|
var v ProblemDetails
|
|
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
newErr.error = err.Error()
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
|
|
newErr.model = v
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
|
|
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
newErr := &GenericOpenAPIError{
|
|
body: localVarBody,
|
|
error: err.Error(),
|
|
}
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
|
|
return localVarReturnValue, localVarHTTPResponse, nil
|
|
}
|
|
|
|
type S3APIGetS3HealthRequest struct {
|
|
ctx context.Context
|
|
ApiService *S3APIService
|
|
}
|
|
|
|
func (r S3APIGetS3HealthRequest) Execute() (*S3S3Health, *http.Response, error) {
|
|
return r.ApiService.GetS3HealthExecute(r)
|
|
}
|
|
|
|
/*
|
|
GetS3Health Reports whether this deployment can serve object storage.
|
|
|
|
Reports whether this deployment can serve object storage.
|
|
|
|
It is a REAL probe rather than a constant: 200 when admin credentials are
|
|
present, so the store is reachable in principle, and 503 with the reason when
|
|
they are not. It is deliberately NOT gated — liveness has to be probe-able
|
|
without a token — so it is the one operation here that names no bucket and
|
|
bills nothing.
|
|
|
|
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
|
@return S3APIGetS3HealthRequest
|
|
*/
|
|
func (a *S3APIService) GetS3Health(ctx context.Context) S3APIGetS3HealthRequest {
|
|
return S3APIGetS3HealthRequest{
|
|
ApiService: a,
|
|
ctx: ctx,
|
|
}
|
|
}
|
|
|
|
// Execute executes the request
|
|
//
|
|
// @return S3S3Health
|
|
func (a *S3APIService) GetS3HealthExecute(r S3APIGetS3HealthRequest) (*S3S3Health, *http.Response, error) {
|
|
var (
|
|
localVarHTTPMethod = http.MethodGet
|
|
localVarPostBody interface{}
|
|
formFiles []formFile
|
|
localVarReturnValue *S3S3Health
|
|
)
|
|
|
|
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "S3APIService.GetS3Health")
|
|
if err != nil {
|
|
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
|
}
|
|
|
|
localVarPath := localBasePath + "/v1/s3/health"
|
|
|
|
localVarHeaderParams := make(map[string]string)
|
|
localVarQueryParams := url.Values{}
|
|
localVarFormParams := url.Values{}
|
|
|
|
// to determine the Content-Type header
|
|
localVarHTTPContentTypes := []string{}
|
|
|
|
// set Content-Type header
|
|
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
|
|
if localVarHTTPContentType != "" {
|
|
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
|
|
}
|
|
|
|
// to determine the Accept header
|
|
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
|
|
|
|
// set Accept header
|
|
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
|
|
if localVarHTTPHeaderAccept != "" {
|
|
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
|
|
}
|
|
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
|
|
if err != nil {
|
|
return localVarReturnValue, nil, err
|
|
}
|
|
|
|
localVarHTTPResponse, err := a.client.callAPI(req)
|
|
if err != nil || localVarHTTPResponse == nil {
|
|
return localVarReturnValue, localVarHTTPResponse, err
|
|
}
|
|
|
|
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
|
|
localVarHTTPResponse.Body.Close()
|
|
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
|
|
if err != nil {
|
|
return localVarReturnValue, localVarHTTPResponse, err
|
|
}
|
|
|
|
if localVarHTTPResponse.StatusCode >= 300 {
|
|
newErr := &GenericOpenAPIError{
|
|
body: localVarBody,
|
|
error: localVarHTTPResponse.Status,
|
|
}
|
|
if localVarHTTPResponse.StatusCode == 503 {
|
|
var v S3S3Health
|
|
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
newErr.error = err.Error()
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
|
|
newErr.model = v
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
var v ProblemDetails
|
|
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
newErr.error = err.Error()
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
|
|
newErr.model = v
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
|
|
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
newErr := &GenericOpenAPIError{
|
|
body: localVarBody,
|
|
error: err.Error(),
|
|
}
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
|
|
return localVarReturnValue, localVarHTTPResponse, nil
|
|
}
|
|
|
|
type S3APIPostS3BucketsRequest struct {
|
|
ctx context.Context
|
|
ApiService *S3APIService
|
|
s3BucketIn *S3BucketIn
|
|
}
|
|
|
|
func (r S3APIPostS3BucketsRequest) S3BucketIn(s3BucketIn S3BucketIn) S3APIPostS3BucketsRequest {
|
|
r.s3BucketIn = &s3BucketIn
|
|
return r
|
|
}
|
|
|
|
func (r S3APIPostS3BucketsRequest) Execute() (*S3BucketItem, *http.Response, error) {
|
|
return r.ApiService.PostS3BucketsExecute(r)
|
|
}
|
|
|
|
/*
|
|
PostS3Buckets Makes a new bucket for the caller's org and answers 201 with it.
|
|
|
|
Makes a new bucket for the caller's org and answers 201 with it.
|
|
|
|
It requires an admin of the org, a SuperAdmin, or the org's own application
|
|
(CI makes its cache bucket on first use): every member of the org uses
|
|
its buckets, and only an admin makes or removes one. Anyone else is refused 403
|
|
with nothing created.
|
|
|
|
The physical name is derived from the caller's validated org, so a tenant can
|
|
only ever create inside its own namespace and no request field can redirect
|
|
that. A name already taken in the org is 409.
|
|
|
|
Billed per call: the balance is checked BEFORE anything is touched, so an
|
|
unfunded org is refused with nothing created, and the debit lands only once the
|
|
bucket exists.
|
|
|
|
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
|
@return S3APIPostS3BucketsRequest
|
|
*/
|
|
func (a *S3APIService) PostS3Buckets(ctx context.Context) S3APIPostS3BucketsRequest {
|
|
return S3APIPostS3BucketsRequest{
|
|
ApiService: a,
|
|
ctx: ctx,
|
|
}
|
|
}
|
|
|
|
// Execute executes the request
|
|
//
|
|
// @return S3BucketItem
|
|
func (a *S3APIService) PostS3BucketsExecute(r S3APIPostS3BucketsRequest) (*S3BucketItem, *http.Response, error) {
|
|
var (
|
|
localVarHTTPMethod = http.MethodPost
|
|
localVarPostBody interface{}
|
|
formFiles []formFile
|
|
localVarReturnValue *S3BucketItem
|
|
)
|
|
|
|
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "S3APIService.PostS3Buckets")
|
|
if err != nil {
|
|
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
|
}
|
|
|
|
localVarPath := localBasePath + "/v1/s3/buckets"
|
|
|
|
localVarHeaderParams := make(map[string]string)
|
|
localVarQueryParams := url.Values{}
|
|
localVarFormParams := url.Values{}
|
|
if r.s3BucketIn == nil {
|
|
return localVarReturnValue, nil, reportError("s3BucketIn is required and must be specified")
|
|
}
|
|
|
|
// to determine the Content-Type header
|
|
localVarHTTPContentTypes := []string{"application/json"}
|
|
|
|
// set Content-Type header
|
|
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
|
|
if localVarHTTPContentType != "" {
|
|
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
|
|
}
|
|
|
|
// to determine the Accept header
|
|
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
|
|
|
|
// set Accept header
|
|
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
|
|
if localVarHTTPHeaderAccept != "" {
|
|
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
|
|
}
|
|
// body params
|
|
localVarPostBody = r.s3BucketIn
|
|
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
|
|
if err != nil {
|
|
return localVarReturnValue, nil, err
|
|
}
|
|
|
|
localVarHTTPResponse, err := a.client.callAPI(req)
|
|
if err != nil || localVarHTTPResponse == nil {
|
|
return localVarReturnValue, localVarHTTPResponse, err
|
|
}
|
|
|
|
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
|
|
localVarHTTPResponse.Body.Close()
|
|
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
|
|
if err != nil {
|
|
return localVarReturnValue, localVarHTTPResponse, err
|
|
}
|
|
|
|
if localVarHTTPResponse.StatusCode >= 300 {
|
|
newErr := &GenericOpenAPIError{
|
|
body: localVarBody,
|
|
error: localVarHTTPResponse.Status,
|
|
}
|
|
var v ProblemDetails
|
|
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
newErr.error = err.Error()
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
|
|
newErr.model = v
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
|
|
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
newErr := &GenericOpenAPIError{
|
|
body: localVarBody,
|
|
error: err.Error(),
|
|
}
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
|
|
return localVarReturnValue, localVarHTTPResponse, nil
|
|
}
|
|
|
|
type S3APIPostS3BucketsByBucketObjectsRequest struct {
|
|
ctx context.Context
|
|
ApiService *S3APIService
|
|
bucket string
|
|
s3UploadIn *S3UploadIn
|
|
}
|
|
|
|
func (r S3APIPostS3BucketsByBucketObjectsRequest) S3UploadIn(s3UploadIn S3UploadIn) S3APIPostS3BucketsByBucketObjectsRequest {
|
|
r.s3UploadIn = &s3UploadIn
|
|
return r
|
|
}
|
|
|
|
func (r S3APIPostS3BucketsByBucketObjectsRequest) Execute() (*S3PresignResponse, *http.Response, error) {
|
|
return r.ApiService.PostS3BucketsByBucketObjectsExecute(r)
|
|
}
|
|
|
|
/*
|
|
PostS3BucketsByBucketObjects Mints a presigned PUT URL the caller uploads to DIRECTLY.
|
|
|
|
Mints a presigned PUT URL the caller uploads to DIRECTLY.
|
|
|
|
The bytes never pass through this binary and the admin credential never leaves
|
|
the server: the URL is signed against the PUBLIC host, scoped to exactly this
|
|
bucket and key, and expires. A deployment with no public endpoint configured
|
|
cannot mint one and answers 503 rather than a URL that will not work.
|
|
|
|
Billed per call — for MINTING the URL, which is the work this operation does;
|
|
the upload that follows it goes straight to the store and is not seen here. The
|
|
balance is checked BEFORE anything is touched, so an unfunded org is refused
|
|
with no URL issued.
|
|
|
|
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
|
@param bucket Bucket is the bucket to upload into, from the path.
|
|
@return S3APIPostS3BucketsByBucketObjectsRequest
|
|
*/
|
|
func (a *S3APIService) PostS3BucketsByBucketObjects(ctx context.Context, bucket string) S3APIPostS3BucketsByBucketObjectsRequest {
|
|
return S3APIPostS3BucketsByBucketObjectsRequest{
|
|
ApiService: a,
|
|
ctx: ctx,
|
|
bucket: bucket,
|
|
}
|
|
}
|
|
|
|
// Execute executes the request
|
|
//
|
|
// @return S3PresignResponse
|
|
func (a *S3APIService) PostS3BucketsByBucketObjectsExecute(r S3APIPostS3BucketsByBucketObjectsRequest) (*S3PresignResponse, *http.Response, error) {
|
|
var (
|
|
localVarHTTPMethod = http.MethodPost
|
|
localVarPostBody interface{}
|
|
formFiles []formFile
|
|
localVarReturnValue *S3PresignResponse
|
|
)
|
|
|
|
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "S3APIService.PostS3BucketsByBucketObjects")
|
|
if err != nil {
|
|
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
|
}
|
|
|
|
localVarPath := localBasePath + "/v1/s3/buckets/{bucket}/objects"
|
|
localVarPath = strings.Replace(localVarPath, "{"+"bucket"+"}", url.PathEscape(parameterValueToString(r.bucket, "bucket")), -1)
|
|
|
|
localVarHeaderParams := make(map[string]string)
|
|
localVarQueryParams := url.Values{}
|
|
localVarFormParams := url.Values{}
|
|
if r.s3UploadIn == nil {
|
|
return localVarReturnValue, nil, reportError("s3UploadIn is required and must be specified")
|
|
}
|
|
|
|
// to determine the Content-Type header
|
|
localVarHTTPContentTypes := []string{"application/json"}
|
|
|
|
// set Content-Type header
|
|
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
|
|
if localVarHTTPContentType != "" {
|
|
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
|
|
}
|
|
|
|
// to determine the Accept header
|
|
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
|
|
|
|
// set Accept header
|
|
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
|
|
if localVarHTTPHeaderAccept != "" {
|
|
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
|
|
}
|
|
// body params
|
|
localVarPostBody = r.s3UploadIn
|
|
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
|
|
if err != nil {
|
|
return localVarReturnValue, nil, err
|
|
}
|
|
|
|
localVarHTTPResponse, err := a.client.callAPI(req)
|
|
if err != nil || localVarHTTPResponse == nil {
|
|
return localVarReturnValue, localVarHTTPResponse, err
|
|
}
|
|
|
|
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
|
|
localVarHTTPResponse.Body.Close()
|
|
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
|
|
if err != nil {
|
|
return localVarReturnValue, localVarHTTPResponse, err
|
|
}
|
|
|
|
if localVarHTTPResponse.StatusCode >= 300 {
|
|
newErr := &GenericOpenAPIError{
|
|
body: localVarBody,
|
|
error: localVarHTTPResponse.Status,
|
|
}
|
|
var v ProblemDetails
|
|
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
newErr.error = err.Error()
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
|
|
newErr.model = v
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
|
|
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
newErr := &GenericOpenAPIError{
|
|
body: localVarBody,
|
|
error: err.Error(),
|
|
}
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
|
|
return localVarReturnValue, localVarHTTPResponse, nil
|
|
}
|
|
|
|
type S3APIPostS3BucketsByBucketUploadsRequest struct {
|
|
ctx context.Context
|
|
ApiService *S3APIService
|
|
bucket string
|
|
s3UploadStart *S3UploadStart
|
|
}
|
|
|
|
func (r S3APIPostS3BucketsByBucketUploadsRequest) S3UploadStart(s3UploadStart S3UploadStart) S3APIPostS3BucketsByBucketUploadsRequest {
|
|
r.s3UploadStart = &s3UploadStart
|
|
return r
|
|
}
|
|
|
|
func (r S3APIPostS3BucketsByBucketUploadsRequest) Execute() (*S3UploadStarted, *http.Response, error) {
|
|
return r.ApiService.PostS3BucketsByBucketUploadsExecute(r)
|
|
}
|
|
|
|
/*
|
|
PostS3BucketsByBucketUploads Begins a multipart upload of a large file into one of the caller's org buckets.
|
|
|
|
Begins a multipart upload of a large file into one of the caller's
|
|
org buckets. Then mint presigned URLs for its parts with POST
|
|
.../uploads/{upload}/parts, PUT each part's bytes to its URL — every part but
|
|
the last exactly partSize bytes — and assemble the object with POST
|
|
.../uploads/{upload}/complete. A dropped connection loses nothing:
|
|
GET .../uploads/{upload} lists the parts already stored, so only the rest are
|
|
sent again. Use this for anything over a few megabytes; a small file takes the
|
|
single presigned PUT of POST /v1/s3/buckets/{bucket}/objects.
|
|
|
|
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
|
@param bucket Bucket is the bucket to upload into, from the path.
|
|
@return S3APIPostS3BucketsByBucketUploadsRequest
|
|
*/
|
|
func (a *S3APIService) PostS3BucketsByBucketUploads(ctx context.Context, bucket string) S3APIPostS3BucketsByBucketUploadsRequest {
|
|
return S3APIPostS3BucketsByBucketUploadsRequest{
|
|
ApiService: a,
|
|
ctx: ctx,
|
|
bucket: bucket,
|
|
}
|
|
}
|
|
|
|
// Execute executes the request
|
|
//
|
|
// @return S3UploadStarted
|
|
func (a *S3APIService) PostS3BucketsByBucketUploadsExecute(r S3APIPostS3BucketsByBucketUploadsRequest) (*S3UploadStarted, *http.Response, error) {
|
|
var (
|
|
localVarHTTPMethod = http.MethodPost
|
|
localVarPostBody interface{}
|
|
formFiles []formFile
|
|
localVarReturnValue *S3UploadStarted
|
|
)
|
|
|
|
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "S3APIService.PostS3BucketsByBucketUploads")
|
|
if err != nil {
|
|
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
|
}
|
|
|
|
localVarPath := localBasePath + "/v1/s3/buckets/{bucket}/uploads"
|
|
localVarPath = strings.Replace(localVarPath, "{"+"bucket"+"}", url.PathEscape(parameterValueToString(r.bucket, "bucket")), -1)
|
|
|
|
localVarHeaderParams := make(map[string]string)
|
|
localVarQueryParams := url.Values{}
|
|
localVarFormParams := url.Values{}
|
|
if r.s3UploadStart == nil {
|
|
return localVarReturnValue, nil, reportError("s3UploadStart is required and must be specified")
|
|
}
|
|
|
|
// to determine the Content-Type header
|
|
localVarHTTPContentTypes := []string{"application/json"}
|
|
|
|
// set Content-Type header
|
|
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
|
|
if localVarHTTPContentType != "" {
|
|
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
|
|
}
|
|
|
|
// to determine the Accept header
|
|
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
|
|
|
|
// set Accept header
|
|
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
|
|
if localVarHTTPHeaderAccept != "" {
|
|
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
|
|
}
|
|
// body params
|
|
localVarPostBody = r.s3UploadStart
|
|
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
|
|
if err != nil {
|
|
return localVarReturnValue, nil, err
|
|
}
|
|
|
|
localVarHTTPResponse, err := a.client.callAPI(req)
|
|
if err != nil || localVarHTTPResponse == nil {
|
|
return localVarReturnValue, localVarHTTPResponse, err
|
|
}
|
|
|
|
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
|
|
localVarHTTPResponse.Body.Close()
|
|
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
|
|
if err != nil {
|
|
return localVarReturnValue, localVarHTTPResponse, err
|
|
}
|
|
|
|
if localVarHTTPResponse.StatusCode >= 300 {
|
|
newErr := &GenericOpenAPIError{
|
|
body: localVarBody,
|
|
error: localVarHTTPResponse.Status,
|
|
}
|
|
var v ProblemDetails
|
|
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
newErr.error = err.Error()
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
|
|
newErr.model = v
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
|
|
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
newErr := &GenericOpenAPIError{
|
|
body: localVarBody,
|
|
error: err.Error(),
|
|
}
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
|
|
return localVarReturnValue, localVarHTTPResponse, nil
|
|
}
|
|
|
|
type S3APIPostS3BucketsByBucketUploadsByUploadCompleteRequest struct {
|
|
ctx context.Context
|
|
ApiService *S3APIService
|
|
bucket string
|
|
upload string
|
|
s3UploadRef *S3UploadRef
|
|
}
|
|
|
|
func (r S3APIPostS3BucketsByBucketUploadsByUploadCompleteRequest) S3UploadRef(s3UploadRef S3UploadRef) S3APIPostS3BucketsByBucketUploadsByUploadCompleteRequest {
|
|
r.s3UploadRef = &s3UploadRef
|
|
return r
|
|
}
|
|
|
|
func (r S3APIPostS3BucketsByBucketUploadsByUploadCompleteRequest) Execute() (*S3UploadDone, *http.Response, error) {
|
|
return r.ApiService.PostS3BucketsByBucketUploadsByUploadCompleteExecute(r)
|
|
}
|
|
|
|
/*
|
|
PostS3BucketsByBucketUploadsByUploadComplete Assembles a multipart upload into its object from every part the store holds, in order.
|
|
|
|
Assembles a multipart upload into its object from every part the
|
|
store holds, in order. The parts must run 1, 2, 3 … with no gap; a gap is 409,
|
|
naming the first part missing, and the upload stays open to send it.
|
|
|
|
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
|
@param bucket Bucket is the bucket, from the path.
|
|
@param upload Upload is the upload's id, from the path.
|
|
@return S3APIPostS3BucketsByBucketUploadsByUploadCompleteRequest
|
|
*/
|
|
func (a *S3APIService) PostS3BucketsByBucketUploadsByUploadComplete(ctx context.Context, bucket string, upload string) S3APIPostS3BucketsByBucketUploadsByUploadCompleteRequest {
|
|
return S3APIPostS3BucketsByBucketUploadsByUploadCompleteRequest{
|
|
ApiService: a,
|
|
ctx: ctx,
|
|
bucket: bucket,
|
|
upload: upload,
|
|
}
|
|
}
|
|
|
|
// Execute executes the request
|
|
//
|
|
// @return S3UploadDone
|
|
func (a *S3APIService) PostS3BucketsByBucketUploadsByUploadCompleteExecute(r S3APIPostS3BucketsByBucketUploadsByUploadCompleteRequest) (*S3UploadDone, *http.Response, error) {
|
|
var (
|
|
localVarHTTPMethod = http.MethodPost
|
|
localVarPostBody interface{}
|
|
formFiles []formFile
|
|
localVarReturnValue *S3UploadDone
|
|
)
|
|
|
|
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "S3APIService.PostS3BucketsByBucketUploadsByUploadComplete")
|
|
if err != nil {
|
|
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
|
}
|
|
|
|
localVarPath := localBasePath + "/v1/s3/buckets/{bucket}/uploads/{upload}/complete"
|
|
localVarPath = strings.Replace(localVarPath, "{"+"bucket"+"}", url.PathEscape(parameterValueToString(r.bucket, "bucket")), -1)
|
|
localVarPath = strings.Replace(localVarPath, "{"+"upload"+"}", url.PathEscape(parameterValueToString(r.upload, "upload")), -1)
|
|
|
|
localVarHeaderParams := make(map[string]string)
|
|
localVarQueryParams := url.Values{}
|
|
localVarFormParams := url.Values{}
|
|
if r.s3UploadRef == nil {
|
|
return localVarReturnValue, nil, reportError("s3UploadRef is required and must be specified")
|
|
}
|
|
|
|
// to determine the Content-Type header
|
|
localVarHTTPContentTypes := []string{"application/json"}
|
|
|
|
// set Content-Type header
|
|
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
|
|
if localVarHTTPContentType != "" {
|
|
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
|
|
}
|
|
|
|
// to determine the Accept header
|
|
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
|
|
|
|
// set Accept header
|
|
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
|
|
if localVarHTTPHeaderAccept != "" {
|
|
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
|
|
}
|
|
// body params
|
|
localVarPostBody = r.s3UploadRef
|
|
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
|
|
if err != nil {
|
|
return localVarReturnValue, nil, err
|
|
}
|
|
|
|
localVarHTTPResponse, err := a.client.callAPI(req)
|
|
if err != nil || localVarHTTPResponse == nil {
|
|
return localVarReturnValue, localVarHTTPResponse, err
|
|
}
|
|
|
|
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
|
|
localVarHTTPResponse.Body.Close()
|
|
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
|
|
if err != nil {
|
|
return localVarReturnValue, localVarHTTPResponse, err
|
|
}
|
|
|
|
if localVarHTTPResponse.StatusCode >= 300 {
|
|
newErr := &GenericOpenAPIError{
|
|
body: localVarBody,
|
|
error: localVarHTTPResponse.Status,
|
|
}
|
|
var v ProblemDetails
|
|
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
newErr.error = err.Error()
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
|
|
newErr.model = v
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
|
|
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
newErr := &GenericOpenAPIError{
|
|
body: localVarBody,
|
|
error: err.Error(),
|
|
}
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
|
|
return localVarReturnValue, localVarHTTPResponse, nil
|
|
}
|
|
|
|
type S3APIPostS3BucketsByBucketUploadsByUploadPartsRequest struct {
|
|
ctx context.Context
|
|
ApiService *S3APIService
|
|
bucket string
|
|
upload string
|
|
s3UploadParts *S3UploadParts
|
|
}
|
|
|
|
func (r S3APIPostS3BucketsByBucketUploadsByUploadPartsRequest) S3UploadParts(s3UploadParts S3UploadParts) S3APIPostS3BucketsByBucketUploadsByUploadPartsRequest {
|
|
r.s3UploadParts = &s3UploadParts
|
|
return r
|
|
}
|
|
|
|
func (r S3APIPostS3BucketsByBucketUploadsByUploadPartsRequest) Execute() (*S3PartURLs, *http.Response, error) {
|
|
return r.ApiService.PostS3BucketsByBucketUploadsByUploadPartsExecute(r)
|
|
}
|
|
|
|
/*
|
|
PostS3BucketsByBucketUploadsByUploadParts Answers presigned PUT URLs for some parts of a multipart upload, at most 64 a call, each valid for minutes: mint them as the upload reaches them.
|
|
|
|
Answers presigned PUT URLs for some parts of a multipart upload, at
|
|
most 64 a call, each valid for minutes: mint them as the upload reaches them.
|
|
PUT a part's bytes to its URL as they are — no headers are signed — and the
|
|
store answers the part's ETag, which completing does not need.
|
|
|
|
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
|
@param bucket Bucket is the bucket, from the path.
|
|
@param upload Upload is the upload's id, from the path.
|
|
@return S3APIPostS3BucketsByBucketUploadsByUploadPartsRequest
|
|
*/
|
|
func (a *S3APIService) PostS3BucketsByBucketUploadsByUploadParts(ctx context.Context, bucket string, upload string) S3APIPostS3BucketsByBucketUploadsByUploadPartsRequest {
|
|
return S3APIPostS3BucketsByBucketUploadsByUploadPartsRequest{
|
|
ApiService: a,
|
|
ctx: ctx,
|
|
bucket: bucket,
|
|
upload: upload,
|
|
}
|
|
}
|
|
|
|
// Execute executes the request
|
|
//
|
|
// @return S3PartURLs
|
|
func (a *S3APIService) PostS3BucketsByBucketUploadsByUploadPartsExecute(r S3APIPostS3BucketsByBucketUploadsByUploadPartsRequest) (*S3PartURLs, *http.Response, error) {
|
|
var (
|
|
localVarHTTPMethod = http.MethodPost
|
|
localVarPostBody interface{}
|
|
formFiles []formFile
|
|
localVarReturnValue *S3PartURLs
|
|
)
|
|
|
|
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "S3APIService.PostS3BucketsByBucketUploadsByUploadParts")
|
|
if err != nil {
|
|
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
|
}
|
|
|
|
localVarPath := localBasePath + "/v1/s3/buckets/{bucket}/uploads/{upload}/parts"
|
|
localVarPath = strings.Replace(localVarPath, "{"+"bucket"+"}", url.PathEscape(parameterValueToString(r.bucket, "bucket")), -1)
|
|
localVarPath = strings.Replace(localVarPath, "{"+"upload"+"}", url.PathEscape(parameterValueToString(r.upload, "upload")), -1)
|
|
|
|
localVarHeaderParams := make(map[string]string)
|
|
localVarQueryParams := url.Values{}
|
|
localVarFormParams := url.Values{}
|
|
if r.s3UploadParts == nil {
|
|
return localVarReturnValue, nil, reportError("s3UploadParts is required and must be specified")
|
|
}
|
|
|
|
// to determine the Content-Type header
|
|
localVarHTTPContentTypes := []string{"application/json"}
|
|
|
|
// set Content-Type header
|
|
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
|
|
if localVarHTTPContentType != "" {
|
|
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
|
|
}
|
|
|
|
// to determine the Accept header
|
|
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
|
|
|
|
// set Accept header
|
|
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
|
|
if localVarHTTPHeaderAccept != "" {
|
|
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
|
|
}
|
|
// body params
|
|
localVarPostBody = r.s3UploadParts
|
|
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
|
|
if err != nil {
|
|
return localVarReturnValue, nil, err
|
|
}
|
|
|
|
localVarHTTPResponse, err := a.client.callAPI(req)
|
|
if err != nil || localVarHTTPResponse == nil {
|
|
return localVarReturnValue, localVarHTTPResponse, err
|
|
}
|
|
|
|
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
|
|
localVarHTTPResponse.Body.Close()
|
|
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
|
|
if err != nil {
|
|
return localVarReturnValue, localVarHTTPResponse, err
|
|
}
|
|
|
|
if localVarHTTPResponse.StatusCode >= 300 {
|
|
newErr := &GenericOpenAPIError{
|
|
body: localVarBody,
|
|
error: localVarHTTPResponse.Status,
|
|
}
|
|
var v ProblemDetails
|
|
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
newErr.error = err.Error()
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
|
|
newErr.model = v
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
|
|
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
newErr := &GenericOpenAPIError{
|
|
body: localVarBody,
|
|
error: err.Error(),
|
|
}
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
|
|
return localVarReturnValue, localVarHTTPResponse, nil
|
|
}
|