Commit 5ed2bf44-94a5-4446-ae82-9d1e805ab744/upstream - golang-github-denverdino-aliyungo

+1

-1

.circleci/config.yml less more

1	1	jobs:
2	2	build:
3	3	docker:
4		- image: circleci/golang:1.8
	4	- image: circleci/golang:1.10
5	5	working_directory: /go/src/github.com/denverdino/aliyungo
6	6	steps:
7	7	- checkout

+31

-0

.github/workflows/go.yml less more

	0	name: Go
	1	on: [push]
	2	jobs:
	3
	4	build:
	5	name: Build
	6	runs-on: ubuntu-latest
	7	steps:
	8
	9	- name: Set up Go 1.13
	10	uses: actions/setup-go@v1
	11	with:
	12	go-version: 1.13
	13	id: go
	14
	15	- name: Check out code into the Go module directory
	16	uses: actions/checkout@v1
	17
	18	- name: Get dependencies
	19	run: \|
	20	go get -v -t -d ./...
	21	if [ -f Gopkg.toml ]; then
	22	curl https://raw.githubusercontent.com/golang/dep/master/install.sh \| sh
	23	dep ensure
	24	fi
	25	- name: Run golangci-lint with reviewdog
	26	uses: reviewdog/action-golangci-lint@v1.1.3
	27	with:
	28	github_token: ${{ secrets.github_token }}
	29
	30

+4

-2

.travis.yml less more

0	0	language: go
1
	1	arch:
	2	- AMD64
	3	- ppc64le
2	4	go:
3		- 1.7.4
	5	- 1.10.8
4	6
5	7	# let us have speedy Docker-based Travis workers
6	8	sudo: false

+12

-21

acm/acm.go less more

