Release v1.1.0 (#102)

Author: eginez

.gitignore

@@ -8,4 +8,5 @@
 .idea/
 *.swp
 .vscode/*
-
+target/
+bin/

CHANGELOG.md

@@ -5,6 +5,17 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](http://keepachangelog.com/)
 
 
+## 1.1.0 - 2018-03-27
+### Added
+- Support for DNS service
+- Support for File Storage service
+- Support for PathRouteSets and Listeners in Load Balancing service
+- Support for Public IPs in Core Services
+- Support for Dynamic Groups in Identity service
+- Support for tagging in Core Services and Identity service. Example can be found on [Github](https://github.com/oracle/oci-go-sdk/tree/master/example/example_tagging_test.go)
+- Fix ComposingConfigurationProvider to not accept a nil ConfigurationProvider
+- Support for passphrase configuration to FileConfiguration provider
+
 ## 1.0.0 - 2018-02-28 Initial Release
 ### Added
 - Support for Audit service

Makefile

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

common/auth/certificate_retriever.go

@@ -82,6 +82,10 @@ func (r *urlBasedX509CertificateRetriever) renewCertificate(url string) (certifi
 	certificatePemRaw = body.Bytes()
 	var block *pem.Block
 	block, _ = pem.Decode(certificatePemRaw)
+	if block == nil {
+		return nil, nil, fmt.Errorf("failed to parse the new certificate, not valid pem data")
+	}
+
 	if certificate, err = x509.ParseCertificate(block.Bytes); err != nil {
 		return nil, nil, fmt.Errorf("failed to parse the new certificate: %s", err.Error())
 	}

common/auth/certificate_retriever_test.go

@@ -17,6 +17,19 @@ import (
 	"time"
 )
 
+func TestUrlBasedX509CertificateRetriever_BadCertificate(t *testing.T) {
+	expectedCert := make([]byte, 100)
+	rand.Read(expectedCert)
+	certServer := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		fmt.Fprint(w, string(expectedCert))
+	}))
+	defer certServer.Close()
+
+	retriever := newURLBasedX509CertificateRetriever(certServer.URL, "", "")
+	err := retriever.Refresh()
+
+	assert.Error(t, err)
+}
 func TestUrlBasedX509CertificateRetriever_RefreshWithoutPrivateKeyUrl(t *testing.T) {
 	_, expectedCert := generateRandomCertificate()
 	certServer := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {

common/common.go

@@ -18,6 +18,8 @@ const (
 	RegionIAD Region = "us-ashburn-1"
 	//RegionFRA region FRA
 	RegionFRA Region = "eu-frankfurt-1"
+	//RegionLHR region LHR
+	RegionLHR Region = "uk-london-1"
 )
 
 //StringToRegion convert a string to Region type
@@ -31,6 +33,8 @@ func StringToRegion(stringRegion string) (r Region) {
 		r = RegionIAD
 	case "fra", "eu-frankfurt-1":
 		r = RegionFRA
+	case "lhr", "uk-london-1":
+		r = RegionLHR
 	default:
 		r = Region(stringRegion)
 		Debugf("region named: %s, is not recognized", stringRegion)

common/configuration.go

@@ -95,7 +95,7 @@ func (p rawConfigurationProvider) Region() (string, error) {
 }
 
 // environmentConfigurationProvider reads configuration from environment variables
-type environmentConfigurationProvider struct { // TODO: Support Instance Principal
+type environmentConfigurationProvider struct {
 	PrivateKeyPassword        string
 	EnvironmentVariablePrefix string
 }
@@ -186,7 +186,7 @@ func (p environmentConfigurationProvider) Region() (value string, err error) {
 }
 
 // fileConfigurationProvider. reads configuration information from a file
-type fileConfigurationProvider struct { // TODO: Support Instance Principal
+type fileConfigurationProvider struct {
 	//The path to the configuration file
 	ConfigPath string
 
@@ -227,8 +227,8 @@ func ConfigurationProviderFromFileWithProfile(configFilePath, profile, privateKe
 }
 
 type configFileInfo struct {
-	UserOcid, Fingerprint, KeyFilePath, TenancyOcid, Region string
-	PresentConfiguration                                    byte
+	UserOcid, Fingerprint, KeyFilePath, TenancyOcid, Region, Passphrase string
+	PresentConfiguration                                                byte
 }
 
 const (
@@ -237,6 +237,7 @@ const (
 	hasFingerprint
 	hasRegion
 	hasKeyFile
+	hasPassphrase
 	none
 )
 
@@ -277,6 +278,9 @@ func parseConfigAtLine(start int, content []string) (info *configFileInfo, err e
 
 		splits := strings.Split(line, "=")
 		switch key, value := strings.TrimSpace(splits[0]), strings.TrimSpace(splits[1]); strings.ToLower(key) {
+		case "passphrase":
+			configurationPresent = configurationPresent | hasPassphrase
+			info.Passphrase = value
 		case "user":
 			configurationPresent = configurationPresent | hasUser
 			info.UserOcid = value
@@ -397,7 +401,13 @@ func (p fileConfigurationProvider) PrivateRSAKey() (key *rsa.PrivateKey, err err
 		return
 	}
 
-	key, err = PrivateKeyFromBytes(pemFileContent, &p.PrivateKeyPassword)
+	password := p.PrivateKeyPassword
+
+	if password == "" && ((info.PresentConfiguration & hasPassphrase) == hasPassphrase) {
+		password = info.Passphrase
+	}
+
+	key, err = PrivateKeyFromBytes(pemFileContent, &password)
 	return
 }
 
@@ -424,6 +434,12 @@ func ComposingConfigurationProvider(providers []ConfigurationProvider) (Configur
 	if len(providers) == 0 {
 		return nil, fmt.Errorf("providers can not be an empty slice")
 	}
+
+	for i, p := range providers {
+		if p == nil {
+			return nil, fmt.Errorf("provider in position: %d is nil. ComposingConfiurationProvider does not support nil values", i)
+		}
+	}
 	return composingConfigurationProvider{Providers: providers}, nil
 }
 

common/configuration_test.go

@@ -32,6 +32,37 @@ gIT7aFOYBFwGgQAQkWNKLvySgKbAZRTeLBacpHMuQdl1DfdntvAyqpAZ0lY0RKmW
 G6aFKaqQfOXKCyWoUiVknQJAXrlgySFci/2ueKlIE1QqIiLSZ8V8OlpFLRnb1pzI
 7U1yQXnTAEFYM560yJlzUpOb1V4cScGd365tiSMvxLOvTA==
 -----END RSA PRIVATE KEY-----`
+	testEncryptedPrivateKeyConf = `-----BEGIN RSA PRIVATE KEY-----
+Proc-Type: 4,ENCRYPTED
+DEK-Info: DES-EDE3-CBC,05B7ACED45203763
+
+bKbv8X2oyfxwp55w3MVKj1bfWnhvQgyqJ/1dER53STao3qRS26epRoBc0BoLtrNj
+L+Wfa3NeuEinetDYKRwWGHZqvbs/3PD5OKIXW1y/EAlg1vr6JWX8KxhQ0PzGJOdQ
+KPcB2duDtlNJ4awoGEsSp/qYyJLKOKpcz893OWTe3Oi9aQpzuL+kgH6VboCUdwdl
+Ub7YyTMFBkGzzjOXV/iSJDaxvVUIZt7CQS/DkBq4IHXX8iFUDzh6L297/BuRp3Q8
+hDL4yQacl2F2yCWpUoNNkbPpe6oOmL8JHrxXxo+u0pSJELXx0sjWMn7bSRfgFFIE
+k08y4wXZeoxHiQDhHmQI+YTikgqnxEWtDYhHYvWudVQY6Wcf1Fdypa1v4I3gv4S9
+QwjDRbRcrnPxMkxWmQEM6xGCwWBj8wmFyIQoEA5MJuQZxWdyptEKVtwwI1TB9etn
+SlXPUl125dYYBu2ynmR96nBVEZd6BWl+iFeeZnqxDHABOB0AvpI61vt/6c7tIimC
+YciZs74XZH/ERs55p0Ng/G23XNu+UGQQptrr2kyRR5JrS0UGKVjivydIK5Lus4c4
+NTaKyEJNMbvSUGY5SLfxyp6HZnlbr4aCDAk62+2ZUotr+sVXplCpuxoSc2Qlw0en
+y+plCvd2RdQ/EzIFkpi9V/snIvbMvH3Sp/HqFDG8GehFTRvwpCIVqWC+BZYeaERX
+n2P4jODz2M8Ns7txv1nB4CyxWgu19398Zit0K0QmG24kCJtLg9spEOmKtoIuVTnU
+9ydxmHQjNNtyH+RceZFn07IkWvPveo2BXpK4K9DXE39Z/g1nQzwTqgN8diXxwRuN
+Ge97lBWup4vP1TV8nyHW2AppgFVuPynO+XWfZUuCUzxNseB+XOyeqitoM4uvSNax
+DQmokjIf4qXC/46EnJ/fd9Ydz4GVQ4TYyxwNCBJK39RdUOcUtyI+A3IbZ+vt2HIV
+eiIN2BhdnwbvNTbPs9nc9McM2NtACqDGQsIzRdXcQ8SFDP2DnTVjGu5E8H9dnVrd
+FcuUnA9TIbfBkRHOS7yoDHOo4j28g6xePDV5tK0L5C2yyDh+bwWnO5AIg/gdpnuH
+wxIZUxFwkD4GvOVtj5Y4W5L+Uy3c94stMPbHE+zGN75DdQRy5aVbDjWqXRB9AEQN
++NSb526oqhv0JyYlZmCqz2ydBxkT4FsShZv/34pkRr3qL5FSTAQTXQAZdiQQbMTe
+H3zKyu4GbEUV9WsyriqSq27ptMwFfIqN1NdsWeVWN1mXf2KZDn61EgleeQXmdSZu
+XM4Z1n98xjYDwdCkF738j+oRAlSUThBeU/hYbH6Ysff6ON9MPBAAKy3ZxM5tF86e
+l0x20lpND2QLLDZbsg/LrCrE6ZzpWkXn4w4PG4lWMAqph0BebSkFqXvUvuds3c39
+yptNH3FsyqeyM9kDwbDpBQAvpsDIQJfwAbQPLAiQJhpbixZyG9lqhkKOhYTZhU3l
+ufFtnLEj/5G9a8A//MFrXsXePUeBDEzjtEcjPGNxe0ZkuOgYx11Zc0R4oLI7LoHO
+07vtw4qCH4hztCJ5+JOUac6sGcILFRc4vSQQ15Cg5QEdBiSbQ/yo1P0hbNtSvnwO
+-----END RSA PRIVATE KEY-----`
+	testKeyPassphrase = "goisfun"
 )
 
 func removeFileFn(filename string) func() {
@@ -443,3 +474,180 @@ func TestComposingConfigurationProvider_MultipleFilesNoConf(t *testing.T) {
 		assert.Error(t, e)
 	}
 }
+
+func TestComposingConfigurationProvider_FirstConfigWrong(t *testing.T) {
+	dataTpl0 := ``
+	dataTpl := `[DEFAULT]
+user=someuser
+fingerprint=somefingerprint
+key_file=%s
+tenancy=sometenancy
+compartment = somecompartment
+region=someregion
+`
+
+	keyFile := writeTempFile(testPrivateKeyConf)
+	data := fmt.Sprintf(dataTpl, keyFile)
+	tmpConfFile0 := writeTempFile(dataTpl0)
+	tmpConfFile := writeTempFile(data)
+
+	defer removeFileFn(tmpConfFile)
+	defer removeFileFn(tmpConfFile0)
+	defer removeFileFn(keyFile)
+
+	c0, _ := ConfigurationProviderFromFile(tmpConfFile0, "")
+	c1, _ := ConfigurationProviderFromFile("/dev/nowhere", "")
+	p0 := ConfigurationProviderEnvironmentVariables("OCI", os.Getenv("BLAH"))
+	c, _ := ConfigurationProviderFromFile(tmpConfFile, "")
+
+	provider, ec := ComposingConfigurationProvider([]ConfigurationProvider{p0, c0, c1, c})
+	assert.NoError(t, ec)
+	ok, err := IsConfigurationProviderValid(provider)
+	assert.NoError(t, err)
+	assert.True(t, ok)
+
+	fns := []func() (string, error){provider.TenancyOCID, provider.UserOCID, provider.KeyFingerprint}
+
+	for _, fn := range fns {
+		val, e := fn()
+		assert.NoError(t, e)
+		assert.NotEmpty(t, val)
+	}
+	key, _ := provider.PrivateRSAKey()
+	assert.NotNil(t, key)
+}
+
+func TestComposingConfigurationProvider_NilConfiguration(t *testing.T) {
+	dataTpl := `[DEFAULT]
+user=someuser
+fingerprint=somefingerprint
+key_file=%s
+tenancy=sometenancy
+compartment = somecompartment
+region=someregion
+`
+
+	keyFile := writeTempFile(testPrivateKeyConf)
+	data := fmt.Sprintf(dataTpl, keyFile)
+	tmpConfFile := writeTempFile(data)
+
+	defer removeFileFn(tmpConfFile)
+	defer removeFileFn(keyFile)
+
+	c1, _ := ConfigurationProviderFromFile("/dev/nowhere", "")
+	p0 := ConfigurationProviderEnvironmentVariables("OCI", os.Getenv("BLAH"))
+	c, _ := ConfigurationProviderFromFile(tmpConfFile, "")
+
+	_, ec := ComposingConfigurationProvider([]ConfigurationProvider{p0, nil, c1, c})
+	assert.Error(t, ec)
+}
+
+func TestComposingConfigurationProvider_WithEncryptedKeyPassphraseInConfig(t *testing.T) {
+	dataTpl := `[DEFAULT]
+user=someuser
+fingerprint=somefingerprint
+key_file=%s
+tenancy=sometenancy
+compartment = somecompartment
+region=someregion
+passphrase=%s
+`
+
+	keyFile := writeTempFile(testEncryptedPrivateKeyConf)
+	data := fmt.Sprintf(dataTpl, keyFile, testKeyPassphrase)
+	tmpConfFile := writeTempFile(data)
+
+	defer removeFileFn(tmpConfFile)
+	defer removeFileFn(keyFile)
+
+	provider, err := ConfigurationProviderFromFile(tmpConfFile, "")
+	assert.NoError(t, err)
+	ok, err := IsConfigurationProviderValid(provider)
+	assert.NoError(t, err)
+	assert.True(t, ok)
+
+	fns := []func() (string, error){provider.TenancyOCID, provider.UserOCID, provider.KeyFingerprint}
+
+	for _, fn := range fns {
+		val, e := fn()
+		assert.NoError(t, e)
+		assert.NotEmpty(t, val)
+	}
+
+	key, err := provider.PrivateRSAKey()
+	assert.NoError(t, err)
+	assert.NotNil(t, key)
+}
+
+func TestComposingConfigurationProvider_WithEncryptedKeyOverridePassphrase(t *testing.T) {
+	dataTpl := `[DEFAULT]
+user=someuser
+fingerprint=somefingerprint
+key_file=%s
+tenancy=sometenancy
+compartment = somecompartment
+region=someregion
+passphrase=%s
+`
+
+	keyFile := writeTempFile(testEncryptedPrivateKeyConf)
+	data := fmt.Sprintf(dataTpl, keyFile, "thewrongpassphrase")
+	tmpConfFile := writeTempFile(data)
+
+	defer removeFileFn(tmpConfFile)
+	defer removeFileFn(keyFile)
+
+	provider, err := ConfigurationProviderFromFile(tmpConfFile, testKeyPassphrase)
+	assert.NoError(t, err)
+	ok, err := IsConfigurationProviderValid(provider)
+	assert.NoError(t, err)
+	assert.True(t, ok)
+
+	fns := []func() (string, error){provider.TenancyOCID, provider.UserOCID, provider.KeyFingerprint}
+
+	for _, fn := range fns {
+		val, e := fn()
+		assert.NoError(t, e)
+		assert.NotEmpty(t, val)
+	}
+
+	key, err := provider.PrivateRSAKey()
+	assert.NoError(t, err)
+	assert.NotNil(t, key)
+}
+
+func TestComposingConfigurationProvider_WithEncryptedKeyNoConfig(t *testing.T) {
+	dataTpl := `[DEFAULT]
+user=someuser
+fingerprint=somefingerprint
+key_file=%s
+tenancy=sometenancy
+compartment = somecompartment
+region=someregion
+`
+
+	keyFile := writeTempFile(testEncryptedPrivateKeyConf)
+	data := fmt.Sprintf(dataTpl, keyFile)
+	tmpConfFile := writeTempFile(data)
+
+	defer removeFileFn(tmpConfFile)
+	defer removeFileFn(keyFile)
+
+	provider, err := ConfigurationProviderFromFile(tmpConfFile, testKeyPassphrase)
+	assert.NoError(t, err)
+	ok, err := IsConfigurationProviderValid(provider)
+	assert.NoError(t, err)
+	assert.True(t, ok)
+
+	fns := []func() (string, error){provider.TenancyOCID, provider.UserOCID, provider.KeyFingerprint}
+
+	for _, fn := range fns {
+		val, e := fn()
+		assert.NoError(t, e)
+		assert.NotEmpty(t, val)
+	}
+
+	key, err := provider.PrivateRSAKey()
+	assert.NoError(t, err)
+	assert.NotNil(t, key)
+}

common/http.go

@@ -301,6 +301,11 @@ func addToPath(request *http.Request, value reflect.Value, field reflect.StructF
 		return fmt.Errorf("can not marshal to path in request for field %s. Due to %s", field.Name, e.Error())
 	}
 
+	// path should not be empty for any operations
+	if len(additionalURLPathPart) == 0 {
+		return fmt.Errorf("value cannot be empty for field %s in path", field.Name)
+	}
+
 	if request.URL == nil {
 		request.URL = &url.URL{}
 		request.URL.Path = ""