2015-04-29 11:19:51 +02:00
|
|
|
/*
|
2015-07-25 02:51:40 +02:00
|
|
|
* Minio Cloud Storage, (C) 2015 Minio, Inc.
|
2015-04-29 11:19:51 +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
|
2015-04-23 01:28:13 +02:00
|
|
|
|
|
|
|
import (
|
|
|
|
"encoding/base64"
|
2016-04-21 02:35:38 +02:00
|
|
|
"encoding/xml"
|
2016-08-26 09:11:53 +02:00
|
|
|
"fmt"
|
2016-04-21 02:35:38 +02:00
|
|
|
"io"
|
2016-09-09 18:38:07 +02:00
|
|
|
"net/http"
|
2016-10-27 12:30:52 +02:00
|
|
|
"net/url"
|
2016-04-21 02:35:38 +02:00
|
|
|
"strings"
|
2016-09-02 05:13:11 +02:00
|
|
|
|
2016-09-19 19:17:46 +02:00
|
|
|
"encoding/json"
|
|
|
|
|
2016-11-23 03:18:22 +01:00
|
|
|
humanize "github.com/dustin/go-humanize"
|
2016-09-02 05:13:11 +02:00
|
|
|
"github.com/pkg/profile"
|
2015-04-23 01:28:13 +02:00
|
|
|
)
|
|
|
|
|
2016-09-09 18:38:07 +02:00
|
|
|
// make a copy of http.Header
|
|
|
|
func cloneHeader(h http.Header) http.Header {
|
|
|
|
h2 := make(http.Header, len(h))
|
|
|
|
for k, vv := range h {
|
|
|
|
vv2 := make([]string, len(vv))
|
|
|
|
copy(vv2, vv)
|
|
|
|
h2[k] = vv2
|
|
|
|
|
|
|
|
}
|
|
|
|
return h2
|
|
|
|
}
|
|
|
|
|
2016-08-26 09:11:53 +02:00
|
|
|
// checkDuplicates - function to validate if there are duplicates in a slice of strings.
|
2016-10-18 21:49:24 +02:00
|
|
|
func checkDuplicateStrings(list []string) error {
|
2016-08-26 09:11:53 +02:00
|
|
|
// Empty lists are not allowed.
|
|
|
|
if len(list) == 0 {
|
|
|
|
return errInvalidArgument
|
|
|
|
}
|
|
|
|
// Empty keys are not allowed.
|
|
|
|
for _, key := range list {
|
|
|
|
if key == "" {
|
|
|
|
return errInvalidArgument
|
|
|
|
}
|
|
|
|
}
|
|
|
|
listMaps := make(map[string]int)
|
|
|
|
// Navigate through each configs and count the entries.
|
|
|
|
for _, key := range list {
|
|
|
|
listMaps[key]++
|
|
|
|
}
|
|
|
|
// Validate if there are any duplicate counts.
|
|
|
|
for key, count := range listMaps {
|
|
|
|
if count != 1 {
|
|
|
|
return fmt.Errorf("Duplicate key: \"%s\" found of count: \"%d\"", key, count)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
// No duplicates.
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2017-01-10 20:01:23 +01:00
|
|
|
// splitStr splits a string into n parts, empty strings are added
|
|
|
|
// if we are not able to reach n elements
|
|
|
|
func splitStr(path, sep string, n int) []string {
|
|
|
|
splits := strings.SplitN(path, sep, n)
|
|
|
|
// Add empty strings if we found elements less than nr
|
|
|
|
for i := n - len(splits); i > 0; i-- {
|
|
|
|
splits = append(splits, "")
|
|
|
|
}
|
|
|
|
return splits
|
|
|
|
}
|
|
|
|
|
|
|
|
// Convert url path into bucket and object name.
|
|
|
|
func urlPath2BucketObjectName(u *url.URL) (bucketName, objectName string) {
|
|
|
|
if u == nil {
|
|
|
|
// Empty url, return bucket and object names.
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
// Trim any preceding slash separator.
|
|
|
|
urlPath := strings.TrimPrefix(u.Path, slashSeparator)
|
|
|
|
|
|
|
|
// Split urlpath using slash separator into a given number of
|
|
|
|
// expected tokens.
|
|
|
|
tokens := splitStr(urlPath, slashSeparator, 2)
|
|
|
|
|
|
|
|
// Extract bucket and objects.
|
|
|
|
bucketName, objectName = tokens[0], tokens[1]
|
|
|
|
|
|
|
|
// Success.
|
|
|
|
return bucketName, objectName
|
|
|
|
}
|
|
|
|
|
2017-01-18 21:24:34 +01:00
|
|
|
// URI scheme constants.
|
|
|
|
const (
|
|
|
|
httpScheme = "http"
|
|
|
|
httpsScheme = "https"
|
|
|
|
)
|
|
|
|
|
2017-01-13 05:08:00 +01:00
|
|
|
var portMap = map[string]string{
|
2017-01-18 21:24:34 +01:00
|
|
|
httpScheme: "80",
|
|
|
|
httpsScheme: "443",
|
2017-01-13 05:08:00 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
// Given a string of the form "host", "host:port", or "[ipv6::address]:port",
|
|
|
|
// return true if the string includes a port.
|
|
|
|
func hasPort(s string) bool { return strings.LastIndex(s, ":") > strings.LastIndex(s, "]") }
|
|
|
|
|
|
|
|
// canonicalAddr returns url.Host but always with a ":port" suffix
|
|
|
|
func canonicalAddr(u *url.URL) string {
|
|
|
|
addr := u.Host
|
|
|
|
if !hasPort(addr) {
|
|
|
|
return addr + ":" + portMap[u.Scheme]
|
|
|
|
}
|
|
|
|
return addr
|
|
|
|
}
|
|
|
|
|
2016-10-18 21:49:24 +02:00
|
|
|
// checkDuplicates - function to validate if there are duplicates in a slice of endPoints.
|
2016-10-27 12:30:52 +02:00
|
|
|
func checkDuplicateEndpoints(endpoints []*url.URL) error {
|
2016-10-18 21:49:24 +02:00
|
|
|
var strs []string
|
2016-10-27 12:30:52 +02:00
|
|
|
for _, ep := range endpoints {
|
2016-10-18 21:49:24 +02:00
|
|
|
strs = append(strs, ep.String())
|
|
|
|
}
|
|
|
|
return checkDuplicateStrings(strs)
|
|
|
|
}
|
|
|
|
|
2016-10-27 12:30:52 +02:00
|
|
|
// Find local node through the command line arguments. Returns in `host:port` format.
|
2016-10-12 10:03:50 +02:00
|
|
|
func getLocalAddress(srvCmdConfig serverCmdConfig) string {
|
2016-11-07 21:09:24 +01:00
|
|
|
if !globalIsDistXL {
|
2016-10-20 20:39:10 +02:00
|
|
|
return srvCmdConfig.serverAddr
|
2016-10-12 10:03:50 +02:00
|
|
|
}
|
2016-10-27 12:30:52 +02:00
|
|
|
for _, ep := range srvCmdConfig.endpoints {
|
|
|
|
// Validates if remote endpoint is local.
|
2016-10-18 21:49:24 +02:00
|
|
|
if isLocalStorage(ep) {
|
2016-10-27 12:30:52 +02:00
|
|
|
return ep.Host
|
2016-10-12 10:03:50 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
return ""
|
|
|
|
}
|
|
|
|
|
2016-04-21 02:35:38 +02:00
|
|
|
// xmlDecoder provide decoded value in xml.
|
2016-07-19 06:20:17 +02:00
|
|
|
func xmlDecoder(body io.Reader, v interface{}, size int64) error {
|
|
|
|
var lbody io.Reader
|
|
|
|
if size > 0 {
|
|
|
|
lbody = io.LimitReader(body, size)
|
|
|
|
} else {
|
|
|
|
lbody = body
|
|
|
|
}
|
|
|
|
d := xml.NewDecoder(lbody)
|
2016-04-21 02:35:38 +02:00
|
|
|
return d.Decode(v)
|
|
|
|
}
|
|
|
|
|
2016-03-13 01:08:15 +01:00
|
|
|
// checkValidMD5 - verify if valid md5, returns md5 in bytes.
|
2016-04-29 23:24:10 +02:00
|
|
|
func checkValidMD5(md5 string) ([]byte, error) {
|
|
|
|
return base64.StdEncoding.DecodeString(strings.TrimSpace(md5))
|
2015-04-23 01:28:13 +02:00
|
|
|
}
|
2015-04-29 11:19:51 +02:00
|
|
|
|
2015-04-29 19:51:59 +02:00
|
|
|
/// http://docs.aws.amazon.com/AmazonS3/latest/dev/UploadingObjects.html
|
2015-04-29 11:19:51 +02:00
|
|
|
const (
|
2015-12-28 08:00:36 +01:00
|
|
|
// maximum object size per PUT request is 5GiB
|
2016-11-23 03:18:22 +01:00
|
|
|
maxObjectSize = 5 * humanize.GiByte
|
|
|
|
// minimum Part size for multipart upload is 5MiB
|
|
|
|
minPartSize = 5 * humanize.MiByte
|
2016-05-24 10:52:47 +02:00
|
|
|
// maximum Part ID for multipart upload is 10000 (Acceptable values range from 1 to 10000 inclusive)
|
|
|
|
maxPartID = 10000
|
2015-04-29 11:19:51 +02:00
|
|
|
)
|
|
|
|
|
|
|
|
// isMaxObjectSize - verify if max object size
|
2015-12-28 08:00:36 +01:00
|
|
|
func isMaxObjectSize(size int64) bool {
|
2016-04-03 02:28:54 +02:00
|
|
|
return size > maxObjectSize
|
2015-04-29 11:19:51 +02:00
|
|
|
}
|
2016-02-05 12:09:31 +01:00
|
|
|
|
2016-05-08 21:06:05 +02:00
|
|
|
// Check if part size is more than or equal to minimum allowed size.
|
|
|
|
func isMinAllowedPartSize(size int64) bool {
|
|
|
|
return size >= minPartSize
|
|
|
|
}
|
|
|
|
|
2016-05-24 10:52:47 +02:00
|
|
|
// isMaxPartNumber - Check if part ID is greater than the maximum allowed ID.
|
|
|
|
func isMaxPartID(partID int) bool {
|
|
|
|
return partID > maxPartID
|
|
|
|
}
|
|
|
|
|
2016-02-05 12:09:31 +01:00
|
|
|
func contains(stringList []string, element string) bool {
|
|
|
|
for _, e := range stringList {
|
|
|
|
if e == element {
|
|
|
|
return true
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return false
|
|
|
|
}
|
2016-08-05 22:48:31 +02:00
|
|
|
|
2016-09-02 05:13:11 +02:00
|
|
|
// Starts a profiler returns nil if profiler is not enabled, caller needs to handle this.
|
|
|
|
func startProfiler(profiler string) interface {
|
|
|
|
Stop()
|
|
|
|
} {
|
2016-11-12 01:36:07 +01:00
|
|
|
// Enable profiler if ``_MINIO_PROFILER`` is set. Supported options are [cpu, mem, block].
|
2016-09-02 05:13:11 +02:00
|
|
|
switch profiler {
|
|
|
|
case "cpu":
|
2016-11-12 01:36:07 +01:00
|
|
|
return profile.Start(profile.CPUProfile, profile.NoShutdownHook)
|
2016-09-02 05:13:11 +02:00
|
|
|
case "mem":
|
2016-11-12 01:36:07 +01:00
|
|
|
return profile.Start(profile.MemProfile, profile.NoShutdownHook)
|
2016-09-02 05:13:11 +02:00
|
|
|
case "block":
|
2016-11-12 01:36:07 +01:00
|
|
|
return profile.Start(profile.BlockProfile, profile.NoShutdownHook)
|
2016-09-02 05:13:11 +02:00
|
|
|
default:
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-10-10 08:03:10 +02:00
|
|
|
// Global profiler to be used by service go-routine.
|
2016-09-02 05:13:11 +02:00
|
|
|
var globalProfiler interface {
|
|
|
|
Stop()
|
|
|
|
}
|
|
|
|
|
2016-09-19 19:17:46 +02:00
|
|
|
// dump the request into a string in JSON format.
|
|
|
|
func dumpRequest(r *http.Request) string {
|
|
|
|
header := cloneHeader(r.Header)
|
|
|
|
header.Set("Host", r.Host)
|
|
|
|
req := struct {
|
|
|
|
Method string `json:"method"`
|
|
|
|
Path string `json:"path"`
|
|
|
|
Query string `json:"query"`
|
|
|
|
Header http.Header `json:"header"`
|
|
|
|
}{r.Method, r.URL.Path, r.URL.RawQuery, header}
|
|
|
|
jsonBytes, err := json.Marshal(req)
|
|
|
|
if err != nil {
|
|
|
|
return "<error dumping request>"
|
|
|
|
}
|
|
|
|
return string(jsonBytes)
|
|
|
|
}
|