init repo

vendor/github.com/alibabacloud-go/tea-utils/service/service.go

@@ -0,0 +1,468 @@
+package service
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"io"
+	"io/ioutil"
+	"net/http"
+	"net/url"
+	"reflect"
+	"runtime"
+	"strconv"
+	"strings"
+	"time"
+
+	"github.com/alibabacloud-go/tea/tea"
+)
+
+var defaultUserAgent = fmt.Sprintf("AlibabaCloud (%s; %s) Golang/%s Core/%s TeaDSL/1", runtime.GOOS, runtime.GOARCH, strings.Trim(runtime.Version(), "go"), "0.01")
+
+type RuntimeOptions struct {
+	Autoretry      *bool   `json:"autoretry" xml:"autoretry"`
+	IgnoreSSL      *bool   `json:"ignoreSSL" xml:"ignoreSSL"`
+	MaxAttempts    *int    `json:"maxAttempts" xml:"maxAttempts"`
+	BackoffPolicy  *string `json:"backoffPolicy" xml:"backoffPolicy"`
+	BackoffPeriod  *int    `json:"backoffPeriod" xml:"backoffPeriod"`
+	ReadTimeout    *int    `json:"readTimeout" xml:"readTimeout"`
+	ConnectTimeout *int    `json:"connectTimeout" xml:"connectTimeout"`
+	LocalAddr      *string `json:"localAddr" xml:"localAddr"`
+	HttpProxy      *string `json:"httpProxy" xml:"httpProxy"`
+	HttpsProxy     *string `json:"httpsProxy" xml:"httpsProxy"`
+	NoProxy        *string `json:"noProxy" xml:"noProxy"`
+	MaxIdleConns   *int    `json:"maxIdleConns" xml:"maxIdleConns"`
+	Socks5Proxy    *string `json:"socks5Proxy" xml:"socks5Proxy"`
+	Socks5NetWork  *string `json:"socks5NetWork" xml:"socks5NetWork"`
+	KeepAlive      *bool   `json:"keepAlive" xml:"keepAlive"`
+}
+
+func (s RuntimeOptions) String() string {
+	return tea.Prettify(s)
+}
+
+func (s RuntimeOptions) GoString() string {
+	return s.String()
+}
+
+func (s *RuntimeOptions) SetAutoretry(v bool) *RuntimeOptions {
+	s.Autoretry = &v
+	return s
+}
+
+func (s *RuntimeOptions) SetIgnoreSSL(v bool) *RuntimeOptions {
+	s.IgnoreSSL = &v
+	return s
+}
+
+func (s *RuntimeOptions) SetMaxAttempts(v int) *RuntimeOptions {
+	s.MaxAttempts = &v
+	return s
+}
+
+func (s *RuntimeOptions) SetBackoffPolicy(v string) *RuntimeOptions {
+	s.BackoffPolicy = &v
+	return s
+}
+
+func (s *RuntimeOptions) SetBackoffPeriod(v int) *RuntimeOptions {
+	s.BackoffPeriod = &v
+	return s
+}
+
+func (s *RuntimeOptions) SetReadTimeout(v int) *RuntimeOptions {
+	s.ReadTimeout = &v
+	return s
+}
+
+func (s *RuntimeOptions) SetConnectTimeout(v int) *RuntimeOptions {
+	s.ConnectTimeout = &v
+	return s
+}
+
+func (s *RuntimeOptions) SetHttpProxy(v string) *RuntimeOptions {
+	s.HttpProxy = &v
+	return s
+}
+
+func (s *RuntimeOptions) SetHttpsProxy(v string) *RuntimeOptions {
+	s.HttpsProxy = &v
+	return s
+}
+
+func (s *RuntimeOptions) SetNoProxy(v string) *RuntimeOptions {
+	s.NoProxy = &v
+	return s
+}
+
+func (s *RuntimeOptions) SetMaxIdleConns(v int) *RuntimeOptions {
+	s.MaxIdleConns = &v
+	return s
+}
+
+func (s *RuntimeOptions) SetLocalAddr(v string) *RuntimeOptions {
+	s.LocalAddr = &v
+	return s
+}
+
+func (s *RuntimeOptions) SetSocks5Proxy(v string) *RuntimeOptions {
+	s.Socks5Proxy = &v
+	return s
+}
+
+func (s *RuntimeOptions) SetSocks5NetWork(v string) *RuntimeOptions {
+	s.Socks5NetWork = &v
+	return s
+}
+
+func (s *RuntimeOptions) SetKeepAlive(v bool) *RuntimeOptions {
+	s.KeepAlive = &v
+	return s
+}
+
+func ReadAsString(body io.Reader) (*string, error) {
+	byt, err := ioutil.ReadAll(body)
+	if err != nil {
+		return tea.String(""), err
+	}
+	r, ok := body.(io.ReadCloser)
+	if ok {
+		r.Close()
+	}
+	return tea.String(string(byt)), nil
+}
+
+func StringifyMapValue(a map[string]interface{}) map[string]*string {
+	res := make(map[string]*string)
+	for key, value := range a {
+		if value != nil {
+			switch value.(type) {
+			case string:
+				res[key] = tea.String(value.(string))
+			default:
+				byt, _ := json.Marshal(value)
+				res[key] = tea.String(string(byt))
+			}
+		}
+	}
+	return res
+}
+
+func AnyifyMapValue(a map[string]*string) map[string]interface{} {
+	res := make(map[string]interface{})
+	for key, value := range a {
+		res[key] = tea.StringValue(value)
+	}
+	return res
+}
+
+func ReadAsBytes(body io.Reader) ([]byte, error) {
+	byt, err := ioutil.ReadAll(body)
+	if err != nil {
+		return nil, err
+	}
+	r, ok := body.(io.ReadCloser)
+	if ok {
+		r.Close()
+	}
+	return byt, nil
+}
+
+func DefaultString(reaStr, defaultStr *string) *string {
+	if reaStr == nil {
+		return defaultStr
+	}
+	return reaStr
+}
+
+func ToJSONString(a interface{}) *string {
+	switch v := a.(type) {
+	case *string:
+		return v
+	case string:
+		return tea.String(v)
+	case []byte:
+		return tea.String(string(v))
+	case io.Reader:
+		byt, err := ioutil.ReadAll(v)
+		if err != nil {
+			return nil
+		}
+		return tea.String(string(byt))
+	}
+	byt, err := json.Marshal(a)
+	if err != nil {
+		return nil
+	}
+	return tea.String(string(byt))
+}
+
+func DefaultNumber(reaNum, defaultNum *int) *int {
+	if reaNum == nil {
+		return defaultNum
+	}
+	return reaNum
+}
+
+func ReadAsJSON(body io.Reader) (result interface{}, err error) {
+	byt, err := ioutil.ReadAll(body)
+	if err != nil {
+		return
+	}
+	if string(byt) == "" {
+		return
+	}
+	r, ok := body.(io.ReadCloser)
+	if ok {
+		r.Close()
+	}
+	d := json.NewDecoder(bytes.NewReader(byt))
+	d.UseNumber()
+	err = d.Decode(&result)
+	return
+}
+
+func GetNonce() *string {
+	return tea.String(getUUID())
+}
+
+func Empty(val *string) *bool {
+	return tea.Bool(val == nil || tea.StringValue(val) == "")
+}
+
+func ValidateModel(a interface{}) error {
+	if a == nil {
+		return nil
+	}
+	err := tea.Validate(a)
+	return err
+}
+
+func EqualString(val1, val2 *string) *bool {
+	return tea.Bool(tea.StringValue(val1) == tea.StringValue(val2))
+}
+
+func EqualNumber(val1, val2 *int) *bool {
+	return tea.Bool(tea.IntValue(val1) == tea.IntValue(val2))
+}
+
+func IsUnset(val interface{}) *bool {
+	if val == nil {
+		return tea.Bool(true)
+	}
+
+	v := reflect.ValueOf(val)
+	if v.Kind() == reflect.Ptr || v.Kind() == reflect.Slice || v.Kind() == reflect.Map {
+		return tea.Bool(v.IsNil())
+	}
+
+	valType := reflect.TypeOf(val)
+	valZero := reflect.Zero(valType)
+	return tea.Bool(valZero == v)
+}
+
+func ToBytes(a *string) []byte {
+	return []byte(tea.StringValue(a))
+}
+
+func AssertAsMap(a interface{}) map[string]interface{} {
+	r := reflect.ValueOf(a)
+	if r.Kind().String() != "map" {
+		panic(fmt.Sprintf("%v is not a map[string]interface{}", a))
+	}
+
+	res := make(map[string]interface{})
+	tmp := r.MapKeys()
+	for _, key := range tmp {
+		res[key.String()] = r.MapIndex(key).Interface()
+	}
+
+	return res
+}
+
+func AssertAsNumber(a interface{}) *int {
+	res := 0
+	switch a.(type) {
+	case int:
+		tmp := a.(int)
+		res = tmp
+	case *int:
+		tmp := a.(*int)
+		res = tea.IntValue(tmp)
+	default:
+		panic(fmt.Sprintf("%v is not a int", a))
+	}
+
+	return tea.Int(res)
+}
+
+func AssertAsBoolean(a interface{}) *bool {
+	res := false
+	switch a.(type) {
+	case bool:
+		tmp := a.(bool)
+		res = tmp
+	case *bool:
+		tmp := a.(*bool)
+		res = tea.BoolValue(tmp)
+	default:
+		panic(fmt.Sprintf("%v is not a bool", a))
+	}
+
+	return tea.Bool(res)
+}
+
+func AssertAsString(a interface{}) *string {
+	res := ""
+	switch a.(type) {
+	case string:
+		tmp := a.(string)
+		res = tmp
+	case *string:
+		tmp := a.(*string)
+		res = tea.StringValue(tmp)
+	default:
+		panic(fmt.Sprintf("%v is not a string", a))
+	}
+
+	return tea.String(res)
+}
+
+func AssertAsBytes(a interface{}) []byte {
+	res, ok := a.([]byte)
+	if !ok {
+		panic(fmt.Sprintf("%v is not []byte", a))
+	}
+	return res
+}
+
+func AssertAsReadable(a interface{}) io.Reader {
+	res, ok := a.(io.Reader)
+	if !ok {
+		panic(fmt.Sprintf("%v is not reader", a))
+	}
+	return res
+}
+
+func AssertAsArray(a interface{}) []interface{} {
+	r := reflect.ValueOf(a)
+	if r.Kind().String() != "array" && r.Kind().String() != "slice" {
+		panic(fmt.Sprintf("%v is not a [x]interface{}", a))
+	}
+	aLen := r.Len()
+	res := make([]interface{}, 0)
+	for i := 0; i < aLen; i++ {
+		res = append(res, r.Index(i).Interface())
+	}
+	return res
+}
+
+func ParseJSON(a *string) interface{} {
+	mapTmp := make(map[string]interface{})
+	d := json.NewDecoder(bytes.NewReader([]byte(tea.StringValue(a))))
+	d.UseNumber()
+	err := d.Decode(&mapTmp)
+	if err == nil {
+		return mapTmp
+	}
+
+	sliceTmp := make([]interface{}, 0)
+	d = json.NewDecoder(bytes.NewReader([]byte(tea.StringValue(a))))
+	d.UseNumber()
+	err = d.Decode(&sliceTmp)
+	if err == nil {
+		return sliceTmp
+	}
+
+	if num, err := strconv.Atoi(tea.StringValue(a)); err == nil {
+		return num
+	}
+
+	if ok, err := strconv.ParseBool(tea.StringValue(a)); err == nil {
+		return ok
+	}
+
+	if floa64tVal, err := strconv.ParseFloat(tea.StringValue(a), 64); err == nil {
+		return floa64tVal
+	}
+	return nil
+}
+
+func ToString(a []byte) *string {
+	return tea.String(string(a))
+}
+
+func ToMap(in interface{}) map[string]interface{} {
+	if in == nil {
+		return nil
+	}
+	res := tea.ToMap(in)
+	return res
+}
+
+func ToFormString(a map[string]interface{}) *string {
+	if a == nil {
+		return tea.String("")
+	}
+	res := ""
+	urlEncoder := url.Values{}
+	for key, value := range a {
+		v := fmt.Sprintf("%v", value)
+		urlEncoder.Add(key, v)
+	}
+	res = urlEncoder.Encode()
+	return tea.String(res)
+}
+
+func GetDateUTCString() *string {
+	return tea.String(time.Now().UTC().Format(http.TimeFormat))
+}
+
+func GetUserAgent(userAgent *string) *string {
+	if userAgent != nil && tea.StringValue(userAgent) != "" {
+		return tea.String(defaultUserAgent + " " + tea.StringValue(userAgent))
+	}
+	return tea.String(defaultUserAgent)
+}
+
+func Is2xx(code *int) *bool {
+	tmp := tea.IntValue(code)
+	return tea.Bool(tmp >= 200 && tmp < 300)
+}
+
+func Is3xx(code *int) *bool {
+	tmp := tea.IntValue(code)
+	return tea.Bool(tmp >= 300 && tmp < 400)
+}
+
+func Is4xx(code *int) *bool {
+	tmp := tea.IntValue(code)
+	return tea.Bool(tmp >= 400 && tmp < 500)
+}
+
+func Is5xx(code *int) *bool {
+	tmp := tea.IntValue(code)
+	return tea.Bool(tmp >= 500 && tmp < 600)
+}
+
+func Sleep(millisecond *int) error {
+	ms := tea.IntValue(millisecond)
+	time.Sleep(time.Duration(ms) * time.Millisecond)
+	return nil
+}
+
+func ToArray(in interface{}) []map[string]interface{} {
+	if tea.BoolValue(IsUnset(in)) {
+		return nil
+	}
+
+	tmp := make([]map[string]interface{}, 0)
+	byt, _ := json.Marshal(in)
+	d := json.NewDecoder(bytes.NewReader(byt))
+	d.UseNumber()
+	err := d.Decode(&tmp)
+	if err != nil {
+		return nil
+	}
+	return tmp
+}

