diff --git a/restapi/client.go b/restapi/client.go index 7a8175187..26110bcc4 100644 --- a/restapi/client.go +++ b/restapi/client.go @@ -143,6 +143,7 @@ type MCClient interface { remove(ctx context.Context, isIncomplete, isRemoveBucket, isBypass bool, contentCh <-chan *mc.ClientContent) <-chan *probe.Error list(ctx context.Context, opts mc.ListOptions) <-chan *mc.ClientContent get(ctx context.Context, opts mc.GetOptions) (io.ReadCloser, *probe.Error) + shareDownload(ctx context.Context, versionID string, expires time.Duration) (string, *probe.Error) } // Interface implementation @@ -183,6 +184,10 @@ func (c mcClient) get(ctx context.Context, opts mc.GetOptions) (io.ReadCloser, * return c.client.Get(ctx, opts) } +func (c mcClient) shareDownload(ctx context.Context, versionID string, expires time.Duration) (string, *probe.Error) { + return c.client.ShareDownload(ctx, versionID, expires) +} + // ConsoleCredentials interface with all functions to be implemented // by mock when testing, it should include all needed consoleCredentials.Login api calls // that are used within this project. diff --git a/restapi/embedded_spec.go b/restapi/embedded_spec.go index 755b8c616..f1e4fe3a0 100644 --- a/restapi/embedded_spec.go +++ b/restapi/embedded_spec.go @@ -469,6 +469,54 @@ func init() { } } }, + "/buckets/{bucket_name}/objects/share": { + "get": { + "tags": [ + "UserAPI" + ], + "summary": "Shares an Object on a url", + "operationId": "ShareObject", + "parameters": [ + { + "type": "string", + "name": "bucket_name", + "in": "path", + "required": true + }, + { + "type": "string", + "name": "prefix", + "in": "query", + "required": true + }, + { + "type": "string", + "name": "version_id", + "in": "query", + "required": true + }, + { + "type": "string", + "name": "expires", + "in": "query" + } + ], + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "type": "string" + } + }, + "default": { + "description": "Generic error response.", + "schema": { + "$ref": "#/definitions/error" + } + } + } + } + }, "/buckets/{bucket_name}/objects/upload": { "post": { "consumes": [ @@ -4962,6 +5010,54 @@ func init() { } } }, + "/buckets/{bucket_name}/objects/share": { + "get": { + "tags": [ + "UserAPI" + ], + "summary": "Shares an Object on a url", + "operationId": "ShareObject", + "parameters": [ + { + "type": "string", + "name": "bucket_name", + "in": "path", + "required": true + }, + { + "type": "string", + "name": "prefix", + "in": "query", + "required": true + }, + { + "type": "string", + "name": "version_id", + "in": "query", + "required": true + }, + { + "type": "string", + "name": "expires", + "in": "query" + } + ], + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "type": "string" + } + }, + "default": { + "description": "Generic error response.", + "schema": { + "$ref": "#/definitions/error" + } + } + } + } + }, "/buckets/{bucket_name}/objects/upload": { "post": { "consumes": [ diff --git a/restapi/operations/console_api.go b/restapi/operations/console_api.go index dc68ef0d0..dd424d091 100644 --- a/restapi/operations/console_api.go +++ b/restapi/operations/console_api.go @@ -253,6 +253,9 @@ func NewConsoleAPI(spec *loads.Document) *ConsoleAPI { AdminAPISetPolicyHandler: admin_api.SetPolicyHandlerFunc(func(params admin_api.SetPolicyParams, principal *models.Principal) middleware.Responder { return middleware.NotImplemented("operation admin_api.SetPolicy has not yet been implemented") }), + UserAPIShareObjectHandler: user_api.ShareObjectHandlerFunc(func(params user_api.ShareObjectParams, principal *models.Principal) middleware.Responder { + return middleware.NotImplemented("operation user_api.ShareObject has not yet been implemented") + }), AdminAPITenantAddZoneHandler: admin_api.TenantAddZoneHandlerFunc(func(params admin_api.TenantAddZoneParams, principal *models.Principal) middleware.Responder { return middleware.NotImplemented("operation admin_api.TenantAddZone has not yet been implemented") }), @@ -458,6 +461,8 @@ type ConsoleAPI struct { AdminAPISetConfigHandler admin_api.SetConfigHandler // AdminAPISetPolicyHandler sets the operation handler for the set policy operation AdminAPISetPolicyHandler admin_api.SetPolicyHandler + // UserAPIShareObjectHandler sets the operation handler for the share object operation + UserAPIShareObjectHandler user_api.ShareObjectHandler // AdminAPITenantAddZoneHandler sets the operation handler for the tenant add zone operation AdminAPITenantAddZoneHandler admin_api.TenantAddZoneHandler // AdminAPITenantInfoHandler sets the operation handler for the tenant info operation @@ -741,6 +746,9 @@ func (o *ConsoleAPI) Validate() error { if o.AdminAPISetPolicyHandler == nil { unregistered = append(unregistered, "admin_api.SetPolicyHandler") } + if o.UserAPIShareObjectHandler == nil { + unregistered = append(unregistered, "user_api.ShareObjectHandler") + } if o.AdminAPITenantAddZoneHandler == nil { unregistered = append(unregistered, "admin_api.TenantAddZoneHandler") } @@ -1122,6 +1130,10 @@ func (o *ConsoleAPI) initHandlerCache() { o.handlers["PUT"] = make(map[string]http.Handler) } o.handlers["PUT"]["/set-policy/{name}"] = admin_api.NewSetPolicy(o.context, o.AdminAPISetPolicyHandler) + if o.handlers["GET"] == nil { + o.handlers["GET"] = make(map[string]http.Handler) + } + o.handlers["GET"]["/buckets/{bucket_name}/objects/share"] = user_api.NewShareObject(o.context, o.UserAPIShareObjectHandler) if o.handlers["POST"] == nil { o.handlers["POST"] = make(map[string]http.Handler) } diff --git a/restapi/operations/user_api/share_object.go b/restapi/operations/user_api/share_object.go new file mode 100644 index 000000000..e23d18f86 --- /dev/null +++ b/restapi/operations/user_api/share_object.go @@ -0,0 +1,90 @@ +// Code generated by go-swagger; DO NOT EDIT. + +// This file is part of MinIO Console Server +// Copyright (c) 2020 MinIO, Inc. +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU Affero General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU Affero General Public License for more details. +// +// You should have received a copy of the GNU Affero General Public License +// along with this program. If not, see . +// + +package user_api + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the generate command + +import ( + "net/http" + + "github.com/go-openapi/runtime/middleware" + + "github.com/minio/console/models" +) + +// ShareObjectHandlerFunc turns a function with the right signature into a share object handler +type ShareObjectHandlerFunc func(ShareObjectParams, *models.Principal) middleware.Responder + +// Handle executing the request and returning a response +func (fn ShareObjectHandlerFunc) Handle(params ShareObjectParams, principal *models.Principal) middleware.Responder { + return fn(params, principal) +} + +// ShareObjectHandler interface for that can handle valid share object params +type ShareObjectHandler interface { + Handle(ShareObjectParams, *models.Principal) middleware.Responder +} + +// NewShareObject creates a new http.Handler for the share object operation +func NewShareObject(ctx *middleware.Context, handler ShareObjectHandler) *ShareObject { + return &ShareObject{Context: ctx, Handler: handler} +} + +/*ShareObject swagger:route GET /buckets/{bucket_name}/objects/share UserAPI shareObject + +Shares an Object on a url + +*/ +type ShareObject struct { + Context *middleware.Context + Handler ShareObjectHandler +} + +func (o *ShareObject) ServeHTTP(rw http.ResponseWriter, r *http.Request) { + route, rCtx, _ := o.Context.RouteInfo(r) + if rCtx != nil { + r = rCtx + } + var Params = NewShareObjectParams() + + uprinc, aCtx, err := o.Context.Authorize(r, route) + if err != nil { + o.Context.Respond(rw, r, route.Produces, route, err) + return + } + if aCtx != nil { + r = aCtx + } + var principal *models.Principal + if uprinc != nil { + principal = uprinc.(*models.Principal) // this is really a models.Principal, I promise + } + + if err := o.Context.BindValidRequest(r, route, &Params); err != nil { // bind params + o.Context.Respond(rw, r, route.Produces, route, err) + return + } + + res := o.Handler.Handle(Params, principal) // actually handle the request + + o.Context.Respond(rw, r, route.Produces, route, res) + +} diff --git a/restapi/operations/user_api/share_object_parameters.go b/restapi/operations/user_api/share_object_parameters.go new file mode 100644 index 000000000..a4f55efed --- /dev/null +++ b/restapi/operations/user_api/share_object_parameters.go @@ -0,0 +1,182 @@ +// Code generated by go-swagger; DO NOT EDIT. + +// This file is part of MinIO Console Server +// Copyright (c) 2020 MinIO, Inc. +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU Affero General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU Affero General Public License for more details. +// +// You should have received a copy of the GNU Affero General Public License +// along with this program. If not, see . +// + +package user_api + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "net/http" + + "github.com/go-openapi/errors" + "github.com/go-openapi/runtime" + "github.com/go-openapi/runtime/middleware" + "github.com/go-openapi/strfmt" + "github.com/go-openapi/validate" +) + +// NewShareObjectParams creates a new ShareObjectParams object +// no default values defined in spec. +func NewShareObjectParams() ShareObjectParams { + + return ShareObjectParams{} +} + +// ShareObjectParams contains all the bound params for the share object operation +// typically these are obtained from a http.Request +// +// swagger:parameters ShareObject +type ShareObjectParams struct { + + // HTTP Request Object + HTTPRequest *http.Request `json:"-"` + + /* + Required: true + In: path + */ + BucketName string + /* + In: query + */ + Expires *string + /* + Required: true + In: query + */ + Prefix string + /* + Required: true + In: query + */ + VersionID string +} + +// BindRequest both binds and validates a request, it assumes that complex things implement a Validatable(strfmt.Registry) error interface +// for simple values it will use straight method calls. +// +// To ensure default values, the struct must have been initialized with NewShareObjectParams() beforehand. +func (o *ShareObjectParams) BindRequest(r *http.Request, route *middleware.MatchedRoute) error { + var res []error + + o.HTTPRequest = r + + qs := runtime.Values(r.URL.Query()) + + rBucketName, rhkBucketName, _ := route.Params.GetOK("bucket_name") + if err := o.bindBucketName(rBucketName, rhkBucketName, route.Formats); err != nil { + res = append(res, err) + } + + qExpires, qhkExpires, _ := qs.GetOK("expires") + if err := o.bindExpires(qExpires, qhkExpires, route.Formats); err != nil { + res = append(res, err) + } + + qPrefix, qhkPrefix, _ := qs.GetOK("prefix") + if err := o.bindPrefix(qPrefix, qhkPrefix, route.Formats); err != nil { + res = append(res, err) + } + + qVersionID, qhkVersionID, _ := qs.GetOK("version_id") + if err := o.bindVersionID(qVersionID, qhkVersionID, route.Formats); err != nil { + res = append(res, err) + } + + if len(res) > 0 { + return errors.CompositeValidationError(res...) + } + return nil +} + +// bindBucketName binds and validates parameter BucketName from path. +func (o *ShareObjectParams) bindBucketName(rawData []string, hasKey bool, formats strfmt.Registry) error { + var raw string + if len(rawData) > 0 { + raw = rawData[len(rawData)-1] + } + + // Required: true + // Parameter is provided by construction from the route + + o.BucketName = raw + + return nil +} + +// bindExpires binds and validates parameter Expires from query. +func (o *ShareObjectParams) bindExpires(rawData []string, hasKey bool, formats strfmt.Registry) error { + var raw string + if len(rawData) > 0 { + raw = rawData[len(rawData)-1] + } + + // Required: false + // AllowEmptyValue: false + if raw == "" { // empty values pass all other validations + return nil + } + + o.Expires = &raw + + return nil +} + +// bindPrefix binds and validates parameter Prefix from query. +func (o *ShareObjectParams) bindPrefix(rawData []string, hasKey bool, formats strfmt.Registry) error { + if !hasKey { + return errors.Required("prefix", "query", rawData) + } + var raw string + if len(rawData) > 0 { + raw = rawData[len(rawData)-1] + } + + // Required: true + // AllowEmptyValue: false + if err := validate.RequiredString("prefix", "query", raw); err != nil { + return err + } + + o.Prefix = raw + + return nil +} + +// bindVersionID binds and validates parameter VersionID from query. +func (o *ShareObjectParams) bindVersionID(rawData []string, hasKey bool, formats strfmt.Registry) error { + if !hasKey { + return errors.Required("version_id", "query", rawData) + } + var raw string + if len(rawData) > 0 { + raw = rawData[len(rawData)-1] + } + + // Required: true + // AllowEmptyValue: false + if err := validate.RequiredString("version_id", "query", raw); err != nil { + return err + } + + o.VersionID = raw + + return nil +} diff --git a/restapi/operations/user_api/share_object_responses.go b/restapi/operations/user_api/share_object_responses.go new file mode 100644 index 000000000..7fc33a606 --- /dev/null +++ b/restapi/operations/user_api/share_object_responses.go @@ -0,0 +1,131 @@ +// Code generated by go-swagger; DO NOT EDIT. + +// This file is part of MinIO Console Server +// Copyright (c) 2020 MinIO, Inc. +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU Affero General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU Affero General Public License for more details. +// +// You should have received a copy of the GNU Affero General Public License +// along with this program. If not, see . +// + +package user_api + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "net/http" + + "github.com/go-openapi/runtime" + + "github.com/minio/console/models" +) + +// ShareObjectOKCode is the HTTP code returned for type ShareObjectOK +const ShareObjectOKCode int = 200 + +/*ShareObjectOK A successful response. + +swagger:response shareObjectOK +*/ +type ShareObjectOK struct { + + /* + In: Body + */ + Payload string `json:"body,omitempty"` +} + +// NewShareObjectOK creates ShareObjectOK with default headers values +func NewShareObjectOK() *ShareObjectOK { + + return &ShareObjectOK{} +} + +// WithPayload adds the payload to the share object o k response +func (o *ShareObjectOK) WithPayload(payload string) *ShareObjectOK { + o.Payload = payload + return o +} + +// SetPayload sets the payload to the share object o k response +func (o *ShareObjectOK) SetPayload(payload string) { + o.Payload = payload +} + +// WriteResponse to the client +func (o *ShareObjectOK) WriteResponse(rw http.ResponseWriter, producer runtime.Producer) { + + rw.WriteHeader(200) + payload := o.Payload + if err := producer.Produce(rw, payload); err != nil { + panic(err) // let the recovery middleware deal with this + } +} + +/*ShareObjectDefault Generic error response. + +swagger:response shareObjectDefault +*/ +type ShareObjectDefault struct { + _statusCode int + + /* + In: Body + */ + Payload *models.Error `json:"body,omitempty"` +} + +// NewShareObjectDefault creates ShareObjectDefault with default headers values +func NewShareObjectDefault(code int) *ShareObjectDefault { + if code <= 0 { + code = 500 + } + + return &ShareObjectDefault{ + _statusCode: code, + } +} + +// WithStatusCode adds the status to the share object default response +func (o *ShareObjectDefault) WithStatusCode(code int) *ShareObjectDefault { + o._statusCode = code + return o +} + +// SetStatusCode sets the status to the share object default response +func (o *ShareObjectDefault) SetStatusCode(code int) { + o._statusCode = code +} + +// WithPayload adds the payload to the share object default response +func (o *ShareObjectDefault) WithPayload(payload *models.Error) *ShareObjectDefault { + o.Payload = payload + return o +} + +// SetPayload sets the payload to the share object default response +func (o *ShareObjectDefault) SetPayload(payload *models.Error) { + o.Payload = payload +} + +// WriteResponse to the client +func (o *ShareObjectDefault) WriteResponse(rw http.ResponseWriter, producer runtime.Producer) { + + rw.WriteHeader(o._statusCode) + if o.Payload != nil { + payload := o.Payload + if err := producer.Produce(rw, payload); err != nil { + panic(err) // let the recovery middleware deal with this + } + } +} diff --git a/restapi/operations/user_api/share_object_urlbuilder.go b/restapi/operations/user_api/share_object_urlbuilder.go new file mode 100644 index 000000000..10d0fe4ee --- /dev/null +++ b/restapi/operations/user_api/share_object_urlbuilder.go @@ -0,0 +1,142 @@ +// Code generated by go-swagger; DO NOT EDIT. + +// This file is part of MinIO Console Server +// Copyright (c) 2020 MinIO, Inc. +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU Affero General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU Affero General Public License for more details. +// +// You should have received a copy of the GNU Affero General Public License +// along with this program. If not, see . +// + +package user_api + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the generate command + +import ( + "errors" + "net/url" + golangswaggerpaths "path" + "strings" +) + +// ShareObjectURL generates an URL for the share object operation +type ShareObjectURL struct { + BucketName string + + Expires *string + Prefix string + VersionID string + + _basePath string + // avoid unkeyed usage + _ struct{} +} + +// WithBasePath sets the base path for this url builder, only required when it's different from the +// base path specified in the swagger spec. +// When the value of the base path is an empty string +func (o *ShareObjectURL) WithBasePath(bp string) *ShareObjectURL { + o.SetBasePath(bp) + return o +} + +// SetBasePath sets the base path for this url builder, only required when it's different from the +// base path specified in the swagger spec. +// When the value of the base path is an empty string +func (o *ShareObjectURL) SetBasePath(bp string) { + o._basePath = bp +} + +// Build a url path and query string +func (o *ShareObjectURL) Build() (*url.URL, error) { + var _result url.URL + + var _path = "/buckets/{bucket_name}/objects/share" + + bucketName := o.BucketName + if bucketName != "" { + _path = strings.Replace(_path, "{bucket_name}", bucketName, -1) + } else { + return nil, errors.New("bucketName is required on ShareObjectURL") + } + + _basePath := o._basePath + if _basePath == "" { + _basePath = "/api/v1" + } + _result.Path = golangswaggerpaths.Join(_basePath, _path) + + qs := make(url.Values) + + var expiresQ string + if o.Expires != nil { + expiresQ = *o.Expires + } + if expiresQ != "" { + qs.Set("expires", expiresQ) + } + + prefixQ := o.Prefix + if prefixQ != "" { + qs.Set("prefix", prefixQ) + } + + versionIDQ := o.VersionID + if versionIDQ != "" { + qs.Set("version_id", versionIDQ) + } + + _result.RawQuery = qs.Encode() + + return &_result, nil +} + +// Must is a helper function to panic when the url builder returns an error +func (o *ShareObjectURL) Must(u *url.URL, err error) *url.URL { + if err != nil { + panic(err) + } + if u == nil { + panic("url can't be nil") + } + return u +} + +// String returns the string representation of the path with query string +func (o *ShareObjectURL) String() string { + return o.Must(o.Build()).String() +} + +// BuildFull builds a full url with scheme, host, path and query string +func (o *ShareObjectURL) BuildFull(scheme, host string) (*url.URL, error) { + if scheme == "" { + return nil, errors.New("scheme is required for a full url on ShareObjectURL") + } + if host == "" { + return nil, errors.New("host is required for a full url on ShareObjectURL") + } + + base, err := o.Build() + if err != nil { + return nil, err + } + + base.Scheme = scheme + base.Host = host + return base, nil +} + +// StringFull returns the string representation of a complete url +func (o *ShareObjectURL) StringFull(scheme, host string) string { + return o.Must(o.BuildFull(scheme, host)).String() +} diff --git a/restapi/user_objects.go b/restapi/user_objects.go index 9c9cb0dbe..cfeaaf762 100644 --- a/restapi/user_objects.go +++ b/restapi/user_objects.go @@ -84,6 +84,14 @@ func registerObjectsHandlers(api *operations.ConsoleAPI) { } return user_api.NewPostBucketsBucketNameObjectsUploadOK() }) + // get share object url + api.UserAPIShareObjectHandler = user_api.ShareObjectHandlerFunc(func(params user_api.ShareObjectParams, session *models.Principal) middleware.Responder { + resp, err := getShareObjectResponse(session, params) + if err != nil { + return user_api.NewShareObjectDefault(int(err.Code)).WithPayload(err) + } + return user_api.NewShareObjectOK().WithPayload(*resp) + }) } // getListObjectsResponse returns a list of objects @@ -148,10 +156,9 @@ func listBucketObjects(ctx context.Context, client MinioClient, bucketName strin legalHoldStatus, err := client.getObjectLegalHold(ctx, bucketName, lsObj.Key, minio.GetObjectLegalHoldOptions{VersionID: lsObj.VersionID}) if err != nil { errResp := minio.ToErrorResponse(probe.NewError(err).ToGoError()) - if errResp.Code != "InvalidRequest" { + if errResp.Code != "InvalidRequest" && errResp.Code != "NoSuchObjectLockConfiguration" { log.Printf("error getting legal hold status for %s : %s", lsObj.VersionID, err) } - } else { if legalHoldStatus != nil { obj.LegalHoldStatus = string(*legalHoldStatus) @@ -255,7 +262,6 @@ func deleteMultipleObjects(ctx context.Context, client MCClient, recursive bool) contentCh := make(chan *mc.ClientContent, 1) errorCh := client.remove(ctx, isIncomplete, isRemoveBucket, isBypass, contentCh) -OUTER_LOOP: for content := range client.list(ctx, listOpts) { if content.Err != nil { switch content.Err.ToGoError().(type) { @@ -279,7 +285,7 @@ OUTER_LOOP: // Ignore Permission error. continue } - break OUTER_LOOP + return pErr.Cause } } } @@ -361,6 +367,44 @@ func uploadObject(ctx context.Context, client MinioClient, bucketName, prefix st return nil } +// getShareObjectResponse returns a share object url +func getShareObjectResponse(session *models.Principal, params user_api.ShareObjectParams) (*string, *models.Error) { + ctx := context.Background() + s3Client, err := newS3BucketClient(session, params.BucketName, params.Prefix) + if err != nil { + return nil, prepareError(err) + } + // create a mc S3Client interface implementation + // defining the client to be used + mcClient := mcClient{client: s3Client} + var expireDuration string + if params.Expires != nil { + expireDuration = *params.Expires + } + url, err := getShareObjectURL(ctx, mcClient, params.VersionID, expireDuration) + if err != nil { + return nil, prepareError(err) + } + return url, nil +} + +func getShareObjectURL(ctx context.Context, client MCClient, versionID string, duration string) (url *string, err error) { + // default duration 7d if not defined + if strings.TrimSpace(duration) == "" { + duration = "168h" + } + + expiresDuration, err := time.ParseDuration(duration) + if err != nil { + return nil, err + } + objURL, pErr := client.shareDownload(ctx, versionID, expiresDuration) + if pErr != nil { + return nil, pErr.Cause + } + return &objURL, nil +} + // newClientURL returns an abstracted URL for filesystems and object storage. func newClientURL(urlStr string) *mc.ClientURL { scheme, rest := getScheme(urlStr) diff --git a/restapi/user_objects_test.go b/restapi/user_objects_test.go index 574b9e044..bf1dc2204 100644 --- a/restapi/user_objects_test.go +++ b/restapi/user_objects_test.go @@ -29,6 +29,7 @@ import ( mc "github.com/minio/mc/cmd" "github.com/minio/mc/pkg/probe" "github.com/minio/minio-go/v7" + "github.com/stretchr/testify/assert" ) var minioListObjectsMock func(ctx context.Context, bucket string, opts minio.ListObjectsOptions) <-chan minio.ObjectInfo @@ -39,6 +40,7 @@ var minioPutObject func(ctx context.Context, bucketName, objectName string, read var mcListMock func(ctx context.Context, opts mc.ListOptions) <-chan *mc.ClientContent var mcRemoveMock func(ctx context.Context, isIncomplete, isRemoveBucket, isBypass bool, contentCh <-chan *mc.ClientContent) <-chan *probe.Error var mcGetMock func(ctx context.Context, opts mc.GetOptions) (io.ReadCloser, *probe.Error) +var mcShareDownloadMock func(ctx context.Context, versionID string, expires time.Duration) (string, *probe.Error) // mock functions for minioClientMock func (ac minioClientMock) listObjects(ctx context.Context, bucket string, opts minio.ListObjectsOptions) <-chan minio.ObjectInfo { @@ -68,6 +70,10 @@ func (c s3ClientMock) get(ctx context.Context, opts mc.GetOptions) (io.ReadClose return mcGetMock(ctx, opts) } +func (c s3ClientMock) shareDownload(ctx context.Context, versionID string, expires time.Duration) (string, *probe.Error) { + return mcShareDownloadMock(ctx, versionID, expires) +} + func Test_listObjects(t *testing.T) { ctx := context.Background() t1 := time.Now() @@ -545,3 +551,83 @@ func Test_deleteObjects(t *testing.T) { }) } } + +func Test_shareObject(t *testing.T) { + assert := assert.New(t) + ctx := context.Background() + client := s3ClientMock{} + type args struct { + versionID string + expires string + shareFunc func(ctx context.Context, versionID string, expires time.Duration) (string, *probe.Error) + } + tests := []struct { + test string + args args + wantError error + expected string + }{ + { + test: "Get share object url", + args: args{ + versionID: "2121434", + expires: "30s", + shareFunc: func(ctx context.Context, versionID string, expires time.Duration) (string, *probe.Error) { + return "http://someurl", nil + }, + }, + wantError: nil, + expected: "http://someurl", + }, + { + test: "handle invalid expire duration", + args: args{ + versionID: "2121434", + expires: "invalid", + shareFunc: func(ctx context.Context, versionID string, expires time.Duration) (string, *probe.Error) { + return "http://someurl", nil + }, + }, + wantError: errors.New("time: invalid duration invalid"), + }, + { + test: "handle empty expire duration", + args: args{ + versionID: "2121434", + expires: "", + shareFunc: func(ctx context.Context, versionID string, expires time.Duration) (string, *probe.Error) { + return "http://someurl", nil + }, + }, + wantError: nil, + expected: "http://someurl", + }, + { + test: "handle error on share func", + args: args{ + versionID: "2121434", + expires: "3h", + shareFunc: func(ctx context.Context, versionID string, expires time.Duration) (string, *probe.Error) { + return "", probe.NewError(errors.New("probe error")) + }, + }, + wantError: errors.New("probe error"), + }, + } + + for _, tt := range tests { + t.Run(tt.test, func(t *testing.T) { + mcShareDownloadMock = tt.args.shareFunc + url, err := getShareObjectURL(ctx, client, tt.args.versionID, tt.args.expires) + if tt.wantError != nil { + if !reflect.DeepEqual(err, tt.wantError) { + t.Errorf("getShareObjectURL() error: %v, wantErr: %v", err, tt.wantError) + return + } + } else { + assert.Equal(*url, tt.expected) + } + + }) + } +} diff --git a/swagger.yml b/swagger.yml index c6b7f35c8..4914220fc 100644 --- a/swagger.yml +++ b/swagger.yml @@ -340,6 +340,39 @@ paths: tags: - UserAPI + /buckets/{bucket_name}/objects/share: + get: + summary: Shares an Object on a url + operationId: ShareObject + parameters: + - name: bucket_name + in: path + required: true + type: string + - name: prefix + in: query + required: true + type: string + - name: version_id + in: query + required: true + type: string + - name: expires + in: query + required: false + type: string + responses: + 200: + description: A successful response. + schema: + type: string + default: + description: Generic error response. + schema: + $ref: "#/definitions/error" + tags: + - UserAPI + /buckets/{name}/set-policy: put: summary: Bucket Set Policy