0	0	package acm
1	1
2	2	import (
	3	"crypto/hmac"
	4	"crypto/sha1"
	5	"encoding/base64"
	6	"errors"
	7	"fmt"
	8	"io/ioutil"
3	9	"net/http"
	10	"net/url"
	11	"strconv"
	12	"strings"
4	13	"time"
5		"fmt"
6		"errors"
7		"io/ioutil"
8		"strings"
9		"encoding/base64"
10		"crypto/sha1"
11		"crypto/hmac"
12		"strconv"
13		"net/url"
14	14	)
15	15
16	16	type Client struct {

65	65	servers := strings.Split(body, "\n")
66	66
67	67	for k, v := range servers {
68		if strings.Index(v, ":") == -1 {
	68	if !strings.Contains(v, ":") {
69	69	c.servers[k] = v + ":8080"
70	70	} else {
71	71	c.servers[k] = v

100	100	timeStamp = timeStamp[:13]
101	101
102	102	spec := "?"
103		if strings.Index(api, "?") != -1 {
	103	if strings.Contains(api, "?") {
104	104	spec = "&"
105	105	}
106	106

147	147	return "", err
148	148	}
149	149
150		byt, err = GbkToUtf8(byt)
151		if err != nil {
152		return "", err
153		}
154
155	150	body := string(byt)
156	151
157	152	if resp.StatusCode != 200 {

180	175	}
181	176
182	177	func (c *Client) Publish(dataId, group, content string) (string, error) {
183		bt, err := Utf8ToGbk([]byte(content))
184		if err != nil {
185		return "", err
186		}
187	178
188	179	return c.callApi("diamond-server/basestone.do?method=syncUpdateAll", map[string]string{
189	180	"tenant": c.NameSpace,
190	181	"dataId": dataId,
191	182	"group": group,
192		"content": string(bt),
	183	"content": content,
193	184	}, "POST")
194	185	}
195	186

+7

-4

acm/acm_test.go less more

0	0	package acm
1	1
2	2	import (
3		"testing"
	3	"fmt"
4	4	"log"
5	5	"os"
6		"fmt"
	6	"testing"
7	7	)
8	8
9	9	func getClient() *Client {

25	25	client := getClient()
26	26	defer client.Delete("test", "test")
27	27
28		_, err := client.Publish("test", "test", "test")
	28	_, err := client.Publish("test", "test", "test测试")
29	29
30	30	if err != nil {
31	31	t.Fatalf("pulish error:%s", err)

49	49	if err != nil {
50	50	t.Error(err)
51	51	}
	52	if ret != "test测试" {
	53	t.Error("wrong respond content")
	54	}
52	55	fmt.Println(ret)
53	56	})
54	57	}
55	58
56	59	func TestClient_Subscribe(t *testing.T) {
57	60	RunWithTest(t, func(client Client, t testing.T) {
58		_, err := client.Subscribe("test", "test","")
	61	_, err := client.Subscribe("test", "test", "")
59	62	if err != nil {
60	63	t.Error(err)
61	64	}

+97

-0

cdn/auth/random_uuid.go less more

	0	package auth
	1
	2	import (
	3	"crypto/rand"
	4	"fmt"
	5	"io"
	6	"os"
	7	"syscall"
	8	"time"
	9	)
	10
	11	const (
	12	// Bits is the number of bits in a UUID
	13	Bits = 128
	14
	15	// Size is the number of bytes in a UUID
	16	Size = Bits / 8
	17
	18	format = "%08x%04x%04x%04x%012x"
	19	)
	20
	21	var (
	22	// Loggerf can be used to override the default logging destination. Such
	23	// log messages in this library should be logged at warning or higher.
	24	Loggerf = func(format string, args ...interface{}) {}
	25	)
	26
	27	// UUID represents a UUID value. UUIDs can be compared and set to other values
	28	// and accessed by byte.
	29	type UUID [Size]byte
	30
	31	// GenerateUUID creates a new, version 4 uuid.
	32	func GenerateUUID() (u UUID) {
	33	const (
	34	// ensures we backoff for less than 450ms total. Use the following to
	35	// select new value, in units of 10ms:
	36	// n*(n+1)/2 = d -> n^2 + n - 2d -> n = (sqrt(8d + 1) - 1)/2
	37	maxretries = 9
	38	backoff = time.Millisecond * 10
	39	)
	40
	41	var (
	42	totalBackoff time.Duration
	43	count int
	44	retries int
	45	)
	46
	47	for {
	48	// This should never block but the read may fail. Because of this,
	49	// we just try to read the random number generator until we get
	50	// something. This is a very rare condition but may happen.
	51	b := time.Duration(retries) * backoff
	52	time.Sleep(b)
	53	totalBackoff += b
	54
	55	n, err := io.ReadFull(rand.Reader, u[count:])
	56	if err != nil {
	57	if retryOnError(err) && retries < maxretries {
	58	count += n
	59	retries++
	60	Loggerf("error generating version 4 uuid, retrying: %v", err)
	61	continue
	62	}
	63
	64	// Any other errors represent a system problem. What did someone
	65	// do to /dev/urandom?
	66	panic(fmt.Errorf("error reading random number generator, retried for %v: %v", totalBackoff.String(), err))
	67	}
	68
	69	break
	70	}
	71
	72	u[6] = (u[6] & 0x0f) \| 0x40 // set version byte
	73	u[8] = (u[8] & 0x3f) \| 0x80 // set high order byte 0b10{8,9,a,b}
	74
	75	return u
	76	}
	77
	78	func (u UUID) String() string {
	79	return fmt.Sprintf(format, u[:4], u[4:6], u[6:8], u[8:10], u[10:])
	80	}
	81
	82	// retryOnError tries to detect whether or not retrying would be fruitful.
	83	func retryOnError(err error) bool {
	84	switch err := err.(type) {
	85	case *os.PathError:
	86	return retryOnError(err.Err) // unpack the target error
	87	case syscall.Errno:
	88	if err == syscall.EPERM {
	89	// EPERM represents an entropy pool exhaustion, a condition under
	90	// which we backoff and retry.
	91	return true
	92	}
	93	}
	94
	95	return false
	96	}

+21

-0

cdn/auth/random_uuid_test.go less more

	0	package auth
	1
	2	import (
	3	"testing"
	4	)
	5
	6	const iterations = 1000
	7
	8	func TestUUID4Generation(t *testing.T) {
	9	for i := 0; i < iterations; i++ {
	10	u := GenerateUUID()
	11
	12	if u[6]&0xf0 != 0x40 {
	13	t.Fatalf("version byte not correctly set: %v, %08b %08b", u, u[6], u[6]&0xf0)
	14	}
	15
	16	if u[8]&0xc0 != 0x80 {
	17	t.Fatalf("top order 8th byte not correctly set: %v, %b", u, u[8])
	18	}
	19	}
	20	}

+80

-0

cdn/auth/sign_url.go less more

	0	package auth
	1
	2	import (
	3	"crypto/md5"
	4	"fmt"
	5	"net/url"
	6	"time"
	7	)
	8
	9	// An URLSigner provides URL signing utilities to sign URLs for Aliyun CDN
	10	// resources.
	11	// authentication document: https://help.aliyun.com/document_detail/85117.html
	12	type URLSigner struct {
	13	authType string
	14	privKey string
	15	}
	16
	17	// NewURLSigner returns a new signer object.
	18	func NewURLSigner(authType string, privKey string) *URLSigner {
	19	return &URLSigner{
	20	authType: authType,
	21	privKey: privKey,
	22	}
	23	}
	24
	25	// Sign returns a signed aliyuncdn url based on authentication type
	26	func (s URLSigner) Sign(uri string, expires time.Time) (string, error) {
	27	r, err := url.Parse(uri)
	28	if err != nil {
	29	return "", fmt.Errorf("unable to parse url: %s", uri)
	30	}
	31
	32	switch s.authType {
	33	case "a":
	34	return aTypeSign(r, s.privKey, expires), nil
	35	case "b":
	36	return bTypeSign(r, s.privKey, expires), nil
	37	case "c":
	38	return cTypeSign(r, s.privKey, expires), nil
	39	default:
	40	return "", fmt.Errorf("invalid authentication type")
	41	}
	42	}
	43
	44	// sign by A type authentication method.
	45	// authentication document: https://help.aliyun.com/document_detail/85113.html
	46	func aTypeSign(r *url.URL, privateKey string, expires time.Time) string {
	47	//rand is a random uuid without "-"
	48	rand := GenerateUUID().String()
	49	// not use, "0" by default
	50	uid := "0"
	51	secret := fmt.Sprintf("%s-%d-%s-%s-%s", r.Path, expires.Unix(), rand, uid, privateKey)
	52	hashValue := md5.Sum([]byte(secret))
	53	authKey := fmt.Sprintf("%d-%s-%s-%x", expires.Unix(), rand, uid, hashValue)
	54	if r.RawQuery == "" {
	55	return fmt.Sprintf("%s?auth_key=%s", r.String(), authKey)
	56	}
	57	return fmt.Sprintf("%s&auth_key=%s", r.String(), authKey)
	58
	59	}
	60
	61	// sign by B type authentication method.
	62	// authentication document: https://help.aliyun.com/document_detail/85114.html
	63	func bTypeSign(r *url.URL, privateKey string, expires time.Time) string {
	64	formatExp := expires.Format("200601021504")
	65	secret := privateKey + formatExp + r.Path
	66	hashValue := md5.Sum([]byte(secret))
	67	signURL := fmt.Sprintf("%s://%s/%s/%x%s?%s", r.Scheme, r.Host, formatExp, hashValue, r.Path, r.RawQuery)
	68	return signURL
	69	}
	70
	71	// sign by C type authentication method.
	72	// authentication document: https://help.aliyun.com/document_detail/85115.html
	73	func cTypeSign(r *url.URL, privateKey string, expires time.Time) string {
	74	hexExp := fmt.Sprintf("%x", expires.Unix())
	75	secret := privateKey + r.Path + hexExp
	76	hashValue := md5.Sum([]byte(secret))
	77	signURL := fmt.Sprintf("%s://%s/%x/%s%s?%s", r.Scheme, r.Host, hashValue, hexExp, r.Path, r.RawQuery)
	78	return signURL
	79	}

+53

-0

cdn/auth/sign_url_test.go less more

	0	package auth
	1
	2	import (
	3	"crypto/md5"
	4	"fmt"
	5	"net/url"
	6	"reflect"
	7	"testing"
	8	"time"
	9	)
	10
	11	var (
	12	testSignTime = time.Unix(1541064730, 0)
	13	testPrivKey = "12345678"
	14	)
	15
	16	func assertEqual(t *testing.T, name string, x, y interface{}) {
	17	if !reflect.DeepEqual(x, y) {
	18	t.Errorf("%s: Not equal! Expected='%v', Actual='%v'\n", name, x, y)
	19	t.FailNow()
	20	}
	21	}
	22
	23	func TestAtypeAuth(t *testing.T) {
	24	r, _ := url.Parse("https://example.com/a?foo=bar")
	25	url := aTypeTest(r, testPrivKey, testSignTime)
	26	assertEqual(t, "testTypeA", "https://example.com/a?foo=bar&auth_key=1541064730-0-0-f9dd5ed1e274ab4b1d5f5745344bf28b", url)
	27	}
	28
	29	func TestBtypeAuth(t *testing.T) {
	30	signer := NewURLSigner("b", testPrivKey)
	31	url, _ := signer.Sign("https://example.com/a?foo=bar", testSignTime)
	32	assertEqual(t, "testTypeB", "https://example.com/201811011732/3a19d83a89ccb00a73212420791b0123/a?foo=bar", url)
	33	}
	34
	35	func TestCtypeAuth(t *testing.T) {
	36	signer := NewURLSigner("c", testPrivKey)
	37	url, _ := signer.Sign("https://example.com/a?foo=bar", testSignTime)
	38	assertEqual(t, "testTypeC", "https://example.com/7d6b308ce87beb16d9dba32d741220f6/5bdac81a/a?foo=bar", url)
	39	}
	40
	41	func aTypeTest(r *url.URL, privateKey string, expires time.Time) string {
	42	//rand equals "0" in test case
	43	rand := "0"
	44	uid := "0"
	45	secret := fmt.Sprintf("%s-%d-%s-%s-%s", r.Path, expires.Unix(), rand, uid, privateKey)
	46	hashValue := md5.Sum([]byte(secret))
	47	authKey := fmt.Sprintf("%d-%s-%s-%x", expires.Unix(), rand, uid, hashValue)
	48	if r.RawQuery == "" {
	49	return fmt.Sprintf("%s?auth_key=%s", r.String(), authKey)
	50	}
	51	return fmt.Sprintf("%s&auth_key=%s", r.String(), authKey)
	52	}

+2

-2

cdn/types.go less more

8	8	const (
9	9	Web = "web"
10	10	Download = "download"
11		video = "video"
	11	Video = "video"
12	12	LiveStream = "liveStream"
13	13	Ipaddr = "ipaddr"
14	14	Domain = "domain"

26	26	AccessControlMaxAge = "Access-Control-Max-Age"
27	27	)
28	28
29		var CdnTypes = []string{Web, Download, video, LiveStream}
	29	var CdnTypes = []string{Web, Download, Video, LiveStream}
30	30	var SourceTypes = []string{Ipaddr, Domain, OSS}
31	31	var Scopes = []string{Domestic, Overseas, Global}
32	32	var HeaderKeys = []string{ContentType, CacheControl, ContentDisposition, ContentLanguage, Expires, AccessControlAllowMethods, AccessControlAllowOrigin, AccessControlMaxAge}

+76

-0

cen/client.go less more

	0	package cen
	1
	2	import (
	3	"os"
	4
	5	"github.com/denverdino/aliyungo/common"
	6	)
	7
	8	// Interval for checking status in WaitForXXX method
	9	const DefaultWaitForInterval = 5
	10
	11	// Default timeout value for WaitForXXX method
	12	const DefaultTimeout = 60
	13
	14	type Client struct {
	15	common.Client
	16	}
	17
	18	const (
	19	// CENDefaultEndpoint is the default API endpoint of CEN services
	20	CENDefaultEndpoint = "https://cbn.aliyuncs.com"
	21	CENAPIVersion = "2017-09-12"
	22	CENServiceCode = "cen"
	23	)
	24
	25	// ---------------------------------------
	26	// NewCENClient creates a new instance of CEN client
	27	// ---------------------------------------
	28	func NewCENClient(accessKeyId, accessKeySecret string, regionID common.Region) *Client {
	29	return NewCENClientWithSecurityToken(accessKeyId, accessKeySecret, "", regionID)
	30	}
	31
	32	func NewCENClientWithSecurityToken(accessKeyId string, accessKeySecret string, securityToken string, regionID common.Region) *Client {
	33	endpoint := os.Getenv("CEN_ENDPOINT")
	34	if endpoint == "" {
	35	endpoint = CENDefaultEndpoint
	36	}
	37
	38	return NewCENClientWithEndpointAndSecurityToken(endpoint, accessKeyId, accessKeySecret, securityToken, regionID)
	39	}
	40
	41	//only for Hangzhou Regional Domain
	42	func NewCENClientWithSecurityToken4RegionalDomain(accessKeyId string, accessKeySecret string, securityToken string, regionID common.Region) *Client {
	43	endpoint := os.Getenv("CEN_ENDPOINT")
	44	if endpoint == "" {
	45	endpoint = CENDefaultEndpoint
	46	}
	47
	48	return NewCENClientWithEndpointAndSecurityToken4RegionalDomain(endpoint, accessKeyId, accessKeySecret, securityToken, regionID)
	49	}
	50
	51	func NewCENClientWithEndpointAndSecurityToken(endpoint string, accessKeyId string, accessKeySecret string, securityToken string, regionID common.Region) *Client {
	52	client := &Client{}
	53	client.WithEndpoint(endpoint).
	54	WithVersion(CENAPIVersion).
	55	WithAccessKeyId(accessKeyId).
	56	WithAccessKeySecret(accessKeySecret).
	57	WithSecurityToken(securityToken).
	58	WithServiceCode(CENServiceCode).
	59	WithRegionID(regionID).
	60	InitClient()
	61	return client
	62	}
	63
	64	func NewCENClientWithEndpointAndSecurityToken4RegionalDomain(endpoint string, accessKeyId string, accessKeySecret string, securityToken string, regionID common.Region) *Client {
	65	client := &Client{}
	66	client.WithEndpoint(endpoint).
	67	WithVersion(CENAPIVersion).
	68	WithAccessKeyId(accessKeyId).
	69	WithAccessKeySecret(accessKeySecret).
	70	WithSecurityToken(securityToken).
	71	WithServiceCode(CENServiceCode).
	72	WithRegionID(regionID).
	73	InitClient4RegionalDomain()
	74	return client
	75	}

+116

-0

cen/route.go less more

	0	package cen
	1
	2	import (
	3	"log"
	4
	5	"github.com/denverdino/aliyungo/common"
	6	)
	7
	8	type PublishRouteEntriesArgs struct {
	9	CenId string
	10	ChildInstanceId string
	11	ChildInstanceRegionId string
	12	ChildInstanceRouteTableId string
	13	ChildInstanceType string
	14	DestinationCidrBlock string
	15	}
	16
	17	type DescribePublishedRouteEntriesArgs struct {
	18	common.Pagination
	19	CenId string
	20	ChildInstanceId string
	21	ChildInstanceRegionId string
	22	ChildInstanceType string
	23	ChildInstanceRouteTableId string
	24	DestinationCidrBlock string
	25	}
	26
	27	type DescribePublishedRouteEntriesResponse struct {
	28	common.Response
	29	common.PaginationResult
	30	PublishedRouteEntries struct {
	31	PublishedRouteEntry []PublishedRouteEntry
	32	}
	33	}
	34
	35	type ConflictStatus string
	36	type NextHopType string
	37
	38	const (
	39	ConflictStatusConflict = ConflictStatus("conflict")
	40	ConflictStatusOverflow = ConflictStatus("overflow")
	41	ConflictStatusProhibited = ConflictStatus("prohibited")
	42	)
	43
	44	const (
	45	NextHopTypeInstance = NextHopType("Instance")
	46	NextHopTypeHaVip = NextHopType("HaVip")
	47	NextHopTypeRouterInterface = NextHopType("RouterInterface")
	48	)
	49
	50	type PublishStatus string
	51
	52	const (
	53	PublishStatusPublished = PublishStatus("Published")
	54	PublishStatusNotPublished = PublishStatus("NonPublished")
	55	)
	56
	57	type RouteType string
	58
	59	const (
	60	RouteTypeSystem = RouteType("System")
	61	RouteTypeCustom = RouteType("Custom")
	62	RouteTypeBGP = RouteType("BGP")
	63	)
	64
	65	type PublishedRouteEntry struct {
	66	ChildInstanceRouteTableId string
	67	Conflicts struct {
	68	Conflict []Conflict
	69	}
	70	DestinationCidrBlock string
	71	NextHopId string
	72
	73	NextHopType string
	74	OperationalMode bool
	75	PublishStatus string
	76	RouteType string
	77	}
	78
	79	type Conflict struct {
	80	DestinationCidrBlock string
	81	InstanceId string
	82	InstanceType string
	83	RegionId string
	84	Status string
	85	}
	86
	87	// PublishRouteEntries publish route
	88	//
	89	// You can read doc at https://help.aliyun.com/document_detail/85470.html
	90	func (client Client) PublishRouteEntries(args PublishRouteEntriesArgs) error {
	91	response := &common.Response{}
	92	err := client.Invoke("PublishRouteEntries", args, response)
	93	if err != nil {
	94	log.Printf("PublishRouteEntries: %s, %s\n", response.RequestId, err.Error())
	95	}
	96	return err
	97	}
	98
	99	// DescribePublishedRouteEntries describe published route
	100	//
	101	// You can read doc at https://help.aliyun.com/document_detail/85472.html
	102	func (client *Client) DescribePublishedRouteEntries(
	103	args *DescribePublishedRouteEntriesArgs,
	104	) (response *DescribePublishedRouteEntriesResponse, err error) {
	105
	106	response = &DescribePublishedRouteEntriesResponse{}
	107
	108	err = client.Invoke("DescribePublishedRouteEntries", args, response)
	109
	110	if err != nil {
	111	log.Printf("DescribePublishedRouteEntries: %v, %v\n", args, response)
	112	}
	113
	114	return response, err
	115	}

+50

-0

cen/route_test.go less more

	0	package cen
	1
	2	import (
	3	"encoding/json"
	4	"fmt"
	5	"testing"
	6	)
	7
	8	var (
	9	ak = ""
	10	sec = ""
	11	)
	12
	13	func TestDescribePublishedRoute(t *testing.T) {
	14	client := NewCENClient(ak, sec, "cn-shanghai")
	15	res, err := client.DescribePublishedRouteEntries(
	16	&DescribePublishedRouteEntriesArgs{
	17	CenId: "cen-qhu4rn3cknrg5o4qhl",
	18	ChildInstanceType: "VPC",
	19	ChildInstanceRegionId: "cn-shanghai",
	20	ChildInstanceRouteTableId: "vtb-uf699blmsutb4wkbzqcmt",
	21	ChildInstanceId: "vpc-uf6ch2jfder4r0z51vtox",
	22	},
	23	)
	24	if err != nil {
	25	t.Errorf("describe: %s", err.Error())
	26	t.FailNow()
	27	}
	28	fmt.Printf("Result: %+v", res)
	29	b, err := json.MarshalIndent(res, "", " ")
	30	fmt.Printf("%s", b)
	31	}
	32
	33	func TestPublishedRoute(t *testing.T) {
	34	client := NewCENClient(ak, sec, "cn-shanghai")
	35	err := client.PublishRouteEntries(
	36	&PublishRouteEntriesArgs{
	37	CenId: "cen-qhu4rn3cknrg5o4qhl",
	38	ChildInstanceType: "VPC",
	39	ChildInstanceRegionId: "cn-shanghai",
	40	ChildInstanceRouteTableId: "vtb-uf6nco4vj87ly556c589f",
	41	ChildInstanceId: "vpc-uf6ch2jfder4r0z51vtox",
	42	DestinationCidrBlock: "192.168.0.0/26",
	43	},
	44	)
	45	if err != nil {
	46	t.Errorf("publish: %s", err.Error())
	47	t.FailNow()
	48	}
	49	}

+8

-0

cms/client.go less more

30	30
31	31	func (client *Client) SetDebug(debug bool) {
32	32	client.debug = debug
	33	}
	34
	35	// SetTransport sets transport to the http client
	36	func (client *Client) SetTransport(transport http.RoundTripper) {
	37	if client.httpClient == nil {
	38	client.httpClient = &http.Client{}
	39	}
	40	client.httpClient.Transport = transport
33	41	}
34	42
35	43	const (

+157

-35

common/client.go less more

6	6	"fmt"
7	7	"io/ioutil"
8	8	"log"
	9	"net"
9	10	"net/http"
10	11	"net/url"
11	12	"os"

47	48	ak += "&"
48	49	}
49	50	client.AccessKeySecret = ak
50		client.debug = false
51		handshakeTimeout, err := strconv.Atoi(os.Getenv("TLSHandshakeTimeout"))
52		if err != nil {
53		handshakeTimeout = 0
54		}
55		if handshakeTimeout == 0 {
56		client.httpClient = &http.Client{}
57		} else {
58		t := &http.Transport{
59		TLSHandshakeTimeout: time.Duration(handshakeTimeout) * time.Second}
60		client.httpClient = &http.Client{Transport: t}
61		}
	51	client.InitClient()
62	52	client.endpoint = endpoint
63	53	client.version = version
64	54	}

70	60	client.regionID = regionID
71	61	}
72	62
	63	// Initialize properties of a client instance including regionID
	64	//only for hz regional Domain
	65	func (client *Client) NewInit4RegionalDomain(endpoint, version, accessKeyId, accessKeySecret, serviceCode string, regionID Region) {
	66	client.Init(endpoint, version, accessKeyId, accessKeySecret)
	67	client.serviceCode = serviceCode
	68	client.regionID = regionID
	69
	70	client.setEndpoint4RegionalDomain(client.regionID, client.serviceCode, client.AccessKeyId, client.AccessKeySecret, client.securityToken)
	71	}
	72
73	73	// Intialize client object when all properties are ready
74	74	func (client Client) InitClient() Client {
75	75	client.debug = false
76		handshakeTimeout, err := strconv.Atoi(os.Getenv("TLSHandshakeTimeout"))
77		if err != nil {
78		handshakeTimeout = 0
79		}
80		if handshakeTimeout == 0 {
81		client.httpClient = &http.Client{}
82		} else {
83		t := &http.Transport{
84		TLSHandshakeTimeout: time.Duration(handshakeTimeout) * time.Second}
85		client.httpClient = &http.Client{Transport: t}
86		}
	76
	77	// create DefaultTransport manully, because transport doesn't has clone method in go 1.10
	78	t :=&http.Transport{
	79	Proxy: http.ProxyFromEnvironment,
	80	DialContext: (&net.Dialer{
	81	Timeout: 30 * time.Second,
	82	KeepAlive: 30 * time.Second,
	83	DualStack: true,
	84	}).DialContext,
	85	MaxIdleConns: 100,
	86	IdleConnTimeout: 90 * time.Second,
	87	TLSHandshakeTimeout: 10 * time.Second,
	88	ExpectContinueTimeout: 1 * time.Second,
	89	}
	90
	91	handshakeTimeoutStr, ok := os.LookupEnv("TLSHandshakeTimeout")
	92	if ok {
	93	handshakeTimeout, err := strconv.Atoi(handshakeTimeoutStr)
	94	if err != nil {
	95	log.Printf("Get TLSHandshakeTimeout from env error: %v.", err)
	96	} else {
	97	t.TLSHandshakeTimeout = time.Duration(handshakeTimeout) * time.Second
	98	}
	99	}
	100
	101	responseHeaderTimeoutStr, ok := os.LookupEnv("ResponseHeaderTimeout")
	102	if ok {
	103	responseHeaderTimeout, err := strconv.Atoi(responseHeaderTimeoutStr)
	104	if err != nil {
	105	log.Printf("Get ResponseHeaderTimeout from env error: %v.", err)
	106	} else {
	107	t.ResponseHeaderTimeout = time.Duration(responseHeaderTimeout) * time.Second
	108	}
	109	}
	110
	111	expectContinueTimeoutStr, ok := os.LookupEnv("ExpectContinueTimeout")
	112	if ok {
	113	expectContinueTimeout, err := strconv.Atoi(expectContinueTimeoutStr)
	114	if err != nil {
	115	log.Printf("Get ExpectContinueTimeout from env error: %v.", err)
	116	} else {
	117	t.ExpectContinueTimeout = time.Duration(expectContinueTimeout) * time.Second
	118	}
	119	}
	120
	121	idleConnTimeoutStr, ok := os.LookupEnv("IdleConnTimeout")
	122	if ok {
	123	idleConnTimeout, err := strconv.Atoi(idleConnTimeoutStr)
	124	if err != nil {
	125	log.Printf("Get IdleConnTimeout from env error: %v.", err)
	126	} else {
	127	t.IdleConnTimeout = time.Duration(idleConnTimeout) * time.Second
	128	}
	129	}
	130
	131	client.httpClient = &http.Client{
	132	Transport: t,
	133	}
	134
	135	httpTimeoutStr, ok := os.LookupEnv("HttpTimeout")
	136	if ok {
	137	httpTimeout, err := strconv.Atoi(httpTimeoutStr)
	138	if err != nil {
	139	log.Printf("Get HttpTimeout from env error: %v.", err)
	140	} else {
	141	client.httpClient.Timeout = time.Duration(httpTimeout) * time.Second
	142	}
	143	}
	144
	145	return client
	146	}
	147
	148	// Intialize client object when all properties are ready
	149	//only for regional domain hz
	150	func (client Client) InitClient4RegionalDomain() Client {
	151	client.InitClient()
	152	//set endpoint
	153	client.setEndpoint4RegionalDomain(client.regionID, client.serviceCode, client.AccessKeyId, client.AccessKeySecret, client.securityToken)
87	154	return client
88	155	}
89	156

104	171	locationClient := NewLocationClient(accessKeyId, accessKeySecret, securityToken)
105	172	locationClient.SetDebug(true)
106	173	ep := locationClient.DescribeOpenAPIEndpoint(region, serviceCode)
107		if ep == "" {
108		ep = loadEndpointFromFile(region, serviceCode)
109		}
	174
	175	if ep != "" {
	176	client.endpoint = ep
	177	}
	178	}
	179
	180	// Get openapi endpoint accessed by ecs instance.
	181	// For some UnitRegions, the endpoint pattern is https://[product].[regionid].aliyuncs.com
	182	// For some CentralRegions, the endpoint pattern is https://[product].vpc-proxy.aliyuncs.com
	183	// The other region, the endpoint pattern is https://[product]-vpc.[regionid].aliyuncs.com
	184	func (client *Client) setEndpoint4RegionalDomain(region Region, serviceCode, accessKeyId, accessKeySecret, securityToken string) {
	185	if endpoint, ok := CentralDomainServices[serviceCode]; ok {
	186	client.endpoint = fmt.Sprintf("https://%s", endpoint)
	187	return
	188	}
	189	for _, service := range RegionalDomainServices {
	190	if service == serviceCode {
	191	if ep, ok := UnitRegions[region]; ok {
	192	client.endpoint = fmt.Sprintf("https://%s.%s.aliyuncs.com", serviceCode, ep)
	193	return
	194	}
	195
	196	client.endpoint = fmt.Sprintf("https://%s%s.%s.aliyuncs.com", serviceCode, "-vpc", region)
	197	return
	198	}
	199	}
	200	locationClient := NewLocationClient(accessKeyId, accessKeySecret, securityToken)
	201	locationClient.SetDebug(true)
	202	ep := locationClient.DescribeOpenAPIEndpoint(region, serviceCode)
110	203
111	204	if ep != "" {
112	205	client.endpoint = ep

207	300	client.endpoint = endpoint
208	301	}
209	302
	303	func (client *Client) GetEndpoint() string {
	304	return client.endpoint
	305	}
	306
210	307	// SetEndpoint sets custom version
211	308	func (client *Client) SetVersion(version string) {
212	309	client.version = version

256	353	client.securityToken = securityToken
257	354	}
258	355
	356	// SetTransport sets transport to the http client
	357	func (client *Client) SetTransport(transport http.RoundTripper) {
	358	if client.httpClient == nil {
	359	client.httpClient = &http.Client{}
	360	}
	361	client.httpClient.Transport = transport
	362	}
	363
259	364	func (client *Client) initEndpoint() error {
260	365	// if set any value to "CUSTOMIZED_ENDPOINT" could skip location service.
261	366	// example: export CUSTOMIZED_ENDPOINT=true

263	368	return nil
264	369	}
265	370
	371	if client.endpoint != "" {
	372	return nil
	373	}
	374
266	375	if client.serviceCode != "" && client.regionID != "" {
267	376	endpoint := client.getEndpointByLocation()
268	377	if endpoint == "" {

280	389	}
281	390
282	391	//init endpoint
283		if err := client.initEndpoint(); err != nil {
284		return err
285		}
	392	//if err := client.initEndpoint(); err != nil {
	393	// return err
	394	//}
286	395
287	396	request := Request{}
288	397	request.init(client.version, action, client.AccessKeyId, client.securityToken, client.regionID)

329	438	if client.debug {
330	439	var prettyJSON bytes.Buffer
331	440	err = json.Indent(&prettyJSON, body, "", " ")
332		log.Println(string(prettyJSON.Bytes()))
	441	if err != nil {
	442	log.Printf("Failed in json.Indent: %v\n", err)
	443	} else {
	444	log.Printf("JSON body: %s\n", prettyJSON.String())
	445	}
333	446	}
334	447
335	448	if statusCode >= 400 && statusCode <= 599 {
336	449	errorResponse := ErrorResponse{}
337	450	err = json.Unmarshal(body, &errorResponse)
	451	if err != nil {
	452	log.Printf("Failed in json.Unmarshal: %v\n", err)
	453	}
338	454	ecsError := &Error{
339	455	ErrorResponse: errorResponse,
340	456	StatusCode: statusCode,

408	524	if client.debug {
409	525	var prettyJSON bytes.Buffer
410	526	err = json.Indent(&prettyJSON, body, "", " ")
411		log.Println(string(prettyJSON.Bytes()))
	527	if err != nil {
	528	log.Printf("Failed in json.Indent: %v\n", err)
	529	}
	530	log.Println(prettyJSON.String())
412	531	}
413	532
414	533	if statusCode >= 400 && statusCode <= 599 {
415	534	errorResponse := ErrorResponse{}
416	535	err = json.Unmarshal(body, &errorResponse)
	536	if err != nil {
	537	log.Printf("Failed in json.Unmarshal: %v\n", err)
	538	}
417	539	ecsError := &Error{
418	540	ErrorResponse: errorResponse,
419	541	StatusCode: statusCode,

439	561	}
440	562
441	563	//init endpoint
442		if err := client.initEndpoint(); err != nil {
443		return err
444		}
	564	//if err := client.initEndpoint(); err != nil {
	565	// return err
	566	//}
445	567
446	568	request := Request{}
447	569	request.init(client.version, action, client.AccessKeyId, client.securityToken, client.regionID)

497	619	if client.debug {
498	620	var prettyJSON bytes.Buffer
499	621	err = json.Indent(&prettyJSON, body, "", " ")
500		log.Println(string(prettyJSON.Bytes()))
	622	log.Println(prettyJSON.String())
501	623	}
502	624
503	625	if statusCode >= 400 && statusCode <= 599 {

+76

-1

common/client_test.go less more

0	0	package common
1	1
2		import "os"
	2	import (
	3	"fmt"
	4	"net/http"
	5	"os"
	6	"testing"
	7	)
3	8
4	9	var (
5	10	TestAccessKeyId = os.Getenv("AccessKeyId")

17	22	}
18	23	return testDebugClient
19	24	}
	25
	26	func TestClient_SetTransport(t *testing.T) {
	27	client := NewTestClientForDebug()
	28	transport := &myTransport{}
	29	client.SetTransport(transport)
	30	if client.httpClient.Transport.(*myTransport) != transport {
	31	t.Fail()
	32	}
	33	}
	34
	35	type myTransport struct{}
	36
	37	func (m myTransport) RoundTrip(req http.Request) (*http.Response, error) {
	38	return http.DefaultTransport.RoundTrip(req)
	39	}
	40
	41	func Test_InitClient4RegionalDomain(t *testing.T) {
	42
	43	var tests = []struct {
	44	service string
	45	version string
	46	endpoint string
	47	}{
	48	{"ecs", "2014-05-26", "https://ecs-cn-hangzhou.aliyuncs.com"},
	49	{"pvtz", "2018-01-01", "https://pvtz.aliyuncs.com"},
	50	{"slb", "2014-05-15", "https://slb.aliyuncs.com"},
	51	{"vpc", "2016-04-28", "https://vpc.aliyuncs.com"},
	52	}
	53
	54	for _, test := range tests {
	55	for _, region := range ValidRegions {
	56	if region == Qingdao \|\| region == HangZhouFinance {
	57	continue
	58	}
	59
	60	client := &Client{}
	61	client.SetDebug(true)
	62	client.WithEndpoint(test.endpoint).
	63	WithVersion(test.version).
	64	WithAccessKeyId(TestAccessKeyId).
	65	WithAccessKeySecret(TestAccessKeySecret).
	66	WithSecurityToken(TestSecurityToken).
	67	WithServiceCode(test.service).
	68	WithRegionID(region).
	69	InitClient4RegionalDomain()
	70
	71	if endpoint, ok := CentralDomainServices[test.service]; ok {
	72	domain := fmt.Sprintf("https://%s", endpoint)
	73	if client.endpoint != domain {
	74	t.Fail()
	75	}
	76	continue
	77	}
	78
	79	if ep, ok := UnitRegions[region]; ok {
	80	domain := fmt.Sprintf("https://%s.%s.aliyuncs.com", test.service, ep)
	81	if client.endpoint != domain {
	82	t.Fail()
	83	}
	84	continue
	85	}
	86
	87	domain := fmt.Sprintf("https://%s%s.%s.aliyuncs.com", test.service, "-vpc", region)
	88	if client.endpoint != domain {
	89	t.Fail()
	90	}
	91	}
	92
	93	}
	94	}

+24

-12

common/endpoint.go less more

3	3	"encoding/xml"
4	4	"fmt"
5	5	"io/ioutil"
	6	"log"
6	7	"os"
7	8	"strings"
	9	"sync"
8	10	"time"
9		"log"
10	11	)
11	12
12	13	const (

18	19	)
19	20
20	21	var (
21		endpoints = make(map[Region]map[string]string)
	22	//endpoints = make(map[Region]map[string]string)
	23
	24	endpoints = sync.Map{}
22	25
23	26	SpecailEnpoints = map[Region]map[string]string{
24	27	APNorthEast1: {

50	53	"slb": "https://slb.eu-central-1.aliyuncs.com",
51	54	"rds": "https://rds.eu-central-1.aliyuncs.com",
52	55	"vpc": "https://vpc.eu-central-1.aliyuncs.com",
	56	},
	57	EUWest1: {
	58	"ecs": "https://ecs.eu-west-1.aliyuncs.com",
	59	"slb": "https://slb.eu-west-1.aliyuncs.com",
	60	"rds": "https://rds.eu-west-1.aliyuncs.com",
	61	"vpc": "https://vpc.eu-west-1.aliyuncs.com",
53	62	},
54	63	Zhangjiakou: {
55	64	"ecs": "https://ecs.cn-zhangjiakou.aliyuncs.com",

122	131	}
123	132
124	133	func getProductRegionEndpoint(region Region, serviceCode string) string {
125		if sp, ok := endpoints[region]; ok {
126		if endpoint, ok := sp[serviceCode]; ok {
127		return endpoint
128		}
129		}
130
	134
	135	if sp, ok := endpoints.Load(region); ok {
	136	spt, ok := sp.(*sync.Map)
	137	if ok {
	138	if endp, ok := spt.Load(serviceCode); ok {
	139	return endp.(string)
	140	}
	141	}
	142	}
131	143	return ""
132	144	}
133	145
134	146	func setProductRegionEndpoint(region Region, serviceCode string, endpoint string) {
135		endpoints[region] = map[string]string{
136		serviceCode: endpoint,
137		}
	147	m := sync.Map{}
	148	m.Store(serviceCode, endpoint)
	149	endpoints.Store(region, &m)
138	150	}
139	151
140	152	func (client *LocationClient) DescribeOpenAPIEndpoint(region Region, serviceCode string) string {

160	172	}
161	173
162	174	if err != nil \|\| endpoint == nil \|\| len(endpoint.Endpoints.Endpoint) <= 0 {
163		log.Printf("aliyungo: can not get endpoint from service, use default. endpoint=[%v], error=[%v]\n",endpoint, err)
	175	log.Printf("aliyungo: can not get endpoint from service, use default. endpoint=[%v], error=[%v]\n", endpoint, err)
164	176	return ""
165	177	}
166	178

+11

-0

common/endpoints.xml less more

1335	1335	<Product><ProductName>Slb</ProductName><DomainName>slb.eu-central-1.aliyuncs.com</DomainName></Product>
1336	1336	</Products>
1337	1337	</Endpoint>
	1338	<Endpoint name="eu-west-1">
	1339	<RegionIds><RegionId>eu-west-1</RegionId></RegionIds>
	1340	<Products>
	1341	<Product><ProductName>Rds</ProductName><DomainName>rds.eu-west-1.aliyuncs.com</DomainName></Product>
	1342	<Product><ProductName>Ecs</ProductName><DomainName>ecs.eu-west-1.aliyuncs.com</DomainName></Product>
	1343	<Product><ProductName>Vpc</ProductName><DomainName>vpc.eu-west-1.aliyuncs.com</DomainName></Product>
	1344	<Product><ProductName>Kms</ProductName><DomainName>kms.eu-west-1.aliyuncs.com</DomainName></Product>
	1345	<Product><ProductName>Cms</ProductName><DomainName>metrics.cn-hangzhou.aliyuncs.com</DomainName></Product>
	1346	<Product><ProductName>Slb</ProductName><DomainName>slb.eu-west-1.aliyuncs.com</DomainName></Product>
	1347	</Products>
	1348	</Endpoint>
1338	1349	<Endpoint name="cn-zhangjiakou">
1339	1350	<RegionIds><RegionId>cn-zhangjiakou</RegionId></RegionIds>
1340	1351	<Products>

+9

-2

common/regions.go less more

13	13	Zhangjiakou = Region("cn-zhangjiakou")
14	14	Huhehaote = Region("cn-huhehaote")
15	15
	16	Chengdu = Region("cn-chengdu")
	17
16	18	APSouthEast1 = Region("ap-southeast-1")
17	19	APNorthEast1 = Region("ap-northeast-1")
18	20	APSouthEast2 = Region("ap-southeast-2")

27	29	MEEast1 = Region("me-east-1")
28	30
29	31	EUCentral1 = Region("eu-central-1")
	32	EUWest1 = Region("eu-west-1")
30	33
31	34	ShenZhenFinance = Region("cn-shenzhen-finance-1")
32	35	ShanghaiFinance = Region("cn-shanghai-finance-1")
	36	HangZhouFinance = Region("cn-hangzhou-finance-1")
	37
	38	CNNorth2Gov1 = Region("cn-north-2-gov-1")
	39	RUSWest1 = Region("rus-west-1")
33	40	)
34	41
35	42	var ValidRegions = []Region{

38	45	APNorthEast1, APSouthEast1, APSouthEast2, APSouthEast3, APSouthEast5,
39	46	APSouth1,
40	47	MEEast1,
41		EUCentral1,
42		ShenZhenFinance, ShanghaiFinance,
	48	EUCentral1, EUWest1,
	49	ShenZhenFinance, ShanghaiFinance, HangZhouFinance, CNNorth2Gov1,
43	50	}
44	51
45	52	// IsValidRegion checks if r is an Ali supported region.

+60

-0

common/types.go less more

12	12	PrePaid = InstanceChargeType("PrePaid")
13	13	PostPaid = InstanceChargeType("PostPaid")
14	14	)
	15
	16	var SpecialDeployedProducts = map[string]map[Region]interface{}{
	17	"vpc": {
	18	Hangzhou: Hangzhou,
	19	Shenzhen: Shenzhen,
	20	APSouthEast1: APSouthEast1,
	21	USWest1: USWest1,
	22	USEast1: USEast1,
	23	Chengdu: Chengdu,
	24	Zhangjiakou: Zhangjiakou,
	25	Huhehaote: Huhehaote,
	26	APSouthEast3: APSouthEast3,
	27	EUCentral1: EUCentral1,
	28	EUWest1: EUWest1,
	29	APSouth1: APSouth1,
	30	APNorthEast1: APNorthEast1,
	31	APSouthEast5: APSouthEast5,
	32	APSouthEast2: APSouthEast2,
	33	MEEast1: MEEast1,
	34	CNNorth2Gov1: CNNorth2Gov1,
	35	},
	36	}
	37
	38	var CentralDomainServices = map[string]string{
	39	"pvtz": "pvtz.vpc-proxy.aliyuncs.com",
	40	}
	41
	42	var RegionalDomainServices = []string{
	43	"ecs",
	44	"vpc",
	45	"slb",
	46	}
	47
	48	// Unit-Domain of central product
	49	var UnitRegions = map[Region]interface{}{
	50	Hangzhou: Hangzhou,
	51	Shenzhen: Shenzhen,
	52	APSouthEast1: APSouthEast1,
	53	USWest1: USWest1,
	54	USEast1: USEast1,
	55	Chengdu: Chengdu,
	56	Zhangjiakou: Zhangjiakou,
	57	Huhehaote: Huhehaote,
	58	APSouthEast3: APSouthEast3,
	59	EUCentral1: EUCentral1,
	60	EUWest1: EUWest1,
	61	APSouth1: APSouth1,
	62	APNorthEast1: APNorthEast1,
	63	APSouthEast5: APSouthEast5,
	64	APSouthEast2: APSouthEast2,
	65	CNNorth2Gov1: CNNorth2Gov1,
	66	//MEEast1: MEEast1,
	67	//RUSWest1: RUSWest1,
	68	//Beijing: Beijing,
	69	//Shanghai: Shanghai,
	70	//Hongkong: Hongkong,
	71	//ShanghaiFinance: ShanghaiFinance,
	72	//ShenZhenFinance: ShenZhenFinance,
	73	HangZhouFinance: Hangzhou,
	74	}
15	75
16	76	type DescribeEndpointArgs struct {
17	77	Id Region

+17

-4

cs/client.go less more

75	75	client.userAgent = userAgent
76	76	}
77	77
	78	// SetEndpoint sets customer endpoint
	79	func (client *Client) SetEndpoint(endpoint string) {
	80	client.endpoint = endpoint
	81	}
	82
	83	// SetTransport sets transport to the http client
	84	func (client *Client) SetTransport(transport http.RoundTripper) {
	85	if client.httpClient == nil {
	86	client.httpClient = &http.Client{}
	87	}
	88	client.httpClient.Transport = transport
	89	}
	90
78	91	type Request struct {
79	92	Method string
80	93	URL string

172	185
173	186	if client.debug {
174	187	var prettyJSON bytes.Buffer
175		err = json.Indent(&prettyJSON, body, "", " ")
176		log.Println(string(prettyJSON.Bytes()))
	188	_ = json.Indent(&prettyJSON, body, "", " ")
	189	log.Println(prettyJSON.String())
177	190	}
178	191
179	192	if statusCode >= 400 && statusCode <= 599 {
180	193	errorResponse := common.ErrorResponse{}
181		err = json.Unmarshal(body, &errorResponse)
	194	_ = json.Unmarshal(body, &errorResponse)
182	195	ecsError := &common.Error{
183	196	ErrorResponse: errorResponse,
184	197	StatusCode: statusCode,

186	199	return ecsError
187	200	}
188	201
189		if response != nil {
	202	if response != nil && len(body) > 0 {
190	203	err = json.Unmarshal(body, response)
191	204	//log.Printf("%++v", response)
192	205	if err != nil {

+233

-66

cs/clusters.go less more

10	10	"fmt"
11	11
12	12	"encoding/json"
	13
13	14	"github.com/denverdino/aliyungo/common"
14	15	"github.com/denverdino/aliyungo/ecs"
15	16	)

26	27	DeleteFailed = ClusterState("deleteFailed")
27	28	Deleted = ClusterState("deleted")
28	29	InActive = ClusterState("inactive")
	30
	31	ClusterTypeKubernetes = "Kubernetes"
	32	ClusterTypeManagedKubernetes = "ManagedKubernetes"
	33
	34	ClusterTypeServerlessKubernetes = "Ask"
29	35	)
	36
	37	var NodeStableClusterState = []ClusterState{Running, Updating, Failed, DeleteFailed, Deleted, InActive}
	38
	39	var NodeUnstableClusterState = []ClusterState{Initial, Scaling, Deleting}
30	40
31	41	type NodeStatus struct {
32	42	Health int64 `json:"health"`

59	69	NodeStatus string `json:"node_status"`
60	70	DockerVersion string `json:"docker_version"`
61	71	ClusterType string `json:"cluster_type"`
	72	Profile string `json:"profile"`
62	73	}
63	74
64	75	func (client *Client) DescribeClusters(nameFilter string) (clusters []ClusterType, err error) {

91	102	ECSImageID string `json:"ecs_image_id,omitempty"`
92	103	IOOptimized ecs.IoOptimized `json:"io_optimized"`
93	104	ReleaseEipFlag bool `json:"release_eip_flag"`
94		}
95
96		type ClusterCreationResponse struct {
	105	NeedSLB bool `json:"need_slb"`
	106	}
	107
	108	type ClusterCommonResponse struct {
97	109	Response
98		ClusterID string `json:"cluster_id"`
99		}
100
101		func (client Client) CreateCluster(region common.Region, args ClusterCreationArgs) (cluster ClusterCreationResponse, err error) {
	110	ClusterID string `json:"cluster_id"`
	111	Token string `json:"token,omitempty"`
	112	TaskId string `json:"task_id,omitempty"`
	113	InstanceId string `json:"instanceId"`
	114	}
	115
	116	//Deprecated
	117	func (client Client) CreateCluster(region common.Region, args ClusterCreationArgs) (cluster ClusterCommonResponse, err error) {
102	118	err = client.Invoke(region, http.MethodPost, "/clusters", nil, args, &cluster)
103	119	return
104	120	}

126	142	SNatEntry bool `json:"SNatEntry,omitempty"`
127	143	}
128	144
	145	// Deprecated
129	146	type KubernetesCreationArgs struct {
130		DisableRollback bool `json:"disable_rollback"`
131		Name string `json:"name"`
132		TimeoutMins int64 `json:"timeout_mins"`
133		ZoneId string `json:"zoneid,omitempty"`
134		VPCID string `json:"vpcid,omitempty"`
135		VSwitchId string `json:"vswitchid,omitempty"`
136		ContainerCIDR string `json:"container_cidr,omitempty"`
137		ServiceCIDR string `json:"service_cidr,omitempty"`
	147	DisableRollback bool `json:"disable_rollback"`
	148	Name string `json:"name"`
	149	TimeoutMins int64 `json:"timeout_mins"`
	150	ZoneId string `json:"zoneid,omitempty"`
	151	VPCID string `json:"vpcid,omitempty"`
	152	RegionId string `json:"region_id,omitempty"`
	153	VSwitchId string `json:"vswitchid,omitempty"`
	154	VSwitchIds []string `json:"vswitch_ids,omitempty"`
	155	ImageId string `json:"image_id"`
	156	ContainerCIDR string `json:"container_cidr,omitempty"`
	157	ServiceCIDR string `json:"service_cidr,omitempty"`
	158
138	159	MasterInstanceType string `json:"master_instance_type,omitempty"`
139	160	MasterSystemDiskSize int64 `json:"master_system_disk_size,omitempty"`
140	161	MasterSystemDiskCategory ecs.DiskCategory `json:"master_system_disk_category,omitempty"`
	162
	163	MasterInstanceChargeType string `json:"master_instance_charge_type"`
	164	MasterPeriodUnit string `json:"master_period_unit"`
	165	MasterPeriod int `json:"master_period"`
	166	MasterAutoRenew bool `json:"master_auto_renew"`
	167	MasterAutoRenewPeriod int `json:"master_auto_renew_period"`
	168
141	169	WorkerInstanceType string `json:"worker_instance_type,omitempty"`
	170	WorkerInstanceTypes []string `json:"worker_instance_types,omitempty"`
142	171	WorkerSystemDiskSize int64 `json:"worker_system_disk_size,omitempty"`
143	172	WorkerSystemDiskCategory ecs.DiskCategory `json:"worker_system_disk_category,omitempty"`
144		WorkerDataDisk bool `json:"worker_data_disk,omitempty"`
145		WorkerDataDiskCategory string `json:"worker_data_disk_category,omitempty"`
	173	WorkerDataDisk bool `json:"worker_data_disk"`
	174	WorkerDataDiskCategory ecs.DiskCategory `json:"worker_data_disk_category,omitempty"`
146	175	WorkerDataDiskSize int64 `json:"worker_data_disk_size,omitempty"`
147		LoginPassword string `json:"login_password,omitempty"`
148		KeyPair string `json:"key_pair,omitempty"`
149		NumOfNodes int64 `json:"num_of_nodes,omitempty"`
150		SNatEntry bool `json:"snat_entry,omitempty"`
151		SSHFlags bool `json:"ssh_flags,omitempty"`
152		CloudMonitorFlags bool `json:"cloud_monitor_flags,omitempty"`
	176
	177	WorkerInstanceChargeType string `json:"worker_instance_charge_type"`
	178	WorkerPeriodUnit string `json:"worker_period_unit"`
	179	WorkerPeriod int `json:"worker_period"`
	180	WorkerAutoRenew bool `json:"worker_auto_renew"`
	181	WorkerAutoRenewPeriod int `json:"worker_auto_renew_period"`
	182
	183	LoginPassword string `json:"login_password,omitempty"`
	184	KeyPair string `json:"key_pair,omitempty"`
	185	UserCA string `json:"user_ca,omitempty"`
	186	NumOfNodes int64 `json:"num_of_nodes,omitempty"`
	187	SNatEntry bool `json:"snat_entry"`
	188	SSHFlags bool `json:"ssh_flags"`
	189	CloudMonitorFlags bool `json:"cloud_monitor_flags"`
	190	NodeCIDRMask string `json:"node_cidr_mask,omitempty"`
	191	LoggingType string `json:"logging_type,omitempty"`
	192	SLSProjectName string `json:"sls_project_name,omitempty"`
	193	PublicSLB bool `json:"public_slb"`
153	194
154	195	ClusterType string `json:"cluster_type"`
155	196	Network string `json:"network,omitempty"`

158	199	StackParams KubernetesStackArgs `json:"stack_params,omitempty"`
159	200	}
160	201
	202	// Deprecated
161	203	type KubernetesMultiAZCreationArgs struct {
162		DisableRollback bool `json:"disable_rollback"`
163		Name string `json:"name"`
164		TimeoutMins int64 `json:"timeout_mins"`
165		ClusterType string `json:"cluster_type"`
166		MultiAZ bool `json:"multi_az,omitempty"`
167		VPCID string `json:"vpcid,omitempty"`
168		ContainerCIDR string `json:"container_cidr"`
169		ServiceCIDR string `json:"service_cidr"`
170		VSwitchIdA string `json:"vswitch_id_a,omitempty"`
171		VSwitchIdB string `json:"vswitch_id_b,omitempty"`
172		VSwitchIdC string `json:"vswitch_id_c,omitempty"`
	204	DisableRollback bool `json:"disable_rollback"`
	205	Name string `json:"name"`
	206	TimeoutMins int64 `json:"timeout_mins"`
	207	ClusterType string `json:"cluster_type"`
	208	MultiAZ bool `json:"multi_az"`
	209	VPCID string `json:"vpcid,omitempty"`
	210	ImageId string `json:"image_id"`
	211	ContainerCIDR string `json:"container_cidr"`
	212	ServiceCIDR string `json:"service_cidr"`
	213	VSwitchIdA string `json:"vswitch_id_a,omitempty"`
	214	VSwitchIdB string `json:"vswitch_id_b,omitempty"`
	215	VSwitchIdC string `json:"vswitch_id_c,omitempty"`
	216
173	217	MasterInstanceTypeA string `json:"master_instance_type_a,omitempty"`
174	218	MasterInstanceTypeB string `json:"master_instance_type_b,omitempty"`
175	219	MasterInstanceTypeC string `json:"master_instance_type_c,omitempty"`
176	220	MasterSystemDiskCategory ecs.DiskCategory `json:"master_system_disk_category"`
177	221	MasterSystemDiskSize int64 `json:"master_system_disk_size"`
	222
	223	MasterInstanceChargeType string `json:"master_instance_charge_type"`
	224	MasterPeriodUnit string `json:"master_period_unit"`
	225	MasterPeriod int `json:"master_period"`
	226	MasterAutoRenew bool `json:"master_auto_renew"`
	227	MasterAutoRenewPeriod int `json:"master_auto_renew_period"`
	228
178	229	WorkerInstanceTypeA string `json:"worker_instance_type_a,omitempty"`
179	230	WorkerInstanceTypeB string `json:"worker_instance_type_b,omitempty"`
180	231	WorkerInstanceTypeC string `json:"worker_instance_type_c,omitempty"`
181	232	WorkerSystemDiskCategory ecs.DiskCategory `json:"worker_system_disk_category"`
182	233	WorkerSystemDiskSize int64 `json:"worker_system_disk_size"`
183	234	WorkerDataDisk bool `json:"worker_data_disk"`
184		WorkerDataDiskCategory string `json:"worker_data_disk_category"`
	235	WorkerDataDiskCategory ecs.DiskCategory `json:"worker_data_disk_category"`
185	236	WorkerDataDiskSize int64 `json:"worker_data_disk_size"`
186		NumOfNodesA int64 `json:"num_of_nodes_a"`
187		NumOfNodesB int64 `json:"num_of_nodes_b"`
188		NumOfNodesC int64 `json:"num_of_nodes_c"`
189		LoginPassword string `json:"login_password,omitempty"`
190		KeyPair string `json:"key_pair,omitempty"`
191		SSHFlags bool `json:"ssh_flags"`
192		CloudMonitorFlags bool `json:"cloud_monitor_flags"`
	237
	238	WorkerInstanceChargeType string `json:"worker_instance_charge_type"`
	239	WorkerPeriodUnit string `json:"worker_period_unit"`
	240	WorkerPeriod int `json:"worker_period"`
	241	WorkerAutoRenew bool `json:"worker_auto_renew"`
	242	WorkerAutoRenewPeriod int `json:"worker_auto_renew_period"`
	243
	244	NumOfNodesA int64 `json:"num_of_nodes_a"`
	245	NumOfNodesB int64 `json:"num_of_nodes_b"`
	246	NumOfNodesC int64 `json:"num_of_nodes_c"`
	247	LoginPassword string `json:"login_password,omitempty"`
	248	KeyPair string `json:"key_pair,omitempty"`
	249	UserCA string `json:"user_ca,omitempty"`
	250	SSHFlags bool `json:"ssh_flags"`
	251	CloudMonitorFlags bool `json:"cloud_monitor_flags"`
	252	NodeCIDRMask string `json:"node_cidr_mask,omitempty"`
	253	LoggingType string `json:"logging_type,omitempty"`
	254	SLSProjectName string `json:"sls_project_name,omitempty"`
	255	PublicSLB bool `json:"public_slb"`
193	256
194	257	KubernetesVersion string `json:"kubernetes_version,omitempty"`
195	258	Network string `json:"network,omitempty"`
196	259	}
197	260
198		func (client Client) CreateKubernetesMultiAZCluster(region common.Region, args KubernetesMultiAZCreationArgs) (cluster ClusterCreationResponse, err error) {
	261	// Deprecated
	262	func (client Client) CreateKubernetesMultiAZCluster(region common.Region, args KubernetesMultiAZCreationArgs) (cluster ClusterCommonResponse, err error) {
199	263	err = client.Invoke(region, http.MethodPost, "/clusters", nil, args, &cluster)
200	264	return
201	265	}
202	266
203		func (client Client) CreateKubernetesCluster(region common.Region, args KubernetesCreationArgs) (cluster ClusterCreationResponse, err error) {
	267	// Deprecated
	268	func (client Client) CreateKubernetesCluster(region common.Region, args KubernetesCreationArgs) (cluster ClusterCommonResponse, err error) {
204	269	err = client.Invoke(region, http.MethodPost, "/clusters", nil, args, &cluster)
205	270	return
206	271	}

213	278	SubClass string `json:"SubClass"`
214	279	}
215	280
	281	// deprecated
216	282	type KubernetesClusterParameter struct {
217		ServiceCidr string `json:"ServiceCIDR"`
218		ContainerCidr string `json:"ContainerCIDR"`
219		DockerVersion string `json:"DockerVersion"`
220		EtcdVersion string `json:"EtcdVersion"`
221		KubernetesVersion string `json:"KubernetesVersion"`
222		VPCID string `json:"VpcId"`
223		KeyPair string `json:"KeyPair"`
224		MasterSystemDiskCategory string `json:"MasterSystemDiskCategory"`
225		MasterSystemDiskSize string `json:"MasterSystemDiskSize"`
226		WorkerSystemDiskCategory string `json:"WorkerSystemDiskCategory"`
227		WorkerSystemDiskSize string `json:"WorkerSystemDiskSize"`
228		ZoneId string `json:"ZoneId"`
	283	ServiceCidr string `json:"ServiceCIDR"`
	284	ContainerCidr string `json:"ContainerCIDR"`
	285	DockerVersion string `json:"DockerVersion"`
	286	EtcdVersion string `json:"EtcdVersion"`
	287	KubernetesVersion string `json:"KubernetesVersion"`
	288	VPCID string `json:"VpcId"`
	289	ImageId string `json:"ImageId"`
	290	KeyPair string `json:"KeyPair"`
	291
	292	MasterSystemDiskCategory ecs.DiskCategory `json:"MasterSystemDiskCategory"`
	293	MasterSystemDiskSize string `json:"MasterSystemDiskSize"`
	294	MasterImageId string `json:"MasterImageId"`
	295
	296	MasterInstanceChargeType string `json:"MasterInstanceChargeType"`
	297	MasterPeriodUnit string `json:"MasterPeriodUnit"`
	298	MasterPeriod string `json:"MasterPeriod"`
	299	MasterAutoRenew *bool
	300	RawMasterAutoRenew string `json:"MasterAutoRenew"`
	301	MasterAutoRenewPeriod string `json:"MasterAutoRenewPeriod"`
	302
	303	WorkerSystemDiskCategory ecs.DiskCategory `json:"WorkerSystemDiskCategory"`
	304	WorkerSystemDiskSize string `json:"WorkerSystemDiskSize"`
	305	WorkerImageId string `json:"WorkerImageId"`
	306	WorkerDataDisk *bool
	307	RawWorkerDataDisk string `json:"WorkerDataDisk"`
	308	WorkerDataDiskCategory ecs.DiskCategory `json:"WorkerDataDiskCategory"`
	309	WorkerDataDiskSize string `json:"WorkerDataDiskSize"`
	310
	311	WorkerInstanceChargeType string `json:"WorkerInstanceChargeType"`
	312	WorkerPeriodUnit string `json:"WorkerPeriodUnit"`
	313	WorkerPeriod string `json:"WorkerPeriod"`
	314	WorkerAutoRenew *bool
	315	RawWorkerAutoRenew string `json:"WorkerAutoRenew"`
	316	WorkerAutoRenewPeriod string `json:"WorkerAutoRenewPeriod"`
	317
	318	ZoneId string `json:"ZoneId"`
	319	NodeCIDRMask string `json:"NodeCIDRMask"`
	320	LoggingType string `json:"LoggingType"`
	321	SLSProjectName string `json:"SLSProjectName"`
	322	PublicSLB *bool
	323	RawPublicSLB string `json:"PublicSLB"`
229	324
230	325	// Single AZ
231	326	MasterInstanceType string `json:"MasterInstanceType"`

248	343	VSwitchIdC string `json:"VSwitchIdC"`
249	344	}
250	345
	346	// Deprecated
251	347	type KubernetesCluster struct {
252	348	ClusterType
253	349

277	373	Parameters KubernetesClusterParameter `json:"parameters"`
278	374	}
279	375
	376	// Deprecated
280	377	func (client *Client) DescribeKubernetesCluster(id string) (cluster KubernetesCluster, err error) {
281	378	err = client.Invoke("", http.MethodGet, "/clusters/"+id, nil, nil, &cluster)
282	379	if err != nil {
283	380	return cluster, err
284	381	}
	382
285	383	var metaData KubernetesClusterMetaData
286	384	err = json.Unmarshal([]byte(cluster.RawMetaData), &metaData)
	385	if err != nil {
	386	return cluster, err
	387	}
287	388	cluster.MetaData = metaData
288	389	cluster.RawMetaData = ""
289		return
290		}
291
	390
	391	return
	392	}
	393
	394	// Deprecated
292	395	type ClusterResizeArgs struct {
293	396	Size int64 `json:"size"`
294	397	InstanceType string `json:"instance_type"`

303	406	Name string `json:"name"`
304	407	}
305	408
	409	// Deprecated
306	410	func (client Client) ResizeCluster(clusterID string, args ClusterResizeArgs) error {
307	411	return client.Invoke("", http.MethodPut, "/clusters/"+clusterID, nil, args, nil)
308	412	}
309	413
310	414	// deprecated
311		// use ResizeKubernetesCluster instead
	415	// use ScaleKubernetesCluster instead
312	416	func (client Client) ResizeKubernetes(clusterID string, args KubernetesCreationArgs) error {
313	417	return client.Invoke("", http.MethodPut, "/clusters/"+clusterID, nil, args, nil)
314	418	}
315	419
	420	// Deprecated
316	421	type KubernetesClusterResizeArgs struct {
317	422	DisableRollback bool `json:"disable_rollback"`
318	423	TimeoutMins int64 `json:"timeout_mins"`
319	424	LoginPassword string `json:"login_password,omitempty"`
320	425
321	426	// Single AZ
322		WorkerInstanceType string `json:"worker_instance_type"`
323		NumOfNodes int64 `json:"num_of_nodes"`
	427	WorkerInstanceType string `json:"worker_instance_type"`
	428	WorkerInstanceTypes []string `json:"worker_instance_types"`
	429	NumOfNodes int64 `json:"num_of_nodes"`
324	430
325	431	// Multi AZ
326	432	WorkerInstanceTypeA string `json:"worker_instance_type_a"`

331	437	NumOfNodesC int64 `json:"num_of_nodes_c"`
332	438	}
333	439
	440	// deprecated
	441	// use ScaleKubernetesCluster instead
334	442	func (client Client) ResizeKubernetesCluster(clusterID string, args KubernetesClusterResizeArgs) error {
335	443	return client.Invoke("", http.MethodPut, "/clusters/"+clusterID, nil, args, nil)
336	444	}
337	445
	446	// Deprecated
	447	type KubernetesClusterScaleArgs struct {
	448	LoginPassword string `json:"login_password,omitempty"`
	449	KeyPair string `json:"key_pair,omitempty"`
	450	WorkerInstanceTypes []string `json:"worker_instance_types"`
	451	WorkerSystemDiskSize int64 `json:"worker_system_disk_size"`
	452	WorkerSystemDiskCategory ecs.DiskCategory `json:"worker_system_disk_category"`
	453	WorkerDataDisk bool `json:"worker_data_disk"`
	454	Count int `json:"count"`
	455
	456	// Edge worker related args
	457	IsEdgeWorker bool `json:"is_edge_worker"`
	458	EnsRegionId string `json:"ens_region_id"`
	459	EnsInternetChargeType string `json:"ens_internet_charge_type"`
	460
	461	//data disk
	462	WorkerDataDiskCategory ecs.DiskCategory `json:"worker_data_disk_category"`
	463	WorkerDataDiskSize int64 `json:"worker_data_disk_size"`
	464	WorkerDataDiskEncrypted string `json:"worker_data_disk_encrypted"`
	465	WorkerDataDiskKMSKeyId string `json:"worker_data_disk_kms_key_id"`
	466	}
	467
	468	// Deprecated
	469	func (client Client) ScaleKubernetesCluster(clusterID string, args KubernetesClusterScaleArgs) error {
	470	return client.Invoke("", http.MethodPost, "/api/v2/clusters/"+clusterID, nil, args, nil)
	471	}
	472
	473	// Deprecated
338	474	func (client *Client) ModifyClusterName(clusterID, clusterName string) error {
339	475	return client.Invoke("", http.MethodPost, "/clusters/"+clusterID+"/name/"+clusterName, nil, nil, nil)
340	476	}
341	477
	478	// Deprecated
342	479	func (client *Client) DeleteCluster(clusterID string) error {
343	480	return client.Invoke("", http.MethodDelete, "/clusters/"+clusterID, nil, nil, nil)
344	481	}

354	491	return
355	492	}
356	493
	494	type ClusterEndpoints struct {
	495	ApiServerEndpoint string `json:"api_server_endpoint"`
	496	DashboardEndpoint string `json:"dashboard_endpoint"`
	497	MiranaEndpoint string `json:"mirana_endpoint"`
	498	ReverseTunnelEndpoint string `json:"reverse_tunnel_endpoint"`
	499	IntranetApiServerEndpoint string `json:"intranet_api_server_endpoint"`
	500	}
	501
	502	func (client *Client) GetClusterEndpoints(id string) (clusterEndpoints ClusterEndpoints, err error) {
	503	err = client.Invoke("", http.MethodGet, "/clusters/"+id+"/endpoints", nil, nil, &clusterEndpoints)
	504	return
	505	}
	506
357	507	type ClusterConfig struct {
358	508	Config string `json:"config"`
359	509	}
360	510
	511	// deprecated
	512	// Please use new api DescribeClusterUserConfig
361	513	func (client *Client) GetClusterConfig(id string) (config ClusterConfig, err error) {
362	514	err = client.Invoke("", http.MethodGet, "/k8s/"+id+"/user_config", nil, nil, &config)
363	515	return

374	526	HostName string `json:"host_name"`
375	527	ImageId string `json:"image_id"`
376	528	InstanceId string `json:"instance_id"`
	529	NodeName string `json:"node_name"`
377	530	}
378	531
379	532	type GetKubernetesClusterNodesResponse struct {

382	535	Nodes []KubernetesNodeType `json:"nodes"`
383	536	}
384	537
385		func (client Client) GetKubernetesClusterNodes(id string, pagination common.Pagination) (nodes []KubernetesNodeType, paginationResult PaginationResult, err error) {
	538	// GetKubernetesClusterNodes is used to get cluster nodes or node pool nodes
	539	func (client Client) GetKubernetesClusterNodes(id string, pagination common.Pagination, nodepoolId string) (nodes []KubernetesNodeType, paginationResult PaginationResult, err error) {
386	540	response := &GetKubernetesClusterNodesResponse{}
387		err = client.Invoke("", http.MethodGet, "/clusters/"+id+"/nodes?pageNumber="+strconv.Itoa(pagination.PageNumber)+"&pageSize="+strconv.Itoa(pagination.PageSize), nil, nil, &response)
	541	if nodepoolId != "" {
	542	err = client.Invoke("", http.MethodGet, "/clusters/"+id+"/nodes?nodepool_id="+nodepoolId+"&pageNumber="+strconv.Itoa(pagination.PageNumber)+"&pageSize="+strconv.Itoa(pagination.PageSize), nil, nil, &response)
	543	} else {
	544	err = client.Invoke("", http.MethodGet, "/clusters/"+id+"/nodes?pageNumber="+strconv.Itoa(pagination.PageNumber)+"&pageSize="+strconv.Itoa(pagination.PageSize), nil, nil, &response)
	545	}
388	546	if err != nil {
389	547	return nil, nil, err
390	548	}

394	552
395	553	const ClusterDefaultTimeout = 300
396	554	const DefaultWaitForInterval = 10
397		const DefaultPreSleepTime = 240
	555	const DefaultPreCheckSleepTime = 20
	556	const DefaultPreSleepTime = 220
398	557
399	558	// WaitForCluster waits for instance to given status
400	559	// when instance.NotFound wait until timeout

402	561	if timeout <= 0 {
403	562	timeout = ClusterDefaultTimeout
404	563	}
	564
	565	// Sleep 20 second to check cluster creating or failed
	566	sleep := math.Min(float64(timeout), float64(DefaultPreCheckSleepTime))
	567	time.Sleep(time.Duration(sleep) * time.Second)
	568
405	569	cluster, err := client.DescribeCluster(clusterId)
406	570	if err != nil {
407	571	return err
	572	} else if cluster.State == Failed {
	573	return fmt.Errorf("Waitting for cluster %s %s failed. Looking the specified reason in the web console.", clusterId, status)
408	574	} else if cluster.State == status {
409	575	//TODO
410	576	return nil
411	577	}
	578
412	579	// Create or Reset cluster usually cost at least 4 min, so there will sleep a long time before polling
413		sleep := math.Min(float64(timeout), float64(DefaultPreSleepTime))
	580	sleep = math.Min(float64(timeout), float64(DefaultPreSleepTime))
414	581	time.Sleep(time.Duration(sleep) * time.Second)
415	582
416	583	for {

+136

-55

cs/clusters_test.go less more

41	41	}
42	42
43	43	for _, cluster := range clusters {
44		if cluster.ClusterType != "Kubernetes" {
	44	if cluster.ClusterType != "Kubernetes" && cluster.ClusterType != "ManagedKubernetes" {
45	45	continue
46	46	}
47	47	t.Logf("Cluster: %++v", cluster)

50	50	t.Errorf("Failed to DescribeCluster: %v", err)
51	51	}
52	52	t.Logf("Cluster Describe: %++v", c)
53		t.Logf("Cluster KeyPair %v", c.Parameters.KeyPair)
54	53
55	54	if c.MetaData.MultiAZ \|\| c.MetaData.SubClass == "3az" {
56	55	t.Logf("%v is a MultiAZ kubernetes cluster", c.ClusterID)
57		t.Logf("Cluster VSWA ID %v", c.Parameters.VSwitchIdA)
58		t.Logf("Cluster VSWB ID %v", c.Parameters.VSwitchIdB)
59		t.Logf("Cluster VSWC ID %v", c.Parameters.VSwitchIdC)
60		t.Logf("Cluster MasterInstanceTypeA %v", c.Parameters.MasterInstanceTypeA)
61		t.Logf("Cluster MasterInstanceTypeB %v", c.Parameters.MasterInstanceTypeB)
62		t.Logf("Cluster MasterInstanceTypeC %v", c.Parameters.MasterInstanceTypeC)
63		t.Logf("Cluster NumOfNodeA %v", c.Parameters.NumOfNodesA)
64		t.Logf("Cluster NumOfNodeB %v", c.Parameters.NumOfNodesB)
65		t.Logf("Cluster NumOfNodeC %v", c.Parameters.NumOfNodesC)
66	56	} else {
67		t.Logf("%v is a single kubernetes cluster", c.ClusterID)
68		t.Logf("Cluster VSW ID %v", c.Parameters.VSwitchID)
69		t.Logf("Cluster MasterInstanceType %v", c.Parameters.MasterInstanceType)
70		t.Logf("Cluster NumOfNode %v", c.Parameters.NumOfNodes)
	57	if cluster.ClusterType == "ManagedKubernetes" {
	58	t.Logf("%v is a Managed kubernetes cluster", c.ClusterID)
	59	} else {
	60	t.Logf("%v is a SingleAZ kubernetes cluster", c.ClusterID)
	61	}
71	62	}
72	63	}
73	64	}

95	86	t.Logf("Cluster certs: %++v", certs)
96	87
97	88	}
	89	}
	90
	91	func _TestGetClusterEndpoints(t *testing.T) {
	92	client := NewTestClientForDebug()
	93	clusterId := "c213c31b97430433c87afe4852b6a08ef"
	94	clusterEndpoints, err := client.GetClusterEndpoints(clusterId)
	95	if err != nil {
	96	t.Fatalf("Failed to GetClusterEndpoints: %v", err)
	97	}
	98	t.Logf("Succeed getting clusterEndpoints %v", clusterEndpoints)
98	99	}
99	100
100	101	func _TestCreateClusters(t *testing.T) {

154	155	WorkerDataDisk: true,
155	156	WorkerDataDiskCategory: "cloud_efficiency",
156	157	WorkerDataDiskSize: 100,
	158	PublicSLB: true,
	159	NodeCIDRMask: "25",
	160	LoggingType: "SLS",
	161	SLSProjectName: "k8s-test-my-terraform-singleaz",
157	162	}
158	163	cluster, err := client.CreateKubernetesCluster(common.Hangzhou, &args)
159	164	if err != nil {

163	168	t.Logf("Cluster: %++v", cluster)
164	169	}
165	170
166		func _TestCreateKubernetesMultiAZCluster(t *testing.T) {
167
168		client := NewTestClientForDebug()
169
170		args := KubernetesMultiAZCreationArgs{
171		Name: "multiaz-test1",
172		ClusterType: "Kubernetes",
173		DisableRollback: true,
174		MultiAZ: true,
175		VPCID: "vpc-id",
176		VSwitchIdA: "vsw-id1",
177		VSwitchIdB: "vsw-id2",
178		VSwitchIdC: "vsw-id3",
179		NumOfNodesA: 1,
180		NumOfNodesB: 1,
181		NumOfNodesC: 1,
182		MasterInstanceTypeA: "ecs.sn1ne.large",
183		MasterInstanceTypeB: "ecs.sn1ne.large",
184		MasterInstanceTypeC: "ecs.sn1ne.large",
	171	func _TestCreateManagedKubernetesCluster(t *testing.T) {
	172
	173	client := NewTestClientForDebug()
	174
	175	args := KubernetesCreationArgs{
	176	Name: "single-managed-az-k8s",
	177	ClusterType: "ManagedKubernetes",
	178	DisableRollback: true,
	179	//VPCID: "vpc-id",
	180	//VSwitchId: "vsw-id",
	181	ZoneId: "cn-hangzhou-g",
	182	SNatEntry: true,
	183	NumOfNodes: 2,
	184	MasterInstanceType: "ecs.sn1ne.large",
185	185	MasterSystemDiskCategory: "cloud_efficiency",
186	186	MasterSystemDiskSize: 40,
187		WorkerInstanceTypeA: "ecs.sn1ne.large",
188		WorkerInstanceTypeB: "ecs.sn1ne.large",
189		WorkerInstanceTypeC: "ecs.sn1ne.large",
	187	WorkerInstanceType: "ecs.sn1ne.large",
190	188	WorkerSystemDiskCategory: "cloud_efficiency",
191	189	WorkerSystemDiskSize: 40,
192	190	SSHFlags: true,
193		ContainerCIDR: "172.17.0.0/16",
194		ServiceCIDR: "172.20.0.0/20",
	191	ContainerCIDR: "172.16.0.0/16",
	192	ServiceCIDR: "172.19.0.0/20",
195	193	LoginPassword: "test-password123",
196	194	WorkerDataDisk: true,
197	195	WorkerDataDiskCategory: "cloud_efficiency",
198	196	WorkerDataDiskSize: 100,
	197	PublicSLB: true,
	198	NodeCIDRMask: "25",
	199	LoggingType: "SLS",
	200	SLSProjectName: "k8s-test-my-terraform-singleaz",
	201	}
	202	cluster, err := client.CreateKubernetesCluster(common.Hangzhou, &args)
	203	if err != nil {
	204	t.Fatalf("Failed to CreateKubernetesCluster: %v", err)
	205	}
	206
	207	t.Logf("Cluster: %++v", cluster)
	208	}
	209
	210	func _TestCreateKubernetesMultiAZCluster(t *testing.T) {
	211
	212	client := NewTestClientForDebug()
	213
	214	args := KubernetesMultiAZCreationArgs{
	215	Name: "multiaz-test",
	216	ClusterType: "Kubernetes",
	217	DisableRollback: true,
	218	MultiAZ: true,
	219	VPCID: "vpc-id",
	220	VSwitchIdA: "vsw-id1",
	221	VSwitchIdB: "vsw-id2",
	222	VSwitchIdC: "vsw-id3",
	223	NumOfNodesA: 1,
	224	NumOfNodesB: 1,
	225	NumOfNodesC: 1,
	226
	227	MasterInstanceTypeA: "ecs.ic5.xlarge",
	228	MasterInstanceTypeB: "ecs.ic5.xlarge",
	229	MasterInstanceTypeC: "ecs.ic5.xlarge",
	230	MasterSystemDiskCategory: "cloud_efficiency",
	231	MasterSystemDiskSize: 40,
	232
	233	MasterInstanceChargeType: "PrePaid",
	234	MasterPeriodUnit: "Week",
	235	MasterPeriod: 1,
	236	MasterAutoRenew: true,
	237	MasterAutoRenewPeriod: 1,
	238
	239	WorkerInstanceTypeA: "ecs.ic5.xlarge",
	240	WorkerInstanceTypeB: "ecs.ic5.xlarge",
	241	WorkerInstanceTypeC: "ecs.ic5.xlarge",
	242	WorkerSystemDiskCategory: "cloud_efficiency",
	243	WorkerSystemDiskSize: 40,
	244
	245	WorkerInstanceChargeType: "PrePaid",
	246	WorkerPeriodUnit: "Week",
	247	WorkerPeriod: 1,
	248	WorkerAutoRenew: true,
	249	WorkerAutoRenewPeriod: 1,
	250
	251	SSHFlags: true,
	252	ContainerCIDR: "172.20.0.0/16",
	253	ServiceCIDR: "172.21.0.0/20",
	254	LoginPassword: "test-password123",
	255	ImageId: "centos_7_03_64_20G_alibase_20170818.vhd",
	256	KubernetesVersion: "1.11.2",
	257	WorkerDataDisk: true,
	258	WorkerDataDiskCategory: "cloud_efficiency",
	259	WorkerDataDiskSize: 100,
	260	NodeCIDRMask: "25",
	261	LoggingType: "SLS",
	262	SLSProjectName: "k8s-test-my-terraform",
199	263	}
200	264	cluster, err := client.CreateKubernetesMultiAZCluster(common.Hangzhou, &args)
201	265	if err != nil {

205	269	t.Logf("Cluster: %++v", cluster)
206	270	}
207	271
208		func _TestResizeKubernetesCluster(t *testing.T) {
209		client := NewTestClientForDebug()
210
211		args := KubernetesClusterResizeArgs{
212		DisableRollback: true,
213		TimeoutMins: 60,
214		LoginPassword: "test-password123",
215		WorkerInstanceType: "ecs.sn1ne.large",
216		NumOfNodes: 2,
217		}
218
219		err := client.ResizeKubernetesCluster("c3419330390a94906bcacc55bfa9dd21f", &args)
220		if err != nil {
221		t.Fatalf("Failed to TestResizeKubernetesCluster: %v", err)
222		}
223		}
	272	func TestScaleKubernetesCluster(t *testing.T) {
	273	// Comment below to test
	274	//t.SkipNow()
	275
	276	client := NewTestClientForDebug()
	277
	278	args := KubernetesClusterScaleArgs{
	279	LoginPassword: "test-password123",
	280	WorkerInstanceTypes: []string{"ecs.sn1ne.large"},
	281	WorkerSystemDiskCategory: "cloud_ssd",
	282	WorkerSystemDiskSize: int64(40),
	283	Count: 2,
	284	WorkerDataDisk: true,
	285	WorkerDataDiskCategory: "cloud_ssd",
	286	WorkerDataDiskSize: int64(200),
	287	}
	288
	289	err := client.ScaleKubernetesCluster(TestClusterId, &args)
	290	if err != nil {
	291	t.Fatalf("Failed to TestScaleKubernetesCluster: %v", err)
	292	}
	293	}
	294
	295	func Test_GetKubernetesClusterNodes(t *testing.T) {
	296	client := NewTestClientForDebug()
	297
	298	resp, _, err := client.GetKubernetesClusterNodes(TestClusterId, common.Pagination{PageNumber: 1, PageSize: 1000}, NodePoolId)
	299	if err != nil {
	300	t.Errorf("Error %++v", err)
	301	} else {
	302	t.Logf("response: %++v", resp)
	303	}
	304	}

+10

-4

cs/config_test.go less more

1	1
2	2	import (
3	3	"os"
	4	"strconv"
4	5
5	6	"github.com/denverdino/aliyungo/common"
6	7	)

8	9	//Modify with your Access Key Id and Access Key Secret
9	10
10	11	var (
11		TestAccessKeyId = os.Getenv("AccessKeyId")
12		TestAccessKeySecret = os.Getenv("AccessKeySecret")
13		TestSecurityToken = os.Getenv("SecurityToken")
14		TestRegionID = common.Region(os.Getenv("RegionId"))
	12	TestAccessKeyId = os.Getenv("AccessKeyId")
	13	TestAccessKeySecret = os.Getenv("AccessKeySecret")
	14	TestSecurityToken = os.Getenv("SecurityToken")
	15	TestRegionID = common.Region(os.Getenv("RegionId"))
	16	TestVpcId = os.Getenv("VpcId")
	17	TestVSwitchId = os.Getenv("VSwitchId")
	18	TestClusterId = os.Getenv("ClusterId")
	19	TestPrivateIpAddress, _ = strconv.ParseBool(os.Getenv("PrivateIpAddress"))
	20	TestToken = os.Getenv("Token")
15	21	)
16	22
17	23	var testClient *Client

+158

-0

cs/kubernetes_cluster_test.go less more

	0	package cs
	1
	2	import (
	3	"testing"
	4	)
	5
	6	func Test_ModifyCluster(t *testing.T) {
	7	client := NewTestClientForDebug()
	8
	9	args := &ModifyClusterArgs{
	10	DeletionProtection: false,
	11	MaintenanceWindow: MaintenanceWindow{
	12	Enable: true,
	13	MaintenanceTime: "2020-12-02T13:06:50.224Z",
	14	Duration: "3h",
	15	WeeklyPeriod: "Wednesday",
	16	},
	17	}
	18
	19	err := client.ModifyCluster(TestClusterId, args)
	20	if err != nil {
	21	t.Errorf("Error %++v", err)
	22	} else {
	23	t.Logf("OK")
	24	}
	25	}
	26
	27	func Test_UpgradeCluster(t *testing.T) {
	28	client := NewTestClientForDebug()
	29
	30	args := &UpgradeClusterArgs{
	31	Version: "1.14.8-aliyun.1",
	32	}
	33
	34	err := client.UpgradeCluster(TestClusterId, args)
	35	if err != nil {
	36	t.Errorf("Error %++v", err)
	37	} else {
	38	t.Logf("OK")
	39	}
	40	}
	41
	42	func Test_CancelUpgradeCluster(t *testing.T) {
	43	client := NewTestClientForDebug()
	44
	45	err := client.CancelUpgradeCluster(TestClusterId)
	46	if err != nil {
	47	t.Errorf("Error %++v", err)
	48	} else {
	49	t.Logf("OK")
	50	}
	51	}
	52
	53	func Test_QueryUpgradeClusterResult(t *testing.T) {
	54	client := NewTestClientForDebug()
	55
	56	result, err := client.QueryUpgradeClusterResult(TestClusterId)
	57	if err != nil {
	58	t.Errorf("Error %++v", err)
	59	} else {
	60	t.Logf("OK, result: %++v", result)
	61	}
	62	}
	63
	64	func Test_CreateDelicatedKubernetesCluster(t *testing.T) {
	65	t.SkipNow()
	66	client := NewTestClientForDebug()
	67
	68	request := &DelicatedKubernetesClusterCreationRequest{}
	69	response, err := client.CreateDelicatedKubernetesCluster(request)
	70	if err != nil {
	71	t.Fatalf("Error %++v", err)
	72	} else {
	73	t.Logf("Response %++v", response)
	74	}
	75	}
	76
	77	func Test_CreateManagedKubernetesCluster(t *testing.T) {
	78	t.SkipNow()
	79	client := NewTestClientForDebug()
	80
	81	request := &ManagedKubernetesClusterCreationRequest{}
	82
	83	response, err := client.CreateManagedKubernetesCluster(request)
	84	if err != nil {
	85	t.Fatalf("Error %++v", err)
	86	} else {
	87	t.Logf("Response %++v", response)
	88	}
	89	}
	90
	91	func Test_DescribeKubernetesClusterDetail(t *testing.T) {
	92	client := NewTestClientForDebug()
	93
	94	cluster, err := client.DescribeKubernetesClusterDetail(TestClusterId)
	95
	96	if err != nil {
	97	t.Fatalf("Error %++v", err)
	98	} else {
	99	t.Logf("Response = %++v", cluster)
	100	t.Logf("MetaData = %++v", cluster.GetMetaData())
	101	}
	102	}
	103
	104	func Test_ScaleOutKubernetesCluster(t *testing.T) {
	105	client := NewTestClientForDebug()
	106
	107	request := &ScaleOutKubernetesClusterRequest{
	108	LoginPassword: "Hello1234",
	109	WorkerVSwitchIds: []string{"vsw-xxxx"},
	110	WorkerInstanceTypes: []string{"ecs.n4.xlarge"},
	111	WorkerInstanceChargeType: "PostPaid",
	112	WorkerPeriod: 1,
	113	WorkerPeriodUnit: "1",
	114	WorkerAutoRenew: true,
	115	WorkerAutoRenewPeriod: 1,
	116	WorkerDataDisk: true,
	117	WorkerDataDisks: []DataDisk{
	118	{
	119	Category: "cloud_ssd",
	120	Size: "200",
	121	},
	122	{
	123	Category: "cloud_ssd",
	124	Size: "300",
	125	},
	126	},
	127	Tags: []Tag{
	128	{Key: "k-aaa",
	129	Value: "v-aaa",
	130	},
	131	},
	132	Count: 2,
	133	}
	134
	135	response, err := client.ScaleOutKubernetesCluster(TestClusterId, request)
	136	if err != nil {
	137	t.Fatalf("Error %++v", err)
	138	} else {
	139	t.Logf("Response %++v", response)
	140	}
	141	}
	142
	143	func Test_DeleteKubernetesClusterNodes(t *testing.T) {
	144	client := NewTestClientForDebug()
	145
	146	request := &DeleteKubernetesClusterNodesRequest{
	147	ReleaseNode: false,
	148	Nodes: []string{"cn-beijing.192.168.0.128"},
	149	}
	150
	151	response, err := client.DeleteKubernetesClusterNodes(TestClusterId, request)
	152	if err != nil {
	153	t.Fatalf("Error %++v", err)
	154	} else {
	155	t.Logf("Response %++v", response)
	156	}
	157	}

+477

-0

cs/kubernets_cluster.go less more

	0	package cs
	1
	2	import (
	3	"encoding/json"
	4	"fmt"
	5	"github.com/denverdino/aliyungo/ecs"
	6	"net/http"
	7	"time"
	8
	9	"github.com/denverdino/aliyungo/common"
	10	)
	11
	12	type TaskState string
	13
	14	const (
	15	// task status
	16	Task_Status_Running = "running"
	17	Task_Status_Success = "Success"
	18	Task_Status_Failed = "Failed"
	19
	20	// upgrade state
	21	UpgradeStep_NotStart = "not_start"
	22	UpgradeStep_Prechecking = "prechecking"
	23	UpgradeStep_Upgrading = "upgrading"
	24	UpgradeStep_Pause = "pause"
	25	UpgradeStep_Success = "success"
	26	)
	27
	28	type WeeklyPeriod string
	29	type MaintenanceTime string
	30
	31	// maintenance window
	32	type MaintenanceWindow struct {
	33	Enable bool `json:"enable"`
	34	MaintenanceTime MaintenanceTime `json:"maintenance_time"`
	35	Duration string `json:"duration"`
	36	Recurrence string `json:"recurrence,omitempty"`
	37	WeeklyPeriod WeeklyPeriod `json:"weekly_period"`
	38	}
	39
	40	//modify cluster,include DeletionProtection and so on
	41	type ModifyClusterArgs struct {
	42	DeletionProtection bool `json:"deletion_protection"`
	43	ResourceGroupId string `json:"resource_group_id"`
	44	MaintenanceWindow MaintenanceWindow `json:"maintenance_window"`
	45	}
	46
	47	type UpgradeClusterArgs struct {
	48	Version string `json:"version"`
	49	}
	50
	51	type UpgradeClusterResult struct {
	52	Status TaskState `json:"status"`
	53	PrecheckReportId string `json:"precheck_report_id"`
	54	UpgradeStep string `json:"upgrade_step"`
	55	ErrorMessage string `json:"error_message"`
	56	*UpgradeTask `json:"upgrade_task,omitempty"`
	57	}
	58
	59	type UpgradeTask struct {
	60	FieldRetries int `json:"retries,omitempty"`
	61	FieldCreatedAt time.Time `json:"created_at"`
	62	FieldMessage string `json:"message,omitempty"`
	63	FieldStatus string `json:"status"` // empty\|running\|success\|failed
	64	FieldFinishedAt time.Time `json:"finished_at,omitempty"`
	65	UpgradeStatus UpgradeStatus `json:"upgrade_status"`
	66	}
	67
	68	type UpgradeStatus struct {
	69	State string `json:"state"`
	70	Phase string `json:"phase"` // {Master1, Master2, Master3, Nodes}
	71	Total int `json:"total"`
	72	Succeeded int `json:"succeeded"`
	73	Failed string `json:"failed"`
	74	Events []Event `json:"events"`
	75	IsCanceled bool `json:"is_canceled"`
	76	}
	77
	78	type Event struct {
	79	Timestamp time.Time
	80	Type string
	81	Reason string
	82	Message string
	83	Source string
	84	}
	85
	86	//modify cluster
	87	func (client Client) ModifyCluster(clusterId string, args ModifyClusterArgs) error {
	88	return client.Invoke("", http.MethodPut, "/api/v2/clusters/"+clusterId, nil, args, nil)
	89	}
	90
	91	//upgrade cluster
	92	func (client Client) UpgradeCluster(clusterId string, args UpgradeClusterArgs) error {
	93	return client.Invoke("", http.MethodPost, fmt.Sprintf("/api/v2/clusters/%s/upgrade", clusterId), nil, args, nil)
	94	}
	95
	96	//cancel upgrade cluster
	97	func (client *Client) CancelUpgradeCluster(clusterId string) error {
	98	return client.Invoke("", http.MethodPost, fmt.Sprintf("/api/v2/clusters/%s/upgrade/cancel", clusterId), nil, nil, nil)
	99	}
	100
	101	func (client Client) QueryUpgradeClusterResult(clusterId string) (UpgradeClusterResult, error) {
	102	cluster := &UpgradeClusterResult{}
	103	err := client.Invoke("", http.MethodGet, fmt.Sprintf("/api/v2/clusters/%s/upgrade/status", clusterId), nil, nil, cluster)
	104	if err != nil {
	105	return nil, err
	106	}
	107	return cluster, nil
	108	}
	109
	110	//Cluster Info
	111	type KubernetesClusterType string
	112
	113	var (
	114	DelicatedKubernetes = KubernetesClusterType("Kubernetes")
	115	ManagedKubernetes = KubernetesClusterType("ManagedKubernetes")
	116	ServerlessKubernetes = KubernetesClusterType("Ask")
	117	)
	118
	119	type ProxyMode string
	120
	121	var (
	122	IPTables = "iptables"
	123	IPVS = "ipvs"
	124	)
	125
	126	type Effect string
	127
	128	var (
	129	TaintNoExecute = "NoExecute"
	130	TaintNoSchedule = "NoSchedule"
	131	TaintPreferNoSchedule = "PreferNoSchedule"
	132	)
	133
	134	type ClusterArgs struct {
	135	DisableRollback bool `json:"disable_rollback"`
	136	TimeoutMins int `json:"timeout_mins"`
	137
	138	Name string `json:"name"`
	139	ClusterType KubernetesClusterType `json:"cluster_type"`
	140	Profile string `json:"profile"`
	141	KubernetesVersion string `json:"kubernetes_version"`
	142	DeletionProtection bool `json:"deletion_protection"`
	143
	144	NodeCidrMask string `json:"node_cidr_mask"`
	145	UserCa string `json:"user_ca"`
	146
	147	OsType string `json:"os_type"`
	148	Platform string `json:"platform"`
	149
	150	UserData string `json:"user_data"`
	151
	152	NodePortRange string `json:"node_port_range"`
	153	NodeNameMode string `json:"node_name_mode"`
	154
	155	//ImageId
	156	ImageId string `json:"image_id"`
	157
	158	PodVswitchIds []string `json:"pod_vswitch_ids"` // eni多网卡模式下，需要传额外的vswitchid给addon
	159
	160	LoginPassword string `json:"login_password"` //和KeyPair 二选一
	161	KeyPair string `json:"key_pair"` ////LoginPassword 二选一
	162
	163	RegionId common.Region `json:"region_id"`
	164	VpcId string `json:"vpcid"`
	165	ContainerCidr string `json:"container_cidr"`
	166	ServiceCidr string `json:"service_cidr"`
	167
	168	CloudMonitorFlags bool `json:"cloud_monitor_flags"`
	169
	170	SecurityGroupId string `json:"security_group_id"`
	171	IsEnterpriseSecurityGroup bool `json:"is_enterprise_security_group"`
	172	EndpointPublicAccess bool `json:"endpoint_public_access"`
	173	LoadBalancerSpec string `json:"load_balancer_spec"` //api server slb实例规格
	174	ProxyMode ProxyMode `json:"proxy_mode"`
	175	SnatEntry bool `json:"snat_entry"`
	176	ResourceGroupId string `json:"resource_group_id"`
	177
	178	Addons []Addon `json:"addons"`
	179	Tags []Tag `json:"tags"`
	180
	181	Taints []Taint `json:"taints"`
	182
	183	ApiAudiences string `json:"api_audiences,omitempty"`
	184	ServiceAccountIssuer string `json:"service_account_issuer,omitempty"`
	185	CustomSAN string `json:"custom_san,omitempty"`
	186	ClusterSpec string `json:"cluster_spec"`
	187	Timezone string `json:"timezone"`
	188	ClusterDomain string `json:"cluster_domain"`
	189	RdsInstances []string `json:"rds_instances"`
	190	EncryptionProviderKey string `json:"encryption_provider_key"`
	191	MaintenanceWindow MaintenanceWindow `json:"maintenance_window"`
	192	}
	193
	194	//addon
	195	type Addon struct {
	196	Name string `json:"name"`
	197	Version string `json:"version"`
	198	Config string `json:"config"`
	199	Disabled bool `json:"disabled"` // 是否禁止默认安装
	200	}
	201
	202	//taint
	203	type Taint struct {
	204	Key string `json:"key"`
	205	Value string `json:"value"`
	206	Effect Effect `json:"effect"`
	207	}
	208
	209	type Label struct {
	210	Key string `json:"key"`
	211	Value string `json:"value"`
	212	}
	213
	214	type MasterArgs struct {
	215	MasterCount int `json:"master_count"`
	216	MasterVSwitchIds []string `json:"master_vswitch_ids"`
	217	MasterInstanceTypes []string `json:"master_instance_types"`
	218
	219	MasterInstanceChargeType string `json:"master_instance_charge_type"`
	220	MasterPeriod int `json:"master_period"`
	221	MasterPeriodUnit string `json:"master_period_unit"`
	222
	223	MasterAutoRenew bool `json:"master_auto_renew"`
	224	MasterAutoRenewPeriod int `json:"master_auto_renew_period"`
	225
	226	MasterSystemDiskCategory ecs.DiskCategory `json:"master_system_disk_category"`
	227	MasterSystemDiskSize int64 `json:"master_system_disk_size"`
	228	MasterSystemDiskPerformanceLevel string `json:"master_system_disk_performance_level"`
	229
	230	MasterDataDisks []DataDisk `json:"master_data_disks"` //支持多个数据盘
	231
	232	//support hpc/scc
	233	MasterHpcClusterId string `json:"master_hpc_cluster_id"`
	234	MasterDeploymentSetId string `json:"master_deploymentset_id"`
	235
	236	//master node deletion protection
	237	MasterDeletionProtection *bool `json:"master_deletion_protection"`
	238
	239	// disk snapshot policy
	240	MasterSnapshotPolicyId string `json:"master_system_disk_snapshot_policy_id"`
	241	}
	242
	243	type WorkerArgs struct {
	244	WorkerVSwitchIds []string `json:"worker_vswitch_ids"`
	245	WorkerInstanceTypes []string `json:"worker_instance_types"`
	246
	247	NumOfNodes int64 `json:"num_of_nodes"`
	248
	249	WorkerInstanceChargeType string `json:"worker_instance_charge_type"`
	250	WorkerPeriod int `json:"worker_period"`
	251	WorkerPeriodUnit string `json:"worker_period_unit"`
	252
	253	WorkerAutoRenew bool `json:"worker_auto_renew"`
	254	WorkerAutoRenewPeriod int `json:"worker_auto_renew_period"`
	255
	256	WorkerSystemDiskCategory ecs.DiskCategory `json:"worker_system_disk_category"`
	257	WorkerSystemDiskSize int64 `json:"worker_system_disk_size"`
	258	WorkerSystemDiskPerformanceLevel string `json:"worker_system_disk_performance_level"`
	259
	260	WorkerDataDisk bool `json:"worker_data_disk"`
	261	WorkerDataDisks []DataDisk `json:"worker_data_disks"` //支持多个数据盘
	262
	263	WorkerHpcClusterId string `json:"worker_hpc_cluster_id"`
	264	WorkerDeploymentSetId string `json:"worker_deploymentset_id"`
	265
	266	//worker node deletion protection
	267	WorkerDeletionProtection *bool `json:"worker_deletion_protection"`
	268
	269	//Runtime only for worker nodes
	270	Runtime Runtime `json:"runtime"`
	271
	272	// disk snapshot policy
	273	WorkerSnapshotPolicyId string `json:"worker_system_disk_snapshot_policy_id"`
	274	}
	275
	276	type ScaleOutKubernetesClusterRequest struct {
	277	LoginPassword string `json:"login_password"` //和KeyPair 二选一
	278	KeyPair string `json:"key_pair"` ////LoginPassword 二选一
	279
	280	WorkerVSwitchIds []string `json:"worker_vswitch_ids"`
	281	WorkerInstanceTypes []string `json:"worker_instance_types"`
	282
	283	WorkerInstanceChargeType string `json:"worker_instance_charge_type"`
	284	WorkerPeriod int `json:"worker_period"`
	285	WorkerPeriodUnit string `json:"worker_period_unit"`
	286
	287	WorkerAutoRenew bool `json:"worker_auto_renew"`
	288	WorkerAutoRenewPeriod int `json:"worker_auto_renew_period"`
	289
	290	WorkerSystemDiskCategory ecs.DiskCategory `json:"worker_system_disk_category"`
	291	WorkerSystemDiskSize int64 `json:"worker_system_disk_size"`
	292	WorkerSnapshotPolicyId string `json:"worker_system_disk_snapshot_policy_id"`
	293	WorkerSystemDiskPerformanceLevel string `json:"worker_system_disk_performance_level"`
	294
	295	WorkerDataDisk bool `json:"worker_data_disk"`
	296	WorkerDataDisks []DataDisk `json:"worker_data_disks"` //支持多个数据盘
	297
	298	Tags []Tag `json:"tags"`
	299	Taints []Taint `json:"taints"`
	300	ImageId string `json:"image_id"`
	301
	302	UserData string `json:"user_data"`
	303
	304	Count int64 `json:"count"`
	305	CpuPolicy string `json:"cpu_policy"`
	306	Runtime Runtime `json:"runtime"`
	307	CloudMonitorFlags bool `json:"cloud_monitor_flags"`
	308	RdsInstances []string ` json:"rds_instances"`
	309	}
	310
	311	//datadiks
	312	type DataDisk struct {
	313	Category string `json:"category"`
	314	KMSKeyId string `json:"kms_key_id"`
	315	Encrypted string `json:"encrypted"` // true\|false
	316	Device string `json:"device"` // could be /dev/xvd[a-z]. If not specification, will use default value.
	317	Size string `json:"size"`
	318	DiskName string `json:"name"`
	319	AutoSnapshotPolicyId string `json:"auto_snapshot_policy_id"`
	320	PerformanceLevel string `json:"performance_Level"`
	321	}
	322
	323	type NodePoolDataDisk struct {
	324	Category string `json:"category"`
	325	KMSKeyId string `json:"kms_key_id"`
	326	Encrypted string `json:"encrypted"` // true\|false
	327	Device string `json:"device"` // could be /dev/xvd[a-z]. If not specification, will use default value.
	328	Size int `json:"size"`
	329	DiskName string `json:"name"`
	330	AutoSnapshotPolicyId string `json:"auto_snapshot_policy_id"`
	331	PerformanceLevel string `json:"performance_Level"`
	332	}
	333
	334	//runtime
	335	type Runtime struct {
	336	Name string `json:"name"`
	337	Version string `json:"version"`
	338	RuntimeClass []string `json:"runtimeClass,omitempty"`
	339	Exist bool `json:"exist"`
	340	AvailableNetworkComponents []string `json:"availableNetworkComponents,omitempty"`
	341	}
	342
	343	//DelicatedKubernetes
	344	type DelicatedKubernetesClusterCreationRequest struct {
	345	ClusterArgs
	346	MasterArgs
	347	WorkerArgs
	348	}
	349
	350	//ManagedKubernetes
	351	type ManagedKubernetesClusterCreationRequest struct {
	352	ClusterArgs
	353	WorkerArgs
	354	}
	355
	356	//Validate
	357
	358	//Create DelicatedKubernetes Cluster
	359	func (client Client) CreateDelicatedKubernetesCluster(request DelicatedKubernetesClusterCreationRequest) (*ClusterCommonResponse, error) {
	360	response := &ClusterCommonResponse{}
	361	path := "/clusters"
	362	if request.ResourceGroupId != "" {
	363	// 创建集群到指定资源组
	364	path = fmt.Sprintf("/resource_groups/%s/clusters", request.ResourceGroupId)
	365	}
	366	err := client.Invoke(request.RegionId, http.MethodPost, path, nil, request, response)
	367	if err != nil {
	368	return nil, err
	369	}
	370
	371	return response, nil
	372	}
	373
	374	//Create ManagedKubernetes Cluster
	375	func (client Client) CreateManagedKubernetesCluster(request ManagedKubernetesClusterCreationRequest) (*ClusterCommonResponse, error) {
	376	response := &ClusterCommonResponse{}
	377	path := "/clusters"
	378	if request.ResourceGroupId != "" {
	379	// 创建集群到指定资源组
	380	path = fmt.Sprintf("/resource_groups/%s/clusters", request.ResourceGroupId)
	381	}
	382	err := client.Invoke(request.RegionId, http.MethodPost, path, nil, request, response)
	383	if err != nil {
	384	return nil, err
	385	}
	386
	387	return response, nil
	388	}
	389
	390	//ScaleKubernetesCluster
	391	func (client Client) ScaleOutKubernetesCluster(clusterId string, request ScaleOutKubernetesClusterRequest) (*ClusterCommonResponse, error) {
	392	response := &ClusterCommonResponse{}
	393	err := client.Invoke("", http.MethodPost, fmt.Sprintf("/api/v2/clusters/%s", clusterId), nil, request, response)
	394	if err != nil {
	395	return nil, err
	396	}
	397
	398	return response, nil
	399	}
	400
	401	//DeleteClusterNodes
	402	type DeleteKubernetesClusterNodesRequest struct {
	403	ReleaseNode bool `json:"release_node"` //if set to true, the ecs instance will be released
	404	Nodes []string `json:"nodes"` //the format is regionId.instanceId\|Ip ,for example cn-hangzhou.192.168.1.2 or cn-hangzhou.i-abc
	405	DrainNode bool `json:"drain_node"` //same as Nodes
	406	}
	407
	408	//DeleteClusterNodes
	409	func (client Client) DeleteKubernetesClusterNodes(clusterId string, request DeleteKubernetesClusterNodesRequest) (*common.Response, error) {
	410	response := &common.Response{}
	411	err := client.Invoke("", http.MethodPost, fmt.Sprintf("/api/v2/clusters/%s/nodes/remove", clusterId), nil, request, response)
	412	if err != nil {
	413	return nil, err
	414	}
	415
	416	return response, nil
	417	}
	418
	419	//Cluster definition
	420	type KubernetesClusterDetail struct {
	421	RegionId common.Region `json:"region_id"`
	422
	423	Name string `json:"name"`
	424	ClusterId string `json:"cluster_id"`
	425	Size int64 `json:"size"`
	426	ClusterType KubernetesClusterType `json:"cluster_type"`
	427	Profile string `json:"profile"`
	428
	429	VpcId string `json:"vpc_id"`
	430	VSwitchIds string `json:"vswitch_id"`
	431	SecurityGroupId string `json:"security_group_id"`
	432	IngressLoadbalancerId string `json:"external_loadbalancer_id"`
	433	ResourceGroupId string `json:"resource_group_id"`
	434	NetworkMode string `json:"network_mode"`
	435	ContainerCIDR string `json:"subnet_cidr"`
	436
	437	Tags []Tag `json:"tags"`
	438	State string `json:"state"`
	439
	440	InitVersion string `json:"init_version"`
	441	CurrentVersion string `json:"current_version"`
	442	PrivateZone bool `json:"private_zone"`
	443	DeletionProtection bool `json:"deletion_protection"`
	444	MetaData string `json:"meta_data"`
	445
	446	Created time.Time `json:"created"`
	447	Updated time.Time `json:"updated"`
	448
	449	WorkerRamRoleName string `json:"worker_ram_role_name"`
	450	ClusterSpec string `json:"cluster_spec"`
	451	OSType string `json:"os_type"`
	452	MasterURL string `json:"master_url"`
	453	MaintenanceWindow MaintenanceWindow `json:"maintenance_window"`
	454	}
	455
	456	//GetMetaData
	457	func (c *KubernetesClusterDetail) GetMetaData() map[string]interface{} {
	458	m := make(map[string]interface{})
	459	_ = json.Unmarshal([]byte(c.MetaData), &m)
	460	return m
	461	}
	462
	463	//查询集群详情
	464	func (client Client) DescribeKubernetesClusterDetail(clusterId string) (KubernetesClusterDetail, error) {
	465	cluster := &KubernetesClusterDetail{}
	466	err := client.Invoke("", http.MethodGet, "/clusters/"+clusterId, nil, nil, cluster)
	467	if err != nil {
	468	return nil, err
	469	}
	470	return cluster, nil
	471	}
	472
	473	//DeleteKubernetesCluster
	474	func (client *Client) DeleteKubernetesCluster(clusterId string) error {
	475	return client.Invoke("", http.MethodDelete, "/clusters/"+clusterId, nil, nil, nil)
	476	}

+208

-0

cs/node_pool.go less more

	0	package cs
	1
	2	import (
	3	"fmt"
	4	"github.com/denverdino/aliyungo/common"
	5	"github.com/denverdino/aliyungo/ecs"
	6	"net/http"
	7	"time"
	8	)
	9
	10	type SpotPrice struct {
	11	InstanceType string `json:"instance_type"`
	12	PriceLimit string `json:"price_limit"`
	13	}
	14
	15	type NodePoolInfo struct {
	16	NodePoolId string `json:"nodepool_id"`
	17	RegionId common.Region `json:"region_id"`
	18	Name string `json:"name"`
	19	Created time.Time `json:"created"`
	20	Updated time.Time `json:"updated"`
	21	IsDefault bool `json:"is_default"`
	22	NodePoolType string `json:"type"`
	23	ResourceGroupId string `json:"resource_group_id"`
	24	}
	25
	26	type ScalingGroup struct {
	27	VpcId string `json:"vpc_id"`
	28	VswitchIds []string `json:"vswitch_ids"`
	29	InstanceTypes []string `json:"instance_types"`
	30	LoginPassword string `json:"login_password"`
	31	KeyPair string `json:"key_pair"`
	32	SecurityGroupId string `json:"security_group_id"`
	33	SystemDiskCategory ecs.DiskCategory `json:"system_disk_category"`
	34	SystemDiskSize int64 `json:"system_disk_size"`
	35	SystemDiskPerformanceLevel string `json:"system_disk_performance_level"`
	36	DataDisks []NodePoolDataDisk `json:"data_disks"` //支持多个数据盘
	37	Tags []Tag `json:"tags"`
	38	ImageId string `json:"image_id"`
	39	Platform string `json:"platform"`
	40	// 支持包年包月
	41	InstanceChargeType string `json:"instance_charge_type"`
	42	Period int `json:"period"`
	43	PeriodUnit string `json:"period_unit"`
	44	AutoRenew bool `json:"auto_renew"`
	45	AutoRenewPeriod int `json:"auto_renew_period"`
	46	// spot实例
	47	SpotStrategy string `json:"spot_strategy"`
	48	SpotPriceLimit []SpotPrice `json:"spot_price_limit"`
	49
	50	RdsInstances []string `json:"rds_instances"`
	51	ScalingPolicy string `json:"scaling_policy"`
	52	ScalingGroupId string `json:"scaling_group_id"`
	53
	54	WorkerSnapshotPolicyId string `json:"worker_system_disk_snapshot_policy_id"`
	55	// 公网ip
	56	InternetChargeType string `json:"internet_charge_type"`
	57	InternetMaxBandwidthOut int `json:"internet_max_bandwidth_out"`
	58	}
	59
	60	type AutoScaling struct {
	61	Enable bool `json:"enable"`
	62	MaxInstances int64 `json:"max_instances"`
	63	MinInstances int64 `json:"min_instances"`
	64	Type string `json:"type"`
	65	// eip
	66	IsBindEip *bool `json:"is_bond_eip"`
	67	// value: PayByBandwidth / PayByTraffic
	68	EipInternetChargeType string `json:"eip_internet_charge_type"`
	69	// default 5
	70	EipBandWidth int64 `json:"eip_bandwidth"`
	71	}
	72
	73	type KubernetesConfig struct {
	74	NodeNameMode string `json:"node_name_mode"`
	75	Taints []Taint `json:"taints"`
	76	Labels []Label `json:"labels"`
	77	CpuPolicy string `json:"cpu_policy"`
	78	UserData string `json:"user_data"`
	79
	80	Runtime string `json:"runtime,omitempty"`
	81	RuntimeVersion string `json:"runtime_version"`
	82	CmsEnabled bool `json:"cms_enabled"`
	83	OverwriteHostname bool `json:"overwrite_hostname"`
	84	Unschedulable bool `json:"unschedulable"`
	85	}
	86
	87	// 加密计算节点池
	88	type TEEConfig struct {
	89	TEEType string `json:"tee_type"`
	90	TEEEnable bool `json:"tee_enable"`
	91	}
	92
	93	// 托管节点池配置
	94	type Management struct {
	95	Enable bool `json:"enable"`
	96	AutoRepair bool `json:"auto_repair"`
	97	UpgradeConf UpgradeConf `json:"upgrade_config"`
	98	}
	99
	100	type UpgradeConf struct {
	101	AutoUpgrade bool `json:"auto_upgrade"`
	102	Surge int64 `json:"surge"`
	103	SurgePercentage int64 `json:"surge_percentage,omitempty"`
	104	MaxUnavailable int64 `json:"max_unavailable"`
	105	KeepSurgeOnFailed bool `json:"keep_surge_on_failed"`
	106	}
	107
	108	type CreateNodePoolRequest struct {
	109	RegionId common.Region `json:"region_id"`
	110	Count int64 `json:"count"`
	111	NodePoolInfo `json:"nodepool_info"`
	112	ScalingGroup `json:"scaling_group"`
	113	KubernetesConfig `json:"kubernetes_config"`
	114	AutoScaling `json:"auto_scaling"`
	115	TEEConfig `json:"tee_config"`
	116	Management `json:"management"`
	117	}
	118
	119	type BasicNodePool struct {
	120	NodePoolInfo `json:"nodepool_info"`
	121	NodePoolStatus `json:"status"`
	122	}
	123
	124	type NodePoolStatus struct {
	125	TotalNodes int `json:"total_nodes"`
	126	OfflineNodes int `json:"offline_nodes"`
	127	ServingNodes int `json:"serving_nodes"`
	128	//DesiredNodes int `json:"desired_nodes"`
	129	RemovingNodes int `json:"removing_nodes"`
	130	FailedNodes int `json:"failed_nodes"`
	131	InitialNodes int `json:"initial_nodes"`
	132	HealthyNodes int `json:"healthy_nodes"`
	133	State string `json:"state"`
	134	}
	135
	136	type NodePoolDetail struct {
	137	BasicNodePool
	138	KubernetesConfig `json:"kubernetes_config"`
	139	ScalingGroup `json:"scaling_group"`
	140	AutoScaling `json:"auto_scaling"`
	141	TEEConfig `json:"tee_config"`
	142	Management `json:"management"`
	143	}
	144
	145	type CreateNodePoolResponse struct {
	146	Response
	147	NodePoolID string `json:"nodepool_id"`
	148	Message string `json:"Message"`
	149	TaskID string `json:"task_id"`
	150	}
	151
	152	type UpdateNodePoolRequest struct {
	153	RegionId common.Region `json:"region_id"`
	154	Count int64 `json:"count"`
	155	NodePoolInfo `json:"nodepool_info"`
	156	ScalingGroup `json:"scaling_group"`
	157	KubernetesConfig `json:"kubernetes_config"`
	158	AutoScaling `json:"auto_scaling"`
	159	Management `json:"management"`
	160	}
	161
	162	type NodePoolsDetail struct {
	163	Response
	164	NodePools []NodePoolDetail `json:"nodepools"`
	165	}
	166
	167	func (client Client) CreateNodePool(request CreateNodePoolRequest, clusterId string) (*CreateNodePoolResponse, error) {
	168	response := &CreateNodePoolResponse{}
	169	err := client.Invoke(request.RegionId, http.MethodPost, fmt.Sprintf("/clusters/%s/nodepools", clusterId), nil, request, response)
	170	if err != nil {
	171	return nil, err
	172	}
	173
	174	return response, nil
	175	}
	176
	177	func (client Client) DescribeNodePoolDetail(clusterId, nodePoolId string) (NodePoolDetail, error) {
	178	nodePool := &NodePoolDetail{}
	179	err := client.Invoke("", http.MethodGet, fmt.Sprintf("/clusters/%s/nodepools/%s", clusterId, nodePoolId), nil, nil, nodePool)
	180	if err != nil {
	181	return nil, err
	182	}
	183	return nodePool, nil
	184	}
	185
	186	func (client Client) DescribeClusterNodePools(clusterId string) ([]NodePoolDetail, error) {
	187	nodePools := &NodePoolsDetail{}
	188	err := client.Invoke("", http.MethodGet, fmt.Sprintf("/clusters/%s/nodepools", clusterId), nil, nil, nodePools)
	189	if err != nil {
	190	return nil, err
	191	}
	192	return &nodePools.NodePools, nil
	193	}
	194
	195	func (client Client) UpdateNodePool(clusterId string, nodePoolId string, request UpdateNodePoolRequest) (*Response, error) {
	196	response := &Response{}
	197	err := client.Invoke(request.RegionId, http.MethodPut, fmt.Sprintf("/clusters/%s/nodepools/%s", clusterId, nodePoolId), nil, request, response)
	198	if err != nil {
	199	return nil, err
	200	}
	201
	202	return response, nil
	203	}
	204
	205	func (client *Client) DeleteNodePool(clusterId, nodePoolId string) error {
	206	return client.Invoke("", http.MethodDelete, fmt.Sprintf("/clusters/%s/nodepools/%s", clusterId, nodePoolId), nil, nil, nil)
	207	}

+98

-0

cs/node_pool_test.go less more

	0	package cs
	1
	2	import (
	3	"os"
	4	"strings"
	5	"testing"
	6	)
	7
	8	var (
	9	VpcId = os.Getenv("VpcId")
	10	VswitchIds = os.Getenv("VswitchIds")
	11	LoginPassword = os.Getenv("LoginPassword")
	12	NodePoolId = os.Getenv("NodePoolId")
	13	)
	14
	15	func Test_CreateNodePool(t *testing.T) {
	16	client := NewTestClientForDebug()
	17
	18	args := &CreateNodePoolRequest{
	19	Count: 1,
	20	RegionId: TestRegionID,
	21	NodePoolInfo: NodePoolInfo{
	22	Name: "test-npl",
	23	NodePoolType: "ess",
	24	},
	25	ScalingGroup: ScalingGroup{
	26	VpcId: VpcId,
	27	VswitchIds: strings.Split(VswitchIds, ","),
	28	InstanceTypes: []string{"ecs.n6.large"},
	29	LoginPassword: LoginPassword,
	30	SystemDiskCategory: "cloud_efficiency",
	31	SystemDiskSize: 120,
	32	DataDisks: []NodePoolDataDisk{{Size: 100, Category: "cloud_ssd"}},
	33	},
	34	KubernetesConfig: KubernetesConfig{
	35	NodeNameMode: "customized,aliyun.com,5,test",
	36	},
	37	}
	38
	39	resp, err := client.CreateNodePool(args, TestClusterId)
	40	if err != nil {
	41	t.Errorf("Error %++v", err)
	42	} else {
	43	t.Logf("response: %++v", resp)
	44	}
	45	}
	46
	47	func Test_DescribeNodePoolDetail(t *testing.T) {
	48	client := NewTestClientForDebug()
	49
	50	resp, err := client.DescribeNodePoolDetail(TestClusterId, NodePoolId)
	51	if err != nil {
	52	t.Errorf("Error %++v", err)
	53	} else {
	54	t.Logf("response: %++v", resp)
	55	}
	56	}
	57
	58	func Test_UpdateNodePool(t *testing.T) {
	59	client := NewTestClientForDebug()
	60
	61	args := &UpdateNodePoolRequest{
	62	Count: 2,
	63	RegionId: TestRegionID,
	64	ScalingGroup: ScalingGroup{
	65	InstanceTypes: []string{"ecs.n4.large"},
	66	},
	67	}
	68
	69	resp, err := client.UpdateNodePool(TestClusterId, NodePoolId, args)
	70	if err != nil {
	71	t.Errorf("Error %++v", err)
	72	} else {
	73	t.Logf("response: %++v", resp)
	74	}
	75	}
	76
	77	func Test_DeleteNodePool(t *testing.T) {
	78	client := NewTestClientForDebug()
	79
	80	err := client.DeleteNodePool(TestClusterId, NodePoolId)
	81	if err != nil {
	82	t.Errorf("Error %++v", err)
	83	} else {
	84	t.Logf("success")
	85	}
	86	}
	87
	88	func Test_DescribeClusterNodePools(t *testing.T) {
	89	client := NewTestClientForDebug()
	90
	91	resp, err := client.DescribeClusterNodePools(TestClusterId)
	92	if err != nil {
	93	t.Errorf("Error %++v", err)
	94	} else {
	95	t.Logf("response: %++v", resp)
	96	}
	97	}

+11

-3

cs/projects_client.go less more

66	66	client.userAgent = userAgent
67	67	}
68	68
	69	// SetTransport sets transport to the http client
	70	func (client *ProjectClient) SetTransport(transport http.RoundTripper) {
	71	if client.httpClient == nil {
	72	client.httpClient = &http.Client{}
	73	}
	74	client.httpClient.Transport = transport
	75	}
	76
69	77	func (client *ProjectClient) ClusterId() string {
70	78	return client.clusterId
71	79	}

133	141
134	142	if client.debug {
135	143	var prettyJSON bytes.Buffer
136		err = json.Indent(&prettyJSON, body, "", " ")
137		log.Println(string(prettyJSON.Bytes()))
	144	_ = json.Indent(&prettyJSON, body, "", " ")
	145	log.Println(prettyJSON.String())
138	146	}
139	147
140	148	if statusCode >= 400 && statusCode <= 599 {
141	149	errorResponse := common.ErrorResponse{}
142		err = json.Unmarshal(body, &errorResponse)
	150	_ = json.Unmarshal(body, &errorResponse)
143	151	ecsError := &common.Error{
144	152	ErrorResponse: errorResponse,
145	153	StatusCode: statusCode,

+135

-0

cs/serverless.go less more

	0	package cs
	1
	2	import (
	3	"fmt"
	4	"github.com/denverdino/aliyungo/common"
	5	"net/http"
	6	"net/url"
	7	"strconv"
	8	"time"
	9	)
	10
	11	type ServerlessCreationArgs struct {
	12	ClusterType KubernetesClusterType `json:"cluster_type"`
	13	Name string `json:"name"`
	14	RegionId string `json:"region_id"`
	15	VpcId string `json:"vpc_id"`
	16	VSwitchId string `json:"vswitch_id"`
	17	VswitchIds []string `json:"vswitch_ids"`
	18	EndpointPublicAccess bool `json:"public_slb"`
	19	PrivateZone bool `json:"private_zone"`
	20	NatGateway bool `json:"nat_gateway"`
	21	KubernetesVersion string `json:"kubernetes_version"`
	22	DeletionProtection bool `json:"deletion_protection"`
	23	SecurityGroupId string `json:"security_group_id"`
	24	Tags []Tag `json:"tags"`
	25	Addons []Addon `json:"addons"`
	26	ResourceGroupId string `json:"resource_group_id"`
	27	ClusterSpec string `json:"cluster_spec"`
	28	LoadBalancerSpec string `json:"load_balancer_spec"` //api server slb实例规格
	29	ServiceCIDR string `json:"service_cidr"`
	30	TimeZone string `json:"timezone"`
	31	ServiceDiscoveryTypes []string `json:"service_discovery_types"`
	32	ZoneID string `json:"zone_id"`
	33	LoggingType string `json:"logging_type"`
	34	SLSProjectName string `json:"sls_project_name"`
	35	}
	36
	37	type ServerlessClusterResponse struct {
	38	ClusterId string `json:"cluster_id"`
	39	Name string `json:"name"`
	40	ClusterType KubernetesClusterType `json:"cluster_type"`
	41	RegionId string `json:"region_id"`
	42	State ClusterState `json:"state"`
	43	VpcId string `json:"vpc_id"`
	44	VSwitchId string `json:"vswitch_id"`
	45	SecurityGroupId string `json:"security_group_id"`
	46	Tags []Tag `json:"tags"`
	47	Created time.Time `json:"created"`
	48	Updated time.Time `json:"updated"`
	49	InitVersion string `json:"init_version"`
	50	CurrentVersion string `json:"current_version"`
	51	PrivateZone bool `json:"private_zone"`
	52	DeletionProtection bool `json:"deletion_protection"`
	53	ResourceGroupId string `json:"resource_group_id"`
	54	ClusterSpec string `json:"cluster_spec"`
	55	}
	56
	57	type Tag struct {
	58	Key string `json:"key"`
	59	Value string `json:"value"`
	60	}
	61
	62	func (this *ServerlessCreationArgs) Validate() error {
	63	if this.Name == "" \|\| this.RegionId == "" \|\| this.VpcId == "" {
	64	return common.GetCustomError("InvalidParameters", "The name,region_id,vpc_id not allowed empty")
	65	}
	66	return nil
	67	}
	68
	69	//create Serverless cluster
	70	func (client Client) CreateServerlessKubernetesCluster(args ServerlessCreationArgs) (*ClusterCommonResponse, error) {
	71	if args == nil {
	72	return nil, common.GetCustomError("InvalidArgs", "The args is nil ")
	73	}
	74
	75	if err := args.Validate(); err != nil {
	76	return nil, err
	77	}
	78
	79	//reset clusterType,
	80	args.ClusterType = ServerlessKubernetes
	81	cluster := &ClusterCommonResponse{}
	82	path := "/clusters"
	83	if args.ResourceGroupId != "" {
	84	// 创建集群到指定资源组
	85	path = fmt.Sprintf("/resource_groups/%s/clusters", args.ResourceGroupId)
	86	}
	87	err := client.Invoke(common.Region(args.RegionId), http.MethodPost, path, nil, args, &cluster)
	88	if err != nil {
	89	return nil, err
	90	}
	91	return cluster, nil
	92	}
	93
	94	//describe Serverless cluster
	95	func (client Client) DescribeServerlessKubernetesCluster(clusterId string) (ServerlessClusterResponse, error) {
	96	cluster := &ServerlessClusterResponse{}
	97	err := client.Invoke("", http.MethodGet, "/clusters/"+clusterId, nil, nil, cluster)
	98	if err != nil {
	99	return nil, err
	100	}
	101	return cluster, nil
	102	}
	103
	104	//describe Serverless clsuters
	105	func (client Client) DescribeServerlessKubernetesClusters() ([]ServerlessClusterResponse, error) {
	106	allClusters := make([]*ServerlessClusterResponse, 0)
	107	askClusters := make([]*ServerlessClusterResponse, 0)
	108
	109	err := client.Invoke("", http.MethodGet, "/clusters", nil, nil, &allClusters)
	110	if err != nil {
	111	return askClusters, err
	112	}
	113
	114	for _, cluster := range allClusters {
	115	if cluster.ClusterType == ClusterTypeServerlessKubernetes {
	116	askClusters = append(askClusters, cluster)
	117	}
	118	}
	119
	120	return askClusters, nil
	121	}
	122
	123	//new api for get cluster kube user config
	124	func (client Client) DescribeClusterUserConfig(clusterId string, privateIpAddress bool) (ClusterConfig, error) {
	125	config := &ClusterConfig{}
	126	query := url.Values{}
	127	query.Add("PrivateIpAddress", strconv.FormatBool(privateIpAddress))
	128
	129	err := client.Invoke("", http.MethodGet, "/k8s/"+clusterId+"/user_config", query, nil, &config)
	130	if err != nil {
	131	return nil, err
	132	}
	133	return config, nil
	134	}

+93

-0

cs/serverless_test.go less more

	0	package cs
	1
	2	import (
	3	"fmt"
	4	"testing"
	5	"time"
	6	)
	7
	8	func Test_CreateServerlessKubernetesCluster(t *testing.T) {
	9	client := NewTestClientForDebug()
	10
	11	tags := make([]Tag, 0)
	12	tags = append(tags, Tag{
	13	Key: "key-a",
	14	Value: "key-a",
	15	})
	16
	17	tags = append(tags, Tag{
	18	Key: "key-b",
	19	Value: "key-b",
	20	})
	21
	22	tags = append(tags, Tag{
	23	Key: "key-c",
	24	Value: "key-c",
	25	})
	26
	27	args := &ServerlessCreationArgs{
	28	ClusterType: ClusterTypeServerlessKubernetes,
	29	Name: fmt.Sprintf("Serverless-cluster-%d", time.Now().Unix()),
	30	RegionId: string(TestRegionID),
	31	VpcId: TestVpcId,
	32	VSwitchId: TestVSwitchId,
	33	PrivateZone: true,
	34	EndpointPublicAccess: true,
	35	NatGateway: true,
	36	DeletionProtection: true,
	37	Tags: tags,
	38	}
	39
	40	response, err := client.CreateServerlessKubernetesCluster(args)
	41	if err != nil {
	42	t.Errorf("Error %++v", err)
	43	} else {
	44	t.Logf("Response = %++v", response)
	45	}
	46	}
	47
	48	func Test_DescribeCluster(t *testing.T) {
	49	client := NewTestClientForDebug()
	50
	51	cluster, err := client.DescribeServerlessKubernetesCluster(TestClusterId)
	52	if err != nil {
	53	t.Errorf("Error = %++v", err)
	54	} else {
	55	t.Logf("Cluster = %#v", cluster)
	56	t.Logf("%v ", cluster.Created)
	57	}
	58	}
	59
	60	func Test_DescribeClusterUserConfig(t *testing.T) {
	61	client := NewTestClientForDebug()
	62
	63	config, err := client.DescribeClusterUserConfig(TestClusterId, TestPrivateIpAddress)
	64	if err != nil {
	65	t.Errorf("Error = %++v", err)
	66	} else {
	67	t.Logf("Config = %#v", config)
	68	}
	69	}
	70
	71	func Test_DeleteServerlessCluster(t *testing.T) {
	72	client := NewTestClientForDebug()
	73
	74	err := client.DeleteCluster(TestClusterId)
	75	if err != nil {
	76	t.Errorf("Error = %++v", err)
	77	} else {
	78	t.Logf("OK")
	79	}
	80	}
	81
	82	func Test_DescribeServerlessKubernetesClusters(t *testing.T) {
	83	client := NewTestClientForDebug()
	84	clusters, err := client.DescribeServerlessKubernetesClusters()
	85	if err != nil {
	86	t.Errorf("Error = %++v", err)
	87	} else {
	88	for _, cluster := range clusters {
	89	t.Logf("Cluster = %#v", cluster)
	90	}
	91	}
	92	}

+49

-0

cs/token.go less more

	0	package cs
	1
	2	import (
	3	"fmt"
	4	"github.com/denverdino/aliyungo/common"
	5	"net/http"
	6	)
	7
	8	type ClusterTokenReqeust struct {
	9	//token 过期时间,如果不填写，则默认24小时过期
	10	Expired int64 `json:"expired"`
	11	IsPermanently bool `json:"is_permanently"`
	12	}
	13
	14	type ClusterTokenResponse struct {
	15	Created int64 ` json:"created"`
	16	Updated int64 `json:"updated"`
	17	Expired int64 ` json:"expired"`
	18
	19	ClusterID string ` json:"cluster_id"`
	20
	21	Token string ` json:"token"`
	22	IsActive int ` json:"is_active"`
	23	}
	24
	25	func (client Client) CreateClusterToken(clusterId string, request ClusterTokenReqeust) (*ClusterTokenResponse, error) {
	26	response := &ClusterTokenResponse{}
	27	err := client.Invoke("", http.MethodPost, "/clusters/"+clusterId+"/token", nil, request, response)
	28	return response, err
	29	}
	30
	31	func (client *Client) RevokeToken(token string) error {
	32	return client.Invoke("", http.MethodDelete, "/token/"+token+"/revoke", nil, nil, nil)
	33	}
	34
	35	func (client Client) DescribeClusterTokens(clusterId string) ([]ClusterTokenResponse, error) {
	36	response := make([]*ClusterTokenResponse, 0)
	37	err := client.Invoke("", http.MethodGet, "/clusters/"+clusterId+"/tokens", nil, nil, &response)
	38	return response, err
	39	}
	40
	41	func (client Client) DescribeClusterToken(clusterId, token string) (ClusterTokenResponse, error) {
	42	if clusterId == "" \|\| token == "" {
	43	return nil, common.GetCustomError("InvalidParamter", "The clusterId or token is empty")
	44	}
	45	tokenInfo := &ClusterTokenResponse{}
	46	err := client.Invoke("", http.MethodGet, fmt.Sprintf("/clusters/%s/tokens/%s", clusterId, token), nil, nil, tokenInfo)
	47	return tokenInfo, err
	48	}

+73

-0

cs/token_test.go less more

	0	package cs
	1
	2	import (
	3	"testing"
	4	"time"
	5	)
	6
	7	func Test_CreateClusterToken(t *testing.T) {
	8	client := NewTestClientForDebug()
	9
	10	req := &ClusterTokenReqeust{
	11	Expired: time.Now().Unix() + 86400,
	12	IsPermanently: false,
	13	}
	14
	15	token, err := client.CreateClusterToken(TestClusterId, req)
	16	if err != nil {
	17	t.Fatalf("Error %++v", err)
	18	} else {
	19	t.Logf("Token = %++v", token)
	20	}
	21	}
	22
	23	func Test_RevokeClusterToken(t *testing.T) {
	24	client := NewTestClientForDebug()
	25	req := &ClusterTokenReqeust{
	26	Expired: time.Now().Unix() + 86400,
	27	IsPermanently: false,
	28	}
	29
	30	token, err := client.CreateClusterToken(TestClusterId, req)
	31	if err != nil {
	32	t.Fatalf("Error = %++v", err)
	33	} else {
	34	err = client.RevokeToken(token.Token)
	35	if err != nil {
	36	t.Fatalf("Error = %++v", err)
	37	} else {
	38	tokens, err := client.DescribeClusterTokens(TestClusterId)
	39	if err != nil {
	40	t.Fatalf("Error %++v", err)
	41	} else {
	42	for _, token := range tokens {
	43	t.Logf("Token = %++v", token)
	44	}
	45	}
	46	}
	47	}
	48	}
	49
	50	func Test_DescribeClusterTokens(t *testing.T) {
	51	client := NewTestClientForDebug()
	52
	53	tokens, err := client.DescribeClusterTokens(TestClusterId)
	54	if err != nil {
	55	t.Fatalf("Error %++v", err)
	56	} else {
	57	for _, token := range tokens {
	58	t.Logf("Token = %++v", token)
	59	}
	60	}
	61	}
	62
	63	func Test_DescribeClusterToken(t *testing.T) {
	64	client := NewTestClientForDebug()
	65
	66	token, err := client.DescribeClusterToken(TestClusterId, TestToken)
	67	if err != nil {
	68	t.Fatalf("Error %++v", err)
	69	} else {
	70	t.Logf("Token = %++v", token)
	71	}
	72	}

+47

-0

ecs/client.go less more

63	63	return NewECSClientWithEndpointAndSecurityToken(endpoint, accessKeyId, accessKeySecret, securityToken, regionID)
64	64	}
65	65
	66	//only for Hangzhou Regional Domain
	67	func NewECSClientWithSecurityToken4RegionalDomain(accessKeyId string, accessKeySecret string, securityToken string, regionID common.Region) *Client {
	68	endpoint := os.Getenv("ECS_ENDPOINT")
	69	if endpoint != "" {
	70	return NewECSClientWithSecurityToken(accessKeyId, accessKeySecret, securityToken, regionID)
	71	}
	72
	73	return NewECSClientWithEndpointAndSecurityToken4RegionalDomain(endpoint, accessKeyId, accessKeySecret, securityToken, regionID)
	74	}
	75
66	76	func NewECSClientWithEndpoint(endpoint string, accessKeyId string, accessKeySecret string, regionID common.Region) *Client {
67	77	return NewECSClientWithEndpointAndSecurityToken(endpoint, accessKeyId, accessKeySecret, "", regionID)
68	78	}

77	87	WithServiceCode(ECSServiceCode).
78	88	WithRegionID(regionID).
79	89	InitClient()
	90	return client
	91	}
	92
	93	func NewECSClientWithEndpointAndSecurityToken4RegionalDomain(endpoint string, accessKeyId string, accessKeySecret string, securityToken string, regionID common.Region) *Client {
	94	client := &Client{}
	95	client.WithEndpoint(endpoint).
	96	WithVersion(ECSAPIVersion).
	97	WithAccessKeyId(accessKeyId).
	98	WithAccessKeySecret(accessKeySecret).
	99	WithSecurityToken(securityToken).
	100	WithServiceCode(ECSServiceCode).
	101	WithRegionID(regionID).
	102	InitClient4RegionalDomain()
80	103	return client
81	104	}
82	105

96	119	return NewVPCClientWithEndpointAndSecurityToken(endpoint, accessKeyId, accessKeySecret, securityToken, regionID)
97	120	}
98	121
	122	//Only for Hangzhou
	123	func NewVPCClientWithSecurityToken4RegionalDomain(accessKeyId string, accessKeySecret string, securityToken string, regionID common.Region) *Client {
	124	endpoint := os.Getenv("VPC_ENDPOINT")
	125	if endpoint != "" {
	126	return NewVPCClientWithEndpointAndSecurityToken(endpoint, accessKeyId, accessKeySecret, securityToken, regionID)
	127	}
	128
	129	return NewVPCClientWithEndpointAndSecurityToken4RegionalDomain(endpoint, accessKeyId, accessKeySecret, securityToken, regionID)
	130	}
	131
99	132	func NewVPCClientWithEndpoint(endpoint string, accessKeyId string, accessKeySecret string, regionID common.Region) *Client {
100	133	return NewVPCClientWithEndpointAndSecurityToken(endpoint, accessKeyId, accessKeySecret, "", regionID)
101	134	}

113	146	return client
114	147	}
115	148
	149	//Only for Hangzhou
	150	func NewVPCClientWithEndpointAndSecurityToken4RegionalDomain(endpoint string, accessKeyId string, accessKeySecret string, securityToken string, regionID common.Region) *Client {
	151	client := &Client{}
	152	client.WithEndpoint(endpoint).
	153	WithVersion(VPCAPIVersion).
	154	WithAccessKeyId(accessKeyId).
	155	WithAccessKeySecret(accessKeySecret).
	156	WithSecurityToken(securityToken).
	157	WithServiceCode(VPCServiceCode).
	158	WithRegionID(regionID).
	159	InitClient4RegionalDomain()
	160	return client
	161	}
	162
116	163	// ---------------------------------------
117	164	// NewVPCClientWithRegion creates a new instance of VPC client automatically get endpoint
118	165	// ---------------------------------------

+12

-0

ecs/client_test.go less more

0	0	package ecs
1	1
2	2	import (
	3	"github.com/denverdino/aliyungo/common"
	4	"github.com/magiconair/properties/assert"
	5	"os"
3	6	"testing"
4	7	)
5	8

72	75	}
73	76	}
74	77	}
	78
	79	func Test_NewVPCClientWithSecurityToken4RegionalDomain(t *testing.T) {
	80	client := NewVPCClientWithSecurityToken4RegionalDomain(TestAccessKeyId, TestAccessKeySecret, TestSecurityToken, common.Beijing)
	81	assert.Equal(t, client.GetEndpoint(), "https://vpc-vpc.cn-beijing.aliyuncs.com")
	82
	83	os.Setenv("VPC_ENDPOINT", "vpc.aliyuncs.com")
	84	client = NewVPCClientWithSecurityToken4RegionalDomain(TestAccessKeyId, TestAccessKeySecret, TestSecurityToken, common.Beijing)
	85	assert.Equal(t, client.GetEndpoint(), "vpc.aliyuncs.com")
	86	}

+3

-3

ecs/config_test.go less more

0	0	package ecs
1	1
2	2	import (
	3	"github.com/denverdino/aliyungo/common"
3	4	"os"
4
5		"github.com/denverdino/aliyungo/common"
6	5	)
7	6
8	7	//Modify with your Access Key Id and Access Key Secret

13	12	TestSecurityToken = os.Getenv("SecurityToken")
14	13	TestRegionID = common.Region(os.Getenv("RegionId"))
15	14	TestVpcId = os.Getenv("VpcId")
	15	TestVswitchID = os.Getenv("TestVswitchID")
16	16
17	17	TestInstanceId = os.Getenv("InstanceId")
18	18	TestSecurityGroupId = "MY_TEST_SECURITY_GROUP_ID"

58	58
59	59	func NetTestLocationClientForDebug() *Client {
60	60	if testLocationClient == nil {
61		testLocationClient = NewECSClient(TestAccessKeyId, TestAccessKeySecret, TestRegionID)
	61	testLocationClient = NewECSClientWithSecurityToken4RegionalDomain(TestAccessKeyId, TestAccessKeySecret, TestSecurityToken, TestRegionID)
62	62	testLocationClient.SetDebug(true)
63	63	}
64	64

+19

-1

ecs/disks.go less more

25	25	DiskCategoryEphemeralSSD = DiskCategory("ephemeral_ssd")
26	26	DiskCategoryCloudEfficiency = DiskCategory("cloud_efficiency")
27	27	DiskCategoryCloudSSD = DiskCategory("cloud_ssd")
	28	DiskCategoryCloudESSD = DiskCategory("cloud_essd")
	29	)
	30
	31	// Performance Level of disks
	32	type DiskPerformanceLevel string
	33
	34	const (
	35	DiskPL0 = DiskCategory("PL0")
	36	DiskPL1 = DiskCategory("PL1")
	37	DiskPL2 = DiskCategory("PL2")
	38	DiskPL3 = DiskCategory("PL3")
28	39	)
29	40
30	41	// Status of disks

95	106	AttachedTime util.ISO6801Time
96	107	DetachedTime util.ISO6801Time
97	108	DiskChargeType DiskChargeType
	109	StorageSetId string
	110	PerformanceLevel DiskPerformanceLevel
98	111	}
99	112
100	113	type DescribeDisksResponse struct {

138	151	Encrypted bool
139	152	DiskCategory DiskCategory
140	153	Size int
	154	Tag map[string]string
141	155	SnapshotId string
142	156	ClientToken string
	157	KMSKeyID string
	158	StorageSetId string
	159
	160	PerformanceLevel DiskPerformanceLevel
143	161	}
144	162
145	163	type CreateDisksResponse struct {

346	364	if err != nil {
347	365	return err
348	366	}
349		if disks == nil \|\| len(disks) == 0 {
	367	if len(disks) == 0 {
350	368	return common.GetClientErrorFromString("Not found")
351	369	}
352	370	if disks[0].Status == status {

+82

-11

ecs/eni.go less more

4	4	"time"
5	5
6	6	"github.com/denverdino/aliyungo/common"
	7	"github.com/denverdino/aliyungo/util"
7	8	)
8	9
9	10	type CreateNetworkInterfaceArgs struct {
10		RegionId common.Region
11		VSwitchId string
12		PrimaryIpAddress string // optional
13		SecurityGroupId string
14		NetworkInterfaceName string // optional
15		Description string // optional
16		ClientToken string // optional
	11	RegionId common.Region
	12	VSwitchId string
	13	PrimaryIpAddress string // optional
	14	SecurityGroupId string
	15	NetworkInterfaceName string // optional
	16	Description string // optional
	17	ClientToken string // optional
	18	Tag map[string]string // optional
	19	ResourceGroupId string // optional
	20	SecurityGroupIds []string `query:"list"` // optional
	21	PrivateIpAddress []string `query:"list"` // optional
	22	SecondaryPrivateIpAddressCount int
17	23	}
18	24
19	25	type CreateNetworkInterfaceResponse struct {

32	38	type DescribeNetworkInterfacesArgs struct {
33	39	RegionId common.Region
34	40	VSwitchId string
	41	VpcID string
35	42	PrimaryIpAddress string
	43	PrivateIpAddress []string `query:"list"`
36	44	SecurityGroupId string
37	45	NetworkInterfaceName string
38	46	Type string

45	53	NetworkInterfaceId string
46	54	NetworkInterfaceName string
47	55	PrimaryIpAddress string
48		MacAddress string
49		Status string
50		PrivateIpAddress string
	56	PrivateIpSets struct {
	57	PrivateIpSet []PrivateIpType
	58	}
	59	MacAddress string
	60	Status string
	61	Type string
	62	VpcId string
	63	VSwitchId string
	64	ZoneId string
	65	AssociatedPublicIp AssociatedPublicIp
	66	SecurityGroupIds struct {
	67	SecurityGroupId []string
	68	}
	69	Description string
	70	InstanceId string
	71	CreationTime util.ISO6801Time
	72	PrivateIpAddress string
	73	}
	74
	75	type PrivateIpType struct {
	76	PrivateIpAddress string
	77	Primary bool
	78	AssociatedPublicIp AssociatedPublicIp
	79	}
	80
	81	type AssociatedPublicIp struct {
	82	PublicIpAddress string
	83	AllocationId string
51	84	}
52	85
53	86	type DescribeNetworkInterfacesResponse struct {

74	107	type ModifyNetworkInterfaceAttributeArgs struct {
75	108	RegionId common.Region
76	109	NetworkInterfaceId string
77		SecurityGroupId []string
	110	SecurityGroupId []string `query:"list"`
78	111	NetworkInterfaceName string
79	112	Description string
80	113	}
81	114	type ModifyNetworkInterfaceAttributeResponse common.Response
	115
	116	type UnassignPrivateIpAddressesArgs struct {
	117	RegionId common.Region
	118	NetworkInterfaceId string
	119	PrivateIpAddress []string `query:"list"`
	120	}
	121
	122	type UnassignPrivateIpAddressesResponse common.Response
	123
	124	type AssignPrivateIpAddressesArgs struct {
	125	RegionId common.Region
	126	NetworkInterfaceId string
	127	PrivateIpAddress []string `query:"list"` // optional
	128	SecondaryPrivateIpAddressCount int // optional
	129	}
	130
	131	type AssignPrivateIpAddressesResponse struct {
	132	common.Response
	133
	134	AssignedPrivateIpAddressesSet struct {
	135	NetworkInterfaceId string
	136	PrivateIpSet struct {
	137	PrivateIpAddress []string
	138	}
	139	}
	140	}
82	141
83	142	func (client Client) CreateNetworkInterface(args CreateNetworkInterfaceArgs) (resp *CreateNetworkInterfaceResponse, err error) {
84	143	resp = &CreateNetworkInterfaceResponse{}

116	175	return resp, err
117	176	}
118	177
	178	func (client Client) UnassignPrivateIpAddresses(args UnassignPrivateIpAddressesArgs) (resp *UnassignPrivateIpAddressesResponse, err error) {
	179	resp = &UnassignPrivateIpAddressesResponse{}
	180	err = client.Invoke("UnassignPrivateIpAddresses", args, resp)
	181	return resp, err
	182	}
	183
	184	func (client Client) AssignPrivateIpAddresses(args AssignPrivateIpAddressesArgs) (resp *AssignPrivateIpAddressesResponse, err error) {
	185	resp = &AssignPrivateIpAddressesResponse{}
	186	err = client.Invoke("AssignPrivateIpAddresses", args, resp)
	187	return resp, err
	188	}
	189
119	190	// Default timeout value for WaitForInstance method
120	191	const NetworkInterfacesDefaultTimeout = 120
121	192

+109

-0

ecs/eni_test.go less more

	0	package ecs
	1
	2	import (
	3	"github.com/denverdino/aliyungo/common"
	4	"testing"
	5	"time"
	6	)
	7
	8	func TestAssignPrivateIPAddresses(t *testing.T) {
	9	req := AssignPrivateIpAddressesArgs{
	10	RegionId: common.Beijing,
	11	NetworkInterfaceId: "eni-testeni",
	12	PrivateIpAddress: []string{"192.168.1.200", "192.168.1.201"},
	13	}
	14	client := NewTestClient()
	15	assignPrivateIpAddressesResponse, err := client.AssignPrivateIpAddresses(&req)
	16	if err != nil {
	17	t.Errorf("Failed to AssignPrivateIpAddresses: %v", err)
	18	}
	19
	20	if assignPrivateIpAddressesResponse.AssignedPrivateIpAddressesSet.NetworkInterfaceId != "eni-testeni" {
	21	t.Errorf("assert network id mismatch.%s\n", assignPrivateIpAddressesResponse.AssignedPrivateIpAddressesSet.NetworkInterfaceId)
	22	}
	23
	24	time.Sleep(5 * time.Second)
	25
	26	req = AssignPrivateIpAddressesArgs{
	27	RegionId: common.Beijing,
	28	NetworkInterfaceId: "eni-testeni",
	29	SecondaryPrivateIpAddressCount: 1,
	30	}
	31
	32	_, err = client.AssignPrivateIpAddresses(&req)
	33	if err != nil {
	34	t.Errorf("Failed to AssignPrivateIpAddresses: %v", err)
	35	}
	36	}
	37
	38	func TestDescribeENI(t *testing.T) {
	39	req := DescribeNetworkInterfacesArgs{
	40	RegionId: common.Beijing,
	41	NetworkInterfaceId: []string{"eni-testeni"},
	42	}
	43	client := NewTestClient()
	44	resp, err := client.DescribeNetworkInterfaces(&req)
	45	if err != nil {
	46	t.Errorf("Failed to DescribeNetworkInterfaces: %v", err)
	47	}
	48	if len(resp.NetworkInterfaceSets.NetworkInterfaceSet[0].PrivateIpSets.PrivateIpSet) != 4 {
	49	t.Errorf("assert network private ip count be 4, %+v", resp.NetworkInterfaceSets.NetworkInterfaceSet[0].PrivateIpSets.PrivateIpSet)
	50	}
	51	t.Logf("%+v", resp.NetworkInterfaceSets.NetworkInterfaceSet[0])
	52	}
	53
	54	func TestFindENIByPrivateIP(t *testing.T) {
	55	req := DescribeNetworkInterfacesArgs{
	56	RegionId: common.Shanghai,
	57	VpcID: "vpc-xxx",
	58	PrivateIpAddress: []string{"192.168.108.191"},
	59	}
	60	client := NewTestClient()
	61	resp, err := client.DescribeNetworkInterfaces(&req)
	62	if err != nil {
	63	t.Errorf("Failed to DescribeNetworkInterfaces: %v", err)
	64	}
	65	t.Logf("%+v", resp.NetworkInterfaceSets.NetworkInterfaceSet)
	66	}
	67
	68	func TestUnAssignPrivateIPAddresses(t *testing.T) {
	69	req := UnassignPrivateIpAddressesArgs{
	70	RegionId: common.Beijing,
	71	NetworkInterfaceId: "eni-testeni",
	72	PrivateIpAddress: []string{"192.168.1.200", "192.168.1.201"},
	73	}
	74	client := NewTestClient()
	75	_, err := client.UnassignPrivateIpAddresses(&req)
	76	if err != nil {
	77	t.Errorf("Failed to UnAssignPrivateIpAddresses: %v", err)
	78	}
	79	}
	80
	81	func TestModifyNetworkInterfaceAttribute(t *testing.T) {
	82	args := &ModifyNetworkInterfaceAttributeArgs{
	83	RegionId: common.Shanghai,
	84	NetworkInterfaceId: "eni-testeni",
	85	SecurityGroupId: []string{"sg-xxx", "sg-yyy"},
	86	}
	87
	88	client := NewTestClient()
	89	_, err := client.ModifyNetworkInterfaceAttribute(args)
	90	if err != nil {
	91	t.Errorf("failed to ModifyNetworkInterfaceAttribute: %v", err)
	92	}
	93	}
	94
	95	func TestCreateNetworkInterface(t *testing.T) {
	96	args := &CreateNetworkInterfaceArgs{
	97	RegionId: common.Shanghai,
	98	VSwitchId: "vsw-xxx",
	99	SecurityGroupIds: []string{"sg-xxx", "sg-yyy"},
	100	SecondaryPrivateIpAddressCount: 9,
	101	}
	102	client := NewTestClient()
	103	resp, err := client.CreateNetworkInterface(args)
	104	if err != nil {
	105	t.Errorf("failed to CreateNetworkInterface: %v", err)
	106	}
	107	t.Logf("new eni info: %+v", resp)
	108	}

+1

-1

ecs/images.go less more

312	312	if err != nil {
313	313	return err
314	314	}
315		if images == nil \|\| len(images) == 0 {
	315	if len(images) == 0 {
316	316	args.Status = ImageStatusAvailable
317	317	images, _, er := client.DescribeImages(&args)
318	318	if er == nil && len(images) == 1 {

+14

-12

ecs/instance_types.go less more

3	3
4	4	type DescribeInstanceTypesArgs struct {
5	5	InstanceTypeFamily string
	6	InstanceTypes []string `query:"list"`
6	7	}
7	8
8	9	//
9	10	// You can read doc at http://docs.aliyun.com/#/pub/ecs/open-api/datatype&instancetypeitemtype
10	11	type InstanceTypeItemType struct {
11		InstanceTypeId string
12		CpuCoreCount int
13		MemorySize float64
14		InstanceTypeFamily string
15		GPUAmount int
16		GPUSpec string
17		InitialCredit int
18		BaselineCredit int
19		EniQuantity int
20		LocalStorageCapacity int
21		LocalStorageAmount int
22		LocalStorageCategory string
	12	InstanceTypeId string
	13	CpuCoreCount int
	14	MemorySize float64
	15	InstanceTypeFamily string
	16	GPUAmount int
	17	GPUSpec string
	18	InitialCredit int
	19	BaselineCredit int
	20	EniQuantity int
	21	EniPrivateIpAddressQuantity int
	22	LocalStorageCapacity int
	23	LocalStorageAmount int
	24	LocalStorageCategory string
23	25	}
24	26
25	27	type DescribeInstanceTypesResponse struct {

+10

-1

ecs/instance_types_test.go less more

4	4	)
5	5
6	6	func TestDescribeInstanceTypes(t *testing.T) {
7
8	7	client := NewTestClient()
9	8	instanceTypes, err := client.DescribeInstanceTypes()
10	9	if err != nil {

13	12	for _, instanceType := range instanceTypes {
14	13	t.Logf("InstanceType: %++v", instanceType)
15	14	}
	15
	16	instanceTypes, err = client.DescribeInstanceTypesNew(&DescribeInstanceTypesArgs{
	17	InstanceTypes: []string{"ecs.ec5.24xlarge", "ecs.ddh6s.custom.c4m48"},
	18	})
	19	if err != nil {
	20	t.Fatalf("Failed to DescribeInstanceTypesNew: %v", err)
	21	}
	22	for _, instanceType := range instanceTypes {
	23	t.Logf("InstanceType: %++v", instanceType)
	24	}
16	25	}

+6

-4

ecs/instances.go less more

490	490	}
491	491
492	492	type SystemDiskType struct {
493		Size int
494		Category DiskCategory //Enum cloud, ephemeral, ephemeral_ssd
495		DiskName string
496		Description string
	493	Size int
	494	Category DiskCategory //Enum cloud, ephemeral, ephemeral_ssd
	495	DiskName string
	496	Description string
	497	PerformanceLevel DiskPerformanceLevel
	498	AutoSnapshotPolicyId string
497	499	}
498	500
499	501	type IoOptimized string

+1

-1

ecs/instances_test.go less more

331	331	RegionId: TestRegionID,
332	332	Pagination: common.Pagination{
333	333	PageNumber: 1,
334		PageSize: 100,
	334	PageSize: 2,
335	335	},
336	336	//SecurityToken: TestSecurityToken,
337	337	}

+10

-0

ecs/nat_gateway.go less more

1	1
2	2	import (
3	3	"github.com/denverdino/aliyungo/common"
	4	)
	5
	6	type NatType string
	7
	8	const (
	9	NgwNatTypeNormal = NatType("Normal")
	10	NgwNatTypeEnhanced = NatType("Enhanced")
4	11	)
5	12
6	13	type BandwidthPackageType struct {

12	19	type CreateNatGatewayArgs struct {
13	20	RegionId common.Region
14	21	VpcId string
	22	VSwitchId string
15	23	Spec string
16	24	BandwidthPackage []BandwidthPackageType
17	25	Name string
18	26	Description string
	27	NatType NatType
19	28	ClientToken string
20	29	}
21	30

74	83	Spec string
75	84	Status string
76	85	VpcId string
	86	NatType NatType
77	87	}
78	88
79	89	type DescribeNatGatewayResponse struct {

+17

-0

ecs/nat_gateway_test.go less more

37	37	}
38	38	}
39	39	}
	40
	41	func TestClient_CreateNatGateway(t *testing.T) {
	42	client := NewVpcTestClientForDebug()
	43	args := &CreateNatGatewayArgs{
	44	RegionId: TestRegionID,
	45	VpcId: TestVpcId,
	46	VSwitchId: TestVswitchID,
	47	NatType: NgwNatTypeEnhanced,
	48	}
	49
	50	resp, err := client.CreateNatGateway(args)
	51	if err != nil {
	52	t.Fatalf("Error %++v", err)
	53	} else {
	54	t.Logf("ngw id :%s", resp.NatGatewayId)
	55	}
	56	}

+38

-17

ecs/networks.go less more

85	85	type EipInstanceType string
86	86
87	87	const (
88		EcsInstance = "EcsInstance"
89		SlbInstance = "SlbInstance"
90		Nat = "Nat"
91		HaVip = "HaVip"
	88	EcsInstance = "EcsInstance"
	89	SlbInstance = "SlbInstance"
	90	Nat = "Nat"
	91	HaVip = "HaVip"
	92	NetworkInterface = "NetworkInterface"
	93	)
	94
	95	type AssociateEipAddressMode string
	96
	97	const (
	98	NAT = "NAT"
	99	MULTI_BINDED = "MULTI_BINDED"
	100	BINDED = "BINDED"
92	101	)
93	102
94	103	type AssociateEipAddressArgs struct {
95		AllocationId string
96		InstanceId string
97		InstanceType EipInstanceType
	104	AllocationId string
	105	InstanceId string
	106	InstanceRegionId common.Region
	107	InstanceType EipInstanceType
	108	PrivateIpAddress string
	109	Mode AssociateEipAddressMode
98	110	}
99	111
100	112	type AssociateEipAddressResponse struct {
101	113	common.Response
102	114	}
103	115
104		// AssociateEipAddress associates EIP address to VM instance
105		//
106		// You can read doc at http://docs.aliyun.com/#/pub/ecs/open-api/network&associateeipaddress
	116	// AssociateEipAddress associates EIP address to instance
	117	//
	118	// You can read doc at https://help.aliyun.com/api/vpc/AssociateEipAddress.html
107	119	func (client *Client) AssociateEipAddress(allocationId string, instanceId string) error {
108	120	args := AssociateEipAddressArgs{
109	121	AllocationId: allocationId,

131	143	type AssociatedInstanceType string
132	144
133	145	const (
134		AssociatedInstanceTypeEcsInstance = AssociatedInstanceType("EcsInstance")
135		AssociatedInstanceTypeSlbInstance = AssociatedInstanceType("SlbInstance")
136		AssociatedInstanceTypeNat = AssociatedInstanceType("Nat")
137		AssociatedInstanceTypeHaVip = AssociatedInstanceType("HaVip")
	146	AssociatedInstanceTypeEcsInstance = AssociatedInstanceType("EcsInstance")
	147	AssociatedInstanceTypeSlbInstance = AssociatedInstanceType("SlbInstance")
	148	AssociatedInstanceTypeNat = AssociatedInstanceType("Nat")
	149	AssociatedInstanceTypeHaVip = AssociatedInstanceType("HaVip")
	150	AssociatedInstanceTypeNetworkInterface = AssociatedInstanceType("NetworkInterface")
138	151	)
139	152
140	153	type DescribeEipAddressesArgs struct {

142	155	Status EipStatus //enum Associating \| Unassociating \| InUse \| Available
143	156	EipAddress string
144	157	AllocationId string
145		AssociatedInstanceType AssociatedInstanceType //enum EcsInstance \| SlbInstance \| Nat \| HaVip
	158	AssociatedInstanceType AssociatedInstanceType //enum EcsInstance \| SlbInstance \| Nat \| HaVip \| NetworkInterface
146	159	AssociatedInstanceId string //绑定的资源的Id。这是一个过滤器性质的参数，若不指定，则表示不适用该条件对结果进行过滤。如果要使用该过滤器，必须同时使用AssociatedInstanceType。若InstanceType为EcsInstance，则此处填写ECS实例Id。若InstanceType为SlbInstance，则此处填写VPC类型的私网SLB 的实例ID。若InstanceType为Nat，则此处填写NAT 的实例ID。。若InstanceType为HaVip，则此处填写HaVipId。
147	160	common.Pagination
148	161	}

157	170	InstanceId string
158	171	InstanceType string
159	172	Bandwidth string // Why string
	173	PrivateIpAddress string
160	174	InternetChargeType common.InternetChargeType
161	175	OperationLocks OperationLocksType
162	176	AllocationTime util.ISO6801Time

217	231	}
218	232
219	233	type UnallocateEipAddressArgs struct {
220		AllocationId string
221		InstanceId string
	234	AllocationId string
	235	InstanceId string
	236	InstanceType EipInstanceType
	237	PrivateIpAddress string
222	238	}
223	239
224	240	type UnallocateEipAddressResponse struct {

235	251	}
236	252	response := UnallocateEipAddressResponse{}
237	253	return client.Invoke("UnassociateEipAddress", &args, &response)
	254	}
	255
	256	func (client Client) NewUnassociateEipAddress(args UnallocateEipAddressArgs) error {
	257	response := UnallocateEipAddressResponse{}
	258	return client.Invoke("UnassociateEipAddress", args, &response)
238	259	}
239	260
240	261	type ReleaseEipAddressArgs struct {

+31

-0

ecs/networks_test.go less more

84	84
85	85	}
86	86
	87	func TestClient_AssociateEipAddress_ENIIP(t *testing.T) {
	88	client := NewVpcTestClientForDebug()
	89	eipID := "eip-xxx"
	90	eniID := "eni-yyy"
	91	eniSecIP := "192.168.0.100"
	92	region := common.Region("cn-hangzhou")
	93
	94	err := client.NewAssociateEipAddress(&AssociateEipAddressArgs{
	95	AllocationId: eipID,
	96	InstanceId: eniID,
	97	InstanceType: NetworkInterface,
	98	PrivateIpAddress: eniSecIP,
	99	})
	100	if err != nil {
	101	t.Errorf("Failed to associate EIP address: %v", err)
	102	}
	103	err = client.WaitForEip(region, eipID, EipStatusInUse, DefaultTimeout)
	104	if err != nil {
	105	t.Errorf("Failed wait associate EIP address: %v", err)
	106	}
	107	err = client.NewUnassociateEipAddress(&UnallocateEipAddressArgs{
	108	AllocationId: eipID,
	109	InstanceId: eniID,
	110	InstanceType: NetworkInterface,
	111	PrivateIpAddress: eniSecIP,
	112	})
	113	if err != nil {
	114	t.Errorf("Failed unassociate EIP address: %v", err)
	115	}
	116	}
	117
87	118	func TestClient_DescribeEipAddresses(t *testing.T) {
88	119	client := NewVpcTestClientForDebug()
89	120	args := &DescribeEipAddressesArgs{

+61

-0

ecs/route_entry.go less more

	0	package ecs
	1
	2	import "github.com/denverdino/aliyungo/common"
	3
	4	type DescribeRouteEntryListArgs struct {
	5	RegionId string
	6	RouteTableId string
	7	DestinationCidrBlock string
	8	IpVersion string
	9	MaxResult int
	10	NextHopId string
	11	NextHopType string
	12	NextToken string
	13	RouteEntryId string
	14	RouteEntryName string
	15	RouteEntryType string
	16	}
	17
	18	type DescribeRouteEntryListResponse struct {
	19	common.Response
	20	NextToken string
	21	RouteEntrys struct {
	22	RouteEntry []RouteEntry
	23	}
	24	}
	25
	26	type RouteEntry struct {
	27	DestinationCidrBlock string
	28	IpVersion string
	29	RouteEntryId string
	30	RouteEntryName string
	31	RouteTableId string
	32	Status string
	33	Type string
	34	NextHops struct {
	35	NextHop []NextHop
	36	}
	37	}
	38
	39	type NextHop struct {
	40	Enabled int
	41	Weight int
	42	NextHopId string
	43	NextHopRegionId string
	44	NextHopType string
	45	NextHopRelatedInfo NextHopRelatedInfo
	46	}
	47
	48	type NextHopRelatedInfo struct {
	49	RegionId string
	50	InstanceId string
	51	InstanceType string
	52	}
	53
	54	// DescribeRouteEntryList describes route entries
	55	//
	56	func (client Client) DescribeRouteEntryList(args DescribeRouteEntryListArgs) (*DescribeRouteEntryListResponse, error) {
	57	response := &DescribeRouteEntryListResponse{}
	58	err := client.Invoke("DescribeRouteEntryList", args, &response)
	59	return response, err
	60	}

+27

-0

ecs/route_entry_test.go less more

	0	package ecs
	1
	2	import (
	3	"testing"
	4	)
	5
	6	func TestClient_DescribeRouteEntry(t *testing.T) {
	7	client := NewVpcTestClientForDebug()
	8
	9	nextHopId := "i-xxxx"
	10	destinationCidrBlock := "172.xxx/x"
	11	args := &DescribeRouteEntryListArgs{
	12	RegionId: "cn-hangzhou",
	13	RouteTableId: "vtb-xxxxx",
	14	DestinationCidrBlock: destinationCidrBlock,
	15	NextHopId: nextHopId,
	16	RouteEntryType: "Custom",
	17	}
	18
	19	response, err := client.DescribeRouteEntryList(args)
	20
	21	if err != nil {
	22	t.Fatalf("Error %++v", err)
	23	} else {
	24	t.Logf("Result %++v", response)
	25	}
	26	}

+7

-3

ecs/route_tables.go less more

99	99	type NextHopType string
100	100
101	101	const (
102		NextHopIntance = NextHopType("Instance") //Default
103		NextHopTunnel = NextHopType("Tunnel")
104		NextHopTunnelRouterInterface = NextHopType("RouterInterface")
	102	NextHopInstance = NextHopType("Instance") //Default
	103	NextHopHaVip = NextHopType("HaVip")
	104	NextHopRouterInterface = NextHopType("RouterInterface")
	105	NextHopNetworkInterface = NextHopType("NetworkInterface")
	106	NextHopVpnGateway = NextHopType("VpnGateway")
	107	NextHopIPv6Gateway = NextHopType("IPv6Gateway")
	108	NextHopTunnel = NextHopType("Tunnel")
105	109	)
106	110
107	111	type CreateRouteEntryArgs struct {

+1

-1

ecs/route_tables_test.go less more

10	10	createArgs := CreateRouteEntryArgs{
11	11	RouteTableId: routeTableId,
12	12	DestinationCidrBlock: cidrBlock,
13		NextHopType: NextHopIntance,
	13	NextHopType: NextHopInstance,
14	14	NextHopId: instanceId,
15	15	ClientToken: client.GenerateClientToken(),
16	16	}

+1

-1

ecs/router_interface.go less more

237	237	for {
238	238	interfaces, err := client.DescribeRouterInterfaces(&DescribeRouterInterfacesArgs{
239	239	RegionId: regionId,
240		Filter: []Filter{Filter{Key: "RouterInterfaceId", Value: []string{interfaceId}}},
	240	Filter: []Filter{{Key: "RouterInterfaceId", Value: []string{interfaceId}}},
241	241	})
242	242	if err != nil {
243	243	return err

+9

-2

ecs/security_groups.go less more

6	6
7	7	type NicType string
8	8	type Direction string
	9	type SecurityGroupType string
9	10
10	11	const (
11	12	NicTypeInternet = NicType("internet")

14	15	DirectionIngress = Direction("ingress")
15	16	DirectionEgress = Direction("egress")
16	17	DirectionAll = Direction("all")
	18
	19	SecurityGroupTypeNormal = SecurityGroupType("normal")
	20	SecurityGroupTypeEnterprise = SecurityGroupType("enterprise")
17	21	)
18	22
19	23	type IpProtocol string

91	95	}
92	96
93	97	type DescribeSecurityGroupsArgs struct {
94		RegionId common.Region
95		VpcId string
	98	RegionId common.Region
	99	VpcId string
	100	SecurityGroupIds []string
96	101	common.Pagination
97	102	}
98	103

103	108	SecurityGroupName string
104	109	Description string
105	110	VpcId string
	111	SecurityGroupType SecurityGroupType // normal\|enterprise
	112	ServiceManaged bool
106	113	CreationTime util.ISO6801Time
107	114	}
108	115

+19

-0

ecs/security_groups_test.go less more

0	0	package ecs
1	1
2	2	import (
	3	"os"
	4	"strings"
3	5	"testing"
4	6
5	7	"github.com/denverdino/aliyungo/common"

38	40	t.Logf("SecurityGroup Attribute: %++v", sga)
39	41
40	42	}
	43	}
	44	}
	45
	46	func TestSecurityGroups_BatchQuery(t *testing.T) {
	47
	48	client := NewTestClient()
	49	arg := DescribeSecurityGroupsArgs{
	50	RegionId: common.Region(os.Getenv("RegionId")),
	51	SecurityGroupIds: strings.Split(os.Getenv("SecurityGroupIDs"), ","),
	52	}
	53
	54	sgs, _, err := client.DescribeSecurityGroups(&arg)
	55	if err != nil {
	56	t.Errorf("Failed to DescribeSecurityGroups, error:%++v", err)
	57	}
	58	for _, sg := range sgs {
	59	t.Logf("SecurityGroup: %++v", sg)
41	60	}
42	61	}
43	62

+1

-1

ecs/snapshots.go less more

125	125	if err != nil {
126	126	return err
127	127	}
128		if snapshots == nil \|\| len(snapshots) == 0 {
	128	if len(snapshots) == 0 {
129	129	return common.GetClientErrorFromString("Not found")
130	130	}
131	131	if snapshots[0].Progress == "100%" {

+60

-8

ecs/snat_entry.go less more

0	0	package ecs
1	1
2		import "github.com/denverdino/aliyungo/common"
	2	import (
	3	"time"
	4
	5	"github.com/denverdino/aliyungo/common"
	6	)
	7
	8	type SnatEntryStatus string
	9
	10	const (
	11	SnatEntryStatusPending = SnatEntryStatus("Pending")
	12	SnatEntryStatusAvailable = SnatEntryStatus("Available")
	13	)
3	14
4	15	type CreateSnatEntryArgs struct {
5	16	RegionId common.Region
6	17	SnatTableId string
7	18	SourceVSwitchId string
8	19	SnatIp string
	20	SourceCIDR string
9	21	}
10	22
11	23	type CreateSnatEntryResponse struct {

20	32	SnatTableId string
21	33	SourceCIDR string
22	34	SourceVSwitchId string
23		Status string
	35	Status SnatEntryStatus
24	36	}
25	37
26	38	type DescribeSnatTableEntriesArgs struct {
27		RegionId common.Region
28		SnatTableId string
	39	RegionId common.Region
	40	SnatTableId string
	41	SnatEntryId string
	42	SnatEntryName string
	43	SnatIp string
	44	SourceCIDR string
	45	SourceVSwitchId string
29	46	common.Pagination
30	47	}
31	48

38	55	}
39	56
40	57	type ModifySnatEntryArgs struct {
41		RegionId common.Region
42		SnatTableId string
43		SnatEntryId string
44		SnatIp string
	58	RegionId common.Region
	59	SnatTableId string
	60	SnatEntryId string
	61	SnatIp string
	62	SnatEntryName string
45	63	}
46	64
47	65	type ModifySnatEntryResponse struct {

100	118	err := client.Invoke("DeleteSnatEntry", args, &response)
101	119	return err
102	120	}
	121
	122	// WaitForSnatEntryAvailable waits for SnatEntry to available status
	123	func (client *Client) WaitForSnatEntryAvailable(regionId common.Region, snatTableId, snatEntryId string, timeout int) error {
	124	if timeout <= 0 {
	125	timeout = DefaultTimeout
	126	}
	127
	128	args := &DescribeSnatTableEntriesArgs{
	129	RegionId: regionId,
	130	SnatTableId: snatTableId,
	131	SnatEntryId: snatEntryId,
	132	}
	133
	134	for {
	135	snatEntries, _, err := client.DescribeSnatTableEntries(args)
	136	if err != nil {
	137	return err
	138	}
	139
	140	if len(snatEntries) == 0 {
	141	return common.GetClientErrorFromString("Not found")
	142	}
	143	if snatEntries[0].Status == SnatEntryStatusAvailable {
	144	break
	145	}
	146
	147	timeout = timeout - DefaultWaitForInterval
	148	if timeout <= 0 {
	149	return common.GetClientErrorFromString("Timeout")
	150	}
	151	time.Sleep(DefaultWaitForInterval * time.Second)
	152	}
	153	return nil
	154	}

+15

-0

ecs/snat_entry_test.go less more

13	13	t.Fatalf("Failed to DescribeBandwidthPackages: %v", err)
14	14	}
15	15	}
	16
	17	func TestCreateSnatEntryWithSourceCIDR(t *testing.T) {
	18	client := NewTestClient()
	19	args := CreateSnatEntryArgs{
	20	RegionId: "cn-beijing",
	21	SnatTableId: "stb-xxx",
	22	SnatIp: "47.XX.XX.98",
	23	SourceCIDR: "192.168.1.1/32",
	24	}
	25
	26	_, err := client.CreateSnatEntry(&args)
	27	if err != nil {
	28	t.Errorf("failed to CreateSnatEntry with SourceCIDR: %v", err)
	29	}
	30	}

+11

-5

ecs/vpcs.go less more

75	75	VSwitchIds struct {
76	76	VSwitchId []string
77	77	}
78		CidrBlock string
79		VRouterId string
80		Description string
81		IsDefault bool
82		CreationTime util.ISO6801Time
	78	CidrBlock string
	79	VRouterId string
	80	Description string
	81	IsDefault bool
	82	CreationTime util.ISO6801Time
	83	SecondaryCidrBlocks struct {
	84	SecondaryCidrBlock []string
	85	}
	86	RouterTableIds struct {
	87	RouterTableIds []string
	88	}
83	89	}
84	90
85	91	type DescribeVpcsResponse struct {

+4

-0

ecs/vpcs_test.go less more

163	163	t.Logf("Instance %s is created successfully.", instanceId)
164	164	instance, err := client.DescribeInstanceAttribute(instanceId)
165	165	t.Logf("Instance: %++v %v", instance, err)
	166
166	167	err = client.WaitForInstance(instanceId, Stopped, 0)
	168	if err != nil {
	169	t.Errorf("Failed to wait instance to stopped %s: %v", instanceId, err)
	170	}
167	171
168	172	err = client.StartInstance(instanceId)
169	173	if err != nil {

+81

-1

ess/configuration.go less more

1	1
2	2	import (
3	3	"encoding/base64"
4
5	4	"github.com/denverdino/aliyungo/common"
6	5	"github.com/denverdino/aliyungo/ecs"
7	6	)

89	88	CreationTime string
90	89	InternetMaxBandwidthIn int
91	90	InternetMaxBandwidthOut int
	91	SystemDiskSize int
92	92	SystemDiskCategory string
93	93	DataDisks struct {
94	94	DataDisk []DataDiskItemType

166	166	}
167	167	return &response, nil
168	168	}
	169
	170	type ModifyScalingConfigurationRequest struct {
	171	ScalingConfigurationId string
	172	IoOptimized string
	173	DataDisk []DataDisk
	174	SpotStrategy string
	175	SpotPriceLimit []SpotPriceLimit
	176	ScalingConfigurationName string
	177	InstanceName string
	178	HostName string
	179	ImageId string
	180	ImageName string
	181	InstanceTypes []string
	182	Cpu int
	183	Memory int
	184	InternetChargeType string
	185	InternetMaxBandwidthOut int
	186	SystemDisk SystemDisk
	187	LoadBalancerWeight string
	188	UserData string
	189	KeyPairName string
	190	RamRoleName string
	191	PasswordInherit string
	192	Tags string
	193	DeploymentSetId string
	194	SecurityGroupId string
	195	Override bool
	196	ResourceGroupId string
	197	SecurityGroupIds []string
	198	HpcClusterId string
	199
	200	InstanceDescription string
	201	Ipv6AddressCount int
	202
	203	CreditSpecification string
	204	ImageFamily string
	205	DedicatedHostId string
	206	Affinity string
	207	Tenancy string
	208	}
	209
	210	type DataDisk struct {
	211	Size int
	212	SnapshotId string
	213	Category string
	214	Device string
	215	DeleteWithInstance bool
	216	Encrypted bool
	217	KMSKeyId string
	218	DiskName string
	219	Description string
	220	AutoSnapshotPolicyId string
	221	}
	222
	223	type SpotPriceLimit struct {
	224	InstanceType string
	225	PriceLimit float32
	226	}
	227
	228	type SystemDisk struct {
	229	Category string
	230	Size int
	231	DiskName string
	232	Description string
	233	AutoSnapshotPolicyId string
	234	}
	235
	236	type ModifyScalingConfigurationResponse struct {
	237	common.Response
	238	}
	239
	240	func (client Client) ModifyScalingConfiguration(args ModifyScalingConfigurationRequest) (resp *ModifyScalingConfigurationResponse, err error) {
	241	response := ModifyScalingConfigurationResponse{}
	242	err = client.InvokeByFlattenMethod("ModifyScalingConfiguration", args, &response)
	243
	244	if err != nil {
	245	return nil, err
	246	}
	247	return &response, nil
	248	}

+51

-0

ess/group.go less more

14	14	InService = LifecycleState("InService")
15	15	Pending = LifecycleState("Pending")
16	16	Removing = LifecycleState("Removing")
	17	)
	18
	19	type MultiAZPolicy string
	20
	21	const (
	22	MultiAZPolicyPriority = MultiAZPolicy("PRIORITY")
	23	MultiAZPolicyCostOptimized = MultiAZPolicy("COST_OPTIMIZED")
	24	MultiAZPolicyBalance = MultiAZPolicy("BALANCE")
17	25	)
18	26
19	27	type CreateScalingGroupArgs struct {

26	34	// NOTE: Set MinSize, MaxSize and DefaultCooldown type to int pointer to distinguish zero value from unset value.
27	35	MinSize *int
28	36	MaxSize *int
	37	MultiAZPolicy MultiAZPolicy
29	38	DefaultCooldown *int
30	39	RemovalPolicy common.FlattenArray
31	40	DBInstanceIds string

337	346	}
338	347	return nil
339	348	}
	349
	350	type DescribeScalingActivitiesRequest struct {
	351	ScalingActivityId []string
	352	ScalingGroupId string
	353	StatusCode string
	354	RegionId common.Region
	355	common.Pagination
	356	}
	357
	358	type DescribeScalingActivitiesResponse struct {
	359	common.PaginationResult
	360	common.Response
	361	ScalingActivities struct {
	362	ScalingActivity []ScalingActivity
	363	}
	364	}
	365
	366	type ScalingActivity struct {
	367	AttachedCapacity int
	368	AutoCreatedCapacity int
	369	Cause string
	370	Description string
	371	EndTime string
	372	Progress int
	373	ScalingActivityId string
	374	ScalingGroupId string
	375	ScalingInstanceNumber int
	376	StartTime string
	377	StatusCode string
	378	StatusMessage string
	379	TotalCapacity int
	380	}
	381
	382	func (client Client) DescribeScalingActivities(args DescribeScalingActivitiesRequest) (resp *DescribeScalingActivitiesResponse, err error) {
	383	response := DescribeScalingActivitiesResponse{}
	384	err = client.InvokeByFlattenMethod("DescribeScalingActivities", args, &response)
	385
	386	if err != nil {
	387	return nil, err
	388	}
	389	return &response, nil
	390	}

+18

-0

ess/group_test.go less more

0	0	package ess
1	1
2	2	import (
	3	"fmt"
3	4	"testing"
4	5
5	6	"github.com/denverdino/aliyungo/common"

74	75	}
75	76	t.Logf("Instance %s is deleted successfully.", instanceId)
76	77	}
	78
	79	func TestEssScalingActivity(t *testing.T) {
	80
	81	client := NewTestClient(common.Region(RegionId))
	82	id := "asg-uf68jfxw7gqlao0wlc94"
	83	result, err := client.DescribeScalingActivities(
	84	&DescribeScalingActivitiesRequest{
	85	ScalingGroupId: id,
	86	RegionId: common.Shanghai,
	87	},
	88	)
	89	if err != nil {
	90	t.Errorf("get activity %s: %v", id, err)
	91	}
	92	fmt.Printf("%+v\n", result)
	93	t.Logf("get activity succeed by id %s.", id)
	94	}

+1

-1

location/regions_test.go less more

5	5	client := NewTestClientForDebug()
6	6
7	7	args := &DescribeRegionsArgs{
8		//RegionId: common.Beijing,
	8	//RegionId: common.Beijing,
9	9	}
10	10
11	11	regions, err := client.DescribeRegions(args)

+5

-4

metadata/client.go less more

13	13	"encoding/json"
14	14	"reflect"
15	15
	16	"os"
	17
16	18	"github.com/denverdino/aliyungo/util"
17		"os"
18	19	)
19	20
20	21	const (

43	44	VSWITCH_CIDR_BLOCK = "vswitch-cidr-block"
44	45	VSWITCH_ID = "vswitch-id"
45	46	ZONE = "zone-id"
46		RAM_SECURITY = "Ram/security-credentials"
	47	RAM_SECURITY = "ram/security-credentials"
47	48	)
48	49
49	50	type IMetaDataRequest interface {

350	351	func (vpc *MetaDataRequest) Decode(data string, api interface{}) error {
351	352	if data == "" {
352	353	url, _ := vpc.Url()
353		return errors.New(fmt.Sprintf("metadata: alivpc decode data must not be nil. url=[%s]\n", url))
	354	return fmt.Errorf("metadata: alivpc decode data must not be nil. url=[%s]\n", url)
354	355	}
355	356	switch api.(type) {
356	357	case *ResultList:

359	360	case *RoleAuth:
360	361	return json.Unmarshal([]byte(data), api)
361	362	default:
362		return errors.New(fmt.Sprintf("metadata: unknow type to decode, type=%s\n", reflect.TypeOf(api)))
	363	return fmt.Errorf("metadata: unknow type to decode, type=%s\n", reflect.TypeOf(api))
363	364	}
364	365	}
365	366

+8

-0

mns/client.go less more

21	21	client.debug = debug
22	22	}
23	23
	24	// SetTransport sets transport to the http client
	25	func (client *Client) SetTransport(transport http.RoundTripper) {
	26	if client.httpClient == nil {
	27	client.httpClient = &http.Client{}
	28	}
	29	client.httpClient.Transport = transport
	30	}
	31
24	32	func NewClient(accessKeyId, accessKeySecret, endpoint string) (client *Client) {
25	33	client = &Client{
26	34	AccessKeyId: accessKeyId,

+2

-2

mns/signature.go less more

43	43	canonicalizedResource := req.path
44	44	var paramNames []string
45	45	if req.params != nil && len(req.params) > 0 {
46		for k, _ := range req.params {
	46	for k := range req.params {
47	47	paramNames = append(paramNames, k)
48	48	}
49	49	sort.Strings(paramNames)

61	61	func canonicalizeHeader(headers map[string]string) string {
62	62	var canonicalizedHeaders []string
63	63
64		for k, _ := range headers {
	64	for k := range headers {
65	65	if lower := strings.ToLower(k); strings.HasPrefix(lower, HeaderMNSPrefix) {
66	66	canonicalizedHeaders = append(canonicalizedHeaders, lower)
67	67	}

+39

-8

oss/client.go less more

36	36	Internal bool
37	37	Secure bool
38	38	ConnectTimeout time.Duration
	39	Transport http.RoundTripper
39	40
40	41	endpoint string
41	42	debug bool

56	57	// Options struct
57	58	//
58	59	type Options struct {
59		ServerSideEncryption bool
60		Meta map[string][]string
61		ContentEncoding string
62		CacheControl string
63		ContentMD5 string
64		ContentDisposition string
	60	ServerSideEncryption bool
	61	ServerSideEncryptionKeyID string
	62
	63	Meta map[string][]string
	64	ContentEncoding string
	65	CacheControl string
	66	ContentMD5 string
	67	ContentDisposition string
65	68	//Range string
66	69	//Expires int
67	70	}

71	74	CopySourceOptions string
72	75	MetadataDirective string
73	76	//ContentType string
	77
	78	ServerSideEncryption bool
	79	ServerSideEncryptionKeyID string
74	80	}
75	81
76	82	// CopyObjectResult is the output from a Copy request

490	496
491	497	// addHeaders adds o's specified fields to headers
492	498	func (o Options) addHeaders(headers http.Header) {
493		if o.ServerSideEncryption {
	499	if len(o.ServerSideEncryptionKeyID) != 0 {
	500	headers.Set("x-oss-server-side-encryption", "KMS")
	501	headers.Set("x-oss-server-side-encryption-key-id", o.ServerSideEncryptionKeyID)
	502	} else if o.ServerSideEncryption {
494	503	headers.Set("x-oss-server-side-encryption", "AES256")
495	504	}
496	505	if len(o.ContentEncoding) != 0 {

515	524
516	525	// addHeaders adds o's specified fields to headers
517	526	func (o CopyOptions) addHeaders(headers http.Header) {
	527	if len(o.ServerSideEncryptionKeyID) != 0 {
	528	headers.Set("x-oss-server-side-encryption", "KMS")
	529	headers.Set("x-oss-server-side-encryption-key-id", o.ServerSideEncryptionKeyID)
	530	} else if o.ServerSideEncryption {
	531	headers.Set("x-oss-server-side-encryption", "AES256")
	532	}
	533
518	534	if len(o.MetadataDirective) != 0 {
519	535	headers.Set("x-oss-metadata-directive", o.MetadataDirective)
520	536	}

833	849	// to retrieve the object at path. The signature is valid until expires.
834	850	func (b *Bucket) SignedURLWithArgs(path string, expires time.Time, params url.Values, headers http.Header) string {
835	851	return b.SignedURLWithMethod("GET", path, expires, params, headers)
	852	}
	853
	854	func (b *Bucket) SignedURLWithMethodForAssumeRole(method, path string, expires time.Time, params url.Values, headers http.Header) string {
	855	var uv = url.Values{}
	856	if params != nil {
	857	uv = params
	858	}
	859	if len(b.Client.SecurityToken) != 0 {
	860	uv.Set("security-token", b.Client.SecurityToken)
	861	}
	862	return b.SignedURLWithMethod(method, path, expires, params, headers)
836	863	}
837	864
838	865	// SignedURLWithMethod returns a signed URL that allows anyone holding the URL

1023	1050	func (client Client) prepare(req request) error {
1024	1051	// Copy so they can be mutated without affecting on retries.
1025	1052	headers := copyHeader(req.headers)
1026		if len(client.SecurityToken) != 0 {
	1053	// security-token should be in either Params or Header, cannot be in both
	1054	if len(req.params.Get("security-token")) == 0 && len(client.SecurityToken) != 0 {
1027	1055	headers.Set("x-oss-security-token", client.SecurityToken)
1028	1056	}
1029	1057

1161	1189	},
1162	1190	Timeout: req.timeout,
1163	1191	}
	1192	if client.Transport != nil {
	1193	c.Transport = client.Transport
	1194	}
1164	1195
1165	1196	return client.doHttpRequest(c, hreq, resp)
1166	1197	}

+64

-15

oss/client_test.go less more

5	5	"io/ioutil"
6	6	"math/rand"
7	7	"net/http"
8		"os"
	8	"net/url"
9	9	"strconv"
10	10	"sync"
	11
11	12	//"net/http"
12	13	"testing"
13	14	"time"

22	23	)
23	24
24	25	func init() {
25		AccessKeyId := os.Getenv("AccessKeyId")
26		AccessKeySecret := os.Getenv("AccessKeySecret")
27		if len(AccessKeyId) != 0 && len(AccessKeySecret) != 0 {
28		client = oss.NewOSSClient(TestRegion, false, AccessKeyId, AccessKeySecret, false)
29		} else {
30		client = oss.NewOSSClient(TestRegion, false, TestAccessKeyId, TestAccessKeySecret, false)
31		}
32
33		assumeRoleClient = oss.NewOSSClientForAssumeRole(TestRegion, false, TestAccessKeyId, TestAccessKeySecret, TestSecurityToken, false)
	26	client = oss.NewOSSClient(TestRegion, false, TestAccessKeyID, TestAccessKeySecret, false)
	27	assumeRoleClient = oss.NewOSSClientForAssumeRole(TestRegion, false, TestAccessKeyID, TestAccessKeySecret, TestSecurityToken, false)
34	28	assumeRoleClient.SetDebug(true)
35	29	}
36	30

97	91	}
98	92	}
99	93
100		func aTestGetNotFound(t *testing.T) {
	94	func TestGetNotFound(t *testing.T) {
101	95
102	96	b := client.Bucket("non-existent-bucket")
103	97	_, err := b.Get("non-existent")

123	117	}
124	118	}
125	119
	120	func TestPutObjectWithSSE(t *testing.T) {
	121	const DISPOSITION = "attachment; filename=\"0x1a2b3c.jpg\""
	122
	123	b := client.Bucket(TestBucket)
	124	err := b.Put("name-sse", []byte("content"), "content-type", oss.Private, oss.Options{
	125	ContentDisposition: DISPOSITION,
	126	ServerSideEncryptionKeyID: TestServerSideEncryptionKeyID,
	127	})
	128	if err != nil {
	129	t.Errorf("Failed for Put: %v", err)
	130	}
	131	}
	132
	133	func TestPutCopyWithSSE(t *testing.T) {
	134	b := client.Bucket(TestBucket)
	135	t.Log("Source: ", b.Path("name-sse"))
	136	res, err := b.PutCopy("newname-sse", oss.Private, oss.CopyOptions{
	137	ServerSideEncryptionKeyID: TestServerSideEncryptionKeyID,
	138	},
	139	b.Path("name"))
	140	if err == nil {
	141	t.Logf("Copy result: %v", res)
	142	} else {
	143	t.Errorf("Failed for PutCopy: %v", err)
	144	}
	145	}
	146
126	147	func TestList(t *testing.T) {
127	148
128	149	b := client.Bucket(TestBucket)
129	150
130	151	data, err := b.List("n", "", "", 0)
131		if err != nil \|\| len(data.Contents) != 2 {
	152	if err != nil \|\| len(data.Contents) != 4 {
132	153	t.Errorf("Failed for List: %v", err)
133	154	} else {
134	155	t.Logf("Contents = %++v", data)

240	261	resp.Body.Close()
241	262	}
242	263
	264	func TestSignedURLWithArgsWithTrafficLimits(t *testing.T) {
	265	b := client.Bucket(TestBucket)
	266	expires := time.Now().Add(20 * time.Minute)
	267	url := b.SignedURLWithArgs("largefile", expires, url.Values{
	268	"x-oss-traffic-limit": []string{strconv.FormatInt(5*8<<20, 10)}},
	269	nil)
	270	resp, err := http.Get(url)
	271	t.Logf("Large file response headers: %++v", resp.Header)
	272
	273	if err != nil {
	274	t.Fatalf("Failed for GetResponseWithHeaders: %v", err)
	275	}
	276	data, err := ioutil.ReadAll(resp.Body)
	277
	278	if err != nil {
	279	t.Errorf("Failed for Read file: %v", err)
	280	}
	281
	282	if len(data) != int(_fileSize) {
	283	t.Errorf("Incorrect length for Read with offset: %v", len(data))
	284	}
	285	resp.Body.Close()
	286	}
	287
243	288	func TestCopyLargeFile(t *testing.T) {
244	289	b := client.Bucket(TestBucket)
245	290	err := b.CopyLargeFile("largefile", "largefile2", "application/octet-stream", oss.Private, oss.Options{})

271	316	t.Fatalf("Failed for Get file: %v", err)
272	317	}
273	318
274		if bytes.Compare(bytes1, bytes2) != 0 {
	319	if !bytes.Equal(bytes1, bytes2) {
275	320	t.Fatal("The result should be equal")
276	321	}
277	322	}

307	352	t.Fatalf("Failed for Get file: %v", err)
308	353	}
309	354
310		if bytes.Compare(bytes1, bytes2) != 0 {
	355	if !bytes.Equal(bytes1, bytes2) {
311	356	t.Fatal("The result should be equal")
312	357	}
313	358	}

370	415	func TestDelMultiObjects(t *testing.T) {
371	416
372	417	b := client.Bucket(TestBucket)
373		objects := []oss.Object{oss.Object{Key: "newname"}}
	418	objects := []oss.Object{
	419	{Key: "newname"},
	420	{Key: "name-sse"},
	421	{Key: "newname-sse"},
	422	}
374	423	err := b.DelMulti(oss.Delete{
375	424	Quiet: false,
376	425	Objects: objects,

+3

-1

oss/config_test.go less more

15	15	//
16	16
17	17	var (
18		TestAccessKeyId = os.Getenv("AccessKeyId")
	18	TestAccessKeyID = os.Getenv("AccessKeyId")
19	19	TestAccessKeySecret = os.Getenv("AccessKeySecret")
20	20	TestSecurityToken = os.Getenv("SecurityToken")
21	21	TestRegion = oss.Region(os.Getenv("RegionId"))
	22
	23	TestServerSideEncryptionKeyID = os.Getenv("ServerSideEncryptionKeyId")
22	24	)

+1

-0

oss/regions.go less more

26	26	MEEast1 = Region("oss-me-east-1")
27	27
28	28	EUCentral1 = Region("oss-eu-central-1")
	29	EUWest1 = Region("oss-eu-west-1")
29	30
30	31	DefaultRegion = Hangzhou
31	32	)

+34

-15

oss/signature.go less more

12	12
13	13	var ossParamsToSign = map[string]bool{
14	14	"acl": true,
	15	"append": true,
	16	"bucketInfo": true,
	17	"cname": true,
	18	"comp": true,
	19	"cors": true,
15	20	"delete": true,
	21	"endTime": true,
	22	"img": true,
	23	"lifecycle": true,
	24	"live": true,
16	25	"location": true,
17	26	"logging": true,
18		"notification": true,
	27	"objectMeta": true,
19	28	"partNumber": true,
20		"policy": true,
21		"requestPayment": true,
22		"torrent": true,
23		"uploadId": true,
24		"uploads": true,
25		"versionId": true,
26		"versioning": true,
27		"versions": true,
28		"response-content-type": true,
29		"response-content-language": true,
30		"response-expires": true,
	29	"position": true,
	30	"qos": true,
	31	"referer": true,
	32	"replication": true,
	33	"replicationLocation": true,
	34	"replicationProgress": true,
31	35	"response-cache-control": true,
32	36	"response-content-disposition": true,
33	37	"response-content-encoding": true,
34		"bucketInfo": true,
	38	"response-content-language": true,
	39	"response-content-type": true,
	40	"response-expires": true,
	41	"security-token": true,
	42	"startTime": true,
	43	"status": true,
	44	"style": true,
	45	"styleName": true,
	46	"symlink": true,
	47	"tagging": true,
	48	"uploadId": true,
	49	"uploads": true,
	50	"vod": true,
	51	"website": true,
	52	"x-oss-process": true,
	53	"x-oss-traffic-limit": true,
35	54	}
36	55
37	56	func (client Client) signRequest(request request) {

61	80	}
62	81
63	82	if len(params) > 0 {
64		resource = resource + "?" + util.Encode(params)
	83	resource = resource + "?" + util.EncodeWithoutEscape(params)
65	84	}
66	85
67	86	canonicalizedResource := resource

73	92	//log.Println("stringToSign: ", stringToSign)
74	93	signature := util.CreateSignature(stringToSign, client.AccessKeySecret)
75	94
76		if query.Get("OSSAccessKeyId") != "" {
	95	if urlSignature {
77	96	query.Set("Signature", signature)
78	97	} else {
79	98	headers.Set("Authorization", "OSS "+client.AccessKeyId+":"+signature)

+24

-0

pvtz/client.go less more

59	59	return NewPVTZClientWithEndpointAndSecurityToken(endpoint, accessKeyId, accessKeySecret, securityToken, regionID)
60	60	}
61	61
	62	//Onlyfor hangzhou
	63	func NewPVTZClientWithSecurityToken4RegionalDomain(accessKeyId string, accessKeySecret string, securityToken string, regionID common.Region) *Client {
	64	endpoint := os.Getenv("PVTZ_ENDPOINT")
	65	if endpoint == "" {
	66	endpoint = PVTZDefaultEndpoint
	67	}
	68
	69	return NewPVTZClientWithEndpointAndSecurityToken4RegionalDomain(endpoint, accessKeyId, accessKeySecret, securityToken, regionID)
	70	}
	71
62	72	func NewPVTZClientWithEndpoint(endpoint string, accessKeyId string, accessKeySecret string, regionID common.Region) *Client {
63	73	return NewPVTZClientWithEndpointAndSecurityToken(endpoint, accessKeyId, accessKeySecret, "", regionID)
64	74	}

75	85	InitClient()
76	86	return client
77	87	}
	88
	89	//only for hangzhou
	90	func NewPVTZClientWithEndpointAndSecurityToken4RegionalDomain(endpoint string, accessKeyId string, accessKeySecret string, securityToken string, regionID common.Region) *Client {
	91	client := &Client{}
	92	client.WithEndpoint(endpoint).
	93	WithVersion(PVTZAPIVersion).
	94	WithAccessKeyId(accessKeyId).
	95	WithAccessKeySecret(accessKeySecret).
	96	WithSecurityToken(securityToken).
	97	WithServiceCode(PVTZServiceCode).
	98	WithRegionID(regionID).
	99	InitClient4RegionalDomain()
	100	return client
	101	}

+2

-2

pvtz/client_test.go less more

42	42	err = client.BindZoneVpc(&BindZoneVpcArgs{
43	43	ZoneId: zoneId,
44	44	Vpcs: []VPCType{
45		VPCType{
	45	{
46	46	RegionId: common.Beijing,
47	47	VpcId: TestVPCId,
48	48	},

114	114	}
115	115
116	116	func TestDescribeChangeLogs(t *testing.T) {
117		client := NewTestClient()
	117	client := NewTestLocationClientForDebug()
118	118
119	119	changeLogs, err := client.DescribeChangeLogs(&DescribeChangeLogsArgs{})
120	120

+13

-0

pvtz/config_test.go less more

0	0	package pvtz
1	1
2	2	import (
	3	"github.com/denverdino/aliyungo/common"
3	4	"os"
4	5	)
5	6

9	10	TestAccessKeyId = os.Getenv("AccessKeyId")
10	11	TestAccessKeySecret = os.Getenv("AccessKeySecret")
11	12	TestVPCId = os.Getenv("VPCId")
	13	TestSecurityToken = os.Getenv("SecurityToken")
	14	TestRegionID = common.Region(os.Getenv("RegionId"))
12	15	)
13	16
14	17	var testClient *Client

29	32	}
30	33	return testDebugClient
31	34	}
	35
	36	var testDebugLocationClient *Client
	37
	38	func NewTestLocationClientForDebug() *Client {
	39	if testDebugLocationClient == nil {
	40	testDebugLocationClient = NewPVTZClientWithSecurityToken4RegionalDomain(TestAccessKeyId, TestAccessKeySecret, TestSecurityToken, TestRegionID)
	41	testDebugLocationClient.SetDebug(true)
	42	}
	43	return testDebugLocationClient
	44	}

+1

-1

pvtz/records.go less more

151	151	// UpdateZoneRecord update zone record
152	152	//
153	153	// You can read doc at https://help.aliyun.com/document_detail/66250.html
154		func (client Client) UpdateZoneRecord(args AddZoneRecordArgs) (err error) {
	154	func (client Client) UpdateZoneRecord(args UpdateZoneRecordArgs) (err error) {
155	155	response := &UpdateZoneRecordResponse{}
156	156
157	157	err = client.Invoke("UpdateZoneRecord", args, &response)

+3

-0

ram/api.go less more

80	80	ClearAccountAlias() (RamCommonResponse, error)
81	81	SetPasswordPolicy(passwordPolicy PasswordPolicyRequest) (PasswordPolicyResponse, error)
82	82	GetPasswordPolicy() (PasswordPolicyResponse, error)
	83
	84	// Common Client Methods
	85	SetUserAgent(userAgent string)
83	86	}

+2

-1

ram/policy.go less more

23	23
24	24	type PolicyResponse struct {
25	25	RamCommonResponse
26		Policy Policy
	26	Policy Policy
	27	DefaultPolicyVersion PolicyVersion
27	28	}
28	29
29	30	type PolicyQueryRequest struct {

+2

-2

ram/policy_test.go less more

11	11	policy_name string
12	12	policy_document = PolicyDocument{
13	13	Statement: []PolicyItem{
14		PolicyItem{
	14	{
15	15	Action: "*",
16	16	Effect: "Allow",
17	17	Resource: "*",

202	202	t.Logf("pass ListPoliciesForGroup %++v", resp)
203	203	}
204	204
205		func TEstListEntitiesForPolicy(t *testing.T) {
	205	func TestListEntitiesForPolicy(t *testing.T) {
206	206	client := NewTestClient()
207	207	policyReq := PolicyRequest{
208	208	PolicyType: "Custom",

+2

-2

ram/role_test.go less more

19	19
20	20	policyDocument = AssumeRolePolicyDocument{
21	21	Statement: []AssumeRolePolicyItem{
22		AssumeRolePolicyItem{Action: "sts:AssumeRole", Effect: "Allow", Principal: princpal},
	22	{Action: "sts:AssumeRole", Effect: "Allow", Principal: princpal},
23	23	},
24	24	Version: "1"}
25	25
26	26	newPolicyDocument = AssumeRolePolicyDocument{
27	27	Statement: []AssumeRolePolicyItem{
28		AssumeRolePolicyItem{Action: "sts:AssumeRole", Effect: "Deny", Principal: princpal},
	28	{Action: "sts:AssumeRole", Effect: "Deny", Principal: princpal},
29	29	},
30	30	Version: "1"}
31	31

+0

-1

rds/instances.go less more

204	204	}
205	205
206	206	// CreateOrder create db instance order
207		// you can read doc at http://docs.alibaba-inc.com/pages/viewpage.action?pageId=259349053
208	207	func (client Client) CreateOrder(args CreateOrderArgs) (resp CreateOrderResponse, err error) {
209	208	response := CreateOrderResponse{}
210	209	err = client.Invoke("CreateOrder", args, &response)

+1

-1

rds/instances_test.go less more

253	253	args := AllocateInstancePublicConnectionArgs{
254	254	DBInstanceId: DBInstanceId,
255	255	ConnectionStringPrefix: DBInstanceId + "o",
256		Port: "3306",
	256	Port: "3306",
257	257	}
258	258
259	259	_, err := client.AllocateInstancePublicConnection(&args)

+12

-3

ros/client.go less more

85	85	client.SecurityToken = securityToken
86	86	}
87	87
	88	// SetTransport sets transport to the http client
	89	func (client *Client) SetTransport(transport http.RoundTripper) {
	90	if client.httpClient == nil {
	91	client.httpClient = &http.Client{}
	92	}
	93	client.httpClient.Transport = transport
	94	}
	95
88	96	type Request struct {
89	97	Method string
90	98	URL string

143	151	httpReq.Header.Set("Date", util.GetGMTime())
144	152	httpReq.Header.Set("Accept", "application/json")
145	153	//httpReq.Header.Set("x-acs-version", client.Version)
	154	httpReq.Header["x-acs-version"] = []string{client.Version}
146	155
147	156	httpReq.Header["x-acs-signature-version"] = []string{"1.0"}
148	157	httpReq.Header["x-acs-signature-nonce"] = []string{util.CreateRandomString()}

179	188
180	189	if client.debug {
181	190	var prettyJSON bytes.Buffer
182		err = json.Indent(&prettyJSON, body, "", " ")
183		log.Println(string(prettyJSON.Bytes()))
	191	_ = json.Indent(&prettyJSON, body, "", " ")
	192	log.Println(prettyJSON.String())
184	193	}
185	194
186	195	if statusCode >= 400 && statusCode <= 599 {
187	196	errorResponse := common.ErrorResponse{}
188		err = json.Unmarshal(body, &errorResponse)
	197	_ = json.Unmarshal(body, &errorResponse)
189	198	cErr := &common.Error{
190	199	ErrorResponse: errorResponse,
191	200	StatusCode: statusCode,

+12

-2

ros/config_test.go less more

13	13	TestSecurityToken = os.Getenv("SecurityToken")
14	14	TestRegionID = common.Region(os.Getenv("RegionId"))
15	15
16		clientForTestCase = NewTestClient()
17		debugClientForTestCase = NewTestClientForDebug()
	16	debugClientForTestCase = NewTestClientForDebug()
	17	debugRpcClientForTestCase = NewTestRpcClientForDebug()
18	18	)
19	19
20	20	var testClient *Client

28	28	}
29	29
30	30	var testDebugClient *Client
	31	var testDebugRpcClient *RpcClient
31	32
32	33	func NewTestClientForDebug() *Client {
33	34	if testDebugClient == nil {

37	38	testDebugClient.SetSecurityToken(TestSecurityToken)
38	39	return testDebugClient
39	40	}
	41
	42	func NewTestRpcClientForDebug() *RpcClient {
	43	if testDebugRpcClient == nil {
	44	testDebugRpcClient = NewRpcClient(TestAccessKeyId, TestAccessKeySecret)
	45	testDebugRpcClient.SetDebug(true)
	46	}
	47	testDebugRpcClient.SetSecurityToken(TestSecurityToken)
	48	return testDebugRpcClient
	49	}

+1

-0

ros/other.go less more

17	17	}
18	18
19	19	type Event struct {
	20	Status string
20	21	ResourceStatus string
21	22	ResourceName string
22	23	StatusReason string

+11

-0

ros/resource.go less more

32	32	func (client Client) DescribeResource(stackId, stackName, resourceName string) (Resource, error) {
33	33	response := &Resource{}
34	34	err := client.Invoke("", http.MethodGet, fmt.Sprintf("/stacks/%s/%s/resources/%s", stackName, stackId, resourceName), nil, nil, &response)
	35	if err != nil {
	36	return nil, err
	37	}
	38
	39	return response, nil
	40	}
	41
	42	//https://help.aliyun.com/document_detail/28917.html?spm=5176.doc28916.6.589.BUPJqx
	43	func (client Client) DescribeResourceByRegion(regionId common.Region, stackId, stackName, resourceName string) (Resource, error) {
	44	response := &Resource{}
	45	err := client.Invoke(regionId, http.MethodGet, fmt.Sprintf("/stacks/%s/%s/resources/%s", stackName, stackId, resourceName), nil, nil, &response)
35	46	if err != nil {
36	47	return nil, err
37	48	}

+51

-0

ros/rpc_client.go less more

	0	package ros
	1
	2	import (
	3	"github.com/denverdino/aliyungo/common"
	4	"os"
	5	)
	6
	7	const (
	8	ROS_RPC_APIVersion = "2019-09-10"
	9	ROSServiceCode = "ros"
	10	)
	11
	12	type RpcClient struct {
	13	common.Client
	14	}
	15
	16	func NewRpcClient(accessKeyId, accessKeySecret string) *RpcClient {
	17	endpoint := os.Getenv("ROS_ENDPOINT")
	18	if endpoint == "" {
	19	endpoint = ROSDefaultEndpoint
	20	}
	21	return NewRpcClientWithEndpoint(endpoint, accessKeyId, accessKeySecret)
	22	}
	23
	24	func NewRpcClientWithEndpoint(endpoint string, accessKeyId string, accessKeySecret string) *RpcClient {
	25	client := &RpcClient{}
	26	client.Init(endpoint, ROS_RPC_APIVersion, accessKeyId, accessKeySecret)
	27	return client
	28	}
	29
	30	func NewRosRpcClientWithSecurityToken(accessKeyId string, accessKeySecret string, securityToken string, regionID common.Region) *RpcClient {
	31	endpoint := os.Getenv("ROS_ENDPOINT")
	32	if endpoint == "" {
	33	endpoint = ROSDefaultEndpoint
	34	}
	35
	36	return NewRosRpcClientWithEndpointAndSecurityToken(endpoint, accessKeyId, accessKeySecret, securityToken, regionID)
	37	}
	38
	39	func NewRosRpcClientWithEndpointAndSecurityToken(endpoint string, accessKeyId string, accessKeySecret string, securityToken string, regionID common.Region) *RpcClient {
	40	client := &RpcClient{}
	41	client.WithEndpoint(endpoint).
	42	WithVersion(ROS_RPC_APIVersion).
	43	WithAccessKeyId(accessKeyId).
	44	WithAccessKeySecret(accessKeySecret).
	45	WithSecurityToken(securityToken).
	46	WithServiceCode(ROSServiceCode).
	47	WithRegionID(regionID).
	48	InitClient()
	49	return client
	50	}

+3

-2

ros/signature.go less more

21	21	_, canonicalizedHeader := canonicalizeHeader(headers)
22	22
23	23	stringToSign := request.Method + "\n" + accept + "\n" + contentMd5 + "\n" + contentType + "\n" + date + "\n" + canonicalizedHeader + canonicalizedResource
24
25		log.Println("stringToSign: ", stringToSign)
	24	if client.debug {
	25	log.Println("stringToSign: ", stringToSign)
	26	}
26	27	signature := util.CreateSignature(stringToSign, client.AccessKeySecret)
27	28	headers.Set("Authorization", "acs "+client.AccessKeyId+":"+signature)
28	29	}

+53

-9

ros/stack.go less more

8	8	"github.com/denverdino/aliyungo/util"
9	9	)
10	10
	11	type DeletionProtection string
	12
	13	const (
	14	DeletionProtectionEnabled = DeletionProtection("Enabled")
	15	DeletionProtectionDisabled = DeletionProtection("Disabled")
	16	)
	17
11	18	//https://help.aliyun.com/document_detail/28910.html?spm=5176.doc50083.6.580.b5wkQr
12	19	type CreateStackRequest struct {
13		Name string
14		Template string
15		Parameters interface{}
16		DisableRollback bool
17		TimeoutMins int
	20	Name string
	21	Template string
	22	Parameters interface{}
	23	DisableRollback bool
	24	DeletionProtection DeletionProtection
	25	TimeoutMins int
18	26	}
19	27
20	28	type CreateStackResponse struct {

35	43	//https://help.aliyun.com/document_detail/28911.html?spm=5176.doc28910.6.581.etoi2Z
36	44	type DeleteStackRequest struct {
37	45	RegionId common.Region
	46	}
	47
	48	type DeleteStackRpcRequest struct {
	49	RegionId common.Region
	50	StackId string
	51	RetainResources common.FlattenArray
	52	RetainAllResources bool
	53	}
	54
	55	type SetDeletionProtectionRequest struct {
	56	RegionId common.Region
	57	StackId string
	58	DeletionProtection DeletionProtection
38	59	}
39	60
40	61	type DeleteStackResponse struct {

202	223
203	224	//https://help.aliyun.com/document_detail/49066.html?spm=5176.doc28910.6.586.MJjWQh
204	225	type UpdateStackRequest struct {
205		Template string
206		Parameters interface{}
207		DisableRollback bool
208		TimeoutMins int
	226	Template string
	227	Parameters interface{}
	228	DisableRollback bool
	229	TimeoutMins int
	230	StackPolicy interface{}
	231	UpdateAllowPolicy interface{}
	232	Existing bool
209	233	}
210	234
211	235	type UpdateStackResponse struct {

223	247
224	248	return stack, nil
225	249	}
	250
	251	// rpc api: https://help.aliyun.com/document_detail/132113.html?spm=a2c4g.11174283.6.880.1b1d143eCzdE0b
	252	func (client RpcClient) DeleteStack(args DeleteStackRpcRequest) (*DeleteStackResponse, error) {
	253	response := &DeleteStackResponse{}
	254	err := client.InvokeByFlattenMethod("DeleteStack", args, response)
	255	if err != nil {
	256	return nil, err
	257	}
	258	return response, nil
	259	}
	260
	261	// rpc api: https://help.aliyun.com/document_detail/161560.html?spm=a2c4g.11186623.6.991.18f62842yOfz9G
	262	func (client RpcClient) SetDeletionProtection(args SetDeletionProtectionRequest) (*common.Response, error) {
	263	response := &common.Response{}
	264	err := client.Invoke("SetDeletionProtection", args, response)
	265	if err != nil {
	266	return nil, err
	267	}
	268	return response, nil
	269	}

+66

-0

ros/stack_test.go less more

0	0	package ros
1	1
2	2	import (
	3	"strings"
3	4	"testing"
4	5
5	6	"fmt"

90	91	}
91	92	}
92	93
	94	func TestClient_CreateStack_DeletionProtection(t *testing.T) {
	95	args := &CreateStackRequest{
	96	Name: fmt.Sprintf("my-k8s-test-stack-%d", time.Now().Unix()),
	97	Template: myTestTemplate,
	98	Parameters: map[string]interface{}{},
	99	DisableRollback: false,
	100	DeletionProtection: DeletionProtectionEnabled,
	101	TimeoutMins: 30,
	102	}
	103
	104	response, err := debugClientForTestCase.CreateStack(TestRegionID, args)
	105	if err != nil {
	106	t.Fatalf("Failed to CreateStack %++v", err)
	107	} else {
	108	t.Logf("Success %++v", response)
	109	}
	110	}
	111
93	112	func TestClient_DeleteStack(t *testing.T) {
94	113	stackName := os.Getenv("StackName")
95	114	stackId := os.Getenv("StackId")

158	177	t.Logf("Success %++v", response)
159	178	}
160	179	}
	180
	181	func TestClient_DeleteStackWithParams(t *testing.T) {
	182	stackId := os.Getenv("StackId")
	183	resourceIds := os.Getenv("RetainResources")
	184
	185	args := &DeleteStackRpcRequest{
	186	RegionId: TestRegionID,
	187	StackId: stackId,
	188	RetainResources: strings.Split(resourceIds, ","),
	189	}
	190
	191	response, err := debugRpcClientForTestCase.DeleteStack(args)
	192	if err != nil {
	193	t.Fatalf("Failed to DeleteStack %++v", err)
	194	} else {
	195	t.Logf("Success %++v", response)
	196	}
	197	}
	198
	199	func TestClient_DeleteStack_DisabledProtection(t *testing.T) {
	200	stackId := os.Getenv("StackId")
	201
	202	args := &SetDeletionProtectionRequest{
	203	RegionId: TestRegionID,
	204	StackId: stackId,
	205	DeletionProtection: DeletionProtectionDisabled,
	206	}
	207
	208	response, err := debugRpcClientForTestCase.SetDeletionProtection(args)
	209	if err != nil {
	210	t.Fatalf("Failed to SetDeletionProtection %++v", err)
	211	} else {
	212	t.Logf("Success %++v", response)
	213	}
	214
	215	deleteArgs := &DeleteStackRpcRequest{
	216	RegionId: TestRegionID,
	217	StackId: stackId,
	218	}
	219
	220	resp, err := debugRpcClientForTestCase.DeleteStack(deleteArgs)
	221	if err != nil {
	222	t.Fatalf("Failed to DeleteStack %++v", err)
	223	} else {
	224	t.Logf("Success %++v", resp)
	225	}
	226	}

+48

-0

ros/standard/client.go less more

	0	package standard
	1
	2	import (
	3	"github.com/denverdino/aliyungo/common"
	4
	5	"os"
	6	)
	7
	8	type Client struct {
	9	common.Client
	10	}
	11
	12	const (
	13	// ROSDefaultEndpoint is the default API endpoint of ESS services
	14	ROSDefaultEndpoint = "https://ros.aliyuncs.com"
	15	ROSAPIVersion = "2019-09-10"
	16	ROSServiceCode = "ros"
	17	)
	18
	19	// NewClient creates a new instance of RDS client
	20	func NewClient(accessKeyId, accessKeySecret string) *Client {
	21	endpoint := os.Getenv("ROS_ENDPOINT")
	22	if endpoint == "" {
	23	endpoint = ROSDefaultEndpoint
	24	}
	25	return NewClientWithEndpoint(endpoint, accessKeyId, accessKeySecret)
	26	}
	27
	28	func NewClientWithEndpoint(endpoint string, accessKeyId, accessKeySecret string) *Client {
	29	client := &Client{}
	30	client.Init(endpoint, ROSAPIVersion, accessKeyId, accessKeySecret)
	31	return client
	32	}
	33
	34	func NewROSClient(accessKeyId, accessKeySecret string, regionID common.Region) *Client {
	35	endpoint := os.Getenv("ROS_ENDPOINT")
	36	if endpoint == "" {
	37	endpoint = ROSDefaultEndpoint
	38	}
	39
	40	return NewClientWithRegion(endpoint, accessKeyId, accessKeySecret, regionID)
	41	}
	42
	43	func NewClientWithRegion(endpoint string, accessKeyId, accessKeySecret string, regionID common.Region) *Client {
	44	client := &Client{}
	45	client.NewInit(endpoint, ROSAPIVersion, accessKeyId, accessKeySecret, ROSServiceCode, regionID)
	46	return client
	47	}

+77

-0

ros/standard/client_test.go less more

	0	package standard
	1
	2	import (
	3	"fmt"
	4	"github.com/denverdino/aliyungo/common"
	5	"testing"
	6	)
	7
	8	const (
	9	TestAccessKeyId = ""
	10	TestAccessKeySecret = ""
	11	Region = common.Shanghai
	12	StackID = "c7f1fed9-0104-4596-aae6-aa5215f5a793"
	13	)
	14
	15	func NewTestClient() *Client {
	16	return NewROSClient(TestAccessKeyId, TestAccessKeySecret, Region)
	17	}
	18
	19	func TestGetStack(t *testing.T) {
	20
	21	client := NewTestClient()
	22	req := GetStackRequest{
	23	RegionId: Region,
	24	StackId: StackID,
	25	}
	26	res, err := client.GetStack(&req)
	27	if err != nil {
	28	t.Fail()
	29	}
	30	fmt.Printf("Response: %+v\n", res)
	31	}
	32
	33	func TestListStack(t *testing.T) {
	34	client := NewTestClient()
	35	req := &ListStacksRequest{}
	36	res, err := client.ListStacks(req)
	37	if err != nil {
	38	t.Fail()
	39	}
	40	fmt.Printf("ListResponse: %+v\n", res)
	41	}
	42
	43	func TestListStackEvent(t *testing.T) {
	44	client := NewTestClient()
	45	req := &ListStackEventsRequest{
	46	StackId: StackID,
	47	}
	48	res, err := client.ListStackEvents(req)
	49	if err != nil {
	50	t.Fail()
	51	}
	52	fmt.Printf("ListEventResponse: %+v\n", res)
	53	}
	54
	55	func TestCreateStack(t *testing.T) {
	56	client := NewTestClient()
	57	req := &CreateStackRequest{
	58	StackName: "TDDDDDDD",
	59	TemplateBody: tpl,
	60	DisableRollback: true,
	61	TimeoutInMinutes: 60,
	62	Parameters: []Parameter{
	63	{ParameterKey: "SystemDisk", ParameterValue: ""},
	64	},
	65	}
	66	res, err := client.CreateStack(req)
	67	if err != nil {
	68	t.Logf("create stack: %s", err.Error())
	69	t.Fail()
	70	}
	71	fmt.Printf("ListEventResponse: %+v\n", res)
	72	}
	73
	74	var tpl = `
	75
	76	`

+316

-0

ros/standard/stack.go less more

	0	package standard
	1
	2	import (
	3	"github.com/denverdino/aliyungo/common"
	4	)
	5
	6	type DeletionProtection string
	7
	8	const (
	9	DeletionProtectionEnabled = DeletionProtection("Enabled")
	10	DeletionProtectionDisabled = DeletionProtection("Disabled")
	11	)
	12
	13	//https://help.aliyun.com/document_detail/28910.html?spm=5176.doc50083.6.580.b5wkQr
	14	type CreateStackRequest struct {
	15	RegionId common.Region
	16	StackName string
	17	DisableRollback bool
	18	TemplateBody string
	19	TemplateURL string
	20	Parameters []Parameter
	21	StackPolicyURL string
	22	TimeoutInMinutes int
	23	StackPolicyBody string
	24	ClientToken string
	25	NotificationURLs []string
	26	DeletionProtection DeletionProtection
	27	RamRoleName string
	28	}
	29
	30	type CreateStackResponse struct {
	31	StackId string
	32	common.Response
	33	}
	34
	35	type ListStackEventsRequest struct {
	36	common.Pagination
	37	RegionId common.Region
	38	StackId string
	39	Status []string
	40	ResourceType []string
	41	LogicalResourceId []string
	42	}
	43
	44	type ListStackEventsResponse struct {
	45	common.Response
	46	common.PaginationResult
	47	RegionId common.Region
	48	Events []Event
	49	}
	50
	51	type Event struct {
	52	StackId string
	53	Status string
	54	StackName string
	55	StatusReason string
	56	EventId string
	57	LogicalResourceId string
	58	ResourceType string
	59	PhysicalResourceId string
	60	CreateTime string
	61	}
	62
	63	func (client Client) ListStackEvents(args ListStackEventsRequest) (*ListStackEventsResponse, error) {
	64	response := &ListStackEventsResponse{}
	65	err := client.Invoke("ListStackEvents", args, response)
	66	if err != nil {
	67	return nil, err
	68	}
	69
	70	return response, nil
	71	}
	72
	73	func (client Client) CreateStack(args CreateStackRequest) (*CreateStackResponse, error) {
	74	stack := &CreateStackResponse{}
	75	err := client.Invoke("CreateStack", args, stack)
	76	if err != nil {
	77	return nil, err
	78	}
	79
	80	return stack, nil
	81	}
	82
	83	//https://help.aliyun.com/document_detail/28911.html?spm=5176.doc28910.6.581.etoi2Z
	84	type DeleteStackRequest struct {
	85	RegionId common.Region
	86	StackId string
	87	RetainAllResources bool
	88	RetainResources []string
	89	RamRoleName string
	90	}
	91
	92	type DeleteStackResponse struct {
	93	common.Response
	94	}
	95
	96	func (client Client) DeleteStack(req DeleteStackRequest) (*DeleteStackResponse, error) {
	97	response := &DeleteStackResponse{}
	98	err := client.Invoke("DeleteStack", req, response)
	99	if err != nil {
	100	return nil, err
	101	}
	102
	103	return response, nil
	104	}
	105
	106	type GetStackRequest struct {
	107	RegionId common.Region
	108	StackId string
	109	ClientToken string
	110	}
	111
	112	type GetStackResponse struct {
	113	CreateTime string
	114	Description string
	115	DisableRollback bool
	116	NotificationURLs []string
	117	Outputs []Output
	118	ParentStackId string
	119	RegionId common.Region
	120	Status string
	121	StackId string
	122	StackName string
	123	Parameters []Parameter
	124	UpdateTime string
	125	StatusReason string
	126	TemplateDescription string
	127	TimeoutInMinutes int
	128
	129	RequestId string
	130	DeletionProtection DeletionProtection
	131	DriftDetectionTime string
	132	RamRoleName string
	133	RootStackId string
	134	StackDriftStatus string
	135	StackType string
	136	}
	137
	138	type Parameter struct {
	139	ParameterKey string
	140	ParameterValue string
	141	}
	142
	143	type Output struct {
	144	Description string
	145	OutputKey string
	146	OutputValue interface{}
	147	}
	148
	149	func (client Client) GetStack(req GetStackRequest) (*GetStackResponse, error) {
	150	response := &GetStackResponse{}
	151	err := client.Invoke("GetStack", req, response)
	152	if err != nil {
	153	return nil, err
	154	}
	155
	156	return response, nil
	157	}
	158
	159	type ListStacksRequest struct {
	160	RegionId common.Region
	161	StackId string
	162	Status []string
	163	ParentStackId string
	164	StackName []string
	165	ShowNestedStack bool
	166	Tag []Tag
	167	common.Pagination
	168	}
	169
	170	type ListStacksResponse struct {
	171	common.PaginationResult
	172	common.Response
	173	Stacks []Stack
	174	}
	175
	176	type Stack struct {
	177	CreateTime string
	178
	179	DisableRollback bool
	180	DriftDetectionTime string
	181	ParentStackId string
	182	RegionId common.Region
	183	StackDriftStatus string
	184	StackId string
	185	StackName string
	186	Status string
	187	StatusReason string
	188
	189	TimeoutInMinutes int
	190	UpdateTime string
	191	}
	192
	193	type Tag struct {
	194	Key string
	195	Value string
	196	}
	197
	198	func (client Client) ListStacks(req ListStacksRequest) (*ListStacksResponse, error) {
	199	response := &ListStacksResponse{}
	200	err := client.Invoke("ListStacks", req, response)
	201	if err != nil {
	202	return nil, err
	203	}
	204
	205	return response, nil
	206	}
	207
	208	type UpdateStackRequest struct {
	209	Parameters []Parameter
	210	RegionId string
	211	StackId string
	212	ClientToken string
	213	StackPolicyDuringUpdateBody string
	214	TimeoutInMinutes int
	215	TemplateBody string
	216	StackPolicyURL string
	217	StackPolicyDuringUpdateURL string
	218	StackPolicyBody string
	219	UsePreviousParameters bool
	220	DisableRollback bool
	221	TemplateURL string
	222	RamRoleName string
	223	ReplacementOption string
	224	}
	225
	226	type UpdateStackResponse struct {
	227	StackId string
	228	common.Response
	229	}
	230
	231	func (client Client) UpdateStack(req UpdateStackRequest) (*UpdateStackResponse, error) {
	232	response := &UpdateStackResponse{}
	233	err := client.Invoke("UpdateStack", req, response)
	234	if err != nil {
	235	return nil, err
	236	}
	237
	238	return response, nil
	239	}
	240
	241	type GetStackResourceRequest struct {
	242	StackId string
	243	LogicalResourceId string
	244	ClientToken string
	245	ShowResourceAttributes bool
	246	RegionId common.Region
	247	}
	248
	249	type GetStackResourceResponse struct {
	250	Status string
	251	Description string
	252	LogicalResourceId string
	253	StackId string
	254
	255	StackName string
	256	StatusReason string
	257	PhysicalResourceId string
	258	ResourceType string
	259	CreateTime string
	260	Metadata map[string]string
	261	UpdateTime string
	262	ResourceAttributes []ResourceAttribute
	263	RequestId string
	264	DriftDetectionTime string
	265	ResourceDriftStatus string
	266	}
	267	type ResourceAttribute struct {
	268	ResourceAttributeValue string
	269	ResourceAttributeKey string
	270	}
	271
	272	func (client Client) GetStackResource(req GetStackResourceRequest) (*GetStackResourceResponse, error) {
	273	response := &GetStackResourceResponse{}
	274	err := client.Invoke("GetStackResource", req, response)
	275	if err != nil {
	276	return nil, err
	277	}
	278
	279	return response, nil
	280	}
	281
	282	type ListStackResourcesRequest struct {
	283	RegionId common.Region
	284	StackId string
	285	}
	286
	287	type ListStackResourcesResponse struct {
	288	common.Response
	289	Resources []Resource
	290	}
	291
	292	type Resource struct {
	293	CreateTime string
	294	DriftDetectionTime string
	295	LogicalResourceId string
	296	PhysicalResourceId string
	297
	298	ResourceDriftStatus string
	299	ResourceType string
	300	StackId string
	301	StackName string
	302	Status string
	303	StatusReason string
	304	UpdateTime string
	305	}
	306
	307	func (client Client) ListStackResources(req ListStackResourcesRequest) (*ListStackResourcesResponse, error) {
	308	response := &ListStackResourcesResponse{}
	309	err := client.Invoke("ListStackResources", req, response)
	310	if err != nil {
	311	return nil, err
	312	}
	313
	314	return response, nil
	315	}

+24

-0

slb/client.go less more

56	56	return NewSLBClientWithEndpointAndSecurityToken(endpoint, accessKeyId, accessKeySecret, securityToken, regionID)
57	57	}
58	58
	59	//Only for hangzhou
	60	func NewSLBClientWithSecurityToken4RegionalDomain(accessKeyId string, accessKeySecret string, securityToken string, regionID common.Region) *Client {
	61	endpoint := os.Getenv("SLB_ENDPOINT")
	62	if endpoint == "" {
	63	endpoint = SLBDefaultEndpoint
	64	}
	65
	66	return NewSLBClientWithEndpointAndSecurityToken4RegionalDomain(endpoint, accessKeyId, accessKeySecret, securityToken, regionID)
	67	}
	68
59	69	func NewSLBClientWithEndpointAndSecurityToken(endpoint string, accessKeyId string, accessKeySecret string, securityToken string, regionID common.Region) *Client {
60	70	client := &Client{}
61	71	client.WithEndpoint(endpoint).

68	78	InitClient()
69	79	return client
70	80	}
	81
	82	//only for hangzhou
	83	func NewSLBClientWithEndpointAndSecurityToken4RegionalDomain(endpoint string, accessKeyId string, accessKeySecret string, securityToken string, regionID common.Region) *Client {
	84	client := &Client{}
	85	client.WithEndpoint(endpoint).
	86	WithVersion(SLBAPIVersion).
	87	WithAccessKeyId(accessKeyId).
	88	WithAccessKeySecret(accessKeySecret).
	89	WithSecurityToken(securityToken).
	90	WithServiceCode(SLBServiceCode).
	91	WithRegionID(regionID).
	92	InitClient4RegionalDomain()
	93	return client
	94	}

+2

-1

slb/config_test.go less more

15	15	TestVServerGroupID = "MY_VSERVER_GROUPID"
16	16	TestListenerPort = 9000
17	17	TestInstanceId = "MY_INSTANCE_ID"
	18	TestENIId = "MY_ENI_ID"
18	19	TestRegionID = common.Region(os.Getenv("RegionId"))
19	20	TestIAmRich = false
20	21	TestQuick = false

43	44
44	45	func NewTestNewSLBClientForDebug() *Client {
45	46	if testDebugNewSLBClient == nil {
46		testDebugNewSLBClient = NewSLBClientWithSecurityToken(TestAccessKeyId, TestAccessKeySecret, TestSecurityToken, TestRegionID)
	47	testDebugNewSLBClient = NewSLBClientWithSecurityToken4RegionalDomain(TestAccessKeyId, TestAccessKeySecret, TestSecurityToken, TestRegionID)
47	48	testDebugNewSLBClient.SetDebug(true)
48	49	}
49	50	return testDebugNewSLBClient

+17

-2

slb/listeners.go less more

98	98	UnhealthyThreshold int
99	99	HealthCheckTimeout int
100	100	HealthCheckInterval int
	101	ForwardPort int
	102	ListenerForward FlagType
101	103	HealthCheckHttpCode HealthCheckHttpCodeType
102	104	VServerGroup FlagType
103	105	VServerGroupId string

105	107	XForwardedFor_SLBID FlagType
106	108	XForwardedFor_SLBIP FlagType
107	109	XForwardedFor_proto FlagType
	110	Description string
	111	AclId string
	112	AclStatus string
	113	AclType string
108	114	}
109	115	type CreateLoadBalancerHTTPListenerArgs HTTPListenerType
110	116

146	152	BackendServerPort int
147	153	Bandwidth int
148	154	Scheduler SchedulerType
149		PersistenceTimeout int
	155	PersistenceTimeout *int
150	156	HealthCheck FlagType
151	157	HealthCheckType HealthCheckType
152	158	HealthCheckDomain string

159	165	HealthCheckHttpCode HealthCheckHttpCodeType
160	166	VServerGroup FlagType
161	167	VServerGroupId string
	168	Description string
	169	AclId string
	170	AclStatus string
	171	AclType string
162	172	}
163	173
164	174	type CreateLoadBalancerTCPListenerArgs TCPListenerType

178	188	BackendServerPort int
179	189	Bandwidth int
180	190	Scheduler SchedulerType
181		PersistenceTimeout int
	191	PersistenceTimeout *int
182	192	HealthCheck FlagType
183	193	HealthCheckConnectPort int
184	194	HealthyThreshold int

187	197	HealthCheckInterval int
188	198	VServerGroup FlagType
189	199	VServerGroupId string
	200	Description string
	201
	202	AclId string
	203	AclStatus string
	204	AclType string
190	205	}
191	206	type CreateLoadBalancerUDPListenerArgs UDPListenerType
192	207

+41

-1

slb/listerners_test.go less more

0	0	package slb
1	1
2		import "testing"
	2	import (
	3	"bytes"
	4	"encoding/json"
	5	"fmt"
	6	"testing"
	7	)
3	8
4	9	func testListeners(t testing.T, client Client, loadBalancerId string) {
5	10

40	45	}
41	46	t.Logf("Listener: %++v", *response)
42	47	}
	48
	49	func TestDescribeListener(t *testing.T) {
	50
	51	response, err := client.DescribeLoadBalancerTCPListenerAttribute(loadBalancerId, 22)
	52	if err != nil {
	53	t.Error(err)
	54	} else {
	55	fmt.Println(PrettyJson(response))
	56	}
	57	}
	58
	59	func TestDescribeSLB(t *testing.T) {
	60
	61	response, err := client.DescribeLoadBalancerAttribute(loadBalancerId)
	62	if err != nil {
	63	t.Error(err)
	64	} else {
	65	fmt.Println(PrettyJson(response))
	66	}
	67	}
	68
	69	func PrettyJson(obj interface{}) string {
	70	pretty := bytes.Buffer{}
	71	data, err := json.Marshal(obj)
	72	if err != nil {
	73	return err.Error()
	74	}
	75	err = json.Indent(&pretty, data, "", " ")
	76
	77	if err != nil {
	78	return err.Error()
	79	}
	80
	81	return pretty.String()
	82	}

+141

-26

slb/loadbalancers.go less more

19	19	const (
20	20	PayByBandwidth = InternetChargeType("paybybandwidth")
21	21	PayByTraffic = InternetChargeType("paybytraffic")
	22	)
	23
	24	type AddressIPVersionType string
	25
	26	const (
	27	IPv4 = AddressIPVersionType("ipv4")
	28	IPv6 = AddressIPVersionType("ipv6")
22	29	)
23	30
24	31	type LoadBalancerSpecType string

32	39	S3Large = "slb.s3.large"
33	40	)
34	41
	42	type ModificationProtectionType string
	43
	44	const (
	45	NonProtection = ModificationProtectionType("NonProtection")
	46	ConsoleProtection = ModificationProtectionType("ConsoleProtection")
	47	)
	48
35	49	type CreateLoadBalancerArgs struct {
36		RegionId common.Region
37		LoadBalancerName string
38		AddressType AddressType
39		VSwitchId string
40		InternetChargeType InternetChargeType
41		Bandwidth int
42		ClientToken string
43		MasterZoneId string
44		SlaveZoneId string
45		LoadBalancerSpec LoadBalancerSpecType
	50	RegionId common.Region
	51	LoadBalancerName string
	52	AddressType AddressType
	53	VSwitchId string
	54	InternetChargeType InternetChargeType
	55	Bandwidth int
	56	ClientToken string
	57	MasterZoneId string
	58	SlaveZoneId string
	59	LoadBalancerSpec LoadBalancerSpecType
	60	AddressIPVersion AddressIPVersionType
	61	DeleteProtection FlagType
	62	ModificationProtectionStatus ModificationProtectionType
	63	ModificationProtectionReason string
	64	ResourceGroupId string
46	65	}
47	66
48	67	type CreateLoadBalancerResponse struct {

53	72	VpcId string
54	73	VSwitchId string
55	74	LoadBalancerName string
	75	MasterZoneId string
	76	SlaveZoneId string
	77	AddressIPVersion AddressIPVersionType
56	78	}
57	79
58	80	// CreateLoadBalancer create loadbalancer

192	214	type ListenerPortAndProtocolType struct {
193	215	ListenerPort int
194	216	ListenerProtocol string
	217	Description string
195	218	}
196	219
197	220	type BackendServerType struct {

200	223	Type string
201	224	}
202	225
	226	type ServiceManagedModeType string
	227
	228	const (
	229	Managed = ServiceManagedModeType("Managed")
	230	Unmanaged = ServiceManagedModeType("Unmanaged")
	231	DependencyManaged = ServiceManagedModeType("DependencyManaged")
	232	)
	233
203	234	type LoadBalancerType struct {
204		LoadBalancerId string
205		LoadBalancerName string
206		LoadBalancerStatus string
207		Address string
208		RegionId common.Region
209		RegionIdAlias string
210		AddressType AddressType
211		VSwitchId string
212		VpcId string
213		NetworkType string
214		Bandwidth int
215		InternetChargeType InternetChargeType
216		CreateTime string //Why not ISO 6801
217		CreateTimeStamp util.ISO6801Time
218		ListenerPorts struct {
	235	LoadBalancerId string
	236	ResourceGroupId string
	237	LoadBalancerName string
	238	LoadBalancerStatus string
	239	Address string
	240	RegionId common.Region
	241	RegionIdAlias string
	242	AddressType AddressType
	243	VSwitchId string
	244	VpcId string
	245	NetworkType string
	246	Bandwidth int
	247	InternetChargeType InternetChargeType
	248	CreateTime string //Why not ISO 6801
	249	CreateTimeStamp util.ISO6801Time
	250	DeleteProtection FlagType
	251	ModificationProtectionStatus ModificationProtectionType
	252	ModificationProtectionReason string
	253	ListenerPorts struct {
219	254	ListenerPort []int
220	255	}
221	256	ListenerPortsAndProtocol struct {

224	259	BackendServers struct {
225	260	BackendServer []BackendServerType
226	261	}
227		LoadBalancerSpec LoadBalancerSpecType
	262	LoadBalancerSpec LoadBalancerSpecType
	263	MasterZoneId string
	264	SlaveZoneId string
	265	AddressIPVersion AddressIPVersionType
	266	ServiceManagedMode ServiceManagedModeType
228	267	}
229	268
230	269	type DescribeLoadBalancersResponse struct {

320	359	}
321	360	return nil
322	361	}
	362
	363	type SetLoadBalancerDeleteProtectionArgs struct {
	364	LoadBalancerId string
	365	DeleteProtection FlagType
	366	RegionId common.Region
	367	}
	368
	369	type SetLoadBalancerDeleteProtectionResponse struct {
	370	common.Response
	371	}
	372
	373	// SetLoadBalancerDeleteProtection loadbalancer delete protection
	374	//
	375	// You can read doc at https://help.aliyun.com/document_detail/122674.html?spm=a2c4g.11186623.6.720.694f4265hwOdXQ
	376	func (client Client) SetLoadBalancerDeleteProtection(args SetLoadBalancerDeleteProtectionArgs) (err error) {
	377	response := &SetLoadBalancerDeleteProtectionResponse{}
	378	err = client.Invoke("SetLoadBalancerDeleteProtection", args, response)
	379	return err
	380	}
	381
	382	type SetLoadBalancerModificationProtectionArgs struct {
	383	RegionId common.Region
	384	LoadBalancerId string
	385	ModificationProtectionStatus ModificationProtectionType
	386	ModificationProtectionReason string
	387	}
	388
	389	type SetLoadBalancerModificationProtectionResponse struct {
	390	common.Response
	391	}
	392
	393	func (client Client) SetLoadBalancerModificationProtection(args SetLoadBalancerModificationProtectionArgs) (err error) {
	394	response := &SetLoadBalancerModificationProtectionResponse{}
	395	err = client.Invoke("SetLoadBalancerModificationProtection", args, response)
	396	return err
	397	}
	398
	399	type ManagedResourceType string
	400
	401	const (
	402	ManagedLoadBalancer = ManagedResourceType("LoadBalancer")
	403	ManagedTls = ManagedResourceType("Tls")
	404	ManagedVServerGroup = ManagedResourceType("VServerGroup")
	405	ManagedMasterSlaveServerGroup = ManagedResourceType("MasterSlaveServerGroup")
	406	ManagedAcl = ManagedResourceType("Acl")
	407	ManagedListener = ManagedResourceType("Listener")
	408	ManagedRule = ManagedResourceType("Rule")
	409	ManagedAppRule = ManagedResourceType("AppRule")
	410	ManagedDomainExtension = ManagedResourceType("DomainExtension")
	411	)
	412
	413	type ManagedResourceModel struct {
	414	ResourceId string
	415	Port int
	416	Protocol string
	417	}
	418
	419	type ServiceManagedControlArgs struct {
	420	RegionId common.Region
	421	ServiceManagedMode ServiceManagedModeType
	422	ResourceUid string
	423	ResourceBid string
	424	ResourceType ManagedResourceType
	425	Resources []ManagedResourceModel
	426	}
	427
	428	type ServiceManagedControlResponse struct {
	429	common.Response
	430	}
	431
	432	//api: https://yuque.antfin-inc.com/docs/share/63b5a2d3-6fb3-4bd7-a50e-c4b385b866fd?#
	433	func (client Client) ServiceManagedControl(args ServiceManagedControlArgs) (err error) {
	434	response := &ServiceManagedControlResponse{}
	435	err = client.Invoke("ServiceManagedControl", args, response)
	436	return err
	437	}

+214

-1

slb/loadbalancers_test.go less more

5	5	"github.com/denverdino/aliyungo/common"
6	6	)
7	7
8		func TestLoadBlancer(t *testing.T) {
	8	func TestLoadBalancer(t *testing.T) {
9	9
10	10	client := NewTestClientForDebug()
11	11
12	12	creationArgs := CreateLoadBalancerArgs{
13	13	RegionId: common.Beijing,
14	14	LoadBalancerName: "test-slb",
	15	LoadBalancerSpec: S2Medium, // eni not support slb.s0.share slb(default slb.s0.share)
15	16	AddressType: InternetAddressType,
16	17	ClientToken: client.GenerateClientToken(),
17	18	}

29	30
30	31	describeLoadBalancersArgs := DescribeLoadBalancersArgs{
31	32	RegionId: common.Beijing,
	33	}
	34
	35	loadBalancers, err := client.DescribeLoadBalancers(&describeLoadBalancersArgs)
	36
	37	if err != nil {
	38	t.Fatalf("Failed to DescribeLoadBalancers: %v", err)
	39	}
	40	t.Logf("DescribeLoadBalancers result: %++v", loadBalancers)
	41
	42	err = client.SetLoadBalancerStatus(lbId, InactiveStatus)
	43	if err != nil {
	44	t.Fatalf("Failed to SetLoadBalancerStatus: %v", err)
	45	}
	46	err = client.SetLoadBalancerName(lbId, "test-slb2")
	47	if err != nil {
	48	t.Fatalf("Failed to SetLoadBalancerName: %v", err)
	49	}
	50	loadBalancer, err := client.DescribeLoadBalancerAttribute(lbId)
	51
	52	if err != nil {
	53	t.Fatalf("Failed to DescribeLoadBalancerAttribute: %v", err)
	54	}
	55	t.Logf("DescribeLoadBalancerAttribute result: %++v", loadBalancer)
	56
	57	err = client.DeleteLoadBalancer(lbId)
	58	if err != nil {
	59	t.Errorf("Failed to DeleteLoadBalancer: %v", err)
	60	}
	61
	62	t.Logf("DeleteLoadBalancer successfully: %s", lbId)
	63
	64	}
	65
	66	func TestLoadBalancerIPv6(t *testing.T) {
	67
	68	client := NewTestClientForDebug()
	69
	70	creationArgs := CreateLoadBalancerArgs{
	71	RegionId: common.Hangzhou,
	72	LoadBalancerName: "test-slb-ipv6",
	73	AddressType: InternetAddressType,
	74	MasterZoneId: "cn-hangzhou-e",
	75	SlaveZoneId: "cn-hangzhou-f",
	76	ClientToken: client.GenerateClientToken(),
	77	AddressIPVersion: IPv6,
	78	}
	79
	80	response, err := client.CreateLoadBalancer(&creationArgs)
	81	if err != nil {
	82	t.Fatalf("Failed to CreateLoadBalancer: %v", err)
	83	}
	84
	85	t.Logf("CreateLoadBalancer result: %v", *response)
	86	lbId := response.LoadBalancerId
	87
	88	describeLoadBalancersArgs := DescribeLoadBalancersArgs{
	89	RegionId: common.Hangzhou,
32	90	}
33	91
34	92	loadBalancers, err := client.DescribeLoadBalancers(&describeLoadBalancersArgs)

78	136	t.Logf("Result = %++v", slbs)
79	137	}
80	138	}
	139
	140	func TestClient_SetLoadBalancerDeleteProtection(t *testing.T) {
	141	client := NewTestNewSLBClientForDebug()
	142
	143	creationArgs := CreateLoadBalancerArgs{
	144	RegionId: common.Beijing,
	145	LoadBalancerName: "test-slb",
	146	LoadBalancerSpec: S2Medium,
	147	AddressType: InternetAddressType,
	148	ClientToken: client.GenerateClientToken(),
	149	}
	150
	151	response, err := client.CreateLoadBalancer(&creationArgs)
	152	if err != nil {
	153	t.Fatalf("Failed to CreateLoadBalancer: %v", err)
	154	}
	155
	156	t.Logf("CreateLoadBalancer result: %v", *response)
	157	lbId := response.LoadBalancerId
	158
	159	args := &SetLoadBalancerDeleteProtectionArgs{
	160	LoadBalancerId: lbId,
	161	DeleteProtection: OnFlag,
	162	RegionId: common.Beijing,
	163	}
	164
	165	err = client.SetLoadBalancerDeleteProtection(args)
	166	if err != nil {
	167	t.Fatalf("Failed %++v", err)
	168	}
	169	t.Logf("SetLoadBalancerDeleteProtection result: %v", *response)
	170
	171	err = client.DeleteLoadBalancer(lbId)
	172	if err != nil {
	173	t.Logf("DeleteLoadBalancer result: %++v", err)
	174	} else {
	175	t.Fatalf("Failed to set LoadBalancer delete protection.")
	176	}
	177	}
	178
	179	func TestClient_SetLoadBalancerModificationProtection(t *testing.T) {
	180	client := NewTestNewSLBClientForDebug()
	181
	182	creationArgs := CreateLoadBalancerArgs{
	183	RegionId: common.Beijing,
	184	LoadBalancerName: "test-slb-modification-protection",
	185	LoadBalancerSpec: S1Small,
	186	AddressType: InternetAddressType,
	187	ModificationProtectionStatus: ConsoleProtection,
	188	ModificationProtectionReason: "kubernetes.do.not.delete",
	189	ClientToken: client.GenerateClientToken(),
	190	}
	191	response, err := client.CreateLoadBalancer(&creationArgs)
	192	if err != nil {
	193	t.Fatalf("Failed to CreateLoadBalancer: %v", err)
	194	}
	195
	196	t.Logf("CreateLoadBalancer result: %v", *response)
	197	lbId := response.LoadBalancerId
	198
	199	lb, err := client.DescribeLoadBalancerAttribute(lbId)
	200	if err != nil {
	201	t.Fatalf("Failed to DescribeLoadBalancerAttribute: %v", err)
	202	}
	203
	204	if lb.ModificationProtectionStatus != ConsoleProtection {
	205	t.Fatalf("Failed to SetLoadBalancerModificationProtection, slb %s, expected %s got %s",
	206	lbId, ConsoleProtection, lb.ModificationProtectionStatus)
	207	}
	208
	209	args := SetLoadBalancerModificationProtectionArgs{
	210	RegionId: common.Beijing,
	211	LoadBalancerId: lbId,
	212	ModificationProtectionStatus: NonProtection,
	213	}
	214
	215	err = client.SetLoadBalancerModificationProtection(&args)
	216	if err != nil {
	217	t.Fatalf("Failed to SetLoadBalancerModificationProtection: %v", err)
	218	}
	219
	220	lb, err = client.DescribeLoadBalancerAttribute(lbId)
	221	if err != nil {
	222	t.Fatalf("Failed to DescribeLoadBalancerAttribute: %v", err)
	223	}
	224
	225	if lb.ModificationProtectionStatus != NonProtection {
	226	t.Fatalf("Failed to SetLoadBalancerModificationProtection, slb %s, expected %s got %s",
	227	lbId, ConsoleProtection, lb.ModificationProtectionStatus)
	228	}
	229
	230	// Delete Slb
	231	err = client.DeleteLoadBalancer(lbId)
	232	if err != nil {
	233	t.Fatalf("Failed to DeleteLoadBalancer: %v", err)
	234	}
	235
	236	}
	237
	238	func TestClient_ServiceManagedControl(t *testing.T) {
	239	client := NewTestNewSLBClientForDebug()
	240
	241	creationArgs := CreateLoadBalancerArgs{
	242	RegionId: common.Beijing,
	243	LoadBalancerName: "test-slb-modification-protection",
	244	LoadBalancerSpec: S1Small,
	245	AddressType: InternetAddressType,
	246	ModificationProtectionStatus: ConsoleProtection,
	247	ModificationProtectionReason: "kubernetes.do.not.delete",
	248	ClientToken: client.GenerateClientToken(),
	249	}
	250	response, err := client.CreateLoadBalancer(&creationArgs)
	251	if err != nil {
	252	t.Fatalf("Failed to CreateLoadBalancer: %v", err)
	253	}
	254
	255	t.Logf("CreateLoadBalancer result: %v", *response)
	256	lbId := response.LoadBalancerId
	257
	258	lb, err := client.DescribeLoadBalancerAttribute(lbId)
	259	if err != nil {
	260	t.Fatalf("Failed to DescribeLoadBalancerAttribute: %v", err)
	261	}
	262
	263	resource := make([]ManagedResourceModel, 0)
	264	resource = append(resource, ManagedResourceModel{ResourceId: lb.LoadBalancerId})
	265	args := ServiceManagedControlArgs{
	266	RegionId: common.Beijing,
	267	ServiceManagedMode: Managed,
	268	ResourceType: ManagedLoadBalancer,
	269	Resources: resource,
	270	}
	271
	272	err = client.ServiceManagedControl(&args)
	273	if err != nil {
	274	t.Fatalf("Failed to modify resource managed status: %v", err)
	275	}
	276
	277	lb, err = client.DescribeLoadBalancerAttribute(lbId)
	278	if err != nil {
	279	t.Fatalf("Failed to DescribeLoadBalancerAttribute: %v", err)
	280	}
	281
	282	if lb.ServiceManagedMode != Managed {
	283	t.Fatalf("Failed to modify resource managed status, slb %s, expected %s got %s",
	284	lbId, Managed, lb.ServiceManagedMode)
	285	}
	286
	287	// Delete Slb
	288	err = client.DeleteLoadBalancer(lbId)
	289	if err != nil {
	290	t.Fatalf("Failed to DeleteLoadBalancer: %v", err)
	291	}
	292
	293	}

+2

-2

slb/rules_test.go less more

10	10	client := NewTestClientForDebug()
11	11
12	12	rulesArr := []Rule{
13		Rule{RuleName: "rule-001", Domain: "datapaking.com", Url: "/rule0001", VServerGroupId: TestVServerGroupID},
14		Rule{RuleName: "rule-002", Domain: "datapaking.com", Url: "/rule0002", VServerGroupId: TestVServerGroupID},
	13	{RuleName: "rule-001", Domain: "datapaking.com", Url: "/rule0001", VServerGroupId: TestVServerGroupID},
	14	{RuleName: "rule-002", Domain: "datapaking.com", Url: "/rule0002", VServerGroupId: TestVServerGroupID},
15	15	}
16	16	ruleStr, _ := json.Marshal(rulesArr)
17	17

+6

-4

slb/servers.go less more

1	1
2	2	import (
3	3	"encoding/json"
4
5	4	"github.com/denverdino/aliyungo/common"
6	5	)
7	6

62	61
63	62	type RemoveBackendServersArgs struct {
64	63	LoadBalancerId string
65		BackendServers []string
	64	BackendServers string
66	65	}
67	66
68	67	type RemoveBackendServersResponse struct {

76	75	// RemoveBackendServers Remove backend servers
77	76	//
78	77	// You can read doc at http://docs.aliyun.com/#/pub/slb/api-reference/api-related-backendserver&RemoveBackendServers
79		func (client *Client) RemoveBackendServers(loadBalancerId string, backendServers []string) (result []BackendServerType, err error) {
	78	func (client *Client) RemoveBackendServers(loadBalancerId string, backendServers []BackendServerType) (result []BackendServerType, err error) {
	79	bytes, _ := json.Marshal(backendServers)
	80
80	81	args := &RemoveBackendServersArgs{
81	82	LoadBalancerId: loadBalancerId,
82		BackendServers: backendServers,
	83	BackendServers: string(bytes),
83	84	}
84	85	response := &RemoveBackendServersResponse{}
	86
85	87	err = client.Invoke("RemoveBackendServers", args, response)
86	88	if err != nil {
87	89	return nil, err

+8

-2

slb/servers_test.go less more

4	4	func testBackendServers(t testing.T, client Client, loadBalancerId string) {
5	5
6	6	backendServers := []BackendServerType{
7		BackendServerType{
	7	{
8	8	ServerId: TestInstanceId,
9	9	Weight: 100,
	10	Type: "ecs",
10	11	},
	12	//BackendServerType{
	13	// ServerId: TestENIId,
	14	// Weight: 100,
	15	// Type: "eni",
	16	//},
11	17	}
12	18
13	19	servers, err := client.AddBackendServers(loadBalancerId, backendServers)

28	34
29	35	t.Logf("Backend servers: %++v", servers)
30	36
31		servers, err = client.RemoveBackendServers(loadBalancerId, []string{TestInstanceId})
	37	servers, err = client.RemoveBackendServers(loadBalancerId, backendServers)
32	38	if err != nil {
33	39	t.Errorf("Failed to RemoveBackendServers: %v", err)
34	40	}

+4

-4

slb/tags_test.go less more

10	10	client := NewTestClientForDebug()
11	11
12	12	tagItemArr := []TagItem{
13		TagItem{TagKey: "username", TagValue: "test"},
14		TagItem{TagKey: "birdthday", TagValue: "20170101"},
	13	{TagKey: "username", TagValue: "test"},
	14	{TagKey: "birdthday", TagValue: "20170101"},
15	15	}
16	16	tagItems, _ := json.Marshal(tagItemArr)
17	17

33	33	client := NewTestClientForDebug()
34	34
35	35	tagItemArr := []TagItem{
36		TagItem{TagKey: "username", TagValue: "test"},
37		TagItem{TagKey: "birdthday", TagValue: "20170101"},
	36	{TagKey: "username", TagValue: "test"},
	37	{TagKey: "birdthday", TagValue: "20170101"},
38	38	}
39	39	tagItems, _ := json.Marshal(tagItemArr)
40	40

+22

-7

slb/vserver_group.go less more

4	4	)
5	5
6	6	type VBackendServerType struct {
7		ServerId string
8		Weight int
9		Port int
10		Type string
	7	ServerId string
	8	Weight int
	9	Port int
	10	Type string
	11	ServerIp string
	12	Description string
11	13	}
12	14
13	15	type VServerGroup struct {
	16	RegionId common.Region
14	17	VServerGroupName string
15	18	VServerGroupId string
16	19	}

50	53	}
51	54
52	55	type DescribeVServerGroupsArgs struct {
53		LoadBalancerId string
54		RegionId common.Region
	56	LoadBalancerId string
	57	RegionId common.Region
	58	IncludeRule bool
	59	IncludeListener bool
55	60	}
56	61
57	62	type DescribeVServerGroupAttributeArgs struct {

82	87	VServerGroups struct {
83	88	VServerGroup []VServerGroup
84	89	}
	90	AssociatedObjects struct {
	91	Listeners string
	92	Rules string
	93	}
85	94	}
86		type DescribeVServerGroupAttributeResponse CreateVServerGroupResponse
	95	type DescribeVServerGroupAttributeResponse struct {
	96	common.Response
	97	VServerGroupId string
	98	VServerGroupName string
	99	LoadBalancerId string
	100	BackendServers VBackendServers
	101	}
87	102
88	103	func (client Client) CreateVServerGroup(args CreateVServerGroupArgs) (response *CreateVServerGroupResponse, err error) {
89	104	response = &CreateVServerGroupResponse{}

+7

-6

slb/vserver_group_test.go less more

2	2	import (
3	3	"encoding/json"
4	4	"testing"
	5
	6	"fmt"
5	7
6	8	"github.com/denverdino/aliyungo/common"
7	9	)

56	58
57	59	func TestDescribeVServerGroups(t *testing.T) {
58	60	arg := &DescribeVServerGroupsArgs{
59		LoadBalancerId: loadBalancerId,
60		RegionId: region,
	61	LoadBalancerId: loadBalancerId,
	62	RegionId: region,
	63	IncludeListener: true,
	64	IncludeRule: true,
61	65	}
62	66	response, err := client.DescribeVServerGroups(arg)
63	67	if err != nil {
64	68	t.Error(err)
65	69	} else {
66		t.Log(response)
67		for _, vserverGroup := range response.VServerGroups.VServerGroup {
68		deleteVServerGroupIdList = append(deleteVServerGroupIdList, vserverGroup.VServerGroupId)
69		}
	70	fmt.Println(PrettyJson(response))
70	71	}
71	72	}
72	73

+51

-0

slb/zones.go less more

	0	package slb
	1
	2	import (
	3	"github.com/denverdino/aliyungo/common"
	4	)
	5
	6	type DescribeZonesArgs struct {
	7	RegionId common.Region
	8	}
	9
	10	//
	11	// You can read doc at http://docs.aliyun.com/#/pub/ecs/open-api/datatype&zonetype
	12	type ZoneType struct {
	13	ZoneId string
	14	LocalName string
	15	SlaveZones struct {
	16	SlaveZone []ZoneType
	17	}
	18	}
	19
	20	type DescribeZonesResponse struct {
	21	common.Response
	22	Zones struct {
	23	Zone []ZoneType
	24	}
	25	}
	26
	27	// DescribeZones describes zones
	28	func (client *Client) DescribeZones(regionId common.Region) (zones []ZoneType, err error) {
	29	response, err := client.DescribeZonesWithRaw(regionId)
	30	if err == nil {
	31	return response.Zones.Zone, nil
	32	}
	33
	34	return []ZoneType{}, err
	35	}
	36
	37	func (client Client) DescribeZonesWithRaw(regionId common.Region) (response DescribeZonesResponse, err error) {
	38	args := DescribeZonesArgs{
	39	RegionId: regionId,
	40	}
	41	response = &DescribeZonesResponse{}
	42
	43	err = client.Invoke("DescribeZones", &args, response)
	44
	45	if err == nil {
	46	return response, nil
	47	}
	48
	49	return nil, err
	50	}

+20

-0

slb/zones_test.go less more

	0	package slb
	1
	2	import (
	3	"github.com/denverdino/aliyungo/common"
	4	"testing"
	5	)
	6
	7	func TestDescribeZones(t *testing.T) {
	8
	9	client := NewTestNewSLBClientForDebug()
	10
	11	zones, err := client.DescribeZones(common.Hangzhou)
	12
	13	if err == nil {
	14	t.Logf("regions: %v", zones)
	15	} else {
	16	t.Errorf("Failed to DescribeZones: %v", err)
	17	}
	18
	19	}

+8

-0

sls/client.go less more

25	25
26	26	func (client *Client) SetDebug(debug bool) {
27	27	client.debug = debug
	28	}
	29
	30	// SetTransport sets transport to the http client
	31	func (client *Client) SetTransport(transport http.RoundTripper) {
	32	if client.httpClient == nil {
	33	client.httpClient = &http.Client{}
	34	}
	35	client.httpClient.Transport = transport
28	36	}
29	37
30	38	type Project struct {

+1

-2

sls/machine_group.go less more

1	1
2	2	import (
3	3	"encoding/json"
4		"errors"
5	4	"fmt"
6	5	"strconv"
7	6	)

153	152	return v, nil
154	153	}
155	154
156		return nil, errors.New(fmt.Sprintf("%v is not a string array", configs["config"]))
	155	return nil, fmt.Errorf("%v is not a string array", configs["config"])
157	156	}

+2

-2

sls/signature.go less more

50	50	canonicalizedResource := req.path
51	51	var paramNames []string
52	52	if req.params != nil && len(req.params) > 0 {
53		for k, _ := range req.params {
	53	for k := range req.params {
54	54	paramNames = append(paramNames, k)
55	55	}
56	56	sort.Strings(paramNames)

68	68	func canonicalizeHeader(headers map[string]string) string {
69	69	var canonicalizedHeaders []string
70	70
71		for k, _ := range headers {
	71	for k := range headers {
72	72	if lower := strings.ToLower(k); strings.HasPrefix(lower, HeaderSLSPrefix1) \|\| strings.HasPrefix(lower, HeaderSLSPrefix2) {
73	73	canonicalizedHeaders = append(canonicalizedHeaders, lower)
74	74	}

+3

-3

sts/assume_role_test.go less more

25	25
26	26	princpalPolicyDocument = ram.AssumeRolePolicyDocument{
27	27	Statement: []ram.AssumeRolePolicyItem{
28		ram.AssumeRolePolicyItem{Action: "sts:AssumeRole", Effect: "Allow", Principal: princpal},
	28	{Action: "sts:AssumeRole", Effect: "Allow", Principal: princpal},
29	29	},
30	30	Version: "1"}
31	31

38	38
39	39	var policyDocument = ram.PolicyDocument{
40	40	Statement: []ram.PolicyItem{
41		ram.PolicyItem{
	41	{
42	42	Action: "oss:GetObject",
43	43	Effect: "Allow",
44	44	Resource: "acs:oss:::*/anyprefix",

65	65	func createPolicyDocument() *ram.PolicyDocument {
66	66	return &ram.PolicyDocument{
67	67	Statement: []ram.PolicyItem{
68		ram.PolicyItem{
	68	{
69	69	Action: "oss:GetObject",
70	70	Effect: "Allow",
71	71	Resource: "acs:oss:::/",

+2

-2

util/attempt_test.go less more

13	13	got := make([]time.Duration, 0, len(want)) // avoid allocation when testing timing
14	14	t0 := time.Now()
15	15	for a := testAttempt.Start(); a.Next(); {
16		got = append(got, time.Now().Sub(t0))
	16	got = append(got, time.Since(t0))
17	17	}
18		got = append(got, time.Now().Sub(t0))
	18	got = append(got, time.Since(t0))
19	19	if len(got) != len(want) {
20	20	t.Fatalf("Failed!")
21	21	}

+2

-2

util/encoding.go less more

46	46	// add to support url.Values
47	47	mapValues, ok := i.(url.Values)
48	48	if ok {
49		for k, _ := range mapValues {
	49	for k := range mapValues {
50	50	values.Set(k, mapValues.Get(k))
51	51	}
52	52	return

190	190	// add to support url.Values
191	191	mapValues, ok := i.(url.Values)
192	192	if ok {
193		for k, _ := range mapValues {
	193	for k := range mapValues {
194	194	values.Set(k, mapValues.Get(k))
195	195	}
196	196	return

+2

-2

util/encoding_test.go less more

64	64	StringArray: []string{"abc", "xyz"},
65	65	StringArray2: []string{"abc", "xyz"},
66	66	StructArray: []SubStruct{
67		SubStruct{A: "a", B: 1},
68		SubStruct{A: "x", B: 2},
	67	{A: "a", B: 1},
	68	{A: "x", B: 2},
69	69	},
70	70	SubStruct: SubStruct{A: "M", B: 0},
71	71	test: TestString("test"),

+38

-0

util/util.go less more

3	3	"bytes"
4	4	srand "crypto/rand"
5	5	"encoding/binary"
	6	"encoding/json"
	7	"fmt"
6	8	"math/rand"
7	9	"net/http"
8	10	"net/url"

57	59	if v != "" {
58	60	buf.WriteString("=")
59	61	buf.WriteString(url.QueryEscape(v))
	62	}
	63	}
	64	}
	65	return buf.String()
	66	}
	67
	68	// Like Encode, but key and value are not escaped
	69	func EncodeWithoutEscape(v url.Values) string {
	70	if v == nil {
	71	return ""
	72	}
	73	var buf bytes.Buffer
	74	keys := make([]string, 0, len(v))
	75	for k := range v {
	76	keys = append(keys, k)
	77	}
	78	sort.Strings(keys)
	79	for _, k := range keys {
	80	vs := v[k]
	81	prefix := k
	82	for _, v := range vs {
	83	if buf.Len() > 0 {
	84	buf.WriteByte('&')
	85	}
	86	buf.WriteString(prefix)
	87	if v != "" {
	88	buf.WriteString("=")
	89	buf.WriteString(v)
60	90	}
61	91	}
62	92	}

144	174	return string(s)
145	175
146	176	}
	177
	178	func PrettyJson(object interface{}) string {
	179	b, err := json.MarshalIndent(object, "", " ")
	180	if err != nil {
	181	fmt.Printf("ERROR: PrettyJson, %v\n %s\n", err, b)
	182	}
	183	return string(b)
	184	}