2016-07-24 07:51:12 +02:00
|
|
|
/*
|
|
|
|
* Minio Cloud Storage, (C) 2016 Minio, Inc.
|
|
|
|
*
|
|
|
|
* 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 "strings"
|
|
|
|
|
|
|
|
// List of valid event types.
|
|
|
|
var suppportedEventTypes = map[string]struct{}{
|
|
|
|
// Object created event types.
|
|
|
|
"s3:ObjectCreated:*": {},
|
|
|
|
"s3:ObjectCreated:Put": {},
|
|
|
|
"s3:ObjectCreated:Post": {},
|
|
|
|
"s3:ObjectCreated:Copy": {},
|
|
|
|
"s3:ObjectCreated:CompleteMultipartUpload": {},
|
|
|
|
// Object removed event types.
|
|
|
|
"s3:ObjectRemoved:*": {},
|
|
|
|
"s3:ObjectRemoved:Delete": {},
|
|
|
|
}
|
|
|
|
|
|
|
|
// checkEvent - checks if an event is supported.
|
|
|
|
func checkEvent(event string) APIErrorCode {
|
|
|
|
_, ok := suppportedEventTypes[event]
|
|
|
|
if !ok {
|
|
|
|
return ErrEventNotification
|
|
|
|
}
|
|
|
|
return ErrNone
|
|
|
|
}
|
|
|
|
|
|
|
|
// checkEvents - checks given list of events if all of them are valid.
|
|
|
|
// given if one of them is invalid, this function returns an error.
|
|
|
|
func checkEvents(events []string) APIErrorCode {
|
|
|
|
for _, event := range events {
|
|
|
|
if s3Error := checkEvent(event); s3Error != ErrNone {
|
|
|
|
return s3Error
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return ErrNone
|
|
|
|
}
|
|
|
|
|
2016-07-26 02:53:55 +02:00
|
|
|
// Valid if filterName is 'prefix'.
|
|
|
|
func isValidFilterNamePrefix(filterName string) bool {
|
|
|
|
return "prefix" == filterName
|
|
|
|
}
|
|
|
|
|
|
|
|
// Valid if filterName is 'suffix'.
|
|
|
|
func isValidFilterNameSuffix(filterName string) bool {
|
|
|
|
return "suffix" == filterName
|
|
|
|
}
|
|
|
|
|
|
|
|
// Is this a valid filterName? - returns true if valid.
|
|
|
|
func isValidFilterName(filterName string) bool {
|
|
|
|
return isValidFilterNamePrefix(filterName) || isValidFilterNameSuffix(filterName)
|
|
|
|
}
|
|
|
|
|
|
|
|
// checkFilterRules - checks given list of filter rules if all of them are valid.
|
|
|
|
func checkFilterRules(filterRules []filterRule) APIErrorCode {
|
|
|
|
ruleSetMap := make(map[string]string)
|
|
|
|
// Validate all filter rules.
|
|
|
|
for _, filterRule := range filterRules {
|
|
|
|
// Unknown filter rule name found, returns an appropriate error.
|
|
|
|
if !isValidFilterName(filterRule.Name) {
|
|
|
|
return ErrFilterNameInvalid
|
|
|
|
}
|
|
|
|
|
|
|
|
// Filter names should not be set twice per notification service
|
|
|
|
// configuration, if found return an appropriate error.
|
|
|
|
if _, ok := ruleSetMap[filterRule.Name]; ok {
|
|
|
|
if isValidFilterNamePrefix(filterRule.Name) {
|
|
|
|
return ErrFilterNamePrefix
|
|
|
|
} else if isValidFilterNameSuffix(filterRule.Name) {
|
|
|
|
return ErrFilterNameSuffix
|
|
|
|
} else {
|
|
|
|
return ErrFilterNameInvalid
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if !IsValidObjectPrefix(filterRule.Value) {
|
2016-08-18 21:00:01 +02:00
|
|
|
return ErrFilterValueInvalid
|
2016-07-26 02:53:55 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
// Set the new rule name to keep track of duplicates.
|
|
|
|
ruleSetMap[filterRule.Name] = filterRule.Value
|
|
|
|
}
|
|
|
|
// Success all prefixes validated.
|
|
|
|
return ErrNone
|
|
|
|
}
|
|
|
|
|
2016-08-18 01:34:03 +02:00
|
|
|
// Checks validity of input ARN for a given arnType.
|
|
|
|
func checkARN(arn, arnType string) APIErrorCode {
|
|
|
|
if !strings.HasPrefix(arn, arnType) {
|
2016-07-24 07:51:12 +02:00
|
|
|
return ErrARNNotification
|
|
|
|
}
|
2016-08-18 01:34:03 +02:00
|
|
|
if !strings.HasPrefix(arn, arnType+serverConfig.GetRegion()+":") {
|
2016-08-05 07:01:58 +02:00
|
|
|
return ErrRegionNotification
|
|
|
|
}
|
2016-08-18 01:34:03 +02:00
|
|
|
account := strings.SplitN(strings.TrimPrefix(arn, arnType+serverConfig.GetRegion()+":"), ":", 2)
|
|
|
|
switch len(account) {
|
|
|
|
case 1:
|
|
|
|
// This means ARN is malformed, account should have min of 2elements.
|
|
|
|
return ErrARNNotification
|
|
|
|
case 2:
|
|
|
|
// Account topic id or topic name cannot be empty.
|
|
|
|
if account[0] == "" || account[1] == "" {
|
|
|
|
return ErrARNNotification
|
|
|
|
}
|
|
|
|
}
|
2016-08-05 07:01:58 +02:00
|
|
|
return ErrNone
|
|
|
|
}
|
|
|
|
|
2016-08-18 01:34:03 +02:00
|
|
|
// checkQueueARN - check if the queue arn is valid.
|
|
|
|
func checkQueueARN(queueARN string) APIErrorCode {
|
|
|
|
return checkARN(queueARN, minioSqs)
|
|
|
|
}
|
|
|
|
|
2016-08-16 05:56:43 +02:00
|
|
|
// checkTopicARN - check if the topic arn is valid.
|
|
|
|
func checkTopicARN(topicARN string) APIErrorCode {
|
2016-08-18 01:34:03 +02:00
|
|
|
return checkARN(topicARN, minioTopic)
|
2016-07-24 07:51:12 +02:00
|
|
|
}
|
|
|
|
|
2016-08-16 05:56:43 +02:00
|
|
|
// Returns true if the topicARN is for an Minio sns listen type.
|
|
|
|
func isMinioSNS(topicARN arnTopic) bool {
|
|
|
|
return strings.HasSuffix(topicARN.Type, snsTypeMinio)
|
|
|
|
}
|
|
|
|
|
|
|
|
// isMinioSNSConfigured - verifies if one topic ARN is valid and is enabled.
|
|
|
|
func isMinioSNSConfigured(topicARN string, topicConfigs []topicConfig) bool {
|
|
|
|
for _, topicConfig := range topicConfigs {
|
|
|
|
// Validate if topic ARN is already enabled.
|
|
|
|
if topicARN == topicConfig.TopicARN {
|
|
|
|
return true
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
|
2016-07-26 02:53:55 +02:00
|
|
|
// Validate if we recognize the queue type.
|
2016-08-05 07:01:58 +02:00
|
|
|
func isValidQueue(sqsARN arnSQS) bool {
|
|
|
|
amqpQ := isAMQPQueue(sqsARN) // Is amqp queue?.
|
|
|
|
elasticQ := isElasticQueue(sqsARN) // Is elastic queue?.
|
|
|
|
redisQ := isRedisQueue(sqsARN) // Is redis queue?.
|
2016-07-26 02:53:55 +02:00
|
|
|
return amqpQ || elasticQ || redisQ
|
|
|
|
}
|
|
|
|
|
2016-08-16 05:56:43 +02:00
|
|
|
// Validate if we recognize the topic type.
|
|
|
|
func isValidTopic(topicARN arnTopic) bool {
|
|
|
|
return isMinioSNS(topicARN) // Is minio topic?.
|
2016-08-05 07:01:58 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
// Validates account id for input queue ARN.
|
|
|
|
func isValidQueueID(queueARN string) bool {
|
|
|
|
// Unmarshals QueueARN into structured object.
|
|
|
|
sqsARN := unmarshalSqsARN(queueARN)
|
2016-09-17 02:26:27 +02:00
|
|
|
// Is Queue identifier valid?.
|
|
|
|
if isAMQPQueue(sqsARN) { // AMQP eueue.
|
2016-08-05 07:01:58 +02:00
|
|
|
amqpN := serverConfig.GetAMQPNotifyByID(sqsARN.AccountID)
|
|
|
|
return amqpN.Enable && amqpN.URL != ""
|
|
|
|
} else if isElasticQueue(sqsARN) { // Elastic queue.
|
|
|
|
elasticN := serverConfig.GetElasticSearchNotifyByID(sqsARN.AccountID)
|
|
|
|
return elasticN.Enable && elasticN.URL != ""
|
|
|
|
} else if isRedisQueue(sqsARN) { // Redis queue.
|
|
|
|
redisN := serverConfig.GetRedisNotifyByID(sqsARN.AccountID)
|
|
|
|
return redisN.Enable && redisN.Addr != ""
|
|
|
|
}
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
|
2016-07-24 07:51:12 +02:00
|
|
|
// Check - validates queue configuration and returns error if any.
|
|
|
|
func checkQueueConfig(qConfig queueConfig) APIErrorCode {
|
|
|
|
// Check queue arn is valid.
|
2016-08-05 07:01:58 +02:00
|
|
|
if s3Error := checkQueueARN(qConfig.QueueARN); s3Error != ErrNone {
|
2016-07-24 07:51:12 +02:00
|
|
|
return s3Error
|
|
|
|
}
|
|
|
|
|
2016-08-05 07:01:58 +02:00
|
|
|
// Validate if the account ID is correct.
|
|
|
|
if !isValidQueueID(qConfig.QueueARN) {
|
2016-07-24 07:51:12 +02:00
|
|
|
return ErrARNNotification
|
|
|
|
}
|
|
|
|
|
|
|
|
// Check if valid events are set in queue config.
|
|
|
|
if s3Error := checkEvents(qConfig.Events); s3Error != ErrNone {
|
|
|
|
return s3Error
|
|
|
|
}
|
|
|
|
|
2016-07-26 02:53:55 +02:00
|
|
|
// Check if valid filters are set in queue config.
|
|
|
|
if s3Error := checkFilterRules(qConfig.Filter.Key.FilterRules); s3Error != ErrNone {
|
|
|
|
return s3Error
|
|
|
|
}
|
|
|
|
|
2016-07-24 07:51:12 +02:00
|
|
|
// Success.
|
|
|
|
return ErrNone
|
|
|
|
}
|
|
|
|
|
2016-08-05 07:01:58 +02:00
|
|
|
// Check - validates queue configuration and returns error if any.
|
2016-08-16 05:56:43 +02:00
|
|
|
func checkTopicConfig(tConfig topicConfig) APIErrorCode {
|
2016-08-05 07:01:58 +02:00
|
|
|
// Check queue arn is valid.
|
2016-08-16 05:56:43 +02:00
|
|
|
if s3Error := checkTopicARN(tConfig.TopicARN); s3Error != ErrNone {
|
2016-08-05 07:01:58 +02:00
|
|
|
return s3Error
|
|
|
|
}
|
|
|
|
|
|
|
|
// Unmarshals QueueARN into structured object.
|
2016-08-16 05:56:43 +02:00
|
|
|
topicARN := unmarshalTopicARN(tConfig.TopicARN)
|
|
|
|
// Validate if topicARN requested any of the known supported queues.
|
|
|
|
if !isValidTopic(topicARN) {
|
2016-08-05 07:01:58 +02:00
|
|
|
return ErrARNNotification
|
|
|
|
}
|
|
|
|
|
|
|
|
// Check if valid events are set in queue config.
|
2016-08-16 05:56:43 +02:00
|
|
|
if s3Error := checkEvents(tConfig.Events); s3Error != ErrNone {
|
2016-08-05 07:01:58 +02:00
|
|
|
return s3Error
|
|
|
|
}
|
|
|
|
|
|
|
|
// Check if valid filters are set in queue config.
|
2016-08-16 05:56:43 +02:00
|
|
|
if s3Error := checkFilterRules(tConfig.Filter.Key.FilterRules); s3Error != ErrNone {
|
2016-08-05 07:01:58 +02:00
|
|
|
return s3Error
|
|
|
|
}
|
|
|
|
|
|
|
|
// Success.
|
|
|
|
return ErrNone
|
|
|
|
}
|
|
|
|
|
2016-07-24 07:51:12 +02:00
|
|
|
// Validates all incoming queue configs, checkQueueConfig validates if the
|
|
|
|
// input fields for each queues is not malformed and has valid configuration
|
|
|
|
// information. If validation fails bucket notifications are not enabled.
|
|
|
|
func validateQueueConfigs(queueConfigs []queueConfig) APIErrorCode {
|
|
|
|
for _, qConfig := range queueConfigs {
|
|
|
|
if s3Error := checkQueueConfig(qConfig); s3Error != ErrNone {
|
|
|
|
return s3Error
|
|
|
|
}
|
|
|
|
}
|
|
|
|
// Success.
|
|
|
|
return ErrNone
|
|
|
|
}
|
|
|
|
|
2016-08-16 05:56:43 +02:00
|
|
|
// Validates all incoming topic configs, checkTopicConfig validates if the
|
2016-08-05 07:01:58 +02:00
|
|
|
// input fields for each queues is not malformed and has valid configuration
|
|
|
|
// information. If validation fails bucket notifications are not enabled.
|
2016-08-16 05:56:43 +02:00
|
|
|
func validateTopicConfigs(topicConfigs []topicConfig) APIErrorCode {
|
|
|
|
for _, tConfig := range topicConfigs {
|
|
|
|
if s3Error := checkTopicConfig(tConfig); s3Error != ErrNone {
|
2016-08-05 07:01:58 +02:00
|
|
|
return s3Error
|
|
|
|
}
|
|
|
|
}
|
|
|
|
// Success.
|
|
|
|
return ErrNone
|
|
|
|
}
|
|
|
|
|
2016-08-24 03:42:30 +02:00
|
|
|
// Check all the queue configs for any duplicates.
|
|
|
|
func checkDuplicateQueueConfigs(configs []queueConfig) APIErrorCode {
|
2016-08-26 09:11:53 +02:00
|
|
|
var queueConfigARNS []string
|
2016-08-24 03:42:30 +02:00
|
|
|
|
|
|
|
// Navigate through each configs and count the entries.
|
|
|
|
for _, config := range configs {
|
2016-08-26 09:11:53 +02:00
|
|
|
queueConfigARNS = append(queueConfigARNS, config.QueueARN)
|
2016-08-24 03:42:30 +02:00
|
|
|
}
|
|
|
|
|
2016-08-26 09:11:53 +02:00
|
|
|
// Check if there are any duplicate counts.
|
|
|
|
if err := checkDuplicates(queueConfigARNS); err != nil {
|
|
|
|
errorIf(err, "Invalid queue configs found.")
|
|
|
|
return ErrOverlappingConfigs
|
2016-08-24 03:42:30 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
// Success.
|
|
|
|
return ErrNone
|
|
|
|
}
|
|
|
|
|
|
|
|
// Check all the topic configs for any duplicates.
|
|
|
|
func checkDuplicateTopicConfigs(configs []topicConfig) APIErrorCode {
|
2016-08-26 09:11:53 +02:00
|
|
|
var topicConfigARNS []string
|
2016-08-24 03:42:30 +02:00
|
|
|
|
|
|
|
// Navigate through each configs and count the entries.
|
|
|
|
for _, config := range configs {
|
2016-08-26 09:11:53 +02:00
|
|
|
topicConfigARNS = append(topicConfigARNS, config.TopicARN)
|
2016-08-24 03:42:30 +02:00
|
|
|
}
|
|
|
|
|
2016-08-26 09:11:53 +02:00
|
|
|
// Check if there are any duplicate counts.
|
|
|
|
if err := checkDuplicates(topicConfigARNS); err != nil {
|
|
|
|
errorIf(err, "Invalid topic configs found.")
|
|
|
|
return ErrOverlappingConfigs
|
2016-08-24 03:42:30 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
// Success.
|
|
|
|
return ErrNone
|
|
|
|
}
|
|
|
|
|
2016-07-24 07:51:12 +02:00
|
|
|
// Validates all the bucket notification configuration for their validity,
|
|
|
|
// if one of the config is malformed or has invalid data it is rejected.
|
|
|
|
// Configuration is never applied partially.
|
|
|
|
func validateNotificationConfig(nConfig notificationConfig) APIErrorCode {
|
2016-08-24 03:42:30 +02:00
|
|
|
// Validate all queue configs.
|
2016-08-05 07:01:58 +02:00
|
|
|
if s3Error := validateQueueConfigs(nConfig.QueueConfigs); s3Error != ErrNone {
|
2016-07-24 07:51:12 +02:00
|
|
|
return s3Error
|
|
|
|
}
|
2016-08-24 03:42:30 +02:00
|
|
|
// Validate all topic configs.
|
2016-08-16 05:56:43 +02:00
|
|
|
if s3Error := validateTopicConfigs(nConfig.TopicConfigs); s3Error != ErrNone {
|
2016-08-05 07:01:58 +02:00
|
|
|
return s3Error
|
|
|
|
}
|
|
|
|
|
2016-08-24 03:42:30 +02:00
|
|
|
// Check for duplicate queue configs.
|
2016-08-26 09:11:53 +02:00
|
|
|
if len(nConfig.QueueConfigs) > 1 {
|
|
|
|
if s3Error := checkDuplicateQueueConfigs(nConfig.QueueConfigs); s3Error != ErrNone {
|
|
|
|
return s3Error
|
|
|
|
}
|
2016-08-24 03:42:30 +02:00
|
|
|
}
|
2016-08-26 09:11:53 +02:00
|
|
|
|
2016-08-24 03:42:30 +02:00
|
|
|
// Check for duplicate topic configs.
|
2016-08-26 09:11:53 +02:00
|
|
|
if len(nConfig.TopicConfigs) > 1 {
|
|
|
|
if s3Error := checkDuplicateTopicConfigs(nConfig.TopicConfigs); s3Error != ErrNone {
|
|
|
|
return s3Error
|
|
|
|
}
|
2016-08-24 03:42:30 +02:00
|
|
|
}
|
|
|
|
|
2016-07-24 07:51:12 +02:00
|
|
|
// Add validation for other configurations.
|
|
|
|
return ErrNone
|
|
|
|
}
|
|
|
|
|
2016-08-16 05:56:43 +02:00
|
|
|
// Unmarshals input value of AWS ARN format into minioTopic object.
|
|
|
|
// Returned value represents minio topic type, currently supported are
|
|
|
|
// - listen
|
|
|
|
func unmarshalTopicARN(topicARN string) arnTopic {
|
|
|
|
topic := arnTopic{}
|
|
|
|
if !strings.HasPrefix(topicARN, minioTopic+serverConfig.GetRegion()+":") {
|
|
|
|
return topic
|
2016-08-05 07:01:58 +02:00
|
|
|
}
|
2016-08-16 05:56:43 +02:00
|
|
|
topicType := strings.TrimPrefix(topicARN, minioTopic+serverConfig.GetRegion()+":")
|
2016-08-05 07:01:58 +02:00
|
|
|
switch {
|
2016-08-16 05:56:43 +02:00
|
|
|
case strings.HasSuffix(topicType, snsTypeMinio):
|
|
|
|
topic.Type = snsTypeMinio
|
|
|
|
} // Add more topic here.
|
|
|
|
topic.AccountID = strings.TrimSuffix(topicType, ":"+topic.Type)
|
|
|
|
return topic
|
2016-08-05 07:01:58 +02:00
|
|
|
}
|
|
|
|
|
2016-07-24 07:51:12 +02:00
|
|
|
// Unmarshals input value of AWS ARN format into minioSqs object.
|
|
|
|
// Returned value represents minio sqs types, currently supported are
|
|
|
|
// - amqp
|
|
|
|
// - elasticsearch
|
2016-07-26 02:53:55 +02:00
|
|
|
// - redis
|
2016-08-05 07:01:58 +02:00
|
|
|
func unmarshalSqsARN(queueARN string) (mSqs arnSQS) {
|
|
|
|
mSqs = arnSQS{}
|
|
|
|
if !strings.HasPrefix(queueARN, minioSqs+serverConfig.GetRegion()+":") {
|
|
|
|
return mSqs
|
|
|
|
}
|
|
|
|
sqsType := strings.TrimPrefix(queueARN, minioSqs+serverConfig.GetRegion()+":")
|
|
|
|
switch {
|
|
|
|
case strings.HasSuffix(sqsType, queueTypeAMQP):
|
|
|
|
mSqs.Type = queueTypeAMQP
|
|
|
|
case strings.HasSuffix(sqsType, queueTypeElastic):
|
|
|
|
mSqs.Type = queueTypeElastic
|
|
|
|
case strings.HasSuffix(sqsType, queueTypeRedis):
|
|
|
|
mSqs.Type = queueTypeRedis
|
|
|
|
} // Add more queues here.
|
|
|
|
mSqs.AccountID = strings.TrimSuffix(sqsType, ":"+mSqs.Type)
|
2016-07-24 07:51:12 +02:00
|
|
|
return mSqs
|
|
|
|
}
|