2016-07-24 07:51:12 +02:00
|
|
|
/*
|
2019-04-09 20:39:42 +02:00
|
|
|
* MinIO Cloud Storage, (C) 2016, 2017, 2018 MinIO, Inc.
|
2016-07-24 07:51:12 +02:00
|
|
|
*
|
|
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
|
|
* you may not use this file except in compliance with the License.
|
|
|
|
* You may obtain a copy of the License at
|
|
|
|
*
|
|
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
|
|
*
|
|
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
|
|
* See the License for the specific language governing permissions and
|
|
|
|
* limitations under the License.
|
|
|
|
*/
|
|
|
|
|
2016-08-19 01:23:42 +02:00
|
|
|
package cmd
|
2016-07-24 07:51:12 +02:00
|
|
|
|
|
|
|
import (
|
2019-12-12 19:01:23 +01:00
|
|
|
"encoding/json"
|
2016-07-24 07:51:12 +02:00
|
|
|
"encoding/xml"
|
2018-03-15 21:03:41 +01:00
|
|
|
"errors"
|
2016-07-24 07:51:12 +02:00
|
|
|
"io"
|
|
|
|
"net/http"
|
2019-12-12 19:01:23 +01:00
|
|
|
"net/url"
|
2019-07-30 10:49:06 +02:00
|
|
|
"path"
|
2019-12-13 21:36:45 +01:00
|
|
|
"reflect"
|
2019-12-12 19:01:23 +01:00
|
|
|
"time"
|
2016-07-24 07:51:12 +02:00
|
|
|
|
|
|
|
"github.com/gorilla/mux"
|
2019-07-11 22:19:25 +02:00
|
|
|
xhttp "github.com/minio/minio/cmd/http"
|
2018-04-06 00:04:40 +02:00
|
|
|
"github.com/minio/minio/cmd/logger"
|
2020-01-27 23:12:34 +01:00
|
|
|
"github.com/minio/minio/pkg/bucket/policy"
|
2018-03-15 21:03:41 +01:00
|
|
|
"github.com/minio/minio/pkg/event"
|
2016-07-24 07:51:12 +02:00
|
|
|
)
|
|
|
|
|
|
|
|
const (
|
|
|
|
bucketConfigPrefix = "buckets"
|
|
|
|
bucketNotificationConfig = "notification.xml"
|
|
|
|
)
|
|
|
|
|
2018-03-15 21:03:41 +01:00
|
|
|
var errNoSuchNotifications = errors.New("The specified bucket does not have bucket notifications")
|
|
|
|
|
|
|
|
// GetBucketNotificationHandler - This HTTP handler returns event notification configuration
|
|
|
|
// as per http://docs.aws.amazon.com/AmazonS3/latest/dev/NotificationHowTo.html.
|
|
|
|
// It returns empty configuration if its not set.
|
2016-07-24 07:51:12 +02:00
|
|
|
func (api objectAPIHandlers) GetBucketNotificationHandler(w http.ResponseWriter, r *http.Request) {
|
2018-07-21 03:46:32 +02:00
|
|
|
ctx := newContext(r, w, "GetBucketNotification")
|
2018-02-10 00:19:30 +01:00
|
|
|
|
2018-11-22 05:03:24 +01:00
|
|
|
defer logger.AuditLog(w, r, "GetBucketNotification", mustGetClaimsFromToken(r))
|
2018-10-12 21:25:59 +02:00
|
|
|
|
2018-04-25 00:53:30 +02:00
|
|
|
vars := mux.Vars(r)
|
|
|
|
bucketName := vars["bucket"]
|
|
|
|
|
2016-08-11 03:47:49 +02:00
|
|
|
objAPI := api.ObjectAPI()
|
|
|
|
if objAPI == nil {
|
2019-02-14 01:07:21 +01:00
|
|
|
writeErrorResponse(ctx, w, errorCodes.ToAPIErr(ErrServerNotInitialized), r.URL, guessIsBrowserReq(r))
|
2016-08-11 03:47:49 +02:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2018-02-10 00:19:30 +01:00
|
|
|
if !objAPI.IsNotificationSupported() {
|
2019-02-14 01:07:21 +01:00
|
|
|
writeErrorResponse(ctx, w, errorCodes.ToAPIErr(ErrNotImplemented), r.URL, guessIsBrowserReq(r))
|
2018-02-10 00:19:30 +01:00
|
|
|
return
|
|
|
|
}
|
2018-04-25 00:53:30 +02:00
|
|
|
|
|
|
|
if s3Error := checkRequestAuthType(ctx, r, policy.GetBucketNotificationAction, bucketName, ""); s3Error != ErrNone {
|
2019-02-14 01:07:21 +01:00
|
|
|
writeErrorResponse(ctx, w, errorCodes.ToAPIErr(s3Error), r.URL, guessIsBrowserReq(r))
|
2016-07-24 07:51:12 +02:00
|
|
|
return
|
|
|
|
}
|
2016-11-21 22:51:05 +01:00
|
|
|
|
2018-03-14 20:01:47 +01:00
|
|
|
_, err := objAPI.GetBucketInfo(ctx, bucketName)
|
2016-11-15 00:45:00 +01:00
|
|
|
if err != nil {
|
2019-02-14 01:07:21 +01:00
|
|
|
writeErrorResponse(ctx, w, toAPIError(ctx, err), r.URL, guessIsBrowserReq(r))
|
2016-11-15 00:45:00 +01:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2019-07-30 10:49:06 +02:00
|
|
|
// Construct path to notification.xml for the given bucket.
|
|
|
|
configFile := path.Join(bucketConfigPrefix, bucketName, bucketNotificationConfig)
|
|
|
|
|
2019-12-13 21:36:45 +01:00
|
|
|
var config = event.Config{}
|
2019-07-30 10:49:06 +02:00
|
|
|
configData, err := readConfig(ctx, objAPI, configFile)
|
2018-03-15 21:03:41 +01:00
|
|
|
if err != nil {
|
2019-07-30 10:49:06 +02:00
|
|
|
if err != errConfigNotFound {
|
|
|
|
writeErrorResponse(ctx, w, toAPIError(ctx, err), r.URL, guessIsBrowserReq(r))
|
|
|
|
return
|
|
|
|
}
|
2019-12-13 21:36:45 +01:00
|
|
|
config.SetRegion(globalServerRegion)
|
2020-01-30 05:28:05 +01:00
|
|
|
config.XMLNS = "http://s3.amazonaws.com/doc/2006-03-01/"
|
2019-12-13 21:36:45 +01:00
|
|
|
notificationBytes, err := xml.Marshal(config)
|
|
|
|
if err != nil {
|
2019-02-14 01:07:21 +01:00
|
|
|
writeErrorResponse(ctx, w, toAPIError(ctx, err), r.URL, guessIsBrowserReq(r))
|
2018-03-15 21:03:41 +01:00
|
|
|
return
|
|
|
|
}
|
2019-12-13 21:36:45 +01:00
|
|
|
|
|
|
|
writeSuccessResponseXML(w, notificationBytes)
|
|
|
|
return
|
2016-08-05 07:01:58 +02:00
|
|
|
}
|
2018-03-15 21:03:41 +01:00
|
|
|
|
2019-10-23 07:59:13 +02:00
|
|
|
config.SetRegion(globalServerRegion)
|
2019-07-30 10:49:06 +02:00
|
|
|
|
2019-12-13 21:36:45 +01:00
|
|
|
if err = xml.Unmarshal(configData, &config); err != nil {
|
|
|
|
writeErrorResponse(ctx, w, toAPIError(ctx, err), r.URL, guessIsBrowserReq(r))
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
if err = config.Validate(globalServerRegion, globalNotificationSys.targetList); err != nil {
|
|
|
|
arnErr, ok := err.(*event.ErrARNNotFound)
|
|
|
|
if !ok {
|
|
|
|
writeErrorResponse(ctx, w, toAPIError(ctx, err), r.URL, guessIsBrowserReq(r))
|
|
|
|
return
|
|
|
|
}
|
|
|
|
for i, queue := range config.QueueList {
|
|
|
|
// Remove ARN not found queues, because we previously allowed
|
|
|
|
// adding unexpected entries into the config.
|
|
|
|
//
|
|
|
|
// With newer config disallowing changing / turning off
|
|
|
|
// notification targets without removing ARN in notification
|
|
|
|
// configuration we won't see this problem anymore.
|
2020-04-14 20:06:23 +02:00
|
|
|
if reflect.DeepEqual(queue.ARN, arnErr.ARN) && i < len(config.QueueList) {
|
2019-12-13 21:36:45 +01:00
|
|
|
config.QueueList = append(config.QueueList[:i],
|
|
|
|
config.QueueList[i+1:]...)
|
|
|
|
}
|
|
|
|
// This is a one time activity we shall do this
|
|
|
|
// here and allow stale ARN to be removed. We shall
|
|
|
|
// never reach a stage where we will have stale
|
|
|
|
// notification configs.
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-01-30 05:28:05 +01:00
|
|
|
// If xml namespace is empty, set a default value before returning.
|
|
|
|
if config.XMLNS == "" {
|
|
|
|
config.XMLNS = "http://s3.amazonaws.com/doc/2006-03-01/"
|
|
|
|
}
|
|
|
|
|
2019-07-30 10:49:06 +02:00
|
|
|
notificationBytes, err := xml.Marshal(config)
|
2016-07-24 07:51:12 +02:00
|
|
|
if err != nil {
|
2019-02-14 01:07:21 +01:00
|
|
|
writeErrorResponse(ctx, w, toAPIError(ctx, err), r.URL, guessIsBrowserReq(r))
|
2016-07-24 07:51:12 +02:00
|
|
|
return
|
|
|
|
}
|
2017-01-06 09:37:00 +01:00
|
|
|
|
|
|
|
writeSuccessResponseXML(w, notificationBytes)
|
2016-07-24 07:51:12 +02:00
|
|
|
}
|
|
|
|
|
2018-03-15 21:03:41 +01:00
|
|
|
// PutBucketNotificationHandler - This HTTP handler stores given notification configuration as per
|
|
|
|
// http://docs.aws.amazon.com/AmazonS3/latest/dev/NotificationHowTo.html.
|
2016-07-24 07:51:12 +02:00
|
|
|
func (api objectAPIHandlers) PutBucketNotificationHandler(w http.ResponseWriter, r *http.Request) {
|
2018-07-21 03:46:32 +02:00
|
|
|
ctx := newContext(r, w, "PutBucketNotification")
|
2018-02-10 00:19:30 +01:00
|
|
|
|
2018-11-22 05:03:24 +01:00
|
|
|
defer logger.AuditLog(w, r, "PutBucketNotification", mustGetClaimsFromToken(r))
|
2018-10-12 21:25:59 +02:00
|
|
|
|
2016-08-11 03:47:49 +02:00
|
|
|
objectAPI := api.ObjectAPI()
|
|
|
|
if objectAPI == nil {
|
2019-02-14 01:07:21 +01:00
|
|
|
writeErrorResponse(ctx, w, errorCodes.ToAPIErr(ErrServerNotInitialized), r.URL, guessIsBrowserReq(r))
|
2016-08-11 03:47:49 +02:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2018-02-10 00:19:30 +01:00
|
|
|
if !objectAPI.IsNotificationSupported() {
|
2019-02-14 01:07:21 +01:00
|
|
|
writeErrorResponse(ctx, w, errorCodes.ToAPIErr(ErrNotImplemented), r.URL, guessIsBrowserReq(r))
|
2018-02-10 00:19:30 +01:00
|
|
|
return
|
|
|
|
}
|
2016-11-21 22:51:05 +01:00
|
|
|
|
2016-07-24 07:51:12 +02:00
|
|
|
vars := mux.Vars(r)
|
2018-03-15 21:03:41 +01:00
|
|
|
bucketName := vars["bucket"]
|
2016-07-24 07:51:12 +02:00
|
|
|
|
2018-04-25 00:53:30 +02:00
|
|
|
if s3Error := checkRequestAuthType(ctx, r, policy.PutBucketNotificationAction, bucketName, ""); s3Error != ErrNone {
|
2019-02-14 01:07:21 +01:00
|
|
|
writeErrorResponse(ctx, w, errorCodes.ToAPIErr(s3Error), r.URL, guessIsBrowserReq(r))
|
2018-04-25 00:53:30 +02:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2018-03-14 20:01:47 +01:00
|
|
|
_, err := objectAPI.GetBucketInfo(ctx, bucketName)
|
2016-07-24 07:51:12 +02:00
|
|
|
if err != nil {
|
2019-02-14 01:07:21 +01:00
|
|
|
writeErrorResponse(ctx, w, toAPIError(ctx, err), r.URL, guessIsBrowserReq(r))
|
2016-07-24 07:51:12 +02:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2017-01-21 01:33:01 +01:00
|
|
|
// PutBucketNotification always needs a Content-Length.
|
2018-03-15 21:03:41 +01:00
|
|
|
if r.ContentLength <= 0 {
|
2019-02-14 01:07:21 +01:00
|
|
|
writeErrorResponse(ctx, w, errorCodes.ToAPIErr(ErrMissingContentLength), r.URL, guessIsBrowserReq(r))
|
2017-01-21 01:33:01 +01:00
|
|
|
return
|
2016-07-24 07:51:12 +02:00
|
|
|
}
|
|
|
|
|
2019-12-13 21:36:45 +01:00
|
|
|
lreader := io.LimitReader(r.Body, r.ContentLength)
|
|
|
|
config, err := event.ParseConfig(lreader, globalServerRegion, globalNotificationSys.targetList)
|
2016-07-24 07:51:12 +02:00
|
|
|
if err != nil {
|
2019-02-12 10:25:52 +01:00
|
|
|
apiErr := errorCodes.ToAPIErr(ErrMalformedXML)
|
2018-03-15 21:03:41 +01:00
|
|
|
if event.IsEventError(err) {
|
2019-02-12 10:25:52 +01:00
|
|
|
apiErr = toAPIError(ctx, err)
|
2018-03-15 21:03:41 +01:00
|
|
|
}
|
2019-12-13 21:36:45 +01:00
|
|
|
writeErrorResponse(ctx, w, apiErr, r.URL, guessIsBrowserReq(r))
|
|
|
|
return
|
2016-07-24 07:51:12 +02:00
|
|
|
}
|
|
|
|
|
2018-10-09 23:00:01 +02:00
|
|
|
if err = saveNotificationConfig(ctx, objectAPI, bucketName, config); err != nil {
|
2019-02-14 01:07:21 +01:00
|
|
|
writeErrorResponse(ctx, w, toAPIError(ctx, err), r.URL, guessIsBrowserReq(r))
|
2018-03-15 21:03:41 +01:00
|
|
|
return
|
2017-11-16 19:56:06 +01:00
|
|
|
}
|
|
|
|
|
2018-03-15 21:03:41 +01:00
|
|
|
rulesMap := config.ToRulesMap()
|
|
|
|
globalNotificationSys.AddRulesMap(bucketName, rulesMap)
|
2018-07-03 20:09:36 +02:00
|
|
|
globalNotificationSys.PutBucketNotification(ctx, bucketName, rulesMap)
|
2017-11-16 19:56:06 +01:00
|
|
|
|
2018-03-15 21:03:41 +01:00
|
|
|
writeSuccessResponseHeadersOnly(w)
|
2016-08-05 07:01:58 +02:00
|
|
|
}
|
|
|
|
|
2019-12-13 20:33:11 +01:00
|
|
|
func (api objectAPIHandlers) ListenBucketNotificationHandler(w http.ResponseWriter, r *http.Request) {
|
|
|
|
ctx := newContext(r, w, "ListenBucketNotification")
|
2019-12-12 19:01:23 +01:00
|
|
|
|
2019-12-13 20:33:11 +01:00
|
|
|
defer logger.AuditLog(w, r, "ListenBucketNotification", mustGetClaimsFromToken(r))
|
2019-12-12 19:01:23 +01:00
|
|
|
|
|
|
|
// Validate if bucket exists.
|
|
|
|
objAPI := api.ObjectAPI()
|
|
|
|
if objAPI == nil {
|
|
|
|
writeErrorResponse(ctx, w, errorCodes.ToAPIErr(ErrServerNotInitialized), r.URL, guessIsBrowserReq(r))
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
if !objAPI.IsNotificationSupported() {
|
|
|
|
writeErrorResponse(ctx, w, errorCodes.ToAPIErr(ErrNotImplemented), r.URL, guessIsBrowserReq(r))
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
if !objAPI.IsListenBucketSupported() {
|
|
|
|
writeErrorResponse(ctx, w, errorCodes.ToAPIErr(ErrNotImplemented), r.URL, guessIsBrowserReq(r))
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
vars := mux.Vars(r)
|
|
|
|
bucketName := vars["bucket"]
|
|
|
|
|
|
|
|
values := r.URL.Query()
|
2019-12-20 20:45:03 +01:00
|
|
|
values.Set(peerRESTListenBucket, bucketName)
|
2019-12-12 19:01:23 +01:00
|
|
|
|
|
|
|
var prefix string
|
2019-12-17 05:30:57 +01:00
|
|
|
if len(values[peerRESTListenPrefix]) > 1 {
|
2019-12-12 19:01:23 +01:00
|
|
|
writeErrorResponse(ctx, w, errorCodes.ToAPIErr(ErrFilterNamePrefix), r.URL, guessIsBrowserReq(r))
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2019-12-17 05:30:57 +01:00
|
|
|
if len(values[peerRESTListenPrefix]) == 1 {
|
|
|
|
if err := event.ValidateFilterRuleValue(values[peerRESTListenPrefix][0]); err != nil {
|
2019-12-12 19:01:23 +01:00
|
|
|
writeErrorResponse(ctx, w, toAPIError(ctx, err), r.URL, guessIsBrowserReq(r))
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2019-12-17 05:30:57 +01:00
|
|
|
prefix = values[peerRESTListenPrefix][0]
|
2019-12-12 19:01:23 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
var suffix string
|
2019-12-17 05:30:57 +01:00
|
|
|
if len(values[peerRESTListenSuffix]) > 1 {
|
2019-12-12 19:01:23 +01:00
|
|
|
writeErrorResponse(ctx, w, errorCodes.ToAPIErr(ErrFilterNameSuffix), r.URL, guessIsBrowserReq(r))
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2019-12-17 05:30:57 +01:00
|
|
|
if len(values[peerRESTListenSuffix]) == 1 {
|
|
|
|
if err := event.ValidateFilterRuleValue(values[peerRESTListenSuffix][0]); err != nil {
|
2019-12-12 19:01:23 +01:00
|
|
|
writeErrorResponse(ctx, w, toAPIError(ctx, err), r.URL, guessIsBrowserReq(r))
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2019-12-17 05:30:57 +01:00
|
|
|
suffix = values[peerRESTListenSuffix][0]
|
2019-12-12 19:01:23 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
pattern := event.NewPattern(prefix, suffix)
|
|
|
|
|
2019-12-17 05:30:57 +01:00
|
|
|
var eventNames []event.Name
|
|
|
|
for _, s := range values[peerRESTListenEvents] {
|
2019-12-12 19:01:23 +01:00
|
|
|
eventName, err := event.ParseName(s)
|
|
|
|
if err != nil {
|
|
|
|
writeErrorResponse(ctx, w, toAPIError(ctx, err), r.URL, guessIsBrowserReq(r))
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
eventNames = append(eventNames, eventName)
|
|
|
|
}
|
|
|
|
|
|
|
|
if _, err := objAPI.GetBucketInfo(ctx, bucketName); err != nil {
|
|
|
|
writeErrorResponse(ctx, w, toAPIError(ctx, err), r.URL, guessIsBrowserReq(r))
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2019-12-17 05:30:57 +01:00
|
|
|
rulesMap := event.NewRulesMap(eventNames, pattern, event.TargetID{ID: mustGetUUID()})
|
2019-12-12 19:01:23 +01:00
|
|
|
|
|
|
|
w.Header().Set(xhttp.ContentType, "text/event-stream")
|
|
|
|
|
|
|
|
// Listen Publisher and peer-listen-client uses nonblocking send and hence does not wait for slow receivers.
|
|
|
|
// Use buffered channel to take care of burst sends or slow w.Write()
|
|
|
|
listenCh := make(chan interface{}, 4000)
|
|
|
|
|
2020-04-17 20:20:56 +02:00
|
|
|
peers := newPeerRestClients(globalEndpoints)
|
2019-12-12 19:01:23 +01:00
|
|
|
|
2020-04-16 19:56:18 +02:00
|
|
|
globalHTTPListen.Subscribe(listenCh, ctx.Done(), func(evI interface{}) bool {
|
2019-12-12 19:01:23 +01:00
|
|
|
ev, ok := evI.(event.Event)
|
|
|
|
if !ok {
|
|
|
|
return false
|
|
|
|
}
|
2019-12-20 20:45:03 +01:00
|
|
|
if ev.S3.Bucket.Name != values.Get(peerRESTListenBucket) {
|
|
|
|
return false
|
|
|
|
}
|
2019-12-12 19:01:23 +01:00
|
|
|
objectName, uerr := url.QueryUnescape(ev.S3.Object.Key)
|
|
|
|
if uerr != nil {
|
2019-12-17 05:30:57 +01:00
|
|
|
objectName = ev.S3.Object.Key
|
2019-12-12 19:01:23 +01:00
|
|
|
}
|
|
|
|
return len(rulesMap.Match(ev.EventName, objectName).ToSlice()) != 0
|
|
|
|
})
|
|
|
|
|
|
|
|
for _, peer := range peers {
|
|
|
|
if peer == nil {
|
|
|
|
continue
|
|
|
|
}
|
2020-04-16 19:56:18 +02:00
|
|
|
peer.Listen(listenCh, ctx.Done(), values)
|
2019-12-12 19:01:23 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
keepAliveTicker := time.NewTicker(500 * time.Millisecond)
|
|
|
|
defer keepAliveTicker.Stop()
|
|
|
|
|
|
|
|
enc := json.NewEncoder(w)
|
|
|
|
for {
|
|
|
|
select {
|
|
|
|
case evI := <-listenCh:
|
|
|
|
ev := evI.(event.Event)
|
2019-12-17 05:30:57 +01:00
|
|
|
if len(string(ev.EventName)) > 0 {
|
|
|
|
if err := enc.Encode(struct{ Records []event.Event }{[]event.Event{ev}}); err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
if _, err := w.Write([]byte(" ")); err != nil {
|
|
|
|
return
|
|
|
|
}
|
2019-12-12 19:01:23 +01:00
|
|
|
}
|
|
|
|
w.(http.Flusher).Flush()
|
|
|
|
case <-keepAliveTicker.C:
|
|
|
|
if _, err := w.Write([]byte(" ")); err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
w.(http.Flusher).Flush()
|
2020-04-16 19:56:18 +02:00
|
|
|
case <-ctx.Done():
|
2019-12-12 19:01:23 +01:00
|
|
|
return
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|