oracle / oci-go-sdk

Go SDK for Oracle Cloud Infrastructure

Oracle Cloud Infrastructure Golang SDK

This is the Go SDK for Oracle Cloud Infrastructure. This project is open source and maintained by Oracle Corp. The home page for the project is here.

Survey

Are you a Developer using the OCI SDK? If so, please fill out our survey to help us make the OCI SDK better for you. Click here for the survey page.

Dependencies

• Install Go programming language, Go1.17, 1.18, 1.19, 1.20, and 1.21 are supported By OCI Go SDK.
• Install GNU Make, using the package manager or binary distribution tool appropriate for your platform.

Versioning

• The breaking changes in service client APIs will no longer result in a major version bump (x+1.y.z relative to the last published version). Instead, we will bump the minor version of the SDK (x.y+1.z relative to the last published version).
• If there are no breaking changes in a release, we will bump the patch version of the SDK (x.y.z+1 relative to the last published version). We will continue to announce any breaking changes in a new version under the Breaking Changes section in the release changelog and on the Github release page [https://github.com/oracle/oci-go-sdk/releases].
• However, breaking changes in the SDK's common module will continue to result in a major version bump (x+1.y.z relative to the last published version). That said, we'll continue to maintain backward compatibility as much as possible to minimize the effort involved in upgrading the SDK version used by your code.

Installing

If you want to install the SDK under $GOPATH, you can use go get to retrieve the SDK:

go get -u github.com/oracle/oci-go-sdk

If you are using Go modules, you can install by running the following command within a folder containing a go.mod file:

go get -d github.com/oracle/oci-go-sdk/v49@latest

The latest major version (for example v49) can be identified on the Github releases page.

Alternatively, you can install a specific version (supported from v25.0.0 on):

go get -d github.com/oracle/oci-go-sdk/[email protected]

Run go mod tidy

In your project, you also need to ensure the import paths contain the correct major-version:

import "github.com/oracle/oci-go-sdk/v49/common"  // or whatever major version you're using

Working with the Go SDK

To start working with the Go SDK, you import the service package, create a client, and then use that client to make calls.

Configuring

Before using the SDK, set up a config file with the required credentials. See SDK and Tool Configuration for instructions.

Note that the Go SDK does not support profile inheritance or defining custom values in the configuration file.

Once a config file has been setup, call common.DefaultConfigProvider() function as follows:

// Import necessary packages
import (
   "github.com/oracle/oci-go-sdk/v49/common"
   "github.com/oracle/oci-go-sdk/v49/identity" // Identity or any other service you wish to make requests to
)

//...

configProvider := common.DefaultConfigProvider()

Or, to configure the SDK programmatically instead, implement the ConfigurationProvider interface shown below:

// ConfigurationProvider wraps information about the account owner
type ConfigurationProvider interface {
   KeyProvider
   TenancyOCID() (string, error)
   UserOCID() (string, error)
   KeyFingerprint() (string, error)
   Region() (string, error)
   // AuthType() is used for specify the needed auth type, like UserPrincipal, InstancePrincipal, etc. AuthConfig is used for getting auth related paras in config file.
   AuthType() (AuthConfig, error)
}

Or simply use one of structs exposed by the oci-go-sdk that already implement the above interface

Making a Request

To make a request to an Oracle Cloud Infrastructure service, create a client for the service and then use the client to call a function from the service.

• Creating a client: All packages provide a function to create clients, using the naming convention New<ServiceName>ClientWithConfigurationProvider, such as NewVirtualNetworkClientWithConfigurationProvider or NewIdentityClientWithConfigurationProvider. To create a new client, pass a struct that conforms to the ConfigurationProvider interface, or use the DefaultConfigProvider() function in the common package.

For example:

config := common.DefaultConfigProvider()
client, err := identity.NewIdentityClientWithConfigurationProvider(config)
if err != nil { 
     panic(err)
}

• Making calls: After successfully creating a client, requests can now be made to the service. Generally all functions associated with an operation accept context.Context and a struct that wraps all input parameters. The functions then return a response struct that contains the desired data, and an error struct that describes the error if an error occurs.

For example:

id := "your_group_id"
response, err := client.GetGroup(context.Background(), identity.GetGroupRequest{GroupId:&id})
if err != nil {
	//Something happened
	panic(err)
}
//Process the data in response struct
fmt.Println("Group's name is:", response.Name)

• Expect header: Some services specified "PUT/POST" requests add Expect 100-continue header by default, if it is not expected, please explicitly set the env var:

export OCI_GOSDK_USING_EXPECT_HEADER=FALSE

• Circuit Breaker: By default, circuit breaker feature is enabled, if it is not expected, please explicitly set the env var:

export OCI_SDK_DEFAULT_CIRCUITBREAKER_ENABLED=FALSE

• Cicuit Breaker: Circuit Breaker error message includes a set of previous failed responses. By default, the number of the failed responses is set to 5. It can be explicitly set using the env var:

export OCI_SDK_CIRCUITBREAKER_NUM_HISTORY_RESPONSE=<int value>

Organization of the SDK

The oci-go-sdk contains the following:

• Service packages: All packages except common and any other package found inside cmd. These packages represent the Oracle Cloud Infrastructure services supported by the Go SDK. Each package represents a service. These packages include methods to interact with the service, structs that model input and output parameters, and a client struct that acts as receiver for the above methods.

• Common package: Found in the common directory. The common package provides supporting functions and structs used by service packages. Includes HTTP request/response (de)serialization, request signing, JSON parsing, pointer to reference and other helper functions. Most of the functions in this package are meant to be used by the service packages.

• cmd: Internal tools used by the oci-go-sdk.

Examples

Examples can be found here

Documentation

Full documentation can be found on the godocs site.

Help

• The Issues page of this GitHub repository.
• Stack Overflow, use the oracle-cloud-infrastructure and oci-go-sdk tags in your post.
• Developer Tools of the Oracle Cloud forums.
• My Oracle Support.

Contributing

This project welcomes contributions from the community. Before submitting a pull request, please review our contribution guide

Security

Please consult the security guide for our responsible security vulnerability disclosure process

License

Copyright (c) 2016, 2023, Oracle and/or its affiliates. All rights reserved. This software is dual-licensed to you under the Universal Permissive License (UPL) 1.0 as shown at https://oss.oracle.com/licenses/upl or Apache License 2.0 as shown at http://www.apache.org/licenses/LICENSE-2.0. You may choose either license.

See LICENSE for more details.

Changes

See CHANGELOG.

Known Issues

You can find information on any known issues with the SDK here and under the Issues tab of this project's GitHub repository.

Building and Testing

Dev Dependencies

For Go versions below 1.17

• Install Testify with the command:

go get github.com/stretchr/testify

• Install gobreaker with the command:

go get github.com/sony/gobreaker

• Install flock with the command:

go get github.com/gofrs/flock

• Install go lint with the command:

go get -u golang.org/x/lint/golint

For Go versions 1.17 and above

• Install Testify with the command:

go install github.com/stretchr/testify

• Install gobreaker with the command:

go install github.com/sony/gobreaker

• Install flock with the command:

go install github.com/gofrs/flock

• Install go lint with the command:

go install github.com/golang/lint/golint

• Install staticcheck with the command:

go install honnef.co/go/tools/cmd/[email protected]

Linting and Staticcheck

Linting (performed by golint) can be done with the following command:

make lint

Linting will perform a number of formatting changes across the code base.

make static-check

This command is also run by the make build and make test commands. Staticcheck will provide formatting warnings but will not make any changes to any files. You can also cause staticcheck to be run before calls to "git commit" with the pre-commit plugin.

pre-commit install

You can install pre-commit itself, you can use your package manager of choice, such as

brew install pre-commit

Build

Building is provided by the make file at the root of the project. To build the project execute.

make build

To run the tests:

make test

oci-go-sdk's Issues

PutObject and GetObject should accept a Reader/Writer

Having to store the data you wish to upload/download in memory is undesirable and streaming is preferable.

Put Object might look like this

func (c *Client) PutObject(
	namespace Namespace,
	bucketName string,
	objectName string,
	content ReadCloser,
	opts *PutObjectOptions,
) (object *Object, e error) 

And GetObject like this

func (c *Client) GetObject(
	namespace Namespace,
	bucketName string,
	objectName string,
        output WriteCloser,
	opts *GetObjectOptions,
) (object *Object, e error) {

Default HTTP transport is wiped meaning proxy is not picked up from environment

We require a mechanism for setting a HTTP(s) proxy via environment variables. The SDK wipes the http transport to an empty struct which does not support setting http proxy via environment variables.

// Transport specifies the mechanism by which individual
// HTTP requests are made.
// If nil, DefaultTransport is used.
Transport RoundTripper

var DefaultTransport RoundTripper = &Transport{
  	Proxy: ProxyFromEnvironment,

Implement rawConfigurationProvider

We often need to instantiate a client from raw byte arrays (i.e pulling configuration from a custom structure rather than a static file).

This change would implement a rawConfigurationProvider that would allow a user to instantiate a client configuration from raw values.

Convert pointers to slices or maps to slices or maps

can't unmarshal response into core.VolumeAttachment

resp, err := c.coreClient.ListVolumeAttachments(ctx, core.ListVolumeAttachmentsRequest{
    CompartmentID: &compartmentID,
    InstanceID:    &instanceID,
})

is returning the following error:

json: cannot unmarshal object into Go value of type core.VolumeAttachment

My client is latest master.

optional enum in request got pass to server which result in 400 error

for the optional enum, go sdk will pass value = null to server which causing 400 error return from server. we need to remove optional enum from request

How to find Block Volume from SDK on host

If I have an iSCSI Block Volume attached to a host how can I find the proper Block Volume?

Infrastructure:

1. Create compute instance
2. Add block volume(BV) to it via iSCSI
3. Run Attach commands, etc.. to mount BV to the compute instance.

Find Block Volume on Host using SDK

1. Determine the host we're on by finding the hostname
2. ListInstances and filter by hostname, pull instanceId
3. ListVolumeAttachments for instanceId
4. Find Volume Id by ???

I have several pieces of information on the compute instance but nothing that maps me back to a Volume Id that I'm aware of outside of setting a FreeForm tag and searching for it.

Is there another way to retrieve the Block Volume Id when all you have is the information on the Compute instance?

Object Store Upload Part API Does not return etag.

I'm trying to do a multipart upload of a huge object to object store using the sdk.

The UploadPart in objectstoreage_client.go ignores the etag value that is returned. This value is needed later to commit the upload. With out the etag of the part it is not possible to use multipart upload feature and go-sdk.

Here is the Upload Method.

func (client ObjectStorageClient) UploadPart(ctx context.Context, request UploadPartRequest) (err error) {
	httpRequest, err := common.MakeDefaultHTTPRequestWithTaggedStruct(http.MethodPut, "/n/{namespaceName}/b/{bucketName}/u/{objectName}", request)
	if err != nil {
		return
	}
	_, err = client.Call(ctx, &httpRequest)
	return
}

Primitives should not be pointers

It'd be nice to remove the requirement on pointers for everything. It becomes very burdensome on consumers of the SDK when they're unable to easily create objects and are required to work around pointers. It also significantly decreases the readability code using the SDK.

For example lets take the following struct (some fields have been removed).

type CreateBackendDetails struct {

	// The IP address of the backend server.
	// Example: `10.10.10.4`
	IpAddress *string `mandatory:"true" json:"ipAddress,omitempty"`

	// The communication port for the backend server.
	// Example: `8080`
	Port *int `mandatory:"true" json:"port,omitempty"`
}

The idiomatic way to create an object for this struct would be

cbd := &CreateBackendDetails{
  IpAddress: "127.0.0.1",
  Port: 80,
}

However with how the structs are setup you're required to do this.

ip := "127.0.0.1"
port := 80
cbd := &CreateBackendDetails{
  IpAddress: &ip,
  Port: &port,
}

As you can imagine on larger structs that becomes a lot of unneeded boilerplate.

rawConfigurationProvider does not work with compositeConfigurationProvider

Noticed this issue when trying to use the rawConfigurationProvider with the compositeConfigurationProvider. The compositeConfigurationProvider checks if an error is returned from the delegate configuration provider. However, the rawConfigurationProvider does not return an error if the value is an empty string or nil. So, if the rawConfigurationProvider is used at the beginning of the slice, it's possible an empty value can be returned from any of the interface methods.

Either the compositeConfigurationProvider needs to also check if the value returned from the delegate is empty or nil or the rawConfigurationProvider needs to return an error if the value is empty or nil.

Object Store ListObjects nil for Size, MD5 and Created

go version go1.10.3 darwin/amd64
oci-go-sdk 2.2.0

Hello it seems as though these values don't come through using the oci-go-sdk vs. the oci command?

oci os object list -bn --namespace

Unit test in common should not assume default config

Some test in client_test.go use the NewClientForRegion function. Such function assumes a default config that may or may not be present.

Polymorphic JSON support made some objects extremely difficult to use

Example difference:

oci-go-sdk/core/attach_volume_details.go

Lines 16 to 25 in 8517d32

	type AttachVolumeDetails interface {
	// The OCID of the instance.
	GetInstanceID() *string
	// The OCID of the volume.
	GetVolumeID() *string
	// A user-friendly name. Does not have to be unique, and it cannot be changed. Avoid entering confidential information.
	GetDisplayName() *string

compared to

oci-go-sdk/core/create_volume_details.go

Lines 15 to 36 in 84049ed

	type CreateVolumeDetails struct {
	// The Availability Domain of the volume.
	// Example: `Uocm:PHX-AD-1`
	AvailabilityDomain *string `mandatory:"true" json:"availabilityDomain,omitempty"`
	// The OCID of the compartment that contains the volume.
	CompartmentID *string `mandatory:"true" json:"compartmentId,omitempty"`
	// A user-friendly name. Does not have to be unique, and it's changeable.
	// Avoid entering confidential information.
	DisplayName *string `mandatory:"false" json:"displayName,omitempty"`
	// The size of the volume in GBs.
	SizeInGBs *int `mandatory:"false" json:"sizeInGBs,omitempty"`
	// The size of the volume in MBs. The value must be a multiple of 1024.
	// This field is deprecated. Please use sizeInGBs.
	SizeInMBs *int `mandatory:"false" json:"sizeInMBs,omitempty"`
	// The OCID of the volume backup from which the data should be restored on the newly created volume.
	VolumeBackupID *string `mandatory:"false" json:"volumeBackupId,omitempty"`

The Interface approach makes this largely unusable w/o copy/paste of core private objects since you have to implement your own implementation to satisfy the interface. The only implementation of the interface in the project is not public.

VolumeAttachment is now an interface and became difficult to use as well since instead of providing direct access to fields you have to access them through methods like GetID() *string. You lose the ability to easily dereference fields since you can't do *attachment.GetID(). yes, I could write more helper methods but there are also better ways to do polymorphic things in Go like how proto3 does oneOf. More helper methods like common.PointerString(attachment.GetID()) will only continue to decrease the readability of the code using this client.

You also can't easily create a new VolumeAttachment programmatically since you need to implement the interface yourself. This overcomplicates testing with this client.

non-idiomatic go variables on structs that end with ID

One of the recent lint cleanup commits fixed a lot but also changed some idiomatic variables to non-idiomatic. All fields ending in ID got replaced with Id.

Provide more examples of how to use the SDK and its features.

It'd be nice if this SDK provided examples like the java sdk. Especially around the polymorphic types.

Support pagination

As far as I am aware the existing SDK does not support pagination (at the user request level) and only exposes it in responses.

Add support for local metadata

It'd be nice if we exposed a way to call the local metadata service since we use this across most of the go projects I'm aware of that use the go client.

https://docs.cloud.oracle.com/iaas/Content/Compute/Tasks/gettingmetadata.htm?tocpath=Services%7CCompute%7C_____17#AccessingInstanceMetadataonOracleProvidedImages

Add Travis or Wercker build file

Support for service principles as a mechanism for authentication

A project we work on requires support for service principles as a mechanism for authentication.

Is this something that will be added to the Go SDK in the near future?

Add support for Public IPs API

https://docs.us-phoenix-1.oraclecloud.com/api/#/en/iaas/20160918/PublicIp/

The client should support custom HTTP timeouts

Currently the http timeout is set to 30s which is very long for some clients to block. This should be configurable.

Issues with building Packer on the Windows platform due to number of files in oci-go-sdk/core package and limitation of golang's compile on windows

Our merge of the OCI Go SDK into Packer has broken builds under certain circumstances in Windows.

We should reduce the number of generated files in the core package to resolve.

See: hashicorp/packer#6220

Loadbalancer API is unusable.

The load balancer operations should all return the opc-work-request-id.
Currently they return nothing.

The response structures exists just they are not used.

func (client LoadBalancerClient) CreateLoadBalancer(ctx context.Context, request CreateLoadBalancerRequest, options ...common.RetryPolicyOption) (err error)

should be

func (client LoadBalancerClient) CreateLoadBalancer(ctx context.Context, request CreateLoadBalancerRequest, options ...common.RetryPolicyOption) (response CreateLoadBalancerResponse, err error)

Please add a way how to launch multiple instances at a time.

Hi,

Could you please add a way how to launch multiple instances at a time. The synopsis would be similar to the LaunchInstance() method, but it would take an additional parameter NumberOfInstances. E.g.:

func (o *OciCompute) LaunchInstances(numberOfInstances int, request LaunchInstanceRequest) ([]LaunchInstanceResponse, error)

The advantage can be in fact that spawning multiple uniform instances on the backend might be faster rather than calling multiple parallel single LaunchInstance() requests in multiple threads from the client. Also network traffic and number of requests issued on the backend is more effiecient (1 : N).

Thanks.

There have anyway I can batch create subnets ?

From doc I found CreateSubnet it's work, but if I want create per subnet for 3 AD , I need call API 3 times , there have any API I can batch create subnets ?

Host value should be read from request.Host instead of request.URL.Host

The request.URL.Host may not be populated in cases where the HTTP call looks something like this:

Request GET /api HTTP/1.1
Host: localhost:7000
Authorization: Signature version="1",headers="date (request-target) host"

I found this to be the case when using code like http.NewRequest("GET", "http://localhost:7000/api", nil) and passing the request to the signing logic in oci-go-sdk. I would get a signature value of date: Mon, 19 Feb 2018 20:20:07 CST\n(request-target): get /api\nhost:

Reference: https://stackoverflow.com/a/42926149/217965

Unable to unmarshall VolumeAttachment

It appears there might be a bug in the unmarshalling of VolumeAttachments.

Steps to reproduce

func main () {

       client,_ := core.NewComputeClientWithConfigurationProvider(config)

	var (
		compartment = "ocid1.com..."
		volume      = "ocid1.volume.oc1.phx.ab..."
	)

	request := core.ListVolumeAttachmentsRequest{
		CompartmentId: &compartment,
		VolumeId:      &volume,
	}

	response, _ := client.ListVolumeAttachments(context.Background(), request)
	for _, attachment := range response.Items {
		fmt.Printf("Item %v\n", attachment)
	}
}

Expected

VolumeAttachment unmarshalled

Actual

Request failed json: cannot unmarshal object into Go value of type core.VolumeAttachment

In the case of attaching an already attached volume, how do I get the http status code?

We have recently ungraded out oci-go-sdk version from 1.0.0 to 1.5.0 and in the process I've noticed that in the case where I'm trying to attach a volume twice, the error comes back, however, the response is nil. What is the recommended way of extracting the http status code in this case? Has the API changed when it comes to this?

newServiceFailureFromResponse does not use codes provided by server

I'm attempting to identify whether clients are encountering authentication errors. From the documentation provided inline and on the OCI website, it looks like I should be checking servicefailure.Code.

However, looking at how newServiceFailureFromResponse it appears that the servicefailure is never updated with the code provided by the API server.

func newServiceFailureFromResponse(response *http.Response) error {
	var err error

	se := servicefailure{
		StatusCode:   response.StatusCode,
		Code:         "BadErrorResponse",
		OpcRequestID: response.Header.Get("opc-request-id")}

	body, err := ioutil.ReadAll(response.Body)
	if err != nil {
		...
	}

	err = json.Unmarshal(body, &se)
	if err != nil {
		...
		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
}

This makes it impossible to detect the actual error, as the HTTP codes are insufficient.

Could you please let me know where I'm going wrong?

createKubeconfig function should not close http reponse body

Hi,

the defer common.CloseBodyIfValid(httpResponse) call in the containerengine.createKubeconfig function closes the http body which makes impossible to get the content of it.

// createKubeconfig implements the OCIOperation interface (enables retrying operations)
func (client ContainerEngineClient) createKubeconfig(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) {
httpRequest, err := request.HTTPRequest(http.MethodPost, "/clusters/{clusterId}/kubeconfig/content")
if err != nil {
return nil, err
}

var response CreateKubeconfigResponse
var httpResponse *http.Response
httpResponse, err = client.Call(ctx, &httpRequest)
defer common.CloseBodyIfValid(httpResponse)
response.RawResponse = httpResponse
if err != nil {
return response, err
}

err = common.UnmarshalResponse(httpResponse, &response)
return response, err
}

Thanks!

Dynamic group support

Need to support

retrieve/create/update/delete dynamic group

which was already supported in java-sdk

Implementation example of SourceDetails in LaunchInstanceDetails

refer to https://stackoverflow.com/questions/52011758/example-of-launchinstance-with-instancesourcedetails-interface

looking for an example of an implementation of an interface for SourceDetails in laynchInstanceDetails.

Go lint errors from generated code

There are a few places where generated code that is exposed to the user would break go lint tooling checks.

Example common.REGION_PHX

Clients should implement interfaces

Currently the various clients are all structs, which means they are not easily testable. This is going to require consumers of the SDK to implement their own interfaces on top of the SDK so that the clients can be mocked. This was a common pattern with consumers of the original SDK.

the signing algorithm does not lower case the header fields

https://tools.ietf.org/html/draft-cavage-http-signatures-10#section-2.3

Create the header field string by concatenating the lowercased header field name followed with an ASCII colon :, an ASCII space , and the header field value.

https://github.com/oracle/oci-go-sdk/blob/master/common/http_signer.go#L108-L130

This can causes signatures to fail verification between client and server. part in the code above should be passed through strings.ToLower

Add support for new path based routing for load balancers

https://docs.us-phoenix-1.oraclecloud.com/Content/Balance/Tasks/managingrequest.htm

Wercker check keeps failing

For the past 2 release the wercker check has failed to pull the github repo. Something presumably changed in the setup

OCI error is missing opc-request-id value

Responses from OCI include an ID that's extremely valuable when debugging failed requests, which is set on the response header opc-request-id. The error returned from the go sdk should include that which matches how other sdks, like the java one, exposes errors.

CreateClusterDetails Options is required

// Optional attributes for the cluster.
Options *ClusterCreateOptions mandatory:"false" json:"options"

mandatory is false, but when I use api get "Service error:InvalidParameter. options can't be empty"

Multipart Upload Issue(s)

go version 1.10.1
latest version of oci-go-sdk
Original File size: 368M
Split at 100MB then tried at 20MB
Original Error: net/http: request canceled (Client.Timeout exceeded while awaiting headers)
I modified the file: common.client and changed timeout from 30 to 60 seconds.
First error went away now I have a second error:

net/http: HTTP/1.x transport connection broken: http: ContentLength=104857600 with Body length 385447926

After Change to smaller split size:
net/http: HTTP/1.x transport connection broken: http: ContentLength=20971520 with Body length 385447926

Expose configuration options for instance principals

It is generally not possible to write external unit tests against the instance principal code in common/auth. The code has been hard coded to the opc metadata endpoint http://169.254.169.254 and there's public configuration exposed to override this endpoint for different URLs or mechanisms: https://godoc.org/github.com/oracle/oci-go-sdk/common/auth#InstancePrincipalConfigurationProvider

As an example, the unit tests for this package make use of private methods to use httptest.Server: https://github.com/oracle/oci-go-sdk/blob/master/common/auth/instance_principal_key_provider_test.go#L16-L26. Consumers of the package can not access these private methods, so we can not write isolated unit tests to verify our code. A simple approach to alleviate this is to implement a MockServer() that is configured with certificates. Developers can then populate those certs through their own mechanism and perform mock validation or real validation with the certificates.

Inconsistency with identifiers

The generated code results in a few inconsistencies that break Go code conventions. We use ID/Id and IP/Ip throughout the project mainly due to the Swagger generation I think. These should be consistent (eg. ID and IP).

Support custom loggers

Many projects using this SDK will have their own logger whether that's glog, logrus or whatever. Consumers should have the ability to use whatever logger they wish for client logs given it meets the required interface of the SDK.

Support for definedTags and freeFormTags

We require support for tagging volumes (and other resources).

Update generated code to support definedTags and freeFormTags where appropriate.

https://docs.us-phoenix-1.oraclecloud.com/api/#/en/iaas/20160918/requests/CreateVolumeDetails

https://docs.us-phoenix-1.oraclecloud.com/Content/General/Concepts/resourcetags.htm

Cross platform support for getHomeFolder()

Support for Windows would be broken by https://github.com/oracle/oci-go-sdk/blob/master/common/client.go#L105

Add support for tagging load balancers

https://docs.cloud.oracle.com/iaas/releasenotes/changes/9ced7d70-005a-4aa1-a47a-213dd8d2dcad/

Can't find GetObject in OCI go SDK Object Storage

Hi there:
I searched https://godoc.org/github.com/oracle/oci-go-sdk/objectstorage
I find PutObject to upload files but I don't find GetObject to download files
Am I missing sth? Also in the sdk examples, can you provide examples to download files?

Thanks
Henry

retry context should be cancelable during blocked sleep

In case of context cancel, the sleep operation here:

https://github.com/oracle/oci-go-sdk/blob/master/common/retry.go#L131

should instead use a select waiting on both time.After() and ctx.Done().

Some generated file names are incorrect

This isn't causing any problems / is low priority but i noticed some generated names are incorrect like core/update_i_p_sec_connection_request_response.go:i_p should be ip.

Composing configuration provider panics / isnt usable

it seems that if there is an incorrect config provider first it panics every time. If i put p2 first then it'll work. If p4 or p1 are first then it panics.

	p1, _ := common.ConfigurationProviderFromFile(os.Getenv("OCI_CONFIG_FILE"), "")
	p2, _ := common.ConfigurationProviderFromFile(path.Join(os.Getenv("HOME"), ".oci", "config"), "")
	p4 := common.ConfigurationProviderEnvironmentVariables("OCI", os.Getenv("OCI_PRIVATE_KEY_PASSWORD"))
	provider, err := common.ComposingConfigurationProvider([]common.ConfigurationProvider{
		p4, p1, p2,
	})

panic: runtime error: invalid memory address or nil pointer dereference
[signal SIGSEGV: segmentation violation code=0x1 addr=0x40 pc=0x1ed60b7]

goroutine 77 [running]:
path/vendor/github.com/oracle/oci-go-sdk/common.composingConfigurationProvider.TenancyOCID(0xc4202028a0, 0x3, 0x3, 0x0, 0xc420496700, 0xc420496700, 0x48028b0)
	/Users/horwitz/gocode/src/path/vendor/github.com/oracle/oci-go-sdk/common/configuration.go:431 +0x57
path/vendor/github.com/oracle/oci-go-sdk/common.(*composingConfigurationProvider).TenancyOCID(0xc42000c6e0, 0xc4205934d8, 0x1012867, 0x4863008, 0xc4204df4c0)
	<autogenerated>:1 +0x4e
path/vendor/github.com/oracle/oci-go-sdk/common.(ConfigurationProvider).TenancyOCID-fm(0xc42000c601, 0x100070120255810, 0x0, 0x1a)
	/Users/horwitz/gocode/src/path/vendor/github.com/oracle/oci-go-sdk/common/configuration.go:25 +0x2f
path/vendor/github.com/oracle/oci-go-sdk/common.IsConfigurationProviderValid(0x2eea360, 0xc42000c6e0, 0x1048bd8, 0xc4204df4d4, 0x23b1fc6)
	/Users/horwitz/gocode/src/path/vendor/github.com/oracle/oci-go-sdk/common/configuration.go:27 +0x1b7
path/vendor/github.com/oracle/oci-go-sdk/common.NewClientWithConfig(0x2eea360, 0xc42000c6e0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, ...)
	/Users/horwitz/gocode/src/path/vendor/github.com/oracle/oci-go-sdk/common/client.go:99 +0x7b
path/vendor/github.com/oracle/oci-go-sdk/core.NewComputeClientWithConfigurationProvider(0x2eea360, 0xc42000c6e0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, ...)
	/Users/horwitz/gocode/src/path/vendor/github.com/oracle/oci-go-sdk/core/core_compute_client.go:27 +0x9d