mirror of
https://github.com/octoleo/restic.git
synced 2024-12-25 12:09:59 +00:00
2b39f9f4b2
Among others, this updates minio-go, so that the new "eu-west-3" zone for AWS is supported.
219 lines
6.0 KiB
Go
219 lines
6.0 KiB
Go
package autorest
|
|
|
|
// Copyright 2017 Microsoft Corporation
|
|
//
|
|
// 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.
|
|
|
|
import (
|
|
"bytes"
|
|
"encoding/json"
|
|
"encoding/xml"
|
|
"fmt"
|
|
"io"
|
|
"net/http"
|
|
"net/url"
|
|
"reflect"
|
|
"strings"
|
|
|
|
"github.com/Azure/go-autorest/autorest/adal"
|
|
)
|
|
|
|
// EncodedAs is a series of constants specifying various data encodings
|
|
type EncodedAs string
|
|
|
|
const (
|
|
// EncodedAsJSON states that data is encoded as JSON
|
|
EncodedAsJSON EncodedAs = "JSON"
|
|
|
|
// EncodedAsXML states that data is encoded as Xml
|
|
EncodedAsXML EncodedAs = "XML"
|
|
)
|
|
|
|
// Decoder defines the decoding method json.Decoder and xml.Decoder share
|
|
type Decoder interface {
|
|
Decode(v interface{}) error
|
|
}
|
|
|
|
// NewDecoder creates a new decoder appropriate to the passed encoding.
|
|
// encodedAs specifies the type of encoding and r supplies the io.Reader containing the
|
|
// encoded data.
|
|
func NewDecoder(encodedAs EncodedAs, r io.Reader) Decoder {
|
|
if encodedAs == EncodedAsJSON {
|
|
return json.NewDecoder(r)
|
|
} else if encodedAs == EncodedAsXML {
|
|
return xml.NewDecoder(r)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// CopyAndDecode decodes the data from the passed io.Reader while making a copy. Having a copy
|
|
// is especially useful if there is a chance the data will fail to decode.
|
|
// encodedAs specifies the expected encoding, r provides the io.Reader to the data, and v
|
|
// is the decoding destination.
|
|
func CopyAndDecode(encodedAs EncodedAs, r io.Reader, v interface{}) (bytes.Buffer, error) {
|
|
b := bytes.Buffer{}
|
|
return b, NewDecoder(encodedAs, io.TeeReader(r, &b)).Decode(v)
|
|
}
|
|
|
|
// TeeReadCloser returns a ReadCloser that writes to w what it reads from rc.
|
|
// It utilizes io.TeeReader to copy the data read and has the same behavior when reading.
|
|
// Further, when it is closed, it ensures that rc is closed as well.
|
|
func TeeReadCloser(rc io.ReadCloser, w io.Writer) io.ReadCloser {
|
|
return &teeReadCloser{rc, io.TeeReader(rc, w)}
|
|
}
|
|
|
|
type teeReadCloser struct {
|
|
rc io.ReadCloser
|
|
r io.Reader
|
|
}
|
|
|
|
func (t *teeReadCloser) Read(p []byte) (int, error) {
|
|
return t.r.Read(p)
|
|
}
|
|
|
|
func (t *teeReadCloser) Close() error {
|
|
return t.rc.Close()
|
|
}
|
|
|
|
func containsInt(ints []int, n int) bool {
|
|
for _, i := range ints {
|
|
if i == n {
|
|
return true
|
|
}
|
|
}
|
|
return false
|
|
}
|
|
|
|
func escapeValueStrings(m map[string]string) map[string]string {
|
|
for key, value := range m {
|
|
m[key] = url.QueryEscape(value)
|
|
}
|
|
return m
|
|
}
|
|
|
|
func ensureValueStrings(mapOfInterface map[string]interface{}) map[string]string {
|
|
mapOfStrings := make(map[string]string)
|
|
for key, value := range mapOfInterface {
|
|
mapOfStrings[key] = ensureValueString(value)
|
|
}
|
|
return mapOfStrings
|
|
}
|
|
|
|
func ensureValueString(value interface{}) string {
|
|
if value == nil {
|
|
return ""
|
|
}
|
|
switch v := value.(type) {
|
|
case string:
|
|
return v
|
|
case []byte:
|
|
return string(v)
|
|
default:
|
|
return fmt.Sprintf("%v", v)
|
|
}
|
|
}
|
|
|
|
// MapToValues method converts map[string]interface{} to url.Values.
|
|
func MapToValues(m map[string]interface{}) url.Values {
|
|
v := url.Values{}
|
|
for key, value := range m {
|
|
x := reflect.ValueOf(value)
|
|
if x.Kind() == reflect.Array || x.Kind() == reflect.Slice {
|
|
for i := 0; i < x.Len(); i++ {
|
|
v.Add(key, ensureValueString(x.Index(i)))
|
|
}
|
|
} else {
|
|
v.Add(key, ensureValueString(value))
|
|
}
|
|
}
|
|
return v
|
|
}
|
|
|
|
// AsStringSlice method converts interface{} to []string. This expects a
|
|
//that the parameter passed to be a slice or array of a type that has the underlying
|
|
//type a string.
|
|
func AsStringSlice(s interface{}) ([]string, error) {
|
|
v := reflect.ValueOf(s)
|
|
if v.Kind() != reflect.Slice && v.Kind() != reflect.Array {
|
|
return nil, NewError("autorest", "AsStringSlice", "the value's type is not an array.")
|
|
}
|
|
stringSlice := make([]string, 0, v.Len())
|
|
|
|
for i := 0; i < v.Len(); i++ {
|
|
stringSlice = append(stringSlice, v.Index(i).String())
|
|
}
|
|
return stringSlice, nil
|
|
}
|
|
|
|
// String method converts interface v to string. If interface is a list, it
|
|
// joins list elements using the seperator. Note that only sep[0] will be used for
|
|
// joining if any separator is specified.
|
|
func String(v interface{}, sep ...string) string {
|
|
if len(sep) == 0 {
|
|
return ensureValueString(v)
|
|
}
|
|
stringSlice, ok := v.([]string)
|
|
if ok == false {
|
|
var err error
|
|
stringSlice, err = AsStringSlice(v)
|
|
if err != nil {
|
|
panic(fmt.Sprintf("autorest: Couldn't convert value to a string %s.", err))
|
|
}
|
|
}
|
|
return ensureValueString(strings.Join(stringSlice, sep[0]))
|
|
}
|
|
|
|
// Encode method encodes url path and query parameters.
|
|
func Encode(location string, v interface{}, sep ...string) string {
|
|
s := String(v, sep...)
|
|
switch strings.ToLower(location) {
|
|
case "path":
|
|
return pathEscape(s)
|
|
case "query":
|
|
return queryEscape(s)
|
|
default:
|
|
return s
|
|
}
|
|
}
|
|
|
|
func pathEscape(s string) string {
|
|
return strings.Replace(url.QueryEscape(s), "+", "%20", -1)
|
|
}
|
|
|
|
func queryEscape(s string) string {
|
|
return url.QueryEscape(s)
|
|
}
|
|
|
|
// ChangeToGet turns the specified http.Request into a GET (it assumes it wasn't).
|
|
// This is mainly useful for long-running operations that use the Azure-AsyncOperation
|
|
// header, so we change the initial PUT into a GET to retrieve the final result.
|
|
func ChangeToGet(req *http.Request) *http.Request {
|
|
req.Method = "GET"
|
|
req.Body = nil
|
|
req.ContentLength = 0
|
|
req.Header.Del("Content-Length")
|
|
return req
|
|
}
|
|
|
|
// IsTokenRefreshError returns true if the specified error implements the TokenRefreshError
|
|
// interface. If err is a DetailedError it will walk the chain of Original errors.
|
|
func IsTokenRefreshError(err error) bool {
|
|
if _, ok := err.(adal.TokenRefreshError); ok {
|
|
return true
|
|
}
|
|
if de, ok := err.(DetailedError); ok {
|
|
return IsTokenRefreshError(de.Original)
|
|
}
|
|
return false
|
|
}
|