vendor/github.com/alibabacloud-go/tea-utils/service/util.go

@@ -0,0 +1,52 @@
+package service
+
+import (
+	"crypto/md5"
+	"crypto/rand"
+	"encoding/hex"
+	"hash"
+	rand2 "math/rand"
+)
+
+type UUID [16]byte
+
+const numBytes = "1234567890"
+
+func getUUID() (uuidHex string) {
+	uuid := newUUID()
+	uuidHex = hex.EncodeToString(uuid[:])
+	return
+}
+
+func randStringBytes(n int) string {
+	b := make([]byte, n)
+	for i := range b {
+		b[i] = numBytes[rand2.Intn(len(numBytes))]
+	}
+	return string(b)
+}
+
+func newUUID() UUID {
+	ns := UUID{}
+	safeRandom(ns[:])
+	u := newFromHash(md5.New(), ns, randStringBytes(16))
+	u[6] = (u[6] & 0x0f) | (byte(2) << 4)
+	u[8] = (u[8]&(0xff>>2) | (0x02 << 6))
+
+	return u
+}
+
+func newFromHash(h hash.Hash, ns UUID, name string) UUID {
+	u := UUID{}
+	h.Write(ns[:])
+	h.Write([]byte(name))
+	copy(u[:], h.Sum(nil))
+
+	return u
+}
+
+func safeRandom(dest []byte) {
+	if _, err := rand.Read(dest); err != nil {
+		panic(err)
+	}
+}