d396eb6be9
* fixed downloading empty file * fixed formatting * fixed error handling * fixed cache_test.go to accomodate for error * fixed error verbose messaging for wrong downlaods * clean up
258 lines
8.0 KiB
Go
258 lines
8.0 KiB
Go
// Copyright (C) 2018 Storj Labs, Inc.
|
|
// See LICENSE for copying information.
|
|
|
|
package logging
|
|
|
|
import (
|
|
context "context"
|
|
io "io"
|
|
"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"
|
|
)
|
|
|
|
var errTemplate = "gateway error: %+v"
|
|
|
|
type gwLogWrap struct {
|
|
gw minio.Gateway
|
|
}
|
|
|
|
// Gateway is a wrapper of minio.Gateway that logs errors before
|
|
// returning them.
|
|
func Gateway(gw minio.Gateway) minio.Gateway {
|
|
return &gwLogWrap{gw: gw}
|
|
}
|
|
|
|
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: zap.S()}, err
|
|
}
|
|
|
|
type olLogWrap struct {
|
|
ol minio.ObjectLayer
|
|
logger ErrorLogger
|
|
}
|
|
|
|
// ErrorLogger logs a templated error message
|
|
type ErrorLogger interface {
|
|
Errorf(template string, args ...interface{})
|
|
}
|
|
|
|
func (ol *olLogWrap) wrap(err error) error {
|
|
if err != nil {
|
|
ol.logger.Errorf(errTemplate, err)
|
|
}
|
|
return err
|
|
}
|
|
|
|
func (ol *olLogWrap) Shutdown(ctx context.Context) error {
|
|
return ol.wrap(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.wrap(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.wrap(err)
|
|
}
|
|
|
|
func (ol *olLogWrap) ListBuckets(ctx context.Context) (
|
|
buckets []minio.BucketInfo, err error) {
|
|
buckets, err = ol.ol.ListBuckets(ctx)
|
|
return buckets, ol.wrap(err)
|
|
}
|
|
|
|
func (ol *olLogWrap) DeleteBucket(ctx context.Context, bucket string) error {
|
|
return ol.wrap(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.wrap(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.wrap(err)
|
|
}
|
|
|
|
func (ol *olLogWrap) GetObject(ctx context.Context, bucket, object string,
|
|
startOffset int64, length int64, writer io.Writer, etag string) (err error) {
|
|
return ol.wrap(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)
|
|
if _, ok := err.(minio.ObjectNotFound); ok {
|
|
return objInfo, err
|
|
}
|
|
return objInfo, ol.wrap(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.wrap(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.wrap(err)
|
|
}
|
|
|
|
func (ol *olLogWrap) DeleteObject(ctx context.Context, bucket, object string) (
|
|
err error) {
|
|
return ol.wrap(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.wrap(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.wrap(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.wrap(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.wrap(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.wrap(err)
|
|
}
|
|
|
|
func (ol *olLogWrap) AbortMultipartUpload(ctx context.Context,
|
|
bucket, object, uploadID string) error {
|
|
return ol.wrap(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.wrap(err)
|
|
}
|
|
|
|
func (ol *olLogWrap) ReloadFormat(ctx context.Context, dryRun bool) error {
|
|
return ol.wrap(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.wrap(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.wrap(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.wrap(err)
|
|
}
|
|
|
|
func (ol *olLogWrap) ListBucketsHeal(ctx context.Context) (
|
|
buckets []minio.BucketInfo, err error) {
|
|
buckets, err = ol.ol.ListBucketsHeal(ctx)
|
|
return buckets, ol.wrap(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.wrap(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.wrap(err)
|
|
}
|
|
|
|
func (ol *olLogWrap) ClearLocks(ctx context.Context,
|
|
lockInfos []minio.VolumeLockInfo) error {
|
|
return ol.wrap(ol.ol.ClearLocks(ctx, lockInfos))
|
|
}
|
|
|
|
func (ol *olLogWrap) SetBucketPolicy(ctx context.Context, n string,
|
|
p *policy.Policy) error {
|
|
return ol.wrap(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.wrap(err)
|
|
}
|
|
|
|
func (ol *olLogWrap) DeleteBucketPolicy(ctx context.Context, n string) error {
|
|
return ol.wrap(ol.ol.DeleteBucketPolicy(ctx, n))
|
|
}
|
|
|
|
func (ol *olLogWrap) IsNotificationSupported() bool {
|
|
return ol.ol.IsNotificationSupported()
|
|
}
|
|
|
|
func (ol *olLogWrap) IsEncryptionSupported() bool {
|
|
return ol.ol.IsEncryptionSupported()
|
|
}
|