Optimize compilation by removing logging tests (#816)
This commit is contained in:
Egon Elbre
GitHub
parent
3f9492a4dd
commit
26dbf788ad
@ -14,7 +14,6 @@ import (
|
||||
|
||||
"storj.io/storj/pkg/eestream"
|
||||
"storj.io/storj/pkg/metainfo/kvmetainfo"
|
||||
"storj.io/storj/pkg/miniogw/logging"
|
||||
"storj.io/storj/pkg/overlay"
|
||||
"storj.io/storj/pkg/pointerdb/pdbclient"
|
||||
"storj.io/storj/pkg/provider"
|
||||
@ -119,7 +118,7 @@ func (c Config) action(ctx context.Context, cliCtx *cli.Context, identity *provi
|
||||
return err
|
||||
}
|
||||
|
||||
minio.StartGateway(cliCtx, logging.Gateway(gw, zap.L()))
|
||||
minio.StartGateway(cliCtx, Logging(gw, zap.L()))
|
||||
return Error.New("unexpected minio exit")
|
||||
}
|
||||
|
||||
|
||||
@ -1,10 +1,11 @@
|
||||
// Copyright (C) 2018 Storj Labs, Inc.
|
||||
// See LICENSE for copying information.
|
||||
|
||||
package miniogw
|
||||
package miniogw_test
|
||||
|
||||
import (
|
||||
"context"
|
||||
"errors"
|
||||
"flag"
|
||||
"os"
|
||||
"testing"
|
||||
@ -21,7 +22,7 @@ import (
|
||||
"storj.io/storj/internal/testcontext"
|
||||
"storj.io/storj/internal/testplanet"
|
||||
"storj.io/storj/pkg/cfgstruct"
|
||||
"storj.io/storj/pkg/miniogw/logging"
|
||||
"storj.io/storj/pkg/miniogw"
|
||||
"storj.io/storj/pkg/provider"
|
||||
)
|
||||
|
||||
@ -38,7 +39,7 @@ func TestUploadDownload(t *testing.T) {
|
||||
assert.NoError(t, err)
|
||||
|
||||
// bind default values to config
|
||||
var gwCfg Config
|
||||
var gwCfg miniogw.Config
|
||||
cfgstruct.Bind(&flag.FlagSet{}, &gwCfg)
|
||||
|
||||
// minio config directory
|
||||
@ -116,7 +117,7 @@ func TestUploadDownload(t *testing.T) {
|
||||
}
|
||||
|
||||
// runGateway creates and starts a gateway
|
||||
func runGateway(ctx context.Context, c Config, log *zap.Logger, identity *provider.FullIdentity) (err error) {
|
||||
func runGateway(ctx context.Context, c miniogw.Config, log *zap.Logger, identity *provider.FullIdentity) (err error) {
|
||||
|
||||
// set gateway flags
|
||||
flags := flag.NewFlagSet("gateway", flag.ExitOnError)
|
||||
@ -148,6 +149,6 @@ func runGateway(ctx context.Context, c Config, log *zap.Logger, identity *provid
|
||||
return err
|
||||
}
|
||||
|
||||
minio.StartGateway(cliCtx, logging.Gateway(gw, log))
|
||||
return Error.New("unexpected minio exit")
|
||||
minio.StartGateway(cliCtx, miniogw.Logging(gw, log))
|
||||
return errors.New("unexpected minio exit")
|
||||
}
|
||||
|
||||
208
pkg/miniogw/logging.go
Normal file
208
pkg/miniogw/logging.go
Normal file
@ -0,0 +1,208 @@
|
||||
// Copyright (C) 2018 Storj Labs, Inc.
|
||||
// See LICENSE for copying information.
|
||||
|
||||
package miniogw
|
||||
|
||||
import (
|
||||
"context"
|
||||
"io"
|
||||
"reflect"
|
||||
"time"
|
||||
|
||||
minio "github.com/minio/minio/cmd"
|
||||
"github.com/minio/minio/pkg/auth"
|
||||
"github.com/minio/minio/pkg/hash"
|
||||
"github.com/minio/minio/pkg/madmin"
|
||||
"github.com/minio/minio/pkg/policy"
|
||||
"go.uber.org/zap"
|
||||
)
|
||||
|
||||
type gatewayLogging struct {
|
||||
gateway minio.Gateway
|
||||
log *zap.Logger
|
||||
}
|
||||
|
||||
// Logging returns a wrapper of minio.Gateway that logs errors before returning them.
|
||||
func Logging(gateway minio.Gateway, log *zap.Logger) minio.Gateway {
|
||||
return &gatewayLogging{gateway, log}
|
||||
}
|
||||
|
||||
func (lg *gatewayLogging) Name() string { return lg.gateway.Name() }
|
||||
func (lg *gatewayLogging) Production() bool { return lg.gateway.Production() }
|
||||
func (lg *gatewayLogging) NewGatewayLayer(creds auth.Credentials) (minio.ObjectLayer, error) {
|
||||
layer, err := lg.gateway.NewGatewayLayer(creds)
|
||||
return &layerLogging{layer: layer, logger: lg.log}, err
|
||||
}
|
||||
|
||||
type layerLogging struct {
|
||||
layer minio.ObjectLayer
|
||||
logger *zap.Logger
|
||||
}
|
||||
|
||||
// minioError checks if the given error is a minio error.
|
||||
func minioError(err error) bool {
|
||||
return reflect.TypeOf(err).ConvertibleTo(reflect.TypeOf(minio.GenericError{}))
|
||||
}
|
||||
|
||||
// log unexpected errors, i.e. non-minio errors. It will return the given error
|
||||
// to allow method chaining.
|
||||
func (log *layerLogging) log(err error) error {
|
||||
if err != nil && !minioError(err) {
|
||||
log.logger.Error("gateway error:", zap.Error(err))
|
||||
}
|
||||
return err
|
||||
}
|
||||
|
||||
func (log *layerLogging) Shutdown(ctx context.Context) error {
|
||||
return log.log(log.layer.Shutdown(ctx))
|
||||
}
|
||||
|
||||
func (log *layerLogging) StorageInfo(ctx context.Context) minio.StorageInfo {
|
||||
return log.layer.StorageInfo(ctx)
|
||||
}
|
||||
|
||||
func (log *layerLogging) MakeBucketWithLocation(ctx context.Context, bucket string, location string) error {
|
||||
return log.log(log.layer.MakeBucketWithLocation(ctx, bucket, location))
|
||||
}
|
||||
|
||||
func (log *layerLogging) GetBucketInfo(ctx context.Context, bucket string) (bucketInfo minio.BucketInfo, err error) {
|
||||
bucketInfo, err = log.layer.GetBucketInfo(ctx, bucket)
|
||||
return bucketInfo, log.log(err)
|
||||
}
|
||||
|
||||
func (log *layerLogging) ListBuckets(ctx context.Context) (buckets []minio.BucketInfo, err error) {
|
||||
buckets, err = log.layer.ListBuckets(ctx)
|
||||
return buckets, log.log(err)
|
||||
}
|
||||
|
||||
func (log *layerLogging) DeleteBucket(ctx context.Context, bucket string) error {
|
||||
return log.log(log.layer.DeleteBucket(ctx, bucket))
|
||||
}
|
||||
|
||||
func (log *layerLogging) ListObjects(ctx context.Context, bucket, prefix, marker, delimiter string, maxKeys int) (result minio.ListObjectsInfo, err error) {
|
||||
result, err = log.layer.ListObjects(ctx, bucket, prefix, marker, delimiter,
|
||||
maxKeys)
|
||||
return result, log.log(err)
|
||||
}
|
||||
|
||||
func (log *layerLogging) ListObjectsV2(ctx context.Context, bucket, prefix, continuationToken, delimiter string, maxKeys int, fetchOwner bool, startAfter string) (result minio.ListObjectsV2Info, err error) {
|
||||
result, err = log.layer.ListObjectsV2(ctx, bucket, prefix, continuationToken, delimiter, maxKeys, fetchOwner, startAfter)
|
||||
return result, log.log(err)
|
||||
}
|
||||
|
||||
func (log *layerLogging) GetObject(ctx context.Context, bucket, object string, startOffset int64, length int64, writer io.Writer, etag string) (err error) {
|
||||
return log.log(log.layer.GetObject(ctx, bucket, object, startOffset, length, writer, etag))
|
||||
}
|
||||
|
||||
func (log *layerLogging) GetObjectInfo(ctx context.Context, bucket, object string) (objInfo minio.ObjectInfo, err error) {
|
||||
objInfo, err = log.layer.GetObjectInfo(ctx, bucket, object)
|
||||
return objInfo, log.log(err)
|
||||
}
|
||||
|
||||
func (log *layerLogging) PutObject(ctx context.Context, bucket, object string, data *hash.Reader, metadata map[string]string) (objInfo minio.ObjectInfo, err error) {
|
||||
objInfo, err = log.layer.PutObject(ctx, bucket, object, data, metadata)
|
||||
return objInfo, log.log(err)
|
||||
}
|
||||
|
||||
func (log *layerLogging) CopyObject(ctx context.Context, srcBucket, srcObject, destBucket, destObject string, srcInfo minio.ObjectInfo) (objInfo minio.ObjectInfo, err error) {
|
||||
objInfo, err = log.layer.CopyObject(ctx, srcBucket, srcObject, destBucket, destObject, srcInfo)
|
||||
return objInfo, log.log(err)
|
||||
}
|
||||
|
||||
func (log *layerLogging) DeleteObject(ctx context.Context, bucket, object string) (err error) {
|
||||
return log.log(log.layer.DeleteObject(ctx, bucket, object))
|
||||
}
|
||||
|
||||
func (log *layerLogging) ListMultipartUploads(ctx context.Context, bucket, prefix, keyMarker, uploadIDMarker, delimiter string, maxUploads int) (result minio.ListMultipartsInfo, err error) {
|
||||
result, err = log.layer.ListMultipartUploads(ctx, bucket, prefix, keyMarker, uploadIDMarker, delimiter, maxUploads)
|
||||
return result, log.log(err)
|
||||
}
|
||||
|
||||
func (log *layerLogging) NewMultipartUpload(ctx context.Context, bucket, object string, metadata map[string]string) (uploadID string, err error) {
|
||||
uploadID, err = log.layer.NewMultipartUpload(ctx, bucket, object, metadata)
|
||||
return uploadID, log.log(err)
|
||||
}
|
||||
|
||||
func (log *layerLogging) CopyObjectPart(ctx context.Context, srcBucket, srcObject, destBucket, destObject string, uploadID string, partID int, startOffset int64, length int64, srcInfo minio.ObjectInfo) (info minio.PartInfo, err error) {
|
||||
info, err = log.layer.CopyObjectPart(ctx, srcBucket, srcObject, destBucket, destObject, uploadID, partID, startOffset, length, srcInfo)
|
||||
return info, log.log(err)
|
||||
}
|
||||
|
||||
func (log *layerLogging) PutObjectPart(ctx context.Context, bucket, object, uploadID string, partID int, data *hash.Reader) (info minio.PartInfo, err error) {
|
||||
info, err = log.layer.PutObjectPart(ctx, bucket, object, uploadID, partID, data)
|
||||
return info, log.log(err)
|
||||
}
|
||||
|
||||
func (log *layerLogging) ListObjectParts(ctx context.Context, bucket, object, uploadID string, partNumberMarker int, maxParts int) (result minio.ListPartsInfo, err error) {
|
||||
result, err = log.layer.ListObjectParts(ctx, bucket, object, uploadID,
|
||||
partNumberMarker, maxParts)
|
||||
return result, log.log(err)
|
||||
}
|
||||
|
||||
func (log *layerLogging) AbortMultipartUpload(ctx context.Context, bucket, object, uploadID string) error {
|
||||
return log.log(log.layer.AbortMultipartUpload(ctx, bucket, object, uploadID))
|
||||
}
|
||||
|
||||
func (log *layerLogging) CompleteMultipartUpload(ctx context.Context, bucket, object, uploadID string, uploadedParts []minio.CompletePart) (objInfo minio.ObjectInfo, err error) {
|
||||
objInfo, err = log.layer.CompleteMultipartUpload(ctx, bucket, object, uploadID, uploadedParts)
|
||||
return objInfo, log.log(err)
|
||||
}
|
||||
|
||||
func (log *layerLogging) ReloadFormat(ctx context.Context, dryRun bool) error {
|
||||
return log.log(log.layer.ReloadFormat(ctx, dryRun))
|
||||
}
|
||||
|
||||
func (log *layerLogging) HealFormat(ctx context.Context, dryRun bool) (madmin.HealResultItem, error) {
|
||||
rv, err := log.layer.HealFormat(ctx, dryRun)
|
||||
return rv, log.log(err)
|
||||
}
|
||||
|
||||
func (log *layerLogging) HealBucket(ctx context.Context, bucket string, dryRun bool) ([]madmin.HealResultItem, error) {
|
||||
rv, err := log.layer.HealBucket(ctx, bucket, dryRun)
|
||||
return rv, log.log(err)
|
||||
}
|
||||
|
||||
func (log *layerLogging) HealObject(ctx context.Context, bucket, object string, dryRun bool) (madmin.HealResultItem, error) {
|
||||
rv, err := log.layer.HealObject(ctx, bucket, object, dryRun)
|
||||
return rv, log.log(err)
|
||||
}
|
||||
|
||||
func (log *layerLogging) ListBucketsHeal(ctx context.Context) (buckets []minio.BucketInfo, err error) {
|
||||
buckets, err = log.layer.ListBucketsHeal(ctx)
|
||||
return buckets, log.log(err)
|
||||
}
|
||||
|
||||
func (log *layerLogging) ListObjectsHeal(ctx context.Context, bucket, prefix, marker, delimiter string, maxKeys int) (minio.ListObjectsInfo, error) {
|
||||
rv, err := log.layer.ListObjectsHeal(ctx, bucket, prefix, marker, delimiter, maxKeys)
|
||||
return rv, log.log(err)
|
||||
}
|
||||
|
||||
func (log *layerLogging) ListLocks(ctx context.Context, bucket, prefix string, duration time.Duration) ([]minio.VolumeLockInfo, error) {
|
||||
rv, err := log.layer.ListLocks(ctx, bucket, prefix, duration)
|
||||
return rv, log.log(err)
|
||||
}
|
||||
|
||||
func (log *layerLogging) ClearLocks(ctx context.Context, lockInfos []minio.VolumeLockInfo) error {
|
||||
return log.log(log.layer.ClearLocks(ctx, lockInfos))
|
||||
}
|
||||
|
||||
func (log *layerLogging) SetBucketPolicy(ctx context.Context, n string, p *policy.Policy) error {
|
||||
return log.log(log.layer.SetBucketPolicy(ctx, n, p))
|
||||
}
|
||||
|
||||
func (log *layerLogging) GetBucketPolicy(ctx context.Context, n string) (*policy.Policy, error) {
|
||||
p, err := log.layer.GetBucketPolicy(ctx, n)
|
||||
return p, log.log(err)
|
||||
}
|
||||
|
||||
func (log *layerLogging) DeleteBucketPolicy(ctx context.Context, n string) error {
|
||||
return log.log(log.layer.DeleteBucketPolicy(ctx, n))
|
||||
}
|
||||
|
||||
func (log *layerLogging) IsNotificationSupported() bool {
|
||||
return log.layer.IsNotificationSupported()
|
||||
}
|
||||
|
||||
func (log *layerLogging) IsEncryptionSupported() bool {
|
||||
return log.layer.IsEncryptionSupported()
|
||||
}
|
||||
@ -1,76 +0,0 @@
|
||||
// Copyright (C) 2018 Storj Labs, Inc.
|
||||
// See LICENSE for copying information.
|
||||
|
||||
// Code generated by MockGen. DO NOT EDIT.
|
||||
// Source: github.com/minio/minio/cmd (interfaces: Gateway)
|
||||
|
||||
// Package logging is a generated GoMock package.
|
||||
package logging
|
||||
|
||||
import (
|
||||
reflect "reflect"
|
||||
|
||||
gomock "github.com/golang/mock/gomock"
|
||||
cmd "github.com/minio/minio/cmd"
|
||||
auth "github.com/minio/minio/pkg/auth"
|
||||
)
|
||||
|
||||
// MockGateway is a mock of Gateway interface
|
||||
type MockGateway struct {
|
||||
ctrl *gomock.Controller
|
||||
recorder *MockGatewayMockRecorder
|
||||
}
|
||||
|
||||
// MockGatewayMockRecorder is the mock recorder for MockGateway
|
||||
type MockGatewayMockRecorder struct {
|
||||
mock *MockGateway
|
||||
}
|
||||
|
||||
// NewMockGateway creates a new mock instance
|
||||
func NewMockGateway(ctrl *gomock.Controller) *MockGateway {
|
||||
mock := &MockGateway{ctrl: ctrl}
|
||||
mock.recorder = &MockGatewayMockRecorder{mock}
|
||||
return mock
|
||||
}
|
||||
|
||||
// EXPECT returns an object that allows the caller to indicate expected use
|
||||
func (m *MockGateway) EXPECT() *MockGatewayMockRecorder {
|
||||
return m.recorder
|
||||
}
|
||||
|
||||
// Name mocks base method
|
||||
func (m *MockGateway) Name() string {
|
||||
ret := m.ctrl.Call(m, "Name")
|
||||
ret0, _ := ret[0].(string)
|
||||
return ret0
|
||||
}
|
||||
|
||||
// Name indicates an expected call of Name
|
||||
func (mr *MockGatewayMockRecorder) Name() *gomock.Call {
|
||||
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Name", reflect.TypeOf((*MockGateway)(nil).Name))
|
||||
}
|
||||
|
||||
// NewGatewayLayer mocks base method
|
||||
func (m *MockGateway) NewGatewayLayer(arg0 auth.Credentials) (cmd.ObjectLayer, error) {
|
||||
ret := m.ctrl.Call(m, "NewGatewayLayer", arg0)
|
||||
ret0, _ := ret[0].(cmd.ObjectLayer)
|
||||
ret1, _ := ret[1].(error)
|
||||
return ret0, ret1
|
||||
}
|
||||
|
||||
// NewGatewayLayer indicates an expected call of NewGatewayLayer
|
||||
func (mr *MockGatewayMockRecorder) NewGatewayLayer(arg0 interface{}) *gomock.Call {
|
||||
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewGatewayLayer", reflect.TypeOf((*MockGateway)(nil).NewGatewayLayer), arg0)
|
||||
}
|
||||
|
||||
// Production mocks base method
|
||||
func (m *MockGateway) Production() bool {
|
||||
ret := m.ctrl.Call(m, "Production")
|
||||
ret0, _ := ret[0].(bool)
|
||||
return ret0
|
||||
}
|
||||
|
||||
// Production indicates an expected call of Production
|
||||
func (mr *MockGatewayMockRecorder) Production() *gomock.Call {
|
||||
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Production", reflect.TypeOf((*MockGateway)(nil).Production))
|
||||
}
|
||||
@ -1,63 +0,0 @@
|
||||
// Code generated by MockGen. DO NOT EDIT.
|
||||
// Source: storj.io/storj/pkg/miniogw/logging (interfaces: ErrorLogger)
|
||||
|
||||
// Package logging is a generated GoMock package.
|
||||
package logging
|
||||
|
||||
import (
|
||||
gomock "github.com/golang/mock/gomock"
|
||||
reflect "reflect"
|
||||
)
|
||||
|
||||
// MockErrorLogger is a mock of ErrorLogger interface
|
||||
type MockErrorLogger struct {
|
||||
ctrl *gomock.Controller
|
||||
recorder *MockErrorLoggerMockRecorder
|
||||
}
|
||||
|
||||
// MockErrorLoggerMockRecorder is the mock recorder for MockErrorLogger
|
||||
type MockErrorLoggerMockRecorder struct {
|
||||
mock *MockErrorLogger
|
||||
}
|
||||
|
||||
// NewMockErrorLogger creates a new mock instance
|
||||
func NewMockErrorLogger(ctrl *gomock.Controller) *MockErrorLogger {
|
||||
mock := &MockErrorLogger{ctrl: ctrl}
|
||||
mock.recorder = &MockErrorLoggerMockRecorder{mock}
|
||||
return mock
|
||||
}
|
||||
|
||||
// EXPECT returns an object that allows the caller to indicate expected use
|
||||
func (m *MockErrorLogger) EXPECT() *MockErrorLoggerMockRecorder {
|
||||
return m.recorder
|
||||
}
|
||||
|
||||
// Debugf mocks base method
|
||||
func (m *MockErrorLogger) Debugf(arg0 string, arg1 ...interface{}) {
|
||||
varargs := []interface{}{arg0}
|
||||
for _, a := range arg1 {
|
||||
varargs = append(varargs, a)
|
||||
}
|
||||
m.ctrl.Call(m, "Debugf", varargs...)
|
||||
}
|
||||
|
||||
// Debugf indicates an expected call of Debugf
|
||||
func (mr *MockErrorLoggerMockRecorder) Debugf(arg0 interface{}, arg1 ...interface{}) *gomock.Call {
|
||||
varargs := append([]interface{}{arg0}, arg1...)
|
||||
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Debugf", reflect.TypeOf((*MockErrorLogger)(nil).Debugf), varargs...)
|
||||
}
|
||||
|
||||
// Errorf mocks base method
|
||||
func (m *MockErrorLogger) Errorf(arg0 string, arg1 ...interface{}) {
|
||||
varargs := []interface{}{arg0}
|
||||
for _, a := range arg1 {
|
||||
varargs = append(varargs, a)
|
||||
}
|
||||
m.ctrl.Call(m, "Errorf", varargs...)
|
||||
}
|
||||
|
||||
// Errorf indicates an expected call of Errorf
|
||||
func (mr *MockErrorLoggerMockRecorder) Errorf(arg0 interface{}, arg1 ...interface{}) *gomock.Call {
|
||||
varargs := append([]interface{}{arg0}, arg1...)
|
||||
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Errorf", reflect.TypeOf((*MockErrorLogger)(nil).Errorf), varargs...)
|
||||
}
|
||||
@ -1,261 +0,0 @@
|
||||
// Copyright (C) 2018 Storj Labs, Inc.
|
||||
// See LICENSE for copying information.
|
||||
|
||||
package logging
|
||||
|
||||
import (
|
||||
context "context"
|
||||
io "io"
|
||||
"reflect"
|
||||
"time"
|
||||
|
||||
minio "github.com/minio/minio/cmd"
|
||||
"github.com/minio/minio/pkg/auth"
|
||||
"github.com/minio/minio/pkg/hash"
|
||||
"github.com/minio/minio/pkg/madmin"
|
||||
"github.com/minio/minio/pkg/policy"
|
||||
"go.uber.org/zap"
|
||||
)
|
||||
|
||||
type gwLogWrap struct {
|
||||
gw minio.Gateway
|
||||
log *zap.Logger
|
||||
}
|
||||
|
||||
// Gateway is a wrapper of minio.Gateway that logs errors before
|
||||
// returning them.
|
||||
func Gateway(gw minio.Gateway, log *zap.Logger) minio.Gateway {
|
||||
return &gwLogWrap{gw, log}
|
||||
}
|
||||
|
||||
func (lg *gwLogWrap) Name() string { return lg.gw.Name() }
|
||||
func (lg *gwLogWrap) Production() bool { return lg.gw.Production() }
|
||||
func (lg *gwLogWrap) NewGatewayLayer(creds auth.Credentials) (
|
||||
minio.ObjectLayer, error) {
|
||||
ol, err := lg.gw.NewGatewayLayer(creds)
|
||||
return &olLogWrap{ol: ol, logger: lg.log}, err
|
||||
}
|
||||
|
||||
type olLogWrap struct {
|
||||
ol minio.ObjectLayer
|
||||
logger ErrorLogger
|
||||
}
|
||||
|
||||
// ErrorLogger logs a templated error message.
|
||||
type ErrorLogger interface {
|
||||
Error(msg string, fields ...zap.Field)
|
||||
}
|
||||
|
||||
// minioError checks if the given error is a minio error.
|
||||
func minioError(err error) bool {
|
||||
return reflect.TypeOf(err).ConvertibleTo(reflect.TypeOf(minio.GenericError{}))
|
||||
}
|
||||
|
||||
// log unexpected errors, i.e. non-minio errors. It will return the given error
|
||||
// to allow method chaining.
|
||||
func (ol *olLogWrap) log(err error) error {
|
||||
if err != nil && !minioError(err) {
|
||||
ol.logger.Error("gateway error:", zap.Error(err))
|
||||
}
|
||||
return err
|
||||
}
|
||||
|
||||
func (ol *olLogWrap) Shutdown(ctx context.Context) error {
|
||||
return ol.log(ol.ol.Shutdown(ctx))
|
||||
}
|
||||
|
||||
func (ol *olLogWrap) StorageInfo(ctx context.Context) minio.StorageInfo {
|
||||
return ol.ol.StorageInfo(ctx)
|
||||
}
|
||||
|
||||
func (ol *olLogWrap) MakeBucketWithLocation(ctx context.Context,
|
||||
bucket string, location string) error {
|
||||
return ol.log(ol.ol.MakeBucketWithLocation(ctx, bucket, location))
|
||||
}
|
||||
|
||||
func (ol *olLogWrap) GetBucketInfo(ctx context.Context, bucket string) (
|
||||
bucketInfo minio.BucketInfo, err error) {
|
||||
bucketInfo, err = ol.ol.GetBucketInfo(ctx, bucket)
|
||||
return bucketInfo, ol.log(err)
|
||||
}
|
||||
|
||||
func (ol *olLogWrap) ListBuckets(ctx context.Context) (
|
||||
buckets []minio.BucketInfo, err error) {
|
||||
buckets, err = ol.ol.ListBuckets(ctx)
|
||||
return buckets, ol.log(err)
|
||||
}
|
||||
|
||||
func (ol *olLogWrap) DeleteBucket(ctx context.Context, bucket string) error {
|
||||
return ol.log(ol.ol.DeleteBucket(ctx, bucket))
|
||||
}
|
||||
|
||||
func (ol *olLogWrap) ListObjects(ctx context.Context,
|
||||
bucket, prefix, marker, delimiter string, maxKeys int) (
|
||||
result minio.ListObjectsInfo, err error) {
|
||||
result, err = ol.ol.ListObjects(ctx, bucket, prefix, marker, delimiter,
|
||||
maxKeys)
|
||||
return result, ol.log(err)
|
||||
}
|
||||
|
||||
func (ol *olLogWrap) ListObjectsV2(ctx context.Context,
|
||||
bucket, prefix, continuationToken, delimiter string, maxKeys int,
|
||||
fetchOwner bool, startAfter string) (result minio.ListObjectsV2Info,
|
||||
err error) {
|
||||
result, err = ol.ol.ListObjectsV2(ctx, bucket, prefix, continuationToken,
|
||||
delimiter, maxKeys, fetchOwner, startAfter)
|
||||
return result, ol.log(err)
|
||||
}
|
||||
|
||||
func (ol *olLogWrap) GetObject(ctx context.Context, bucket, object string,
|
||||
startOffset int64, length int64, writer io.Writer, etag string) (err error) {
|
||||
return ol.log(ol.ol.GetObject(ctx, bucket, object, startOffset, length,
|
||||
writer, etag))
|
||||
}
|
||||
|
||||
func (ol *olLogWrap) GetObjectInfo(ctx context.Context, bucket, object string) (
|
||||
objInfo minio.ObjectInfo, err error) {
|
||||
objInfo, err = ol.ol.GetObjectInfo(ctx, bucket, object)
|
||||
return objInfo, ol.log(err)
|
||||
}
|
||||
|
||||
func (ol *olLogWrap) PutObject(ctx context.Context, bucket, object string,
|
||||
data *hash.Reader, metadata map[string]string) (objInfo minio.ObjectInfo,
|
||||
err error) {
|
||||
objInfo, err = ol.ol.PutObject(ctx, bucket, object, data, metadata)
|
||||
return objInfo, ol.log(err)
|
||||
}
|
||||
|
||||
func (ol *olLogWrap) CopyObject(ctx context.Context,
|
||||
srcBucket, srcObject, destBucket, destObject string,
|
||||
srcInfo minio.ObjectInfo) (objInfo minio.ObjectInfo, err error) {
|
||||
objInfo, err = ol.ol.CopyObject(ctx, srcBucket, srcObject, destBucket,
|
||||
destObject, srcInfo)
|
||||
return objInfo, ol.log(err)
|
||||
}
|
||||
|
||||
func (ol *olLogWrap) DeleteObject(ctx context.Context, bucket, object string) (
|
||||
err error) {
|
||||
return ol.log(ol.ol.DeleteObject(ctx, bucket, object))
|
||||
}
|
||||
|
||||
func (ol *olLogWrap) ListMultipartUploads(ctx context.Context,
|
||||
bucket, prefix, keyMarker, uploadIDMarker, delimiter string, maxUploads int) (
|
||||
result minio.ListMultipartsInfo, err error) {
|
||||
result, err = ol.ol.ListMultipartUploads(ctx, bucket, prefix, keyMarker,
|
||||
uploadIDMarker, delimiter, maxUploads)
|
||||
return result, ol.log(err)
|
||||
}
|
||||
|
||||
func (ol *olLogWrap) NewMultipartUpload(ctx context.Context,
|
||||
bucket, object string, metadata map[string]string) (uploadID string,
|
||||
err error) {
|
||||
uploadID, err = ol.ol.NewMultipartUpload(ctx, bucket, object, metadata)
|
||||
return uploadID, ol.log(err)
|
||||
}
|
||||
|
||||
func (ol *olLogWrap) CopyObjectPart(ctx context.Context,
|
||||
srcBucket, srcObject, destBucket, destObject string, uploadID string,
|
||||
partID int, startOffset int64, length int64, srcInfo minio.ObjectInfo) (
|
||||
info minio.PartInfo, err error) {
|
||||
info, err = ol.ol.CopyObjectPart(ctx, srcBucket, srcObject, destBucket,
|
||||
destObject, uploadID, partID, startOffset, length, srcInfo)
|
||||
return info, ol.log(err)
|
||||
}
|
||||
|
||||
func (ol *olLogWrap) PutObjectPart(ctx context.Context,
|
||||
bucket, object, uploadID string, partID int, data *hash.Reader) (
|
||||
info minio.PartInfo, err error) {
|
||||
info, err = ol.ol.PutObjectPart(ctx, bucket, object, uploadID, partID, data)
|
||||
return info, ol.log(err)
|
||||
}
|
||||
|
||||
func (ol *olLogWrap) ListObjectParts(ctx context.Context,
|
||||
bucket, object, uploadID string, partNumberMarker int, maxParts int) (
|
||||
result minio.ListPartsInfo, err error) {
|
||||
result, err = ol.ol.ListObjectParts(ctx, bucket, object, uploadID,
|
||||
partNumberMarker, maxParts)
|
||||
return result, ol.log(err)
|
||||
}
|
||||
|
||||
func (ol *olLogWrap) AbortMultipartUpload(ctx context.Context,
|
||||
bucket, object, uploadID string) error {
|
||||
return ol.log(ol.ol.AbortMultipartUpload(ctx, bucket, object, uploadID))
|
||||
}
|
||||
|
||||
func (ol *olLogWrap) CompleteMultipartUpload(ctx context.Context,
|
||||
bucket, object, uploadID string, uploadedParts []minio.CompletePart) (
|
||||
objInfo minio.ObjectInfo, err error) {
|
||||
objInfo, err = ol.ol.CompleteMultipartUpload(ctx, bucket, object, uploadID,
|
||||
uploadedParts)
|
||||
return objInfo, ol.log(err)
|
||||
}
|
||||
|
||||
func (ol *olLogWrap) ReloadFormat(ctx context.Context, dryRun bool) error {
|
||||
return ol.log(ol.ol.ReloadFormat(ctx, dryRun))
|
||||
}
|
||||
|
||||
func (ol *olLogWrap) HealFormat(ctx context.Context, dryRun bool) (
|
||||
madmin.HealResultItem, error) {
|
||||
rv, err := ol.ol.HealFormat(ctx, dryRun)
|
||||
return rv, ol.log(err)
|
||||
}
|
||||
|
||||
func (ol *olLogWrap) HealBucket(ctx context.Context, bucket string,
|
||||
dryRun bool) ([]madmin.HealResultItem, error) {
|
||||
rv, err := ol.ol.HealBucket(ctx, bucket, dryRun)
|
||||
return rv, ol.log(err)
|
||||
}
|
||||
|
||||
func (ol *olLogWrap) HealObject(ctx context.Context, bucket, object string,
|
||||
dryRun bool) (madmin.HealResultItem, error) {
|
||||
rv, err := ol.ol.HealObject(ctx, bucket, object, dryRun)
|
||||
return rv, ol.log(err)
|
||||
}
|
||||
|
||||
func (ol *olLogWrap) ListBucketsHeal(ctx context.Context) (
|
||||
buckets []minio.BucketInfo, err error) {
|
||||
buckets, err = ol.ol.ListBucketsHeal(ctx)
|
||||
return buckets, ol.log(err)
|
||||
}
|
||||
|
||||
func (ol *olLogWrap) ListObjectsHeal(ctx context.Context,
|
||||
bucket, prefix, marker, delimiter string, maxKeys int) (
|
||||
minio.ListObjectsInfo, error) {
|
||||
rv, err := ol.ol.ListObjectsHeal(ctx, bucket, prefix, marker, delimiter,
|
||||
maxKeys)
|
||||
return rv, ol.log(err)
|
||||
}
|
||||
|
||||
func (ol *olLogWrap) ListLocks(ctx context.Context, bucket, prefix string,
|
||||
duration time.Duration) ([]minio.VolumeLockInfo, error) {
|
||||
rv, err := ol.ol.ListLocks(ctx, bucket, prefix, duration)
|
||||
return rv, ol.log(err)
|
||||
}
|
||||
|
||||
func (ol *olLogWrap) ClearLocks(ctx context.Context,
|
||||
lockInfos []minio.VolumeLockInfo) error {
|
||||
return ol.log(ol.ol.ClearLocks(ctx, lockInfos))
|
||||
}
|
||||
|
||||
func (ol *olLogWrap) SetBucketPolicy(ctx context.Context, n string,
|
||||
p *policy.Policy) error {
|
||||
return ol.log(ol.ol.SetBucketPolicy(ctx, n, p))
|
||||
}
|
||||
|
||||
func (ol *olLogWrap) GetBucketPolicy(ctx context.Context, n string) (
|
||||
*policy.Policy, error) {
|
||||
p, err := ol.ol.GetBucketPolicy(ctx, n)
|
||||
return p, ol.log(err)
|
||||
}
|
||||
|
||||
func (ol *olLogWrap) DeleteBucketPolicy(ctx context.Context, n string) error {
|
||||
return ol.log(ol.ol.DeleteBucketPolicy(ctx, n))
|
||||
}
|
||||
|
||||
func (ol *olLogWrap) IsNotificationSupported() bool {
|
||||
return ol.ol.IsNotificationSupported()
|
||||
}
|
||||
|
||||
func (ol *olLogWrap) IsEncryptionSupported() bool {
|
||||
return ol.ol.IsEncryptionSupported()
|
||||
}
|
||||
@ -1,460 +0,0 @@
|
||||
// Copyright (C) 2018 Storj Labs, Inc.
|
||||
// See LICENSE for copying information.
|
||||
|
||||
// Code generated by MockGen. DO NOT EDIT.
|
||||
// Source: github.com/minio/minio/cmd (interfaces: ObjectLayer)
|
||||
|
||||
// Package logging is a generated GoMock package.
|
||||
package logging
|
||||
|
||||
import (
|
||||
context "context"
|
||||
io "io"
|
||||
reflect "reflect"
|
||||
time "time"
|
||||
|
||||
gomock "github.com/golang/mock/gomock"
|
||||
cmd "github.com/minio/minio/cmd"
|
||||
hash "github.com/minio/minio/pkg/hash"
|
||||
madmin "github.com/minio/minio/pkg/madmin"
|
||||
policy "github.com/minio/minio/pkg/policy"
|
||||
)
|
||||
|
||||
// MockObjectLayer is a mock of ObjectLayer interface
|
||||
type MockObjectLayer struct {
|
||||
ctrl *gomock.Controller
|
||||
recorder *MockObjectLayerMockRecorder
|
||||
}
|
||||
|
||||
// MockObjectLayerMockRecorder is the mock recorder for MockObjectLayer
|
||||
type MockObjectLayerMockRecorder struct {
|
||||
mock *MockObjectLayer
|
||||
}
|
||||
|
||||
// NewMockObjectLayer creates a new mock instance
|
||||
func NewMockObjectLayer(ctrl *gomock.Controller) *MockObjectLayer {
|
||||
mock := &MockObjectLayer{ctrl: ctrl}
|
||||
mock.recorder = &MockObjectLayerMockRecorder{mock}
|
||||
return mock
|
||||
}
|
||||
|
||||
// EXPECT returns an object that allows the caller to indicate expected use
|
||||
func (m *MockObjectLayer) EXPECT() *MockObjectLayerMockRecorder {
|
||||
return m.recorder
|
||||
}
|
||||
|
||||
// AbortMultipartUpload mocks base method
|
||||
func (m *MockObjectLayer) AbortMultipartUpload(arg0 context.Context, arg1, arg2, arg3 string) error {
|
||||
ret := m.ctrl.Call(m, "AbortMultipartUpload", arg0, arg1, arg2, arg3)
|
||||
ret0, _ := ret[0].(error)
|
||||
return ret0
|
||||
}
|
||||
|
||||
// AbortMultipartUpload indicates an expected call of AbortMultipartUpload
|
||||
func (mr *MockObjectLayerMockRecorder) AbortMultipartUpload(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
|
||||
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AbortMultipartUpload", reflect.TypeOf((*MockObjectLayer)(nil).AbortMultipartUpload), arg0, arg1, arg2, arg3)
|
||||
}
|
||||
|
||||
// ClearLocks mocks base method
|
||||
func (m *MockObjectLayer) ClearLocks(arg0 context.Context, arg1 []cmd.VolumeLockInfo) error {
|
||||
ret := m.ctrl.Call(m, "ClearLocks", arg0, arg1)
|
||||
ret0, _ := ret[0].(error)
|
||||
return ret0
|
||||
}
|
||||
|
||||
// ClearLocks indicates an expected call of ClearLocks
|
||||
func (mr *MockObjectLayerMockRecorder) ClearLocks(arg0, arg1 interface{}) *gomock.Call {
|
||||
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClearLocks", reflect.TypeOf((*MockObjectLayer)(nil).ClearLocks), arg0, arg1)
|
||||
}
|
||||
|
||||
// CompleteMultipartUpload mocks base method
|
||||
func (m *MockObjectLayer) CompleteMultipartUpload(arg0 context.Context, arg1, arg2, arg3 string, arg4 []cmd.CompletePart) (cmd.ObjectInfo, error) {
|
||||
ret := m.ctrl.Call(m, "CompleteMultipartUpload", arg0, arg1, arg2, arg3, arg4)
|
||||
ret0, _ := ret[0].(cmd.ObjectInfo)
|
||||
ret1, _ := ret[1].(error)
|
||||
return ret0, ret1
|
||||
}
|
||||
|
||||
// CompleteMultipartUpload indicates an expected call of CompleteMultipartUpload
|
||||
func (mr *MockObjectLayerMockRecorder) CompleteMultipartUpload(arg0, arg1, arg2, arg3, arg4 interface{}) *gomock.Call {
|
||||
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CompleteMultipartUpload", reflect.TypeOf((*MockObjectLayer)(nil).CompleteMultipartUpload), arg0, arg1, arg2, arg3, arg4)
|
||||
}
|
||||
|
||||
// CopyObject mocks base method
|
||||
func (m *MockObjectLayer) CopyObject(arg0 context.Context, arg1, arg2, arg3, arg4 string, arg5 cmd.ObjectInfo) (cmd.ObjectInfo, error) {
|
||||
ret := m.ctrl.Call(m, "CopyObject", arg0, arg1, arg2, arg3, arg4, arg5)
|
||||
ret0, _ := ret[0].(cmd.ObjectInfo)
|
||||
ret1, _ := ret[1].(error)
|
||||
return ret0, ret1
|
||||
}
|
||||
|
||||
// CopyObject indicates an expected call of CopyObject
|
||||
func (mr *MockObjectLayerMockRecorder) CopyObject(arg0, arg1, arg2, arg3, arg4, arg5 interface{}) *gomock.Call {
|
||||
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CopyObject", reflect.TypeOf((*MockObjectLayer)(nil).CopyObject), arg0, arg1, arg2, arg3, arg4, arg5)
|
||||
}
|
||||
|
||||
// CopyObjectPart mocks base method
|
||||
func (m *MockObjectLayer) CopyObjectPart(arg0 context.Context, arg1, arg2, arg3, arg4, arg5 string, arg6 int, arg7, arg8 int64, arg9 cmd.ObjectInfo) (cmd.PartInfo, error) {
|
||||
ret := m.ctrl.Call(m, "CopyObjectPart", arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9)
|
||||
ret0, _ := ret[0].(cmd.PartInfo)
|
||||
ret1, _ := ret[1].(error)
|
||||
return ret0, ret1
|
||||
}
|
||||
|
||||
// CopyObjectPart indicates an expected call of CopyObjectPart
|
||||
func (mr *MockObjectLayerMockRecorder) CopyObjectPart(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9 interface{}) *gomock.Call {
|
||||
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CopyObjectPart", reflect.TypeOf((*MockObjectLayer)(nil).CopyObjectPart), arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9)
|
||||
}
|
||||
|
||||
// DeleteBucket mocks base method
|
||||
func (m *MockObjectLayer) DeleteBucket(arg0 context.Context, arg1 string) error {
|
||||
ret := m.ctrl.Call(m, "DeleteBucket", arg0, arg1)
|
||||
ret0, _ := ret[0].(error)
|
||||
return ret0
|
||||
}
|
||||
|
||||
// DeleteBucket indicates an expected call of DeleteBucket
|
||||
func (mr *MockObjectLayerMockRecorder) DeleteBucket(arg0, arg1 interface{}) *gomock.Call {
|
||||
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteBucket", reflect.TypeOf((*MockObjectLayer)(nil).DeleteBucket), arg0, arg1)
|
||||
}
|
||||
|
||||
// DeleteBucketPolicy mocks base method
|
||||
func (m *MockObjectLayer) DeleteBucketPolicy(arg0 context.Context, arg1 string) error {
|
||||
ret := m.ctrl.Call(m, "DeleteBucketPolicy", arg0, arg1)
|
||||
ret0, _ := ret[0].(error)
|
||||
return ret0
|
||||
}
|
||||
|
||||
// DeleteBucketPolicy indicates an expected call of DeleteBucketPolicy
|
||||
func (mr *MockObjectLayerMockRecorder) DeleteBucketPolicy(arg0, arg1 interface{}) *gomock.Call {
|
||||
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteBucketPolicy", reflect.TypeOf((*MockObjectLayer)(nil).DeleteBucketPolicy), arg0, arg1)
|
||||
}
|
||||
|
||||
// DeleteObject mocks base method
|
||||
func (m *MockObjectLayer) DeleteObject(arg0 context.Context, arg1, arg2 string) error {
|
||||
ret := m.ctrl.Call(m, "DeleteObject", arg0, arg1, arg2)
|
||||
ret0, _ := ret[0].(error)
|
||||
return ret0
|
||||
}
|
||||
|
||||
// DeleteObject indicates an expected call of DeleteObject
|
||||
func (mr *MockObjectLayerMockRecorder) DeleteObject(arg0, arg1, arg2 interface{}) *gomock.Call {
|
||||
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteObject", reflect.TypeOf((*MockObjectLayer)(nil).DeleteObject), arg0, arg1, arg2)
|
||||
}
|
||||
|
||||
// GetBucketInfo mocks base method
|
||||
func (m *MockObjectLayer) GetBucketInfo(arg0 context.Context, arg1 string) (cmd.BucketInfo, error) {
|
||||
ret := m.ctrl.Call(m, "GetBucketInfo", arg0, arg1)
|
||||
ret0, _ := ret[0].(cmd.BucketInfo)
|
||||
ret1, _ := ret[1].(error)
|
||||
return ret0, ret1
|
||||
}
|
||||
|
||||
// GetBucketInfo indicates an expected call of GetBucketInfo
|
||||
func (mr *MockObjectLayerMockRecorder) GetBucketInfo(arg0, arg1 interface{}) *gomock.Call {
|
||||
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBucketInfo", reflect.TypeOf((*MockObjectLayer)(nil).GetBucketInfo), arg0, arg1)
|
||||
}
|
||||
|
||||
// GetBucketPolicy mocks base method
|
||||
func (m *MockObjectLayer) GetBucketPolicy(arg0 context.Context, arg1 string) (*policy.Policy, error) {
|
||||
ret := m.ctrl.Call(m, "GetBucketPolicy", arg0, arg1)
|
||||
ret0, _ := ret[0].(*policy.Policy)
|
||||
ret1, _ := ret[1].(error)
|
||||
return ret0, ret1
|
||||
}
|
||||
|
||||
// GetBucketPolicy indicates an expected call of GetBucketPolicy
|
||||
func (mr *MockObjectLayerMockRecorder) GetBucketPolicy(arg0, arg1 interface{}) *gomock.Call {
|
||||
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBucketPolicy", reflect.TypeOf((*MockObjectLayer)(nil).GetBucketPolicy), arg0, arg1)
|
||||
}
|
||||
|
||||
// GetObject mocks base method
|
||||
func (m *MockObjectLayer) GetObject(arg0 context.Context, arg1, arg2 string, arg3, arg4 int64, arg5 io.Writer, arg6 string) error {
|
||||
ret := m.ctrl.Call(m, "GetObject", arg0, arg1, arg2, arg3, arg4, arg5, arg6)
|
||||
ret0, _ := ret[0].(error)
|
||||
return ret0
|
||||
}
|
||||
|
||||
// GetObject indicates an expected call of GetObject
|
||||
func (mr *MockObjectLayerMockRecorder) GetObject(arg0, arg1, arg2, arg3, arg4, arg5, arg6 interface{}) *gomock.Call {
|
||||
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetObject", reflect.TypeOf((*MockObjectLayer)(nil).GetObject), arg0, arg1, arg2, arg3, arg4, arg5, arg6)
|
||||
}
|
||||
|
||||
// GetObjectInfo mocks base method
|
||||
func (m *MockObjectLayer) GetObjectInfo(arg0 context.Context, arg1, arg2 string) (cmd.ObjectInfo, error) {
|
||||
ret := m.ctrl.Call(m, "GetObjectInfo", arg0, arg1, arg2)
|
||||
ret0, _ := ret[0].(cmd.ObjectInfo)
|
||||
ret1, _ := ret[1].(error)
|
||||
return ret0, ret1
|
||||
}
|
||||
|
||||
// GetObjectInfo indicates an expected call of GetObjectInfo
|
||||
func (mr *MockObjectLayerMockRecorder) GetObjectInfo(arg0, arg1, arg2 interface{}) *gomock.Call {
|
||||
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetObjectInfo", reflect.TypeOf((*MockObjectLayer)(nil).GetObjectInfo), arg0, arg1, arg2)
|
||||
}
|
||||
|
||||
// HealBucket mocks base method
|
||||
func (m *MockObjectLayer) HealBucket(arg0 context.Context, arg1 string, arg2 bool) ([]madmin.HealResultItem, error) {
|
||||
ret := m.ctrl.Call(m, "HealBucket", arg0, arg1, arg2)
|
||||
ret0, _ := ret[0].([]madmin.HealResultItem)
|
||||
ret1, _ := ret[1].(error)
|
||||
return ret0, ret1
|
||||
}
|
||||
|
||||
// HealBucket indicates an expected call of HealBucket
|
||||
func (mr *MockObjectLayerMockRecorder) HealBucket(arg0, arg1, arg2 interface{}) *gomock.Call {
|
||||
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HealBucket", reflect.TypeOf((*MockObjectLayer)(nil).HealBucket), arg0, arg1, arg2)
|
||||
}
|
||||
|
||||
// HealFormat mocks base method
|
||||
func (m *MockObjectLayer) HealFormat(arg0 context.Context, arg1 bool) (madmin.HealResultItem, error) {
|
||||
ret := m.ctrl.Call(m, "HealFormat", arg0, arg1)
|
||||
ret0, _ := ret[0].(madmin.HealResultItem)
|
||||
ret1, _ := ret[1].(error)
|
||||
return ret0, ret1
|
||||
}
|
||||
|
||||
// HealFormat indicates an expected call of HealFormat
|
||||
func (mr *MockObjectLayerMockRecorder) HealFormat(arg0, arg1 interface{}) *gomock.Call {
|
||||
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HealFormat", reflect.TypeOf((*MockObjectLayer)(nil).HealFormat), arg0, arg1)
|
||||
}
|
||||
|
||||
// HealObject mocks base method
|
||||
func (m *MockObjectLayer) HealObject(arg0 context.Context, arg1, arg2 string, arg3 bool) (madmin.HealResultItem, error) {
|
||||
ret := m.ctrl.Call(m, "HealObject", arg0, arg1, arg2, arg3)
|
||||
ret0, _ := ret[0].(madmin.HealResultItem)
|
||||
ret1, _ := ret[1].(error)
|
||||
return ret0, ret1
|
||||
}
|
||||
|
||||
// HealObject indicates an expected call of HealObject
|
||||
func (mr *MockObjectLayerMockRecorder) HealObject(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
|
||||
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HealObject", reflect.TypeOf((*MockObjectLayer)(nil).HealObject), arg0, arg1, arg2, arg3)
|
||||
}
|
||||
|
||||
// IsEncryptionSupported mocks base method
|
||||
func (m *MockObjectLayer) IsEncryptionSupported() bool {
|
||||
ret := m.ctrl.Call(m, "IsEncryptionSupported")
|
||||
ret0, _ := ret[0].(bool)
|
||||
return ret0
|
||||
}
|
||||
|
||||
// IsEncryptionSupported indicates an expected call of IsEncryptionSupported
|
||||
func (mr *MockObjectLayerMockRecorder) IsEncryptionSupported() *gomock.Call {
|
||||
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsEncryptionSupported", reflect.TypeOf((*MockObjectLayer)(nil).IsEncryptionSupported))
|
||||
}
|
||||
|
||||
// IsNotificationSupported mocks base method
|
||||
func (m *MockObjectLayer) IsNotificationSupported() bool {
|
||||
ret := m.ctrl.Call(m, "IsNotificationSupported")
|
||||
ret0, _ := ret[0].(bool)
|
||||
return ret0
|
||||
}
|
||||
|
||||
// IsNotificationSupported indicates an expected call of IsNotificationSupported
|
||||
func (mr *MockObjectLayerMockRecorder) IsNotificationSupported() *gomock.Call {
|
||||
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsNotificationSupported", reflect.TypeOf((*MockObjectLayer)(nil).IsNotificationSupported))
|
||||
}
|
||||
|
||||
// ListBuckets mocks base method
|
||||
func (m *MockObjectLayer) ListBuckets(arg0 context.Context) ([]cmd.BucketInfo, error) {
|
||||
ret := m.ctrl.Call(m, "ListBuckets", arg0)
|
||||
ret0, _ := ret[0].([]cmd.BucketInfo)
|
||||
ret1, _ := ret[1].(error)
|
||||
return ret0, ret1
|
||||
}
|
||||
|
||||
// ListBuckets indicates an expected call of ListBuckets
|
||||
func (mr *MockObjectLayerMockRecorder) ListBuckets(arg0 interface{}) *gomock.Call {
|
||||
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListBuckets", reflect.TypeOf((*MockObjectLayer)(nil).ListBuckets), arg0)
|
||||
}
|
||||
|
||||
// ListBucketsHeal mocks base method
|
||||
func (m *MockObjectLayer) ListBucketsHeal(arg0 context.Context) ([]cmd.BucketInfo, error) {
|
||||
ret := m.ctrl.Call(m, "ListBucketsHeal", arg0)
|
||||
ret0, _ := ret[0].([]cmd.BucketInfo)
|
||||
ret1, _ := ret[1].(error)
|
||||
return ret0, ret1
|
||||
}
|
||||
|
||||
// ListBucketsHeal indicates an expected call of ListBucketsHeal
|
||||
func (mr *MockObjectLayerMockRecorder) ListBucketsHeal(arg0 interface{}) *gomock.Call {
|
||||
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListBucketsHeal", reflect.TypeOf((*MockObjectLayer)(nil).ListBucketsHeal), arg0)
|
||||
}
|
||||
|
||||
// ListLocks mocks base method
|
||||
func (m *MockObjectLayer) ListLocks(arg0 context.Context, arg1, arg2 string, arg3 time.Duration) ([]cmd.VolumeLockInfo, error) {
|
||||
ret := m.ctrl.Call(m, "ListLocks", arg0, arg1, arg2, arg3)
|
||||
ret0, _ := ret[0].([]cmd.VolumeLockInfo)
|
||||
ret1, _ := ret[1].(error)
|
||||
return ret0, ret1
|
||||
}
|
||||
|
||||
// ListLocks indicates an expected call of ListLocks
|
||||
func (mr *MockObjectLayerMockRecorder) ListLocks(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
|
||||
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListLocks", reflect.TypeOf((*MockObjectLayer)(nil).ListLocks), arg0, arg1, arg2, arg3)
|
||||
}
|
||||
|
||||
// ListMultipartUploads mocks base method
|
||||
func (m *MockObjectLayer) ListMultipartUploads(arg0 context.Context, arg1, arg2, arg3, arg4, arg5 string, arg6 int) (cmd.ListMultipartsInfo, error) {
|
||||
ret := m.ctrl.Call(m, "ListMultipartUploads", arg0, arg1, arg2, arg3, arg4, arg5, arg6)
|
||||
ret0, _ := ret[0].(cmd.ListMultipartsInfo)
|
||||
ret1, _ := ret[1].(error)
|
||||
return ret0, ret1
|
||||
}
|
||||
|
||||
// ListMultipartUploads indicates an expected call of ListMultipartUploads
|
||||
func (mr *MockObjectLayerMockRecorder) ListMultipartUploads(arg0, arg1, arg2, arg3, arg4, arg5, arg6 interface{}) *gomock.Call {
|
||||
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListMultipartUploads", reflect.TypeOf((*MockObjectLayer)(nil).ListMultipartUploads), arg0, arg1, arg2, arg3, arg4, arg5, arg6)
|
||||
}
|
||||
|
||||
// ListObjectParts mocks base method
|
||||
func (m *MockObjectLayer) ListObjectParts(arg0 context.Context, arg1, arg2, arg3 string, arg4, arg5 int) (cmd.ListPartsInfo, error) {
|
||||
ret := m.ctrl.Call(m, "ListObjectParts", arg0, arg1, arg2, arg3, arg4, arg5)
|
||||
ret0, _ := ret[0].(cmd.ListPartsInfo)
|
||||
ret1, _ := ret[1].(error)
|
||||
return ret0, ret1
|
||||
}
|
||||
|
||||
// ListObjectParts indicates an expected call of ListObjectParts
|
||||
func (mr *MockObjectLayerMockRecorder) ListObjectParts(arg0, arg1, arg2, arg3, arg4, arg5 interface{}) *gomock.Call {
|
||||
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListObjectParts", reflect.TypeOf((*MockObjectLayer)(nil).ListObjectParts), arg0, arg1, arg2, arg3, arg4, arg5)
|
||||
}
|
||||
|
||||
// ListObjects mocks base method
|
||||
func (m *MockObjectLayer) ListObjects(arg0 context.Context, arg1, arg2, arg3, arg4 string, arg5 int) (cmd.ListObjectsInfo, error) {
|
||||
ret := m.ctrl.Call(m, "ListObjects", arg0, arg1, arg2, arg3, arg4, arg5)
|
||||
ret0, _ := ret[0].(cmd.ListObjectsInfo)
|
||||
ret1, _ := ret[1].(error)
|
||||
return ret0, ret1
|
||||
}
|
||||
|
||||
// ListObjects indicates an expected call of ListObjects
|
||||
func (mr *MockObjectLayerMockRecorder) ListObjects(arg0, arg1, arg2, arg3, arg4, arg5 interface{}) *gomock.Call {
|
||||
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListObjects", reflect.TypeOf((*MockObjectLayer)(nil).ListObjects), arg0, arg1, arg2, arg3, arg4, arg5)
|
||||
}
|
||||
|
||||
// ListObjectsHeal mocks base method
|
||||
func (m *MockObjectLayer) ListObjectsHeal(arg0 context.Context, arg1, arg2, arg3, arg4 string, arg5 int) (cmd.ListObjectsInfo, error) {
|
||||
ret := m.ctrl.Call(m, "ListObjectsHeal", arg0, arg1, arg2, arg3, arg4, arg5)
|
||||
ret0, _ := ret[0].(cmd.ListObjectsInfo)
|
||||
ret1, _ := ret[1].(error)
|
||||
return ret0, ret1
|
||||
}
|
||||
|
||||
// ListObjectsHeal indicates an expected call of ListObjectsHeal
|
||||
func (mr *MockObjectLayerMockRecorder) ListObjectsHeal(arg0, arg1, arg2, arg3, arg4, arg5 interface{}) *gomock.Call {
|
||||
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListObjectsHeal", reflect.TypeOf((*MockObjectLayer)(nil).ListObjectsHeal), arg0, arg1, arg2, arg3, arg4, arg5)
|
||||
}
|
||||
|
||||
// ListObjectsV2 mocks base method
|
||||
func (m *MockObjectLayer) ListObjectsV2(arg0 context.Context, arg1, arg2, arg3, arg4 string, arg5 int, arg6 bool, arg7 string) (cmd.ListObjectsV2Info, error) {
|
||||
ret := m.ctrl.Call(m, "ListObjectsV2", arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7)
|
||||
ret0, _ := ret[0].(cmd.ListObjectsV2Info)
|
||||
ret1, _ := ret[1].(error)
|
||||
return ret0, ret1
|
||||
}
|
||||
|
||||
// ListObjectsV2 indicates an expected call of ListObjectsV2
|
||||
func (mr *MockObjectLayerMockRecorder) ListObjectsV2(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7 interface{}) *gomock.Call {
|
||||
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListObjectsV2", reflect.TypeOf((*MockObjectLayer)(nil).ListObjectsV2), arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7)
|
||||
}
|
||||
|
||||
// MakeBucketWithLocation mocks base method
|
||||
func (m *MockObjectLayer) MakeBucketWithLocation(arg0 context.Context, arg1, arg2 string) error {
|
||||
ret := m.ctrl.Call(m, "MakeBucketWithLocation", arg0, arg1, arg2)
|
||||
ret0, _ := ret[0].(error)
|
||||
return ret0
|
||||
}
|
||||
|
||||
// MakeBucketWithLocation indicates an expected call of MakeBucketWithLocation
|
||||
func (mr *MockObjectLayerMockRecorder) MakeBucketWithLocation(arg0, arg1, arg2 interface{}) *gomock.Call {
|
||||
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MakeBucketWithLocation", reflect.TypeOf((*MockObjectLayer)(nil).MakeBucketWithLocation), arg0, arg1, arg2)
|
||||
}
|
||||
|
||||
// NewMultipartUpload mocks base method
|
||||
func (m *MockObjectLayer) NewMultipartUpload(arg0 context.Context, arg1, arg2 string, arg3 map[string]string) (string, error) {
|
||||
ret := m.ctrl.Call(m, "NewMultipartUpload", arg0, arg1, arg2, arg3)
|
||||
ret0, _ := ret[0].(string)
|
||||
ret1, _ := ret[1].(error)
|
||||
return ret0, ret1
|
||||
}
|
||||
|
||||
// NewMultipartUpload indicates an expected call of NewMultipartUpload
|
||||
func (mr *MockObjectLayerMockRecorder) NewMultipartUpload(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
|
||||
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewMultipartUpload", reflect.TypeOf((*MockObjectLayer)(nil).NewMultipartUpload), arg0, arg1, arg2, arg3)
|
||||
}
|
||||
|
||||
// PutObject mocks base method
|
||||
func (m *MockObjectLayer) PutObject(arg0 context.Context, arg1, arg2 string, arg3 *hash.Reader, arg4 map[string]string) (cmd.ObjectInfo, error) {
|
||||
ret := m.ctrl.Call(m, "PutObject", arg0, arg1, arg2, arg3, arg4)
|
||||
ret0, _ := ret[0].(cmd.ObjectInfo)
|
||||
ret1, _ := ret[1].(error)
|
||||
return ret0, ret1
|
||||
}
|
||||
|
||||
// PutObject indicates an expected call of PutObject
|
||||
func (mr *MockObjectLayerMockRecorder) PutObject(arg0, arg1, arg2, arg3, arg4 interface{}) *gomock.Call {
|
||||
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutObject", reflect.TypeOf((*MockObjectLayer)(nil).PutObject), arg0, arg1, arg2, arg3, arg4)
|
||||
}
|
||||
|
||||
// PutObjectPart mocks base method
|
||||
func (m *MockObjectLayer) PutObjectPart(arg0 context.Context, arg1, arg2, arg3 string, arg4 int, arg5 *hash.Reader) (cmd.PartInfo, error) {
|
||||
ret := m.ctrl.Call(m, "PutObjectPart", arg0, arg1, arg2, arg3, arg4, arg5)
|
||||
ret0, _ := ret[0].(cmd.PartInfo)
|
||||
ret1, _ := ret[1].(error)
|
||||
return ret0, ret1
|
||||
}
|
||||
|
||||
// PutObjectPart indicates an expected call of PutObjectPart
|
||||
func (mr *MockObjectLayerMockRecorder) PutObjectPart(arg0, arg1, arg2, arg3, arg4, arg5 interface{}) *gomock.Call {
|
||||
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutObjectPart", reflect.TypeOf((*MockObjectLayer)(nil).PutObjectPart), arg0, arg1, arg2, arg3, arg4, arg5)
|
||||
}
|
||||
|
||||
// ReloadFormat mocks base method
|
||||
func (m *MockObjectLayer) ReloadFormat(arg0 context.Context, arg1 bool) error {
|
||||
ret := m.ctrl.Call(m, "ReloadFormat", arg0, arg1)
|
||||
ret0, _ := ret[0].(error)
|
||||
return ret0
|
||||
}
|
||||
|
||||
// ReloadFormat indicates an expected call of ReloadFormat
|
||||
func (mr *MockObjectLayerMockRecorder) ReloadFormat(arg0, arg1 interface{}) *gomock.Call {
|
||||
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReloadFormat", reflect.TypeOf((*MockObjectLayer)(nil).ReloadFormat), arg0, arg1)
|
||||
}
|
||||
|
||||
// SetBucketPolicy mocks base method
|
||||
func (m *MockObjectLayer) SetBucketPolicy(arg0 context.Context, arg1 string, arg2 *policy.Policy) error {
|
||||
ret := m.ctrl.Call(m, "SetBucketPolicy", arg0, arg1, arg2)
|
||||
ret0, _ := ret[0].(error)
|
||||
return ret0
|
||||
}
|
||||
|
||||
// SetBucketPolicy indicates an expected call of SetBucketPolicy
|
||||
func (mr *MockObjectLayerMockRecorder) SetBucketPolicy(arg0, arg1, arg2 interface{}) *gomock.Call {
|
||||
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetBucketPolicy", reflect.TypeOf((*MockObjectLayer)(nil).SetBucketPolicy), arg0, arg1, arg2)
|
||||
}
|
||||
|
||||
// Shutdown mocks base method
|
||||
func (m *MockObjectLayer) Shutdown(arg0 context.Context) error {
|
||||
ret := m.ctrl.Call(m, "Shutdown", arg0)
|
||||
ret0, _ := ret[0].(error)
|
||||
return ret0
|
||||
}
|
||||
|
||||
// Shutdown indicates an expected call of Shutdown
|
||||
func (mr *MockObjectLayerMockRecorder) Shutdown(arg0 interface{}) *gomock.Call {
|
||||
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Shutdown", reflect.TypeOf((*MockObjectLayer)(nil).Shutdown), arg0)
|
||||
}
|
||||
|
||||
// StorageInfo mocks base method
|
||||
func (m *MockObjectLayer) StorageInfo(arg0 context.Context) cmd.StorageInfo {
|
||||
ret := m.ctrl.Call(m, "StorageInfo", arg0)
|
||||
ret0, _ := ret[0].(cmd.StorageInfo)
|
||||
return ret0
|
||||
}
|
||||
|
||||
// StorageInfo indicates an expected call of StorageInfo
|
||||
func (mr *MockObjectLayerMockRecorder) StorageInfo(arg0 interface{}) *gomock.Call {
|
||||
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StorageInfo", reflect.TypeOf((*MockObjectLayer)(nil).StorageInfo), arg0)
|
||||
}
|
||||
@ -1,110 +0,0 @@
|
||||
// Copyright (C) 2018 Storj Labs, Inc.
|
||||
// See LICENSE for copying information.
|
||||
|
||||
// Code generated by MockGen. DO NOT EDIT.
|
||||
// Source: storj.io/storj/pkg/storage/objects (interfaces: Store)
|
||||
|
||||
// Package miniogw is a generated GoMock package.
|
||||
package miniogw
|
||||
|
||||
import (
|
||||
context "context"
|
||||
io "io"
|
||||
reflect "reflect"
|
||||
time "time"
|
||||
|
||||
gomock "github.com/golang/mock/gomock"
|
||||
|
||||
"storj.io/storj/pkg/pb"
|
||||
ranger "storj.io/storj/pkg/ranger"
|
||||
objects "storj.io/storj/pkg/storage/objects"
|
||||
)
|
||||
|
||||
// MockStore is a mock of Store interface
|
||||
type MockStore struct {
|
||||
ctrl *gomock.Controller
|
||||
recorder *MockStoreMockRecorder
|
||||
}
|
||||
|
||||
// MockStoreMockRecorder is the mock recorder for MockStore
|
||||
type MockStoreMockRecorder struct {
|
||||
mock *MockStore
|
||||
}
|
||||
|
||||
// NewMockStore creates a new mock instance
|
||||
func NewMockStore(ctrl *gomock.Controller) *MockStore {
|
||||
mock := &MockStore{ctrl: ctrl}
|
||||
mock.recorder = &MockStoreMockRecorder{mock}
|
||||
return mock
|
||||
}
|
||||
|
||||
// EXPECT returns an object that allows the caller to indicate expected use
|
||||
func (m *MockStore) EXPECT() *MockStoreMockRecorder {
|
||||
return m.recorder
|
||||
}
|
||||
|
||||
// Delete mocks base method
|
||||
func (m *MockStore) Delete(arg0 context.Context, arg1 string) error {
|
||||
ret := m.ctrl.Call(m, "Delete", arg0, arg1)
|
||||
ret0, _ := ret[0].(error)
|
||||
return ret0
|
||||
}
|
||||
|
||||
// Delete indicates an expected call of Delete
|
||||
func (mr *MockStoreMockRecorder) Delete(arg0, arg1 interface{}) *gomock.Call {
|
||||
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockStore)(nil).Delete), arg0, arg1)
|
||||
}
|
||||
|
||||
// Get mocks base method
|
||||
func (m *MockStore) Get(arg0 context.Context, arg1 string) (ranger.Ranger, objects.Meta, error) {
|
||||
ret := m.ctrl.Call(m, "Get", arg0, arg1)
|
||||
ret0, _ := ret[0].(ranger.Ranger)
|
||||
ret1, _ := ret[1].(objects.Meta)
|
||||
ret2, _ := ret[2].(error)
|
||||
return ret0, ret1, ret2
|
||||
}
|
||||
|
||||
// Get indicates an expected call of Get
|
||||
func (mr *MockStoreMockRecorder) Get(arg0, arg1 interface{}) *gomock.Call {
|
||||
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockStore)(nil).Get), arg0, arg1)
|
||||
}
|
||||
|
||||
// List mocks base method
|
||||
func (m *MockStore) List(arg0 context.Context, arg1, arg2, arg3 string, arg4 bool, arg5 int, arg6 uint32) ([]objects.ListItem, bool, error) {
|
||||
ret := m.ctrl.Call(m, "List", arg0, arg1, arg2, arg3, arg4, arg5, arg6)
|
||||
ret0, _ := ret[0].([]objects.ListItem)
|
||||
ret1, _ := ret[1].(bool)
|
||||
ret2, _ := ret[2].(error)
|
||||
return ret0, ret1, ret2
|
||||
}
|
||||
|
||||
// List indicates an expected call of List
|
||||
func (mr *MockStoreMockRecorder) List(arg0, arg1, arg2, arg3, arg4, arg5, arg6 interface{}) *gomock.Call {
|
||||
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "List", reflect.TypeOf((*MockStore)(nil).List), arg0, arg1, arg2, arg3, arg4, arg5, arg6)
|
||||
}
|
||||
|
||||
// Meta mocks base method
|
||||
func (m *MockStore) Meta(arg0 context.Context, arg1 string) (objects.Meta, error) {
|
||||
ret := m.ctrl.Call(m, "Meta", arg0, arg1)
|
||||
ret0, _ := ret[0].(objects.Meta)
|
||||
ret1, _ := ret[1].(error)
|
||||
return ret0, ret1
|
||||
}
|
||||
|
||||
// Meta indicates an expected call of Meta
|
||||
func (mr *MockStoreMockRecorder) Meta(arg0, arg1 interface{}) *gomock.Call {
|
||||
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Meta", reflect.TypeOf((*MockStore)(nil).Meta), arg0, arg1)
|
||||
}
|
||||
|
||||
// Put mocks base method
|
||||
func (m *MockStore) Put(arg0 context.Context, arg1 string, arg2 io.Reader, arg3 pb.SerializableMeta, arg4 time.Time) (objects.Meta, error) {
|
||||
ret := m.ctrl.Call(m, "Put", arg0, arg1, arg2, arg3, arg4)
|
||||
ret0, _ := ret[0].(objects.Meta)
|
||||
ret1, _ := ret[1].(error)
|
||||
return ret0, ret1
|
||||
}
|
||||
|
||||
// Put indicates an expected call of Put
|
||||
func (mr *MockStoreMockRecorder) Put(arg0, arg1, arg2, arg3, arg4 interface{}) *gomock.Call {
|
||||
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Put", reflect.TypeOf((*MockStore)(nil).Put), arg0, arg1, arg2, arg3, arg4)
|
||||
}
|
||||
Loading…
Reference in New Issue
Block a user