Releasing version v2.5.0 (#130)

Releasing version v2.5.0

Author: jasonyin

CHANGELOG.md

@@ -4,6 +4,14 @@ All notable changes to this project will be documented in this file.
 
 The format is based on [Keep a Changelog](http://keepachangelog.com/)
 
+## 2.5.0 - 2018-09-27
+### Added
+- Support for paravirtualized launch mode when importing images in the Compute service
+- Support for Key Management service
+- Support for encrypting the contents of an Object Storage bucket using a Key Management service key
+- Support for specifying a Key Management service key when launching a compute instance in the Compute service
+- Support for specifying a Key Management service key when backing up or restoring a block storage volume in the Block Volume service
+
 ## 2.4.0 - 2018-09-06
 ### Added
 - Added support for updating metadata fields on an instance in the Compute service

Makefile

@@ -1,6 +1,6 @@
 DOC_SERVER_URL=https:\/\/docs.us-phoenix-1.oraclecloud.com
 
-GEN_TARGETS = identity core objectstorage loadbalancer database audit dns filestorage email containerengine resourcesearch ##SPECNAME##
+GEN_TARGETS = identity core objectstorage loadbalancer database audit dns filestorage email containerengine resourcesearch keymanagement ##SPECNAME##
 NON_GEN_TARGETS = common common/auth
 TARGETS = $(NON_GEN_TARGETS) $(GEN_TARGETS)
 

common/client.go

@@ -197,10 +197,6 @@ func (client *BaseClient) prepareRequest(request *http.Request) (err error) {
 	request.Header.Set(requestHeaderUserAgent, client.UserAgent)
 	request.Header.Set(requestHeaderDate, time.Now().UTC().Format(http.TimeFormat))
 
-	if request.Header.Get(requestHeaderOpcRetryToken) == "" {
-		request.Header.Set(requestHeaderOpcRetryToken, generateRetryToken())
-	}
-
 	if !strings.Contains(client.Host, "http") &&
 		!strings.Contains(client.Host, "https") {
 		client.Host = fmt.Sprintf("%s://%s", defaultScheme, client.Host)

common/client_test.go

@@ -104,26 +104,6 @@ func TestClient_prepareRequestUpdatesDateHeader(t *testing.T) {
 	assert.NotEqual(t, d1, d2)
 }
 
-func TestClient_prepareRequestOnlySetsRetryTokenOnce(t *testing.T) {
-	host := "somehost:9000"
-	basePath := "basePath"
-	restPath := "somepath"
-
-	c := BaseClient{UserAgent: "asdf"}
-	c.Host = host
-	c.BasePath = basePath
-
-	request := http.Request{}
-	request.URL = &url.URL{Path: restPath}
-	c.prepareRequest(&request)
-	token1 := request.Header.Get(requestHeaderOpcRetryToken)
-	assert.NotEmpty(t, token1)
-	c.prepareRequest(&request)
-	token2 := request.Header.Get(requestHeaderOpcRetryToken)
-	assert.NotEmpty(t, token2)
-	assert.Equal(t, token1, token2)
-}
-
 func TestDefaultHTTPDispatcher_transportNotSet(t *testing.T) {
 	client := defaultHTTPDispatcher()
 
@@ -473,8 +453,8 @@ func TestRetry_GetsSuccessfulResponseAfterMultipleAttempts(t *testing.T) {
 }
 
 func TestRetryToken_GenerateMultipleTimes(t *testing.T) {
-	token1 := generateRetryToken()
-	token2 := generateRetryToken()
+	token1 := RetryToken()
+	token2 := RetryToken()
 	assert.NotEqual(t, token1, token2)
 }
 

common/common.go

@@ -3,6 +3,7 @@
 package common
 
 import (
+	"fmt"
 	"strings"
 )
 
@@ -41,3 +42,12 @@ func StringToRegion(stringRegion string) (r Region) {
 	}
 	return
 }
+
+// canStringBeRegion test if the string can be a region, if it can, returns the string as is, otherwise it
+// returns an error
+func canStringBeRegion(stringRegion string) (region string, err error) {
+	if strings.Contains(stringRegion, " ") || stringRegion == "" {
+		return "", fmt.Errorf("region can not be empty or have spaces")
+	}
+	return stringRegion, nil
+}

common/configuration.go

@@ -92,7 +92,7 @@ func (p rawConfigurationProvider) KeyFingerprint() (string, error) {
 }
 
 func (p rawConfigurationProvider) Region() (string, error) {
-	return p.region, nil
+	return canStringBeRegion(p.region)
 }
 
 // environmentConfigurationProvider reads configuration from environment variables
@@ -183,8 +183,10 @@ func (p environmentConfigurationProvider) Region() (value string, err error) {
 	var ok bool
 	if value, ok = os.LookupEnv(environmentVariable); !ok {
 		err = fmt.Errorf("can not read region from environment variable %s", environmentVariable)
+		return value, err
 	}
-	return
+
+	return canStringBeRegion(value)
 }
 
 // fileConfigurationProvider. reads configuration information from a file
@@ -436,7 +438,11 @@ func (p fileConfigurationProvider) Region() (value string, err error) {
 	}
 
 	value, err = presentOrError(info.Region, hasRegion, info.PresentConfiguration, "region")
-	return
+	if err != nil {
+		return
+	}
+
+	return canStringBeRegion(value)
 }
 
 // A configuration provider that look for information in  multiple configuration providers

common/configuration_test.go

@@ -112,6 +112,72 @@ func TestRawConfigurationProvider(t *testing.T) {
 
 }
 
+func TestRawConfigurationProvider_BadRegion(t *testing.T) {
+	var (
+		testTenancy     = "ocid1.tenancy.oc1..aaaaaaaaxf3fuazos"
+		testUser        = "ocid1.user.oc1..aaaaaaaa3p67n2kmpxnbcnff"
+		testRegion      = "us-ashburn-1  "
+		testFingerprint = "af:81:71:8e:d2"
+	)
+
+	c := NewRawConfigurationProvider(testTenancy, testUser, testRegion, testFingerprint, testPrivateKeyConf, nil)
+
+	user, err := c.UserOCID()
+	assert.NoError(t, err)
+	assert.Equal(t, user, testUser)
+
+	fingerprint, err := c.KeyFingerprint()
+	assert.NoError(t, err)
+	assert.Equal(t, fingerprint, testFingerprint)
+
+	_, err = c.Region()
+	assert.Error(t, err)
+
+	rsaKey, err := c.PrivateRSAKey()
+	assert.NoError(t, err)
+	assert.NotEmpty(t, rsaKey)
+
+	keyID, err := c.KeyID()
+	assert.NoError(t, err)
+	assert.NotEmpty(t, keyID)
+
+	assert.Equal(t, keyID, "ocid1.tenancy.oc1..aaaaaaaaxf3fuazos/ocid1.user.oc1..aaaaaaaa3p67n2kmpxnbcnff/af:81:71:8e:d2")
+
+}
+
+func TestEnvironmentConfigurationProvider(t *testing.T) {
+	envVars := []string{"region", "fingerprint", "user_ocid", "tenancy_ocid"}
+	keyFile := writeTempFile(testPrivateKeyConf)
+	defer removeFileFn(keyFile)
+
+	for _, v := range envVars {
+		os.Setenv(fmt.Sprintf("OCI_TEST_%s", v), "someval")
+	}
+	os.Setenv("OCI_TEST_private_key_path", keyFile)
+
+	conf := ConfigurationProviderEnvironmentVariables("OCI_TEST", "")
+	b, _ := IsConfigurationProviderValid(conf)
+	assert.True(t, b)
+}
+
+func TestEnvironmentConfigurationProvider_BadRegion(t *testing.T) {
+	envVars := []string{"fingerprint", "user_ocid", "tenancy_ocid"}
+	keyFile := writeTempFile(testPrivateKeyConf)
+	defer removeFileFn(keyFile)
+
+	for _, v := range envVars {
+		os.Setenv(fmt.Sprintf("OCI_TEST_%s", v), "someval")
+	}
+	os.Setenv("OCI_TEST_private_key_path", keyFile)
+	os.Setenv("OCI_TEST_region", "asdfas ")
+
+	conf := ConfigurationProviderEnvironmentVariables("OCI_TEST", "")
+	b, _ := IsConfigurationProviderValid(conf)
+	assert.False(t, b)
+	_, e := conf.Region()
+	assert.Error(t, e)
+}
+
 func TestFileConfigurationProvider_parseConfigFileData(t *testing.T) {
 	data := `[DEFAULT]
 user=someuser
@@ -160,6 +226,27 @@ region=someregion
 	}
 }
 
+func TestFileConfigurationProvider_FromFileBadRegion(t *testing.T) {
+	data := `[DEFAULT]
+user=someuser
+fingerprint=somefingerprint
+key_file=somelocation
+tenancy=sometenancy
+compartment = somecompartment
+region= asdf   asdf
+`
+	filename := writeTempFile(data)
+	defer removeFileFn(filename)
+
+	c := fileConfigurationProvider{ConfigPath: filename, Profile: "DEFAULT"}
+	fns := []func() (string, error){c.Region}
+
+	for _, fn := range fns {
+		_, e := fn()
+		assert.Error(t, e)
+	}
+}
+
 func TestFileConfigurationProvider_FromFileEmptyProfile(t *testing.T) {
 	expected := []string{ttenancy, tuser, tfingerprint, tkeyfile}
 	data := `
@@ -722,3 +809,32 @@ func TestExpandPath(t *testing.T) {
 		})
 	}
 }
+
+func TestIsRegionValid(t *testing.T) {
+	testIO := []struct {
+		name     string
+		input    string
+		expected bool
+	}{
+		{"valid", "aasb asdf", true},
+		{"valid", "aasb-asdf", false},
+		{"empty", "", true},
+		{"leading strings", "    aasb", true},
+		{"single leading string", " aasb", true},
+		{"single trailing string", "aasb ", true},
+		{"trailing string", "aasb      ", true},
+		{"single trailing and leading", " aasb ", true},
+		{"trailing and leading", " aasb   ", true},
+	}
+
+	for _, tIO := range testIO {
+		t.Run(tIO.name, func(t *testing.T) {
+			_, err := canStringBeRegion(tIO.input)
+			if tIO.expected {
+				assert.Error(t, err)
+			} else {
+				assert.NoError(t, err)
+			}
+		})
+	}
+}

common/helpers.go

@@ -149,6 +149,21 @@ func tryParsing(data []byte, layouts ...string) (tm time.Time, err error) {
 	return
 }
 
+// String returns string representation of SDKDate
+func (t *SDKDate) String() string {
+	return t.Date.Format(sdkDateFormat)
+}
+
+// NewSDKDateFromString parses the dateString into SDKDate
+func NewSDKDateFromString(dateString string) (*SDKDate, error) {
+	parsedTime, err := time.Parse(sdkDateFormat, dateString)
+	if err != nil {
+		return nil, err
+	}
+
+	return &SDKDate{Date: parsedTime}, nil
+}
+
 // UnmarshalJSON unmarshals from json
 func (t *SDKTime) UnmarshalJSON(data []byte) (e error) {
 	s := string(data)
@@ -222,3 +237,9 @@ func generateRandUUID() (string, error) {
 
 	return uuid, nil
 }
+
+func makeACopy(original []string) []string {
+	tmp := make([]string, len(original))
+	copy(tmp, original)
+	return tmp
+}

common/helpers_test.go

@@ -159,3 +159,22 @@ func TestFormattedTimeUnMarshaling(t *testing.T) {
 	}
 
 }
+
+func TestSDKDateToAndFromString(t *testing.T) {
+	_, err := NewSDKDateFromString("InvalidFormat")
+	s, _ := NewSDKDateFromString("2018-09-13")
+	str := fmt.Sprintf("%s", s)
+
+	assert.Equal(t, "2018-09-13", str)
+	assert.IsType(t, &time.ParseError{}, err)
+}
+
+func TestMakeACopy(t *testing.T) {
+	original := []string{"a", "b", "c"}
+
+	copy := makeACopy(original)
+
+	assert.Equal(t, original, copy)
+	copy[0] = "mutate"
+	assert.NotEqual(t, original, copy)
+}

common/http.go

@@ -433,7 +433,7 @@ func addToHeader(request *http.Request, value reflect.Value, field reflect.Struc
 		return
 	}
 
-	request.Header.Set(headerName, headerValue)
+	request.Header.Add(headerName, headerValue)
 	return
 }
 

