Releasing version 2 1 0

Releasing version 2 1 0

Author: jasonyin

CHANGELOG.md

@@ -4,6 +4,15 @@ All notable changes to this project will be documented in this file.
 
 The format is based on [Keep a Changelog](http://keepachangelog.com/)
 
+## 2.1.0 - 2018-07-26
+### Added
+- Support for the OCI Search service
+- Support for specifying a backup policy when creating a boot volume in the Block Storage service
+
+### Fixed
+- OCI error is missing opc-request-id value [Github Issue 120](https://github.com/oracle/oci-go-sdk/issues/120)
+- Include raw http response when service error occurred
+
 ## 2.0.0 - 2018-07-12
 ### Added
 - Support for tagging Load Balancers in the Load Balancing 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
+GEN_TARGETS = identity core objectstorage loadbalancer database audit dns filestorage email containerengine resourcesearch
 NON_GEN_TARGETS = common common/auth
 TARGETS = $(NON_GEN_TARGETS) $(GEN_TARGETS)
 

audit/audit_client.go

@@ -67,6 +67,9 @@ func (client AuditClient) GetConfiguration(ctx context.Context, request GetConfi
 	}
 	ociResponse, err = common.Retry(ctx, request, client.getConfiguration, policy)
 	if err != nil {
+		if ociResponse != nil {
+			response = GetConfigurationResponse{RawResponse: ociResponse.HTTPResponse()}
+		}
 		return
 	}
 	if convertedResponse, ok := ociResponse.(GetConfigurationResponse); ok {
@@ -106,6 +109,9 @@ func (client AuditClient) ListEvents(ctx context.Context, request ListEventsRequ
 	}
 	ociResponse, err = common.Retry(ctx, request, client.listEvents, policy)
 	if err != nil {
+		if ociResponse != nil {
+			response = ListEventsResponse{RawResponse: ociResponse.HTTPResponse()}
+		}
 		return
 	}
 	if convertedResponse, ok := ociResponse.(ListEventsResponse); ok {
@@ -145,6 +151,9 @@ func (client AuditClient) UpdateConfiguration(ctx context.Context, request Updat
 	}
 	ociResponse, err = common.Retry(ctx, request, client.updateConfiguration, policy)
 	if err != nil {
+		if ociResponse != nil {
+			response = UpdateConfigurationResponse{RawResponse: ociResponse.HTTPResponse()}
+		}
 		return
 	}
 	if convertedResponse, ok := ociResponse.(UpdateConfigurationResponse); ok {

common/errors.go

@@ -20,43 +20,46 @@ type ServiceError interface {
 	// A short error code that defines the error, meant for programmatic parsing.
 	// See https://docs.us-phoenix-1.oraclecloud.com/Content/API/References/apierrors.htm
 	GetCode() string
+
+	// Unique Oracle-assigned identifier for the request.
+	// If you need to contact Oracle about a particular request, please provide the request ID.
+	GetOpcRequestID() string
 }
 
 type servicefailure struct {
-	StatusCode int
-	Code       string `json:"code,omitempty"`
-	Message    string `json:"message,omitempty"`
+	StatusCode   int
+	Code         string `json:"code,omitempty"`
+	Message      string `json:"message,omitempty"`
+	OpcRequestID string `json:"opc-request-id"`
 }
 
 func newServiceFailureFromResponse(response *http.Response) error {
 	var err error
 
+	se := servicefailure{
+		StatusCode:   response.StatusCode,
+		Code:         "BadErrorResponse",
+		OpcRequestID: response.Header.Get("opc-request-id")}
+
 	//If there is an error consume the body, entirely
 	body, err := ioutil.ReadAll(response.Body)
 	if err != nil {
-		return servicefailure{
-			StatusCode: response.StatusCode,
-			Code:       "BadErrorResponse",
-			Message:    fmt.Sprintf("The body of the response was not readable, due to :%s", err.Error()),
-		}
+		se.Message = fmt.Sprintf("The body of the response was not readable, due to :%s", err.Error())
+		return se
 	}
 
-	se := servicefailure{StatusCode: response.StatusCode}
 	err = json.Unmarshal(body, &se)
 	if err != nil {
 		Debugf("Error response could not be parsed due to: %s", err.Error())
-		return servicefailure{
-			StatusCode: response.StatusCode,
-			Code:       "BadErrorResponse",
-			Message:    fmt.Sprintf("Error while parsing failure from response"),
-		}
+		se.Message = fmt.Sprintf("Failed to parse json from response body due to: %s. With response body %s.", err.Error(), string(body[:]))
+		return se
 	}
 	return se
 }
 
 func (se servicefailure) Error() string {
-	return fmt.Sprintf("Service error:%s. %s. http status code: %d",
-		se.Code, se.Message, se.StatusCode)
+	return fmt.Sprintf("Service error:%s. %s. http status code: %d. Opc request id: %s",
+		se.Code, se.Message, se.StatusCode, se.OpcRequestID)
 }
 
 func (se servicefailure) GetHTTPStatusCode() int {
@@ -72,6 +75,10 @@ func (se servicefailure) GetCode() string {
 	return se.Code
 }
 
+func (se servicefailure) GetOpcRequestID() string {
+	return se.OpcRequestID
+}
+
 // IsServiceError returns false if the error is not service side, otherwise true
 // additionally it returns an interface representing the ServiceError
 func IsServiceError(err error) (failure ServiceError, ok bool) {

common/errors_test.go

@@ -0,0 +1,47 @@
+// Copyright (c) 2016, 2018, Oracle and/or its affiliates. All rights reserved.
+
+package common
+
+import (
+	"bytes"
+	"io/ioutil"
+	"net/http"
+	"strings"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestErrors_ServiceFailureFromResponse(t *testing.T) {
+	header := http.Header{}
+	opcID := "111"
+	header.Set("opc-request-id", opcID)
+	sampleResponse := `{"key" : "test"}`
+
+	httpResponse := http.Response{Header: header}
+	bodyBuffer := bytes.NewBufferString(sampleResponse)
+	httpResponse.Body = ioutil.NopCloser(bodyBuffer)
+	httpResponse.StatusCode = 200
+	err := newServiceFailureFromResponse(&httpResponse)
+	assert.Equal(t, err.(ServiceError).GetOpcRequestID(), opcID)
+	assert.Equal(t, strings.Contains(err.Error(), "Service error:"), true)
+
+	failure, ok := IsServiceError(err)
+	assert.Equal(t, ok, true)
+	assert.Equal(t, failure.GetHTTPStatusCode(), httpResponse.StatusCode)
+}
+
+func TestErrors_FailedToParseJson(t *testing.T) {
+	// invalid json
+	sampleResponse := `{"key" : test"}`
+
+	httpResponse := http.Response{}
+	bodyBuffer := bytes.NewBufferString(sampleResponse)
+	httpResponse.Body = ioutil.NopCloser(bodyBuffer)
+	err := newServiceFailureFromResponse(&httpResponse)
+
+	failure, ok := IsServiceError(err)
+	assert.Equal(t, ok, true)
+	assert.Equal(t, failure.GetCode(), "BadErrorResponse")
+	assert.Equal(t, strings.Contains(failure.GetMessage(), "Failed to parse json from response body due to"), true)
+}

common/http.go

@@ -180,7 +180,14 @@ func omitNilFieldsInJSON(data interface{}, value reflect.Value) (interface{}, er
 		}
 		return jsonMap, nil
 	case reflect.Slice, reflect.Array:
-		jsonList := data.([]interface{})
+		// Special case: a []byte may have been marshalled as a string
+		if reflect.TypeOf(data).Kind() == reflect.String && value.Type().Elem().Kind() == reflect.Uint8 {
+			return data, nil
+		}
+		jsonList, ok := data.([]interface{})
+		if !ok {
+			return nil, fmt.Errorf("can not omit nil fields, data was expected to be a list")
+		}
 		newList := make([]interface{}, len(jsonList))
 		var err error
 		for i, val := range jsonList {
@@ -191,7 +198,10 @@ func omitNilFieldsInJSON(data interface{}, value reflect.Value) (interface{}, er
 		}
 		return newList, nil
 	case reflect.Map:
-		jsonMap := data.(map[string]interface{})
+		jsonMap, ok := data.(map[string]interface{})
+		if !ok {
+			return nil, fmt.Errorf("can not omit nil fields, data was expected to be a map")
+		}
 		newMap := make(map[string]interface{}, len(jsonMap))
 		var err error
 		for key, val := range jsonMap {

common/http_test.go

@@ -61,6 +61,19 @@ type uploadAPIKeyRequestPtr struct {
 	OpcRetryToken              *string `mandatory:"false" contributesTo:"header" name:"opc-retry-token"`
 }
 
+type EmbeddedByteSlice struct {
+	Key   *[]byte `mandatory:"false" json:"key"`
+	Value []byte  `mandatory:"true" json:"value"`
+}
+
+type KVList struct {
+	KVs []EmbeddedByteSlice `mandatory:"true" json:"kvs"`
+}
+
+type KVRequest struct {
+	KVList `contributesTo:"body"`
+}
+
 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
 func TestHttpMarshallerInvalidStruct(t *testing.T) {
@@ -359,6 +372,22 @@ func TestHttpMarshalerUnsupportedTypes(t *testing.T) {
 	}
 }
 
+func TestHttpMarshallerEmbeddedBytes(t *testing.T) {
+	s := KVRequest{
+		KVList{
+			KVs: []EmbeddedByteSlice{
+				{Value: []byte{1, 2, 3, 4}},
+				{Key: &[]byte{6, 7, 8, 9}, Value: []byte{1, 2, 3, 4}},
+				{Value: []byte{}},
+			},
+		}}
+	request := MakeDefaultHTTPRequest(http.MethodPost, "/random")
+	HTTPRequestMarshaller(s, &request)
+	b, _ := ioutil.ReadAll(request.Body)
+	st := string(b)
+	assert.Equal(t, `{"kvs":[{"value":"AQIDBA=="},{"key":"BgcICQ==","value":"AQIDBA=="},{"value":""}]}`, st)
+}
+
 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 //Response Unmarshaling