common/http_signer.go

@@ -50,6 +50,16 @@ var (
 	}
 )
 
+// DefaultGenericHeaders list of default generic headers that is used in signing
+func DefaultGenericHeaders() []string {
+	return makeACopy(defaultGenericHeaders)
+}
+
+// DefaultBodyHeaders list of default body headers that is used in signing
+func DefaultBodyHeaders() []string {
+	return makeACopy(defaultBodyHeaders)
+}
+
 // DefaultRequestSigner creates a signer with default parameters.
 func DefaultRequestSigner(provider KeyProvider) HTTPRequestSigner {
 	return RequestSigner(provider, defaultGenericHeaders, defaultBodyHeaders)

common/http_signer_test.go

@@ -285,3 +285,17 @@ func TestOCIRequestSigner_SignEmptyBody(t *testing.T) {
 	assert.NotEmpty(t, r.Header.Get(requestHeaderAuthorization))
 	assert.NotEmpty(t, r.Header.Get(requestHeaderXContentSHA256))
 }
+
+func TestDefaultHeadersReturnsCopy(t *testing.T) {
+	genericHeaders := DefaultGenericHeaders()
+	bodyHeaders := DefaultBodyHeaders()
+
+	assert.Equal(t, defaultGenericHeaders, genericHeaders)
+	assert.Equal(t, defaultBodyHeaders, bodyHeaders)
+
+	genericHeaders[0] = "mutate"
+	bodyHeaders[0] = "mutate"
+
+	assert.NotEqual(t, defaultGenericHeaders, genericHeaders)
+	assert.NotEqual(t, defaultBodyHeaders, bodyHeaders)
+}

common/http_test.go

@@ -38,6 +38,8 @@ type updateUserRequest struct {
 	UserID                string `mandatory:"true" contributesTo:"path" name:"userId"`
 	TestupdateUserDetails `contributesTo:"body"`
 	IfMatch               string `mandatory:"false" contributesTo:"header" name:"if-match"`
+	HeaderValueOne        string `mandatory:"false" contributesTo:"header" name:"listInHeader"`
+	HeaderValueTwo        string `mandatory:"false" contributesTo:"header" name:"listInHeader"`
 }
 
 type TestcreateAPIKeyDetails struct {
@@ -101,11 +103,21 @@ func TestMakeDefault(t *testing.T) {
 }
 
 func TestHttpMarshallerSimpleHeader(t *testing.T) {
-	s := updateUserRequest{UserID: "id1", IfMatch: "n=as", TestupdateUserDetails: TestupdateUserDetails{Description: "name of"}}
+	s := updateUserRequest{
+		UserID:                "id1",
+		IfMatch:               "n=as",
+		TestupdateUserDetails: TestupdateUserDetails{Description: "name of"},
+		HeaderValueOne:        "1",
+		HeaderValueTwo:        "2",
+	}
 	request := MakeDefaultHTTPRequest(http.MethodPost, "/random")
 	HTTPRequestMarshaller(s, &request)
 	header := request.Header
 	assert.True(t, header.Get(requestHeaderIfMatch) == "n=as")
+	listInHeader := header["Listinheader"]
+	assert.True(t, len(listInHeader) == 2)
+	hone, htwo := listInHeader[0], listInHeader[1]
+	assert.True(t, hone == "1" && htwo == "2")
 }
 
 func TestHttpMarshallerSimpleStruct(t *testing.T) {