iSharkFly-Docs
/
packer-cn
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge remote-tracking branch 'origin/master' into azr_selectable_temp_keygen_type_gcp

This commit is contained in:
Adrien Delorme 2020-10-20 16:39:01 +02:00
parent 536421efaf 6d4fae0f2d
commit f51b231c17
606 changed files with 33527 additions and 19394 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

9
CHANGELOG.md
View File

@ -18,12 +18,21 @@
### IMPROVEMENTS:
* builder/amazon: Add `io2` as a supported volume type. [GH-10102]
* builder/amazon: Add support for source instance tenancy [GH-10085]
* builder/google: Add service account impersonation. [GH-9968] [GH-10054]
* builder/googlecompute: Add `skip_create_image` option. [GH-10115]
* builder/oracle-oci: New option to specify image compartment separate from
build compartment. [GH-10040]
* builder/oracle-oci: New option to specify boot volume size. [GH-10017]
* builder/outscale: Migrate to new Outscale SDK. [GH-10056]
* builder/scaleway: Allow the user to use an image label (eg ubuntu_focal)
instead of a hardcoded UUID on the Scaleway builder. [GH-10061]
* hcl: Add build.name variable so users can access build name in addition to
source name. [GH-10114]
* hcl: Add consul_key function to HCL templates. [GH-10119]
* hcl: Add packer.version variable to hcl configs so users can access the
Packer release version. [GH-10117]
## 1.6.4 (September 30, 2020)

4
builder/amazon/common/block_device.go
View File

@ -134,8 +134,8 @@ func (blockDevice BlockDevice) BuildEC2BlockDeviceMapping() *ec2.BlockDeviceMapp
ebsBlockDevice.VolumeSize = aws.Int64(blockDevice.VolumeSize)
}
// IOPS is only valid for io1 type
if blockDevice.VolumeType == "io1" {
// IOPS is only valid for io1 and io2 types
if blockDevice.VolumeType == "io1" || blockDevice.VolumeType == "io2" {
ebsBlockDevice.Iops = aws.Int64(blockDevice.IOPS)
}

19
builder/amazon/common/block_device_test.go
View File

@ -66,6 +66,25 @@ func TestBlockDevice(t *testing.T) {
},
},
},
{
Config: &BlockDevice{
DeviceName: "/dev/sdb",
VolumeType: "io2",
VolumeSize: 8,
DeleteOnTermination: true,
IOPS: 1000,
},
Result: &ec2.BlockDeviceMapping{
DeviceName: aws.String("/dev/sdb"),
Ebs: &ec2.EbsBlockDevice{
VolumeType: aws.String("io2"),
VolumeSize: aws.Int64(8),
DeleteOnTermination: aws.Bool(true),
Iops: aws.Int64(1000),
},
},
},
{
Config: &BlockDevice{
DeviceName: "/dev/sdb",

13
builder/amazon/common/run_config.go
View File

@ -376,6 +376,12 @@ type RunConfig struct {
// subnet-12345def, where Packer will launch the EC2 instance. This field is
// required if you are using an non-default VPC.
SubnetId string `mapstructure:"subnet_id" required:"false"`
// [Tenancy](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/dedicated-instance.html) used
// when Packer launches the EC2 instance, allowing it to be launched on dedicated hardware.
//
// The default is "default", meaning shared tenancy. Allowed values are "default",
// "dedicated" and "host".
Tenancy string `mapstructure:"tenancy" required:"false"`
// The name of the temporary key pair to
// generate. By default, Packer generates a name that looks like
// `packer_<UUID>`, where &lt;UUID&gt; is a 36 character unique identifier.
@ -631,6 +637,13 @@ func (c *RunConfig) Prepare(ctx *interpolate.Context) []error {
}
}
if c.Tenancy != "" &&
c.Tenancy != "default" &&
c.Tenancy != "dedicated" &&
c.Tenancy != "host" {
errs = append(errs, fmt.Errorf("Error: Unknown tenancy type %s", c.Tenancy))
}
return errs
}

20
builder/amazon/common/run_config_test.go
View File

@ -232,3 +232,23 @@ func TestRunConfigPrepare_TemporaryKeyPairName(t *testing.T) {
t.Fatal("keypair name does not match")
}
}
func TestRunConfigPrepare_TenancyBad(t *testing.T) {
c := testConfig()
c.Tenancy = "not_real"
if err := c.Prepare(nil); len(err) != 1 {
t.Fatal("Should error if tenancy is set to an invalid type")
}
}
func TestRunConfigPrepare_TenancyGood(t *testing.T) {
validTenancy := []string{"", "default", "dedicated", "host"}
for _, vt := range validTenancy {
c := testConfig()
c.Tenancy = vt
if err := c.Prepare(nil); len(err) != 0 {
t.Fatalf("Should not error if tenancy is set to %s", vt)
}
}
}

5
builder/amazon/common/step_run_source_instance.go
View File

@ -33,6 +33,7 @@ type StepRunSourceInstance struct {
IsRestricted bool
SourceAMI string
Tags map[string]string
Tenancy string
UserData string
UserDataFile string
VolumeTags map[string]string
@ -195,6 +196,10 @@ func (s *StepRunSourceInstance) Run(ctx context.Context, state multistep.StateBa
runOpts.InstanceInitiatedShutdownBehavior = &s.InstanceInitiatedShutdownBehavior
}
if s.Tenancy != "" {
runOpts.Placement.Tenancy = aws.String(s.Tenancy)
}
var runResp *ec2.Reservation
err = retry.Config{
Tries: 11,

1
builder/amazon/ebs/builder.go
View File

@ -206,6 +206,7 @@ func (b *Builder) Run(ctx context.Context, ui packer.Ui, hook packer.Hook) (pack
IsRestricted: b.config.IsChinaCloud() || b.config.IsGovCloud(),
SourceAMI: b.config.SourceAmi,
Tags: b.config.RunTags,
Tenancy: b.config.Tenancy,
UserData: b.config.UserData,
UserDataFile: b.config.UserDataFile,
VolumeTags: b.config.VolumeRunTags,

2
builder/amazon/ebs/builder.hcl2spec.go
View File

@ -81,6 +81,7 @@ type FlatConfig struct {
SpotTag []hcl2template.FlatKeyValue `mapstructure:"spot_tag" required:"false" cty:"spot_tag" hcl:"spot_tag"`
SubnetFilter *common.FlatSubnetFilterOptions `mapstructure:"subnet_filter" required:"false" cty:"subnet_filter" hcl:"subnet_filter"`
SubnetId *string `mapstructure:"subnet_id" required:"false" cty:"subnet_id" hcl:"subnet_id"`
Tenancy *string `mapstructure:"tenancy" required:"false" cty:"tenancy" hcl:"tenancy"`
TemporaryKeyPairName *string `mapstructure:"temporary_key_pair_name" required:"false" cty:"temporary_key_pair_name" hcl:"temporary_key_pair_name"`
TemporarySGSourceCidrs []string `mapstructure:"temporary_security_group_source_cidrs" required:"false" cty:"temporary_security_group_source_cidrs" hcl:"temporary_security_group_source_cidrs"`
UserData *string `mapstructure:"user_data" required:"false" cty:"user_data" hcl:"user_data"`
@ -227,6 +228,7 @@ func (*FlatConfig) HCL2Spec() map[string]hcldec.Spec {
"spot_tag": &hcldec.BlockListSpec{TypeName: "spot_tag", Nested: hcldec.ObjectSpec((*hcl2template.FlatKeyValue)(nil).HCL2Spec())},
"subnet_filter": &hcldec.BlockSpec{TypeName: "subnet_filter", Nested: hcldec.ObjectSpec((*common.FlatSubnetFilterOptions)(nil).HCL2Spec())},
"subnet_id": &hcldec.AttrSpec{Name: "subnet_id", Type: cty.String, Required: false},
"tenancy": &hcldec.AttrSpec{Name: "tenancy", Type: cty.String, Required: false},
"temporary_key_pair_name": &hcldec.AttrSpec{Name: "temporary_key_pair_name", Type: cty.String, Required: false},
"temporary_security_group_source_cidrs": &hcldec.AttrSpec{Name: "temporary_security_group_source_cidrs", Type: cty.List(cty.String), Required: false},
"user_data": &hcldec.AttrSpec{Name: "user_data", Type: cty.String, Required: false},

1
builder/amazon/ebssurrogate/builder.go
View File

@ -228,6 +228,7 @@ func (b *Builder) Run(ctx context.Context, ui packer.Ui, hook packer.Hook) (pack
IsRestricted: b.config.IsChinaCloud() || b.config.IsGovCloud(),
SourceAMI: b.config.SourceAmi,
Tags: b.config.RunTags,
Tenancy: b.config.Tenancy,
UserData: b.config.UserData,
UserDataFile: b.config.UserDataFile,
VolumeTags: b.config.VolumeRunTags,

2
builder/amazon/ebssurrogate/builder.hcl2spec.go
View File

@ -103,6 +103,7 @@ type FlatConfig struct {
SpotTag []hcl2template.FlatKeyValue `mapstructure:"spot_tag" required:"false" cty:"spot_tag" hcl:"spot_tag"`
SubnetFilter *common.FlatSubnetFilterOptions `mapstructure:"subnet_filter" required:"false" cty:"subnet_filter" hcl:"subnet_filter"`
SubnetId *string `mapstructure:"subnet_id" required:"false" cty:"subnet_id" hcl:"subnet_id"`
Tenancy *string `mapstructure:"tenancy" required:"false" cty:"tenancy" hcl:"tenancy"`
TemporaryKeyPairName *string `mapstructure:"temporary_key_pair_name" required:"false" cty:"temporary_key_pair_name" hcl:"temporary_key_pair_name"`
TemporarySGSourceCidrs []string `mapstructure:"temporary_security_group_source_cidrs" required:"false" cty:"temporary_security_group_source_cidrs" hcl:"temporary_security_group_source_cidrs"`
UserData *string `mapstructure:"user_data" required:"false" cty:"user_data" hcl:"user_data"`
@ -250,6 +251,7 @@ func (*FlatConfig) HCL2Spec() map[string]hcldec.Spec {
"spot_tag": &hcldec.BlockListSpec{TypeName: "spot_tag", Nested: hcldec.ObjectSpec((*hcl2template.FlatKeyValue)(nil).HCL2Spec())},
"subnet_filter": &hcldec.BlockSpec{TypeName: "subnet_filter", Nested: hcldec.ObjectSpec((*common.FlatSubnetFilterOptions)(nil).HCL2Spec())},
"subnet_id": &hcldec.AttrSpec{Name: "subnet_id", Type: cty.String, Required: false},
"tenancy": &hcldec.AttrSpec{Name: "tenancy", Type: cty.String, Required: false},
"temporary_key_pair_name": &hcldec.AttrSpec{Name: "temporary_key_pair_name", Type: cty.String, Required: false},
"temporary_security_group_source_cidrs": &hcldec.AttrSpec{Name: "temporary_security_group_source_cidrs", Type: cty.List(cty.String), Required: false},
"user_data": &hcldec.AttrSpec{Name: "user_data", Type: cty.String, Required: false},

1
builder/amazon/ebsvolume/builder.go
View File

@ -209,6 +209,7 @@ func (b *Builder) Run(ctx context.Context, ui packer.Ui, hook packer.Hook) (pack
IsRestricted: b.config.IsChinaCloud() || b.config.IsGovCloud(),
SourceAMI: b.config.SourceAmi,
Tags: b.config.RunTags,
Tenancy: b.config.Tenancy,
UserData: b.config.UserData,
UserDataFile: b.config.UserDataFile,
VolumeTags: b.config.VolumeRunTags,

2
builder/amazon/ebsvolume/builder.hcl2spec.go
View File

@ -105,6 +105,7 @@ type FlatConfig struct {
SpotTag []hcl2template.FlatKeyValue `mapstructure:"spot_tag" required:"false" cty:"spot_tag" hcl:"spot_tag"`
SubnetFilter *common.FlatSubnetFilterOptions `mapstructure:"subnet_filter" required:"false" cty:"subnet_filter" hcl:"subnet_filter"`
SubnetId *string `mapstructure:"subnet_id" required:"false" cty:"subnet_id" hcl:"subnet_id"`
Tenancy *string `mapstructure:"tenancy" required:"false" cty:"tenancy" hcl:"tenancy"`
TemporaryKeyPairName *string `mapstructure:"temporary_key_pair_name" required:"false" cty:"temporary_key_pair_name" hcl:"temporary_key_pair_name"`
TemporarySGSourceCidrs []string `mapstructure:"temporary_security_group_source_cidrs" required:"false" cty:"temporary_security_group_source_cidrs" hcl:"temporary_security_group_source_cidrs"`
UserData *string `mapstructure:"user_data" required:"false" cty:"user_data" hcl:"user_data"`
@ -230,6 +231,7 @@ func (*FlatConfig) HCL2Spec() map[string]hcldec.Spec {
"spot_tag": &hcldec.BlockListSpec{TypeName: "spot_tag", Nested: hcldec.ObjectSpec((*hcl2template.FlatKeyValue)(nil).HCL2Spec())},
"subnet_filter": &hcldec.BlockSpec{TypeName: "subnet_filter", Nested: hcldec.ObjectSpec((*common.FlatSubnetFilterOptions)(nil).HCL2Spec())},
"subnet_id": &hcldec.AttrSpec{Name: "subnet_id", Type: cty.String, Required: false},
"tenancy": &hcldec.AttrSpec{Name: "tenancy", Type: cty.String, Required: false},
"temporary_key_pair_name": &hcldec.AttrSpec{Name: "temporary_key_pair_name", Type: cty.String, Required: false},
"temporary_security_group_source_cidrs": &hcldec.AttrSpec{Name: "temporary_security_group_source_cidrs", Type: cty.List(cty.String), Required: false},
"user_data": &hcldec.AttrSpec{Name: "user_data", Type: cty.String, Required: false},

1
builder/amazon/instance/builder.go
View File

@ -286,6 +286,7 @@ func (b *Builder) Run(ctx context.Context, ui packer.Ui, hook packer.Hook) (pack
IsRestricted: b.config.IsChinaCloud() || b.config.IsGovCloud(),
SourceAMI: b.config.SourceAmi,
Tags: b.config.RunTags,
Tenancy: b.config.Tenancy,
UserData: b.config.UserData,
UserDataFile: b.config.UserDataFile,
}

2
builder/amazon/instance/builder.hcl2spec.go
View File

@ -81,6 +81,7 @@ type FlatConfig struct {
SpotTag []hcl2template.FlatKeyValue `mapstructure:"spot_tag" required:"false" cty:"spot_tag" hcl:"spot_tag"`
SubnetFilter *common.FlatSubnetFilterOptions `mapstructure:"subnet_filter" required:"false" cty:"subnet_filter" hcl:"subnet_filter"`
SubnetId *string `mapstructure:"subnet_id" required:"false" cty:"subnet_id" hcl:"subnet_id"`
Tenancy *string `mapstructure:"tenancy" required:"false" cty:"tenancy" hcl:"tenancy"`
TemporaryKeyPairName *string `mapstructure:"temporary_key_pair_name" required:"false" cty:"temporary_key_pair_name" hcl:"temporary_key_pair_name"`
TemporarySGSourceCidrs []string `mapstructure:"temporary_security_group_source_cidrs" required:"false" cty:"temporary_security_group_source_cidrs" hcl:"temporary_security_group_source_cidrs"`
UserData *string `mapstructure:"user_data" required:"false" cty:"user_data" hcl:"user_data"`
@ -233,6 +234,7 @@ func (*FlatConfig) HCL2Spec() map[string]hcldec.Spec {
"spot_tag": &hcldec.BlockListSpec{TypeName: "spot_tag", Nested: hcldec.ObjectSpec((*hcl2template.FlatKeyValue)(nil).HCL2Spec())},
"subnet_filter": &hcldec.BlockSpec{TypeName: "subnet_filter", Nested: hcldec.ObjectSpec((*common.FlatSubnetFilterOptions)(nil).HCL2Spec())},
"subnet_id": &hcldec.AttrSpec{Name: "subnet_id", Type: cty.String, Required: false},
"tenancy": &hcldec.AttrSpec{Name: "tenancy", Type: cty.String, Required: false},
"temporary_key_pair_name": &hcldec.AttrSpec{Name: "temporary_key_pair_name", Type: cty.String, Required: false},
"temporary_security_group_source_cidrs": &hcldec.AttrSpec{Name: "temporary_security_group_source_cidrs", Type: cty.List(cty.String), Required: false},
"user_data": &hcldec.AttrSpec{Name: "user_data", Type: cty.String, Required: false},

2
builder/googlecompute/config.go
View File

@ -76,6 +76,8 @@ type Config struct {
EnableIntegrityMonitoring bool `mapstructure:"enable_integrity_monitoring" required:"false"`
// Whether to use an IAP proxy.
IAPConfig `mapstructure:",squash"`
// Skip creating the image. Useful for setting to `true` during a build test stage. Defaults to `false`.
SkipCreateImage bool `mapstructure:"skip_create_image" required:"false"`
// The unique name of the resulting image. Defaults to
// `packer-{{timestamp}}`.
ImageName string `mapstructure:"image_name" required:"false"`

2
builder/googlecompute/config.hcl2spec.go
View File

@ -82,6 +82,7 @@ type FlatConfig struct {
IAPHashBang *string `mapstructure:"iap_hashbang" required:"false" cty:"iap_hashbang" hcl:"iap_hashbang"`
IAPExt *string `mapstructure:"iap_ext" required:"false" cty:"iap_ext" hcl:"iap_ext"`
IAPTunnelLaunchWait *int `mapstructure:"iap_tunnel_launch_wait" required:"false" cty:"iap_tunnel_launch_wait" hcl:"iap_tunnel_launch_wait"`
SkipCreateImage *bool `mapstructure:"skip_create_image" required:"false" cty:"skip_create_image" hcl:"skip_create_image"`
ImageName *string `mapstructure:"image_name" required:"false" cty:"image_name" hcl:"image_name"`
ImageDescription *string `mapstructure:"image_description" required:"false" cty:"image_description" hcl:"image_description"`
ImageEncryptionKey *FlatCustomerEncryptionKey `mapstructure:"image_encryption_key" required:"false" cty:"image_encryption_key" hcl:"image_encryption_key"`
@ -202,6 +203,7 @@ func (*FlatConfig) HCL2Spec() map[string]hcldec.Spec {
"iap_hashbang": &hcldec.AttrSpec{Name: "iap_hashbang", Type: cty.String, Required: false},
"iap_ext": &hcldec.AttrSpec{Name: "iap_ext", Type: cty.String, Required: false},
"iap_tunnel_launch_wait": &hcldec.AttrSpec{Name: "iap_tunnel_launch_wait", Type: cty.Number, Required: false},
"skip_create_image": &hcldec.AttrSpec{Name: "skip_create_image", Type: cty.Bool, Required: false},
"image_name": &hcldec.AttrSpec{Name: "image_name", Type: cty.String, Required: false},
"image_description": &hcldec.AttrSpec{Name: "image_description", Type: cty.String, Required: false},
"image_encryption_key": &hcldec.BlockSpec{TypeName: "image_encryption_key", Nested: hcldec.ObjectSpec((*FlatCustomerEncryptionKey)(nil).HCL2Spec())},

5
builder/googlecompute/step_create_image.go
View File

@ -23,6 +23,11 @@ func (s *StepCreateImage) Run(ctx context.Context, state multistep.StateBag) mul
driver := state.Get("driver").(Driver)
ui := state.Get("ui").(packer.Ui)
if config.SkipCreateImage {
ui.Say("Skipping image creation...")
return multistep.ActionContinue
}
if config.PackerForce && config.imageAlreadyExists {
ui.Say("Deleting previous image...")

33
builder/osc/bsu/builder.go
View File

@ -9,9 +9,7 @@ package bsu
import (
"context"
"crypto/tls"
"fmt"
"net/http"
"github.com/hashicorp/hcl/v2/hcldec"
osccommon "github.com/hashicorp/packer/builder/osc/common"
@ -21,7 +19,6 @@ import (
"github.com/hashicorp/packer/helper/multistep"
"github.com/hashicorp/packer/packer"
"github.com/hashicorp/packer/template/interpolate"
"github.com/outscale/osc-go/oapi"
)
// The unique ID for this builder
@ -86,24 +83,13 @@ func (b *Builder) Prepare(raws ...interface{}) ([]string, []string, error) {
}
func (b *Builder) Run(ctx context.Context, ui packer.Ui, hook packer.Hook) (packer.Artifact, error) {
clientConfig, err := b.config.Config()
if err != nil {
return nil, err
}
skipClient := &http.Client{
Transport: &http.Transport{
TLSClientConfig: &tls.Config{InsecureSkipVerify: true},
},
}
oapiconn := oapi.NewClient(clientConfig, skipClient)
oscConn := b.config.NewOSCClient()
// Setup the state bag and initial state for the steps
state := new(multistep.BasicStateBag)
state.Put("config", &b.config)
state.Put("oapi", oapiconn)
state.Put("clientConfig", clientConfig)
state.Put("osc", oscConn)
state.Put("accessConfig", &b.config.AccessConfig)
state.Put("hook", hook)
state.Put("ui", ui)
@ -129,7 +115,7 @@ func (b *Builder) Run(ctx context.Context, ui packer.Ui, hook packer.Hook) (pack
&osccommon.StepKeyPair{
Debug: b.config.PackerDebug,
Comm: &b.config.RunConfig.Comm,
DebugKeyPath: fmt.Sprintf("oapi_%s", b.config.PackerBuildName),
DebugKeyPath: fmt.Sprintf("osc_%s", b.config.PackerBuildName),
},
&osccommon.StepPublicIp{
AssociatePublicIpAddress: b.config.AssociatePublicIpAddress,
@ -161,6 +147,7 @@ func (b *Builder) Run(ctx context.Context, ui packer.Ui, hook packer.Hook) (pack
UserData: b.config.UserData,
UserDataFile: b.config.UserDataFile,
VolumeTags: b.config.VolumeRunTags,
RawRegion: b.config.RawRegion,
},
&osccommon.StepGetPassword{
Debug: b.config.PackerDebug,
@ -170,8 +157,8 @@ func (b *Builder) Run(ctx context.Context, ui packer.Ui, hook packer.Hook) (pack
},
&communicator.StepConnect{
Config: &b.config.RunConfig.Comm,
Host: osccommon.SSHHost(
oapiconn,
Host: osccommon.OscSSHHost(
oscConn.VmApi,
b.config.SSHInterface),
SSHConfig: b.config.RunConfig.Comm.SSHConfigFunc(),
},
@ -190,10 +177,13 @@ func (b *Builder) Run(ctx context.Context, ui packer.Ui, hook packer.Hook) (pack
OMIName: b.config.OMIName,
Regions: b.config.OMIRegions,
},
&stepCreateOMI{},
&stepCreateOMI{
RawRegion: b.config.RawRegion,
},
&osccommon.StepUpdateOMIAttributes{
AccountIds: b.config.OMIAccountIDs,
SnapshotAccountIds: b.config.SnapshotAccountIDs,
RawRegion: b.config.RawRegion,
Ctx: b.config.ctx,
},
&osccommon.StepCreateTags{
@ -217,7 +207,6 @@ func (b *Builder) Run(ctx context.Context, ui packer.Ui, hook packer.Hook) (pack
artifact := &osccommon.Artifact{
Omis: omis.(map[string]string),
BuilderIdValue: BuilderId,
Config: clientConfig,
StateData: map[string]interface{}{"generated_data": state.Get("generated_data")},
}

26
builder/osc/bsu/builder_acc_test.go
View File

@ -2,13 +2,9 @@
package bsu
import (
"crypto/tls"
"net/http"
"testing"
"github.com/hashicorp/packer/builder/osc/common"
builderT "github.com/hashicorp/packer/helper/builder/testing"
"github.com/outscale/osc-go/oapi"
)
func TestBuilderAcc_basic(t *testing.T) {
@ -23,31 +19,17 @@ func TestBuilderAcc_basic(t *testing.T) {
func testAccPreCheck(t *testing.T) {
}
func testOAPIConn() (*oapi.Client, error) {
access := &common.AccessConfig{RawRegion: "us-east-1"}
clientConfig, err := access.Config()
if err != nil {
return nil, err
}
skipClient := &http.Client{
Transport: &http.Transport{
TLSClientConfig: &tls.Config{InsecureSkipVerify: true},
},
}
return oapi.NewClient(clientConfig, skipClient), nil
}
const testBuilderAccBasic = `
{
"builders": [{
"type": "test",
"region": "eu-west-2",
"vm_type": "t2.micro",
"source_omi": "ami-65efcc11",
"source_omi": "ami-abe953fa",
"ssh_username": "outscale",
"omi_name": "packer-test {{timestamp}}"
"omi_name": "packer-test",
"associate_public_ip_address": true,
"force_deregister": true
}]
}
`

64
builder/osc/bsu/step_create_omi.go
View File

@ -5,62 +5,68 @@ import (
"fmt"
"log"
"github.com/antihax/optional"
osccommon "github.com/hashicorp/packer/builder/osc/common"
"github.com/hashicorp/packer/helper/multistep"
"github.com/hashicorp/packer/packer"
"github.com/outscale/osc-go/oapi"
"github.com/outscale/osc-sdk-go/osc"
)
type stepCreateOMI struct {
image *oapi.Image
image *osc.Image
RawRegion string
}
func (s *stepCreateOMI) Run(ctx context.Context, state multistep.StateBag) multistep.StepAction {
config := state.Get("config").(*Config)
oapiconn := state.Get("oapi").(*oapi.Client)
vm := state.Get("vm").(oapi.Vm)
oscconn := state.Get("osc").(*osc.APIClient)
vm := state.Get("vm").(osc.Vm)
ui := state.Get("ui").(packer.Ui)
// Create the image
omiName := config.OMIName
ui.Say(fmt.Sprintf("Creating OMI %s from vm %s", omiName, vm.VmId))
createOpts := oapi.CreateImageRequest{
createOpts := osc.CreateImageRequest{
VmId: vm.VmId,
ImageName: omiName,
BlockDeviceMappings: config.BlockDevices.BuildOMIDevices(),
BlockDeviceMappings: config.BlockDevices.BuildOscOMIDevices(),
}
resp, err := oapiconn.POST_CreateImage(createOpts)
if err != nil || resp.OK == nil {
resp, _, err := oscconn.ImageApi.CreateImage(context.Background(), &osc.CreateImageOpts{
CreateImageRequest: optional.NewInterface(createOpts),
})
if err != nil || resp.Image.ImageId == "" {
err := fmt.Errorf("Error creating OMI: %s", err)
state.Put("error", err)
ui.Error(err.Error())
return multistep.ActionHalt
}
image := resp.OK.Image
image := resp.Image
// Set the OMI ID in the state
ui.Message(fmt.Sprintf("OMI: %s", image.ImageId))
omis := make(map[string]string)
omis[oapiconn.GetConfig().Region] = image.ImageId
omis[s.RawRegion] = image.ImageId
state.Put("omis", omis)
// Wait for the image to become ready
ui.Say("Waiting for OMI to become ready...")
if err := osccommon.WaitUntilImageAvailable(oapiconn, image.ImageId); err != nil {
if err := osccommon.WaitUntilOscImageAvailable(oscconn, image.ImageId); err != nil {
log.Printf("Error waiting for OMI: %s", err)
imagesResp, err := oapiconn.POST_ReadImages(oapi.ReadImagesRequest{
Filters: oapi.FiltersImage{
ImageIds: []string{image.ImageId},
},
imagesResp, _, err := oscconn.ImageApi.ReadImages(context.Background(), &osc.ReadImagesOpts{
ReadImagesRequest: optional.NewInterface(osc.ReadImagesRequest{
Filters: osc.FiltersImage{
ImageIds: []string{image.ImageId},
},
}),
})
if err != nil {
log.Printf("Unable to determine reason waiting for OMI failed: %s", err)
err = fmt.Errorf("Unknown error waiting for OMI.")
err = fmt.Errorf("Unknown error waiting for OMI")
} else {
stateReason := imagesResp.OK.Images[0].StateComment
stateReason := imagesResp.Images[0].StateComment
err = fmt.Errorf("Error waiting for OMI. Reason: %s", stateReason)
}
@ -69,10 +75,12 @@ func (s *stepCreateOMI) Run(ctx context.Context, state multistep.StateBag) multi
return multistep.ActionHalt
}
imagesResp, err := oapiconn.POST_ReadImages(oapi.ReadImagesRequest{
Filters: oapi.FiltersImage{
ImageIds: []string{image.ImageId},
},
imagesResp, _, err := oscconn.ImageApi.ReadImages(context.Background(), &osc.ReadImagesOpts{
ReadImagesRequest: optional.NewInterface(osc.ReadImagesRequest{
Filters: osc.FiltersImage{
ImageIds: []string{image.ImageId},
},
}),
})
if err != nil {
err := fmt.Errorf("Error searching for OMI: %s", err)
@ -80,12 +88,12 @@ func (s *stepCreateOMI) Run(ctx context.Context, state multistep.StateBag) multi
ui.Error(err.Error())
return multistep.ActionHalt
}
s.image = &imagesResp.OK.Images[0]
s.image = &imagesResp.Images[0]
snapshots := make(map[string][]string)
for _, blockDeviceMapping := range imagesResp.OK.Images[0].BlockDeviceMappings {
for _, blockDeviceMapping := range imagesResp.Images[0].BlockDeviceMappings {
if blockDeviceMapping.Bsu.SnapshotId != "" {
snapshots[oapiconn.GetConfig().Region] = append(snapshots[oapiconn.GetConfig().Region], blockDeviceMapping.Bsu.SnapshotId)
snapshots[s.RawRegion] = append(snapshots[s.RawRegion], blockDeviceMapping.Bsu.SnapshotId)
}
}
state.Put("snapshots", snapshots)
@ -104,12 +112,14 @@ func (s *stepCreateOMI) Cleanup(state multistep.StateBag) {
return
}
oapiconn := state.Get("oapi").(*oapi.Client)
oscconn := state.Get("osc").(*osc.APIClient)
ui := state.Get("ui").(packer.Ui)
ui.Say("Deregistering the OMI because cancellation or error...")
DeleteOpts := oapi.DeleteImageRequest{ImageId: s.image.ImageId}
if _, err := oapiconn.POST_DeleteImage(DeleteOpts); err != nil {
DeleteOpts := osc.DeleteImageRequest{ImageId: s.image.ImageId}
if _, _, err := oscconn.ImageApi.DeleteImage(context.Background(), &osc.DeleteImageOpts{
DeleteImageRequest: optional.NewInterface(DeleteOpts),
}); err != nil {
ui.Error(fmt.Sprintf("Error Deleting OMI, may still be around: %s", err))
return
}

34
builder/osc/bsusurrogate/builder.go
View File

@ -6,10 +6,8 @@ package bsusurrogate
import (
"context"
"crypto/tls"
"errors"
"fmt"
"net/http"
"github.com/hashicorp/hcl/v2/hcldec"
osccommon "github.com/hashicorp/packer/builder/osc/common"
@ -19,7 +17,6 @@ import (
"github.com/hashicorp/packer/helper/multistep"
"github.com/hashicorp/packer/packer"
"github.com/hashicorp/packer/template/interpolate"
"github.com/outscale/osc-go/oapi"
)
const BuilderId = "oapi.outscale.bsusurrogate"
@ -104,31 +101,20 @@ func (b *Builder) Prepare(raws ...interface{}) ([]string, []string, error) {
}
func (b *Builder) Run(ctx context.Context, ui packer.Ui, hook packer.Hook) (packer.Artifact, error) {
clientConfig, err := b.config.Config()
if err != nil {
return nil, err
}
skipClient := &http.Client{
Transport: &http.Transport{
TLSClientConfig: &tls.Config{InsecureSkipVerify: true},
},
}
oapiconn := oapi.NewClient(clientConfig, skipClient)
oscConn := b.config.NewOSCClient()
// Setup the state bag and initial state for the steps
state := new(multistep.BasicStateBag)
state.Put("config", &b.config)
state.Put("oapi", oapiconn)
state.Put("clientConfig", clientConfig)
state.Put("osc", oscConn)
state.Put("accessConfig", &b.config.AccessConfig)
state.Put("hook", hook)
state.Put("ui", ui)
//VMStep
omiDevices := b.config.BuildOMIDevices()
launchDevices := b.config.BuildLaunchDevices()
omiDevices := b.config.BuildOscOMIDevices()
launchOSCDevices := b.config.BuildOSCLaunchDevices()
steps := []multistep.Step{
&osccommon.StepPreValidate{
@ -193,8 +179,8 @@ func (b *Builder) Run(ctx context.Context, ui packer.Ui, hook packer.Hook) (pack
},
&communicator.StepConnect{
Config: &b.config.RunConfig.Comm,
Host: osccommon.SSHHost(
oapiconn,
Host: osccommon.OscSSHHost(
oscConn.VmApi,
b.config.SSHInterface),
SSHConfig: b.config.RunConfig.Comm.SSHConfigFunc(),
},
@ -207,7 +193,7 @@ func (b *Builder) Run(ctx context.Context, ui packer.Ui, hook packer.Hook) (pack
DisableStopVm: b.config.DisableStopVm,
},
&StepSnapshotVolumes{
LaunchDevices: launchDevices,
LaunchDevices: launchOSCDevices,
},
&osccommon.StepDeregisterOMI{
AccessConfig: &b.config.AccessConfig,
@ -219,7 +205,8 @@ func (b *Builder) Run(ctx context.Context, ui packer.Ui, hook packer.Hook) (pack
&StepRegisterOMI{
RootDevice: b.config.RootDevice,
OMIDevices: omiDevices,
LaunchDevices: launchDevices,
LaunchDevices: launchOSCDevices,
RawRegion: b.config.RawRegion,
},
&osccommon.StepUpdateOMIAttributes{
AccountIds: b.config.OMIAccountIDs,
@ -247,7 +234,6 @@ func (b *Builder) Run(ctx context.Context, ui packer.Ui, hook packer.Hook) (pack
artifact := &osccommon.Artifact{
Omis: omis.(map[string]string),
BuilderIdValue: BuilderId,
Config: clientConfig,
StateData: map[string]interface{}{"generated_data": state.Get("generated_data")},
}

2
builder/osc/bsusurrogate/builder_acc_test.go
View File

@ -24,7 +24,7 @@ const testBuilderAccBasic = `
"type": "test",
"region": "eu-west-2",
"vm_type": "t2.micro",
"source_omi": "ami-65efcc11",
"source_omi": "ami-abe953fa",
"ssh_username": "outscale",
"omi_name": "packer-test {{timestamp}}",
"omi_virtualization_type": "hvm",

62
builder/osc/bsusurrogate/step_register_omi.go
View File

@ -4,23 +4,25 @@ import (
"context"
"fmt"
"github.com/antihax/optional"
osccommon "github.com/hashicorp/packer/builder/osc/common"
"github.com/hashicorp/packer/helper/multistep"
"github.com/hashicorp/packer/packer"
"github.com/outscale/osc-go/oapi"
"github.com/outscale/osc-sdk-go/osc"
)
// StepRegisterOMI creates the OMI.
type StepRegisterOMI struct {
RootDevice RootBlockDevice
OMIDevices []oapi.BlockDeviceMappingImage
LaunchDevices []oapi.BlockDeviceMappingVmCreation
image *oapi.Image
OMIDevices []osc.BlockDeviceMappingImage
LaunchDevices []osc.BlockDeviceMappingVmCreation
image *osc.Image
RawRegion string
}
func (s *StepRegisterOMI) Run(ctx context.Context, state multistep.StateBag) multistep.StepAction {
config := state.Get("config").(*Config)
oapiconn := state.Get("oapi").(*oapi.Client)
oscconn := state.Get("osc").(*osc.APIClient)
snapshotIds := state.Get("snapshot_ids").(map[string]string)
ui := state.Get("ui").(packer.Ui)
@ -28,14 +30,16 @@ func (s *StepRegisterOMI) Run(ctx context.Context, state multistep.StateBag) mul
blockDevices := s.combineDevices(snapshotIds)
registerOpts := oapi.CreateImageRequest{
registerOpts := osc.CreateImageRequest{
ImageName: config.OMIName,
Architecture: "x86_64",
RootDeviceName: s.RootDevice.DeviceName,
BlockDeviceMappings: blockDevices,
}
registerResp, err := oapiconn.POST_CreateImage(registerOpts)
registerResp, _, err := oscconn.ImageApi.CreateImage(context.Background(), &osc.CreateImageOpts{
CreateImageRequest: optional.NewInterface(registerOpts),
})
if err != nil {
state.Put("error", fmt.Errorf("Error registering OMI: %s", err))
ui.Error(state.Get("error").(error).Error())
@ -43,24 +47,26 @@ func (s *StepRegisterOMI) Run(ctx context.Context, state multistep.StateBag) mul
}
// Set the OMI ID in the state
ui.Say(fmt.Sprintf("OMI: %s", registerResp.OK.Image.ImageId))
ui.Say(fmt.Sprintf("OMI: %s", registerResp.Image.ImageId))
omis := make(map[string]string)
omis[oapiconn.GetConfig().Region] = registerResp.OK.Image.ImageId
omis[s.RawRegion] = registerResp.Image.ImageId
state.Put("omis", omis)
// Wait for the image to become ready
ui.Say("Waiting for OMI to become ready...")
if err := osccommon.WaitUntilImageAvailable(oapiconn, registerResp.OK.Image.ImageId); err != nil {
if err := osccommon.WaitUntilOscImageAvailable(oscconn, registerResp.Image.ImageId); err != nil {
err := fmt.Errorf("Error waiting for OMI: %s", err)
state.Put("error", err)
ui.Error(err.Error())
return multistep.ActionHalt
}
imagesResp, err := oapiconn.POST_ReadImages(oapi.ReadImagesRequest{
Filters: oapi.FiltersImage{
ImageIds: []string{registerResp.OK.Image.ImageId},
},
imagesResp, _, err := oscconn.ImageApi.ReadImages(context.Background(), &osc.ReadImagesOpts{
ReadImagesRequest: optional.NewInterface(osc.ReadImagesRequest{
Filters: osc.FiltersImage{
ImageIds: []string{registerResp.Image.ImageId},
},
}),
})
if err != nil {
@ -69,12 +75,12 @@ func (s *StepRegisterOMI) Run(ctx context.Context, state multistep.StateBag) mul
ui.Error(err.Error())
return multistep.ActionHalt
}
s.image = &imagesResp.OK.Images[0]
s.image = &imagesResp.Images[0]
snapshots := make(map[string][]string)
for _, blockDeviceMapping := range imagesResp.OK.Images[0].BlockDeviceMappings {
for _, blockDeviceMapping := range imagesResp.Images[0].BlockDeviceMappings {
if blockDeviceMapping.Bsu.SnapshotId != "" {
snapshots[oapiconn.GetConfig().Region] = append(snapshots[oapiconn.GetConfig().Region], blockDeviceMapping.Bsu.SnapshotId)
snapshots[s.RawRegion] = append(snapshots[s.RawRegion], blockDeviceMapping.Bsu.SnapshotId)
}
}
state.Put("snapshots", snapshots)
@ -93,19 +99,23 @@ func (s *StepRegisterOMI) Cleanup(state multistep.StateBag) {
return
}
oapiconn := state.Get("oapi").(*oapi.Client)
oscconn := state.Get("osc").(*osc.APIClient)
ui := state.Get("ui").(packer.Ui)
ui.Say("Deregistering the OMI because cancellation or error...")
deregisterOpts := oapi.DeleteImageRequest{ImageId: s.image.ImageId}
if _, err := oapiconn.POST_DeleteImage(deregisterOpts); err != nil {
deregisterOpts := osc.DeleteImageRequest{ImageId: s.image.ImageId}
_, _, err := oscconn.ImageApi.DeleteImage(context.Background(), &osc.DeleteImageOpts{
DeleteImageRequest: optional.NewInterface(deregisterOpts),
})
if err != nil {
ui.Error(fmt.Sprintf("Error deregistering OMI, may still be around: %s", err))
return
}
}
func (s *StepRegisterOMI) combineDevices(snapshotIds map[string]string) []oapi.BlockDeviceMappingImage {
devices := map[string]oapi.BlockDeviceMappingImage{}
func (s *StepRegisterOMI) combineDevices(snapshotIds map[string]string) []osc.BlockDeviceMappingImage {
devices := map[string]osc.BlockDeviceMappingImage{}
for _, device := range s.OMIDevices {
devices[device.DeviceName] = device
@ -125,18 +135,18 @@ func (s *StepRegisterOMI) combineDevices(snapshotIds map[string]string) []oapi.B
devices[device.DeviceName] = copyToDeviceMappingImage(device)
}
blockDevices := []oapi.BlockDeviceMappingImage{}
blockDevices := []osc.BlockDeviceMappingImage{}
for _, device := range devices {
blockDevices = append(blockDevices, device)
}
return blockDevices
}
func copyToDeviceMappingImage(device oapi.BlockDeviceMappingVmCreation) oapi.BlockDeviceMappingImage {
deviceImage := oapi.BlockDeviceMappingImage{
func copyToDeviceMappingImage(device osc.BlockDeviceMappingVmCreation) osc.BlockDeviceMappingImage {
deviceImage := osc.BlockDeviceMappingImage{
DeviceName: device.DeviceName,
VirtualDeviceName: device.VirtualDeviceName,
Bsu: oapi.BsuToCreate{
Bsu: osc.BsuToCreate{
DeleteOnVmDeletion: device.Bsu.DeleteOnVmDeletion,
Iops: device.Bsu.Iops,
SnapshotId: device.Bsu.SnapshotId,

31
builder/osc/bsusurrogate/step_snapshop_volumes.go
View File

@ -6,11 +6,12 @@ import (
"sync"
"time"
"github.com/antihax/optional"
multierror "github.com/hashicorp/go-multierror"
osccommon "github.com/hashicorp/packer/builder/osc/common"
"github.com/hashicorp/packer/helper/multistep"
"github.com/hashicorp/packer/packer"
"github.com/outscale/osc-go/oapi"
"github.com/outscale/osc-sdk-go/osc"
)
// StepSnapshotVolumes creates snapshots of the created volumes.
@ -18,14 +19,14 @@ import (
// Produces:
// snapshot_ids map[string]string - IDs of the created snapshots
type StepSnapshotVolumes struct {
LaunchDevices []oapi.BlockDeviceMappingVmCreation
LaunchDevices []osc.BlockDeviceMappingVmCreation
snapshotIds map[string]string
}
func (s *StepSnapshotVolumes) snapshotVolume(ctx context.Context, deviceName string, state multistep.StateBag) error {
oapiconn := state.Get("oapi").(*oapi.Client)
oscconn := state.Get("osc").(*osc.APIClient)
ui := state.Get("ui").(packer.Ui)
vm := state.Get("vm").(oapi.Vm)
vm := state.Get("vm").(osc.Vm)
var volumeId string
for _, volume := range vm.BlockDeviceMappings {
@ -40,19 +41,21 @@ func (s *StepSnapshotVolumes) snapshotVolume(ctx context.Context, deviceName str
ui.Say(fmt.Sprintf("Creating snapshot of EBS Volume %s...", volumeId))
description := fmt.Sprintf("Packer: %s", time.Now().String())
createSnapResp, err := oapiconn.POST_CreateSnapshot(oapi.CreateSnapshotRequest{
VolumeId: volumeId,
Description: description,
createSnapResp, _, err := oscconn.SnapshotApi.CreateSnapshot(context.Background(), &osc.CreateSnapshotOpts{
CreateSnapshotRequest: optional.NewInterface(osc.CreateSnapshotRequest{
VolumeId: volumeId,
Description: description,
}),
})
if err != nil {
return err
}
// Set the snapshot ID so we can delete it later
s.snapshotIds[deviceName] = createSnapResp.OK.Snapshot.SnapshotId
s.snapshotIds[deviceName] = createSnapResp.Snapshot.SnapshotId
// Wait for snapshot to be created
err = osccommon.WaitUntilSnapshotCompleted(oapiconn, createSnapResp.OK.Snapshot.SnapshotId)
err = osccommon.WaitUntilOscSnapshotCompleted(oscconn, createSnapResp.Snapshot.SnapshotId)
return err
}
@ -65,7 +68,7 @@ func (s *StepSnapshotVolumes) Run(ctx context.Context, state multistep.StateBag)
var errs *multierror.Error
for _, device := range s.LaunchDevices {
wg.Add(1)
go func(device oapi.BlockDeviceMappingVmCreation) {
go func(device osc.BlockDeviceMappingVmCreation) {
defer wg.Done()
if err := s.snapshotVolume(ctx, device.DeviceName, state); err != nil {
errs = multierror.Append(errs, err)
@ -94,11 +97,13 @@ func (s *StepSnapshotVolumes) Cleanup(state multistep.StateBag) {
_, halted := state.GetOk(multistep.StateHalted)
if cancelled || halted {
oapiconn := state.Get("oapi").(*oapi.Client)
oscconn := state.Get("osc").(*osc.APIClient)
ui := state.Get("ui").(packer.Ui)
ui.Say("Removing snapshots since we cancelled or halted...")
for _, snapshotId := range s.snapshotIds {
_, err := oapiconn.POST_DeleteSnapshot(oapi.DeleteSnapshotRequest{SnapshotId: snapshotId})
for _, snapshotID := range s.snapshotIds {
_, _, err := oscconn.SnapshotApi.DeleteSnapshot(context.Background(), &osc.DeleteSnapshotOpts{
DeleteSnapshotRequest: optional.NewInterface(osc.DeleteSnapshotRequest{SnapshotId: snapshotID}),
})
if err != nil {
ui.Error(fmt.Sprintf("Error: %s", err))
}

12
builder/osc/bsuvolume/artifact.go
View File

@ -1,13 +1,15 @@
package bsuvolume
import (
"context"
"fmt"
"log"
"sort"
"strings"
"github.com/antihax/optional"
"github.com/hashicorp/packer/packer"
"github.com/outscale/osc-go/oapi"
"github.com/outscale/osc-sdk-go/osc"
)
// map of region to list of volume IDs
@ -22,7 +24,7 @@ type Artifact struct {
BuilderIdValue string
// Client connection for performing API stuff.
Conn *oapi.Client
Conn *osc.APIClient
// StateData should store data such as GeneratedData
// to be shared with post-processors
@ -70,10 +72,12 @@ func (a *Artifact) Destroy() error {
for _, volumeID := range volumeIDs {
log.Printf("Deregistering Volume ID (%s) from region (%s)", volumeID, region)
input := oapi.DeleteVolumeRequest{
input := osc.DeleteVolumeRequest{
VolumeId: volumeID,
}
if _, err := a.Conn.POST_DeleteVolume(input); err != nil {
if _, _, err := a.Conn.VolumeApi.DeleteVolume(context.Background(), &osc.DeleteVolumeOpts{
DeleteVolumeRequest: optional.NewInterface(optional.NewInterface(input)),
}); err != nil {
errors = append(errors, err)
}
}

33
builder/osc/bsuvolume/builder.go
View File

@ -6,10 +6,8 @@ package bsuvolume
import (
"context"
"crypto/tls"
"fmt"
"log"
"net/http"
"github.com/hashicorp/hcl/v2/hcldec"
osccommon "github.com/hashicorp/packer/builder/osc/common"
@ -19,7 +17,6 @@ import (
"github.com/hashicorp/packer/helper/multistep"
"github.com/hashicorp/packer/packer"
"github.com/hashicorp/packer/template/interpolate"
"github.com/outscale/osc-go/oapi"
)
const BuilderId = "oapi.outscale.bsuvolume"
@ -89,22 +86,22 @@ func (b *Builder) Prepare(raws ...interface{}) ([]string, []string, error) {
}
func (b *Builder) Run(ctx context.Context, ui packer.Ui, hook packer.Hook) (packer.Artifact, error) {
clientConfig, err := b.config.Config()
if err != nil {
return nil, err
}
// clientConfig, err := b.config.Config()
// if err != nil {
// return nil, err
// }
skipClient := &http.Client{
Transport: &http.Transport{
TLSClientConfig: &tls.Config{InsecureSkipVerify: true},
},
}
// skipClient := &http.Client{
// Transport: &http.Transport{
// TLSClientConfig: &tls.Config{InsecureSkipVerify: true},
// },
// }
oapiconn := oapi.NewClient(clientConfig, skipClient)
oscConn := b.config.NewOSCClient()
// Setup the state bag and initial state for the steps
state := new(multistep.BasicStateBag)
state.Put("oapi", oapiconn)
state.Put("osc", oscConn)
state.Put("hook", hook)
state.Put("ui", ui)
@ -117,7 +114,7 @@ func (b *Builder) Run(ctx context.Context, ui packer.Ui, hook packer.Hook) (pack
Debug: b.config.PackerDebug,
BsuOptimized: b.config.BsuOptimized,
EnableT2Unlimited: b.config.EnableT2Unlimited,
ExpectedRootDevice: "ebs",
ExpectedRootDevice: "bsu",
IamVmProfile: b.config.IamVmProfile,
VmInitiatedShutdownBehavior: b.config.VmInitiatedShutdownBehavior,
VmType: b.config.VmType,
@ -170,8 +167,8 @@ func (b *Builder) Run(ctx context.Context, ui packer.Ui, hook packer.Hook) (pack
},
&communicator.StepConnect{
Config: &b.config.RunConfig.Comm,
Host: osccommon.SSHHost(
oapiconn,
Host: osccommon.OscSSHHost(
oscConn.VmApi,
b.config.SSHInterface),
SSHConfig: b.config.RunConfig.Comm.SSHConfigFunc(),
},
@ -198,7 +195,7 @@ func (b *Builder) Run(ctx context.Context, ui packer.Ui, hook packer.Hook) (pack
artifact := &Artifact{
Volumes: state.Get("bsuvolumes").(BsuVolumes),
BuilderIdValue: BuilderId,
Conn: oapiconn,
Conn: oscConn,
StateData: map[string]interface{}{"generated_data": state.Get("generated_data")},
}
ui.Say(fmt.Sprintf("Created Volumes: %s", artifact))

22
builder/osc/bsuvolume/builder_acc_test.go
View File

@ -2,13 +2,9 @@
package bsuvolume
import (
"crypto/tls"
"net/http"
"testing"
"github.com/hashicorp/packer/builder/osc/common"
builderT "github.com/hashicorp/packer/helper/builder/testing"
"github.com/outscale/osc-go/oapi"
)
func TestBuilderAcc_basic(t *testing.T) {
@ -23,22 +19,6 @@ func TestBuilderAcc_basic(t *testing.T) {
func testAccPreCheck(t *testing.T) {
}
func testOAPIConn() (*oapi.Client, error) {
access := &common.AccessConfig{RawRegion: "us-east-1"}
clientConfig, err := access.Config()
if err != nil {
return nil, err
}
skipClient := &http.Client{
Transport: &http.Transport{
TLSClientConfig: &tls.Config{InsecureSkipVerify: true},
},
}
return oapi.NewClient(clientConfig, skipClient), nil
}
const testBuilderAccBasic = `
{
"builders": [
@ -46,7 +26,7 @@ const testBuilderAccBasic = `
"type": "test",
"region": "eu-west-2",
"vm_type": "t2.micro",
"source_omi": "ami-65efcc11",
"source_omi": "ami-abe953fa",
"ssh_username": "outscale",
"bsu_volumes": [
{

24
builder/osc/bsuvolume/step_tag_bsu_volumes.go
View File

@ -4,28 +4,30 @@ import (
"context"
"fmt"
"github.com/antihax/optional"
"github.com/hashicorp/packer/helper/multistep"
"github.com/hashicorp/packer/packer"
"github.com/hashicorp/packer/template/interpolate"
"github.com/outscale/osc-go/oapi"
"github.com/outscale/osc-sdk-go/osc"
)
type stepTagBSUVolumes struct {
VolumeMapping []BlockDevice
RawRegion string
Ctx interpolate.Context
}
func (s *stepTagBSUVolumes) Run(_ context.Context, state multistep.StateBag) multistep.StepAction {
oapiconn := state.Get("oapi").(*oapi.Client)
vm := state.Get("vm").(oapi.Vm)
oscconn := state.Get("osc").(*osc.APIClient)
vm := state.Get("vm").(osc.Vm)
ui := state.Get("ui").(packer.Ui)
volumes := make(BsuVolumes)
for _, instanceBlockDevices := range vm.BlockDeviceMappings {
for _, configVolumeMapping := range s.VolumeMapping {
if configVolumeMapping.DeviceName == instanceBlockDevices.DeviceName {
volumes[oapiconn.GetConfig().Region] = append(
volumes[oapiconn.GetConfig().Region],
volumes[s.RawRegion] = append(
volumes[s.RawRegion],
instanceBlockDevices.Bsu.VolumeId)
}
}
@ -35,14 +37,14 @@ func (s *stepTagBSUVolumes) Run(_ context.Context, state multistep.StateBag) mul
if len(s.VolumeMapping) > 0 {
ui.Say("Tagging BSU volumes...")
toTag := map[string][]oapi.ResourceTag{}
toTag := map[string][]osc.ResourceTag{}
for _, mapping := range s.VolumeMapping {
if len(mapping.Tags) == 0 {
ui.Say(fmt.Sprintf("No tags specified for volume on %s...", mapping.DeviceName))
continue
}
tags, err := mapping.Tags.OAPITags(s.Ctx, oapiconn.GetConfig().Region, state)
tags, err := mapping.Tags.OSCTags(s.Ctx, s.RawRegion, state)
if err != nil {
err := fmt.Errorf("Error tagging device %s with %s", mapping.DeviceName, err)
state.Put("error", err)
@ -59,9 +61,11 @@ func (s *stepTagBSUVolumes) Run(_ context.Context, state multistep.StateBag) mul
}
for volumeId, tags := range toTag {
_, err := oapiconn.POST_CreateTags(oapi.CreateTagsRequest{
ResourceIds: []string{volumeId},
Tags: tags,
_, _, err := oscconn.TagApi.CreateTags(context.Background(), &osc.CreateTagsOpts{
CreateTagsRequest: optional.NewInterface(osc.CreateTagsRequest{
ResourceIds: []string{volumeId},
Tags: tags,
}),
})
if err != nil {
err := fmt.Errorf("Error tagging BSU Volume %s on %s: %s", volumeId, vm.VmId, err)

26
builder/osc/chroot/builder.go
View File

@ -8,9 +8,7 @@ package chroot
import (
"context"
"crypto/tls"
"errors"
"net/http"
"runtime"
"github.com/hashicorp/hcl/v2/hcldec"
@ -20,7 +18,6 @@ import (
"github.com/hashicorp/packer/helper/multistep"
"github.com/hashicorp/packer/packer"
"github.com/hashicorp/packer/template/interpolate"
"github.com/outscale/osc-go/oapi"
)
// The unique ID for this builder
@ -193,19 +190,7 @@ func (b *Builder) Run(ctx context.Context, ui packer.Ui, hook packer.Hook) (pack
return nil, errors.New("The outscale-chroot builder only works on Linux environments.")
}
clientConfig, err := b.config.Config()
if err != nil {
return nil, err
}
skipClient := &http.Client{
Transport: &http.Transport{
TLSClientConfig: &tls.Config{InsecureSkipVerify: true},
},
}
oapiconn := oapi.NewClient(clientConfig, skipClient)
oscConn := b.config.NewOSCClient()
wrappedCommand := func(command string) (string, error) {
ctx := b.config.ctx
ctx.Data = &wrappedCommandTemplate{Command: command}
@ -215,8 +200,7 @@ func (b *Builder) Run(ctx context.Context, ui packer.Ui, hook packer.Hook) (pack
// Setup the state bag and initial state for the steps
state := new(multistep.BasicStateBag)
state.Put("config", &b.config)
state.Put("oapi", oapiconn)
state.Put("clientConfig", clientConfig)
state.Put("osc", oscConn)
state.Put("hook", hook)
state.Put("ui", ui)
state.Put("wrappedCommand", CommandWrapper(wrappedCommand))
@ -266,7 +250,9 @@ func (b *Builder) Run(ctx context.Context, ui packer.Ui, hook packer.Hook) (pack
&StepCopyFiles{},
&StepChrootProvision{},
&StepEarlyCleanup{},
&StepSnapshot{},
&StepSnapshot{
RawRegion: b.config.RawRegion,
},
&osccommon.StepDeregisterOMI{
AccessConfig: &b.config.AccessConfig,
ForceDeregister: b.config.OMIForceDeregister,
@ -276,6 +262,7 @@ func (b *Builder) Run(ctx context.Context, ui packer.Ui, hook packer.Hook) (pack
},
&StepCreateOMI{
RootVolumeSize: b.config.RootVolumeSize,
RawRegion: b.config.RawRegion,
},
&osccommon.StepUpdateOMIAttributes{
AccountIds: b.config.OMIAccountIDs,
@ -307,7 +294,6 @@ func (b *Builder) Run(ctx context.Context, ui packer.Ui, hook packer.Hook) (pack
artifact := &osccommon.Artifact{
Omis: state.Get("omis").(map[string]string),
BuilderIdValue: BuilderId,
Config: clientConfig,
StateData: map[string]interface{}{"generated_data": state.Get("generated_data")},
}

4
builder/osc/chroot/step_check_root_device.go
View File

@ -6,14 +6,14 @@ import (
"github.com/hashicorp/packer/helper/multistep"
"github.com/hashicorp/packer/packer"
"github.com/outscale/osc-go/oapi"
"github.com/outscale/osc-sdk-go/osc"
)
// StepCheckRootDevice makes sure the root device on the OMI is BSU-backed.
type StepCheckRootDevice struct{}
func (s *StepCheckRootDevice) Run(_ context.Context, state multistep.StateBag) multistep.StepAction {
image := state.Get("source_image").(oapi.Image)
image := state.Get("source_image").(osc.Image)
ui := state.Get("ui").(packer.Ui)
ui.Say("Checking the root device on source OMI...")

42
builder/osc/chroot/step_create_omi.go
View File

@ -4,42 +4,44 @@ import (
"context"
"fmt"
"github.com/antihax/optional"
osccommon "github.com/hashicorp/packer/builder/osc/common"
"github.com/hashicorp/packer/helper/multistep"
"github.com/hashicorp/packer/packer"
"github.com/outscale/osc-go/oapi"
"github.com/outscale/osc-sdk-go/osc"
)
// StepCreateOMI creates the OMI.
type StepCreateOMI struct {
RootVolumeSize int64
RawRegion string
}
func (s *StepCreateOMI) Run(ctx context.Context, state multistep.StateBag) multistep.StepAction {
config := state.Get("config").(*Config)
oapiconn := state.Get("oapi").(*oapi.Client)
osconn := state.Get("osc").(*osc.APIClient)
snapshotId := state.Get("snapshot_id").(string)
ui := state.Get("ui").(packer.Ui)
ui.Say("Creating the OMI...")
var (
registerOpts oapi.CreateImageRequest
mappings []oapi.BlockDeviceMappingImage
image oapi.Image
registerOpts osc.CreateImageRequest
mappings []osc.BlockDeviceMappingImage
image osc.Image
rootDeviceName string
)
if config.FromScratch {
mappings = config.OMIBlockDevices.BuildOMIDevices()
mappings = config.OMIBlockDevices.BuildOscOMIDevices()
rootDeviceName = config.RootDeviceName
} else {
image = state.Get("source_image").(oapi.Image)
image = state.Get("source_image").(osc.Image)
mappings = image.BlockDeviceMappings
rootDeviceName = image.RootDeviceName
}
newMappings := make([]oapi.BlockDeviceMappingImage, len(mappings))
newMappings := make([]osc.BlockDeviceMappingImage, len(mappings))
for i, device := range mappings {
newDevice := device
@ -48,14 +50,14 @@ func (s *StepCreateOMI) Run(ctx context.Context, state multistep.StateBag) multi
newDevice.Bsu.VolumeSize = gibSize
if newDevice.DeviceName == rootDeviceName {
if newDevice.Bsu != (oapi.BsuToCreate{}) {
if newDevice.Bsu != (osc.BsuToCreate{}) {
newDevice.Bsu.SnapshotId = snapshotId
} else {
newDevice.Bsu = oapi.BsuToCreate{SnapshotId: snapshotId}
newDevice.Bsu = osc.BsuToCreate{SnapshotId: snapshotId}
}
if config.FromScratch || s.RootVolumeSize > newDevice.Bsu.VolumeSize {
newDevice.Bsu.VolumeSize = s.RootVolumeSize
if config.FromScratch || int32(s.RootVolumeSize) > newDevice.Bsu.VolumeSize {
newDevice.Bsu.VolumeSize = int32(s.RootVolumeSize)
}
}
@ -63,7 +65,7 @@ func (s *StepCreateOMI) Run(ctx context.Context, state multistep.StateBag) multi
}
if config.FromScratch {
registerOpts = oapi.CreateImageRequest{
registerOpts = osc.CreateImageRequest{
ImageName: config.OMIName,
Architecture: "x86_64",
RootDeviceName: rootDeviceName,
@ -73,23 +75,25 @@ func (s *StepCreateOMI) Run(ctx context.Context, state multistep.StateBag) multi
registerOpts = buildRegisterOpts(config, image, newMappings)
}
registerResp, err := oapiconn.POST_CreateImage(registerOpts)
registerResp, _, err := osconn.ImageApi.CreateImage(context.Background(), &osc.CreateImageOpts{
CreateImageRequest: optional.NewInterface(registerOpts),
})
if err != nil {
state.Put("error", fmt.Errorf("Error registering OMI: %s", err))
ui.Error(state.Get("error").(error).Error())
return multistep.ActionHalt
}
imageID := registerResp.OK.Image.ImageId
imageID := registerResp.Image.ImageId
// Set the OMI ID in the state
ui.Say(fmt.Sprintf("OMI: %s", imageID))
omis := make(map[string]string)
omis[oapiconn.GetConfig().Region] = imageID
omis[s.RawRegion] = imageID
state.Put("omis", omis)
ui.Say("Waiting for OMI to become ready...")
if err := osccommon.WaitUntilImageAvailable(oapiconn, imageID); err != nil {
if err := osccommon.WaitUntilOscImageAvailable(osconn, imageID); err != nil {
err := fmt.Errorf("Error waiting for OMI: %s", err)
state.Put("error", err)
ui.Error(err.Error())
@ -101,8 +105,8 @@ func (s *StepCreateOMI) Run(ctx context.Context, state multistep.StateBag) multi
func (s *StepCreateOMI) Cleanup(state multistep.StateBag) {}
func buildRegisterOpts(config *Config, image oapi.Image, mappings []oapi.BlockDeviceMappingImage) oapi.CreateImageRequest {
registerOpts := oapi.CreateImageRequest{
func buildRegisterOpts(config *Config, image osc.Image, mappings []osc.BlockDeviceMappingImage) osc.CreateImageRequest {
registerOpts := osc.CreateImageRequest{
ImageName: config.OMIName,
Architecture: image.Architecture,
RootDeviceName: image.RootDeviceName,

46
builder/osc/chroot/step_create_volume.go
View File

@ -6,11 +6,12 @@ import (
"fmt"
"log"
"github.com/antihax/optional"
osccommon "github.com/hashicorp/packer/builder/osc/common"
"github.com/hashicorp/packer/helper/multistep"
"github.com/hashicorp/packer/packer"
"github.com/hashicorp/packer/template/interpolate"
"github.com/outscale/osc-go/oapi"
"github.com/outscale/osc-sdk-go/osc"
)
// StepCreateVolume creates a new volume from the snapshot of the root
@ -23,18 +24,19 @@ type StepCreateVolume struct {
RootVolumeSize int64
RootVolumeType string
RootVolumeTags osccommon.TagMap
RawRegion string
Ctx interpolate.Context
}
func (s *StepCreateVolume) Run(ctx context.Context, state multistep.StateBag) multistep.StepAction {
config := state.Get("config").(*Config)
oapiconn := state.Get("oapi").(*oapi.Client)
vm := state.Get("vm").(oapi.Vm)
oscconn := state.Get("osc").(*osc.APIClient)
vm := state.Get("vm").(osc.Vm)
ui := state.Get("ui").(packer.Ui)
var err error
volTags, err := s.RootVolumeTags.OAPITags(s.Ctx, oapiconn.GetConfig().Region, state)
volTags, err := s.RootVolumeTags.OSCTags(s.Ctx, s.RawRegion, state)
if err != nil {
state.Put("error", err)
@ -42,7 +44,7 @@ func (s *StepCreateVolume) Run(ctx context.Context, state multistep.StateBag) mu
return multistep.ActionHalt
}
var createVolume *oapi.CreateVolumeRequest
var createVolume *osc.CreateVolumeRequest
if config.FromScratch {
rootVolumeType := osccommon.VolumeTypeGp2
if s.RootVolumeType == "io1" {
@ -53,17 +55,17 @@ func (s *StepCreateVolume) Run(ctx context.Context, state multistep.StateBag) mu
} else if s.RootVolumeType != "" {
rootVolumeType = s.RootVolumeType
}
createVolume = &oapi.CreateVolumeRequest{
createVolume = &osc.CreateVolumeRequest{
SubregionName: vm.Placement.SubregionName,
Size: s.RootVolumeSize,
Size: int32(s.RootVolumeSize),
VolumeType: rootVolumeType,
}
} else {
// Determine the root device snapshot
image := state.Get("source_image").(oapi.Image)
image := state.Get("source_image").(osc.Image)
log.Printf("Searching for root device of the image (%s)", image.RootDeviceName)
var rootDevice *oapi.BlockDeviceMappingImage
var rootDevice *osc.BlockDeviceMappingImage
for _, device := range image.BlockDeviceMappings {
if device.DeviceName == image.RootDeviceName {
rootDevice = &device
@ -82,7 +84,9 @@ func (s *StepCreateVolume) Run(ctx context.Context, state multistep.StateBag) mu
log.Printf("Create args: %+v", createVolume)
createVolumeResp, err := oapiconn.POST_CreateVolume(*createVolume)
createVolumeResp, _, err := oscconn.VolumeApi.CreateVolume(context.Background(), &osc.CreateVolumeOpts{
CreateVolumeRequest: optional.NewInterface(*createVolume),
})
if err != nil {
err := fmt.Errorf("Error creating root volume: %s", err)
state.Put("error", err)
@ -91,12 +95,12 @@ func (s *StepCreateVolume) Run(ctx context.Context, state multistep.StateBag) mu
}
// Set the volume ID so we remember to delete it later
s.volumeId = createVolumeResp.OK.Volume.VolumeId
s.volumeId = createVolumeResp.Volume.VolumeId
log.Printf("Volume ID: %s", s.volumeId)
//Create tags for volume
if len(volTags) > 0 {
if err := osccommon.CreateTags(oapiconn, s.volumeId, ui, volTags); err != nil {
if err := osccommon.CreateOSCTags(oscconn, s.volumeId, ui, volTags); err != nil {
err := fmt.Errorf("Error creating tags for volume: %s", err)
state.Put("error", err)
ui.Error(err.Error())
@ -105,7 +109,7 @@ func (s *StepCreateVolume) Run(ctx context.Context, state multistep.StateBag) mu
}
// Wait for the volume to become ready
err = osccommon.WaitUntilVolumeAvailable(oapiconn, s.volumeId)
err = osccommon.WaitUntilOscVolumeAvailable(oscconn, s.volumeId)
if err != nil {
err := fmt.Errorf("Error waiting for volume: %s", err)
state.Put("error", err)
@ -122,32 +126,34 @@ func (s *StepCreateVolume) Cleanup(state multistep.StateBag) {
return
}
oapiconn := state.Get("oapi").(*oapi.Client)
oscconn := state.Get("osc").(*osc.APIClient)
ui := state.Get("ui").(packer.Ui)
ui.Say("Deleting the created BSU volume...")
_, err := oapiconn.POST_DeleteVolume(oapi.DeleteVolumeRequest{VolumeId: s.volumeId})
_, _, err := oscconn.VolumeApi.DeleteVolume(context.Background(), &osc.DeleteVolumeOpts{
DeleteVolumeRequest: optional.NewInterface(osc.DeleteVolumeRequest{VolumeId: s.volumeId}),
})
if err != nil {
ui.Error(fmt.Sprintf("Error deleting BSU volume: %s", err))
}
}
func (s *StepCreateVolume) buildCreateVolumeInput(suregionName string, rootDevice *oapi.BlockDeviceMappingImage) (*oapi.CreateVolumeRequest, error) {
func (s *StepCreateVolume) buildCreateVolumeInput(suregionName string, rootDevice *osc.BlockDeviceMappingImage) (*osc.CreateVolumeRequest, error) {
if rootDevice == nil {
return nil, fmt.Errorf("Couldn't find root device!")
return nil, fmt.Errorf("Couldn't find root device")
}
//FIX: Temporary fix
gibSize := rootDevice.Bsu.VolumeSize / (1024 * 1024 * 1024)
createVolumeInput := &oapi.CreateVolumeRequest{
createVolumeInput := &osc.CreateVolumeRequest{
SubregionName: suregionName,
Size: gibSize,
SnapshotId: rootDevice.Bsu.SnapshotId,
VolumeType: rootDevice.Bsu.VolumeType,
Iops: rootDevice.Bsu.Iops,
}
if s.RootVolumeSize > rootDevice.Bsu.VolumeSize {
createVolumeInput.Size = s.RootVolumeSize
if int32(s.RootVolumeSize) > rootDevice.Bsu.VolumeSize {
createVolumeInput.Size = int32(s.RootVolumeSize)
}
if s.RootVolumeType == "" || s.RootVolumeType == rootDevice.Bsu.VolumeType {

28
builder/osc/chroot/step_link_volume.go
View File

@ -4,10 +4,11 @@ import (
"context"
"fmt"
"github.com/antihax/optional"
osccommon "github.com/hashicorp/packer/builder/osc/common"
"github.com/hashicorp/packer/helper/multistep"
"github.com/hashicorp/packer/packer"
"github.com/outscale/osc-go/oapi"
"github.com/outscale/osc-sdk-go/osc"
)
// StepLinkVolume attaches the previously created volume to an
@ -22,9 +23,9 @@ type StepLinkVolume struct {
}
func (s *StepLinkVolume) Run(ctx context.Context, state multistep.StateBag) multistep.StepAction {
oapiconn := state.Get("oapi").(*oapi.Client)
oscconn := state.Get("osc").(*osc.APIClient)
device := state.Get("device").(string)
vm := state.Get("vm").(oapi.Vm)
vm := state.Get("vm").(osc.Vm)
ui := state.Get("ui").(packer.Ui)
volumeId := state.Get("volume_id").(string)
@ -33,10 +34,12 @@ func (s *StepLinkVolume) Run(ctx context.Context, state multistep.StateBag) mult
linkVolume := device
ui.Say(fmt.Sprintf("Attaching the root volume to %s", linkVolume))
_, err := oapiconn.POST_LinkVolume(oapi.LinkVolumeRequest{
VmId: vm.VmId,
VolumeId: volumeId,
DeviceName: linkVolume,
_, _, err := oscconn.VolumeApi.LinkVolume(context.Background(), &osc.LinkVolumeOpts{
LinkVolumeRequest: optional.NewInterface(osc.LinkVolumeRequest{
VmId: vm.VmId,
VolumeId: volumeId,
DeviceName: linkVolume,
}),
})
if err != nil {
@ -51,7 +54,7 @@ func (s *StepLinkVolume) Run(ctx context.Context, state multistep.StateBag) mult
s.volumeId = volumeId
// Wait for the volume to become attached
err = osccommon.WaitUntilVolumeIsLinked(oapiconn, s.volumeId)
err = osccommon.WaitUntilOscVolumeIsLinked(oscconn, s.volumeId)
if err != nil {
err := fmt.Errorf("Error waiting for volume: %s", err)
state.Put("error", err)
@ -75,11 +78,14 @@ func (s *StepLinkVolume) CleanupFunc(state multistep.StateBag) error {
return nil
}
oapiconn := state.Get("oapi").(*oapi.Client)
oscconn := state.Get("osc").(*osc.APIClient)
ui := state.Get("ui").(packer.Ui)
ui.Say("Detaching BSU volume...")
_, err := oapiconn.POST_UnlinkVolume(oapi.UnlinkVolumeRequest{VolumeId: s.volumeId})
_, _, err := oscconn.VolumeApi.UnlinkVolume(context.Background(), &osc.UnlinkVolumeOpts{
UnlinkVolumeRequest: optional.NewInterface(osc.UnlinkVolumeRequest{VolumeId: s.volumeId}),
})
if err != nil {
return fmt.Errorf("Error detaching BSU volume: %s", err)
}
@ -87,7 +93,7 @@ func (s *StepLinkVolume) CleanupFunc(state multistep.StateBag) error {
s.attached = false
// Wait for the volume to detach
err = osccommon.WaitUntilVolumeIsUnlinked(oapiconn, s.volumeId)
err = osccommon.WaitUntilOscVolumeIsUnlinked(oscconn, s.volumeId)
if err != nil {
return fmt.Errorf("Error waiting for volume: %s", err)
}

26
builder/osc/chroot/step_snapshot.go
View File

@ -5,10 +5,11 @@ import (
"fmt"
"time"
"github.com/antihax/optional"
osccommon "github.com/hashicorp/packer/builder/osc/common"
"github.com/hashicorp/packer/helper/multistep"
"github.com/hashicorp/packer/packer"
"github.com/outscale/osc-go/oapi"
"github.com/outscale/osc-sdk-go/osc"
)
// StepSnapshot creates a snapshot of the created volume.
@ -17,19 +18,22 @@ import (
// snapshot_id string - ID of the created snapshot
type StepSnapshot struct {
snapshotId string
RawRegion string
}
func (s *StepSnapshot) Run(ctx context.Context, state multistep.StateBag) multistep.StepAction {
oapiconn := state.Get("oapi").(*oapi.Client)
oscconn := state.Get("osc").(*osc.APIClient)
ui := state.Get("ui").(packer.Ui)
volumeId := state.Get("volume_id").(string)
ui.Say("Creating snapshot...")
description := fmt.Sprintf("Packer: %s", time.Now().String())
createSnapResp, err := oapiconn.POST_CreateSnapshot(oapi.CreateSnapshotRequest{
VolumeId: volumeId,
Description: description,
createSnapResp, _, err := oscconn.SnapshotApi.CreateSnapshot(context.Background(), &osc.CreateSnapshotOpts{
CreateSnapshotRequest: optional.NewInterface(osc.CreateSnapshotRequest{
VolumeId: volumeId,
Description: description,
}),
})
if err != nil {
err := fmt.Errorf("Error creating snapshot: %s", err)
@ -39,11 +43,11 @@ func (s *StepSnapshot) Run(ctx context.Context, state multistep.StateBag) multis
}
// Set the snapshot ID so we can delete it later
s.snapshotId = createSnapResp.OK.Snapshot.SnapshotId
s.snapshotId = createSnapResp.Snapshot.SnapshotId
ui.Message(fmt.Sprintf("Snapshot ID: %s", s.snapshotId))
// Wait for the snapshot to be ready
err = osccommon.WaitUntilSnapshotDone(oapiconn, s.snapshotId)
err = osccommon.WaitUntilOscSnapshotDone(oscconn, s.snapshotId)
if err != nil {
err := fmt.Errorf("Error waiting for snapshot: %s", err)
state.Put("error", err)
@ -54,7 +58,7 @@ func (s *StepSnapshot) Run(ctx context.Context, state multistep.StateBag) multis
state.Put("snapshot_id", s.snapshotId)
snapshots := map[string][]string{
oapiconn.GetConfig().Region: {s.snapshotId},
s.RawRegion: {s.snapshotId},
}
state.Put("snapshots", snapshots)
@ -70,10 +74,12 @@ func (s *StepSnapshot) Cleanup(state multistep.StateBag) {
_, halted := state.GetOk(multistep.StateHalted)
if cancelled || halted {
oapiconn := state.Get("oapi").(*oapi.Client)
oscconn := state.Get("osc").(*osc.APIClient)
ui := state.Get("ui").(packer.Ui)
ui.Say("Removing snapshot since we cancelled or halted...")
_, err := oapiconn.POST_DeleteSnapshot(oapi.DeleteSnapshotRequest{SnapshotId: s.snapshotId})
_, _, err := oscconn.SnapshotApi.DeleteSnapshot(context.Background(), &osc.DeleteSnapshotOpts{
DeleteSnapshotRequest: optional.NewInterface(osc.DeleteSnapshotRequest{SnapshotId: s.snapshotId}),
})
if err != nil {
ui.Error(fmt.Sprintf("Error: %s", err))
}

17
builder/osc/chroot/step_vm_info.go
View File

@ -5,16 +5,17 @@ import (
"fmt"
"log"
"github.com/antihax/optional"
"github.com/hashicorp/packer/helper/multistep"
"github.com/hashicorp/packer/packer"
"github.com/outscale/osc-go/oapi"
"github.com/outscale/osc-sdk-go/osc"
)
// StepVmInfo verifies that this builder is running on an Outscale vm.
type StepVmInfo struct{}
func (s *StepVmInfo) Run(_ context.Context, state multistep.StateBag) multistep.StepAction {
oapiconn := state.Get("oapi").(*oapi.Client)
oscconn := state.Get("osc").(*osc.APIClient)
//session := state.Get("clientConfig").(*session.Session)
ui := state.Get("ui").(packer.Ui)
@ -36,9 +37,11 @@ func (s *StepVmInfo) Run(_ context.Context, state multistep.StateBag) multistep.
log.Printf("[Debug] VmID got: %s", string(vmID))
// Query the entire vm metadata
resp, err := oapiconn.POST_ReadVms(oapi.ReadVmsRequest{Filters: oapi.FiltersVm{
VmIds: []string{string(vmID)},
}})
resp, _, err := oscconn.VmApi.ReadVms(context.Background(), &osc.ReadVmsOpts{
ReadVmsRequest: optional.NewInterface(osc.ReadVmsRequest{Filters: osc.FiltersVm{
VmIds: []string{string(vmID)},
}}),
})
if err != nil {
err := fmt.Errorf("Error getting vm data: %s", err)
state.Put("error", err)
@ -46,10 +49,10 @@ func (s *StepVmInfo) Run(_ context.Context, state multistep.StateBag) multistep.
return multistep.ActionHalt
}
vmsResp := resp.OK
vmsResp := resp
if len(vmsResp.Vms) == 0 {
err := fmt.Errorf("Error getting vm data: no vm found.")
err := fmt.Errorf("Error getting vm data: no vm found")
state.Put("error", err)
ui.Error(err.Error())
return multistep.ActionHalt

52
builder/osc/common/access_config.go
View File

@ -8,7 +8,7 @@ import (
"os"
"github.com/hashicorp/packer/template/interpolate"
"github.com/outscale/osc-go/oapi"
"github.com/outscale/osc-sdk-go/osc"
)
// AccessConfig is for common configuration related to Outscale API access
@ -23,20 +23,10 @@ type AccessConfig struct {
SkipValidation bool `mapstructure:"skip_region_validation"`
SkipMetadataApiCheck bool `mapstructure:"skip_metadata_api_check"`
Token string `mapstructure:"token"`
clientConfig *oapi.Config
getOAPIConnection func() oapi.OAPIClient
}
// Config returns a valid oapi.Config object for access to Outscale services, or
// an error if the authentication and region couldn't be resolved
func (c *AccessConfig) Config() (*oapi.Config, error) {
if c.clientConfig != nil {
return c.clientConfig, nil
}
//Check env variables if access configuration is not set.
// NewOSCClient retrieves the Outscale OSC-SDK client
func (c *AccessConfig) NewOSCClient() *osc.APIClient {
if c.AccessKey == "" {
c.AccessKey = os.Getenv("OUTSCALE_ACCESSKEYID")
}
@ -57,36 +47,32 @@ func (c *AccessConfig) Config() (*oapi.Config, error) {
c.CustomEndpointOAPI = "outscale.com/oapi/latest"
}
config := &oapi.Config{
AccessKey: c.AccessKey,
SecretKey: c.SecretKey,
Region: c.RawRegion,
URL: c.CustomEndpointOAPI,
Service: "api",
}
return config, nil
return c.NewOSCClientByRegion(c.RawRegion)
}
func (c *AccessConfig) NewOAPIConnection() (oapi.OAPIClient, error) {
if c.getOAPIConnection != nil {
return c.getOAPIConnection(), nil
}
oapicfg, err := c.Config()
if err != nil {
return nil, err
}
// GetRegion retrieves the Outscale OSC-SDK Region set
func (c *AccessConfig) GetRegion() string {
return c.RawRegion
}
// NewOSCClientByRegion returns the connection depdending of the region given
func (c *AccessConfig) NewOSCClientByRegion(region string) *osc.APIClient {
skipClient := &http.Client{
Transport: &http.Transport{
TLSClientConfig: &tls.Config{InsecureSkipVerify: c.InsecureSkipTLSVerify},
Proxy: http.ProxyFromEnvironment,
},
}
oapiClient := oapi.NewClient(oapicfg, skipClient)
skipClient.Transport = NewTransport(c.AccessKey, c.SecretKey, c.RawRegion, skipClient.Transport)
return oapiClient, nil
return osc.NewAPIClient(&osc.Configuration{
BasePath: fmt.Sprintf("https://api.%s.%s", region, c.CustomEndpointOAPI),
DefaultHeader: make(map[string]string),
UserAgent: "packer-osc",
HTTPClient: skipClient,
Debug: true,
})
}
func (c *AccessConfig) Prepare(ctx *interpolate.Context) []error {

33
builder/osc/common/access_config_test.go
View File

@ -2,50 +2,29 @@ package common
import (
"testing"
"github.com/outscale/osc-go/oapi"
)
type mockOAPIClient struct {
oapi.OAPIClient
}
func testAccessConfig() *AccessConfig {
return &AccessConfig{
getOAPIConnection: func() oapi.OAPIClient {
return &mockOAPIClient{}
},
}
}
func (m *mockOAPIClient) POST_ReadRegions(oapi.ReadRegionsRequest) (*oapi.POST_ReadRegionsResponses, error) {
return &oapi.POST_ReadRegionsResponses{
OK: &oapi.ReadRegionsResponse{
Regions: []oapi.Region{
{RegionEndpoint: "us-west1", RegionName: "us-west1"},
{RegionEndpoint: "us-east-1", RegionName: "us-east-1"},
},
},
}, nil
return &AccessConfig{}
}
func TestAccessConfigPrepare_Region(t *testing.T) {
c := testAccessConfig()
c.RawRegion = "us-east-12"
err := c.ValidateRegion(c.RawRegion)
err := c.ValidateOSCRegion(c.RawRegion)
if err == nil {
t.Fatalf("should have region validation err: %s", c.RawRegion)
}
c.RawRegion = "us-east-1"
err = c.ValidateRegion(c.RawRegion)
if err != nil {
t.Fatalf("shouldn't have region validation err: %s", c.RawRegion)
err = c.ValidateOSCRegion(c.RawRegion)
if err == nil {
t.Fatalf("should have region validation err: %s", c.RawRegion)
}
c.RawRegion = "custom"
err = c.ValidateRegion(c.RawRegion)
err = c.ValidateOSCRegion(c.RawRegion)
if err == nil {
t.Fatalf("should have region validation err: %s", c.RawRegion)
}

48
builder/osc/common/artifact.go
View File

@ -1,15 +1,15 @@
package common
import (
"crypto/tls"
"context"
"fmt"
"log"
"net/http"
"sort"
"strings"
"github.com/antihax/optional"
"github.com/hashicorp/packer/packer"
"github.com/outscale/osc-go/oapi"
"github.com/outscale/osc-sdk-go/osc"
)
// Artifact is an artifact implementation that contains built OMIs.
@ -20,9 +20,6 @@ type Artifact struct {
// BuilderId is the unique ID for the builder that created this OMI
BuilderIdValue string
// OAPI connection for performing API stuff.
Config *oapi.Config
// StateData should store data such as GeneratedData
// to be shared with post-processors
StateData map[string]interface{}
@ -74,47 +71,36 @@ func (a *Artifact) State(name string) interface{} {
func (a *Artifact) Destroy() error {
errors := make([]error, 0)
config := a.State("accessConfig").(*AccessConfig)
for region, imageId := range a.Omis {
log.Printf("Deregistering image ID (%s) from region (%s)", imageId, region)
newConfig := &oapi.Config{
UserAgent: a.Config.UserAgent,
AccessKey: a.Config.AccessKey,
SecretKey: a.Config.SecretKey,
Service: a.Config.Service,
Region: region, //New region
URL: a.Config.URL,
}
log.Printf("[DEBUG] New Client config %+v", newConfig)
skipClient := &http.Client{
Transport: &http.Transport{
TLSClientConfig: &tls.Config{InsecureSkipVerify: true},
},
}
regionConn := oapi.NewClient(newConfig, skipClient)
regionConn := config.NewOSCClientByRegion(region)
// Get image metadata
imageResp, err := regionConn.POST_ReadImages(oapi.ReadImagesRequest{
Filters: oapi.FiltersImage{
ImageIds: []string{imageId},
},
imageResp, _, err := regionConn.ImageApi.ReadImages(context.Background(), &osc.ReadImagesOpts{
ReadImagesRequest: optional.NewInterface(osc.ReadImagesRequest{
Filters: osc.FiltersImage{
ImageIds: []string{imageId},
},
}),
})
if err != nil {
errors = append(errors, err)
}
if len(imageResp.OK.Images) == 0 {
if len(imageResp.Images) == 0 {
err := fmt.Errorf("Error retrieving details for OMI (%s), no images found", imageId)
errors = append(errors, err)
}
// Deregister ami
input := oapi.DeleteImageRequest{
input := osc.DeleteImageRequest{
ImageId: imageId,
}
if _, err := regionConn.POST_DeleteImage(input); err != nil {
if _, _, err := regionConn.ImageApi.DeleteImage(context.Background(), &osc.DeleteImageOpts{
DeleteImageRequest: optional.NewInterface(input),
}); err != nil {
errors = append(errors, err)
}

39
builder/osc/common/block_device.go
View File

@ -5,9 +5,8 @@ import (
"log"
"strings"
"github.com/aws/aws-sdk-go/aws"
"github.com/hashicorp/packer/template/interpolate"
"github.com/outscale/osc-go/oapi"
"github.com/outscale/osc-sdk-go/osc"
)
// BlockDevice
@ -35,11 +34,11 @@ type LaunchBlockDevices struct {
LaunchMappings []BlockDevice `mapstructure:"launch_block_device_mappings"`
}
func buildBlockDevicesImage(b []BlockDevice) []oapi.BlockDeviceMappingImage {
var blockDevices []oapi.BlockDeviceMappingImage
func buildOscBlockDevicesImage(b []BlockDevice) []osc.BlockDeviceMappingImage {
var blockDevices []osc.BlockDeviceMappingImage
for _, blockDevice := range b {
mapping := oapi.BlockDeviceMappingImage{
mapping := osc.BlockDeviceMappingImage{
DeviceName: blockDevice.DeviceName,
}
@ -48,8 +47,8 @@ func buildBlockDevicesImage(b []BlockDevice) []oapi.BlockDeviceMappingImage {
mapping.VirtualDeviceName = blockDevice.VirtualName
}
} else {
bsu := oapi.BsuToCreate{
DeleteOnVmDeletion: aws.Bool(blockDevice.DeleteOnVmDeletion),
bsu := osc.BsuToCreate{
DeleteOnVmDeletion: blockDevice.DeleteOnVmDeletion,
}
if blockDevice.VolumeType != "" {
@ -57,12 +56,12 @@ func buildBlockDevicesImage(b []BlockDevice) []oapi.BlockDeviceMappingImage {
}
if blockDevice.VolumeSize > 0 {
bsu.VolumeSize = blockDevice.VolumeSize
bsu.VolumeSize = int32(blockDevice.VolumeSize)
}
// IOPS is only valid for io1 type
if blockDevice.VolumeType == "io1" {
bsu.Iops = blockDevice.IOPS
bsu.Iops = int32(blockDevice.IOPS)
}
if blockDevice.SnapshotId != "" {
@ -77,13 +76,13 @@ func buildBlockDevicesImage(b []BlockDevice) []oapi.BlockDeviceMappingImage {
return blockDevices
}
func buildBlockDevicesVmCreation(b []BlockDevice) []oapi.BlockDeviceMappingVmCreation {
func buildOscBlockDevicesVmCreation(b []BlockDevice) []osc.BlockDeviceMappingVmCreation {
log.Printf("[DEBUG] Launch Block Device %#v", b)
var blockDevices []oapi.BlockDeviceMappingVmCreation
var blockDevices []osc.BlockDeviceMappingVmCreation
for _, blockDevice := range b {
mapping := oapi.BlockDeviceMappingVmCreation{
mapping := osc.BlockDeviceMappingVmCreation{
DeviceName: blockDevice.DeviceName,
}
@ -94,8 +93,8 @@ func buildBlockDevicesVmCreation(b []BlockDevice) []oapi.BlockDeviceMappingVmCre
mapping.VirtualDeviceName = blockDevice.VirtualName
}
} else {
bsu := oapi.BsuToCreate{
DeleteOnVmDeletion: aws.Bool(blockDevice.DeleteOnVmDeletion),
bsu := osc.BsuToCreate{
DeleteOnVmDeletion: blockDevice.DeleteOnVmDeletion,
}
if blockDevice.VolumeType != "" {
@ -103,12 +102,12 @@ func buildBlockDevicesVmCreation(b []BlockDevice) []oapi.BlockDeviceMappingVmCre
}
if blockDevice.VolumeSize > 0 {
bsu.VolumeSize = blockDevice.VolumeSize
bsu.VolumeSize = int32(blockDevice.VolumeSize)
}
// IOPS is only valid for io1 type
if blockDevice.VolumeType == "io1" {
bsu.Iops = blockDevice.IOPS
bsu.Iops = int32(blockDevice.IOPS)
}
if blockDevice.SnapshotId != "" {
@ -145,10 +144,10 @@ func (b *BlockDevices) Prepare(ctx *interpolate.Context) (errs []error) {
return errs
}
func (b *OMIBlockDevices) BuildOMIDevices() []oapi.BlockDeviceMappingImage {
return buildBlockDevicesImage(b.OMIMappings)
func (b *OMIBlockDevices) BuildOscOMIDevices() []osc.BlockDeviceMappingImage {
return buildOscBlockDevicesImage(b.OMIMappings)
}
func (b *LaunchBlockDevices) BuildLaunchDevices() []oapi.BlockDeviceMappingVmCreation {
return buildBlockDevicesVmCreation(b.LaunchMappings)
func (b *LaunchBlockDevices) BuildOSCLaunchDevices() []osc.BlockDeviceMappingVmCreation {
return buildOscBlockDevicesVmCreation(b.LaunchMappings)
}

115
builder/osc/common/block_device_test.go
View File

@ -4,19 +4,13 @@ import (
"reflect"
"testing"
"github.com/outscale/osc-go/oapi"
"github.com/outscale/osc-sdk-go/osc"
)
func TestBlockDevice_LaunchDevices(t *testing.T) {
tr := new(bool)
f := new(bool)
*tr = true
*f = false
cases := []struct {
Config *BlockDevice
Result oapi.BlockDeviceMappingVmCreation
Result osc.BlockDeviceMappingVmCreation
}{
{
Config: &BlockDevice{
@ -27,13 +21,13 @@ func TestBlockDevice_LaunchDevices(t *testing.T) {
DeleteOnVmDeletion: true,
},
Result: oapi.BlockDeviceMappingVmCreation{
Result: osc.BlockDeviceMappingVmCreation{
DeviceName: "/dev/sdb",
Bsu: oapi.BsuToCreate{
Bsu: osc.BsuToCreate{
SnapshotId: "snap-1234",
VolumeType: "standard",
VolumeSize: 8,
DeleteOnVmDeletion: tr,
DeleteOnVmDeletion: true,
},
},
},
@ -43,11 +37,11 @@ func TestBlockDevice_LaunchDevices(t *testing.T) {
VolumeSize: 8,
},
Result: oapi.BlockDeviceMappingVmCreation{
Result: osc.BlockDeviceMappingVmCreation{
DeviceName: "/dev/sdb",
Bsu: oapi.BsuToCreate{
Bsu: osc.BsuToCreate{
VolumeSize: 8,
DeleteOnVmDeletion: f,
DeleteOnVmDeletion: false,
},
},
},
@ -60,12 +54,12 @@ func TestBlockDevice_LaunchDevices(t *testing.T) {
IOPS: 1000,
},
Result: oapi.BlockDeviceMappingVmCreation{
Result: osc.BlockDeviceMappingVmCreation{
DeviceName: "/dev/sdb",
Bsu: oapi.BsuToCreate{
Bsu: osc.BsuToCreate{
VolumeType: "io1",
VolumeSize: 8,
DeleteOnVmDeletion: tr,
DeleteOnVmDeletion: true,
Iops: 1000,
},
},
@ -78,12 +72,12 @@ func TestBlockDevice_LaunchDevices(t *testing.T) {
DeleteOnVmDeletion: true,
},
Result: oapi.BlockDeviceMappingVmCreation{
Result: osc.BlockDeviceMappingVmCreation{
DeviceName: "/dev/sdb",
Bsu: oapi.BsuToCreate{
Bsu: osc.BsuToCreate{
VolumeType: "gp2",
VolumeSize: 8,
DeleteOnVmDeletion: tr,
DeleteOnVmDeletion: true,
},
},
},
@ -95,12 +89,12 @@ func TestBlockDevice_LaunchDevices(t *testing.T) {
DeleteOnVmDeletion: true,
},
Result: oapi.BlockDeviceMappingVmCreation{
Result: osc.BlockDeviceMappingVmCreation{
DeviceName: "/dev/sdb",
Bsu: oapi.BsuToCreate{
Bsu: osc.BsuToCreate{
VolumeType: "gp2",
VolumeSize: 8,
DeleteOnVmDeletion: tr,
DeleteOnVmDeletion: true,
},
},
},
@ -111,11 +105,11 @@ func TestBlockDevice_LaunchDevices(t *testing.T) {
DeleteOnVmDeletion: true,
},
Result: oapi.BlockDeviceMappingVmCreation{
Result: osc.BlockDeviceMappingVmCreation{
DeviceName: "/dev/sdb",
Bsu: oapi.BsuToCreate{
Bsu: osc.BsuToCreate{
VolumeType: "standard",
DeleteOnVmDeletion: tr,
DeleteOnVmDeletion: true,
},
},
},
@ -125,7 +119,7 @@ func TestBlockDevice_LaunchDevices(t *testing.T) {
VirtualName: "ephemeral0",
},
Result: oapi.BlockDeviceMappingVmCreation{
Result: osc.BlockDeviceMappingVmCreation{
DeviceName: "/dev/sdb",
VirtualDeviceName: "ephemeral0",
},
@ -136,7 +130,7 @@ func TestBlockDevice_LaunchDevices(t *testing.T) {
NoDevice: true,
},
Result: oapi.BlockDeviceMappingVmCreation{
Result: osc.BlockDeviceMappingVmCreation{
DeviceName: "/dev/sdb",
NoDevice: "",
},
@ -149,9 +143,9 @@ func TestBlockDevice_LaunchDevices(t *testing.T) {
LaunchMappings: []BlockDevice{*tc.Config},
}
expected := []oapi.BlockDeviceMappingVmCreation{tc.Result}
expected := []osc.BlockDeviceMappingVmCreation{tc.Result}
launchResults := launchBlockDevices.BuildLaunchDevices()
launchResults := launchBlockDevices.BuildOSCLaunchDevices()
if !reflect.DeepEqual(expected, launchResults) {
t.Fatalf("Bad block device, \nexpected: %#v\n\ngot: %#v",
expected, launchResults)
@ -160,15 +154,9 @@ func TestBlockDevice_LaunchDevices(t *testing.T) {
}
func TestBlockDevice_OMI(t *testing.T) {
tr := new(bool)
f := new(bool)
*tr = true
*f = false
cases := []struct {
Config *BlockDevice
Result oapi.BlockDeviceMappingImage
Result osc.BlockDeviceMappingImage
}{
{
Config: &BlockDevice{
@ -179,27 +167,28 @@ func TestBlockDevice_OMI(t *testing.T) {
DeleteOnVmDeletion: true,
},
Result: oapi.BlockDeviceMappingImage{
Result: osc.BlockDeviceMappingImage{
DeviceName: "/dev/sdb",
Bsu: oapi.BsuToCreate{
Bsu: osc.BsuToCreate{
SnapshotId: "snap-1234",
VolumeType: "standard",
VolumeSize: 8,
DeleteOnVmDeletion: tr,
DeleteOnVmDeletion: true,
},
},
},
{
Config: &BlockDevice{
DeviceName: "/dev/sdb",
VolumeSize: 8,
DeviceName: "/dev/sdb",
VolumeSize: 8,
DeleteOnVmDeletion: true,
},
Result: oapi.BlockDeviceMappingImage{
Result: osc.BlockDeviceMappingImage{
DeviceName: "/dev/sdb",
Bsu: oapi.BsuToCreate{
Bsu: osc.BsuToCreate{
VolumeSize: 8,
DeleteOnVmDeletion: f,
DeleteOnVmDeletion: true,
},
},
},
@ -212,12 +201,12 @@ func TestBlockDevice_OMI(t *testing.T) {
IOPS: 1000,
},
Result: oapi.BlockDeviceMappingImage{
Result: osc.BlockDeviceMappingImage{
DeviceName: "/dev/sdb",
Bsu: oapi.BsuToCreate{
Bsu: osc.BsuToCreate{
VolumeType: "io1",
VolumeSize: 8,
DeleteOnVmDeletion: tr,
DeleteOnVmDeletion: true,
Iops: 1000,
},
},
@ -230,12 +219,12 @@ func TestBlockDevice_OMI(t *testing.T) {
DeleteOnVmDeletion: true,
},
Result: oapi.BlockDeviceMappingImage{
Result: osc.BlockDeviceMappingImage{
DeviceName: "/dev/sdb",
Bsu: oapi.BsuToCreate{
Bsu: osc.BsuToCreate{
VolumeType: "gp2",
VolumeSize: 8,
DeleteOnVmDeletion: tr,
DeleteOnVmDeletion: true,
},
},
},
@ -247,12 +236,12 @@ func TestBlockDevice_OMI(t *testing.T) {
DeleteOnVmDeletion: true,
},
Result: oapi.BlockDeviceMappingImage{
Result: osc.BlockDeviceMappingImage{
DeviceName: "/dev/sdb",
Bsu: oapi.BsuToCreate{
Bsu: osc.BsuToCreate{
VolumeType: "gp2",
VolumeSize: 8,
DeleteOnVmDeletion: tr,
DeleteOnVmDeletion: true,
},
},
},
@ -263,11 +252,11 @@ func TestBlockDevice_OMI(t *testing.T) {
DeleteOnVmDeletion: true,
},
Result: oapi.BlockDeviceMappingImage{
Result: osc.BlockDeviceMappingImage{
DeviceName: "/dev/sdb",
Bsu: oapi.BsuToCreate{
Bsu: osc.BsuToCreate{
VolumeType: "standard",
DeleteOnVmDeletion: tr,
DeleteOnVmDeletion: true,
},
},
},
@ -277,24 +266,24 @@ func TestBlockDevice_OMI(t *testing.T) {
VirtualName: "ephemeral0",
},
Result: oapi.BlockDeviceMappingImage{
Result: osc.BlockDeviceMappingImage{
DeviceName: "/dev/sdb",
VirtualDeviceName: "ephemeral0",
},
},
}
for _, tc := range cases {
for i, tc := range cases {
omiBlockDevices := OMIBlockDevices{
OMIMappings: []BlockDevice{*tc.Config},
}
expected := []oapi.BlockDeviceMappingImage{tc.Result}
expected := []osc.BlockDeviceMappingImage{tc.Result}
omiResults := omiBlockDevices.BuildOMIDevices()
omiResults := omiBlockDevices.BuildOscOMIDevices()
if !reflect.DeepEqual(expected, omiResults) {
t.Fatalf("Bad block device, \nexpected: %+#v\n\ngot: %+#v",
expected, omiResults)
t.Fatalf("%d - Bad block device, \nexpected: %+#v\n\ngot: %+#v",
i, expected, omiResults)
}
}
}

89
builder/osc/common/build_filters.go
View File

@ -4,11 +4,11 @@ import (
"log"
"strconv"
"github.com/outscale/osc-go/oapi"
"github.com/outscale/osc-sdk-go/osc"
)
func buildNetFilters(input map[string]string) oapi.FiltersNet {
var filters oapi.FiltersNet
func buildOscNetFilters(input map[string]string) osc.FiltersNet {
var filters osc.FiltersNet
for k, v := range input {
filterValue := []string{v}
switch name := k; name {
@ -33,14 +33,14 @@ func buildNetFilters(input map[string]string) oapi.FiltersNet {
return filters
}
func buildSubnetFilters(input map[string]string) oapi.FiltersSubnet {
var filters oapi.FiltersSubnet
func buildOscSubnetFilters(input map[string]string) osc.FiltersSubnet {
var filters osc.FiltersSubnet
for k, v := range input {
filterValue := []string{v}
switch name := k; name {
case "available-ips-counts":
if ipCount, err := strconv.Atoi(v); err == nil {
filters.AvailableIpsCounts = []int64{int64(ipCount)}
filters.AvailableIpsCounts = []int32{int32(ipCount)}
}
case "ip-ranges":
filters.IpRanges = filterValue
@ -59,8 +59,8 @@ func buildSubnetFilters(input map[string]string) oapi.FiltersSubnet {
return filters
}
func buildOMIFilters(input map[string]string) oapi.FiltersImage {
var filters oapi.FiltersImage
func buildOSCOMIFilters(input map[string]string) osc.FiltersImage {
var filters osc.FiltersImage
for k, v := range input {
filterValue := []string{v}
@ -75,14 +75,14 @@ func buildOMIFilters(input map[string]string) oapi.FiltersImage {
filters.ImageIds = filterValue
case "image-name":
filters.ImageNames = filterValue
case "image-type":
filters.ImageTypes = filterValue
// case "image-type":
// filters.ImageTypes = filterValue
case "virtualization-type":
filters.VirtualizationTypes = filterValue
case "root-device-type":
filters.RootDeviceTypes = filterValue
case "block-device-mapping-volume-type":
filters.BlockDeviceMappingVolumeType = filterValue
// case "block-device-mapping-volume-type":
// filters.BlockDeviceMappingVolumeType = filterValue
//Some params are missing.
default:
log.Printf("[WARN] Unknown Filter Name: %s.", name)
@ -90,68 +90,3 @@ func buildOMIFilters(input map[string]string) oapi.FiltersImage {
}
return filters
}
func buildSecurityGroupFilters(input map[string]string) oapi.FiltersSecurityGroup {
var filters oapi.FiltersSecurityGroup
for k, v := range input {
filterValue := []string{v}
switch name := k; name {
case "account-ids":
filters.AccountIds = filterValue
case "descriptions":
filters.Descriptions = filterValue
case "inbound-rule-account-ids":
filters.InboundRuleAccountIds = filterValue
case "inbound-rule-from-port-ranges":
if val, err := strconv.Atoi(v); err == nil {
filters.InboundRuleFromPortRanges = []int64{int64(val)}
}
case "inbound-rule-ip-ranges":
filters.InboundRuleIpRanges = filterValue
case "inbound-rule-protocols":
filters.InboundRuleProtocols = filterValue
case "inbound-rule-security-group-ids":
filters.InboundRuleSecurityGroupIds = filterValue
case "inbound-rule-security-group-names":
filters.InboundRuleSecurityGroupNames = filterValue
case "inbound-rule-to-port-ranges":
if val, err := strconv.Atoi(v); err == nil {
filters.InboundRuleToPortRanges = []int64{int64(val)}
}
case "net-ids":
filters.NetIds = filterValue
case "outbound-rule-account-ids":
filters.OutboundRuleAccountIds = filterValue
case "outbound-rule-from-port-ranges":
if val, err := strconv.Atoi(v); err == nil {
filters.OutboundRuleFromPortRanges = []int64{int64(val)}
}
case "outbound-rule-ip-ranges":
filters.OutboundRuleIpRanges = filterValue
case "outbound-rule-protocols":
filters.OutboundRuleProtocols = filterValue
case "outbound-rule-security-group-ids":
filters.OutboundRuleSecurityGroupIds = filterValue
case "outbound-rule-security-group-names":
filters.OutboundRuleSecurityGroupNames = filterValue
case "outbound-rule-to-port-ranges":
if val, err := strconv.Atoi(v); err == nil {
filters.OutboundRuleToPortRanges = []int64{int64(val)}
}
case "security-group-ids":
filters.SecurityGroupIds = filterValue
case "security-group-names":
filters.SecurityGroupNames = filterValue
case "tags-keys":
filters.TagKeys = filterValue
case "tags-values":
filters.TagValues = filterValue
//Some params are missing.
default:
log.Printf("[Debug] Unknown Filter Name: %s.", name)
}
}
return filters
}

4
builder/osc/common/interpolate_build_info.go
View File

@ -2,7 +2,7 @@ package common
import (
"github.com/hashicorp/packer/helper/multistep"
"github.com/outscale/osc-go/oapi"
"github.com/outscale/osc-sdk-go/osc"
)
type BuildInfoTemplate struct {
@ -20,7 +20,7 @@ func extractBuildInfo(region string, state multistep.StateBag) *BuildInfoTemplat
}
}
sourceOMI := rawSourceOMI.(oapi.Image)
sourceOMI := rawSourceOMI.(osc.Image)
sourceOMITags := make(map[string]string, len(sourceOMI.Tags))
for _, tag := range sourceOMI.Tags {
sourceOMITags[tag.Key] = tag.Value

8
builder/osc/common/interpolate_build_info_test.go
View File

@ -5,14 +5,14 @@ import (
"testing"
"github.com/hashicorp/packer/helper/multistep"
"github.com/outscale/osc-go/oapi"
"github.com/outscale/osc-sdk-go/osc"
)
func testImage() oapi.Image {
return oapi.Image{
func testImage() osc.Image {
return osc.Image{
ImageId: "ami-abcd1234",
ImageName: "ami_test_name",
Tags: []oapi.ResourceTag{
Tags: []osc.ResourceTag{
{
Key: "key-1",
Value: "value-1",

8
builder/osc/common/omi_config_test.go
View File

@ -36,17 +36,13 @@ func TestOMIConfigPrepare_regions(t *testing.T) {
c.OMIRegions = nil
var errs []error
var err error
accessConf := testAccessConfig()
mockConn := &mockOAPIClient{}
if errs = c.prepareRegions(accessConf); len(errs) > 0 {
t.Fatalf("shouldn't have err: %#v", errs)
}
c.OMIRegions, err = listOAPIRegions(mockConn)
if err != nil {
t.Fatalf("shouldn't have err: %s", err.Error())
}
c.OMIRegions = []string{"us-east-1", "us-west-1"}
if errs = c.prepareRegions(accessConf); len(errs) > 0 {
t.Fatalf("shouldn't have err: %#v", errs)
}

23
builder/osc/common/regions.go
View File

@ -1,19 +1,23 @@
package common
import (
"context"
"fmt"
"github.com/outscale/osc-go/oapi"
"github.com/antihax/optional"
"github.com/outscale/osc-sdk-go/osc"
)
func listOAPIRegions(oapiconn oapi.OAPIClient) ([]string, error) {
func listOSCRegions(oscconn *osc.RegionApiService) ([]string, error) {
var regions []string
resp, err := oapiconn.POST_ReadRegions(oapi.ReadRegionsRequest{})
if resp.OK == nil || err != nil {
resp, _, err := oscconn.ReadRegions(context.Background(), &osc.ReadRegionsOpts{
ReadRegionsRequest: optional.NewInterface(osc.ReadRegionsRequest{}),
})
if err != nil {
return []string{}, err
}
resultRegions := resp.OK
resultRegions := resp
for _, region := range resultRegions.Regions {
regions = append(regions, region.RegionName)
@ -24,13 +28,10 @@ func listOAPIRegions(oapiconn oapi.OAPIClient) ([]string, error) {
// ValidateRegion returns true if the supplied region is a valid Outscale
// region and false if it's not.
func (c *AccessConfig) ValidateRegion(regions ...string) error {
oapiconn, err := c.NewOAPIConnection()
if err != nil {
return err
}
func (c *AccessConfig) ValidateOSCRegion(regions ...string) error {
oscconn := c.NewOSCClient()
validRegions, err := listOAPIRegions(oapiconn)
validRegions, err := listOSCRegions(oscconn.RegionApi)
if err != nil {
return err
}

97
builder/osc/common/ssh.go
View File

@ -1,16 +1,20 @@
package common
import (
"context"
"errors"
"fmt"
"time"
"net/http"
"github.com/antihax/optional"
"github.com/hashicorp/packer/helper/multistep"
"github.com/outscale/osc-go/oapi"
"github.com/outscale/osc-sdk-go/osc"
)
type oapiDescriber interface {
POST_ReadVms(oapi.ReadVmsRequest) (*oapi.POST_ReadVmsResponses, error)
type oscDescriber interface {
ReadVms(ctx context.Context, localVarOptionals *osc.ReadVmsOpts) (osc.ReadVmsResponse, *http.Response, error)
}
var (
@ -20,13 +24,13 @@ var (
// SSHHost returns a function that can be given to the SSH communicator
// for determining the SSH address based on the vm DNS name.
func SSHHost(e oapiDescriber, sshInterface string) func(multistep.StateBag) (string, error) {
func SSHHost(e oscDescriber, sshInterface string) func(multistep.StateBag) (string, error) {
return func(state multistep.StateBag) (string, error) {
const tries = 2
// <= with current structure to check result of describing `tries` times
for j := 0; j <= tries; j++ {
var host string
i := state.Get("vm").(oapi.Vm)
i := state.Get("vm").(osc.Vm)
if sshInterface != "" {
switch sshInterface {
@ -63,20 +67,91 @@ func SSHHost(e oapiDescriber, sshInterface string) func(multistep.StateBag) (str
return host, nil
}
r, err := e.POST_ReadVms(oapi.ReadVmsRequest{
Filters: oapi.FiltersVm{
VmIds: []string{i.VmId},
},
r, _, err := e.ReadVms(context.Background(), &osc.ReadVmsOpts{
ReadVmsRequest: optional.NewInterface(osc.ReadVmsRequest{
Filters: osc.FiltersVm{
VmIds: []string{i.VmId},
},
}),
})
if err != nil {
return "", err
}
if len(r.OK.Vms) == 0 {
if len(r.Vms) == 0 {
return "", fmt.Errorf("vm not found: %s", i.VmId)
}
state.Put("vm", r.OK.Vms[0])
state.Put("vm", r.Vms[0])
time.Sleep(sshHostSleepDuration)
}
return "", errors.New("couldn't determine address for vm")
}
}
// SSHHost returns a function that can be given to the SSH communicator
// for determining the SSH address based on the vm DNS name.
func OscSSHHost(e oscDescriber, sshInterface string) func(multistep.StateBag) (string, error) {
return func(state multistep.StateBag) (string, error) {
const tries = 2
// <= with current structure to check result of describing `tries` times
for j := 0; j <= tries; j++ {
var host string
i := state.Get("vm").(osc.Vm)
if sshInterface != "" {
switch sshInterface {
case "public_ip":
if i.PublicIp != "" {
host = i.PublicIp
}
case "public_dns":
if i.PublicDnsName != "" {
host = i.PublicDnsName
}
case "private_ip":
if i.PrivateIp != "" {
host = i.PrivateIp
}
case "private_dns":
if i.PrivateDnsName != "" {
host = i.PrivateDnsName
}
default:
panic(fmt.Sprintf("Unknown interface type: %s", sshInterface))
}
} else if i.NetId != "" {
if i.PublicIp != "" {
host = i.PublicIp
} else if i.PrivateIp != "" {
host = i.PrivateIp
}
} else if i.PublicDnsName != "" {
host = i.PublicDnsName
}
if host != "" {
return host, nil
}
r, _, err := e.ReadVms(context.Background(), &osc.ReadVmsOpts{
ReadVmsRequest: optional.NewInterface(osc.ReadVmsRequest{
Filters: osc.FiltersVm{
VmIds: []string{i.VmId},
},
}),
})
if err != nil {
return "", err
}
if len(r.Vms) == 0 {
return "", fmt.Errorf("vm not found: %s", i.VmId)
}
state.Put("vm", r.Vms[0])
time.Sleep(sshHostSleepDuration)
}

248
builder/osc/common/state.go
View File

@ -1,78 +1,73 @@
package common
import (
"context"
"fmt"
"log"
"github.com/antihax/optional"
"github.com/hashicorp/packer/common"
"github.com/outscale/osc-go/oapi"
"github.com/outscale/osc-sdk-go/osc"
)
type stateRefreshFunc func() (string, error)
func waitForSecurityGroup(conn *oapi.Client, securityGroupID string) error {
func waitUntilForOscVmRunning(conn *osc.APIClient, vmID string) error {
errCh := make(chan error, 1)
go waitForState(errCh, "exists", securityGroupWaitFunc(conn, securityGroupID))
go waitForState(errCh, "running", waitUntilOscVmStateFunc(conn, vmID))
err := <-errCh
return err
}
func waitUntilForVmRunning(conn *oapi.Client, vmID string) error {
func waitUntilOscVmDeleted(conn *osc.APIClient, vmID string) error {
errCh := make(chan error, 1)
go waitForState(errCh, "running", waitUntilVmStateFunc(conn, vmID))
err := <-errCh
return err
}
func waitUntilVmDeleted(conn *oapi.Client, vmID string) error {
errCh := make(chan error, 1)
go waitForState(errCh, "terminated", waitUntilVmStateFunc(conn, vmID))
go waitForState(errCh, "terminated", waitUntilOscVmStateFunc(conn, vmID))
return <-errCh
}
func waitUntilVmStopped(conn *oapi.Client, vmID string) error {
func waitUntilOscVmStopped(conn *osc.APIClient, vmID string) error {
errCh := make(chan error, 1)
go waitForState(errCh, "stopped", waitUntilVmStateFunc(conn, vmID))
go waitForState(errCh, "stopped", waitUntilOscVmStateFunc(conn, vmID))
return <-errCh
}
func WaitUntilSnapshotCompleted(conn *oapi.Client, id string) error {
func WaitUntilOscSnapshotCompleted(conn *osc.APIClient, id string) error {
errCh := make(chan error, 1)
go waitForState(errCh, "completed", waitUntilSnapshotStateFunc(conn, id))
go waitForState(errCh, "completed", waitUntilOscSnapshotStateFunc(conn, id))
return <-errCh
}
func WaitUntilImageAvailable(conn *oapi.Client, imageID string) error {
func WaitUntilOscImageAvailable(conn *osc.APIClient, imageID string) error {
errCh := make(chan error, 1)
go waitForState(errCh, "available", waitUntilImageStateFunc(conn, imageID))
go waitForState(errCh, "available", waitUntilOscImageStateFunc(conn, imageID))
return <-errCh
}
func WaitUntilVolumeAvailable(conn *oapi.Client, volumeID string) error {
func WaitUntilOscVolumeAvailable(conn *osc.APIClient, volumeID string) error {
errCh := make(chan error, 1)
go waitForState(errCh, "available", volumeWaitFunc(conn, volumeID))
go waitForState(errCh, "available", volumeOscWaitFunc(conn, volumeID))
return <-errCh
}
func WaitUntilVolumeIsLinked(conn *oapi.Client, volumeID string) error {
func WaitUntilOscVolumeIsLinked(conn *osc.APIClient, volumeID string) error {
errCh := make(chan error, 1)
go waitForState(errCh, "attached", waitUntilVolumeLinkedStateFunc(conn, volumeID))
go waitForState(errCh, "attached", waitUntilOscVolumeLinkedStateFunc(conn, volumeID))
return <-errCh
}
func WaitUntilVolumeIsUnlinked(conn *oapi.Client, volumeID string) error {
func WaitUntilOscVolumeIsUnlinked(conn *osc.APIClient, volumeID string) error {
errCh := make(chan error, 1)
go waitForState(errCh, "dettached", waitUntilVolumeUnLinkedStateFunc(conn, volumeID))
go waitForState(errCh, "dettached", waitUntilOscVolumeUnLinkedStateFunc(conn, volumeID))
return <-errCh
}
func WaitUntilSnapshotDone(conn *oapi.Client, snapshotID string) error {
func WaitUntilOscSnapshotDone(conn *osc.APIClient, snapshotID string) error {
errCh := make(chan error, 1)
go waitForState(errCh, "completed", waitUntilSnapshotDoneStateFunc(conn, snapshotID))
go waitForState(errCh, "completed", waitUntilOscSnapshotDoneStateFunc(conn, snapshotID))
return <-errCh
}
func waitForState(errCh chan<- error, target string, refresh stateRefreshFunc) error {
func waitForState(errCh chan<- error, target string, refresh stateRefreshFunc) {
err := common.Retry(2, 2, 0, func(_ uint) (bool, error) {
state, err := refresh()
if err != nil {
@ -83,91 +78,83 @@ func waitForState(errCh chan<- error, target string, refresh stateRefreshFunc) e
return false, nil
})
errCh <- err
return err
}
func waitUntilVmStateFunc(conn *oapi.Client, id string) stateRefreshFunc {
func waitUntilOscVmStateFunc(conn *osc.APIClient, id string) stateRefreshFunc {
return func() (string, error) {
log.Printf("[Debug] Retrieving state for VM with id %s", id)
resp, err := conn.POST_ReadVms(oapi.ReadVmsRequest{
Filters: oapi.FiltersVm{
VmIds: []string{id},
},
resp, _, err := conn.VmApi.ReadVms(context.Background(), &osc.ReadVmsOpts{
ReadVmsRequest: optional.NewInterface(osc.ReadVmsRequest{
Filters: osc.FiltersVm{
VmIds: []string{id},
},
}),
})
log.Printf("[Debug] Read Response %+v", resp.OK)
if err != nil {
return "", err
}
if resp.OK == nil {
return "", fmt.Errorf("Vm with ID %s not Found", id)
}
//TODO: check if needed
// if resp == nil {
// return "", fmt.Errorf("Vm with ID %s not Found", id)
// }
if len(resp.OK.Vms) == 0 {
if len(resp.Vms) == 0 {
return "pending", nil
}
return resp.OK.Vms[0].State, nil
return resp.Vms[0].State, nil
}
}
func waitUntilVolumeLinkedStateFunc(conn *oapi.Client, id string) stateRefreshFunc {
func waitUntilOscVolumeLinkedStateFunc(conn *osc.APIClient, id string) stateRefreshFunc {
return func() (string, error) {
log.Printf("[Debug] Check if volume with id %s exists", id)
resp, err := conn.POST_ReadVolumes(oapi.ReadVolumesRequest{
Filters: oapi.FiltersVolume{
VolumeIds: []string{id},
},
resp, _, err := conn.VolumeApi.ReadVolumes(context.Background(), &osc.ReadVolumesOpts{
ReadVolumesRequest: optional.NewInterface(osc.ReadVolumesRequest{
Filters: osc.FiltersVolume{
VolumeIds: []string{id},
},
}),
})
if err != nil {
return "", err
}
if resp.OK == nil {
return "", fmt.Errorf("Vm with ID %s. Not Found", id)
}
log.Printf("[Debug] Read Response %+v", resp.OK)
if len(resp.OK.Volumes) == 0 {
if len(resp.Volumes) == 0 {
return "pending", nil
}
if len(resp.OK.Volumes[0].LinkedVolumes) == 0 {
if len(resp.Volumes[0].LinkedVolumes) == 0 {
return "pending", nil
}
return resp.OK.Volumes[0].LinkedVolumes[0].State, nil
return resp.Volumes[0].LinkedVolumes[0].State, nil
}
}
func waitUntilVolumeUnLinkedStateFunc(conn *oapi.Client, id string) stateRefreshFunc {
func waitUntilOscVolumeUnLinkedStateFunc(conn *osc.APIClient, id string) stateRefreshFunc {
return func() (string, error) {
log.Printf("[Debug] Check if volume with id %s exists", id)
resp, err := conn.POST_ReadVolumes(oapi.ReadVolumesRequest{
Filters: oapi.FiltersVolume{
VolumeIds: []string{id},
},
resp, _, err := conn.VolumeApi.ReadVolumes(context.Background(), &osc.ReadVolumesOpts{
ReadVolumesRequest: optional.NewInterface(osc.ReadVolumesRequest{
Filters: osc.FiltersVolume{
VolumeIds: []string{id},
},
}),
})
if err != nil {
return "", err
}
if resp.OK == nil {
return "", fmt.Errorf("Vm with ID %s. Not Found", id)
}
log.Printf("[Debug] Read Response %+v", resp.OK)
if len(resp.OK.Volumes) == 0 {
if len(resp.Volumes) == 0 {
return "pending", nil
}
if len(resp.OK.Volumes[0].LinkedVolumes) == 0 {
if len(resp.Volumes[0].LinkedVolumes) == 0 {
return "dettached", nil
}
@ -175,149 +162,106 @@ func waitUntilVolumeUnLinkedStateFunc(conn *oapi.Client, id string) stateRefresh
}
}
func waitUntilSnapshotStateFunc(conn *oapi.Client, id string) stateRefreshFunc {
func waitUntilOscSnapshotStateFunc(conn *osc.APIClient, id string) stateRefreshFunc {
return func() (string, error) {
log.Printf("[Debug] Check if Snapshot with id %s exists", id)
resp, err := conn.POST_ReadSnapshots(oapi.ReadSnapshotsRequest{
Filters: oapi.FiltersSnapshot{
SnapshotIds: []string{id},
},
resp, _, err := conn.SnapshotApi.ReadSnapshots(context.Background(), &osc.ReadSnapshotsOpts{
ReadSnapshotsRequest: optional.NewInterface(osc.ReadSnapshotsRequest{
Filters: osc.FiltersSnapshot{
SnapshotIds: []string{id},
},
}),
})
log.Printf("[Debug] Read Response %+v", resp.OK)
if err != nil {
return "", err
}
if resp.OK == nil {
return "", fmt.Errorf("Vm with ID %s. Not Found", id)
}
if len(resp.OK.Snapshots) == 0 {
if len(resp.Snapshots) == 0 {
return "pending", nil
}
return resp.OK.Snapshots[0].State, nil
return resp.Snapshots[0].State, nil
}
}
func waitUntilImageStateFunc(conn *oapi.Client, id string) stateRefreshFunc {
func waitUntilOscImageStateFunc(conn *osc.APIClient, id string) stateRefreshFunc {
return func() (string, error) {
log.Printf("[Debug] Check if Image with id %s exists", id)
resp, err := conn.POST_ReadImages(oapi.ReadImagesRequest{
Filters: oapi.FiltersImage{
ImageIds: []string{id},
},
resp, _, err := conn.ImageApi.ReadImages(context.Background(), &osc.ReadImagesOpts{
ReadImagesRequest: optional.NewInterface(osc.ReadImagesRequest{
Filters: osc.FiltersImage{
ImageIds: []string{id},
},
}),
})
log.Printf("[Debug] Read Response %+v", resp.OK)
if err != nil {
return "", err
}
if resp.OK == nil {
return "", fmt.Errorf("Vm with ID %s. Not Found", id)
}
if len(resp.OK.Images) == 0 {
if len(resp.Images) == 0 {
return "pending", nil
}
if resp.OK.Images[0].State == "failed" {
return resp.OK.Images[0].State, fmt.Errorf("Image (%s) creation is failed", id)
if resp.Images[0].State == "failed" {
return resp.Images[0].State, fmt.Errorf("Image (%s) creation is failed", id)
}
return resp.OK.Images[0].State, nil
return resp.Images[0].State, nil
}
}
func securityGroupWaitFunc(conn *oapi.Client, id string) stateRefreshFunc {
return func() (string, error) {
log.Printf("[Debug] Check if SG with id %s exists", id)
resp, err := conn.POST_ReadSecurityGroups(oapi.ReadSecurityGroupsRequest{
Filters: oapi.FiltersSecurityGroup{
SecurityGroupIds: []string{id},
},
})
log.Printf("[Debug] Read Response %+v", resp.OK)
if err != nil {
return "", err
}
if resp.OK == nil {
return "", fmt.Errorf("Security Group with ID %s. Not Found", id)
}
if len(resp.OK.SecurityGroups) == 0 {
return "waiting", nil
}
return "exists", nil
}
}
func waitUntilSnapshotDoneStateFunc(conn *oapi.Client, id string) stateRefreshFunc {
func waitUntilOscSnapshotDoneStateFunc(conn *osc.APIClient, id string) stateRefreshFunc {
return func() (string, error) {
log.Printf("[Debug] Check if Snapshot with id %s exists", id)
resp, err := conn.POST_ReadSnapshots(oapi.ReadSnapshotsRequest{
Filters: oapi.FiltersSnapshot{
SnapshotIds: []string{id},
},
resp, _, err := conn.SnapshotApi.ReadSnapshots(context.Background(), &osc.ReadSnapshotsOpts{
ReadSnapshotsRequest: optional.NewInterface(osc.ReadSnapshotsRequest{
Filters: osc.FiltersSnapshot{
SnapshotIds: []string{id},
},
}),
})
log.Printf("[Debug] Read Response %+v", resp.OK)
if err != nil {
return "", err
}
if resp.OK == nil {
if len(resp.Snapshots) == 0 {
return "", fmt.Errorf("Snapshot with ID %s. Not Found", id)
}
if len(resp.OK.Snapshots) == 0 {
return "", fmt.Errorf("Snapshot with ID %s. Not Found", id)
if resp.Snapshots[0].State == "error" {
return resp.Snapshots[0].State, fmt.Errorf("Snapshot (%s) creation is failed", id)
}
if resp.OK.Snapshots[0].State == "error" {
return resp.OK.Snapshots[0].State, fmt.Errorf("Snapshot (%s) creation is failed", id)
}
return resp.OK.Snapshots[0].State, nil
return resp.Snapshots[0].State, nil
}
}
func volumeWaitFunc(conn *oapi.Client, id string) stateRefreshFunc {
func volumeOscWaitFunc(conn *osc.APIClient, id string) stateRefreshFunc {
return func() (string, error) {
log.Printf("[Debug] Check if SvolumeG with id %s exists", id)
resp, err := conn.POST_ReadVolumes(oapi.ReadVolumesRequest{
Filters: oapi.FiltersVolume{
VolumeIds: []string{id},
},
resp, _, err := conn.VolumeApi.ReadVolumes(context.Background(), &osc.ReadVolumesOpts{
ReadVolumesRequest: optional.NewInterface(osc.ReadVolumesRequest{
Filters: osc.FiltersVolume{
VolumeIds: []string{id},
},
}),
})
log.Printf("[Debug] Read Response %+v", resp.OK)
if err != nil {
return "", err
}
if resp.OK == nil {
return "", fmt.Errorf("Volume with ID %s. Not Found", id)
}
if len(resp.OK.Volumes) == 0 {
if len(resp.Volumes) == 0 {
return "waiting", nil
}
if resp.OK.Volumes[0].State == "error" {
return resp.OK.Volumes[0].State, fmt.Errorf("Volume (%s) creation is failed", id)
if resp.Volumes[0].State == "error" {
return resp.Volumes[0].State, fmt.Errorf("Volume (%s) creation is failed", id)
}
return resp.OK.Volumes[0].State, nil
return resp.Volumes[0].State, nil
}
}

34
builder/osc/common/step_cleanup_volumes.go
View File

@ -5,29 +5,32 @@ import (
"fmt"
"reflect"
"github.com/antihax/optional"
"github.com/hashicorp/packer/helper/multistep"
"github.com/hashicorp/packer/packer"
"github.com/outscale/osc-go/oapi"
"github.com/outscale/osc-sdk-go/osc"
)
// stepCleanupVolumes cleans up any orphaned volumes that were not designated to
// StepCleanupVolumes cleans up any orphaned volumes that were not designated to
// remain after termination of the vm. These volumes are typically ones
// that are marked as "delete on terminate:false" in the source_ami of a build.
type StepCleanupVolumes struct {
BlockDevices BlockDevices
}
//Run ...
func (s *StepCleanupVolumes) Run(_ context.Context, state multistep.StateBag) multistep.StepAction {
// stepCleanupVolumes is for Cleanup only
return multistep.ActionContinue
}
// Cleanup ...
func (s *StepCleanupVolumes) Cleanup(state multistep.StateBag) {
oapiconn := state.Get("oapi").(*oapi.Client)
oscconn := state.Get("osc").(*osc.APIClient)
vmRaw := state.Get("vm")
var vm oapi.Vm
var vm osc.Vm
if vmRaw != nil {
vm = vmRaw.(oapi.Vm)
vm = vmRaw.(osc.Vm)
}
ui := state.Get("ui").(packer.Ui)
if vm.VmId == "" {
@ -42,7 +45,7 @@ func (s *StepCleanupVolumes) Cleanup(state multistep.StateBag) {
var vl []string
volList := make(map[string]string)
for _, bdm := range vm.BlockDeviceMappings {
if !reflect.DeepEqual(bdm.Bsu, oapi.BsuCreated{}) {
if !reflect.DeepEqual(bdm.Bsu, osc.BsuCreated{}) {
vl = append(vl, bdm.Bsu.VolumeId)
volList[bdm.Bsu.VolumeId] = bdm.DeviceName
}
@ -50,10 +53,12 @@ func (s *StepCleanupVolumes) Cleanup(state multistep.StateBag) {
// Using the volume list from the cached Vm, check with Outscale for up to
// date information on them
resp, err := oapiconn.POST_ReadVolumes(oapi.ReadVolumesRequest{
Filters: oapi.FiltersVolume{
VolumeIds: vl,
},
resp, _, err := oscconn.VolumeApi.ReadVolumes(context.Background(), &osc.ReadVolumesOpts{
ReadVolumesRequest: optional.NewInterface(osc.ReadVolumesRequest{
Filters: osc.FiltersVolume{
VolumeIds: vl,
},
}),
})
if err != nil {
@ -63,13 +68,13 @@ func (s *StepCleanupVolumes) Cleanup(state multistep.StateBag) {
// If any of the returned volumes are in a "deleting" stage or otherwise not
// available, remove them from the list of volumes
for _, v := range resp.OK.Volumes {
for _, v := range resp.Volumes {
if v.State != "" && v.State != "available" {
delete(volList, v.VolumeId)
}
}
if len(resp.OK.Volumes) == 0 {
if len(resp.Volumes) == 0 {
ui.Say("No volumes to clean up, skipping")
return
}
@ -87,10 +92,11 @@ func (s *StepCleanupVolumes) Cleanup(state multistep.StateBag) {
// Destroy remaining volumes
for k := range volList {
ui.Say(fmt.Sprintf("Destroying volume (%s)...", k))
_, err := oapiconn.POST_DeleteVolume(oapi.DeleteVolumeRequest{VolumeId: k})
_, _, err := oscconn.VolumeApi.DeleteVolume(context.Background(), &osc.DeleteVolumeOpts{
DeleteVolumeRequest: optional.NewInterface(osc.DeleteVolumeRequest{VolumeId: k}),
})
if err != nil {
ui.Say(fmt.Sprintf("Error deleting volume: %s", err))
}
}
}

58
builder/osc/common/step_create_tags.go
View File

@ -2,16 +2,15 @@ package common
import (
"context"
"crypto/tls"
"fmt"
"net/http"
"github.com/antihax/optional"
"github.com/aws/aws-sdk-go/aws/awserr"
retry "github.com/hashicorp/packer/common"
"github.com/hashicorp/packer/helper/multistep"
"github.com/hashicorp/packer/packer"
"github.com/hashicorp/packer/template/interpolate"
"github.com/outscale/osc-go/oapi"
"github.com/outscale/osc-sdk-go/osc"
)
type StepCreateTags struct {
@ -21,8 +20,7 @@ type StepCreateTags struct {
}
func (s *StepCreateTags) Run(_ context.Context, state multistep.StateBag) multistep.StepAction {
oapiconn := state.Get("oapi").(*oapi.Client)
config := state.Get("clientConfig").(*oapi.Config)
config := state.Get("accessConfig").(*AccessConfig)
ui := state.Get("ui").(packer.Ui)
omis := state.Get("omis").(map[string]string)
@ -34,28 +32,16 @@ func (s *StepCreateTags) Run(_ context.Context, state multistep.StateBag) multis
for region, ami := range omis {
ui.Say(fmt.Sprintf("Adding tags to OMI (%s)...", ami))
newConfig := &oapi.Config{
UserAgent: config.UserAgent,
SecretKey: config.SecretKey,
Service: config.Service,
Region: region, //New region
URL: config.URL,
}
skipClient := &http.Client{
Transport: &http.Transport{
TLSClientConfig: &tls.Config{InsecureSkipVerify: true},
},
}
regionConn := oapi.NewClient(newConfig, skipClient)
regionconn := config.NewOSCClientByRegion(region)
// Retrieve image list for given OMI
resourceIds := []string{ami}
imageResp, err := regionConn.POST_ReadImages(oapi.ReadImagesRequest{
Filters: oapi.FiltersImage{
ImageIds: resourceIds,
},
imageResp, _, err := regionconn.ImageApi.ReadImages(context.Background(), &osc.ReadImagesOpts{
ReadImagesRequest: optional.NewInterface(osc.ReadImagesRequest{
Filters: osc.FiltersImage{
ImageIds: resourceIds,
},
}),
})
if err != nil {
@ -65,14 +51,14 @@ func (s *StepCreateTags) Run(_ context.Context, state multistep.StateBag) multis
return multistep.ActionHalt
}
if len(imageResp.OK.Images) == 0 {
if len(imageResp.Images) == 0 {
err := fmt.Errorf("Error retrieving details for OMI (%s), no images found", ami)
state.Put("error", err)
ui.Error(err.Error())
return multistep.ActionHalt
}
image := imageResp.OK.Images[0]
image := imageResp.Images[0]
snapshotIds := []string{}
// Add only those with a Snapshot ID, i.e. not Ephemeral
@ -86,7 +72,7 @@ func (s *StepCreateTags) Run(_ context.Context, state multistep.StateBag) multis
// Convert tags to oapi.Tag format
ui.Say("Creating OMI tags")
amiTags, err := s.Tags.OAPITags(s.Ctx, oapiconn.GetConfig().Region, state)
amiTags, err := s.Tags.OSCTags(s.Ctx, config.RawRegion, state)
if err != nil {
state.Put("error", err)
ui.Error(err.Error())
@ -95,7 +81,7 @@ func (s *StepCreateTags) Run(_ context.Context, state multistep.StateBag) multis
amiTags.Report(ui)
ui.Say("Creating snapshot tags")
snapshotTags, err := s.SnapshotTags.OAPITags(s.Ctx, oapiconn.GetConfig().Region, state)
snapshotTags, err := s.SnapshotTags.OSCTags(s.Ctx, config.RawRegion, state)
if err != nil {
state.Put("error", err)
ui.Error(err.Error())
@ -106,9 +92,11 @@ func (s *StepCreateTags) Run(_ context.Context, state multistep.StateBag) multis
// Retry creating tags for about 2.5 minutes
err = retry.Retry(0.2, 30, 11, func(_ uint) (bool, error) {
// Tag images and snapshots
_, err := regionConn.POST_CreateTags(oapi.CreateTagsRequest{
ResourceIds: resourceIds,
Tags: amiTags,
_, _, err := regionconn.TagApi.CreateTags(context.Background(), &osc.CreateTagsOpts{
CreateTagsRequest: optional.NewInterface(osc.CreateTagsRequest{
ResourceIds: resourceIds,
Tags: amiTags,
}),
})
if awsErr, ok := err.(awserr.Error); ok {
if awsErr.Code() == "InvalidOMIID.NotFound" ||
@ -119,9 +107,11 @@ func (s *StepCreateTags) Run(_ context.Context, state multistep.StateBag) multis
// Override tags on snapshots
if len(snapshotTags) > 0 {
_, err = regionConn.POST_CreateTags(oapi.CreateTagsRequest{
ResourceIds: snapshotIds,
Tags: snapshotTags,
_, _, err = regionconn.TagApi.CreateTags(context.Background(), &osc.CreateTagsOpts{
CreateTagsRequest: optional.NewInterface(osc.CreateTagsRequest{
ResourceIds: snapshotIds,
Tags: snapshotTags,
}),
})
}
if err == nil {

75
builder/osc/common/step_deregister_omi.go
View File

@ -2,13 +2,14 @@ package common
import (
"context"
"crypto/tls"
"fmt"
"net/http"
"log"
"github.com/antihax/optional"
"github.com/outscale/osc-sdk-go/osc"
"github.com/hashicorp/packer/helper/multistep"
"github.com/hashicorp/packer/packer"
"github.com/outscale/osc-go/oapi"
)
type StepDeregisterOMI struct {
@ -26,76 +27,72 @@ func (s *StepDeregisterOMI) Run(_ context.Context, state multistep.StateBag) mul
}
ui := state.Get("ui").(packer.Ui)
oapiconn := state.Get("oapi").(*oapi.Client)
// Add the session region to list of regions will will deregister OMIs in
regions := append(s.Regions, oapiconn.GetConfig().Region)
for _, region := range regions {
s.Regions = append(s.Regions, s.AccessConfig.GetRegion())
log.Printf("LOG_ s.Regions: %#+v\n", s.Regions)
for _, region := range s.Regions {
// get new connection for each region in which we need to deregister vms
config, err := s.AccessConfig.Config()
if err != nil {
return multistep.ActionHalt
}
conn := s.AccessConfig.NewOSCClientByRegion(region)
newConfig := &oapi.Config{
UserAgent: config.UserAgent,
SecretKey: config.SecretKey,
Service: config.Service,
Region: region, //New region
URL: config.URL,
}
skipClient := &http.Client{
Transport: &http.Transport{
TLSClientConfig: &tls.Config{InsecureSkipVerify: true},
},
}
regionconn := oapi.NewClient(newConfig, skipClient)
resp, err := regionconn.POST_ReadImages(oapi.ReadImagesRequest{
Filters: oapi.FiltersImage{
ImageNames: []string{s.OMIName},
AccountAliases: []string{"self"},
},
resp, _, err := conn.ImageApi.ReadImages(context.Background(), &osc.ReadImagesOpts{
ReadImagesRequest: optional.NewInterface(osc.ReadImagesRequest{
Filters: osc.FiltersImage{
ImageNames: []string{s.OMIName},
//AccountAliases: []string{"self"},
},
}),
})
if err != nil {
err := fmt.Errorf("Error describing OMI: %s", err)
state.Put("error", err)
ui.Error(err.Error())
return multistep.ActionHalt
}
log.Printf("LOG_ resp.Images: %#+v\n", resp.Images)
// Deregister image(s) by name
for _, i := range resp.OK.Images {
for i := range resp.Images {
//We are supposing that DeleteImage does the same action as DeregisterImage
_, err := regionconn.POST_DeleteImage(oapi.DeleteImageRequest{
ImageId: i.ImageId,
_, _, err := conn.ImageApi.DeleteImage(context.Background(), &osc.DeleteImageOpts{
DeleteImageRequest: optional.NewInterface(osc.DeleteImageRequest{
ImageId: resp.Images[i].ImageId,
}),
})
if err != nil {
err := fmt.Errorf("Error deregistering existing OMI: %s", err)
state.Put("error", err)
ui.Error(err.Error())
return multistep.ActionHalt
}
ui.Say(fmt.Sprintf("Deregistered OMI %s, id: %s", s.OMIName, i.ImageId))
ui.Say(fmt.Sprintf("Deregistered OMI %s, id: %s", s.OMIName, resp.Images[i].ImageId))
// Delete snapshot(s) by image
if s.ForceDeleteSnapshot {
for _, b := range i.BlockDeviceMappings {
for _, b := range resp.Images[i].BlockDeviceMappings {
if b.Bsu.SnapshotId != "" {
_, err := regionconn.POST_DeleteSnapshot(oapi.DeleteSnapshotRequest{
SnapshotId: b.Bsu.SnapshotId,
_, _, err := conn.SnapshotApi.DeleteSnapshot(context.Background(), &osc.DeleteSnapshotOpts{
DeleteSnapshotRequest: optional.NewInterface(osc.DeleteSnapshotRequest{
SnapshotId: b.Bsu.SnapshotId,
}),
})
if err != nil {
err := fmt.Errorf("Error deleting existing snapshot: %s", err)
state.Put("error", err)
ui.Error(err.Error())
return multistep.ActionHalt
}
ui.Say(fmt.Sprintf("Deleted snapshot: %s", b.Bsu.SnapshotId))
}
}

17
builder/osc/common/step_get_password.go
View File

@ -11,10 +11,11 @@ import (
"log"
"time"
"github.com/antihax/optional"
"github.com/hashicorp/packer/helper/communicator"
"github.com/hashicorp/packer/helper/multistep"
"github.com/hashicorp/packer/packer"
"github.com/outscale/osc-go/oapi"
"github.com/outscale/osc-sdk-go/osc"
)
// StepGetPassword reads the password from a Windows server and sets it
@ -102,8 +103,8 @@ WaitLoop:
func (s *StepGetPassword) Cleanup(multistep.StateBag) {}
func (s *StepGetPassword) waitForPassword(state multistep.StateBag, cancel <-chan struct{}) (string, error) {
oapiconn := state.Get("oapi").(*oapi.Client)
vm := state.Get("vm").(oapi.Vm)
oscconn := state.Get("osc").(*osc.APIClient)
vm := state.Get("vm").(osc.Vm)
privateKey := s.Comm.SSHPrivateKey
for {
@ -114,17 +115,19 @@ func (s *StepGetPassword) waitForPassword(state multistep.StateBag, cancel <-cha
case <-time.After(5 * time.Second):
}
resp, err := oapiconn.POST_ReadAdminPassword(oapi.ReadAdminPasswordRequest{
VmId: vm.VmId,
resp, _, err := oscconn.VmApi.ReadAdminPassword(context.Background(), &osc.ReadAdminPasswordOpts{
ReadAdminPasswordRequest: optional.NewInterface(osc.ReadAdminPasswordRequest{
VmId: vm.VmId,
}),
})
if err != nil {
err := fmt.Errorf("Error retrieving auto-generated vm password: %s", err)
return "", err
}
if resp.OK.AdminPassword != "" {
if resp.AdminPassword != "" {
decryptedPassword, err := decryptPasswordDataWithPrivateKey(
resp.OK.AdminPassword, []byte(privateKey))
resp.AdminPassword, privateKey)
if err != nil {
err := fmt.Errorf("Error decrypting auto-generated vm password: %s", err)
return "", err

31
builder/osc/common/step_key_pair.go
View File

@ -6,10 +6,11 @@ import (
"os"
"runtime"
"github.com/antihax/optional"
"github.com/hashicorp/packer/helper/communicator"
"github.com/hashicorp/packer/helper/multistep"
"github.com/hashicorp/packer/packer"
"github.com/outscale/osc-go/oapi"
"github.com/outscale/osc-sdk-go/osc"
)
type StepKeyPair struct {
@ -52,11 +53,16 @@ func (s *StepKeyPair) Run(_ context.Context, state multistep.StateBag) multistep
return multistep.ActionContinue
}
oapiconn := state.Get("oapi").(*oapi.Client)
conn := state.Get("osc").(*osc.APIClient)
ui.Say(fmt.Sprintf("Creating temporary keypair: %s", s.Comm.SSHTemporaryKeyPairName))
keyResp, err := oapiconn.POST_CreateKeypair(oapi.CreateKeypairRequest{
KeypairName: s.Comm.SSHTemporaryKeyPairName})
resp, _, err := conn.KeypairApi.CreateKeypair(context.Background(), &osc.CreateKeypairOpts{
CreateKeypairRequest: optional.NewInterface(osc.CreateKeypairRequest{
KeypairName: s.Comm.SSHTemporaryKeyPairName,
}),
})
if err != nil {
state.Put("error", fmt.Errorf("Error creating temporary keypair: %s", err))
return multistep.ActionHalt
@ -66,7 +72,7 @@ func (s *StepKeyPair) Run(_ context.Context, state multistep.StateBag) multistep
// Set some data for use in future steps
s.Comm.SSHKeyPairName = s.Comm.SSHTemporaryKeyPairName
s.Comm.SSHPrivateKey = []byte(keyResp.OK.Keypair.PrivateKey)
s.Comm.SSHPrivateKey = []byte(resp.Keypair.PrivateKey)
// If we're in debug mode, output the private key to the working
// directory.
@ -80,7 +86,7 @@ func (s *StepKeyPair) Run(_ context.Context, state multistep.StateBag) multistep
defer f.Close()
// Write the key out
if _, err := f.Write([]byte(keyResp.OK.Keypair.PrivateKey)); err != nil {
if _, err := f.Write([]byte(resp.Keypair.PrivateKey)); err != nil {
state.Put("error", fmt.Errorf("Error saving debug key: %s", err))
return multistep.ActionHalt
}
@ -102,12 +108,19 @@ func (s *StepKeyPair) Cleanup(state multistep.StateBag) {
return
}
oapiconn := state.Get("oapi").(*oapi.Client)
ui := state.Get("ui").(packer.Ui)
var (
conn = state.Get("osc").(*osc.APIClient)
ui = state.Get("ui").(packer.Ui)
)
// Remove the keypair
ui.Say("Deleting temporary keypair...")
_, err := oapiconn.POST_DeleteKeypair(oapi.DeleteKeypairRequest{KeypairName: s.Comm.SSHTemporaryKeyPairName})
_, _, err := conn.KeypairApi.DeleteKeypair(context.Background(), &osc.DeleteKeypairOpts{
DeleteKeypairRequest: optional.NewInterface(osc.DeleteKeypairRequest{
KeypairName: s.Comm.SSHTemporaryKeyPairName,
}),
})
if err != nil {
ui.Error(fmt.Sprintf(
"Error cleaning up keypair. Please delete the key manually: %s", s.Comm.SSHTemporaryKeyPairName))

72
builder/osc/common/step_network_info.go
View File

@ -7,9 +7,10 @@ import (
"math/rand"
"sort"
"github.com/antihax/optional"
"github.com/hashicorp/packer/helper/multistep"
"github.com/hashicorp/packer/packer"
"github.com/outscale/osc-go/oapi"
"github.com/outscale/osc-sdk-go/osc"
)
// StepNetworkInfo queries OUTSCALE for information about
@ -29,34 +30,37 @@ type StepNetworkInfo struct {
SecurityGroupFilter SecurityGroupFilterOptions
}
type subnetsSort []oapi.Subnet
type subnetsOscSort []osc.Subnet
func (a subnetsSort) Len() int { return len(a) }
func (a subnetsSort) Swap(i, j int) { a[i], a[j] = a[j], a[i] }
func (a subnetsSort) Less(i, j int) bool {
func (a subnetsOscSort) Len() int { return len(a) }
func (a subnetsOscSort) Swap(i, j int) { a[i], a[j] = a[j], a[i] }
func (a subnetsOscSort) Less(i, j int) bool {
return a[i].AvailableIpsCount < a[j].AvailableIpsCount
}
// Returns the most recent OMI out of a slice of images.
func mostFreeSubnet(subnets []oapi.Subnet) oapi.Subnet {
func mostFreeOscSubnet(subnets []osc.Subnet) osc.Subnet {
sortedSubnets := subnets
sort.Sort(subnetsSort(sortedSubnets))
sort.Sort(subnetsOscSort(sortedSubnets))
return sortedSubnets[len(sortedSubnets)-1]
}
//Run ...
func (s *StepNetworkInfo) Run(_ context.Context, state multistep.StateBag) multistep.StepAction {
oapiconn := state.Get("oapi").(*oapi.Client)
oscconn := state.Get("osc").(*osc.APIClient)
ui := state.Get("ui").(packer.Ui)
// NET
if s.NetId == "" && !s.NetFilter.Empty() {
params := oapi.ReadNetsRequest{}
params.Filters = buildNetFilters(s.NetFilter.Filters)
params := osc.ReadNetsRequest{}
params.Filters = buildOscNetFilters(s.NetFilter.Filters)
s.NetFilter.Filters["state"] = "available"
log.Printf("Using NET Filters %v", params)
vpcResp, err := oapiconn.POST_ReadNets(params)
vpcResp, _, err := oscconn.NetApi.ReadNets(context.Background(), &osc.ReadNetsOpts{
ReadNetsRequest: optional.NewInterface(params),
})
if err != nil {
err := fmt.Errorf("Error querying NETs: %s", err)
state.Put("error", err)
@ -64,20 +68,20 @@ func (s *StepNetworkInfo) Run(_ context.Context, state multistep.StateBag) multi
return multistep.ActionHalt
}
if len(vpcResp.OK.Nets) != 1 {
err := fmt.Errorf("Exactly one NET should match the filter, but %d NET's was found matching filters: %v", len(vpcResp.OK.Nets), params)
if len(vpcResp.Nets) != 1 {
err := fmt.Errorf("Exactly one NET should match the filter, but %d NET's was found matching filters: %v", len(vpcResp.Nets), params)
state.Put("error", err)
ui.Error(err.Error())
return multistep.ActionHalt
}
s.NetId = vpcResp.OK.Nets[0].NetId
s.NetId = vpcResp.Nets[0].NetId
ui.Message(fmt.Sprintf("Found NET ID: %s", s.NetId))
}
// Subnet
if s.SubnetId == "" && !s.SubnetFilter.Empty() {
params := oapi.ReadSubnetsRequest{}
params := osc.ReadSubnetsRequest{}
s.SubnetFilter.Filters["state"] = "available"
if s.NetId != "" {
@ -86,39 +90,41 @@ func (s *StepNetworkInfo) Run(_ context.Context, state multistep.StateBag) multi
if s.SubregionName != "" {
s.SubnetFilter.Filters["availability-zone"] = s.SubregionName
}
params.Filters = buildSubnetFilters(s.SubnetFilter.Filters)
params.Filters = buildOscSubnetFilters(s.SubnetFilter.Filters)
log.Printf("Using Subnet Filters %v", params)
subnetsResp, err := oapiconn.POST_ReadSubnets(params)
subnetsResp, _, err := oscconn.SubnetApi.ReadSubnets(context.Background(), &osc.ReadSubnetsOpts{
ReadSubnetsRequest: optional.NewInterface(params),
})
if err != nil {
err := fmt.Errorf("Error querying Subnets: %s", err)
err := fmt.Errorf("error querying Subnets: %s", err)
state.Put("error", err)
ui.Error(err.Error())
return multistep.ActionHalt
}
if len(subnetsResp.OK.Subnets) == 0 {
if len(subnetsResp.Subnets) == 0 {
err := fmt.Errorf("No Subnets was found matching filters: %v", params)
state.Put("error", err)
ui.Error(err.Error())
return multistep.ActionHalt
}
if len(subnetsResp.OK.Subnets) > 1 && !s.SubnetFilter.Random && !s.SubnetFilter.MostFree {
err := fmt.Errorf("Your filter matched %d Subnets. Please try a more specific search, or set random or most_free to true.", len(subnetsResp.OK.Subnets))
if len(subnetsResp.Subnets) > 1 && !s.SubnetFilter.Random && !s.SubnetFilter.MostFree {
err := fmt.Errorf("your filter matched %d Subnets. Please try a more specific search, or set random or most_free to true", len(subnetsResp.Subnets))
state.Put("error", err)
ui.Error(err.Error())
return multistep.ActionHalt
}
var subnet oapi.Subnet
var subnet osc.Subnet
switch {
case s.SubnetFilter.MostFree:
subnet = mostFreeSubnet(subnetsResp.OK.Subnets)
subnet = mostFreeOscSubnet(subnetsResp.Subnets)
case s.SubnetFilter.Random:
subnet = subnetsResp.OK.Subnets[rand.Intn(len(subnetsResp.OK.Subnets))]
subnet = subnetsResp.Subnets[rand.Intn(len(subnetsResp.Subnets))]
default:
subnet = subnetsResp.OK.Subnets[0]
subnet = subnetsResp.Subnets[0]
}
s.SubnetId = subnet.SubnetId
ui.Message(fmt.Sprintf("Found Subnet ID: %s", s.SubnetId))
@ -127,24 +133,25 @@ func (s *StepNetworkInfo) Run(_ context.Context, state multistep.StateBag) multi
// Try to find Subregion and NET Id from Subnet if they are not yet found/given
if s.SubnetId != "" && (s.SubregionName == "" || s.NetId == "") {
log.Printf("[INFO] Finding Subregion and NetId for the given subnet '%s'", s.SubnetId)
resp, err := oapiconn.POST_ReadSubnets(
oapi.ReadSubnetsRequest{
Filters: oapi.FiltersSubnet{
resp, _, err := oscconn.SubnetApi.ReadSubnets(context.Background(), &osc.ReadSubnetsOpts{
ReadSubnetsRequest: optional.NewInterface(osc.ReadSubnetsRequest{
Filters: osc.FiltersSubnet{
SubnetIds: []string{s.SubnetId},
},
})
}),
})
if err != nil {
err := fmt.Errorf("Describing the subnet: %s returned error: %s.", s.SubnetId, err)
err := fmt.Errorf("describing the subnet: %s returned error: %s", s.SubnetId, err)
state.Put("error", err)
ui.Error(err.Error())
return multistep.ActionHalt
}
if s.SubregionName == "" {
s.SubregionName = resp.OK.Subnets[0].SubregionName
s.SubregionName = resp.Subnets[0].SubregionName
log.Printf("[INFO] SubregionName found: '%s'", s.SubregionName)
}
if s.NetId == "" {
s.NetId = resp.OK.Subnets[0].NetId
s.NetId = resp.Subnets[0].NetId
log.Printf("[INFO] NetId found: '%s'", s.NetId)
}
}
@ -155,4 +162,5 @@ func (s *StepNetworkInfo) Run(_ context.Context, state multistep.StateBag) multi
return multistep.ActionContinue
}
//Cleanup ...
func (s *StepNetworkInfo) Cleanup(multistep.StateBag) {}

26
builder/osc/common/step_pre_validate.go
View File

@ -4,9 +4,10 @@ import (
"context"
"fmt"
"github.com/antihax/optional"
"github.com/hashicorp/packer/helper/multistep"
"github.com/hashicorp/packer/packer"
"github.com/outscale/osc-go/oapi"
"github.com/outscale/osc-sdk-go/osc"
)
// StepPreValidate provides an opportunity to pre-validate any configuration for
@ -15,6 +16,7 @@ import (
type StepPreValidate struct {
DestOmiName string
ForceDeregister bool
API string
}
func (s *StepPreValidate) Run(_ context.Context, state multistep.StateBag) multistep.StepAction {
@ -24,11 +26,19 @@ func (s *StepPreValidate) Run(_ context.Context, state multistep.StateBag) multi
return multistep.ActionContinue
}
oapiconn := state.Get("oapi").(*oapi.Client)
var (
conn = state.Get("osc").(*osc.APIClient)
images []interface{}
)
ui.Say(fmt.Sprintf("Prevalidating OMI Name: %s", s.DestOmiName))
resp, err := oapiconn.POST_ReadImages(oapi.ReadImagesRequest{
Filters: oapi.FiltersImage{ImageNames: []string{s.DestOmiName}},
resp, _, err := conn.ImageApi.ReadImages(context.Background(), &osc.ReadImagesOpts{
ReadImagesRequest: optional.NewInterface(osc.ReadImagesRequest{
Filters: osc.FiltersImage{
ImageNames: []string{s.DestOmiName},
},
}),
})
if err != nil {
@ -38,18 +48,14 @@ func (s *StepPreValidate) Run(_ context.Context, state multistep.StateBag) multi
return multistep.ActionHalt
}
//FIXME: Remove when the oAPI filters works
images := make([]oapi.Image, 0)
for _, omi := range resp.OK.Images {
for _, omi := range resp.Images {
if omi.ImageName == s.DestOmiName {
images = append(images, omi)
}
}
//if len(resp.OK.Images) > 0 {
if len(images) > 0 {
err := fmt.Errorf("Error: name conflicts with an existing OMI: %s", resp.OK.Images[0].ImageId)
err := fmt.Errorf("Error: name conflicts with an existing OMI: %s", s.DestOmiName)
state.Put("error", err)
ui.Error(err.Error())
return multistep.ActionHalt

44
builder/osc/common/step_public_ip.go
View File

@ -4,10 +4,11 @@ import (
"context"
"fmt"
"github.com/antihax/optional"
"github.com/hashicorp/packer/helper/communicator"
"github.com/hashicorp/packer/helper/multistep"
"github.com/hashicorp/packer/packer"
"github.com/outscale/osc-go/oapi"
"github.com/outscale/osc-sdk-go/osc"
)
type StepPublicIp struct {
@ -20,20 +21,24 @@ type StepPublicIp struct {
}
func (s *StepPublicIp) Run(_ context.Context, state multistep.StateBag) multistep.StepAction {
ui := state.Get("ui").(packer.Ui)
oapiconn := state.Get("oapi").(*oapi.Client)
netId := state.Get("net_id").(string)
subnetId := state.Get("subnet_id").(string)
var (
ui = state.Get("ui").(packer.Ui)
conn = state.Get("osc").(*osc.APIClient)
)
if !s.AssociatePublicIpAddress {
if netId == "" || subnetId == "" || !s.AssociatePublicIpAddress {
// In this case, we are in the public Cloud, so we'll
// not explicitely allocate a public IP.
return multistep.ActionContinue
}
ui.Say(fmt.Sprintf("Creating temporary PublicIp for instance in subnet %s (net %s)", subnetId, netId))
ui.Say("Creating temporary PublicIp for instance ")
resp, _, err := conn.PublicIpApi.CreatePublicIp(context.Background(), &osc.CreatePublicIpOpts{
CreatePublicIpRequest: optional.NewInterface(osc.CreatePublicIpRequest{}),
})
publicIpResp, err := oapiconn.POST_CreatePublicIp(oapi.CreatePublicIpRequest{})
if err != nil {
state.Put("error", fmt.Errorf("Error creating temporary PublicIp: %s", err))
return multistep.ActionHalt
@ -43,8 +48,8 @@ func (s *StepPublicIp) Run(_ context.Context, state multistep.StateBag) multiste
s.doCleanup = true
// Set some data for use in future steps
s.publicIpId = publicIpResp.OK.PublicIp.PublicIpId
state.Put("publicip_id", publicIpResp.OK.PublicIp.PublicIpId)
s.publicIpId = resp.PublicIp.PublicIpId
state.Put("publicip_id", resp.PublicIp.PublicIpId)
return multistep.ActionContinue
}
@ -54,15 +59,20 @@ func (s *StepPublicIp) Cleanup(state multistep.StateBag) {
return
}
oapiconn := state.Get("oapi").(*oapi.Client)
ui := state.Get("ui").(packer.Ui)
var (
conn = state.Get("osc").(*osc.APIClient)
ui = state.Get("ui").(packer.Ui)
)
// Remove the Public IP
ui.Say("Deleting temporary PublicIp...")
_, err := oapiconn.POST_DeletePublicIp(oapi.DeletePublicIpRequest{PublicIpId: s.publicIpId})
if err != nil {
ui.Error(fmt.Sprintf(
"Error cleaning up PublicIp. Please delete the PublicIp manually: %s", s.publicIpId))
}
_, _, err := conn.PublicIpApi.DeletePublicIp(context.Background(), &osc.DeletePublicIpOpts{
DeletePublicIpRequest: optional.NewInterface(osc.DeletePublicIpRequest{
PublicIpId: s.publicIpId,
}),
})
if err != nil {
ui.Error(fmt.Sprintf("Error cleaning up PublicIp. Please delete the PublicIp manually: %s", s.publicIpId))
}
}

121
builder/osc/common/step_run_source_vm.go
View File

@ -8,8 +8,9 @@ import (
"log"
"reflect"
"github.com/antihax/optional"
"github.com/aws/aws-sdk-go/aws/awserr"
"github.com/outscale/osc-go/oapi"
"github.com/outscale/osc-sdk-go/osc"
retry "github.com/hashicorp/packer/common"
"github.com/hashicorp/packer/helper/communicator"
@ -39,13 +40,13 @@ type StepRunSourceVm struct {
UserData string
UserDataFile string
VolumeTags TagMap
RawRegion string
vmId string
}
func (s *StepRunSourceVm) Run(ctx context.Context, state multistep.StateBag) multistep.StepAction {
oapiconn := state.Get("oapi").(*oapi.Client)
oscconn := state.Get("osc").(*osc.APIClient)
securityGroupIds := state.Get("securityGroupIds").([]string)
ui := state.Get("ui").(packer.Ui)
@ -67,7 +68,7 @@ func (s *StepRunSourceVm) Run(ctx context.Context, state multistep.StateBag) mul
}
ui.Say("Launching a source OUTSCALE vm...")
image, ok := state.Get("source_image").(oapi.Image)
image, ok := state.Get("source_image").(osc.Image)
if !ok {
state.Put("error", fmt.Errorf("source_image type assertion failed"))
return multistep.ActionHalt
@ -89,7 +90,9 @@ func (s *StepRunSourceVm) Run(ctx context.Context, state multistep.StateBag) mul
s.Tags["Name"] = "Packer Builder"
}
oapiTags, err := s.Tags.OAPITags(s.Ctx, oapiconn.GetConfig().Region, state)
rawRegion := s.RawRegion
oscTags, err := s.Tags.OSCTags(s.Ctx, rawRegion, state)
if err != nil {
err := fmt.Errorf("Error tagging source vm: %s", err)
state.Put("error", err)
@ -97,7 +100,7 @@ func (s *StepRunSourceVm) Run(ctx context.Context, state multistep.StateBag) mul
return multistep.ActionHalt
}
volTags, err := s.VolumeTags.OAPITags(s.Ctx, oapiconn.GetConfig().Region, state)
volTags, err := s.VolumeTags.OSCTags(s.Ctx, rawRegion, state)
if err != nil {
err := fmt.Errorf("Error tagging volumes: %s", err)
state.Put("error", err)
@ -106,73 +109,42 @@ func (s *StepRunSourceVm) Run(ctx context.Context, state multistep.StateBag) mul
}
subregion := state.Get("subregion_name").(string)
runOpts := oapi.CreateVmsRequest{
runOpts := osc.CreateVmsRequest{
ImageId: s.SourceOMI,
VmType: s.VmType,
UserData: userData,
MaxVmsCount: 1,
MinVmsCount: 1,
Placement: oapi.Placement{SubregionName: subregion},
Placement: osc.Placement{SubregionName: subregion},
BsuOptimized: s.BsuOptimized,
BlockDeviceMappings: s.BlockDevices.BuildLaunchDevices(),
//IamVmProfile: oapi.IamVmProfileSpecification{Name: &s.IamVmProfile},
BlockDeviceMappings: s.BlockDevices.BuildOSCLaunchDevices(),
}
// if s.EnableT2Unlimited {
// creditOption := "unlimited"
// runOpts.CreditSpecification = &oapi.CreditSpecificationRequest{CpuCredits: &creditOption}
// }
// Collect tags for tagging on resource creation
// var tagSpecs []oapi.ResourceTag
// if len(oapiTags) > 0 {
// runTags := &oapi.ResourceTag{
// ResourceType: aws.String("vm"),
// Tags: oapiTags,
// }
// tagSpecs = append(tagSpecs, runTags)
// }
// if len(volTags) > 0 {
// runVolTags := &oapi.TagSpecification{
// ResourceType: aws.String("volume"),
// Tags: volTags,
// }
// tagSpecs = append(tagSpecs, runVolTags)
// }
// // If our region supports it, set tag specifications
// if len(tagSpecs) > 0 && !s.IsRestricted {
// runOpts.SetTagSpecifications(tagSpecs)
// oapiTags.Report(ui)
// volTags.Report(ui)
// }
if s.Comm.SSHKeyPairName != "" {
runOpts.KeypairName = s.Comm.SSHKeyPairName
}
subnetId := state.Get("subnet_id").(string)
subnetID := state.Get("subnet_id").(string)
runOpts.SubnetId = subnetId
runOpts.SubnetId = subnetID
runOpts.SecurityGroupIds = securityGroupIds
if s.ExpectedRootDevice == "bsu" {
runOpts.VmInitiatedShutdownBehavior = s.VmInitiatedShutdownBehavior
}
runResp, err := oapiconn.POST_CreateVms(runOpts)
runResp, _, err := oscconn.VmApi.CreateVms(context.Background(), &osc.CreateVmsOpts{
CreateVmsRequest: optional.NewInterface(runOpts),
})
if err != nil {
err := fmt.Errorf("Error launching source vm: %s", err)
state.Put("error", err)
ui.Error(err.Error())
return multistep.ActionHalt
}
vmId = runResp.OK.Vms[0].VmId
volumeId := runResp.OK.Vms[0].BlockDeviceMappings[0].Bsu.VolumeId
vmId = runResp.Vms[0].VmId
volumeId := runResp.Vms[0].BlockDeviceMappings[0].Bsu.VolumeId
// Set the vm ID so that the cleanup works properly
s.vmId = vmId
@ -180,12 +152,12 @@ func (s *StepRunSourceVm) Run(ctx context.Context, state multistep.StateBag) mul
ui.Message(fmt.Sprintf("Vm ID: %s", vmId))
ui.Say(fmt.Sprintf("Waiting for vm (%v) to become ready...", vmId))
request := oapi.ReadVmsRequest{
Filters: oapi.FiltersVm{
request := osc.ReadVmsRequest{
Filters: osc.FiltersVm{
VmIds: []string{vmId},
},
}
if err := waitUntilForVmRunning(oapiconn, vmId); err != nil {
if err := waitUntilForOscVmRunning(oscconn, vmId); err != nil {
err := fmt.Errorf("Error waiting for vm (%s) to become ready: %s", vmId, err)
state.Put("error", err)
ui.Error(err.Error())
@ -193,8 +165,8 @@ func (s *StepRunSourceVm) Run(ctx context.Context, state multistep.StateBag) mul
}
//Set Vm tags and vollume tags
if len(oapiTags) > 0 {
if err := CreateTags(oapiconn, s.vmId, ui, oapiTags); err != nil {
if len(oscTags) > 0 {
if err := CreateOSCTags(oscconn, s.vmId, ui, oscTags); err != nil {
err := fmt.Errorf("Error creating tags for vm (%s): %s", s.vmId, err)
state.Put("error", err)
ui.Error(err.Error())
@ -203,7 +175,7 @@ func (s *StepRunSourceVm) Run(ctx context.Context, state multistep.StateBag) mul
}
if len(volTags) > 0 {
if err := CreateTags(oapiconn, volumeId, ui, volTags); err != nil {
if err := CreateOSCTags(oscconn, volumeId, ui, volTags); err != nil {
err := fmt.Errorf("Error creating tags for volume (%s): %s", volumeId, err)
state.Put("error", err)
ui.Error(err.Error())
@ -213,7 +185,9 @@ func (s *StepRunSourceVm) Run(ctx context.Context, state multistep.StateBag) mul
if publicip_id, ok := state.Get("publicip_id").(string); ok {
ui.Say(fmt.Sprintf("Linking temporary PublicIp %s to instance %s", publicip_id, vmId))
_, err := oapiconn.POST_LinkPublicIp(oapi.LinkPublicIpRequest{PublicIpId: publicip_id, VmId: vmId})
_, _, err := oscconn.PublicIpApi.LinkPublicIp(context.Background(), &osc.LinkPublicIpOpts{
LinkPublicIpRequest: optional.NewInterface(osc.LinkPublicIpRequest{PublicIpId: publicip_id, VmId: vmId}),
})
if err != nil {
state.Put("error", fmt.Errorf("Error linking PublicIp to VM: %s", err))
ui.Error(err.Error())
@ -221,9 +195,11 @@ func (s *StepRunSourceVm) Run(ctx context.Context, state multistep.StateBag) mul
}
}
resp, err := oapiconn.POST_ReadVms(request)
resp, _, err := oscconn.VmApi.ReadVms(context.Background(), &osc.ReadVmsOpts{
ReadVmsRequest: optional.NewInterface(request),
})
r := resp.OK
r := resp
if err != nil || len(r.Vms) == 0 {
err := fmt.Errorf("Error finding source vm.")
@ -256,12 +232,14 @@ func (s *StepRunSourceVm) Run(ctx context.Context, state multistep.StateBag) mul
// do that now.
if s.IsRestricted {
oapiTags.Report(ui)
oscTags.Report(ui)
// Retry creating tags for about 2.5 minutes
err = retry.Retry(0.2, 30, 11, func(_ uint) (bool, error) {
_, err := oapiconn.POST_CreateTags(oapi.CreateTagsRequest{
Tags: oapiTags,
ResourceIds: []string{vmId},
_, _, err := oscconn.TagApi.CreateTags(context.Background(), &osc.CreateTagsOpts{
CreateTagsRequest: optional.NewInterface(osc.CreateTagsRequest{
Tags: oscTags,
ResourceIds: []string{vmId},
}),
})
if err == nil {
return true, nil
@ -286,7 +264,7 @@ func (s *StepRunSourceVm) Run(ctx context.Context, state multistep.StateBag) mul
volumeIds := make([]string, 0)
for _, v := range vm.BlockDeviceMappings {
if bsu := v.Bsu; !reflect.DeepEqual(bsu, oapi.BsuCreated{}) {
if bsu := v.Bsu; !reflect.DeepEqual(bsu, osc.BsuCreated{}) {
volumeIds = append(volumeIds, bsu.VolumeId)
}
}
@ -294,7 +272,7 @@ func (s *StepRunSourceVm) Run(ctx context.Context, state multistep.StateBag) mul
if len(volumeIds) > 0 && s.VolumeTags.IsSet() {
ui.Say("Adding tags to source BSU Volumes")
volumeTags, err := s.VolumeTags.OAPITags(s.Ctx, oapiconn.GetConfig().Region, state)
volumeTags, err := s.VolumeTags.OSCTags(s.Ctx, rawRegion, state)
if err != nil {
err := fmt.Errorf("Error tagging source BSU Volumes on %s: %s", vm.VmId, err)
state.Put("error", err)
@ -303,9 +281,11 @@ func (s *StepRunSourceVm) Run(ctx context.Context, state multistep.StateBag) mul
}
volumeTags.Report(ui)
_, err = oapiconn.POST_CreateTags(oapi.CreateTagsRequest{
ResourceIds: volumeIds,
Tags: volumeTags,
_, _, err = oscconn.TagApi.CreateTags(context.Background(), &osc.CreateTagsOpts{
CreateTagsRequest: optional.NewInterface(osc.CreateTagsRequest{
ResourceIds: volumeIds,
Tags: volumeTags,
}),
})
if err != nil {
@ -321,19 +301,20 @@ func (s *StepRunSourceVm) Run(ctx context.Context, state multistep.StateBag) mul
}
func (s *StepRunSourceVm) Cleanup(state multistep.StateBag) {
oapiconn := state.Get("oapi").(*oapi.Client)
oscconn := state.Get("osc").(*osc.APIClient)
ui := state.Get("ui").(packer.Ui)
// Terminate the source vm if it exists
if s.vmId != "" {
ui.Say("Terminating the source OUTSCALE vm...")
if _, err := oapiconn.POST_DeleteVms(oapi.DeleteVmsRequest{VmIds: []string{s.vmId}}); err != nil {
if _, _, err := oscconn.VmApi.DeleteVms(context.Background(), &osc.DeleteVmsOpts{
DeleteVmsRequest: optional.NewInterface(osc.DeleteVmsRequest{VmIds: []string{s.vmId}}),
}); err != nil {
ui.Error(fmt.Sprintf("Error terminating vm, may still be around: %s", err))
return
}
if err := waitUntilVmDeleted(oapiconn, s.vmId); err != nil {
if err := waitUntilOscVmDeleted(oscconn, s.vmId); err != nil {
ui.Error(err.Error())
}
}

152
builder/osc/common/step_security_group.go
View File

@ -5,13 +5,13 @@ import (
"fmt"
"log"
"strings"
"time"
"github.com/antihax/optional"
"github.com/hashicorp/packer/common/uuid"
"github.com/hashicorp/packer/helper/communicator"
"github.com/hashicorp/packer/helper/multistep"
"github.com/hashicorp/packer/packer"
"github.com/outscale/osc-go/oapi"
"github.com/outscale/osc-sdk-go/osc"
)
type StepSecurityGroup struct {
@ -24,50 +24,56 @@ type StepSecurityGroup struct {
}
func (s *StepSecurityGroup) Run(_ context.Context, state multistep.StateBag) multistep.StepAction {
oapiconn := state.Get("oapi").(*oapi.Client)
ui := state.Get("ui").(packer.Ui)
netId := state.Get("net_id").(string)
var (
ui = state.Get("ui").(packer.Ui)
conn = state.Get("osc").(*osc.APIClient)
netID = state.Get("net_id").(string)
)
if len(s.SecurityGroupIds) > 0 {
resp, err := oapiconn.POST_ReadSecurityGroups(
oapi.ReadSecurityGroupsRequest{
Filters: oapi.FiltersSecurityGroup{
resp, _, err := conn.SecurityGroupApi.ReadSecurityGroups(context.Background(), &osc.ReadSecurityGroupsOpts{
ReadSecurityGroupsRequest: optional.NewInterface(osc.ReadSecurityGroupsRequest{
Filters: osc.FiltersSecurityGroup{
SecurityGroupIds: s.SecurityGroupIds,
},
},
)
if err != nil || resp.OK == nil || len(resp.OK.SecurityGroups) <= 0 {
}),
})
if err != nil || len(resp.SecurityGroups) == 0 {
err := fmt.Errorf("Couldn't find specified security group: %s", err)
log.Printf("[DEBUG] %s", err.Error())
state.Put("error", err)
return multistep.ActionHalt
}
log.Printf("Using specified security groups: %v", s.SecurityGroupIds)
state.Put("securityGroupIds", s.SecurityGroupIds)
return multistep.ActionContinue
}
if !s.SecurityGroupFilter.Empty() {
filterReq := buildSecurityGroupFilters(s.SecurityGroupFilter.Filters)
params := oapi.ReadSecurityGroupsRequest{}
if netId != "" {
s.SecurityGroupFilter.Filters["net-id"] = netId
}
params.Filters = buildSecurityGroupFilters(s.SecurityGroupFilter.Filters)
log.Printf("Using SecurityGroup Filters %v", filterReq)
log.Printf("Using SecurityGroup Filters %v", params)
resp, _, err := conn.SecurityGroupApi.ReadSecurityGroups(context.Background(), &osc.ReadSecurityGroupsOpts{
ReadSecurityGroupsRequest: optional.NewInterface(osc.ReadSecurityGroupsRequest{
Filters: filterReq,
}),
})
sgResp, err := oapiconn.POST_ReadSecurityGroups(params)
if err != nil || sgResp.OK == nil {
if err != nil || len(resp.SecurityGroups) == 0 {
err := fmt.Errorf("Couldn't find security groups for filter: %s", err)
log.Printf("[DEBUG] %s", err.Error())
state.Put("error", err)
return multistep.ActionHalt
}
securityGroupIds := []string{}
for _, sg := range sgResp.OK.SecurityGroups {
for _, sg := range resp.SecurityGroups {
securityGroupIds = append(securityGroupIds, sg.SecurityGroupId)
}
@ -77,24 +83,20 @@ func (s *StepSecurityGroup) Run(_ context.Context, state multistep.StateBag) mul
return multistep.ActionContinue
}
port := s.CommConfig.Port()
if port == 0 {
if s.CommConfig.Type != "none" {
panic("port must be set to a non-zero value.")
}
}
// Create the group
groupName := fmt.Sprintf("packer_%s", uuid.TimeOrderedUUID())
/* Create the group */
groupName := fmt.Sprintf("packer_osc_%s", uuid.TimeOrderedUUID())
ui.Say(fmt.Sprintf("Creating temporary security group for this instance: %s", groupName))
group := oapi.CreateSecurityGroupRequest{
createSGReq := osc.CreateSecurityGroupRequest{
SecurityGroupName: groupName,
NetId: netID,
Description: "Temporary group for Packer",
}
group.NetId = netId
resp, _, err := conn.SecurityGroupApi.CreateSecurityGroup(context.Background(), &osc.CreateSecurityGroupOpts{
CreateSecurityGroupRequest: optional.NewInterface(createSGReq),
})
groupResp, err := oapiconn.POST_CreateSecurityGroup(group)
if err != nil {
ui.Error(err.Error())
state.Put("error", err)
@ -102,38 +104,36 @@ func (s *StepSecurityGroup) Run(_ context.Context, state multistep.StateBag) mul
}
// Set the group ID so we can delete it later
s.createdGroupId = groupResp.OK.SecurityGroup.SecurityGroupId
s.createdGroupId = resp.SecurityGroup.SecurityGroupId
// Wait for the security group become available for authorizing
log.Printf("[DEBUG] Waiting for temporary security group: %s", s.createdGroupId)
err = waitForSecurityGroup(oapiconn, s.createdGroupId)
if err == nil {
log.Printf("[DEBUG] Found security group %s", s.createdGroupId)
} else {
err := fmt.Errorf("Timed out waiting for security group %s: %s", s.createdGroupId, err)
log.Printf("[DEBUG] %s", err.Error())
state.Put("error", err)
return multistep.ActionHalt
port := s.CommConfig.Port()
if port == 0 {
if s.CommConfig.Type != "none" {
state.Put("error", "port must be set to a non-zero value.")
return multistep.ActionHalt
}
}
// Authorize the SSH access for the security group
groupRules := oapi.CreateSecurityGroupRuleRequest{
SecurityGroupId: groupResp.OK.SecurityGroup.SecurityGroupId,
createSGRReq := osc.CreateSecurityGroupRuleRequest{
SecurityGroupId: resp.SecurityGroup.SecurityGroupId,
Flow: "Inbound",
Rules: []oapi.SecurityGroupRule{
Rules: []osc.SecurityGroupRule{
{
FromPortRange: int64(port),
ToPortRange: int64(port),
FromPortRange: int32(port),
ToPortRange: int32(port),
IpRanges: []string{s.TemporarySGSourceCidr},
IpProtocol: "tcp",
},
},
}
ui.Say(fmt.Sprintf(
"Authorizing access to port %d from %s in the temporary security group...",
port, s.TemporarySGSourceCidr))
_, err = oapiconn.POST_CreateSecurityGroupRule(groupRules)
ui.Say(fmt.Sprintf("Authorizing access to port %d from %s in the temporary security group...", port, s.TemporarySGSourceCidr))
_, _, err = conn.SecurityGroupRuleApi.CreateSecurityGroupRule(context.Background(), &osc.CreateSecurityGroupRuleOpts{
CreateSecurityGroupRuleRequest: optional.NewInterface(createSGRReq),
})
if err != nil {
err := fmt.Errorf("Error authorizing temporary security group: %s", err)
state.Put("error", err)
@ -152,24 +152,48 @@ func (s *StepSecurityGroup) Cleanup(state multistep.StateBag) {
return
}
oapiconn := state.Get("oapi").(*oapi.Client)
ui := state.Get("ui").(packer.Ui)
var (
ui = state.Get("ui").(packer.Ui)
conn = state.Get("osc").(*osc.APIClient)
)
ui.Say("Deleting temporary security group...")
var err error
for i := 0; i < 5; i++ {
_, err = oapiconn.POST_DeleteSecurityGroup(oapi.DeleteSecurityGroupRequest{SecurityGroupId: s.createdGroupId})
if err == nil {
break
}
log.Printf("Error deleting security group: %s", err)
time.Sleep(5 * time.Second)
}
_, _, err := conn.SecurityGroupApi.DeleteSecurityGroup(context.Background(), &osc.DeleteSecurityGroupOpts{
DeleteSecurityGroupRequest: optional.NewInterface(osc.DeleteSecurityGroupRequest{
SecurityGroupId: s.createdGroupId,
}),
})
if err != nil {
ui.Error(fmt.Sprintf(
"Error cleaning up security group. Please delete the group manually: %s", s.createdGroupId))
}
}
func buildSecurityGroupFilters(input map[string]string) osc.FiltersSecurityGroup {
var filters osc.FiltersSecurityGroup
for k, v := range input {
filterValue := []string{v}
switch name := k; name {
case "account_ids":
filters.AccountIds = filterValue
case "security_group_ids":
filters.SecurityGroupIds = filterValue
case "security_group_names":
filters.SecurityGroupNames = filterValue
case "tag_keys":
filters.TagKeys = filterValue
case "tag_values":
filters.TagValues = filterValue
case "tags":
filters.Tags = filterValue
default:
log.Printf("[Debug] Unknown Filter Name: %s.", name)
}
}
return filters
}

41
builder/osc/common/step_source_omi_info.go
View File

@ -7,45 +7,46 @@ import (
"sort"
"time"
"github.com/antihax/optional"
"github.com/hashicorp/packer/helper/multistep"
"github.com/hashicorp/packer/packer"
"github.com/outscale/osc-go/oapi"
"github.com/outscale/osc-sdk-go/osc"
)
// StepSourceOMIInfo extracts critical information from the source OMI
// that is used throughout the OMI creation process.
//
// Produces:
// source_image *oapi.Image - the source OMI info
// source_image *osc.Image - the source OMI info
type StepSourceOMIInfo struct {
SourceOmi string
OMIVirtType string
OmiFilters OmiFilterOptions
}
type imageSort []oapi.Image
type imageOscSort []osc.Image
func (a imageSort) Len() int { return len(a) }
func (a imageSort) Swap(i, j int) { a[i], a[j] = a[j], a[i] }
func (a imageSort) Less(i, j int) bool {
func (a imageOscSort) Len() int { return len(a) }
func (a imageOscSort) Swap(i, j int) { a[i], a[j] = a[j], a[i] }
func (a imageOscSort) Less(i, j int) bool {
itime, _ := time.Parse(time.RFC3339, a[i].CreationDate)
jtime, _ := time.Parse(time.RFC3339, a[j].CreationDate)
return itime.Unix() < jtime.Unix()
}
// Returns the most recent OMI out of a slice of images.
func mostRecentOmi(images []oapi.Image) oapi.Image {
func mostRecentOscOmi(images []osc.Image) osc.Image {
sortedImages := images
sort.Sort(imageSort(sortedImages))
sort.Sort(imageOscSort(sortedImages))
return sortedImages[len(sortedImages)-1]
}
func (s *StepSourceOMIInfo) Run(_ context.Context, state multistep.StateBag) multistep.StepAction {
oapiconn := state.Get("oapi").(*oapi.Client)
oscconn := state.Get("osc").(*osc.APIClient)
ui := state.Get("ui").(packer.Ui)
params := oapi.ReadImagesRequest{
Filters: oapi.FiltersImage{},
params := osc.ReadImagesRequest{
Filters: osc.FiltersImage{},
}
if s.SourceOmi != "" {
@ -54,7 +55,7 @@ func (s *StepSourceOMIInfo) Run(_ context.Context, state multistep.StateBag) mul
// We have filters to apply
if len(s.OmiFilters.Filters) > 0 {
params.Filters = buildOMIFilters(s.OmiFilters.Filters)
params.Filters = buildOSCOMIFilters(s.OmiFilters.Filters)
}
//TODO:Check if AccountIds correspond to Owners.
if len(s.OmiFilters.Owners) > 0 {
@ -62,7 +63,9 @@ func (s *StepSourceOMIInfo) Run(_ context.Context, state multistep.StateBag) mul
}
log.Printf("Using OMI Filters %#v", params)
imageResp, err := oapiconn.POST_ReadImages(params)
imageResp, _, err := oscconn.ImageApi.ReadImages(context.Background(), &osc.ReadImagesOpts{
ReadImagesRequest: optional.NewInterface(params),
})
if err != nil {
err := fmt.Errorf("Error querying OMI: %s", err)
state.Put("error", err)
@ -70,25 +73,25 @@ func (s *StepSourceOMIInfo) Run(_ context.Context, state multistep.StateBag) mul
return multistep.ActionHalt
}
if len(imageResp.OK.Images) == 0 {
if len(imageResp.Images) == 0 {
err := fmt.Errorf("No OMI was found matching filters: %#v", params)
state.Put("error", err)
ui.Error(err.Error())
return multistep.ActionHalt
}
if len(imageResp.OK.Images) > 1 && !s.OmiFilters.MostRecent {
err := fmt.Errorf("Your query returned more than one result. Please try a more specific search, or set most_recent to true.")
if len(imageResp.Images) > 1 && !s.OmiFilters.MostRecent {
err := fmt.Errorf("your query returned more than one result. Please try a more specific search, or set most_recent to true")
state.Put("error", err)
ui.Error(err.Error())
return multistep.ActionHalt
}
var image oapi.Image
var image osc.Image
if s.OmiFilters.MostRecent {
image = mostRecentOmi(imageResp.OK.Images)
image = mostRecentOscOmi(imageResp.Images)
} else {
image = imageResp.OK.Images[0]
image = imageResp.Images[0]
}
ui.Message(fmt.Sprintf("Found Image ID: %s", image.ImageId))

15
builder/osc/common/step_stop_bsu_backed_vm.go
View File

@ -4,11 +4,12 @@ import (
"context"
"fmt"
"github.com/antihax/optional"
"github.com/aws/aws-sdk-go/aws/awserr"
"github.com/hashicorp/packer/common"
"github.com/hashicorp/packer/helper/multistep"
"github.com/hashicorp/packer/packer"
"github.com/outscale/osc-go/oapi"
"github.com/outscale/osc-sdk-go/osc"
)
type StepStopBSUBackedVm struct {
@ -17,8 +18,8 @@ type StepStopBSUBackedVm struct {
}
func (s *StepStopBSUBackedVm) Run(ctx context.Context, state multistep.StateBag) multistep.StepAction {
oapiconn := state.Get("oapi").(*oapi.Client)
vm := state.Get("vm").(oapi.Vm)
oscconn := state.Get("osc").(*osc.APIClient)
vm := state.Get("vm").(osc.Vm)
ui := state.Get("ui").(packer.Ui)
// Skip when it is a spot vm
@ -43,8 +44,10 @@ func (s *StepStopBSUBackedVm) Run(ctx context.Context, state multistep.StateBag)
err := common.Retry(10, 60, 6, func(i uint) (bool, error) {
ui.Message(fmt.Sprintf("Stopping vm, attempt %d", i+1))
_, err = oapiconn.POST_StopVms(oapi.StopVmsRequest{
VmIds: []string{vm.VmId},
_, _, err = oscconn.VmApi.StopVms(context.Background(), &osc.StopVmsOpts{
StopVmsRequest: optional.NewInterface(osc.StopVmsRequest{
VmIds: []string{vm.VmId},
}),
})
if err == nil {
@ -78,7 +81,7 @@ func (s *StepStopBSUBackedVm) Run(ctx context.Context, state multistep.StateBag)
// Wait for the vm to actually stop
ui.Say("Waiting for the vm to stop...")
err = waitUntilVmStopped(oapiconn, vm.VmId)
err = waitUntilOscVmStopped(oscconn, vm.VmId)
if err != nil {
err := fmt.Errorf("Error waiting for vm to stop: %s", err)

79
builder/osc/common/step_update_omi.go
View File

@ -2,25 +2,24 @@ package common
import (
"context"
"crypto/tls"
"fmt"
"net/http"
"github.com/antihax/optional"
"github.com/hashicorp/packer/helper/multistep"
"github.com/hashicorp/packer/packer"
"github.com/hashicorp/packer/template/interpolate"
"github.com/outscale/osc-go/oapi"
"github.com/outscale/osc-sdk-go/osc"
)
type StepUpdateOMIAttributes struct {
AccountIds []string
SnapshotAccountIds []string
RawRegion string
Ctx interpolate.Context
}
func (s *StepUpdateOMIAttributes) Run(_ context.Context, state multistep.StateBag) multistep.StepAction {
oapiconn := state.Get("oapi").(*oapi.Client)
config := state.Get("clientConfig").(*oapi.Config)
config := state.Get("accessConfig").(*AccessConfig)
ui := state.Get("ui").(packer.Ui)
omis := state.Get("omis").(map[string]string)
snapshots := state.Get("snapshots").(map[string][]string)
@ -34,20 +33,20 @@ func (s *StepUpdateOMIAttributes) Run(_ context.Context, state multistep.StateBa
return multistep.ActionContinue
}
s.Ctx.Data = extractBuildInfo(oapiconn.GetConfig().Region, state)
s.Ctx.Data = extractBuildInfo(s.RawRegion, state)
updateSnapshoptRequest := oapi.UpdateSnapshotRequest{
PermissionsToCreateVolume: oapi.PermissionsOnResourceCreation{
Additions: oapi.PermissionsOnResource{
updateSnapshoptRequest := osc.UpdateSnapshotRequest{
PermissionsToCreateVolume: osc.PermissionsOnResourceCreation{
Additions: osc.PermissionsOnResource{
AccountIds: s.AccountIds,
GlobalPermission: false,
},
},
}
updateImageRequest := oapi.UpdateImageRequest{
PermissionsToLaunch: oapi.PermissionsOnResourceCreation{
Additions: oapi.PermissionsOnResource{
updateImageRequest := osc.UpdateImageRequest{
PermissionsToLaunch: osc.PermissionsOnResourceCreation{
Additions: osc.PermissionsOnResource{
AccountIds: s.AccountIds,
GlobalPermission: false,
},
@ -57,26 +56,31 @@ func (s *StepUpdateOMIAttributes) Run(_ context.Context, state multistep.StateBa
// Updating image attributes
for region, omi := range omis {
ui.Say(fmt.Sprintf("Updating attributes on OMI (%s)...", omi))
newConfig := &oapi.Config{
UserAgent: config.UserAgent,
AccessKey: config.AccessKey,
SecretKey: config.SecretKey,
Service: config.Service,
Region: region, //New region
URL: config.URL,
}
regionconn := config.NewOSCClientByRegion(region)
skipClient := &http.Client{
Transport: &http.Transport{
TLSClientConfig: &tls.Config{InsecureSkipVerify: true},
},
}
// newConfig := &osc.Configuration{
// UserAgent: config.UserAgent,
// AccessKey: config.AccessKey,
// SecretKey: config.SecretKey,
// Service: config.Service,
// Region: region, //New region
// URL: config.URL,
// }
regionconn := oapi.NewClient(newConfig, skipClient)
// skipClient := &http.Client{
// Transport: &http.Transport{
// TLSClientConfig: &tls.Config{InsecureSkipVerify: true},
// },
// }
//regionconn := oapi.NewClient(newConfig, skipClient)
ui.Message(fmt.Sprintf("Updating: %s", omi))
updateImageRequest.ImageId = omi
_, err := regionconn.POST_UpdateImage(updateImageRequest)
_, _, err := regionconn.ImageApi.UpdateImage(context.Background(), &osc.UpdateImageOpts{
UpdateImageRequest: optional.NewInterface(updateImageRequest),
})
if err != nil {
err := fmt.Errorf("Error updating OMI: %s", err)
state.Put("error", err)
@ -89,26 +93,13 @@ func (s *StepUpdateOMIAttributes) Run(_ context.Context, state multistep.StateBa
for region, region_snapshots := range snapshots {
for _, snapshot := range region_snapshots {
ui.Say(fmt.Sprintf("Updating attributes on snapshot (%s)...", snapshot))
newConfig := &oapi.Config{
UserAgent: config.UserAgent,
AccessKey: config.AccessKey,
SecretKey: config.SecretKey,
Service: config.Service,
Region: region, //New region
URL: config.URL,
}
skipClient := &http.Client{
Transport: &http.Transport{
TLSClientConfig: &tls.Config{InsecureSkipVerify: true},
},
}
regionconn := oapi.NewClient(newConfig, skipClient)
regionconn := config.NewOSCClientByRegion(region)
ui.Message(fmt.Sprintf("Updating: %s", snapshot))
updateSnapshoptRequest.SnapshotId = snapshot
_, err := regionconn.POST_UpdateSnapshot(updateSnapshoptRequest)
_, _, err := regionconn.SnapshotApi.UpdateSnapshot(context.Background(), &osc.UpdateSnapshotOpts{
UpdateSnapshotRequest: optional.NewInterface(updateSnapshoptRequest),
})
if err != nil {
err := fmt.Errorf("Error updating snapshot: %s", err)
state.Put("error", err)

26
builder/osc/common/tags.go
View File

@ -1,18 +1,20 @@
package common
import (
"context"
"fmt"
"github.com/antihax/optional"
"github.com/hashicorp/packer/helper/multistep"
"github.com/hashicorp/packer/packer"
"github.com/hashicorp/packer/template/interpolate"
"github.com/outscale/osc-go/oapi"
"github.com/outscale/osc-sdk-go/osc"
)
type TagMap map[string]string
type OAPITags []oapi.ResourceTag
type OSCTags []osc.ResourceTag
func (t OAPITags) Report(ui packer.Ui) {
func (t OSCTags) Report(ui packer.Ui) {
for _, tag := range t {
ui.Message(fmt.Sprintf("Adding tag: \"%s\": \"%s\"",
tag.Key, tag.Value))
@ -23,8 +25,8 @@ func (t TagMap) IsSet() bool {
return len(t) > 0
}
func (t TagMap) OAPITags(ctx interpolate.Context, region string, state multistep.StateBag) (OAPITags, error) {
var oapiTags []oapi.ResourceTag
func (t TagMap) OSCTags(ctx interpolate.Context, region string, state multistep.StateBag) (OSCTags, error) {
var oscTags []osc.ResourceTag
ctx.Data = extractBuildInfo(region, state)
for key, value := range t {
@ -36,20 +38,22 @@ func (t TagMap) OAPITags(ctx interpolate.Context, region string, state multistep
if err != nil {
return nil, fmt.Errorf("Error processing tag: %s:%s - %s", key, value, err)
}
oapiTags = append(oapiTags, oapi.ResourceTag{
oscTags = append(oscTags, osc.ResourceTag{
Key: interpolatedKey,
Value: interpolatedValue,
})
}
return oapiTags, nil
return oscTags, nil
}
func CreateTags(conn *oapi.Client, resourceID string, ui packer.Ui, tags OAPITags) error {
func CreateOSCTags(conn *osc.APIClient, resourceID string, ui packer.Ui, tags OSCTags) error {
tags.Report(ui)
_, err := conn.POST_CreateTags(oapi.CreateTagsRequest{
ResourceIds: []string{resourceID},
Tags: tags,
_, _, err := conn.TagApi.CreateTags(context.Background(), &osc.CreateTagsOpts{
CreateTagsRequest: optional.NewInterface(osc.CreateTagsRequest{
ResourceIds: []string{resourceID},
Tags: tags,
}),
})
return err

60
builder/osc/common/transport.go Normal file
View File

@ -0,0 +1,60 @@
package common
import (
"io/ioutil"
"net/http"
"strings"
"time"
"github.com/aws/aws-sdk-go/aws/credentials"
v4 "github.com/aws/aws-sdk-go/aws/signer/v4"
)
// Transport is used to sing the user for each request
type Transport struct {
transport http.RoundTripper
signer *v4.Signer
region string
}
func (t *Transport) sign(req *http.Request, body []byte) error {
reader := strings.NewReader(string(body))
timestamp := time.Now()
_, err := t.signer.Sign(req, reader, "osc", t.region, timestamp)
return err
}
// RoundTrip is implemented according with the interface RoundTrip to sing for each request
func (t *Transport) RoundTrip(req *http.Request) (*http.Response, error) {
//Get the body
getBody := req.GetBody
copyBody, err := getBody()
if err != nil {
return nil, err
}
body, err := ioutil.ReadAll(copyBody)
if err != nil {
return nil, err
}
if err := t.sign(req, body); err != nil {
return nil, err
}
resp, err := t.transport.RoundTrip(req)
if err != nil {
return resp, err
}
return resp, nil
}
// NewTransport returns the transport signing with the given credentials
func NewTransport(accessKey, accessSecret, region string, t http.RoundTripper) *Transport {
s := &v4.Signer{
Credentials: credentials.NewStaticCredentials(accessKey,
accessSecret, ""),
}
return &Transport{t, s, region}
}

2
command/build.go
View File

@ -390,7 +390,7 @@ Options:
-parallel-builds=1 Number of builds to run in parallel. 1 disables parallelization. 0 means no limit (Default: 0)
-timestamp-ui Enable prefixing of each ui output with an RFC3339 timestamp.
-var 'key=value' Variable for templates, can be used multiple times.
-var-file=path JSON file containing user variables.
-var-file=path JSON or HCL2 file containing user variables.
`
return strings.TrimSpace(helpText)

14
command/build_test.go
View File

@ -138,7 +138,7 @@ func TestBuild(t *testing.T) {
},
{
name: "build name: HCL",
name: "source name: HCL",
args: []string{
"-parallel-builds=1", // to ensure order is kept
testFixture("build-name-and-type"),
@ -297,7 +297,6 @@ func TestBuild(t *testing.T) {
},
},
},
{
name: "hcl - recipes - only recipes",
args: []string{
@ -314,6 +313,17 @@ func TestBuild(t *testing.T) {
},
},
},
{
name: "hcl - build.name accessible",
args: []string{
filepath.Join(testFixture("build-name-and-type"), "buildname.pkr.hcl"),
},
fileCheck: fileCheck{
expected: []string{
"pineapple.pizza.txt",
},
},
},
}
for _, tt := range tc {

2
command/console.go
View File

@ -81,7 +81,7 @@ Usage: packer console [options] [TEMPLATE]
Options:
-var 'key=value' Variable for templates, can be used multiple times.
-var-file=path JSON file containing user variables. [ Note that even in HCL mode this expects file to contain JSON, a fix is comming soon ]
-var-file=path JSON or HCL2 file containing user variables. [ Note that even in HCL mode this expects file to contain JSON, a fix is comming soon ]
`
return strings.TrimSpace(helpText)

14
command/hcl2_upgrade.go
View File

@ -55,7 +55,7 @@ func (c *HCL2UpgradeCommand) ParseArgs(args []string) (*HCL2UpgradeArgs, int) {
}
const (
hcl2UpgradeFileHeader = `# This file was autogenerate by the BETA 'packer hcl2_upgrade' command. We
hcl2UpgradeFileHeader = `# This file was autogenerated by the BETA 'packer hcl2_upgrade' command. We
# recommend double checking that everything is correct before going forward. We
# also recommend treating this file as disposable. The HCL2 blocks in this
# file can be moved to other files. For example, the variable blocks could be
@ -64,20 +64,20 @@ const (
# once they also need to be in the same folder. 'packer inspect folder/'
# will describe to you what is in that folder.
# All generated input variables will be of string type as this how Packer JSON
# views them; you can later on change their type. Read the variables type
# All generated input variables will be of 'string' type as this is how Packer JSON
# views them; you can change their type later on. Read the variables type
# constraints documentation
# https://www.packer.io/docs/from-1.5/variables#type-constraints for more info.
`
sourcesHeader = `
# source blocks are generated from your builders; a source can be referenced in
# build blocks. A build block runs provisioner and post-processors onto a
# build blocks. A build block runs provisioner and post-processors on a
# source. Read the documentation for source blocks here:
# https://www.packer.io/docs/from-1.5/blocks/source`
buildHeader = `
# a build block invokes sources and runs provisionning steps on them. The
# a build block invokes sources and runs provisioning steps on them. The
# documentation for build blocks can be found here:
# https://www.packer.io/docs/from-1.5/blocks/build
build {
@ -413,14 +413,14 @@ func (*HCL2UpgradeCommand) Help() string {
helpText := `
Usage: packer hcl2_upgrade -output-file=JSON_TEMPLATE.pkr.hcl JSON_TEMPLATE...
Will transform your JSON template to a HCL2 configuration.
Will transform your JSON template into an HCL2 configuration.
`
return strings.TrimSpace(helpText)
}
func (*HCL2UpgradeCommand) Synopsis() string {
return "transform a JSON template into a HCL2 configuration"
return "transform a JSON template into an HCL2 configuration"
}
func (*HCL2UpgradeCommand) AutocompleteArgs() complete.Predictor {

16
command/test-fixtures/build-name-and-type/buildname.pkr.hcl Normal file
View File

@ -0,0 +1,16 @@
source "null" "pizza" {
communicator = "none"
}
build {
name = "pineapple"
sources = [
"sources.null.pizza",
]
provisioner "shell-local" {
inline = [
"echo '' > ${build.name}.${source.name}.txt"
]
}
}

10
command/test-fixtures/hcl2_upgrade_basic/expected.pkr.hcl
View File

@ -1,4 +1,4 @@
# This file was autogenerate by the BETA 'packer hcl2_upgrade' command. We
# This file was autogenerated by the BETA 'packer hcl2_upgrade' command. We
# recommend double checking that everything is correct before going forward. We
# also recommend treating this file as disposable. The HCL2 blocks in this
# file can be moved to other files. For example, the variable blocks could be
@ -7,8 +7,8 @@
# once they also need to be in the same folder. 'packer inspect folder/'
# will describe to you what is in that folder.
# All generated input variables will be of string type as this how Packer JSON
# views them; you can later on change their type. Read the variables type
# All generated input variables will be of 'string' type as this is how Packer JSON
# views them; you can change their type later on. Read the variables type
# constraints documentation
# https://www.packer.io/docs/from-1.5/variables#type-constraints for more info.
variable "aws_access_key" {
@ -31,7 +31,7 @@ variable "aws_secret_key" {
locals { timestamp = regex_replace(timestamp(), "[- TZ:]", "") }
# source blocks are generated from your builders; a source can be referenced in
# build blocks. A build block runs provisioner and post-processors onto a
# build blocks. A build block runs provisioner and post-processors on a
# source. Read the documentation for source blocks here:
# https://www.packer.io/docs/from-1.5/blocks/source
source "amazon-ebs" "autogenerated_1" {
@ -70,7 +70,7 @@ source "amazon-ebs" "autogenerated_1" {
}
}
# a build block invokes sources and runs provisionning steps on them. The
# a build block invokes sources and runs provisioning steps on them. The
# documentation for build blocks can be found here:
# https://www.packer.io/docs/from-1.5/blocks/build
build {

2
command/validate.go
View File

@ -92,7 +92,7 @@ Options:
-except=foo,bar,baz Validate all builds other than these.
-only=foo,bar,baz Validate only these builds.
-var 'key=value' Variable for templates, can be used multiple times.
-var-file=path JSON file containing user variables. [ Note that even in HCL mode this expects file to contain JSON, a fix is comming soon ]
-var-file=path JSON or HCL2 file containing user variables. [ Note that even in HCL mode this expects file to contain JSON, a fix is comming soon ]
`
return strings.TrimSpace(helpText)

46
common/template/funcs.go
View File

@ -8,6 +8,8 @@ import (
"strings"
"sync"
consulapi "github.com/hashicorp/consul/api"
awssmapi "github.com/hashicorp/packer/template/interpolate/aws/secretsmanager"
vaultapi "github.com/hashicorp/vault/api"
)
@ -61,3 +63,47 @@ func Vault(path string, key string) (string, error) {
}
return "", errors.New("Vault path does not contain the requested key")
}
func Consul(k string) (string, error) {
consulConfig := consulapi.DefaultConfig()
client, err := consulapi.NewClient(consulConfig)
if err != nil {
return "", fmt.Errorf("error getting consul client: %s", err)
}
q := &consulapi.QueryOptions{}
kv, _, err := client.KV().Get(k, q)
if err != nil {
return "", fmt.Errorf("error reading consul key: %s", err)
}
if kv == nil {
return "", fmt.Errorf("key does not exist at the given path: %s", k)
}
value := string(kv.Value)
if value == "" {
return "", fmt.Errorf("value is empty at path %s", k)
}
return value, nil
}
func GetAWSSecret(name, key string) (string, error) {
// Check if at least 1 parameter has been used
if len(name) == 0 {
return "", errors.New("At least one secret name must be provided")
}
// client uses AWS SDK CredentialChain method. So,credentials can
// be loaded from credential file, environment variables, or IAM
// roles.
client := awssmapi.New(
&awssmapi.AWSConfig{},
)
spec := &awssmapi.SecretSpec{
Name: name,
Key: key,
}
return client.GetSecret(spec)
}

4
contrib/zsh-completion/_packer
View File

@ -20,7 +20,7 @@ _packer () {
'-parallel=[(false) Disable parallelization. (Default: false)]'
'-parallel-builds=[(0) Number of builds to run in parallel. (Defaults to infinite: 0)]'
'-var[("key=value") Variable for templates, can be used multiple times.]'
'-var-file=[(path) JSON file containing user variables.]'
'-var-file=[(path) JSON or HCL2 file containing user variables.]'
'(-)*:files:_files -g "*.json"'
)
@ -34,7 +34,7 @@ _packer () {
'-except=[(foo,bar,baz) Validate all builds other than these.]'
'-only=[(foo,bar,baz) Validate only these builds.]'
'-var[("key=value") Variable for templates, can be used multiple times.]'
'-var-file=[(path) JSON file containing user variables.]'
'-var-file=[(path) JSON or HCL2 file containing user variables.]'
'(-)*:files:_files -g "*.json"'
)

4
go.mod
View File

@ -20,6 +20,7 @@ require (
github.com/aliyun/aliyun-oss-go-sdk v0.0.0-20170113022742-e6dbea820a9f
github.com/antchfx/xpath v0.0.0-20170728053731-b5c552e1acbd // indirect
github.com/antchfx/xquery v0.0.0-20170730121040-eb8c3c172607 // indirect
github.com/antihax/optional v1.0.0
github.com/approvals/go-approval-tests v0.0.0-20160714161514-ad96e53bea43
github.com/armon/go-metrics v0.0.0-20190430140413-ec5e00d3c878 // indirect
github.com/aws/aws-sdk-go v1.34.26
@ -102,7 +103,8 @@ require (
github.com/nu7hatch/gouuid v0.0.0-20131221200532-179d4d0c4d8d // indirect
github.com/olekukonko/tablewriter v0.0.0-20180105111133-96aac992fc8b
github.com/oracle/oci-go-sdk v18.0.0+incompatible
github.com/outscale/osc-go v0.0.1
github.com/outscale/osc-go v0.0.1 // indirect
github.com/outscale/osc-sdk-go/osc v0.0.0-20200722135656-d654809d0699
github.com/packer-community/winrmcp v0.0.0-20180921204643-0fd363d6159a
github.com/pierrec/lz4 v2.0.5+incompatible
github.com/pkg/errors v0.9.1

4
go.sum
View File

@ -127,6 +127,7 @@ github.com/armon/go-radix v1.0.0 h1:F4z6KzEeeQIMeLFa97iZU6vupzoecKdU5TX24SNppXI=
github.com/armon/go-radix v1.0.0/go.mod h1:ufUuZ+zHj4x4TnLV4JWEpy2hxWSpsRywHrMgIH9cCH8=
github.com/aws/aws-sdk-go v1.15.78/go.mod h1:E3/ieXAlvM0XWO57iftYVDLLvQ824smPP3ATZkfNZeM=
github.com/aws/aws-sdk-go v1.16.22/go.mod h1:KmX6BPdI08NWTb3/sm4ZGu5ShLoqVDhKgpiN924inxo=
github.com/aws/aws-sdk-go v1.26.3/go.mod h1:KmX6BPdI08NWTb3/sm4ZGu5ShLoqVDhKgpiN924inxo=
github.com/aws/aws-sdk-go v1.30.8 h1:4BHbh8K3qKmcnAgToZ2LShldRF9inoqIBccpCLNCy3I=
github.com/aws/aws-sdk-go v1.30.8/go.mod h1:5zCpMtNQVjRREroY7sYe8lOMRSxkhG6MZveU8YkpAk0=
github.com/aws/aws-sdk-go v1.31.9/go.mod h1:5zCpMtNQVjRREroY7sYe8lOMRSxkhG6MZveU8YkpAk0=
@ -536,6 +537,9 @@ github.com/oracle/oci-go-sdk v18.0.0+incompatible h1:FLV4KixsVfF3rwyVTMI6Ryp/Q+O
github.com/oracle/oci-go-sdk v18.0.0+incompatible/go.mod h1:VQb79nF8Z2cwLkLS35ukwStZIg5F66tcBccjip/j888=
github.com/outscale/osc-go v0.0.1 h1:hvBtORyu7sWSKW1norGlfIP8C7c2aegI2Vkq75SRPCE=
github.com/outscale/osc-go v0.0.1/go.mod h1:hJLmXzqU/t07qQYh90I0TqZzu9s85Zs6FMrxk3ukiFM=
github.com/outscale/osc-sdk-go v1.2.0 h1:1HKr6OMLLVW4w6KQuiQwYZjhNaVz9mNzy/W3KW+zgnA=
github.com/outscale/osc-sdk-go/osc v0.0.0-20200722135656-d654809d0699 h1:SHe9i7h5cHe+cB77fQ6lsEgIwKg3ckNU90P03CjGMnI=
github.com/outscale/osc-sdk-go/osc v0.0.0-20200722135656-d654809d0699/go.mod h1:5AqqNH1X8zCHescKVlpSHRzrat1KCKDXqZoQPe8fY3A=
github.com/packer-community/winrmcp v0.0.0-20180921204643-0fd363d6159a h1:A3QMuteviunoaY/8ex+RKFqwhcZJ/Cf3fCW3IwL2wx4=
github.com/packer-community/winrmcp v0.0.0-20180921204643-0fd363d6159a/go.mod h1:f6Izs6JvFTdnRbziASagjZ2vmf55NSIkC/weStxCHqk=
github.com/pascaldekloe/goe v0.0.0-20180627143212-57f6aae5913c h1:Lgl0gzECD8GnQ5QCWA8o6BtfL6mDH5rQgM4/fX3avOs=

25
hcl2template/function/Consul.go Normal file
View File

@ -0,0 +1,25 @@
package function
import (
"github.com/zclconf/go-cty/cty"
"github.com/zclconf/go-cty/cty/function"
commontpl "github.com/hashicorp/packer/common/template"
)
// ConsulFunc constructs a function that retrieves KV secrets from HC vault
var ConsulFunc = function.New(&function.Spec{
Params: []function.Parameter{
{
Name: "key",
Type: cty.String,
},
},
Type: function.StaticReturnType(cty.String),
Impl: func(args []cty.Value, retType cty.Type) (cty.Value, error) {
key := args[0].AsString()
val, err := commontpl.Consul(key)
return cty.StringVal(val), err
},
})

39
hcl2template/function/aws_secretetkey.go Normal file
View File

@ -0,0 +1,39 @@
package function
import (
"github.com/zclconf/go-cty/cty"
"github.com/zclconf/go-cty/cty/function"
commontpl "github.com/hashicorp/packer/common/template"
)
// AWSSecret constructs a function that retrieves secrets from aws secrets
// manager. If Key field is not set then we will return first secret key stored
// in secret name.
var AWSSecret = function.New(&function.Spec{
Params: []function.Parameter{
{
Name: "name",
Type: cty.String,
AllowNull: false,
AllowUnknown: false,
},
{
Name: "key",
Type: cty.String,
AllowNull: true,
AllowUnknown: false,
},
},
Type: function.StaticReturnType(cty.String),
Impl: func(args []cty.Value, retType cty.Type) (cty.Value, error) {
name := args[0].AsString()
var key string
if !args[1].IsNull() && args[1].IsWhollyKnown() {
key = args[1].AsString()
}
val, err := commontpl.GetAWSSecret(name, key)
return cty.StringVal(val), err
},
})

168
hcl2template/functions.go
View File

@ -28,89 +28,91 @@ import (
func Functions(basedir string) map[string]function.Function {
funcs := map[string]function.Function{
"abs": stdlib.AbsoluteFunc,
"abspath": filesystem.AbsPathFunc,
"basename": filesystem.BasenameFunc,
"base64decode": encoding.Base64DecodeFunc,
"base64encode": encoding.Base64EncodeFunc,
"bcrypt": crypto.BcryptFunc,
"can": tryfunc.CanFunc,
"ceil": stdlib.CeilFunc,
"chomp": stdlib.ChompFunc,
"chunklist": stdlib.ChunklistFunc,
"cidrhost": cidr.HostFunc,
"cidrnetmask": cidr.NetmaskFunc,
"cidrsubnet": cidr.SubnetFunc,
"cidrsubnets": cidr.SubnetsFunc,
"coalesce": collection.CoalesceFunc,
"coalescelist": stdlib.CoalesceListFunc,
"compact": stdlib.CompactFunc,
"concat": stdlib.ConcatFunc,
"contains": stdlib.ContainsFunc,
"convert": typeexpr.ConvertFunc,
"csvdecode": stdlib.CSVDecodeFunc,
"dirname": filesystem.DirnameFunc,
"distinct": stdlib.DistinctFunc,
"element": stdlib.ElementFunc,
"file": filesystem.MakeFileFunc(basedir, false),
"fileexists": filesystem.MakeFileExistsFunc(basedir),
"fileset": filesystem.MakeFileSetFunc(basedir),
"flatten": stdlib.FlattenFunc,
"floor": stdlib.FloorFunc,
"format": stdlib.FormatFunc,
"formatdate": stdlib.FormatDateFunc,
"formatlist": stdlib.FormatListFunc,
"indent": stdlib.IndentFunc,
"index": stdlib.IndexFunc,
"join": stdlib.JoinFunc,
"jsondecode": stdlib.JSONDecodeFunc,
"jsonencode": stdlib.JSONEncodeFunc,
"keys": stdlib.KeysFunc,
"length": stdlib.LengthFunc,
"log": stdlib.LogFunc,
"lookup": stdlib.LookupFunc,
"lower": stdlib.LowerFunc,
"max": stdlib.MaxFunc,
"md5": crypto.Md5Func,
"merge": stdlib.MergeFunc,
"min": stdlib.MinFunc,
"parseint": stdlib.ParseIntFunc,
"pathexpand": filesystem.PathExpandFunc,
"pow": stdlib.PowFunc,
"range": stdlib.RangeFunc,
"reverse": stdlib.ReverseFunc,
"replace": stdlib.ReplaceFunc,
"regex_replace": stdlib.RegexReplaceFunc,
"rsadecrypt": crypto.RsaDecryptFunc,
"setintersection": stdlib.SetIntersectionFunc,
"setproduct": stdlib.SetProductFunc,
"setunion": stdlib.SetUnionFunc,
"sha1": crypto.Sha1Func,
"sha256": crypto.Sha256Func,
"sha512": crypto.Sha512Func,
"signum": stdlib.SignumFunc,
"slice": stdlib.SliceFunc,
"sort": stdlib.SortFunc,
"split": stdlib.SplitFunc,
"strrev": stdlib.ReverseFunc,
"substr": stdlib.SubstrFunc,
"timestamp": pkrfunction.TimestampFunc,
"timeadd": stdlib.TimeAddFunc,
"title": stdlib.TitleFunc,
"trim": stdlib.TrimFunc,
"trimprefix": stdlib.TrimPrefixFunc,
"trimspace": stdlib.TrimSpaceFunc,
"trimsuffix": stdlib.TrimSuffixFunc,
"try": tryfunc.TryFunc,
"upper": stdlib.UpperFunc,
"urlencode": encoding.URLEncodeFunc,
"uuidv4": uuid.V4Func,
"uuidv5": uuid.V5Func,
"values": stdlib.ValuesFunc,
"vault": pkrfunction.VaultFunc,
"yamldecode": ctyyaml.YAMLDecodeFunc,
"yamlencode": ctyyaml.YAMLEncodeFunc,
"zipmap": stdlib.ZipmapFunc,
"abs": stdlib.AbsoluteFunc,
"abspath": filesystem.AbsPathFunc,
"aws_secretsmanager": pkrfunction.AWSSecret,
"basename": filesystem.BasenameFunc,
"base64decode": encoding.Base64DecodeFunc,
"base64encode": encoding.Base64EncodeFunc,
"bcrypt": crypto.BcryptFunc,
"can": tryfunc.CanFunc,
"ceil": stdlib.CeilFunc,
"chomp": stdlib.ChompFunc,
"chunklist": stdlib.ChunklistFunc,
"cidrhost": cidr.HostFunc,
"cidrnetmask": cidr.NetmaskFunc,
"cidrsubnet": cidr.SubnetFunc,
"cidrsubnets": cidr.SubnetsFunc,
"coalesce": collection.CoalesceFunc,
"coalescelist": stdlib.CoalesceListFunc,
"compact": stdlib.CompactFunc,
"concat": stdlib.ConcatFunc,
"consul_key": pkrfunction.ConsulFunc,
"contains": stdlib.ContainsFunc,
"convert": typeexpr.ConvertFunc,
"csvdecode": stdlib.CSVDecodeFunc,
"dirname": filesystem.DirnameFunc,
"distinct": stdlib.DistinctFunc,
"element": stdlib.ElementFunc,
"file": filesystem.MakeFileFunc(basedir, false),
"fileexists": filesystem.MakeFileExistsFunc(basedir),
"fileset": filesystem.MakeFileSetFunc(basedir),
"flatten": stdlib.FlattenFunc,
"floor": stdlib.FloorFunc,
"format": stdlib.FormatFunc,
"formatdate": stdlib.FormatDateFunc,
"formatlist": stdlib.FormatListFunc,
"indent": stdlib.IndentFunc,
"index": stdlib.IndexFunc,
"join": stdlib.JoinFunc,
"jsondecode": stdlib.JSONDecodeFunc,
"jsonencode": stdlib.JSONEncodeFunc,
"keys": stdlib.KeysFunc,
"length": stdlib.LengthFunc,
"log": stdlib.LogFunc,
"lookup": stdlib.LookupFunc,
"lower": stdlib.LowerFunc,
"max": stdlib.MaxFunc,
"md5": crypto.Md5Func,
"merge": stdlib.MergeFunc,
"min": stdlib.MinFunc,
"parseint": stdlib.ParseIntFunc,
"pathexpand": filesystem.PathExpandFunc,
"pow": stdlib.PowFunc,
"range": stdlib.RangeFunc,
"reverse": stdlib.ReverseFunc,
"replace": stdlib.ReplaceFunc,
"regex_replace": stdlib.RegexReplaceFunc,
"rsadecrypt": crypto.RsaDecryptFunc,
"setintersection": stdlib.SetIntersectionFunc,
"setproduct": stdlib.SetProductFunc,
"setunion": stdlib.SetUnionFunc,
"sha1": crypto.Sha1Func,
"sha256": crypto.Sha256Func,
"sha512": crypto.Sha512Func,
"signum": stdlib.SignumFunc,
"slice": stdlib.SliceFunc,
"sort": stdlib.SortFunc,
"split": stdlib.SplitFunc,
"strrev": stdlib.ReverseFunc,
"substr": stdlib.SubstrFunc,
"timestamp": pkrfunction.TimestampFunc,
"timeadd": stdlib.TimeAddFunc,
"title": stdlib.TitleFunc,
"trim": stdlib.TrimFunc,
"trimprefix": stdlib.TrimPrefixFunc,
"trimspace": stdlib.TrimSpaceFunc,
"trimsuffix": stdlib.TrimSuffixFunc,
"try": tryfunc.TryFunc,
"upper": stdlib.UpperFunc,
"urlencode": encoding.URLEncodeFunc,
"uuidv4": uuid.V4Func,
"uuidv5": uuid.V5Func,
"values": stdlib.ValuesFunc,
"vault": pkrfunction.VaultFunc,
"yamldecode": ctyyaml.YAMLDecodeFunc,
"yamlencode": ctyyaml.YAMLEncodeFunc,
"zipmap": stdlib.ZipmapFunc,
}
return funcs

3
hcl2template/types.hcl_provisioner.go
View File

@ -31,6 +31,9 @@ func (p *HCL2Provisioner) HCL2Prepare(buildVars map[string]interface{}) error {
if len(buildVars) > 0 {
ectx = p.evalContext.NewChild()
buildValues := map[string]cty.Value{}
if !p.evalContext.Variables[buildAccessor].IsNull() {
buildValues = p.evalContext.Variables[buildAccessor].AsValueMap()
}
for k, v := range buildVars {
switch v := v.(type) {
case string:

6
hcl2template/types.packer_config.go
View File

@ -9,6 +9,7 @@ import (
"github.com/hashicorp/hcl/v2"
"github.com/hashicorp/hcl/v2/hclsyntax"
"github.com/hashicorp/packer/packer"
"github.com/hashicorp/packer/version"
"github.com/zclconf/go-cty/cty"
)
@ -60,6 +61,7 @@ const (
pathVariablesAccessor = "path"
sourcesAccessor = "source"
buildAccessor = "build"
packerAccessor = "packer"
)
// EvalContext returns the *hcl.EvalContext that will be passed to an hcl
@ -78,6 +80,9 @@ func (cfg *PackerConfig) EvalContext(variables map[string]cty.Value) *hcl.EvalCo
"name": cty.UnknownVal(cty.String),
}),
buildAccessor: cty.UnknownVal(cty.EmptyObject),
packerAccessor: cty.ObjectVal(map[string]cty.Value{
"version": cty.StringVal(version.FormattedVersion()),
}),
pathVariablesAccessor: cty.ObjectVal(map[string]cty.Value{
"cwd": cty.StringVal(strings.ReplaceAll(cfg.Cwd, `\`, `/`)),
"root": cty.StringVal(strings.ReplaceAll(cfg.Basedir, `\`, `/`)),
@ -383,6 +388,7 @@ func (cfg *PackerConfig) GetBuilds(opts packer.GetBuildsOptions) ([]packer.Build
for _, k := range append(packer.BuilderDataCommonKeys, generatedVars...) {
unknownBuildValues[k] = cty.StringVal("<unknown>")
}
unknownBuildValues["name"] = cty.StringVal(build.Name)
variables := map[string]cty.Value{
sourcesAccessor: cty.ObjectVal(src.ctyValues()),

3
template/interpolate/aws/secretsmanager/secretsmanager.go
View File

@ -53,6 +53,9 @@ func (c *Client) GetSecret(spec *SecretSpec) (string, error) {
SecretId: aws.String(spec.Name),
VersionStage: aws.String("AWSCURRENT"),
}
if spec.Name != "" {
params.VersionStage = aws.String(spec.Key)
}
resp, err := c.api.GetSecretValue(params)
if err != nil {

65
template/interpolate/funcs.go
View File

@ -10,11 +10,9 @@ import (
"text/template"
"time"
consulapi "github.com/hashicorp/consul/api"
commontpl "github.com/hashicorp/packer/common/template"
"github.com/hashicorp/packer/common/uuid"
"github.com/hashicorp/packer/helper/common"
awssmapi "github.com/hashicorp/packer/template/interpolate/aws/secretsmanager"
"github.com/hashicorp/packer/version"
strftime "github.com/jehiah/go-strftime"
)
@ -250,34 +248,14 @@ func funcGenPackerVersion(ctx *Context) interface{} {
}
func funcGenConsul(ctx *Context) interface{} {
return func(k string) (string, error) {
return func(key string) (string, error) {
if !ctx.EnableEnv {
// The error message doesn't have to be that detailed since
// semantic checks should catch this.
return "", errors.New("consul_key is not allowed here")
}
consulConfig := consulapi.DefaultConfig()
client, err := consulapi.NewClient(consulConfig)
if err != nil {
return "", fmt.Errorf("error getting consul client: %s", err)
}
q := &consulapi.QueryOptions{}
kv, _, err := client.KV().Get(k, q)
if err != nil {
return "", fmt.Errorf("error reading consul key: %s", err)
}
if kv == nil {
return "", fmt.Errorf("key does not exist at the given path: %s", k)
}
value := string(kv.Value)
if value == "" {
return "", fmt.Errorf("value is empty at path %s", k)
}
return value, nil
return commontpl.Consul(key)
}
}
@ -301,37 +279,16 @@ func funcGenAwsSecrets(ctx *Context) interface{} {
// semantic checks should catch this.
return "", errors.New("AWS Secrets Manager is only allowed in the variables section")
}
// Check if at least 1 parameter has been used
if len(secret) == 0 {
return "", errors.New("At least one secret name must be provided")
switch len(secret) {
case 0:
return "", errors.New("secret name must be provided")
case 1:
return commontpl.GetAWSSecret(secret[0], "")
case 2:
return commontpl.GetAWSSecret(secret[0], secret[1])
default:
return "", errors.New("only secret name and optional secret key can be provided.")
}
// client uses AWS SDK CredentialChain method. So,credentials can
// be loaded from credential file, environment variables, or IAM
// roles.
client := awssmapi.New(
&awssmapi.AWSConfig{},
)
var name, key string
name = secret[0]
// key is optional if not used we fetch the first
// value stored in given secret. If more than two parameters
// are passed we take second param and ignore the others
if len(secret) > 1 {
key = secret[1]
}
spec := &awssmapi.SecretSpec{
Name: name,
Key: key,
}
s, err := client.GetSecret(spec)
if err != nil {
return "", err
}
return s, nil
}
}

10477
vendor/github.com/outscale/osc-go/oapi/client.go generated vendored
View File

File diff suppressed because it is too large Load Diff

1213
vendor/github.com/outscale/osc-go/oapi/interface.go generated vendored
View File

File diff suppressed because it is too large Load Diff

527
vendor/github.com/outscale/osc-go/oapi/provider.go generated vendored
View File

@ -1,527 +0,0 @@
// GENERATED FILE: DO NOT EDIT!
package oapi
// To create a server, first write a class that implements this interface.
// Then pass an instance of it to Initialize().
type Provider interface {
//
POST_AcceptNetPeering(parameters *POST_AcceptNetPeeringParameters, responses *POST_AcceptNetPeeringResponses) (err error)
//
POST_AuthenticateAccount(parameters *POST_AuthenticateAccountParameters, responses *POST_AuthenticateAccountResponses) (err error)
//
POST_CheckSignature(parameters *POST_CheckSignatureParameters, responses *POST_CheckSignatureResponses) (err error)
//
POST_CopyAccount(parameters *POST_CopyAccountParameters, responses *POST_CopyAccountResponses) (err error)
//
POST_CreateAccount(parameters *POST_CreateAccountParameters, responses *POST_CreateAccountResponses) (err error)
//
POST_CreateApiKey(parameters *POST_CreateApiKeyParameters, responses *POST_CreateApiKeyResponses) (err error)
//
POST_CreateClientGateway(parameters *POST_CreateClientGatewayParameters, responses *POST_CreateClientGatewayResponses) (err error)
//
POST_CreateDhcpOptions(parameters *POST_CreateDhcpOptionsParameters, responses *POST_CreateDhcpOptionsResponses) (err error)
//
POST_CreateDirectLink(parameters *POST_CreateDirectLinkParameters, responses *POST_CreateDirectLinkResponses) (err error)
//
POST_CreateDirectLinkInterface(parameters *POST_CreateDirectLinkInterfaceParameters, responses *POST_CreateDirectLinkInterfaceResponses) (err error)
//
POST_CreateImage(parameters *POST_CreateImageParameters, responses *POST_CreateImageResponses) (err error)
//
POST_CreateImageExportTask(parameters *POST_CreateImageExportTaskParameters, responses *POST_CreateImageExportTaskResponses) (err error)
//
POST_CreateInternetService(parameters *POST_CreateInternetServiceParameters, responses *POST_CreateInternetServiceResponses) (err error)
//
POST_CreateKeypair(parameters *POST_CreateKeypairParameters, responses *POST_CreateKeypairResponses) (err error)
//
POST_CreateListenerRule(parameters *POST_CreateListenerRuleParameters, responses *POST_CreateListenerRuleResponses) (err error)
//
POST_CreateLoadBalancer(parameters *POST_CreateLoadBalancerParameters, responses *POST_CreateLoadBalancerResponses) (err error)
//
POST_CreateLoadBalancerListeners(parameters *POST_CreateLoadBalancerListenersParameters, responses *POST_CreateLoadBalancerListenersResponses) (err error)
//
POST_CreateLoadBalancerPolicy(parameters *POST_CreateLoadBalancerPolicyParameters, responses *POST_CreateLoadBalancerPolicyResponses) (err error)
//
POST_CreateNatService(parameters *POST_CreateNatServiceParameters, responses *POST_CreateNatServiceResponses) (err error)
//
POST_CreateNet(parameters *POST_CreateNetParameters, responses *POST_CreateNetResponses) (err error)
//
POST_CreateNetAccessPoint(parameters *POST_CreateNetAccessPointParameters, responses *POST_CreateNetAccessPointResponses) (err error)
//
POST_CreateNetPeering(parameters *POST_CreateNetPeeringParameters, responses *POST_CreateNetPeeringResponses) (err error)
//
POST_CreateNic(parameters *POST_CreateNicParameters, responses *POST_CreateNicResponses) (err error)
//
POST_CreatePolicy(parameters *POST_CreatePolicyParameters, responses *POST_CreatePolicyResponses) (err error)
//
POST_CreatePublicIp(parameters *POST_CreatePublicIpParameters, responses *POST_CreatePublicIpResponses) (err error)
//
POST_CreateRoute(parameters *POST_CreateRouteParameters, responses *POST_CreateRouteResponses) (err error)
//
POST_CreateRouteTable(parameters *POST_CreateRouteTableParameters, responses *POST_CreateRouteTableResponses) (err error)
//
POST_CreateSecurityGroup(parameters *POST_CreateSecurityGroupParameters, responses *POST_CreateSecurityGroupResponses) (err error)
//
POST_CreateSecurityGroupRule(parameters *POST_CreateSecurityGroupRuleParameters, responses *POST_CreateSecurityGroupRuleResponses) (err error)
//
POST_CreateServerCertificate(parameters *POST_CreateServerCertificateParameters, responses *POST_CreateServerCertificateResponses) (err error)
//
POST_CreateSnapshot(parameters *POST_CreateSnapshotParameters, responses *POST_CreateSnapshotResponses) (err error)
//
POST_CreateSnapshotExportTask(parameters *POST_CreateSnapshotExportTaskParameters, responses *POST_CreateSnapshotExportTaskResponses) (err error)
//
POST_CreateSubnet(parameters *POST_CreateSubnetParameters, responses *POST_CreateSubnetResponses) (err error)
//
POST_CreateTags(parameters *POST_CreateTagsParameters, responses *POST_CreateTagsResponses) (err error)
//
POST_CreateUser(parameters *POST_CreateUserParameters, responses *POST_CreateUserResponses) (err error)
//
POST_CreateUserGroup(parameters *POST_CreateUserGroupParameters, responses *POST_CreateUserGroupResponses) (err error)
//
POST_CreateVirtualGateway(parameters *POST_CreateVirtualGatewayParameters, responses *POST_CreateVirtualGatewayResponses) (err error)
//
POST_CreateVms(parameters *POST_CreateVmsParameters, responses *POST_CreateVmsResponses) (err error)
//
POST_CreateVolume(parameters *POST_CreateVolumeParameters, responses *POST_CreateVolumeResponses) (err error)
//
POST_CreateVpnConnection(parameters *POST_CreateVpnConnectionParameters, responses *POST_CreateVpnConnectionResponses) (err error)
//
POST_CreateVpnConnectionRoute(parameters *POST_CreateVpnConnectionRouteParameters, responses *POST_CreateVpnConnectionRouteResponses) (err error)
//
POST_DeleteApiKey(parameters *POST_DeleteApiKeyParameters, responses *POST_DeleteApiKeyResponses) (err error)
//
POST_DeleteClientGateway(parameters *POST_DeleteClientGatewayParameters, responses *POST_DeleteClientGatewayResponses) (err error)
//
POST_DeleteDhcpOptions(parameters *POST_DeleteDhcpOptionsParameters, responses *POST_DeleteDhcpOptionsResponses) (err error)
//
POST_DeleteDirectLink(parameters *POST_DeleteDirectLinkParameters, responses *POST_DeleteDirectLinkResponses) (err error)
//
POST_DeleteDirectLinkInterface(parameters *POST_DeleteDirectLinkInterfaceParameters, responses *POST_DeleteDirectLinkInterfaceResponses) (err error)
//
POST_DeleteExportTask(parameters *POST_DeleteExportTaskParameters, responses *POST_DeleteExportTaskResponses) (err error)
//
POST_DeleteImage(parameters *POST_DeleteImageParameters, responses *POST_DeleteImageResponses) (err error)
//
POST_DeleteInternetService(parameters *POST_DeleteInternetServiceParameters, responses *POST_DeleteInternetServiceResponses) (err error)
//
POST_DeleteKeypair(parameters *POST_DeleteKeypairParameters, responses *POST_DeleteKeypairResponses) (err error)
//
POST_DeleteListenerRule(parameters *POST_DeleteListenerRuleParameters, responses *POST_DeleteListenerRuleResponses) (err error)
//
POST_DeleteLoadBalancer(parameters *POST_DeleteLoadBalancerParameters, responses *POST_DeleteLoadBalancerResponses) (err error)
//
POST_DeleteLoadBalancerListeners(parameters *POST_DeleteLoadBalancerListenersParameters, responses *POST_DeleteLoadBalancerListenersResponses) (err error)
//
POST_DeleteLoadBalancerPolicy(parameters *POST_DeleteLoadBalancerPolicyParameters, responses *POST_DeleteLoadBalancerPolicyResponses) (err error)
//
POST_DeleteNatService(parameters *POST_DeleteNatServiceParameters, responses *POST_DeleteNatServiceResponses) (err error)
//
POST_DeleteNet(parameters *POST_DeleteNetParameters, responses *POST_DeleteNetResponses) (err error)
//
POST_DeleteNetAccessPoints(parameters *POST_DeleteNetAccessPointsParameters, responses *POST_DeleteNetAccessPointsResponses) (err error)
//
POST_DeleteNetPeering(parameters *POST_DeleteNetPeeringParameters, responses *POST_DeleteNetPeeringResponses) (err error)
//
POST_DeleteNic(parameters *POST_DeleteNicParameters, responses *POST_DeleteNicResponses) (err error)
//
POST_DeletePolicy(parameters *POST_DeletePolicyParameters, responses *POST_DeletePolicyResponses) (err error)
//
POST_DeletePublicIp(parameters *POST_DeletePublicIpParameters, responses *POST_DeletePublicIpResponses) (err error)
//
POST_DeleteRoute(parameters *POST_DeleteRouteParameters, responses *POST_DeleteRouteResponses) (err error)
//
POST_DeleteRouteTable(parameters *POST_DeleteRouteTableParameters, responses *POST_DeleteRouteTableResponses) (err error)
//
POST_DeleteSecurityGroup(parameters *POST_DeleteSecurityGroupParameters, responses *POST_DeleteSecurityGroupResponses) (err error)
//
POST_DeleteSecurityGroupRule(parameters *POST_DeleteSecurityGroupRuleParameters, responses *POST_DeleteSecurityGroupRuleResponses) (err error)
//
POST_DeleteServerCertificate(parameters *POST_DeleteServerCertificateParameters, responses *POST_DeleteServerCertificateResponses) (err error)
//
POST_DeleteSnapshot(parameters *POST_DeleteSnapshotParameters, responses *POST_DeleteSnapshotResponses) (err error)
//
POST_DeleteSubnet(parameters *POST_DeleteSubnetParameters, responses *POST_DeleteSubnetResponses) (err error)
//
POST_DeleteTags(parameters *POST_DeleteTagsParameters, responses *POST_DeleteTagsResponses) (err error)
//
POST_DeleteUser(parameters *POST_DeleteUserParameters, responses *POST_DeleteUserResponses) (err error)
//
POST_DeleteUserGroup(parameters *POST_DeleteUserGroupParameters, responses *POST_DeleteUserGroupResponses) (err error)
//
POST_DeleteVirtualGateway(parameters *POST_DeleteVirtualGatewayParameters, responses *POST_DeleteVirtualGatewayResponses) (err error)
//
POST_DeleteVms(parameters *POST_DeleteVmsParameters, responses *POST_DeleteVmsResponses) (err error)
//
POST_DeleteVolume(parameters *POST_DeleteVolumeParameters, responses *POST_DeleteVolumeResponses) (err error)
//
POST_DeleteVpnConnection(parameters *POST_DeleteVpnConnectionParameters, responses *POST_DeleteVpnConnectionResponses) (err error)
//
POST_DeleteVpnConnectionRoute(parameters *POST_DeleteVpnConnectionRouteParameters, responses *POST_DeleteVpnConnectionRouteResponses) (err error)
//
POST_DeregisterUserInUserGroup(parameters *POST_DeregisterUserInUserGroupParameters, responses *POST_DeregisterUserInUserGroupResponses) (err error)
//
POST_DeregisterVmsInLoadBalancer(parameters *POST_DeregisterVmsInLoadBalancerParameters, responses *POST_DeregisterVmsInLoadBalancerResponses) (err error)
//
POST_LinkInternetService(parameters *POST_LinkInternetServiceParameters, responses *POST_LinkInternetServiceResponses) (err error)
//
POST_LinkNic(parameters *POST_LinkNicParameters, responses *POST_LinkNicResponses) (err error)
//
POST_LinkPolicy(parameters *POST_LinkPolicyParameters, responses *POST_LinkPolicyResponses) (err error)
//
POST_LinkPrivateIps(parameters *POST_LinkPrivateIpsParameters, responses *POST_LinkPrivateIpsResponses) (err error)
//
POST_LinkPublicIp(parameters *POST_LinkPublicIpParameters, responses *POST_LinkPublicIpResponses) (err error)
//
POST_LinkRouteTable(parameters *POST_LinkRouteTableParameters, responses *POST_LinkRouteTableResponses) (err error)
//
POST_LinkVirtualGateway(parameters *POST_LinkVirtualGatewayParameters, responses *POST_LinkVirtualGatewayResponses) (err error)
//
POST_LinkVolume(parameters *POST_LinkVolumeParameters, responses *POST_LinkVolumeResponses) (err error)
//
POST_PurchaseReservedVmsOffer(parameters *POST_PurchaseReservedVmsOfferParameters, responses *POST_PurchaseReservedVmsOfferResponses) (err error)
//
POST_ReadAccount(parameters *POST_ReadAccountParameters, responses *POST_ReadAccountResponses) (err error)
//
POST_ReadAccountConsumption(parameters *POST_ReadAccountConsumptionParameters, responses *POST_ReadAccountConsumptionResponses) (err error)
//
POST_ReadAdminPassword(parameters *POST_ReadAdminPasswordParameters, responses *POST_ReadAdminPasswordResponses) (err error)
//
POST_ReadApiKeys(parameters *POST_ReadApiKeysParameters, responses *POST_ReadApiKeysResponses) (err error)
//
POST_ReadApiLogs(parameters *POST_ReadApiLogsParameters, responses *POST_ReadApiLogsResponses) (err error)
//
POST_ReadBillableDigest(parameters *POST_ReadBillableDigestParameters, responses *POST_ReadBillableDigestResponses) (err error)
//
POST_ReadCatalog(parameters *POST_ReadCatalogParameters, responses *POST_ReadCatalogResponses) (err error)
//
POST_ReadClientGateways(parameters *POST_ReadClientGatewaysParameters, responses *POST_ReadClientGatewaysResponses) (err error)
//
POST_ReadConsoleOutput(parameters *POST_ReadConsoleOutputParameters, responses *POST_ReadConsoleOutputResponses) (err error)
//
POST_ReadDhcpOptions(parameters *POST_ReadDhcpOptionsParameters, responses *POST_ReadDhcpOptionsResponses) (err error)
//
POST_ReadDirectLinkInterfaces(parameters *POST_ReadDirectLinkInterfacesParameters, responses *POST_ReadDirectLinkInterfacesResponses) (err error)
//
POST_ReadDirectLinks(parameters *POST_ReadDirectLinksParameters, responses *POST_ReadDirectLinksResponses) (err error)
//
POST_ReadImageExportTasks(parameters *POST_ReadImageExportTasksParameters, responses *POST_ReadImageExportTasksResponses) (err error)
//
POST_ReadImages(parameters *POST_ReadImagesParameters, responses *POST_ReadImagesResponses) (err error)
//
POST_ReadInternetServices(parameters *POST_ReadInternetServicesParameters, responses *POST_ReadInternetServicesResponses) (err error)
//
POST_ReadKeypairs(parameters *POST_ReadKeypairsParameters, responses *POST_ReadKeypairsResponses) (err error)
//
POST_ReadListenerRules(parameters *POST_ReadListenerRulesParameters, responses *POST_ReadListenerRulesResponses) (err error)
//
POST_ReadLoadBalancers(parameters *POST_ReadLoadBalancersParameters, responses *POST_ReadLoadBalancersResponses) (err error)
//
POST_ReadLocations(parameters *POST_ReadLocationsParameters, responses *POST_ReadLocationsResponses) (err error)
//
POST_ReadNatServices(parameters *POST_ReadNatServicesParameters, responses *POST_ReadNatServicesResponses) (err error)
//
POST_ReadNetAccessPointServices(parameters *POST_ReadNetAccessPointServicesParameters, responses *POST_ReadNetAccessPointServicesResponses) (err error)
//
POST_ReadNetAccessPoints(parameters *POST_ReadNetAccessPointsParameters, responses *POST_ReadNetAccessPointsResponses) (err error)
//
POST_ReadNetPeerings(parameters *POST_ReadNetPeeringsParameters, responses *POST_ReadNetPeeringsResponses) (err error)
//
POST_ReadNets(parameters *POST_ReadNetsParameters, responses *POST_ReadNetsResponses) (err error)
//
POST_ReadNics(parameters *POST_ReadNicsParameters, responses *POST_ReadNicsResponses) (err error)
//
POST_ReadPolicies(parameters *POST_ReadPoliciesParameters, responses *POST_ReadPoliciesResponses) (err error)
//
POST_ReadPrefixLists(parameters *POST_ReadPrefixListsParameters, responses *POST_ReadPrefixListsResponses) (err error)
//
POST_ReadProductTypes(parameters *POST_ReadProductTypesParameters, responses *POST_ReadProductTypesResponses) (err error)
//
POST_ReadPublicCatalog(parameters *POST_ReadPublicCatalogParameters, responses *POST_ReadPublicCatalogResponses) (err error)
//
POST_ReadPublicIpRanges(parameters *POST_ReadPublicIpRangesParameters, responses *POST_ReadPublicIpRangesResponses) (err error)
//
POST_ReadPublicIps(parameters *POST_ReadPublicIpsParameters, responses *POST_ReadPublicIpsResponses) (err error)
//
POST_ReadQuotas(parameters *POST_ReadQuotasParameters, responses *POST_ReadQuotasResponses) (err error)
//
POST_ReadRegionConfig(parameters *POST_ReadRegionConfigParameters, responses *POST_ReadRegionConfigResponses) (err error)
//
POST_ReadRegions(parameters *POST_ReadRegionsParameters, responses *POST_ReadRegionsResponses) (err error)
//
POST_ReadReservedVmOffers(parameters *POST_ReadReservedVmOffersParameters, responses *POST_ReadReservedVmOffersResponses) (err error)
//
POST_ReadReservedVms(parameters *POST_ReadReservedVmsParameters, responses *POST_ReadReservedVmsResponses) (err error)
//
POST_ReadRouteTables(parameters *POST_ReadRouteTablesParameters, responses *POST_ReadRouteTablesResponses) (err error)
//
POST_ReadSecurityGroups(parameters *POST_ReadSecurityGroupsParameters, responses *POST_ReadSecurityGroupsResponses) (err error)
//
POST_ReadServerCertificates(parameters *POST_ReadServerCertificatesParameters, responses *POST_ReadServerCertificatesResponses) (err error)
//
POST_ReadSnapshotExportTasks(parameters *POST_ReadSnapshotExportTasksParameters, responses *POST_ReadSnapshotExportTasksResponses) (err error)
//
POST_ReadSnapshots(parameters *POST_ReadSnapshotsParameters, responses *POST_ReadSnapshotsResponses) (err error)
//
POST_ReadSubnets(parameters *POST_ReadSubnetsParameters, responses *POST_ReadSubnetsResponses) (err error)
//
POST_ReadSubregions(parameters *POST_ReadSubregionsParameters, responses *POST_ReadSubregionsResponses) (err error)
//
POST_ReadTags(parameters *POST_ReadTagsParameters, responses *POST_ReadTagsResponses) (err error)
//
POST_ReadUserGroups(parameters *POST_ReadUserGroupsParameters, responses *POST_ReadUserGroupsResponses) (err error)
//
POST_ReadUsers(parameters *POST_ReadUsersParameters, responses *POST_ReadUsersResponses) (err error)
//
POST_ReadVirtualGateways(parameters *POST_ReadVirtualGatewaysParameters, responses *POST_ReadVirtualGatewaysResponses) (err error)
//
POST_ReadVmTypes(parameters *POST_ReadVmTypesParameters, responses *POST_ReadVmTypesResponses) (err error)
//
POST_ReadVms(parameters *POST_ReadVmsParameters, responses *POST_ReadVmsResponses) (err error)
//
POST_ReadVmsHealth(parameters *POST_ReadVmsHealthParameters, responses *POST_ReadVmsHealthResponses) (err error)
//
POST_ReadVmsState(parameters *POST_ReadVmsStateParameters, responses *POST_ReadVmsStateResponses) (err error)
//
POST_ReadVolumes(parameters *POST_ReadVolumesParameters, responses *POST_ReadVolumesResponses) (err error)
//
POST_ReadVpnConnections(parameters *POST_ReadVpnConnectionsParameters, responses *POST_ReadVpnConnectionsResponses) (err error)
//
POST_RebootVms(parameters *POST_RebootVmsParameters, responses *POST_RebootVmsResponses) (err error)
//
POST_RegisterUserInUserGroup(parameters *POST_RegisterUserInUserGroupParameters, responses *POST_RegisterUserInUserGroupResponses) (err error)
//
POST_RegisterVmsInLoadBalancer(parameters *POST_RegisterVmsInLoadBalancerParameters, responses *POST_RegisterVmsInLoadBalancerResponses) (err error)
//
POST_RejectNetPeering(parameters *POST_RejectNetPeeringParameters, responses *POST_RejectNetPeeringResponses) (err error)
//
POST_ResetAccountPassword(parameters *POST_ResetAccountPasswordParameters, responses *POST_ResetAccountPasswordResponses) (err error)
//
POST_SendResetPasswordEmail(parameters *POST_SendResetPasswordEmailParameters, responses *POST_SendResetPasswordEmailResponses) (err error)
//
POST_StartVms(parameters *POST_StartVmsParameters, responses *POST_StartVmsResponses) (err error)
//
POST_StopVms(parameters *POST_StopVmsParameters, responses *POST_StopVmsResponses) (err error)
//
POST_UnlinkInternetService(parameters *POST_UnlinkInternetServiceParameters, responses *POST_UnlinkInternetServiceResponses) (err error)
//
POST_UnlinkNic(parameters *POST_UnlinkNicParameters, responses *POST_UnlinkNicResponses) (err error)
//
POST_UnlinkPolicy(parameters *POST_UnlinkPolicyParameters, responses *POST_UnlinkPolicyResponses) (err error)
//
POST_UnlinkPrivateIps(parameters *POST_UnlinkPrivateIpsParameters, responses *POST_UnlinkPrivateIpsResponses) (err error)
//
POST_UnlinkPublicIp(parameters *POST_UnlinkPublicIpParameters, responses *POST_UnlinkPublicIpResponses) (err error)
//
POST_UnlinkRouteTable(parameters *POST_UnlinkRouteTableParameters, responses *POST_UnlinkRouteTableResponses) (err error)
//
POST_UnlinkVirtualGateway(parameters *POST_UnlinkVirtualGatewayParameters, responses *POST_UnlinkVirtualGatewayResponses) (err error)
//
POST_UnlinkVolume(parameters *POST_UnlinkVolumeParameters, responses *POST_UnlinkVolumeResponses) (err error)
//
POST_UpdateAccount(parameters *POST_UpdateAccountParameters, responses *POST_UpdateAccountResponses) (err error)
//
POST_UpdateApiKey(parameters *POST_UpdateApiKeyParameters, responses *POST_UpdateApiKeyResponses) (err error)
//
POST_UpdateHealthCheck(parameters *POST_UpdateHealthCheckParameters, responses *POST_UpdateHealthCheckResponses) (err error)
//
POST_UpdateImage(parameters *POST_UpdateImageParameters, responses *POST_UpdateImageResponses) (err error)
//
POST_UpdateKeypair(parameters *POST_UpdateKeypairParameters, responses *POST_UpdateKeypairResponses) (err error)
//
POST_UpdateListenerRule(parameters *POST_UpdateListenerRuleParameters, responses *POST_UpdateListenerRuleResponses) (err error)
//
POST_UpdateLoadBalancer(parameters *POST_UpdateLoadBalancerParameters, responses *POST_UpdateLoadBalancerResponses) (err error)
//
POST_UpdateNet(parameters *POST_UpdateNetParameters, responses *POST_UpdateNetResponses) (err error)
//
POST_UpdateNetAccessPoint(parameters *POST_UpdateNetAccessPointParameters, responses *POST_UpdateNetAccessPointResponses) (err error)
//
POST_UpdateNic(parameters *POST_UpdateNicParameters, responses *POST_UpdateNicResponses) (err error)
//
POST_UpdateRoute(parameters *POST_UpdateRouteParameters, responses *POST_UpdateRouteResponses) (err error)
//
POST_UpdateRoutePropagation(parameters *POST_UpdateRoutePropagationParameters, responses *POST_UpdateRoutePropagationResponses) (err error)
//
POST_UpdateServerCertificate(parameters *POST_UpdateServerCertificateParameters, responses *POST_UpdateServerCertificateResponses) (err error)
//
POST_UpdateSnapshot(parameters *POST_UpdateSnapshotParameters, responses *POST_UpdateSnapshotResponses) (err error)
//
POST_UpdateUser(parameters *POST_UpdateUserParameters, responses *POST_UpdateUserResponses) (err error)
//
POST_UpdateUserGroup(parameters *POST_UpdateUserGroupParameters, responses *POST_UpdateUserGroupResponses) (err error)
//
POST_UpdateVm(parameters *POST_UpdateVmParameters, responses *POST_UpdateVmResponses) (err error)
}

5660
vendor/github.com/outscale/osc-go/oapi/types.go generated vendored
View File

File diff suppressed because it is too large Load Diff

27
vendor/github.com/outscale/osc-go/utils/utils.go generated vendored
View File

@ -1,27 +0,0 @@
package utils
import (
"fmt"
"log"
"net/http"
"net/http/httputil"
)
// DebugRequest ...
func DebugRequest(req *http.Request) {
requestDump, err := httputil.DumpRequest(req, true)
if err != nil {
fmt.Println(err)
}
log.Printf("[DEBUG] Request\n%s", string(requestDump))
}
// DebugResponse ...
func DebugResponse(res *http.Response) {
responseDump, err := httputil.DumpResponse(res, true)
if err != nil {
fmt.Println(err)
}
log.Printf("[DEBUG] Response\n%s", string(responseDump))
}

24
vendor/github.com/outscale/osc-sdk-go/osc/.gitignore generated vendored Normal file
View File

@ -0,0 +1,24 @@
# Compiled Object files, Static and Dynamic libs (Shared Objects)
*.o
*.a
*.so
# Folders
_obj
_test
# Architecture specific extensions/prefixes
*.[568vq]
[568vq].out
*.cgo1.go
*.cgo2.c
_cgo_defun.c
_cgo_gotypes.go
_cgo_export.*
_testmain.go
*.exe
*.test
*.prof

23
vendor/github.com/outscale/osc-sdk-go/osc/.openapi-generator-ignore generated vendored Normal file
View File

@ -0,0 +1,23 @@
# OpenAPI Generator Ignore
# Generated by openapi-generator https://github.com/openapitools/openapi-generator
# Use this file to prevent files from being overwritten by the generator.
# The patterns follow closely to .gitignore or .dockerignore.
# As an example, the C# client generator defines ApiClient.cs.
# You can make changes and tell OpenAPI Generator to ignore just this file by uncommenting the following line:
#ApiClient.cs
# You can match any string of characters against a directory, file or extension with a single asterisk (*):
#foo/*/qux
# The above matches foo/bar/qux and foo/baz/qux, but not foo/bar/baz/qux
# You can recursively match patterns against a directory, file or extension with a double asterisk (**):
#foo/**/qux
# This matches foo/bar/qux, foo/baz/qux, and foo/bar/baz/qux
# You can also negate patterns with an exclamation (!).
# For example, you can ignore all files in a docs folder with the file extension .md:
#docs/*.md
# Then explicitly reverse the ignore rule for a single file:
#!docs/README.md

8
vendor/github.com/outscale/osc-sdk-go/osc/.travis.yml generated vendored Normal file
View File

@ -0,0 +1,8 @@
language: go
install:
- go get -d -v .
script:
- go build -v ./

689
vendor/github.com/outscale/osc-sdk-go/osc/README.md generated vendored Normal file
View File

@ -0,0 +1,689 @@
# Go API client for osc
Welcome to the 3DS OUTSCALE's API documentation.<br /><br />
The 3DS OUTSCALE API enables you to manage your resources in the 3DS OUTSCALE Cloud. This documentation describes the different actions available along with code examples.<br /><br />
Note that the 3DS OUTSCALE Cloud is compatible with Amazon Web Services (AWS) APIs, but some resources have different names in AWS than in the 3DS OUTSCALE API. You can find a list of the differences [here](https://wiki.outscale.net/display/EN/3DS+OUTSCALE+APIs+Reference).<br /><br />
You can also manage your resources using the [Cockpit](https://wiki.outscale.net/display/EN/About+Cockpit) web interface.
## Overview
This API client was generated by the [OpenAPI Generator](https://openapi-generator.tech) project. By using the [OpenAPI-spec](https://www.openapis.org/) from a remote server, you can easily generate an API client.
- API version: 1.2
- Package version: 1.0.0
- Build package: org.openapitools.codegen.languages.GoClientCodegen
## Installation
Install the following dependencies:
```shell
go get github.com/stretchr/testify/assert
go get golang.org/x/oauth2
go get github.com/aws/aws-sdk-go/aws
go get golang.org/x/net/context
go get github.com/antihax/optional
```
Put the package under your project folder and add the following in import:
```golang
import "./osc"
```
## Documentation for API Endpoints
All URIs are relative to *https://api.eu-west-2.outscale.com/api/v1*
Class | Method | HTTP request | Description
------------ | ------------- | ------------- | -------------
*AccessKeyApi* | [**CreateAccessKey**](docs/AccessKeyApi.md#createaccesskey) | **Post** /CreateAccessKey |
*AccessKeyApi* | [**DeleteAccessKey**](docs/AccessKeyApi.md#deleteaccesskey) | **Post** /DeleteAccessKey |
*AccessKeyApi* | [**ReadAccessKeys**](docs/AccessKeyApi.md#readaccesskeys) | **Post** /ReadAccessKeys |
*AccessKeyApi* | [**ReadSecretAccessKey**](docs/AccessKeyApi.md#readsecretaccesskey) | **Post** /ReadSecretAccessKey |
*AccessKeyApi* | [**UpdateAccessKey**](docs/AccessKeyApi.md#updateaccesskey) | **Post** /UpdateAccessKey |
*AccountApi* | [**CheckAuthentication**](docs/AccountApi.md#checkauthentication) | **Post** /CheckAuthentication |
*AccountApi* | [**CreateAccount**](docs/AccountApi.md#createaccount) | **Post** /CreateAccount |
*AccountApi* | [**ReadAccounts**](docs/AccountApi.md#readaccounts) | **Post** /ReadAccounts |
*AccountApi* | [**ResetAccountPassword**](docs/AccountApi.md#resetaccountpassword) | **Post** /ResetAccountPassword |
*AccountApi* | [**SendResetPasswordEmail**](docs/AccountApi.md#sendresetpasswordemail) | **Post** /SendResetPasswordEmail |
*AccountApi* | [**UpdateAccount**](docs/AccountApi.md#updateaccount) | **Post** /UpdateAccount |
*ApiLogApi* | [**ReadApiLogs**](docs/ApiLogApi.md#readapilogs) | **Post** /ReadApiLogs |
*ClientGatewayApi* | [**CreateClientGateway**](docs/ClientGatewayApi.md#createclientgateway) | **Post** /CreateClientGateway |
*ClientGatewayApi* | [**DeleteClientGateway**](docs/ClientGatewayApi.md#deleteclientgateway) | **Post** /DeleteClientGateway |
*ClientGatewayApi* | [**ReadClientGateways**](docs/ClientGatewayApi.md#readclientgateways) | **Post** /ReadClientGateways |
*DefaultApi* | [**ReadConsumptionAccount**](docs/DefaultApi.md#readconsumptionaccount) | **Post** /ReadConsumptionAccount |
*DhcpOptionApi* | [**CreateDhcpOptions**](docs/DhcpOptionApi.md#createdhcpoptions) | **Post** /CreateDhcpOptions |
*DhcpOptionApi* | [**DeleteDhcpOptions**](docs/DhcpOptionApi.md#deletedhcpoptions) | **Post** /DeleteDhcpOptions |
*DhcpOptionApi* | [**ReadDhcpOptions**](docs/DhcpOptionApi.md#readdhcpoptions) | **Post** /ReadDhcpOptions |
*DirectLinkApi* | [**CreateDirectLink**](docs/DirectLinkApi.md#createdirectlink) | **Post** /CreateDirectLink |
*DirectLinkApi* | [**DeleteDirectLink**](docs/DirectLinkApi.md#deletedirectlink) | **Post** /DeleteDirectLink |
*DirectLinkApi* | [**ReadDirectLinks**](docs/DirectLinkApi.md#readdirectlinks) | **Post** /ReadDirectLinks |
*DirectLinkInterfaceApi* | [**CreateDirectLinkInterface**](docs/DirectLinkInterfaceApi.md#createdirectlinkinterface) | **Post** /CreateDirectLinkInterface |
*DirectLinkInterfaceApi* | [**DeleteDirectLinkInterface**](docs/DirectLinkInterfaceApi.md#deletedirectlinkinterface) | **Post** /DeleteDirectLinkInterface |
*DirectLinkInterfaceApi* | [**ReadDirectLinkInterfaces**](docs/DirectLinkInterfaceApi.md#readdirectlinkinterfaces) | **Post** /ReadDirectLinkInterfaces |
*FlexibleGpuApi* | [**CreateFlexibleGpu**](docs/FlexibleGpuApi.md#createflexiblegpu) | **Post** /CreateFlexibleGpu |
*FlexibleGpuApi* | [**DeleteFlexibleGpu**](docs/FlexibleGpuApi.md#deleteflexiblegpu) | **Post** /DeleteFlexibleGpu |
*FlexibleGpuApi* | [**LinkFlexibleGpu**](docs/FlexibleGpuApi.md#linkflexiblegpu) | **Post** /LinkFlexibleGpu |
*FlexibleGpuApi* | [**ReadFlexibleGpuCatalog**](docs/FlexibleGpuApi.md#readflexiblegpucatalog) | **Post** /ReadFlexibleGpuCatalog |
*FlexibleGpuApi* | [**ReadFlexibleGpus**](docs/FlexibleGpuApi.md#readflexiblegpus) | **Post** /ReadFlexibleGpus |
*FlexibleGpuApi* | [**UnlinkFlexibleGpu**](docs/FlexibleGpuApi.md#unlinkflexiblegpu) | **Post** /UnlinkFlexibleGpu |
*FlexibleGpuApi* | [**UpdateFlexibleGpu**](docs/FlexibleGpuApi.md#updateflexiblegpu) | **Post** /UpdateFlexibleGpu |
*ImageApi* | [**CreateImage**](docs/ImageApi.md#createimage) | **Post** /CreateImage |
*ImageApi* | [**CreateImageExportTask**](docs/ImageApi.md#createimageexporttask) | **Post** /CreateImageExportTask |
*ImageApi* | [**DeleteImage**](docs/ImageApi.md#deleteimage) | **Post** /DeleteImage |
*ImageApi* | [**ReadImageExportTasks**](docs/ImageApi.md#readimageexporttasks) | **Post** /ReadImageExportTasks |
*ImageApi* | [**ReadImages**](docs/ImageApi.md#readimages) | **Post** /ReadImages |
*ImageApi* | [**UpdateImage**](docs/ImageApi.md#updateimage) | **Post** /UpdateImage |
*InternetServiceApi* | [**CreateInternetService**](docs/InternetServiceApi.md#createinternetservice) | **Post** /CreateInternetService |
*InternetServiceApi* | [**DeleteInternetService**](docs/InternetServiceApi.md#deleteinternetservice) | **Post** /DeleteInternetService |
*InternetServiceApi* | [**LinkInternetService**](docs/InternetServiceApi.md#linkinternetservice) | **Post** /LinkInternetService |
*InternetServiceApi* | [**ReadInternetServices**](docs/InternetServiceApi.md#readinternetservices) | **Post** /ReadInternetServices |
*InternetServiceApi* | [**UnlinkInternetService**](docs/InternetServiceApi.md#unlinkinternetservice) | **Post** /UnlinkInternetService |
*KeypairApi* | [**CreateKeypair**](docs/KeypairApi.md#createkeypair) | **Post** /CreateKeypair |
*KeypairApi* | [**DeleteKeypair**](docs/KeypairApi.md#deletekeypair) | **Post** /DeleteKeypair |
*KeypairApi* | [**ReadKeypairs**](docs/KeypairApi.md#readkeypairs) | **Post** /ReadKeypairs |
*ListenerApi* | [**CreateListenerRule**](docs/ListenerApi.md#createlistenerrule) | **Post** /CreateListenerRule |
*ListenerApi* | [**CreateLoadBalancerListeners**](docs/ListenerApi.md#createloadbalancerlisteners) | **Post** /CreateLoadBalancerListeners |
*ListenerApi* | [**DeleteListenerRule**](docs/ListenerApi.md#deletelistenerrule) | **Post** /DeleteListenerRule |
*ListenerApi* | [**DeleteLoadBalancerListeners**](docs/ListenerApi.md#deleteloadbalancerlisteners) | **Post** /DeleteLoadBalancerListeners |
*ListenerApi* | [**ReadListenerRules**](docs/ListenerApi.md#readlistenerrules) | **Post** /ReadListenerRules |
*ListenerApi* | [**UpdateListenerRule**](docs/ListenerApi.md#updatelistenerrule) | **Post** /UpdateListenerRule |
*LoadBalancerApi* | [**CreateLoadBalancer**](docs/LoadBalancerApi.md#createloadbalancer) | **Post** /CreateLoadBalancer |
*LoadBalancerApi* | [**CreateLoadBalancerTags**](docs/LoadBalancerApi.md#createloadbalancertags) | **Post** /CreateLoadBalancerTags |
*LoadBalancerApi* | [**DeleteLoadBalancer**](docs/LoadBalancerApi.md#deleteloadbalancer) | **Post** /DeleteLoadBalancer |
*LoadBalancerApi* | [**DeleteLoadBalancerTags**](docs/LoadBalancerApi.md#deleteloadbalancertags) | **Post** /DeleteLoadBalancerTags |
*LoadBalancerApi* | [**DeregisterVmsInLoadBalancer**](docs/LoadBalancerApi.md#deregistervmsinloadbalancer) | **Post** /DeregisterVmsInLoadBalancer |
*LoadBalancerApi* | [**ReadLoadBalancerTags**](docs/LoadBalancerApi.md#readloadbalancertags) | **Post** /ReadLoadBalancerTags |
*LoadBalancerApi* | [**ReadLoadBalancers**](docs/LoadBalancerApi.md#readloadbalancers) | **Post** /ReadLoadBalancers |
*LoadBalancerApi* | [**ReadVmsHealth**](docs/LoadBalancerApi.md#readvmshealth) | **Post** /ReadVmsHealth |
*LoadBalancerApi* | [**RegisterVmsInLoadBalancer**](docs/LoadBalancerApi.md#registervmsinloadbalancer) | **Post** /RegisterVmsInLoadBalancer |
*LoadBalancerApi* | [**UpdateLoadBalancer**](docs/LoadBalancerApi.md#updateloadbalancer) | **Post** /UpdateLoadBalancer |
*LoadBalancerPolicyApi* | [**CreateLoadBalancerPolicy**](docs/LoadBalancerPolicyApi.md#createloadbalancerpolicy) | **Post** /CreateLoadBalancerPolicy |
*LoadBalancerPolicyApi* | [**DeleteLoadBalancerPolicy**](docs/LoadBalancerPolicyApi.md#deleteloadbalancerpolicy) | **Post** /DeleteLoadBalancerPolicy |
*LocationApi* | [**ReadLocations**](docs/LocationApi.md#readlocations) | **Post** /ReadLocations |
*NatServiceApi* | [**CreateNatService**](docs/NatServiceApi.md#createnatservice) | **Post** /CreateNatService |
*NatServiceApi* | [**DeleteNatService**](docs/NatServiceApi.md#deletenatservice) | **Post** /DeleteNatService |
*NatServiceApi* | [**ReadNatServices**](docs/NatServiceApi.md#readnatservices) | **Post** /ReadNatServices |
*NetApi* | [**CreateNet**](docs/NetApi.md#createnet) | **Post** /CreateNet |
*NetApi* | [**DeleteNet**](docs/NetApi.md#deletenet) | **Post** /DeleteNet |
*NetApi* | [**ReadNets**](docs/NetApi.md#readnets) | **Post** /ReadNets |
*NetApi* | [**UpdateNet**](docs/NetApi.md#updatenet) | **Post** /UpdateNet |
*NetAccessPointApi* | [**CreateNetAccessPoint**](docs/NetAccessPointApi.md#createnetaccesspoint) | **Post** /CreateNetAccessPoint |
*NetAccessPointApi* | [**DeleteNetAccessPoint**](docs/NetAccessPointApi.md#deletenetaccesspoint) | **Post** /DeleteNetAccessPoint |
*NetAccessPointApi* | [**ReadNetAccessPointServices**](docs/NetAccessPointApi.md#readnetaccesspointservices) | **Post** /ReadNetAccessPointServices |
*NetAccessPointApi* | [**ReadNetAccessPoints**](docs/NetAccessPointApi.md#readnetaccesspoints) | **Post** /ReadNetAccessPoints |
*NetAccessPointApi* | [**UpdateNetAccessPoint**](docs/NetAccessPointApi.md#updatenetaccesspoint) | **Post** /UpdateNetAccessPoint |
*NetPeeringApi* | [**AcceptNetPeering**](docs/NetPeeringApi.md#acceptnetpeering) | **Post** /AcceptNetPeering |
*NetPeeringApi* | [**CreateNetPeering**](docs/NetPeeringApi.md#createnetpeering) | **Post** /CreateNetPeering |
*NetPeeringApi* | [**DeleteNetPeering**](docs/NetPeeringApi.md#deletenetpeering) | **Post** /DeleteNetPeering |
*NetPeeringApi* | [**ReadNetPeerings**](docs/NetPeeringApi.md#readnetpeerings) | **Post** /ReadNetPeerings |
*NetPeeringApi* | [**RejectNetPeering**](docs/NetPeeringApi.md#rejectnetpeering) | **Post** /RejectNetPeering |
*NicApi* | [**CreateNic**](docs/NicApi.md#createnic) | **Post** /CreateNic |
*NicApi* | [**DeleteNic**](docs/NicApi.md#deletenic) | **Post** /DeleteNic |
*NicApi* | [**LinkNic**](docs/NicApi.md#linknic) | **Post** /LinkNic |
*NicApi* | [**LinkPrivateIps**](docs/NicApi.md#linkprivateips) | **Post** /LinkPrivateIps |
*NicApi* | [**ReadNics**](docs/NicApi.md#readnics) | **Post** /ReadNics |
*NicApi* | [**UnlinkNic**](docs/NicApi.md#unlinknic) | **Post** /UnlinkNic |
*NicApi* | [**UnlinkPrivateIps**](docs/NicApi.md#unlinkprivateips) | **Post** /UnlinkPrivateIps |
*NicApi* | [**UpdateNic**](docs/NicApi.md#updatenic) | **Post** /UpdateNic |
*ProductTypeApi* | [**ReadProductTypes**](docs/ProductTypeApi.md#readproducttypes) | **Post** /ReadProductTypes |
*PublicIpApi* | [**CreatePublicIp**](docs/PublicIpApi.md#createpublicip) | **Post** /CreatePublicIp |
*PublicIpApi* | [**DeletePublicIp**](docs/PublicIpApi.md#deletepublicip) | **Post** /DeletePublicIp |
*PublicIpApi* | [**LinkPublicIp**](docs/PublicIpApi.md#linkpublicip) | **Post** /LinkPublicIp |
*PublicIpApi* | [**ReadPublicIpRanges**](docs/PublicIpApi.md#readpublicipranges) | **Post** /ReadPublicIpRanges |
*PublicIpApi* | [**ReadPublicIps**](docs/PublicIpApi.md#readpublicips) | **Post** /ReadPublicIps |
*PublicIpApi* | [**UnlinkPublicIp**](docs/PublicIpApi.md#unlinkpublicip) | **Post** /UnlinkPublicIp |
*QuotaApi* | [**ReadQuotas**](docs/QuotaApi.md#readquotas) | **Post** /ReadQuotas |
*RegionApi* | [**ReadRegions**](docs/RegionApi.md#readregions) | **Post** /ReadRegions |
*RouteApi* | [**CreateRoute**](docs/RouteApi.md#createroute) | **Post** /CreateRoute |
*RouteApi* | [**DeleteRoute**](docs/RouteApi.md#deleteroute) | **Post** /DeleteRoute |
*RouteApi* | [**UpdateRoute**](docs/RouteApi.md#updateroute) | **Post** /UpdateRoute |
*RouteTableApi* | [**CreateRouteTable**](docs/RouteTableApi.md#createroutetable) | **Post** /CreateRouteTable |
*RouteTableApi* | [**DeleteRouteTable**](docs/RouteTableApi.md#deleteroutetable) | **Post** /DeleteRouteTable |
*RouteTableApi* | [**LinkRouteTable**](docs/RouteTableApi.md#linkroutetable) | **Post** /LinkRouteTable |
*RouteTableApi* | [**ReadRouteTables**](docs/RouteTableApi.md#readroutetables) | **Post** /ReadRouteTables |
*RouteTableApi* | [**UnlinkRouteTable**](docs/RouteTableApi.md#unlinkroutetable) | **Post** /UnlinkRouteTable |
*SecurityGroupApi* | [**CreateSecurityGroup**](docs/SecurityGroupApi.md#createsecuritygroup) | **Post** /CreateSecurityGroup |
*SecurityGroupApi* | [**DeleteSecurityGroup**](docs/SecurityGroupApi.md#deletesecuritygroup) | **Post** /DeleteSecurityGroup |
*SecurityGroupApi* | [**ReadSecurityGroups**](docs/SecurityGroupApi.md#readsecuritygroups) | **Post** /ReadSecurityGroups |
*SecurityGroupRuleApi* | [**CreateSecurityGroupRule**](docs/SecurityGroupRuleApi.md#createsecuritygrouprule) | **Post** /CreateSecurityGroupRule |
*SecurityGroupRuleApi* | [**DeleteSecurityGroupRule**](docs/SecurityGroupRuleApi.md#deletesecuritygrouprule) | **Post** /DeleteSecurityGroupRule |
*ServerCertificateApi* | [**CreateServerCertificate**](docs/ServerCertificateApi.md#createservercertificate) | **Post** /CreateServerCertificate |
*ServerCertificateApi* | [**DeleteServerCertificate**](docs/ServerCertificateApi.md#deleteservercertificate) | **Post** /DeleteServerCertificate |
*ServerCertificateApi* | [**ReadServerCertificates**](docs/ServerCertificateApi.md#readservercertificates) | **Post** /ReadServerCertificates |
*ServerCertificateApi* | [**UpdateServerCertificate**](docs/ServerCertificateApi.md#updateservercertificate) | **Post** /UpdateServerCertificate |
*SnapshotApi* | [**CreateSnapshot**](docs/SnapshotApi.md#createsnapshot) | **Post** /CreateSnapshot |
*SnapshotApi* | [**CreateSnapshotExportTask**](docs/SnapshotApi.md#createsnapshotexporttask) | **Post** /CreateSnapshotExportTask |
*SnapshotApi* | [**DeleteSnapshot**](docs/SnapshotApi.md#deletesnapshot) | **Post** /DeleteSnapshot |
*SnapshotApi* | [**ReadSnapshotExportTasks**](docs/SnapshotApi.md#readsnapshotexporttasks) | **Post** /ReadSnapshotExportTasks |
*SnapshotApi* | [**ReadSnapshots**](docs/SnapshotApi.md#readsnapshots) | **Post** /ReadSnapshots |
*SnapshotApi* | [**UpdateSnapshot**](docs/SnapshotApi.md#updatesnapshot) | **Post** /UpdateSnapshot |
*SubnetApi* | [**CreateSubnet**](docs/SubnetApi.md#createsubnet) | **Post** /CreateSubnet |
*SubnetApi* | [**DeleteSubnet**](docs/SubnetApi.md#deletesubnet) | **Post** /DeleteSubnet |
*SubnetApi* | [**ReadSubnets**](docs/SubnetApi.md#readsubnets) | **Post** /ReadSubnets |
*SubnetApi* | [**UpdateSubnet**](docs/SubnetApi.md#updatesubnet) | **Post** /UpdateSubnet |
*SubregionApi* | [**ReadSubregions**](docs/SubregionApi.md#readsubregions) | **Post** /ReadSubregions |
*TagApi* | [**CreateTags**](docs/TagApi.md#createtags) | **Post** /CreateTags |
*TagApi* | [**DeleteTags**](docs/TagApi.md#deletetags) | **Post** /DeleteTags |
*TagApi* | [**ReadTags**](docs/TagApi.md#readtags) | **Post** /ReadTags |
*TaskApi* | [**DeleteExportTask**](docs/TaskApi.md#deleteexporttask) | **Post** /DeleteExportTask |
*VirtualGatewayApi* | [**CreateVirtualGateway**](docs/VirtualGatewayApi.md#createvirtualgateway) | **Post** /CreateVirtualGateway |
*VirtualGatewayApi* | [**DeleteVirtualGateway**](docs/VirtualGatewayApi.md#deletevirtualgateway) | **Post** /DeleteVirtualGateway |
*VirtualGatewayApi* | [**LinkVirtualGateway**](docs/VirtualGatewayApi.md#linkvirtualgateway) | **Post** /LinkVirtualGateway |
*VirtualGatewayApi* | [**ReadVirtualGateways**](docs/VirtualGatewayApi.md#readvirtualgateways) | **Post** /ReadVirtualGateways |
*VirtualGatewayApi* | [**UnlinkVirtualGateway**](docs/VirtualGatewayApi.md#unlinkvirtualgateway) | **Post** /UnlinkVirtualGateway |
*VirtualGatewayApi* | [**UpdateRoutePropagation**](docs/VirtualGatewayApi.md#updateroutepropagation) | **Post** /UpdateRoutePropagation |
*VmApi* | [**CreateVms**](docs/VmApi.md#createvms) | **Post** /CreateVms |
*VmApi* | [**DeleteVms**](docs/VmApi.md#deletevms) | **Post** /DeleteVms |
*VmApi* | [**ReadAdminPassword**](docs/VmApi.md#readadminpassword) | **Post** /ReadAdminPassword |
*VmApi* | [**ReadConsoleOutput**](docs/VmApi.md#readconsoleoutput) | **Post** /ReadConsoleOutput |
*VmApi* | [**ReadVmTypes**](docs/VmApi.md#readvmtypes) | **Post** /ReadVmTypes |
*VmApi* | [**ReadVms**](docs/VmApi.md#readvms) | **Post** /ReadVms |
*VmApi* | [**ReadVmsState**](docs/VmApi.md#readvmsstate) | **Post** /ReadVmsState |
*VmApi* | [**RebootVms**](docs/VmApi.md#rebootvms) | **Post** /RebootVms |
*VmApi* | [**StartVms**](docs/VmApi.md#startvms) | **Post** /StartVms |
*VmApi* | [**StopVms**](docs/VmApi.md#stopvms) | **Post** /StopVms |
*VmApi* | [**UpdateVm**](docs/VmApi.md#updatevm) | **Post** /UpdateVm |
*VolumeApi* | [**CreateVolume**](docs/VolumeApi.md#createvolume) | **Post** /CreateVolume |
*VolumeApi* | [**DeleteVolume**](docs/VolumeApi.md#deletevolume) | **Post** /DeleteVolume |
*VolumeApi* | [**LinkVolume**](docs/VolumeApi.md#linkvolume) | **Post** /LinkVolume |
*VolumeApi* | [**ReadVolumes**](docs/VolumeApi.md#readvolumes) | **Post** /ReadVolumes |
*VolumeApi* | [**UnlinkVolume**](docs/VolumeApi.md#unlinkvolume) | **Post** /UnlinkVolume |
*VpnConnectionApi* | [**CreateVpnConnection**](docs/VpnConnectionApi.md#createvpnconnection) | **Post** /CreateVpnConnection |
*VpnConnectionApi* | [**CreateVpnConnectionRoute**](docs/VpnConnectionApi.md#createvpnconnectionroute) | **Post** /CreateVpnConnectionRoute |
*VpnConnectionApi* | [**DeleteVpnConnection**](docs/VpnConnectionApi.md#deletevpnconnection) | **Post** /DeleteVpnConnection |
*VpnConnectionApi* | [**DeleteVpnConnectionRoute**](docs/VpnConnectionApi.md#deletevpnconnectionroute) | **Post** /DeleteVpnConnectionRoute |
*VpnConnectionApi* | [**ReadVpnConnections**](docs/VpnConnectionApi.md#readvpnconnections) | **Post** /ReadVpnConnections |
## Documentation For Models
- [AcceptNetPeeringRequest](docs/AcceptNetPeeringRequest.md)
- [AcceptNetPeeringResponse](docs/AcceptNetPeeringResponse.md)
- [AccepterNet](docs/AccepterNet.md)
- [AccessKey](docs/AccessKey.md)
- [AccessKeySecretKey](docs/AccessKeySecretKey.md)
- [AccessLog](docs/AccessLog.md)
- [Account](docs/Account.md)
- [ApplicationStickyCookiePolicy](docs/ApplicationStickyCookiePolicy.md)
- [BackendVmHealth](docs/BackendVmHealth.md)
- [BlockDeviceMappingCreated](docs/BlockDeviceMappingCreated.md)
- [BlockDeviceMappingImage](docs/BlockDeviceMappingImage.md)
- [BlockDeviceMappingVmCreation](docs/BlockDeviceMappingVmCreation.md)
- [BlockDeviceMappingVmUpdate](docs/BlockDeviceMappingVmUpdate.md)
- [BsuCreated](docs/BsuCreated.md)
- [BsuToCreate](docs/BsuToCreate.md)
- [BsuToUpdateVm](docs/BsuToUpdateVm.md)
- [CheckAuthenticationRequest](docs/CheckAuthenticationRequest.md)
- [CheckAuthenticationResponse](docs/CheckAuthenticationResponse.md)
- [ClientGateway](docs/ClientGateway.md)
- [ConsumptionEntry](docs/ConsumptionEntry.md)
- [CreateAccessKeyRequest](docs/CreateAccessKeyRequest.md)
- [CreateAccessKeyResponse](docs/CreateAccessKeyResponse.md)
- [CreateAccountRequest](docs/CreateAccountRequest.md)
- [CreateAccountResponse](docs/CreateAccountResponse.md)
- [CreateClientGatewayRequest](docs/CreateClientGatewayRequest.md)
- [CreateClientGatewayResponse](docs/CreateClientGatewayResponse.md)
- [CreateDhcpOptionsRequest](docs/CreateDhcpOptionsRequest.md)
- [CreateDhcpOptionsResponse](docs/CreateDhcpOptionsResponse.md)
- [CreateDirectLinkInterfaceRequest](docs/CreateDirectLinkInterfaceRequest.md)
- [CreateDirectLinkInterfaceResponse](docs/CreateDirectLinkInterfaceResponse.md)
- [CreateDirectLinkRequest](docs/CreateDirectLinkRequest.md)
- [CreateDirectLinkResponse](docs/CreateDirectLinkResponse.md)
- [CreateFlexibleGpuRequest](docs/CreateFlexibleGpuRequest.md)
- [CreateFlexibleGpuResponse](docs/CreateFlexibleGpuResponse.md)
- [CreateImageExportTaskRequest](docs/CreateImageExportTaskRequest.md)
- [CreateImageExportTaskResponse](docs/CreateImageExportTaskResponse.md)
- [CreateImageRequest](docs/CreateImageRequest.md)
- [CreateImageResponse](docs/CreateImageResponse.md)
- [CreateInternetServiceRequest](docs/CreateInternetServiceRequest.md)
- [CreateInternetServiceResponse](docs/CreateInternetServiceResponse.md)
- [CreateKeypairRequest](docs/CreateKeypairRequest.md)
- [CreateKeypairResponse](docs/CreateKeypairResponse.md)
- [CreateListenerRuleRequest](docs/CreateListenerRuleRequest.md)
- [CreateListenerRuleResponse](docs/CreateListenerRuleResponse.md)
- [CreateLoadBalancerListenersRequest](docs/CreateLoadBalancerListenersRequest.md)
- [CreateLoadBalancerListenersResponse](docs/CreateLoadBalancerListenersResponse.md)
- [CreateLoadBalancerPolicyRequest](docs/CreateLoadBalancerPolicyRequest.md)
- [CreateLoadBalancerPolicyResponse](docs/CreateLoadBalancerPolicyResponse.md)
- [CreateLoadBalancerRequest](docs/CreateLoadBalancerRequest.md)
- [CreateLoadBalancerResponse](docs/CreateLoadBalancerResponse.md)
- [CreateLoadBalancerTagsRequest](docs/CreateLoadBalancerTagsRequest.md)
- [CreateLoadBalancerTagsResponse](docs/CreateLoadBalancerTagsResponse.md)
- [CreateNatServiceRequest](docs/CreateNatServiceRequest.md)
- [CreateNatServiceResponse](docs/CreateNatServiceResponse.md)
- [CreateNetAccessPointRequest](docs/CreateNetAccessPointRequest.md)
- [CreateNetAccessPointResponse](docs/CreateNetAccessPointResponse.md)
- [CreateNetPeeringRequest](docs/CreateNetPeeringRequest.md)
- [CreateNetPeeringResponse](docs/CreateNetPeeringResponse.md)
- [CreateNetRequest](docs/CreateNetRequest.md)
- [CreateNetResponse](docs/CreateNetResponse.md)
- [CreateNicRequest](docs/CreateNicRequest.md)
- [CreateNicResponse](docs/CreateNicResponse.md)
- [CreatePublicIpRequest](docs/CreatePublicIpRequest.md)
- [CreatePublicIpResponse](docs/CreatePublicIpResponse.md)
- [CreateRouteRequest](docs/CreateRouteRequest.md)
- [CreateRouteResponse](docs/CreateRouteResponse.md)
- [CreateRouteTableRequest](docs/CreateRouteTableRequest.md)
- [CreateRouteTableResponse](docs/CreateRouteTableResponse.md)
- [CreateSecurityGroupRequest](docs/CreateSecurityGroupRequest.md)
- [CreateSecurityGroupResponse](docs/CreateSecurityGroupResponse.md)
- [CreateSecurityGroupRuleRequest](docs/CreateSecurityGroupRuleRequest.md)
- [CreateSecurityGroupRuleResponse](docs/CreateSecurityGroupRuleResponse.md)
- [CreateServerCertificateRequest](docs/CreateServerCertificateRequest.md)
- [CreateServerCertificateResponse](docs/CreateServerCertificateResponse.md)
- [CreateSnapshotExportTaskRequest](docs/CreateSnapshotExportTaskRequest.md)
- [CreateSnapshotExportTaskResponse](docs/CreateSnapshotExportTaskResponse.md)
- [CreateSnapshotRequest](docs/CreateSnapshotRequest.md)
- [CreateSnapshotResponse](docs/CreateSnapshotResponse.md)
- [CreateSubnetRequest](docs/CreateSubnetRequest.md)
- [CreateSubnetResponse](docs/CreateSubnetResponse.md)
- [CreateTagsRequest](docs/CreateTagsRequest.md)
- [CreateTagsResponse](docs/CreateTagsResponse.md)
- [CreateVirtualGatewayRequest](docs/CreateVirtualGatewayRequest.md)
- [CreateVirtualGatewayResponse](docs/CreateVirtualGatewayResponse.md)
- [CreateVmsRequest](docs/CreateVmsRequest.md)
- [CreateVmsResponse](docs/CreateVmsResponse.md)
- [CreateVolumeRequest](docs/CreateVolumeRequest.md)
- [CreateVolumeResponse](docs/CreateVolumeResponse.md)
- [CreateVpnConnectionRequest](docs/CreateVpnConnectionRequest.md)
- [CreateVpnConnectionResponse](docs/CreateVpnConnectionResponse.md)
- [CreateVpnConnectionRouteRequest](docs/CreateVpnConnectionRouteRequest.md)
- [CreateVpnConnectionRouteResponse](docs/CreateVpnConnectionRouteResponse.md)
- [DeleteAccessKeyRequest](docs/DeleteAccessKeyRequest.md)
- [DeleteAccessKeyResponse](docs/DeleteAccessKeyResponse.md)
- [DeleteClientGatewayRequest](docs/DeleteClientGatewayRequest.md)
- [DeleteClientGatewayResponse](docs/DeleteClientGatewayResponse.md)
- [DeleteDhcpOptionsRequest](docs/DeleteDhcpOptionsRequest.md)
- [DeleteDhcpOptionsResponse](docs/DeleteDhcpOptionsResponse.md)
- [DeleteDirectLinkInterfaceRequest](docs/DeleteDirectLinkInterfaceRequest.md)
- [DeleteDirectLinkInterfaceResponse](docs/DeleteDirectLinkInterfaceResponse.md)
- [DeleteDirectLinkRequest](docs/DeleteDirectLinkRequest.md)
- [DeleteDirectLinkResponse](docs/DeleteDirectLinkResponse.md)
- [DeleteExportTaskRequest](docs/DeleteExportTaskRequest.md)
- [DeleteExportTaskResponse](docs/DeleteExportTaskResponse.md)
- [DeleteFlexibleGpuRequest](docs/DeleteFlexibleGpuRequest.md)
- [DeleteFlexibleGpuResponse](docs/DeleteFlexibleGpuResponse.md)
- [DeleteImageRequest](docs/DeleteImageRequest.md)
- [DeleteImageResponse](docs/DeleteImageResponse.md)
- [DeleteInternetServiceRequest](docs/DeleteInternetServiceRequest.md)
- [DeleteInternetServiceResponse](docs/DeleteInternetServiceResponse.md)
- [DeleteKeypairRequest](docs/DeleteKeypairRequest.md)
- [DeleteKeypairResponse](docs/DeleteKeypairResponse.md)
- [DeleteListenerRuleRequest](docs/DeleteListenerRuleRequest.md)
- [DeleteListenerRuleResponse](docs/DeleteListenerRuleResponse.md)
- [DeleteLoadBalancerListenersRequest](docs/DeleteLoadBalancerListenersRequest.md)
- [DeleteLoadBalancerListenersResponse](docs/DeleteLoadBalancerListenersResponse.md)
- [DeleteLoadBalancerPolicyRequest](docs/DeleteLoadBalancerPolicyRequest.md)
- [DeleteLoadBalancerPolicyResponse](docs/DeleteLoadBalancerPolicyResponse.md)
- [DeleteLoadBalancerRequest](docs/DeleteLoadBalancerRequest.md)
- [DeleteLoadBalancerResponse](docs/DeleteLoadBalancerResponse.md)
- [DeleteLoadBalancerTagsRequest](docs/DeleteLoadBalancerTagsRequest.md)
- [DeleteLoadBalancerTagsResponse](docs/DeleteLoadBalancerTagsResponse.md)
- [DeleteNatServiceRequest](docs/DeleteNatServiceRequest.md)
- [DeleteNatServiceResponse](docs/DeleteNatServiceResponse.md)
- [DeleteNetAccessPointRequest](docs/DeleteNetAccessPointRequest.md)
- [DeleteNetAccessPointResponse](docs/DeleteNetAccessPointResponse.md)
- [DeleteNetPeeringRequest](docs/DeleteNetPeeringRequest.md)
- [DeleteNetPeeringResponse](docs/DeleteNetPeeringResponse.md)
- [DeleteNetRequest](docs/DeleteNetRequest.md)
- [DeleteNetResponse](docs/DeleteNetResponse.md)
- [DeleteNicRequest](docs/DeleteNicRequest.md)
- [DeleteNicResponse](docs/DeleteNicResponse.md)
- [DeletePublicIpRequest](docs/DeletePublicIpRequest.md)
- [DeletePublicIpResponse](docs/DeletePublicIpResponse.md)
- [DeleteRouteRequest](docs/DeleteRouteRequest.md)
- [DeleteRouteResponse](docs/DeleteRouteResponse.md)
- [DeleteRouteTableRequest](docs/DeleteRouteTableRequest.md)
- [DeleteRouteTableResponse](docs/DeleteRouteTableResponse.md)
- [DeleteSecurityGroupRequest](docs/DeleteSecurityGroupRequest.md)
- [DeleteSecurityGroupResponse](docs/DeleteSecurityGroupResponse.md)
- [DeleteSecurityGroupRuleRequest](docs/DeleteSecurityGroupRuleRequest.md)
- [DeleteSecurityGroupRuleResponse](docs/DeleteSecurityGroupRuleResponse.md)
- [DeleteServerCertificateRequest](docs/DeleteServerCertificateRequest.md)
- [DeleteServerCertificateResponse](docs/DeleteServerCertificateResponse.md)
- [DeleteSnapshotRequest](docs/DeleteSnapshotRequest.md)
- [DeleteSnapshotResponse](docs/DeleteSnapshotResponse.md)
- [DeleteSubnetRequest](docs/DeleteSubnetRequest.md)
- [DeleteSubnetResponse](docs/DeleteSubnetResponse.md)
- [DeleteTagsRequest](docs/DeleteTagsRequest.md)
- [DeleteTagsResponse](docs/DeleteTagsResponse.md)
- [DeleteVirtualGatewayRequest](docs/DeleteVirtualGatewayRequest.md)
- [DeleteVirtualGatewayResponse](docs/DeleteVirtualGatewayResponse.md)
- [DeleteVmsRequest](docs/DeleteVmsRequest.md)
- [DeleteVmsResponse](docs/DeleteVmsResponse.md)
- [DeleteVolumeRequest](docs/DeleteVolumeRequest.md)
- [DeleteVolumeResponse](docs/DeleteVolumeResponse.md)
- [DeleteVpnConnectionRequest](docs/DeleteVpnConnectionRequest.md)
- [DeleteVpnConnectionResponse](docs/DeleteVpnConnectionResponse.md)
- [DeleteVpnConnectionRouteRequest](docs/DeleteVpnConnectionRouteRequest.md)
- [DeleteVpnConnectionRouteResponse](docs/DeleteVpnConnectionRouteResponse.md)
- [DeregisterVmsInLoadBalancerRequest](docs/DeregisterVmsInLoadBalancerRequest.md)
- [DeregisterVmsInLoadBalancerResponse](docs/DeregisterVmsInLoadBalancerResponse.md)
- [DhcpOptionsSet](docs/DhcpOptionsSet.md)
- [DirectLink](docs/DirectLink.md)
- [DirectLinkInterface](docs/DirectLinkInterface.md)
- [DirectLinkInterfaces](docs/DirectLinkInterfaces.md)
- [ErrorResponse](docs/ErrorResponse.md)
- [Errors](docs/Errors.md)
- [FiltersAccessKeys](docs/FiltersAccessKeys.md)
- [FiltersApiLog](docs/FiltersApiLog.md)
- [FiltersClientGateway](docs/FiltersClientGateway.md)
- [FiltersDhcpOptions](docs/FiltersDhcpOptions.md)
- [FiltersDirectLink](docs/FiltersDirectLink.md)
- [FiltersDirectLinkInterface](docs/FiltersDirectLinkInterface.md)
- [FiltersExportTask](docs/FiltersExportTask.md)
- [FiltersFlexibleGpu](docs/FiltersFlexibleGpu.md)
- [FiltersImage](docs/FiltersImage.md)
- [FiltersInternetService](docs/FiltersInternetService.md)
- [FiltersKeypair](docs/FiltersKeypair.md)
- [FiltersListenerRule](docs/FiltersListenerRule.md)
- [FiltersLoadBalancer](docs/FiltersLoadBalancer.md)
- [FiltersNatService](docs/FiltersNatService.md)
- [FiltersNet](docs/FiltersNet.md)
- [FiltersNetAccessPoint](docs/FiltersNetAccessPoint.md)
- [FiltersNetPeering](docs/FiltersNetPeering.md)
- [FiltersNic](docs/FiltersNic.md)
- [FiltersProductType](docs/FiltersProductType.md)
- [FiltersPublicIp](docs/FiltersPublicIp.md)
- [FiltersQuota](docs/FiltersQuota.md)
- [FiltersRouteTable](docs/FiltersRouteTable.md)
- [FiltersSecurityGroup](docs/FiltersSecurityGroup.md)
- [FiltersServerCertificate](docs/FiltersServerCertificate.md)
- [FiltersService](docs/FiltersService.md)
- [FiltersSnapshot](docs/FiltersSnapshot.md)
- [FiltersSubnet](docs/FiltersSubnet.md)
- [FiltersSubregion](docs/FiltersSubregion.md)
- [FiltersTag](docs/FiltersTag.md)
- [FiltersVirtualGateway](docs/FiltersVirtualGateway.md)
- [FiltersVm](docs/FiltersVm.md)
- [FiltersVmType](docs/FiltersVmType.md)
- [FiltersVmsState](docs/FiltersVmsState.md)
- [FiltersVolume](docs/FiltersVolume.md)
- [FiltersVpnConnection](docs/FiltersVpnConnection.md)
- [FlexibleGpu](docs/FlexibleGpu.md)
- [FlexibleGpuCatalog](docs/FlexibleGpuCatalog.md)
- [HealthCheck](docs/HealthCheck.md)
- [Image](docs/Image.md)
- [ImageExportTask](docs/ImageExportTask.md)
- [InternetService](docs/InternetService.md)
- [Keypair](docs/Keypair.md)
- [KeypairCreated](docs/KeypairCreated.md)
- [LinkFlexibleGpuRequest](docs/LinkFlexibleGpuRequest.md)
- [LinkFlexibleGpuResponse](docs/LinkFlexibleGpuResponse.md)
- [LinkInternetServiceRequest](docs/LinkInternetServiceRequest.md)
- [LinkInternetServiceResponse](docs/LinkInternetServiceResponse.md)
- [LinkNic](docs/LinkNic.md)
- [LinkNicLight](docs/LinkNicLight.md)
- [LinkNicRequest](docs/LinkNicRequest.md)
- [LinkNicResponse](docs/LinkNicResponse.md)
- [LinkNicToUpdate](docs/LinkNicToUpdate.md)
- [LinkPrivateIpsRequest](docs/LinkPrivateIpsRequest.md)
- [LinkPrivateIpsResponse](docs/LinkPrivateIpsResponse.md)
- [LinkPublicIp](docs/LinkPublicIp.md)
- [LinkPublicIpLightForVm](docs/LinkPublicIpLightForVm.md)
- [LinkPublicIpRequest](docs/LinkPublicIpRequest.md)
- [LinkPublicIpResponse](docs/LinkPublicIpResponse.md)
- [LinkRouteTable](docs/LinkRouteTable.md)
- [LinkRouteTableRequest](docs/LinkRouteTableRequest.md)
- [LinkRouteTableResponse](docs/LinkRouteTableResponse.md)
- [LinkVirtualGatewayRequest](docs/LinkVirtualGatewayRequest.md)
- [LinkVirtualGatewayResponse](docs/LinkVirtualGatewayResponse.md)
- [LinkVolumeRequest](docs/LinkVolumeRequest.md)
- [LinkVolumeResponse](docs/LinkVolumeResponse.md)
- [LinkedVolume](docs/LinkedVolume.md)
- [Listener](docs/Listener.md)
- [ListenerForCreation](docs/ListenerForCreation.md)
- [ListenerRule](docs/ListenerRule.md)
- [ListenerRuleForCreation](docs/ListenerRuleForCreation.md)
- [LoadBalancer](docs/LoadBalancer.md)
- [LoadBalancerLight](docs/LoadBalancerLight.md)
- [LoadBalancerStickyCookiePolicy](docs/LoadBalancerStickyCookiePolicy.md)
- [LoadBalancerTag](docs/LoadBalancerTag.md)
- [Location](docs/Location.md)
- [Log](docs/Log.md)
- [MaintenanceEvent](docs/MaintenanceEvent.md)
- [NatService](docs/NatService.md)
- [Net](docs/Net.md)
- [NetAccessPoint](docs/NetAccessPoint.md)
- [NetPeering](docs/NetPeering.md)
- [NetPeeringState](docs/NetPeeringState.md)
- [NetToVirtualGatewayLink](docs/NetToVirtualGatewayLink.md)
- [Nic](docs/Nic.md)
- [NicForVmCreation](docs/NicForVmCreation.md)
- [NicLight](docs/NicLight.md)
- [OsuApiKey](docs/OsuApiKey.md)
- [OsuExport](docs/OsuExport.md)
- [PermissionsOnResource](docs/PermissionsOnResource.md)
- [PermissionsOnResourceCreation](docs/PermissionsOnResourceCreation.md)
- [Placement](docs/Placement.md)
- [PrivateIp](docs/PrivateIp.md)
- [PrivateIpLight](docs/PrivateIpLight.md)
- [PrivateIpLightForVm](docs/PrivateIpLightForVm.md)
- [ProductType](docs/ProductType.md)
- [PublicIp](docs/PublicIp.md)
- [PublicIpLight](docs/PublicIpLight.md)
- [Quota](docs/Quota.md)
- [QuotaTypes](docs/QuotaTypes.md)
- [ReadAccessKeysRequest](docs/ReadAccessKeysRequest.md)
- [ReadAccessKeysResponse](docs/ReadAccessKeysResponse.md)
- [ReadAccountsRequest](docs/ReadAccountsRequest.md)
- [ReadAccountsResponse](docs/ReadAccountsResponse.md)
- [ReadAdminPasswordRequest](docs/ReadAdminPasswordRequest.md)
- [ReadAdminPasswordResponse](docs/ReadAdminPasswordResponse.md)
- [ReadApiLogsRequest](docs/ReadApiLogsRequest.md)
- [ReadApiLogsResponse](docs/ReadApiLogsResponse.md)
- [ReadClientGatewaysRequest](docs/ReadClientGatewaysRequest.md)
- [ReadClientGatewaysResponse](docs/ReadClientGatewaysResponse.md)
- [ReadConsoleOutputRequest](docs/ReadConsoleOutputRequest.md)
- [ReadConsoleOutputResponse](docs/ReadConsoleOutputResponse.md)
- [ReadConsumptionAccountRequest](docs/ReadConsumptionAccountRequest.md)
- [ReadConsumptionAccountResponse](docs/ReadConsumptionAccountResponse.md)
- [ReadDhcpOptionsRequest](docs/ReadDhcpOptionsRequest.md)
- [ReadDhcpOptionsResponse](docs/ReadDhcpOptionsResponse.md)
- [ReadDirectLinkInterfacesRequest](docs/ReadDirectLinkInterfacesRequest.md)
- [ReadDirectLinkInterfacesResponse](docs/ReadDirectLinkInterfacesResponse.md)
- [ReadDirectLinksRequest](docs/ReadDirectLinksRequest.md)
- [ReadDirectLinksResponse](docs/ReadDirectLinksResponse.md)
- [ReadFlexibleGpuCatalogRequest](docs/ReadFlexibleGpuCatalogRequest.md)
- [ReadFlexibleGpuCatalogResponse](docs/ReadFlexibleGpuCatalogResponse.md)
- [ReadFlexibleGpusRequest](docs/ReadFlexibleGpusRequest.md)
- [ReadFlexibleGpusResponse](docs/ReadFlexibleGpusResponse.md)
- [ReadImageExportTasksRequest](docs/ReadImageExportTasksRequest.md)
- [ReadImageExportTasksResponse](docs/ReadImageExportTasksResponse.md)
- [ReadImagesRequest](docs/ReadImagesRequest.md)
- [ReadImagesResponse](docs/ReadImagesResponse.md)
- [ReadInternetServicesRequest](docs/ReadInternetServicesRequest.md)
- [ReadInternetServicesResponse](docs/ReadInternetServicesResponse.md)
- [ReadKeypairsRequest](docs/ReadKeypairsRequest.md)
- [ReadKeypairsResponse](docs/ReadKeypairsResponse.md)
- [ReadListenerRulesRequest](docs/ReadListenerRulesRequest.md)
- [ReadListenerRulesResponse](docs/ReadListenerRulesResponse.md)
- [ReadLoadBalancerTagsRequest](docs/ReadLoadBalancerTagsRequest.md)
- [ReadLoadBalancerTagsResponse](docs/ReadLoadBalancerTagsResponse.md)
- [ReadLoadBalancersRequest](docs/ReadLoadBalancersRequest.md)
- [ReadLoadBalancersResponse](docs/ReadLoadBalancersResponse.md)
- [ReadLocationsRequest](docs/ReadLocationsRequest.md)
- [ReadLocationsResponse](docs/ReadLocationsResponse.md)
- [ReadNatServicesRequest](docs/ReadNatServicesRequest.md)
- [ReadNatServicesResponse](docs/ReadNatServicesResponse.md)
- [ReadNetAccessPointServicesRequest](docs/ReadNetAccessPointServicesRequest.md)
- [ReadNetAccessPointServicesResponse](docs/ReadNetAccessPointServicesResponse.md)
- [ReadNetAccessPointsRequest](docs/ReadNetAccessPointsRequest.md)
- [ReadNetAccessPointsResponse](docs/ReadNetAccessPointsResponse.md)
- [ReadNetPeeringsRequest](docs/ReadNetPeeringsRequest.md)
- [ReadNetPeeringsResponse](docs/ReadNetPeeringsResponse.md)
- [ReadNetsRequest](docs/ReadNetsRequest.md)
- [ReadNetsResponse](docs/ReadNetsResponse.md)
- [ReadNicsRequest](docs/ReadNicsRequest.md)
- [ReadNicsResponse](docs/ReadNicsResponse.md)
- [ReadProductTypesRequest](docs/ReadProductTypesRequest.md)
- [ReadProductTypesResponse](docs/ReadProductTypesResponse.md)
- [ReadPublicIpRangesRequest](docs/ReadPublicIpRangesRequest.md)
- [ReadPublicIpRangesResponse](docs/ReadPublicIpRangesResponse.md)
- [ReadPublicIpsRequest](docs/ReadPublicIpsRequest.md)
- [ReadPublicIpsResponse](docs/ReadPublicIpsResponse.md)
- [ReadQuotasRequest](docs/ReadQuotasRequest.md)
- [ReadQuotasResponse](docs/ReadQuotasResponse.md)
- [ReadRegionsRequest](docs/ReadRegionsRequest.md)
- [ReadRegionsResponse](docs/ReadRegionsResponse.md)
- [ReadRouteTablesRequest](docs/ReadRouteTablesRequest.md)
- [ReadRouteTablesResponse](docs/ReadRouteTablesResponse.md)
- [ReadSecretAccessKeyRequest](docs/ReadSecretAccessKeyRequest.md)
- [ReadSecretAccessKeyResponse](docs/ReadSecretAccessKeyResponse.md)
- [ReadSecurityGroupsRequest](docs/ReadSecurityGroupsRequest.md)
- [ReadSecurityGroupsResponse](docs/ReadSecurityGroupsResponse.md)
- [ReadServerCertificatesRequest](docs/ReadServerCertificatesRequest.md)
- [ReadServerCertificatesResponse](docs/ReadServerCertificatesResponse.md)
- [ReadSnapshotExportTasksRequest](docs/ReadSnapshotExportTasksRequest.md)
- [ReadSnapshotExportTasksResponse](docs/ReadSnapshotExportTasksResponse.md)
- [ReadSnapshotsRequest](docs/ReadSnapshotsRequest.md)
- [ReadSnapshotsResponse](docs/ReadSnapshotsResponse.md)
- [ReadSubnetsRequest](docs/ReadSubnetsRequest.md)
- [ReadSubnetsResponse](docs/ReadSubnetsResponse.md)
- [ReadSubregionsRequest](docs/ReadSubregionsRequest.md)
- [ReadSubregionsResponse](docs/ReadSubregionsResponse.md)
- [ReadTagsRequest](docs/ReadTagsRequest.md)
- [ReadTagsResponse](docs/ReadTagsResponse.md)
- [ReadVirtualGatewaysRequest](docs/ReadVirtualGatewaysRequest.md)
- [ReadVirtualGatewaysResponse](docs/ReadVirtualGatewaysResponse.md)
- [ReadVmTypesRequest](docs/ReadVmTypesRequest.md)
- [ReadVmTypesResponse](docs/ReadVmTypesResponse.md)
- [ReadVmsHealthRequest](docs/ReadVmsHealthRequest.md)
- [ReadVmsHealthResponse](docs/ReadVmsHealthResponse.md)
- [ReadVmsRequest](docs/ReadVmsRequest.md)
- [ReadVmsResponse](docs/ReadVmsResponse.md)
- [ReadVmsStateRequest](docs/ReadVmsStateRequest.md)
- [ReadVmsStateResponse](docs/ReadVmsStateResponse.md)
- [ReadVolumesRequest](docs/ReadVolumesRequest.md)
- [ReadVolumesResponse](docs/ReadVolumesResponse.md)
- [ReadVpnConnectionsRequest](docs/ReadVpnConnectionsRequest.md)
- [ReadVpnConnectionsResponse](docs/ReadVpnConnectionsResponse.md)
- [RebootVmsRequest](docs/RebootVmsRequest.md)
- [RebootVmsResponse](docs/RebootVmsResponse.md)
- [Region](docs/Region.md)
- [RegisterVmsInLoadBalancerRequest](docs/RegisterVmsInLoadBalancerRequest.md)
- [RegisterVmsInLoadBalancerResponse](docs/RegisterVmsInLoadBalancerResponse.md)
- [RejectNetPeeringRequest](docs/RejectNetPeeringRequest.md)
- [RejectNetPeeringResponse](docs/RejectNetPeeringResponse.md)
- [ResetAccountPasswordRequest](docs/ResetAccountPasswordRequest.md)
- [ResetAccountPasswordResponse](docs/ResetAccountPasswordResponse.md)
- [ResourceLoadBalancerTag](docs/ResourceLoadBalancerTag.md)
- [ResourceTag](docs/ResourceTag.md)
- [ResponseContext](docs/ResponseContext.md)
- [Route](docs/Route.md)
- [RouteLight](docs/RouteLight.md)
- [RoutePropagatingVirtualGateway](docs/RoutePropagatingVirtualGateway.md)
- [RouteTable](docs/RouteTable.md)
- [SecurityGroup](docs/SecurityGroup.md)
- [SecurityGroupLight](docs/SecurityGroupLight.md)
- [SecurityGroupRule](docs/SecurityGroupRule.md)
- [SecurityGroupsMember](docs/SecurityGroupsMember.md)
- [SendResetPasswordEmailRequest](docs/SendResetPasswordEmailRequest.md)
- [SendResetPasswordEmailResponse](docs/SendResetPasswordEmailResponse.md)
- [ServerCertificate](docs/ServerCertificate.md)
- [Service](docs/Service.md)
- [Snapshot](docs/Snapshot.md)
- [SnapshotExportTask](docs/SnapshotExportTask.md)
- [SourceNet](docs/SourceNet.md)
- [SourceSecurityGroup](docs/SourceSecurityGroup.md)
- [StartVmsRequest](docs/StartVmsRequest.md)
- [StartVmsResponse](docs/StartVmsResponse.md)
- [StateComment](docs/StateComment.md)
- [StopVmsRequest](docs/StopVmsRequest.md)
- [StopVmsResponse](docs/StopVmsResponse.md)
- [Subnet](docs/Subnet.md)
- [Subregion](docs/Subregion.md)
- [Tag](docs/Tag.md)
- [UnlinkFlexibleGpuRequest](docs/UnlinkFlexibleGpuRequest.md)
- [UnlinkFlexibleGpuResponse](docs/UnlinkFlexibleGpuResponse.md)
- [UnlinkInternetServiceRequest](docs/UnlinkInternetServiceRequest.md)
- [UnlinkInternetServiceResponse](docs/UnlinkInternetServiceResponse.md)
- [UnlinkNicRequest](docs/UnlinkNicRequest.md)
- [UnlinkNicResponse](docs/UnlinkNicResponse.md)
- [UnlinkPrivateIpsRequest](docs/UnlinkPrivateIpsRequest.md)
- [UnlinkPrivateIpsResponse](docs/UnlinkPrivateIpsResponse.md)
- [UnlinkPublicIpRequest](docs/UnlinkPublicIpRequest.md)
- [UnlinkPublicIpResponse](docs/UnlinkPublicIpResponse.md)
- [UnlinkRouteTableRequest](docs/UnlinkRouteTableRequest.md)
- [UnlinkRouteTableResponse](docs/UnlinkRouteTableResponse.md)
- [UnlinkVirtualGatewayRequest](docs/UnlinkVirtualGatewayRequest.md)
- [UnlinkVirtualGatewayResponse](docs/UnlinkVirtualGatewayResponse.md)
- [UnlinkVolumeRequest](docs/UnlinkVolumeRequest.md)
- [UnlinkVolumeResponse](docs/UnlinkVolumeResponse.md)
- [UpdateAccessKeyRequest](docs/UpdateAccessKeyRequest.md)
- [UpdateAccessKeyResponse](docs/UpdateAccessKeyResponse.md)
- [UpdateAccountRequest](docs/UpdateAccountRequest.md)
- [UpdateAccountResponse](docs/UpdateAccountResponse.md)
- [UpdateFlexibleGpuRequest](docs/UpdateFlexibleGpuRequest.md)
- [UpdateFlexibleGpuResponse](docs/UpdateFlexibleGpuResponse.md)
- [UpdateImageRequest](docs/UpdateImageRequest.md)
- [UpdateImageResponse](docs/UpdateImageResponse.md)
- [UpdateListenerRuleRequest](docs/UpdateListenerRuleRequest.md)
- [UpdateListenerRuleResponse](docs/UpdateListenerRuleResponse.md)
- [UpdateLoadBalancerRequest](docs/UpdateLoadBalancerRequest.md)
- [UpdateLoadBalancerResponse](docs/UpdateLoadBalancerResponse.md)
- [UpdateNetAccessPointRequest](docs/UpdateNetAccessPointRequest.md)
- [UpdateNetAccessPointResponse](docs/UpdateNetAccessPointResponse.md)
- [UpdateNetRequest](docs/UpdateNetRequest.md)
- [UpdateNetResponse](docs/UpdateNetResponse.md)
- [UpdateNicRequest](docs/UpdateNicRequest.md)
- [UpdateNicResponse](docs/UpdateNicResponse.md)
- [UpdateRoutePropagationRequest](docs/UpdateRoutePropagationRequest.md)
- [UpdateRoutePropagationResponse](docs/UpdateRoutePropagationResponse.md)
- [UpdateRouteRequest](docs/UpdateRouteRequest.md)
- [UpdateRouteResponse](docs/UpdateRouteResponse.md)
- [UpdateServerCertificateRequest](docs/UpdateServerCertificateRequest.md)
- [UpdateServerCertificateResponse](docs/UpdateServerCertificateResponse.md)
- [UpdateSnapshotRequest](docs/UpdateSnapshotRequest.md)
- [UpdateSnapshotResponse](docs/UpdateSnapshotResponse.md)
- [UpdateSubnetRequest](docs/UpdateSubnetRequest.md)
- [UpdateSubnetResponse](docs/UpdateSubnetResponse.md)
- [UpdateVmRequest](docs/UpdateVmRequest.md)
- [UpdateVmResponse](docs/UpdateVmResponse.md)
- [VirtualGateway](docs/VirtualGateway.md)
- [Vm](docs/Vm.md)
- [VmState](docs/VmState.md)
- [VmStates](docs/VmStates.md)
- [VmType](docs/VmType.md)
- [Volume](docs/Volume.md)
- [VpnConnection](docs/VpnConnection.md)
- [With](docs/With.md)
## Documentation For Authorization
## ApiKeyAuth
- **Type**: API key
Example
```golang
auth := context.WithValue(context.Background(), sw.ContextAPIKey, sw.APIKey{
Key: "APIKEY",
Prefix: "Bearer", // Omit if not necessary.
})
r, err := client.Service.Operation(auth, args)
```
Example
```golang
auth := context.WithValue(context.Background(), sw.ContextAWSv4, sw.AWSv4{
AccessKey: "ACCESSKEYSTRING",
SecretKey: "SECRETKEYSTRING",
})
r, err := client.Service.Operation(auth, args)
```
## Author
support@outscale.com

582
vendor/github.com/outscale/osc-sdk-go/osc/api_access_key.go generated vendored Normal file
View File

@ -0,0 +1,582 @@
/*
* 3DS OUTSCALE API
*
* Welcome to the 3DS OUTSCALE's API documentation.<br /><br /> The 3DS OUTSCALE API enables you to manage your resources in the 3DS OUTSCALE Cloud. This documentation describes the different actions available along with code examples.<br /><br /> Note that the 3DS OUTSCALE Cloud is compatible with Amazon Web Services (AWS) APIs, but some resources have different names in AWS than in the 3DS OUTSCALE API. You can find a list of the differences [here](https://wiki.outscale.net/display/EN/3DS+OUTSCALE+APIs+Reference).<br /><br /> You can also manage your resources using the [Cockpit](https://wiki.outscale.net/display/EN/About+Cockpit) web interface.
*
* API version: 1.2
* Contact: support@outscale.com
* Generated by: OpenAPI Generator (https://openapi-generator.tech)
*/
package osc
import (
_context "context"
_ioutil "io/ioutil"
_nethttp "net/http"
_neturl "net/url"
"github.com/antihax/optional"
)
// Linger please
var (
_ _context.Context
)
// AccessKeyApiService AccessKeyApi service
type AccessKeyApiService service
// CreateAccessKeyOpts Optional parameters for the method 'CreateAccessKey'
type CreateAccessKeyOpts struct {
CreateAccessKeyRequest optional.Interface
}
/*
CreateAccessKey Method for CreateAccessKey
* @param ctx _context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
* @param optional nil or *CreateAccessKeyOpts - Optional Parameters:
* @param "CreateAccessKeyRequest" (optional.Interface of CreateAccessKeyRequest) -
@return CreateAccessKeyResponse
*/
func (a *AccessKeyApiService) CreateAccessKey(ctx _context.Context, localVarOptionals *CreateAccessKeyOpts) (CreateAccessKeyResponse, *_nethttp.Response, error) {
var (
localVarHTTPMethod = _nethttp.MethodPost
localVarPostBody interface{}
localVarFormFileName string
localVarFileName string
localVarFileBytes []byte
localVarReturnValue CreateAccessKeyResponse
)
// create path and map variables
localVarPath := a.client.cfg.BasePath + "/CreateAccessKey"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := _neturl.Values{}
localVarFormParams := _neturl.Values{}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{"application/json"}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{"application/json"}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
// body params
if localVarOptionals != nil && localVarOptionals.CreateAccessKeyRequest.IsSet() {
localVarOptionalCreateAccessKeyRequest, localVarOptionalCreateAccessKeyRequestok := localVarOptionals.CreateAccessKeyRequest.Value().(CreateAccessKeyRequest)
if !localVarOptionalCreateAccessKeyRequestok {
return localVarReturnValue, nil, reportError("createAccessKeyRequest should be CreateAccessKeyRequest")
}
localVarPostBody = &localVarOptionalCreateAccessKeyRequest
}
if ctx != nil {
// API Key Authentication
if auth, ok := ctx.Value(ContextAPIKey).(APIKey); ok {
var key string
if auth.Prefix != "" {
key = auth.Prefix + " " + auth.Key
} else {
key = auth.Key
}
localVarHeaderParams["Authorization"] = key
}
}
r, err := a.client.prepareRequest(ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFormFileName, localVarFileName, localVarFileBytes)
if err != nil {
return localVarReturnValue, nil, err
}
localVarHTTPResponse, err := a.client.callAPI(r)
if err != nil || localVarHTTPResponse == nil {
return localVarReturnValue, localVarHTTPResponse, err
}
localVarBody, err := _ioutil.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
if err != nil {
return localVarReturnValue, localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
if localVarHTTPResponse.StatusCode == 200 {
var v CreateAccessKeyResponse
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr.error = err.Error()
return localVarReturnValue, localVarHTTPResponse, newErr
}
newErr.model = v
}
return localVarReturnValue, localVarHTTPResponse, newErr
}
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr := GenericOpenAPIError{
body: localVarBody,
error: err.Error(),
}
return localVarReturnValue, localVarHTTPResponse, newErr
}
return localVarReturnValue, localVarHTTPResponse, nil
}
// DeleteAccessKeyOpts Optional parameters for the method 'DeleteAccessKey'
type DeleteAccessKeyOpts struct {
DeleteAccessKeyRequest optional.Interface
}
/*
DeleteAccessKey Method for DeleteAccessKey
* @param ctx _context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
* @param optional nil or *DeleteAccessKeyOpts - Optional Parameters:
* @param "DeleteAccessKeyRequest" (optional.Interface of DeleteAccessKeyRequest) -
@return DeleteAccessKeyResponse
*/
func (a *AccessKeyApiService) DeleteAccessKey(ctx _context.Context, localVarOptionals *DeleteAccessKeyOpts) (DeleteAccessKeyResponse, *_nethttp.Response, error) {
var (
localVarHTTPMethod = _nethttp.MethodPost
localVarPostBody interface{}
localVarFormFileName string
localVarFileName string
localVarFileBytes []byte
localVarReturnValue DeleteAccessKeyResponse
)
// create path and map variables
localVarPath := a.client.cfg.BasePath + "/DeleteAccessKey"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := _neturl.Values{}
localVarFormParams := _neturl.Values{}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{"application/json"}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{"application/json"}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
// body params
if localVarOptionals != nil && localVarOptionals.DeleteAccessKeyRequest.IsSet() {
localVarOptionalDeleteAccessKeyRequest, localVarOptionalDeleteAccessKeyRequestok := localVarOptionals.DeleteAccessKeyRequest.Value().(DeleteAccessKeyRequest)
if !localVarOptionalDeleteAccessKeyRequestok {
return localVarReturnValue, nil, reportError("deleteAccessKeyRequest should be DeleteAccessKeyRequest")
}
localVarPostBody = &localVarOptionalDeleteAccessKeyRequest
}
if ctx != nil {
// API Key Authentication
if auth, ok := ctx.Value(ContextAPIKey).(APIKey); ok {
var key string
if auth.Prefix != "" {
key = auth.Prefix + " " + auth.Key
} else {
key = auth.Key
}
localVarHeaderParams["Authorization"] = key
}
}
r, err := a.client.prepareRequest(ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFormFileName, localVarFileName, localVarFileBytes)
if err != nil {
return localVarReturnValue, nil, err
}
localVarHTTPResponse, err := a.client.callAPI(r)
if err != nil || localVarHTTPResponse == nil {
return localVarReturnValue, localVarHTTPResponse, err
}
localVarBody, err := _ioutil.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
if err != nil {
return localVarReturnValue, localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
if localVarHTTPResponse.StatusCode == 200 {
var v DeleteAccessKeyResponse
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr.error = err.Error()
return localVarReturnValue, localVarHTTPResponse, newErr
}
newErr.model = v
}
return localVarReturnValue, localVarHTTPResponse, newErr
}
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr := GenericOpenAPIError{
body: localVarBody,
error: err.Error(),
}
return localVarReturnValue, localVarHTTPResponse, newErr
}
return localVarReturnValue, localVarHTTPResponse, nil
}
// ReadAccessKeysOpts Optional parameters for the method 'ReadAccessKeys'
type ReadAccessKeysOpts struct {
ReadAccessKeysRequest optional.Interface
}
/*
ReadAccessKeys Method for ReadAccessKeys
* @param ctx _context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
* @param optional nil or *ReadAccessKeysOpts - Optional Parameters:
* @param "ReadAccessKeysRequest" (optional.Interface of ReadAccessKeysRequest) -
@return ReadAccessKeysResponse
*/
func (a *AccessKeyApiService) ReadAccessKeys(ctx _context.Context, localVarOptionals *ReadAccessKeysOpts) (ReadAccessKeysResponse, *_nethttp.Response, error) {
var (
localVarHTTPMethod = _nethttp.MethodPost
localVarPostBody interface{}
localVarFormFileName string
localVarFileName string
localVarFileBytes []byte
localVarReturnValue ReadAccessKeysResponse
)
// create path and map variables
localVarPath := a.client.cfg.BasePath + "/ReadAccessKeys"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := _neturl.Values{}
localVarFormParams := _neturl.Values{}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{"application/json"}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{"application/json"}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
// body params
if localVarOptionals != nil && localVarOptionals.ReadAccessKeysRequest.IsSet() {
localVarOptionalReadAccessKeysRequest, localVarOptionalReadAccessKeysRequestok := localVarOptionals.ReadAccessKeysRequest.Value().(ReadAccessKeysRequest)
if !localVarOptionalReadAccessKeysRequestok {
return localVarReturnValue, nil, reportError("readAccessKeysRequest should be ReadAccessKeysRequest")
}
localVarPostBody = &localVarOptionalReadAccessKeysRequest
}
if ctx != nil {
// API Key Authentication
if auth, ok := ctx.Value(ContextAPIKey).(APIKey); ok {
var key string
if auth.Prefix != "" {
key = auth.Prefix + " " + auth.Key
} else {
key = auth.Key
}
localVarHeaderParams["Authorization"] = key
}
}
r, err := a.client.prepareRequest(ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFormFileName, localVarFileName, localVarFileBytes)
if err != nil {
return localVarReturnValue, nil, err
}
localVarHTTPResponse, err := a.client.callAPI(r)
if err != nil || localVarHTTPResponse == nil {
return localVarReturnValue, localVarHTTPResponse, err
}
localVarBody, err := _ioutil.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
if err != nil {
return localVarReturnValue, localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
if localVarHTTPResponse.StatusCode == 200 {
var v ReadAccessKeysResponse
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr.error = err.Error()
return localVarReturnValue, localVarHTTPResponse, newErr
}
newErr.model = v
}
return localVarReturnValue, localVarHTTPResponse, newErr
}
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr := GenericOpenAPIError{
body: localVarBody,
error: err.Error(),
}
return localVarReturnValue, localVarHTTPResponse, newErr
}
return localVarReturnValue, localVarHTTPResponse, nil
}
// ReadSecretAccessKeyOpts Optional parameters for the method 'ReadSecretAccessKey'
type ReadSecretAccessKeyOpts struct {
ReadSecretAccessKeyRequest optional.Interface
}
/*
ReadSecretAccessKey Method for ReadSecretAccessKey
* @param ctx _context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
* @param optional nil or *ReadSecretAccessKeyOpts - Optional Parameters:
* @param "ReadSecretAccessKeyRequest" (optional.Interface of ReadSecretAccessKeyRequest) -
@return ReadSecretAccessKeyResponse
*/
func (a *AccessKeyApiService) ReadSecretAccessKey(ctx _context.Context, localVarOptionals *ReadSecretAccessKeyOpts) (ReadSecretAccessKeyResponse, *_nethttp.Response, error) {
var (
localVarHTTPMethod = _nethttp.MethodPost
localVarPostBody interface{}
localVarFormFileName string
localVarFileName string
localVarFileBytes []byte
localVarReturnValue ReadSecretAccessKeyResponse
)
// create path and map variables
localVarPath := a.client.cfg.BasePath + "/ReadSecretAccessKey"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := _neturl.Values{}
localVarFormParams := _neturl.Values{}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{"application/json"}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{"application/json"}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
// body params
if localVarOptionals != nil && localVarOptionals.ReadSecretAccessKeyRequest.IsSet() {
localVarOptionalReadSecretAccessKeyRequest, localVarOptionalReadSecretAccessKeyRequestok := localVarOptionals.ReadSecretAccessKeyRequest.Value().(ReadSecretAccessKeyRequest)
if !localVarOptionalReadSecretAccessKeyRequestok {
return localVarReturnValue, nil, reportError("readSecretAccessKeyRequest should be ReadSecretAccessKeyRequest")
}
localVarPostBody = &localVarOptionalReadSecretAccessKeyRequest
}
if ctx != nil {
// API Key Authentication
if auth, ok := ctx.Value(ContextAPIKey).(APIKey); ok {
var key string
if auth.Prefix != "" {
key = auth.Prefix + " " + auth.Key
} else {
key = auth.Key
}
localVarHeaderParams["Authorization"] = key
}
}
r, err := a.client.prepareRequest(ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFormFileName, localVarFileName, localVarFileBytes)
if err != nil {
return localVarReturnValue, nil, err
}
localVarHTTPResponse, err := a.client.callAPI(r)
if err != nil || localVarHTTPResponse == nil {
return localVarReturnValue, localVarHTTPResponse, err
}
localVarBody, err := _ioutil.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
if err != nil {
return localVarReturnValue, localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
if localVarHTTPResponse.StatusCode == 200 {
var v ReadSecretAccessKeyResponse
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr.error = err.Error()
return localVarReturnValue, localVarHTTPResponse, newErr
}
newErr.model = v
}
return localVarReturnValue, localVarHTTPResponse, newErr
}
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr := GenericOpenAPIError{
body: localVarBody,
error: err.Error(),
}
return localVarReturnValue, localVarHTTPResponse, newErr
}
return localVarReturnValue, localVarHTTPResponse, nil
}
// UpdateAccessKeyOpts Optional parameters for the method 'UpdateAccessKey'
type UpdateAccessKeyOpts struct {
UpdateAccessKeyRequest optional.Interface
}
/*
UpdateAccessKey Method for UpdateAccessKey
* @param ctx _context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
* @param optional nil or *UpdateAccessKeyOpts - Optional Parameters:
* @param "UpdateAccessKeyRequest" (optional.Interface of UpdateAccessKeyRequest) -
@return UpdateAccessKeyResponse
*/
func (a *AccessKeyApiService) UpdateAccessKey(ctx _context.Context, localVarOptionals *UpdateAccessKeyOpts) (UpdateAccessKeyResponse, *_nethttp.Response, error) {
var (
localVarHTTPMethod = _nethttp.MethodPost
localVarPostBody interface{}
localVarFormFileName string
localVarFileName string
localVarFileBytes []byte
localVarReturnValue UpdateAccessKeyResponse
)
// create path and map variables
localVarPath := a.client.cfg.BasePath + "/UpdateAccessKey"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := _neturl.Values{}
localVarFormParams := _neturl.Values{}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{"application/json"}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{"application/json"}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
// body params
if localVarOptionals != nil && localVarOptionals.UpdateAccessKeyRequest.IsSet() {
localVarOptionalUpdateAccessKeyRequest, localVarOptionalUpdateAccessKeyRequestok := localVarOptionals.UpdateAccessKeyRequest.Value().(UpdateAccessKeyRequest)
if !localVarOptionalUpdateAccessKeyRequestok {
return localVarReturnValue, nil, reportError("updateAccessKeyRequest should be UpdateAccessKeyRequest")
}
localVarPostBody = &localVarOptionalUpdateAccessKeyRequest
}
if ctx != nil {
// API Key Authentication
if auth, ok := ctx.Value(ContextAPIKey).(APIKey); ok {
var key string
if auth.Prefix != "" {
key = auth.Prefix + " " + auth.Key
} else {
key = auth.Key
}
localVarHeaderParams["Authorization"] = key
}
}
r, err := a.client.prepareRequest(ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFormFileName, localVarFileName, localVarFileBytes)
if err != nil {
return localVarReturnValue, nil, err
}
localVarHTTPResponse, err := a.client.callAPI(r)
if err != nil || localVarHTTPResponse == nil {
return localVarReturnValue, localVarHTTPResponse, err
}
localVarBody, err := _ioutil.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
if err != nil {
return localVarReturnValue, localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
if localVarHTTPResponse.StatusCode == 200 {
var v UpdateAccessKeyResponse
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr.error = err.Error()
return localVarReturnValue, localVarHTTPResponse, newErr
}
newErr.model = v
}
return localVarReturnValue, localVarHTTPResponse, newErr
}
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr := GenericOpenAPIError{
body: localVarBody,
error: err.Error(),
}
return localVarReturnValue, localVarHTTPResponse, newErr
}
return localVarReturnValue, localVarHTTPResponse, nil
}

693
vendor/github.com/outscale/osc-sdk-go/osc/api_account.go generated vendored Normal file
View File

@ -0,0 +1,693 @@
/*
* 3DS OUTSCALE API
*
* Welcome to the 3DS OUTSCALE's API documentation.<br /><br /> The 3DS OUTSCALE API enables you to manage your resources in the 3DS OUTSCALE Cloud. This documentation describes the different actions available along with code examples.<br /><br /> Note that the 3DS OUTSCALE Cloud is compatible with Amazon Web Services (AWS) APIs, but some resources have different names in AWS than in the 3DS OUTSCALE API. You can find a list of the differences [here](https://wiki.outscale.net/display/EN/3DS+OUTSCALE+APIs+Reference).<br /><br /> You can also manage your resources using the [Cockpit](https://wiki.outscale.net/display/EN/About+Cockpit) web interface.
*
* API version: 1.2
* Contact: support@outscale.com
* Generated by: OpenAPI Generator (https://openapi-generator.tech)
*/
package osc
import (
_context "context"
_ioutil "io/ioutil"
_nethttp "net/http"
_neturl "net/url"
"github.com/antihax/optional"
)
// Linger please
var (
_ _context.Context
)
// AccountApiService AccountApi service
type AccountApiService service
// CheckAuthenticationOpts Optional parameters for the method 'CheckAuthentication'
type CheckAuthenticationOpts struct {
CheckAuthenticationRequest optional.Interface
}
/*
CheckAuthentication Method for CheckAuthentication
* @param ctx _context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
* @param optional nil or *CheckAuthenticationOpts - Optional Parameters:
* @param "CheckAuthenticationRequest" (optional.Interface of CheckAuthenticationRequest) -
@return CheckAuthenticationResponse
*/
func (a *AccountApiService) CheckAuthentication(ctx _context.Context, localVarOptionals *CheckAuthenticationOpts) (CheckAuthenticationResponse, *_nethttp.Response, error) {
var (
localVarHTTPMethod = _nethttp.MethodPost
localVarPostBody interface{}
localVarFormFileName string
localVarFileName string
localVarFileBytes []byte
localVarReturnValue CheckAuthenticationResponse
)
// create path and map variables
localVarPath := a.client.cfg.BasePath + "/CheckAuthentication"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := _neturl.Values{}
localVarFormParams := _neturl.Values{}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{"application/json"}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{"application/json"}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
// body params
if localVarOptionals != nil && localVarOptionals.CheckAuthenticationRequest.IsSet() {
localVarOptionalCheckAuthenticationRequest, localVarOptionalCheckAuthenticationRequestok := localVarOptionals.CheckAuthenticationRequest.Value().(CheckAuthenticationRequest)
if !localVarOptionalCheckAuthenticationRequestok {
return localVarReturnValue, nil, reportError("checkAuthenticationRequest should be CheckAuthenticationRequest")
}
localVarPostBody = &localVarOptionalCheckAuthenticationRequest
}
if ctx != nil {
// API Key Authentication
if auth, ok := ctx.Value(ContextAPIKey).(APIKey); ok {
var key string
if auth.Prefix != "" {
key = auth.Prefix + " " + auth.Key
} else {
key = auth.Key
}
localVarHeaderParams["Authorization"] = key
}
}
r, err := a.client.prepareRequest(ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFormFileName, localVarFileName, localVarFileBytes)
if err != nil {
return localVarReturnValue, nil, err
}
localVarHTTPResponse, err := a.client.callAPI(r)
if err != nil || localVarHTTPResponse == nil {
return localVarReturnValue, localVarHTTPResponse, err
}
localVarBody, err := _ioutil.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
if err != nil {
return localVarReturnValue, localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
if localVarHTTPResponse.StatusCode == 200 {
var v CheckAuthenticationResponse
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr.error = err.Error()
return localVarReturnValue, localVarHTTPResponse, newErr
}
newErr.model = v
}
return localVarReturnValue, localVarHTTPResponse, newErr
}
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr := GenericOpenAPIError{
body: localVarBody,
error: err.Error(),
}
return localVarReturnValue, localVarHTTPResponse, newErr
}
return localVarReturnValue, localVarHTTPResponse, nil
}
// CreateAccountOpts Optional parameters for the method 'CreateAccount'
type CreateAccountOpts struct {
CreateAccountRequest optional.Interface
}
/*
CreateAccount Method for CreateAccount
* @param ctx _context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
* @param optional nil or *CreateAccountOpts - Optional Parameters:
* @param "CreateAccountRequest" (optional.Interface of CreateAccountRequest) -
@return CreateAccountResponse
*/
func (a *AccountApiService) CreateAccount(ctx _context.Context, localVarOptionals *CreateAccountOpts) (CreateAccountResponse, *_nethttp.Response, error) {
var (
localVarHTTPMethod = _nethttp.MethodPost
localVarPostBody interface{}
localVarFormFileName string
localVarFileName string
localVarFileBytes []byte
localVarReturnValue CreateAccountResponse
)
// create path and map variables
localVarPath := a.client.cfg.BasePath + "/CreateAccount"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := _neturl.Values{}
localVarFormParams := _neturl.Values{}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{"application/json"}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{"application/json"}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
// body params
if localVarOptionals != nil && localVarOptionals.CreateAccountRequest.IsSet() {
localVarOptionalCreateAccountRequest, localVarOptionalCreateAccountRequestok := localVarOptionals.CreateAccountRequest.Value().(CreateAccountRequest)
if !localVarOptionalCreateAccountRequestok {
return localVarReturnValue, nil, reportError("createAccountRequest should be CreateAccountRequest")
}
localVarPostBody = &localVarOptionalCreateAccountRequest
}
if ctx != nil {
// API Key Authentication
if auth, ok := ctx.Value(ContextAPIKey).(APIKey); ok {
var key string
if auth.Prefix != "" {
key = auth.Prefix + " " + auth.Key
} else {
key = auth.Key
}
localVarHeaderParams["Authorization"] = key
}
}
r, err := a.client.prepareRequest(ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFormFileName, localVarFileName, localVarFileBytes)
if err != nil {
return localVarReturnValue, nil, err
}
localVarHTTPResponse, err := a.client.callAPI(r)
if err != nil || localVarHTTPResponse == nil {
return localVarReturnValue, localVarHTTPResponse, err
}
localVarBody, err := _ioutil.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
if err != nil {
return localVarReturnValue, localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
if localVarHTTPResponse.StatusCode == 200 {
var v CreateAccountResponse
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr.error = err.Error()
return localVarReturnValue, localVarHTTPResponse, newErr
}
newErr.model = v
}
return localVarReturnValue, localVarHTTPResponse, newErr
}
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr := GenericOpenAPIError{
body: localVarBody,
error: err.Error(),
}
return localVarReturnValue, localVarHTTPResponse, newErr
}
return localVarReturnValue, localVarHTTPResponse, nil
}
// ReadAccountsOpts Optional parameters for the method 'ReadAccounts'
type ReadAccountsOpts struct {
ReadAccountsRequest optional.Interface
}
/*
ReadAccounts Method for ReadAccounts
* @param ctx _context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
* @param optional nil or *ReadAccountsOpts - Optional Parameters:
* @param "ReadAccountsRequest" (optional.Interface of ReadAccountsRequest) -
@return ReadAccountsResponse
*/
func (a *AccountApiService) ReadAccounts(ctx _context.Context, localVarOptionals *ReadAccountsOpts) (ReadAccountsResponse, *_nethttp.Response, error) {
var (
localVarHTTPMethod = _nethttp.MethodPost
localVarPostBody interface{}
localVarFormFileName string
localVarFileName string
localVarFileBytes []byte
localVarReturnValue ReadAccountsResponse
)
// create path and map variables
localVarPath := a.client.cfg.BasePath + "/ReadAccounts"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := _neturl.Values{}
localVarFormParams := _neturl.Values{}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{"application/json"}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{"application/json"}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
// body params
if localVarOptionals != nil && localVarOptionals.ReadAccountsRequest.IsSet() {
localVarOptionalReadAccountsRequest, localVarOptionalReadAccountsRequestok := localVarOptionals.ReadAccountsRequest.Value().(ReadAccountsRequest)
if !localVarOptionalReadAccountsRequestok {
return localVarReturnValue, nil, reportError("readAccountsRequest should be ReadAccountsRequest")
}
localVarPostBody = &localVarOptionalReadAccountsRequest
}
if ctx != nil {
// API Key Authentication
if auth, ok := ctx.Value(ContextAPIKey).(APIKey); ok {
var key string
if auth.Prefix != "" {
key = auth.Prefix + " " + auth.Key
} else {
key = auth.Key
}
localVarHeaderParams["Authorization"] = key
}
}
r, err := a.client.prepareRequest(ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFormFileName, localVarFileName, localVarFileBytes)
if err != nil {
return localVarReturnValue, nil, err
}
localVarHTTPResponse, err := a.client.callAPI(r)
if err != nil || localVarHTTPResponse == nil {
return localVarReturnValue, localVarHTTPResponse, err
}
localVarBody, err := _ioutil.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
if err != nil {
return localVarReturnValue, localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
if localVarHTTPResponse.StatusCode == 200 {
var v ReadAccountsResponse
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr.error = err.Error()
return localVarReturnValue, localVarHTTPResponse, newErr
}
newErr.model = v
}
return localVarReturnValue, localVarHTTPResponse, newErr
}
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr := GenericOpenAPIError{
body: localVarBody,
error: err.Error(),
}
return localVarReturnValue, localVarHTTPResponse, newErr
}
return localVarReturnValue, localVarHTTPResponse, nil
}
// ResetAccountPasswordOpts Optional parameters for the method 'ResetAccountPassword'
type ResetAccountPasswordOpts struct {
ResetAccountPasswordRequest optional.Interface
}
/*
ResetAccountPassword Method for ResetAccountPassword
* @param ctx _context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
* @param optional nil or *ResetAccountPasswordOpts - Optional Parameters:
* @param "ResetAccountPasswordRequest" (optional.Interface of ResetAccountPasswordRequest) -
@return ResetAccountPasswordResponse
*/
func (a *AccountApiService) ResetAccountPassword(ctx _context.Context, localVarOptionals *ResetAccountPasswordOpts) (ResetAccountPasswordResponse, *_nethttp.Response, error) {
var (
localVarHTTPMethod = _nethttp.MethodPost
localVarPostBody interface{}
localVarFormFileName string
localVarFileName string
localVarFileBytes []byte
localVarReturnValue ResetAccountPasswordResponse
)
// create path and map variables
localVarPath := a.client.cfg.BasePath + "/ResetAccountPassword"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := _neturl.Values{}
localVarFormParams := _neturl.Values{}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{"application/json"}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{"application/json"}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
// body params
if localVarOptionals != nil && localVarOptionals.ResetAccountPasswordRequest.IsSet() {
localVarOptionalResetAccountPasswordRequest, localVarOptionalResetAccountPasswordRequestok := localVarOptionals.ResetAccountPasswordRequest.Value().(ResetAccountPasswordRequest)
if !localVarOptionalResetAccountPasswordRequestok {
return localVarReturnValue, nil, reportError("resetAccountPasswordRequest should be ResetAccountPasswordRequest")
}
localVarPostBody = &localVarOptionalResetAccountPasswordRequest
}
if ctx != nil {
// API Key Authentication
if auth, ok := ctx.Value(ContextAPIKey).(APIKey); ok {
var key string
if auth.Prefix != "" {
key = auth.Prefix + " " + auth.Key
} else {
key = auth.Key
}
localVarHeaderParams["Authorization"] = key
}
}
r, err := a.client.prepareRequest(ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFormFileName, localVarFileName, localVarFileBytes)
if err != nil {
return localVarReturnValue, nil, err
}
localVarHTTPResponse, err := a.client.callAPI(r)
if err != nil || localVarHTTPResponse == nil {
return localVarReturnValue, localVarHTTPResponse, err
}
localVarBody, err := _ioutil.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
if err != nil {
return localVarReturnValue, localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
if localVarHTTPResponse.StatusCode == 200 {
var v ResetAccountPasswordResponse
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr.error = err.Error()
return localVarReturnValue, localVarHTTPResponse, newErr
}
newErr.model = v
}
return localVarReturnValue, localVarHTTPResponse, newErr
}
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr := GenericOpenAPIError{
body: localVarBody,
error: err.Error(),
}
return localVarReturnValue, localVarHTTPResponse, newErr
}
return localVarReturnValue, localVarHTTPResponse, nil
}
// SendResetPasswordEmailOpts Optional parameters for the method 'SendResetPasswordEmail'
type SendResetPasswordEmailOpts struct {
SendResetPasswordEmailRequest optional.Interface
}
/*
SendResetPasswordEmail Method for SendResetPasswordEmail
* @param ctx _context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
* @param optional nil or *SendResetPasswordEmailOpts - Optional Parameters:
* @param "SendResetPasswordEmailRequest" (optional.Interface of SendResetPasswordEmailRequest) -
@return SendResetPasswordEmailResponse
*/
func (a *AccountApiService) SendResetPasswordEmail(ctx _context.Context, localVarOptionals *SendResetPasswordEmailOpts) (SendResetPasswordEmailResponse, *_nethttp.Response, error) {
var (
localVarHTTPMethod = _nethttp.MethodPost
localVarPostBody interface{}
localVarFormFileName string
localVarFileName string
localVarFileBytes []byte
localVarReturnValue SendResetPasswordEmailResponse
)
// create path and map variables
localVarPath := a.client.cfg.BasePath + "/SendResetPasswordEmail"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := _neturl.Values{}
localVarFormParams := _neturl.Values{}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{"application/json"}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{"application/json"}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
// body params
if localVarOptionals != nil && localVarOptionals.SendResetPasswordEmailRequest.IsSet() {
localVarOptionalSendResetPasswordEmailRequest, localVarOptionalSendResetPasswordEmailRequestok := localVarOptionals.SendResetPasswordEmailRequest.Value().(SendResetPasswordEmailRequest)
if !localVarOptionalSendResetPasswordEmailRequestok {
return localVarReturnValue, nil, reportError("sendResetPasswordEmailRequest should be SendResetPasswordEmailRequest")
}
localVarPostBody = &localVarOptionalSendResetPasswordEmailRequest
}
if ctx != nil {
// API Key Authentication
if auth, ok := ctx.Value(ContextAPIKey).(APIKey); ok {
var key string
if auth.Prefix != "" {
key = auth.Prefix + " " + auth.Key
} else {
key = auth.Key
}
localVarHeaderParams["Authorization"] = key
}
}
r, err := a.client.prepareRequest(ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFormFileName, localVarFileName, localVarFileBytes)
if err != nil {
return localVarReturnValue, nil, err
}
localVarHTTPResponse, err := a.client.callAPI(r)
if err != nil || localVarHTTPResponse == nil {
return localVarReturnValue, localVarHTTPResponse, err
}
localVarBody, err := _ioutil.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
if err != nil {
return localVarReturnValue, localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
if localVarHTTPResponse.StatusCode == 200 {
var v SendResetPasswordEmailResponse
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr.error = err.Error()
return localVarReturnValue, localVarHTTPResponse, newErr
}
newErr.model = v
}
return localVarReturnValue, localVarHTTPResponse, newErr
}
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr := GenericOpenAPIError{
body: localVarBody,
error: err.Error(),
}
return localVarReturnValue, localVarHTTPResponse, newErr
}
return localVarReturnValue, localVarHTTPResponse, nil
}
// UpdateAccountOpts Optional parameters for the method 'UpdateAccount'
type UpdateAccountOpts struct {
UpdateAccountRequest optional.Interface
}
/*
UpdateAccount Method for UpdateAccount
* @param ctx _context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
* @param optional nil or *UpdateAccountOpts - Optional Parameters:
* @param "UpdateAccountRequest" (optional.Interface of UpdateAccountRequest) -
@return UpdateAccountResponse
*/
func (a *AccountApiService) UpdateAccount(ctx _context.Context, localVarOptionals *UpdateAccountOpts) (UpdateAccountResponse, *_nethttp.Response, error) {
var (
localVarHTTPMethod = _nethttp.MethodPost
localVarPostBody interface{}
localVarFormFileName string
localVarFileName string
localVarFileBytes []byte
localVarReturnValue UpdateAccountResponse
)
// create path and map variables
localVarPath := a.client.cfg.BasePath + "/UpdateAccount"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := _neturl.Values{}
localVarFormParams := _neturl.Values{}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{"application/json"}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{"application/json"}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
// body params
if localVarOptionals != nil && localVarOptionals.UpdateAccountRequest.IsSet() {
localVarOptionalUpdateAccountRequest, localVarOptionalUpdateAccountRequestok := localVarOptionals.UpdateAccountRequest.Value().(UpdateAccountRequest)
if !localVarOptionalUpdateAccountRequestok {
return localVarReturnValue, nil, reportError("updateAccountRequest should be UpdateAccountRequest")
}
localVarPostBody = &localVarOptionalUpdateAccountRequest
}
if ctx != nil {
// API Key Authentication
if auth, ok := ctx.Value(ContextAPIKey).(APIKey); ok {
var key string
if auth.Prefix != "" {
key = auth.Prefix + " " + auth.Key
} else {
key = auth.Key
}
localVarHeaderParams["Authorization"] = key
}
}
r, err := a.client.prepareRequest(ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFormFileName, localVarFileName, localVarFileBytes)
if err != nil {
return localVarReturnValue, nil, err
}
localVarHTTPResponse, err := a.client.callAPI(r)
if err != nil || localVarHTTPResponse == nil {
return localVarReturnValue, localVarHTTPResponse, err
}
localVarBody, err := _ioutil.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
if err != nil {
return localVarReturnValue, localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
if localVarHTTPResponse.StatusCode == 200 {
var v UpdateAccountResponse
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr.error = err.Error()
return localVarReturnValue, localVarHTTPResponse, newErr
}
newErr.model = v
}
return localVarReturnValue, localVarHTTPResponse, newErr
}
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr := GenericOpenAPIError{
body: localVarBody,
error: err.Error(),
}
return localVarReturnValue, localVarHTTPResponse, newErr
}
return localVarReturnValue, localVarHTTPResponse, nil
}

138
vendor/github.com/outscale/osc-sdk-go/osc/api_api_log.go generated vendored Normal file
View File

@ -0,0 +1,138 @@
/*
* 3DS OUTSCALE API
*
* Welcome to the 3DS OUTSCALE's API documentation.<br /><br /> The 3DS OUTSCALE API enables you to manage your resources in the 3DS OUTSCALE Cloud. This documentation describes the different actions available along with code examples.<br /><br /> Note that the 3DS OUTSCALE Cloud is compatible with Amazon Web Services (AWS) APIs, but some resources have different names in AWS than in the 3DS OUTSCALE API. You can find a list of the differences [here](https://wiki.outscale.net/display/EN/3DS+OUTSCALE+APIs+Reference).<br /><br /> You can also manage your resources using the [Cockpit](https://wiki.outscale.net/display/EN/About+Cockpit) web interface.
*
* API version: 1.2
* Contact: support@outscale.com
* Generated by: OpenAPI Generator (https://openapi-generator.tech)
*/
package osc
import (
_context "context"
_ioutil "io/ioutil"
_nethttp "net/http"
_neturl "net/url"
"github.com/antihax/optional"
)
// Linger please
var (
_ _context.Context
)
// ApiLogApiService ApiLogApi service
type ApiLogApiService service
// ReadApiLogsOpts Optional parameters for the method 'ReadApiLogs'
type ReadApiLogsOpts struct {
ReadApiLogsRequest optional.Interface
}
/*
ReadApiLogs Method for ReadApiLogs
* @param ctx _context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
* @param optional nil or *ReadApiLogsOpts - Optional Parameters:
* @param "ReadApiLogsRequest" (optional.Interface of ReadApiLogsRequest) -
@return ReadApiLogsResponse
*/
func (a *ApiLogApiService) ReadApiLogs(ctx _context.Context, localVarOptionals *ReadApiLogsOpts) (ReadApiLogsResponse, *_nethttp.Response, error) {
var (
localVarHTTPMethod = _nethttp.MethodPost
localVarPostBody interface{}
localVarFormFileName string
localVarFileName string
localVarFileBytes []byte
localVarReturnValue ReadApiLogsResponse
)
// create path and map variables
localVarPath := a.client.cfg.BasePath + "/ReadApiLogs"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := _neturl.Values{}
localVarFormParams := _neturl.Values{}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{"application/json"}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{"application/json"}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
// body params
if localVarOptionals != nil && localVarOptionals.ReadApiLogsRequest.IsSet() {
localVarOptionalReadApiLogsRequest, localVarOptionalReadApiLogsRequestok := localVarOptionals.ReadApiLogsRequest.Value().(ReadApiLogsRequest)
if !localVarOptionalReadApiLogsRequestok {
return localVarReturnValue, nil, reportError("readApiLogsRequest should be ReadApiLogsRequest")
}
localVarPostBody = &localVarOptionalReadApiLogsRequest
}
if ctx != nil {
// API Key Authentication
if auth, ok := ctx.Value(ContextAPIKey).(APIKey); ok {
var key string
if auth.Prefix != "" {
key = auth.Prefix + " " + auth.Key
} else {
key = auth.Key
}
localVarHeaderParams["Authorization"] = key
}
}
r, err := a.client.prepareRequest(ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFormFileName, localVarFileName, localVarFileBytes)
if err != nil {
return localVarReturnValue, nil, err
}
localVarHTTPResponse, err := a.client.callAPI(r)
if err != nil || localVarHTTPResponse == nil {
return localVarReturnValue, localVarHTTPResponse, err
}
localVarBody, err := _ioutil.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
if err != nil {
return localVarReturnValue, localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
if localVarHTTPResponse.StatusCode == 200 {
var v ReadApiLogsResponse
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr.error = err.Error()
return localVarReturnValue, localVarHTTPResponse, newErr
}
newErr.model = v
}
return localVarReturnValue, localVarHTTPResponse, newErr
}
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr := GenericOpenAPIError{
body: localVarBody,
error: err.Error(),
}
return localVarReturnValue, localVarHTTPResponse, newErr
}
return localVarReturnValue, localVarHTTPResponse, nil
}

360
vendor/github.com/outscale/osc-sdk-go/osc/api_client_gateway.go generated vendored Normal file
View File

@ -0,0 +1,360 @@
/*
* 3DS OUTSCALE API
*
* Welcome to the 3DS OUTSCALE's API documentation.<br /><br /> The 3DS OUTSCALE API enables you to manage your resources in the 3DS OUTSCALE Cloud. This documentation describes the different actions available along with code examples.<br /><br /> Note that the 3DS OUTSCALE Cloud is compatible with Amazon Web Services (AWS) APIs, but some resources have different names in AWS than in the 3DS OUTSCALE API. You can find a list of the differences [here](https://wiki.outscale.net/display/EN/3DS+OUTSCALE+APIs+Reference).<br /><br /> You can also manage your resources using the [Cockpit](https://wiki.outscale.net/display/EN/About+Cockpit) web interface.
*
* API version: 1.2
* Contact: support@outscale.com
* Generated by: OpenAPI Generator (https://openapi-generator.tech)
*/
package osc
import (
_context "context"
_ioutil "io/ioutil"
_nethttp "net/http"
_neturl "net/url"
"github.com/antihax/optional"
)
// Linger please
var (
_ _context.Context
)
// ClientGatewayApiService ClientGatewayApi service
type ClientGatewayApiService service
// CreateClientGatewayOpts Optional parameters for the method 'CreateClientGateway'
type CreateClientGatewayOpts struct {
CreateClientGatewayRequest optional.Interface
}
/*
CreateClientGateway Method for CreateClientGateway
* @param ctx _context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
* @param optional nil or *CreateClientGatewayOpts - Optional Parameters:
* @param "CreateClientGatewayRequest" (optional.Interface of CreateClientGatewayRequest) -
@return CreateClientGatewayResponse
*/
func (a *ClientGatewayApiService) CreateClientGateway(ctx _context.Context, localVarOptionals *CreateClientGatewayOpts) (CreateClientGatewayResponse, *_nethttp.Response, error) {
var (
localVarHTTPMethod = _nethttp.MethodPost
localVarPostBody interface{}
localVarFormFileName string
localVarFileName string
localVarFileBytes []byte
localVarReturnValue CreateClientGatewayResponse
)
// create path and map variables
localVarPath := a.client.cfg.BasePath + "/CreateClientGateway"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := _neturl.Values{}
localVarFormParams := _neturl.Values{}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{"application/json"}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{"application/json"}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
// body params
if localVarOptionals != nil && localVarOptionals.CreateClientGatewayRequest.IsSet() {
localVarOptionalCreateClientGatewayRequest, localVarOptionalCreateClientGatewayRequestok := localVarOptionals.CreateClientGatewayRequest.Value().(CreateClientGatewayRequest)
if !localVarOptionalCreateClientGatewayRequestok {
return localVarReturnValue, nil, reportError("createClientGatewayRequest should be CreateClientGatewayRequest")
}
localVarPostBody = &localVarOptionalCreateClientGatewayRequest
}
if ctx != nil {
// API Key Authentication
if auth, ok := ctx.Value(ContextAPIKey).(APIKey); ok {
var key string
if auth.Prefix != "" {
key = auth.Prefix + " " + auth.Key
} else {
key = auth.Key
}
localVarHeaderParams["Authorization"] = key
}
}
r, err := a.client.prepareRequest(ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFormFileName, localVarFileName, localVarFileBytes)
if err != nil {
return localVarReturnValue, nil, err
}
localVarHTTPResponse, err := a.client.callAPI(r)
if err != nil || localVarHTTPResponse == nil {
return localVarReturnValue, localVarHTTPResponse, err
}
localVarBody, err := _ioutil.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
if err != nil {
return localVarReturnValue, localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
if localVarHTTPResponse.StatusCode == 200 {
var v CreateClientGatewayResponse
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr.error = err.Error()
return localVarReturnValue, localVarHTTPResponse, newErr
}
newErr.model = v
}
return localVarReturnValue, localVarHTTPResponse, newErr
}
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr := GenericOpenAPIError{
body: localVarBody,
error: err.Error(),
}
return localVarReturnValue, localVarHTTPResponse, newErr
}
return localVarReturnValue, localVarHTTPResponse, nil
}
// DeleteClientGatewayOpts Optional parameters for the method 'DeleteClientGateway'
type DeleteClientGatewayOpts struct {
DeleteClientGatewayRequest optional.Interface
}
/*
DeleteClientGateway Method for DeleteClientGateway
* @param ctx _context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
* @param optional nil or *DeleteClientGatewayOpts - Optional Parameters:
* @param "DeleteClientGatewayRequest" (optional.Interface of DeleteClientGatewayRequest) -
@return DeleteClientGatewayResponse
*/
func (a *ClientGatewayApiService) DeleteClientGateway(ctx _context.Context, localVarOptionals *DeleteClientGatewayOpts) (DeleteClientGatewayResponse, *_nethttp.Response, error) {
var (
localVarHTTPMethod = _nethttp.MethodPost
localVarPostBody interface{}
localVarFormFileName string
localVarFileName string
localVarFileBytes []byte
localVarReturnValue DeleteClientGatewayResponse
)
// create path and map variables
localVarPath := a.client.cfg.BasePath + "/DeleteClientGateway"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := _neturl.Values{}
localVarFormParams := _neturl.Values{}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{"application/json"}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{"application/json"}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
// body params
if localVarOptionals != nil && localVarOptionals.DeleteClientGatewayRequest.IsSet() {
localVarOptionalDeleteClientGatewayRequest, localVarOptionalDeleteClientGatewayRequestok := localVarOptionals.DeleteClientGatewayRequest.Value().(DeleteClientGatewayRequest)
if !localVarOptionalDeleteClientGatewayRequestok {
return localVarReturnValue, nil, reportError("deleteClientGatewayRequest should be DeleteClientGatewayRequest")
}
localVarPostBody = &localVarOptionalDeleteClientGatewayRequest
}
if ctx != nil {
// API Key Authentication
if auth, ok := ctx.Value(ContextAPIKey).(APIKey); ok {
var key string
if auth.Prefix != "" {
key = auth.Prefix + " " + auth.Key
} else {
key = auth.Key
}
localVarHeaderParams["Authorization"] = key
}
}
r, err := a.client.prepareRequest(ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFormFileName, localVarFileName, localVarFileBytes)
if err != nil {
return localVarReturnValue, nil, err
}
localVarHTTPResponse, err := a.client.callAPI(r)
if err != nil || localVarHTTPResponse == nil {
return localVarReturnValue, localVarHTTPResponse, err
}
localVarBody, err := _ioutil.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
if err != nil {
return localVarReturnValue, localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
if localVarHTTPResponse.StatusCode == 200 {
var v DeleteClientGatewayResponse
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr.error = err.Error()
return localVarReturnValue, localVarHTTPResponse, newErr
}
newErr.model = v
}
return localVarReturnValue, localVarHTTPResponse, newErr
}
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr := GenericOpenAPIError{
body: localVarBody,
error: err.Error(),
}
return localVarReturnValue, localVarHTTPResponse, newErr
}
return localVarReturnValue, localVarHTTPResponse, nil
}
// ReadClientGatewaysOpts Optional parameters for the method 'ReadClientGateways'
type ReadClientGatewaysOpts struct {
ReadClientGatewaysRequest optional.Interface
}
/*
ReadClientGateways Method for ReadClientGateways
* @param ctx _context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
* @param optional nil or *ReadClientGatewaysOpts - Optional Parameters:
* @param "ReadClientGatewaysRequest" (optional.Interface of ReadClientGatewaysRequest) -
@return ReadClientGatewaysResponse
*/
func (a *ClientGatewayApiService) ReadClientGateways(ctx _context.Context, localVarOptionals *ReadClientGatewaysOpts) (ReadClientGatewaysResponse, *_nethttp.Response, error) {
var (
localVarHTTPMethod = _nethttp.MethodPost
localVarPostBody interface{}
localVarFormFileName string
localVarFileName string
localVarFileBytes []byte
localVarReturnValue ReadClientGatewaysResponse
)
// create path and map variables
localVarPath := a.client.cfg.BasePath + "/ReadClientGateways"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := _neturl.Values{}
localVarFormParams := _neturl.Values{}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{"application/json"}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{"application/json"}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
// body params
if localVarOptionals != nil && localVarOptionals.ReadClientGatewaysRequest.IsSet() {
localVarOptionalReadClientGatewaysRequest, localVarOptionalReadClientGatewaysRequestok := localVarOptionals.ReadClientGatewaysRequest.Value().(ReadClientGatewaysRequest)
if !localVarOptionalReadClientGatewaysRequestok {
return localVarReturnValue, nil, reportError("readClientGatewaysRequest should be ReadClientGatewaysRequest")
}
localVarPostBody = &localVarOptionalReadClientGatewaysRequest
}
if ctx != nil {
// API Key Authentication
if auth, ok := ctx.Value(ContextAPIKey).(APIKey); ok {
var key string
if auth.Prefix != "" {
key = auth.Prefix + " " + auth.Key
} else {
key = auth.Key
}
localVarHeaderParams["Authorization"] = key
}
}
r, err := a.client.prepareRequest(ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFormFileName, localVarFileName, localVarFileBytes)
if err != nil {
return localVarReturnValue, nil, err
}
localVarHTTPResponse, err := a.client.callAPI(r)
if err != nil || localVarHTTPResponse == nil {
return localVarReturnValue, localVarHTTPResponse, err
}
localVarBody, err := _ioutil.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
if err != nil {
return localVarReturnValue, localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
if localVarHTTPResponse.StatusCode == 200 {
var v ReadClientGatewaysResponse
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr.error = err.Error()
return localVarReturnValue, localVarHTTPResponse, newErr
}
newErr.model = v
}
return localVarReturnValue, localVarHTTPResponse, newErr
}
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr := GenericOpenAPIError{
body: localVarBody,
error: err.Error(),
}
return localVarReturnValue, localVarHTTPResponse, newErr
}
return localVarReturnValue, localVarHTTPResponse, nil
}

138
vendor/github.com/outscale/osc-sdk-go/osc/api_default.go generated vendored Normal file
View File

@ -0,0 +1,138 @@
/*
* 3DS OUTSCALE API
*
* Welcome to the 3DS OUTSCALE's API documentation.<br /><br /> The 3DS OUTSCALE API enables you to manage your resources in the 3DS OUTSCALE Cloud. This documentation describes the different actions available along with code examples.<br /><br /> Note that the 3DS OUTSCALE Cloud is compatible with Amazon Web Services (AWS) APIs, but some resources have different names in AWS than in the 3DS OUTSCALE API. You can find a list of the differences [here](https://wiki.outscale.net/display/EN/3DS+OUTSCALE+APIs+Reference).<br /><br /> You can also manage your resources using the [Cockpit](https://wiki.outscale.net/display/EN/About+Cockpit) web interface.
*
* API version: 1.2
* Contact: support@outscale.com
* Generated by: OpenAPI Generator (https://openapi-generator.tech)
*/
package osc
import (
_context "context"
_ioutil "io/ioutil"
_nethttp "net/http"
_neturl "net/url"
"github.com/antihax/optional"
)
// Linger please
var (
_ _context.Context
)
// DefaultApiService DefaultApi service
type DefaultApiService service
// ReadConsumptionAccountOpts Optional parameters for the method 'ReadConsumptionAccount'
type ReadConsumptionAccountOpts struct {
ReadConsumptionAccountRequest optional.Interface
}
/*
ReadConsumptionAccount Method for ReadConsumptionAccount
* @param ctx _context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
* @param optional nil or *ReadConsumptionAccountOpts - Optional Parameters:
* @param "ReadConsumptionAccountRequest" (optional.Interface of ReadConsumptionAccountRequest) -
@return ReadConsumptionAccountResponse
*/
func (a *DefaultApiService) ReadConsumptionAccount(ctx _context.Context, localVarOptionals *ReadConsumptionAccountOpts) (ReadConsumptionAccountResponse, *_nethttp.Response, error) {
var (
localVarHTTPMethod = _nethttp.MethodPost
localVarPostBody interface{}
localVarFormFileName string
localVarFileName string
localVarFileBytes []byte
localVarReturnValue ReadConsumptionAccountResponse
)
// create path and map variables
localVarPath := a.client.cfg.BasePath + "/ReadConsumptionAccount"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := _neturl.Values{}
localVarFormParams := _neturl.Values{}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{"application/json"}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{"application/json"}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
// body params
if localVarOptionals != nil && localVarOptionals.ReadConsumptionAccountRequest.IsSet() {
localVarOptionalReadConsumptionAccountRequest, localVarOptionalReadConsumptionAccountRequestok := localVarOptionals.ReadConsumptionAccountRequest.Value().(ReadConsumptionAccountRequest)
if !localVarOptionalReadConsumptionAccountRequestok {
return localVarReturnValue, nil, reportError("readConsumptionAccountRequest should be ReadConsumptionAccountRequest")
}
localVarPostBody = &localVarOptionalReadConsumptionAccountRequest
}
if ctx != nil {
// API Key Authentication
if auth, ok := ctx.Value(ContextAPIKey).(APIKey); ok {
var key string
if auth.Prefix != "" {
key = auth.Prefix + " " + auth.Key
} else {
key = auth.Key
}
localVarHeaderParams["Authorization"] = key
}
}
r, err := a.client.prepareRequest(ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFormFileName, localVarFileName, localVarFileBytes)
if err != nil {
return localVarReturnValue, nil, err
}
localVarHTTPResponse, err := a.client.callAPI(r)
if err != nil || localVarHTTPResponse == nil {
return localVarReturnValue, localVarHTTPResponse, err
}
localVarBody, err := _ioutil.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
if err != nil {
return localVarReturnValue, localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
if localVarHTTPResponse.StatusCode == 200 {
var v ReadConsumptionAccountResponse
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr.error = err.Error()
return localVarReturnValue, localVarHTTPResponse, newErr
}
newErr.model = v
}
return localVarReturnValue, localVarHTTPResponse, newErr
}
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr := GenericOpenAPIError{
body: localVarBody,
error: err.Error(),
}
return localVarReturnValue, localVarHTTPResponse, newErr
}
return localVarReturnValue, localVarHTTPResponse, nil
}

360
vendor/github.com/outscale/osc-sdk-go/osc/api_dhcp_option.go generated vendored Normal file
View File

@ -0,0 +1,360 @@
/*
* 3DS OUTSCALE API
*
* Welcome to the 3DS OUTSCALE's API documentation.<br /><br /> The 3DS OUTSCALE API enables you to manage your resources in the 3DS OUTSCALE Cloud. This documentation describes the different actions available along with code examples.<br /><br /> Note that the 3DS OUTSCALE Cloud is compatible with Amazon Web Services (AWS) APIs, but some resources have different names in AWS than in the 3DS OUTSCALE API. You can find a list of the differences [here](https://wiki.outscale.net/display/EN/3DS+OUTSCALE+APIs+Reference).<br /><br /> You can also manage your resources using the [Cockpit](https://wiki.outscale.net/display/EN/About+Cockpit) web interface.
*
* API version: 1.2
* Contact: support@outscale.com
* Generated by: OpenAPI Generator (https://openapi-generator.tech)
*/
package osc
import (
_context "context"
_ioutil "io/ioutil"
_nethttp "net/http"
_neturl "net/url"
"github.com/antihax/optional"
)
// Linger please
var (
_ _context.Context
)
// DhcpOptionApiService DhcpOptionApi service
type DhcpOptionApiService service
// CreateDhcpOptionsOpts Optional parameters for the method 'CreateDhcpOptions'
type CreateDhcpOptionsOpts struct {
CreateDhcpOptionsRequest optional.Interface
}
/*
CreateDhcpOptions Method for CreateDhcpOptions
* @param ctx _context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
* @param optional nil or *CreateDhcpOptionsOpts - Optional Parameters:
* @param "CreateDhcpOptionsRequest" (optional.Interface of CreateDhcpOptionsRequest) -
@return CreateDhcpOptionsResponse
*/
func (a *DhcpOptionApiService) CreateDhcpOptions(ctx _context.Context, localVarOptionals *CreateDhcpOptionsOpts) (CreateDhcpOptionsResponse, *_nethttp.Response, error) {
var (
localVarHTTPMethod = _nethttp.MethodPost
localVarPostBody interface{}
localVarFormFileName string
localVarFileName string
localVarFileBytes []byte
localVarReturnValue CreateDhcpOptionsResponse
)
// create path and map variables
localVarPath := a.client.cfg.BasePath + "/CreateDhcpOptions"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := _neturl.Values{}
localVarFormParams := _neturl.Values{}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{"application/json"}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{"application/json"}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
// body params
if localVarOptionals != nil && localVarOptionals.CreateDhcpOptionsRequest.IsSet() {
localVarOptionalCreateDhcpOptionsRequest, localVarOptionalCreateDhcpOptionsRequestok := localVarOptionals.CreateDhcpOptionsRequest.Value().(CreateDhcpOptionsRequest)
if !localVarOptionalCreateDhcpOptionsRequestok {
return localVarReturnValue, nil, reportError("createDhcpOptionsRequest should be CreateDhcpOptionsRequest")
}
localVarPostBody = &localVarOptionalCreateDhcpOptionsRequest
}
if ctx != nil {
// API Key Authentication
if auth, ok := ctx.Value(ContextAPIKey).(APIKey); ok {
var key string
if auth.Prefix != "" {
key = auth.Prefix + " " + auth.Key
} else {
key = auth.Key
}
localVarHeaderParams["Authorization"] = key
}
}
r, err := a.client.prepareRequest(ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFormFileName, localVarFileName, localVarFileBytes)
if err != nil {
return localVarReturnValue, nil, err
}
localVarHTTPResponse, err := a.client.callAPI(r)
if err != nil || localVarHTTPResponse == nil {
return localVarReturnValue, localVarHTTPResponse, err
}
localVarBody, err := _ioutil.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
if err != nil {
return localVarReturnValue, localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
if localVarHTTPResponse.StatusCode == 200 {
var v CreateDhcpOptionsResponse
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr.error = err.Error()
return localVarReturnValue, localVarHTTPResponse, newErr
}
newErr.model = v
}
return localVarReturnValue, localVarHTTPResponse, newErr
}
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr := GenericOpenAPIError{
body: localVarBody,
error: err.Error(),
}
return localVarReturnValue, localVarHTTPResponse, newErr
}
return localVarReturnValue, localVarHTTPResponse, nil
}
// DeleteDhcpOptionsOpts Optional parameters for the method 'DeleteDhcpOptions'
type DeleteDhcpOptionsOpts struct {
DeleteDhcpOptionsRequest optional.Interface
}
/*
DeleteDhcpOptions Method for DeleteDhcpOptions
* @param ctx _context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
* @param optional nil or *DeleteDhcpOptionsOpts - Optional Parameters:
* @param "DeleteDhcpOptionsRequest" (optional.Interface of DeleteDhcpOptionsRequest) -
@return DeleteDhcpOptionsResponse
*/
func (a *DhcpOptionApiService) DeleteDhcpOptions(ctx _context.Context, localVarOptionals *DeleteDhcpOptionsOpts) (DeleteDhcpOptionsResponse, *_nethttp.Response, error) {
var (
localVarHTTPMethod = _nethttp.MethodPost
localVarPostBody interface{}
localVarFormFileName string
localVarFileName string
localVarFileBytes []byte
localVarReturnValue DeleteDhcpOptionsResponse
)
// create path and map variables
localVarPath := a.client.cfg.BasePath + "/DeleteDhcpOptions"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := _neturl.Values{}
localVarFormParams := _neturl.Values{}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{"application/json"}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{"application/json"}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
// body params
if localVarOptionals != nil && localVarOptionals.DeleteDhcpOptionsRequest.IsSet() {
localVarOptionalDeleteDhcpOptionsRequest, localVarOptionalDeleteDhcpOptionsRequestok := localVarOptionals.DeleteDhcpOptionsRequest.Value().(DeleteDhcpOptionsRequest)
if !localVarOptionalDeleteDhcpOptionsRequestok {
return localVarReturnValue, nil, reportError("deleteDhcpOptionsRequest should be DeleteDhcpOptionsRequest")
}
localVarPostBody = &localVarOptionalDeleteDhcpOptionsRequest
}
if ctx != nil {
// API Key Authentication
if auth, ok := ctx.Value(ContextAPIKey).(APIKey); ok {
var key string
if auth.Prefix != "" {
key = auth.Prefix + " " + auth.Key
} else {
key = auth.Key
}
localVarHeaderParams["Authorization"] = key
}
}
r, err := a.client.prepareRequest(ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFormFileName, localVarFileName, localVarFileBytes)
if err != nil {
return localVarReturnValue, nil, err
}
localVarHTTPResponse, err := a.client.callAPI(r)
if err != nil || localVarHTTPResponse == nil {
return localVarReturnValue, localVarHTTPResponse, err
}
localVarBody, err := _ioutil.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
if err != nil {
return localVarReturnValue, localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
if localVarHTTPResponse.StatusCode == 200 {
var v DeleteDhcpOptionsResponse
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr.error = err.Error()
return localVarReturnValue, localVarHTTPResponse, newErr
}
newErr.model = v
}
return localVarReturnValue, localVarHTTPResponse, newErr
}
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr := GenericOpenAPIError{
body: localVarBody,
error: err.Error(),
}
return localVarReturnValue, localVarHTTPResponse, newErr
}
return localVarReturnValue, localVarHTTPResponse, nil
}
// ReadDhcpOptionsOpts Optional parameters for the method 'ReadDhcpOptions'
type ReadDhcpOptionsOpts struct {
ReadDhcpOptionsRequest optional.Interface
}
/*
ReadDhcpOptions Method for ReadDhcpOptions
* @param ctx _context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
* @param optional nil or *ReadDhcpOptionsOpts - Optional Parameters:
* @param "ReadDhcpOptionsRequest" (optional.Interface of ReadDhcpOptionsRequest) -
@return ReadDhcpOptionsResponse
*/
func (a *DhcpOptionApiService) ReadDhcpOptions(ctx _context.Context, localVarOptionals *ReadDhcpOptionsOpts) (ReadDhcpOptionsResponse, *_nethttp.Response, error) {
var (
localVarHTTPMethod = _nethttp.MethodPost
localVarPostBody interface{}
localVarFormFileName string
localVarFileName string
localVarFileBytes []byte
localVarReturnValue ReadDhcpOptionsResponse
)
// create path and map variables
localVarPath := a.client.cfg.BasePath + "/ReadDhcpOptions"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := _neturl.Values{}
localVarFormParams := _neturl.Values{}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{"application/json"}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{"application/json"}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
// body params
if localVarOptionals != nil && localVarOptionals.ReadDhcpOptionsRequest.IsSet() {
localVarOptionalReadDhcpOptionsRequest, localVarOptionalReadDhcpOptionsRequestok := localVarOptionals.ReadDhcpOptionsRequest.Value().(ReadDhcpOptionsRequest)
if !localVarOptionalReadDhcpOptionsRequestok {
return localVarReturnValue, nil, reportError("readDhcpOptionsRequest should be ReadDhcpOptionsRequest")
}
localVarPostBody = &localVarOptionalReadDhcpOptionsRequest
}
if ctx != nil {
// API Key Authentication
if auth, ok := ctx.Value(ContextAPIKey).(APIKey); ok {
var key string
if auth.Prefix != "" {
key = auth.Prefix + " " + auth.Key
} else {
key = auth.Key
}
localVarHeaderParams["Authorization"] = key
}
}
r, err := a.client.prepareRequest(ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFormFileName, localVarFileName, localVarFileBytes)
if err != nil {
return localVarReturnValue, nil, err
}
localVarHTTPResponse, err := a.client.callAPI(r)
if err != nil || localVarHTTPResponse == nil {
return localVarReturnValue, localVarHTTPResponse, err
}
localVarBody, err := _ioutil.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
if err != nil {
return localVarReturnValue, localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
if localVarHTTPResponse.StatusCode == 200 {
var v ReadDhcpOptionsResponse
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr.error = err.Error()
return localVarReturnValue, localVarHTTPResponse, newErr
}
newErr.model = v
}
return localVarReturnValue, localVarHTTPResponse, newErr
}
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr := GenericOpenAPIError{
body: localVarBody,
error: err.Error(),
}
return localVarReturnValue, localVarHTTPResponse, newErr
}
return localVarReturnValue, localVarHTTPResponse, nil
}

360
vendor/github.com/outscale/osc-sdk-go/osc/api_direct_link.go generated vendored Normal file
View File

@ -0,0 +1,360 @@
/*
* 3DS OUTSCALE API
*
* Welcome to the 3DS OUTSCALE's API documentation.<br /><br /> The 3DS OUTSCALE API enables you to manage your resources in the 3DS OUTSCALE Cloud. This documentation describes the different actions available along with code examples.<br /><br /> Note that the 3DS OUTSCALE Cloud is compatible with Amazon Web Services (AWS) APIs, but some resources have different names in AWS than in the 3DS OUTSCALE API. You can find a list of the differences [here](https://wiki.outscale.net/display/EN/3DS+OUTSCALE+APIs+Reference).<br /><br /> You can also manage your resources using the [Cockpit](https://wiki.outscale.net/display/EN/About+Cockpit) web interface.
*
* API version: 1.2
* Contact: support@outscale.com
* Generated by: OpenAPI Generator (https://openapi-generator.tech)
*/
package osc
import (
_context "context"
_ioutil "io/ioutil"
_nethttp "net/http"
_neturl "net/url"
"github.com/antihax/optional"
)
// Linger please
var (
_ _context.Context
)
// DirectLinkApiService DirectLinkApi service
type DirectLinkApiService service
// CreateDirectLinkOpts Optional parameters for the method 'CreateDirectLink'
type CreateDirectLinkOpts struct {
CreateDirectLinkRequest optional.Interface
}
/*
CreateDirectLink Method for CreateDirectLink
* @param ctx _context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
* @param optional nil or *CreateDirectLinkOpts - Optional Parameters:
* @param "CreateDirectLinkRequest" (optional.Interface of CreateDirectLinkRequest) -
@return CreateDirectLinkResponse
*/
func (a *DirectLinkApiService) CreateDirectLink(ctx _context.Context, localVarOptionals *CreateDirectLinkOpts) (CreateDirectLinkResponse, *_nethttp.Response, error) {
var (
localVarHTTPMethod = _nethttp.MethodPost
localVarPostBody interface{}
localVarFormFileName string
localVarFileName string
localVarFileBytes []byte
localVarReturnValue CreateDirectLinkResponse
)
// create path and map variables
localVarPath := a.client.cfg.BasePath + "/CreateDirectLink"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := _neturl.Values{}
localVarFormParams := _neturl.Values{}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{"application/json"}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{"application/json"}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
// body params
if localVarOptionals != nil && localVarOptionals.CreateDirectLinkRequest.IsSet() {
localVarOptionalCreateDirectLinkRequest, localVarOptionalCreateDirectLinkRequestok := localVarOptionals.CreateDirectLinkRequest.Value().(CreateDirectLinkRequest)
if !localVarOptionalCreateDirectLinkRequestok {
return localVarReturnValue, nil, reportError("createDirectLinkRequest should be CreateDirectLinkRequest")
}
localVarPostBody = &localVarOptionalCreateDirectLinkRequest
}
if ctx != nil {
// API Key Authentication
if auth, ok := ctx.Value(ContextAPIKey).(APIKey); ok {
var key string
if auth.Prefix != "" {
key = auth.Prefix + " " + auth.Key
} else {
key = auth.Key
}
localVarHeaderParams["Authorization"] = key
}
}
r, err := a.client.prepareRequest(ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFormFileName, localVarFileName, localVarFileBytes)
if err != nil {
return localVarReturnValue, nil, err
}
localVarHTTPResponse, err := a.client.callAPI(r)
if err != nil || localVarHTTPResponse == nil {
return localVarReturnValue, localVarHTTPResponse, err
}
localVarBody, err := _ioutil.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
if err != nil {
return localVarReturnValue, localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
if localVarHTTPResponse.StatusCode == 200 {
var v CreateDirectLinkResponse
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr.error = err.Error()
return localVarReturnValue, localVarHTTPResponse, newErr
}
newErr.model = v
}
return localVarReturnValue, localVarHTTPResponse, newErr
}
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr := GenericOpenAPIError{
body: localVarBody,
error: err.Error(),
}
return localVarReturnValue, localVarHTTPResponse, newErr
}
return localVarReturnValue, localVarHTTPResponse, nil
}
// DeleteDirectLinkOpts Optional parameters for the method 'DeleteDirectLink'
type DeleteDirectLinkOpts struct {
DeleteDirectLinkRequest optional.Interface
}
/*
DeleteDirectLink Method for DeleteDirectLink
* @param ctx _context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
* @param optional nil or *DeleteDirectLinkOpts - Optional Parameters:
* @param "DeleteDirectLinkRequest" (optional.Interface of DeleteDirectLinkRequest) -
@return DeleteDirectLinkResponse
*/
func (a *DirectLinkApiService) DeleteDirectLink(ctx _context.Context, localVarOptionals *DeleteDirectLinkOpts) (DeleteDirectLinkResponse, *_nethttp.Response, error) {
var (
localVarHTTPMethod = _nethttp.MethodPost
localVarPostBody interface{}
localVarFormFileName string
localVarFileName string
localVarFileBytes []byte
localVarReturnValue DeleteDirectLinkResponse
)
// create path and map variables
localVarPath := a.client.cfg.BasePath + "/DeleteDirectLink"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := _neturl.Values{}
localVarFormParams := _neturl.Values{}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{"application/json"}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{"application/json"}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
// body params
if localVarOptionals != nil && localVarOptionals.DeleteDirectLinkRequest.IsSet() {
localVarOptionalDeleteDirectLinkRequest, localVarOptionalDeleteDirectLinkRequestok := localVarOptionals.DeleteDirectLinkRequest.Value().(DeleteDirectLinkRequest)
if !localVarOptionalDeleteDirectLinkRequestok {
return localVarReturnValue, nil, reportError("deleteDirectLinkRequest should be DeleteDirectLinkRequest")
}
localVarPostBody = &localVarOptionalDeleteDirectLinkRequest
}
if ctx != nil {
// API Key Authentication
if auth, ok := ctx.Value(ContextAPIKey).(APIKey); ok {
var key string
if auth.Prefix != "" {
key = auth.Prefix + " " + auth.Key
} else {
key = auth.Key
}
localVarHeaderParams["Authorization"] = key
}
}
r, err := a.client.prepareRequest(ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFormFileName, localVarFileName, localVarFileBytes)
if err != nil {
return localVarReturnValue, nil, err
}
localVarHTTPResponse, err := a.client.callAPI(r)
if err != nil || localVarHTTPResponse == nil {
return localVarReturnValue, localVarHTTPResponse, err
}
localVarBody, err := _ioutil.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
if err != nil {
return localVarReturnValue, localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
if localVarHTTPResponse.StatusCode == 200 {
var v DeleteDirectLinkResponse
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr.error = err.Error()
return localVarReturnValue, localVarHTTPResponse, newErr
}
newErr.model = v
}
return localVarReturnValue, localVarHTTPResponse, newErr
}
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr := GenericOpenAPIError{
body: localVarBody,
error: err.Error(),
}
return localVarReturnValue, localVarHTTPResponse, newErr
}
return localVarReturnValue, localVarHTTPResponse, nil
}
// ReadDirectLinksOpts Optional parameters for the method 'ReadDirectLinks'
type ReadDirectLinksOpts struct {
ReadDirectLinksRequest optional.Interface
}
/*
ReadDirectLinks Method for ReadDirectLinks
* @param ctx _context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
* @param optional nil or *ReadDirectLinksOpts - Optional Parameters:
* @param "ReadDirectLinksRequest" (optional.Interface of ReadDirectLinksRequest) -
@return ReadDirectLinksResponse
*/
func (a *DirectLinkApiService) ReadDirectLinks(ctx _context.Context, localVarOptionals *ReadDirectLinksOpts) (ReadDirectLinksResponse, *_nethttp.Response, error) {
var (
localVarHTTPMethod = _nethttp.MethodPost
localVarPostBody interface{}
localVarFormFileName string
localVarFileName string
localVarFileBytes []byte
localVarReturnValue ReadDirectLinksResponse
)
// create path and map variables
localVarPath := a.client.cfg.BasePath + "/ReadDirectLinks"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := _neturl.Values{}
localVarFormParams := _neturl.Values{}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{"application/json"}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{"application/json"}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
// body params
if localVarOptionals != nil && localVarOptionals.ReadDirectLinksRequest.IsSet() {
localVarOptionalReadDirectLinksRequest, localVarOptionalReadDirectLinksRequestok := localVarOptionals.ReadDirectLinksRequest.Value().(ReadDirectLinksRequest)
if !localVarOptionalReadDirectLinksRequestok {
return localVarReturnValue, nil, reportError("readDirectLinksRequest should be ReadDirectLinksRequest")
}
localVarPostBody = &localVarOptionalReadDirectLinksRequest
}
if ctx != nil {
// API Key Authentication
if auth, ok := ctx.Value(ContextAPIKey).(APIKey); ok {
var key string
if auth.Prefix != "" {
key = auth.Prefix + " " + auth.Key
} else {
key = auth.Key
}
localVarHeaderParams["Authorization"] = key
}
}
r, err := a.client.prepareRequest(ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFormFileName, localVarFileName, localVarFileBytes)
if err != nil {
return localVarReturnValue, nil, err
}
localVarHTTPResponse, err := a.client.callAPI(r)
if err != nil || localVarHTTPResponse == nil {
return localVarReturnValue, localVarHTTPResponse, err
}
localVarBody, err := _ioutil.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
if err != nil {
return localVarReturnValue, localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
if localVarHTTPResponse.StatusCode == 200 {
var v ReadDirectLinksResponse
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr.error = err.Error()
return localVarReturnValue, localVarHTTPResponse, newErr
}
newErr.model = v
}
return localVarReturnValue, localVarHTTPResponse, newErr
}
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr := GenericOpenAPIError{
body: localVarBody,
error: err.Error(),
}
return localVarReturnValue, localVarHTTPResponse, newErr
}
return localVarReturnValue, localVarHTTPResponse, nil
}

360
vendor/github.com/outscale/osc-sdk-go/osc/api_direct_link_interface.go generated vendored Normal file
View File

@ -0,0 +1,360 @@
/*
* 3DS OUTSCALE API
*
* Welcome to the 3DS OUTSCALE's API documentation.<br /><br /> The 3DS OUTSCALE API enables you to manage your resources in the 3DS OUTSCALE Cloud. This documentation describes the different actions available along with code examples.<br /><br /> Note that the 3DS OUTSCALE Cloud is compatible with Amazon Web Services (AWS) APIs, but some resources have different names in AWS than in the 3DS OUTSCALE API. You can find a list of the differences [here](https://wiki.outscale.net/display/EN/3DS+OUTSCALE+APIs+Reference).<br /><br /> You can also manage your resources using the [Cockpit](https://wiki.outscale.net/display/EN/About+Cockpit) web interface.
*
* API version: 1.2
* Contact: support@outscale.com
* Generated by: OpenAPI Generator (https://openapi-generator.tech)
*/
package osc
import (
_context "context"
_ioutil "io/ioutil"
_nethttp "net/http"
_neturl "net/url"
"github.com/antihax/optional"
)
// Linger please
var (
_ _context.Context
)
// DirectLinkInterfaceApiService DirectLinkInterfaceApi service
type DirectLinkInterfaceApiService service
// CreateDirectLinkInterfaceOpts Optional parameters for the method 'CreateDirectLinkInterface'
type CreateDirectLinkInterfaceOpts struct {
CreateDirectLinkInterfaceRequest optional.Interface
}
/*
CreateDirectLinkInterface Method for CreateDirectLinkInterface
* @param ctx _context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
* @param optional nil or *CreateDirectLinkInterfaceOpts - Optional Parameters:
* @param "CreateDirectLinkInterfaceRequest" (optional.Interface of CreateDirectLinkInterfaceRequest) -
@return CreateDirectLinkInterfaceResponse
*/
func (a *DirectLinkInterfaceApiService) CreateDirectLinkInterface(ctx _context.Context, localVarOptionals *CreateDirectLinkInterfaceOpts) (CreateDirectLinkInterfaceResponse, *_nethttp.Response, error) {
var (
localVarHTTPMethod = _nethttp.MethodPost
localVarPostBody interface{}
localVarFormFileName string
localVarFileName string
localVarFileBytes []byte
localVarReturnValue CreateDirectLinkInterfaceResponse
)
// create path and map variables
localVarPath := a.client.cfg.BasePath + "/CreateDirectLinkInterface"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := _neturl.Values{}
localVarFormParams := _neturl.Values{}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{"application/json"}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{"application/json"}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
// body params
if localVarOptionals != nil && localVarOptionals.CreateDirectLinkInterfaceRequest.IsSet() {
localVarOptionalCreateDirectLinkInterfaceRequest, localVarOptionalCreateDirectLinkInterfaceRequestok := localVarOptionals.CreateDirectLinkInterfaceRequest.Value().(CreateDirectLinkInterfaceRequest)
if !localVarOptionalCreateDirectLinkInterfaceRequestok {
return localVarReturnValue, nil, reportError("createDirectLinkInterfaceRequest should be CreateDirectLinkInterfaceRequest")
}
localVarPostBody = &localVarOptionalCreateDirectLinkInterfaceRequest
}
if ctx != nil {
// API Key Authentication
if auth, ok := ctx.Value(ContextAPIKey).(APIKey); ok {
var key string
if auth.Prefix != "" {
key = auth.Prefix + " " + auth.Key
} else {
key = auth.Key
}
localVarHeaderParams["Authorization"] = key
}
}
r, err := a.client.prepareRequest(ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFormFileName, localVarFileName, localVarFileBytes)
if err != nil {
return localVarReturnValue, nil, err
}
localVarHTTPResponse, err := a.client.callAPI(r)
if err != nil || localVarHTTPResponse == nil {
return localVarReturnValue, localVarHTTPResponse, err
}
localVarBody, err := _ioutil.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
if err != nil {
return localVarReturnValue, localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
if localVarHTTPResponse.StatusCode == 200 {
var v CreateDirectLinkInterfaceResponse
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr.error = err.Error()
return localVarReturnValue, localVarHTTPResponse, newErr
}
newErr.model = v
}
return localVarReturnValue, localVarHTTPResponse, newErr
}
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr := GenericOpenAPIError{
body: localVarBody,
error: err.Error(),
}
return localVarReturnValue, localVarHTTPResponse, newErr
}
return localVarReturnValue, localVarHTTPResponse, nil
}
// DeleteDirectLinkInterfaceOpts Optional parameters for the method 'DeleteDirectLinkInterface'
type DeleteDirectLinkInterfaceOpts struct {
DeleteDirectLinkInterfaceRequest optional.Interface
}
/*
DeleteDirectLinkInterface Method for DeleteDirectLinkInterface
* @param ctx _context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
* @param optional nil or *DeleteDirectLinkInterfaceOpts - Optional Parameters:
* @param "DeleteDirectLinkInterfaceRequest" (optional.Interface of DeleteDirectLinkInterfaceRequest) -
@return DeleteDirectLinkInterfaceResponse
*/
func (a *DirectLinkInterfaceApiService) DeleteDirectLinkInterface(ctx _context.Context, localVarOptionals *DeleteDirectLinkInterfaceOpts) (DeleteDirectLinkInterfaceResponse, *_nethttp.Response, error) {
var (
localVarHTTPMethod = _nethttp.MethodPost
localVarPostBody interface{}
localVarFormFileName string
localVarFileName string
localVarFileBytes []byte
localVarReturnValue DeleteDirectLinkInterfaceResponse
)
// create path and map variables
localVarPath := a.client.cfg.BasePath + "/DeleteDirectLinkInterface"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := _neturl.Values{}
localVarFormParams := _neturl.Values{}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{"application/json"}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{"application/json"}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
// body params
if localVarOptionals != nil && localVarOptionals.DeleteDirectLinkInterfaceRequest.IsSet() {
localVarOptionalDeleteDirectLinkInterfaceRequest, localVarOptionalDeleteDirectLinkInterfaceRequestok := localVarOptionals.DeleteDirectLinkInterfaceRequest.Value().(DeleteDirectLinkInterfaceRequest)
if !localVarOptionalDeleteDirectLinkInterfaceRequestok {
return localVarReturnValue, nil, reportError("deleteDirectLinkInterfaceRequest should be DeleteDirectLinkInterfaceRequest")
}
localVarPostBody = &localVarOptionalDeleteDirectLinkInterfaceRequest
}
if ctx != nil {
// API Key Authentication
if auth, ok := ctx.Value(ContextAPIKey).(APIKey); ok {
var key string
if auth.Prefix != "" {
key = auth.Prefix + " " + auth.Key
} else {
key = auth.Key
}
localVarHeaderParams["Authorization"] = key
}
}
r, err := a.client.prepareRequest(ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFormFileName, localVarFileName, localVarFileBytes)
if err != nil {
return localVarReturnValue, nil, err
}
localVarHTTPResponse, err := a.client.callAPI(r)
if err != nil || localVarHTTPResponse == nil {
return localVarReturnValue, localVarHTTPResponse, err
}
localVarBody, err := _ioutil.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
if err != nil {
return localVarReturnValue, localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
if localVarHTTPResponse.StatusCode == 200 {
var v DeleteDirectLinkInterfaceResponse
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr.error = err.Error()
return localVarReturnValue, localVarHTTPResponse, newErr
}
newErr.model = v
}
return localVarReturnValue, localVarHTTPResponse, newErr
}
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr := GenericOpenAPIError{
body: localVarBody,
error: err.Error(),
}
return localVarReturnValue, localVarHTTPResponse, newErr
}
return localVarReturnValue, localVarHTTPResponse, nil
}
// ReadDirectLinkInterfacesOpts Optional parameters for the method 'ReadDirectLinkInterfaces'
type ReadDirectLinkInterfacesOpts struct {
ReadDirectLinkInterfacesRequest optional.Interface
}
/*
ReadDirectLinkInterfaces Method for ReadDirectLinkInterfaces
* @param ctx _context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
* @param optional nil or *ReadDirectLinkInterfacesOpts - Optional Parameters:
* @param "ReadDirectLinkInterfacesRequest" (optional.Interface of ReadDirectLinkInterfacesRequest) -
@return ReadDirectLinkInterfacesResponse
*/
func (a *DirectLinkInterfaceApiService) ReadDirectLinkInterfaces(ctx _context.Context, localVarOptionals *ReadDirectLinkInterfacesOpts) (ReadDirectLinkInterfacesResponse, *_nethttp.Response, error) {
var (
localVarHTTPMethod = _nethttp.MethodPost
localVarPostBody interface{}
localVarFormFileName string
localVarFileName string
localVarFileBytes []byte
localVarReturnValue ReadDirectLinkInterfacesResponse
)
// create path and map variables
localVarPath := a.client.cfg.BasePath + "/ReadDirectLinkInterfaces"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := _neturl.Values{}
localVarFormParams := _neturl.Values{}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{"application/json"}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{"application/json"}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
// body params
if localVarOptionals != nil && localVarOptionals.ReadDirectLinkInterfacesRequest.IsSet() {
localVarOptionalReadDirectLinkInterfacesRequest, localVarOptionalReadDirectLinkInterfacesRequestok := localVarOptionals.ReadDirectLinkInterfacesRequest.Value().(ReadDirectLinkInterfacesRequest)
if !localVarOptionalReadDirectLinkInterfacesRequestok {
return localVarReturnValue, nil, reportError("readDirectLinkInterfacesRequest should be ReadDirectLinkInterfacesRequest")
}
localVarPostBody = &localVarOptionalReadDirectLinkInterfacesRequest
}
if ctx != nil {
// API Key Authentication
if auth, ok := ctx.Value(ContextAPIKey).(APIKey); ok {
var key string
if auth.Prefix != "" {
key = auth.Prefix + " " + auth.Key
} else {
key = auth.Key
}
localVarHeaderParams["Authorization"] = key
}
}
r, err := a.client.prepareRequest(ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFormFileName, localVarFileName, localVarFileBytes)
if err != nil {
return localVarReturnValue, nil, err
}
localVarHTTPResponse, err := a.client.callAPI(r)
if err != nil || localVarHTTPResponse == nil {
return localVarReturnValue, localVarHTTPResponse, err
}
localVarBody, err := _ioutil.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
if err != nil {
return localVarReturnValue, localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
if localVarHTTPResponse.StatusCode == 200 {
var v ReadDirectLinkInterfacesResponse
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr.error = err.Error()
return localVarReturnValue, localVarHTTPResponse, newErr
}
newErr.model = v
}
return localVarReturnValue, localVarHTTPResponse, newErr
}
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr := GenericOpenAPIError{
body: localVarBody,
error: err.Error(),
}
return localVarReturnValue, localVarHTTPResponse, newErr
}
return localVarReturnValue, localVarHTTPResponse, nil
}

792
vendor/github.com/outscale/osc-sdk-go/osc/api_flexible_gpu.go generated vendored Normal file
View File

@ -0,0 +1,792 @@
/*
* 3DS OUTSCALE API
*
* Welcome to the 3DS OUTSCALE's API documentation.<br /><br /> The 3DS OUTSCALE API enables you to manage your resources in the 3DS OUTSCALE Cloud. This documentation describes the different actions available along with code examples.<br /><br /> Note that the 3DS OUTSCALE Cloud is compatible with Amazon Web Services (AWS) APIs, but some resources have different names in AWS than in the 3DS OUTSCALE API. You can find a list of the differences [here](https://wiki.outscale.net/display/EN/3DS+OUTSCALE+APIs+Reference).<br /><br /> You can also manage your resources using the [Cockpit](https://wiki.outscale.net/display/EN/About+Cockpit) web interface.
*
* API version: 1.2
* Contact: support@outscale.com
* Generated by: OpenAPI Generator (https://openapi-generator.tech)
*/
package osc
import (
_context "context"
_ioutil "io/ioutil"
_nethttp "net/http"
_neturl "net/url"
"github.com/antihax/optional"
)
// Linger please
var (
_ _context.Context
)
// FlexibleGpuApiService FlexibleGpuApi service
type FlexibleGpuApiService service
// CreateFlexibleGpuOpts Optional parameters for the method 'CreateFlexibleGpu'
type CreateFlexibleGpuOpts struct {
CreateFlexibleGpuRequest optional.Interface
}
/*
CreateFlexibleGpu Method for CreateFlexibleGpu
* @param ctx _context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
* @param optional nil or *CreateFlexibleGpuOpts - Optional Parameters:
* @param "CreateFlexibleGpuRequest" (optional.Interface of CreateFlexibleGpuRequest) -
@return CreateFlexibleGpuResponse
*/
func (a *FlexibleGpuApiService) CreateFlexibleGpu(ctx _context.Context, localVarOptionals *CreateFlexibleGpuOpts) (CreateFlexibleGpuResponse, *_nethttp.Response, error) {
var (
localVarHTTPMethod = _nethttp.MethodPost
localVarPostBody interface{}
localVarFormFileName string
localVarFileName string
localVarFileBytes []byte
localVarReturnValue CreateFlexibleGpuResponse
)
// create path and map variables
localVarPath := a.client.cfg.BasePath + "/CreateFlexibleGpu"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := _neturl.Values{}
localVarFormParams := _neturl.Values{}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{"application/json"}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{"application/json"}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
// body params
if localVarOptionals != nil && localVarOptionals.CreateFlexibleGpuRequest.IsSet() {
localVarOptionalCreateFlexibleGpuRequest, localVarOptionalCreateFlexibleGpuRequestok := localVarOptionals.CreateFlexibleGpuRequest.Value().(CreateFlexibleGpuRequest)
if !localVarOptionalCreateFlexibleGpuRequestok {
return localVarReturnValue, nil, reportError("createFlexibleGpuRequest should be CreateFlexibleGpuRequest")
}
localVarPostBody = &localVarOptionalCreateFlexibleGpuRequest
}
if ctx != nil {
// API Key Authentication
if auth, ok := ctx.Value(ContextAPIKey).(APIKey); ok {
var key string
if auth.Prefix != "" {
key = auth.Prefix + " " + auth.Key
} else {
key = auth.Key
}
localVarHeaderParams["Authorization"] = key
}
}
r, err := a.client.prepareRequest(ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFormFileName, localVarFileName, localVarFileBytes)
if err != nil {
return localVarReturnValue, nil, err
}
localVarHTTPResponse, err := a.client.callAPI(r)
if err != nil || localVarHTTPResponse == nil {
return localVarReturnValue, localVarHTTPResponse, err
}
localVarBody, err := _ioutil.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
if err != nil {
return localVarReturnValue, localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
if localVarHTTPResponse.StatusCode == 200 {
var v CreateFlexibleGpuResponse
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr.error = err.Error()
return localVarReturnValue, localVarHTTPResponse, newErr
}
newErr.model = v
}
return localVarReturnValue, localVarHTTPResponse, newErr
}
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr := GenericOpenAPIError{
body: localVarBody,
error: err.Error(),
}
return localVarReturnValue, localVarHTTPResponse, newErr
}
return localVarReturnValue, localVarHTTPResponse, nil
}
// DeleteFlexibleGpuOpts Optional parameters for the method 'DeleteFlexibleGpu'
type DeleteFlexibleGpuOpts struct {
DeleteFlexibleGpuRequest optional.Interface
}
/*
DeleteFlexibleGpu Method for DeleteFlexibleGpu
* @param ctx _context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
* @param optional nil or *DeleteFlexibleGpuOpts - Optional Parameters:
* @param "DeleteFlexibleGpuRequest" (optional.Interface of DeleteFlexibleGpuRequest) -
@return DeleteFlexibleGpuResponse
*/
func (a *FlexibleGpuApiService) DeleteFlexibleGpu(ctx _context.Context, localVarOptionals *DeleteFlexibleGpuOpts) (DeleteFlexibleGpuResponse, *_nethttp.Response, error) {
var (
localVarHTTPMethod = _nethttp.MethodPost
localVarPostBody interface{}
localVarFormFileName string
localVarFileName string
localVarFileBytes []byte
localVarReturnValue DeleteFlexibleGpuResponse
)
// create path and map variables
localVarPath := a.client.cfg.BasePath + "/DeleteFlexibleGpu"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := _neturl.Values{}
localVarFormParams := _neturl.Values{}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{"application/json"}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{"application/json"}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
// body params
if localVarOptionals != nil && localVarOptionals.DeleteFlexibleGpuRequest.IsSet() {
localVarOptionalDeleteFlexibleGpuRequest, localVarOptionalDeleteFlexibleGpuRequestok := localVarOptionals.DeleteFlexibleGpuRequest.Value().(DeleteFlexibleGpuRequest)
if !localVarOptionalDeleteFlexibleGpuRequestok {
return localVarReturnValue, nil, reportError("deleteFlexibleGpuRequest should be DeleteFlexibleGpuRequest")
}
localVarPostBody = &localVarOptionalDeleteFlexibleGpuRequest
}
if ctx != nil {
// API Key Authentication
if auth, ok := ctx.Value(ContextAPIKey).(APIKey); ok {
var key string
if auth.Prefix != "" {
key = auth.Prefix + " " + auth.Key
} else {
key = auth.Key
}
localVarHeaderParams["Authorization"] = key
}
}
r, err := a.client.prepareRequest(ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFormFileName, localVarFileName, localVarFileBytes)
if err != nil {
return localVarReturnValue, nil, err
}
localVarHTTPResponse, err := a.client.callAPI(r)
if err != nil || localVarHTTPResponse == nil {
return localVarReturnValue, localVarHTTPResponse, err
}
localVarBody, err := _ioutil.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
if err != nil {
return localVarReturnValue, localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
if localVarHTTPResponse.StatusCode == 200 {
var v DeleteFlexibleGpuResponse
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr.error = err.Error()
return localVarReturnValue, localVarHTTPResponse, newErr
}
newErr.model = v
}
return localVarReturnValue, localVarHTTPResponse, newErr
}
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr := GenericOpenAPIError{
body: localVarBody,
error: err.Error(),
}
return localVarReturnValue, localVarHTTPResponse, newErr
}
return localVarReturnValue, localVarHTTPResponse, nil
}
// LinkFlexibleGpuOpts Optional parameters for the method 'LinkFlexibleGpu'
type LinkFlexibleGpuOpts struct {
LinkFlexibleGpuRequest optional.Interface
}
/*
LinkFlexibleGpu Method for LinkFlexibleGpu
* @param ctx _context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
* @param optional nil or *LinkFlexibleGpuOpts - Optional Parameters:
* @param "LinkFlexibleGpuRequest" (optional.Interface of LinkFlexibleGpuRequest) -
@return LinkFlexibleGpuResponse
*/
func (a *FlexibleGpuApiService) LinkFlexibleGpu(ctx _context.Context, localVarOptionals *LinkFlexibleGpuOpts) (LinkFlexibleGpuResponse, *_nethttp.Response, error) {
var (
localVarHTTPMethod = _nethttp.MethodPost
localVarPostBody interface{}
localVarFormFileName string
localVarFileName string
localVarFileBytes []byte
localVarReturnValue LinkFlexibleGpuResponse
)
// create path and map variables
localVarPath := a.client.cfg.BasePath + "/LinkFlexibleGpu"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := _neturl.Values{}
localVarFormParams := _neturl.Values{}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{"application/json"}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{"application/json"}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
// body params
if localVarOptionals != nil && localVarOptionals.LinkFlexibleGpuRequest.IsSet() {
localVarOptionalLinkFlexibleGpuRequest, localVarOptionalLinkFlexibleGpuRequestok := localVarOptionals.LinkFlexibleGpuRequest.Value().(LinkFlexibleGpuRequest)
if !localVarOptionalLinkFlexibleGpuRequestok {
return localVarReturnValue, nil, reportError("linkFlexibleGpuRequest should be LinkFlexibleGpuRequest")
}
localVarPostBody = &localVarOptionalLinkFlexibleGpuRequest
}
if ctx != nil {
// API Key Authentication
if auth, ok := ctx.Value(ContextAPIKey).(APIKey); ok {
var key string
if auth.Prefix != "" {
key = auth.Prefix + " " + auth.Key
} else {
key = auth.Key
}
localVarHeaderParams["Authorization"] = key
}
}
r, err := a.client.prepareRequest(ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFormFileName, localVarFileName, localVarFileBytes)
if err != nil {
return localVarReturnValue, nil, err
}
localVarHTTPResponse, err := a.client.callAPI(r)
if err != nil || localVarHTTPResponse == nil {
return localVarReturnValue, localVarHTTPResponse, err
}
localVarBody, err := _ioutil.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
if err != nil {
return localVarReturnValue, localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
if localVarHTTPResponse.StatusCode == 200 {
var v LinkFlexibleGpuResponse
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr.error = err.Error()
return localVarReturnValue, localVarHTTPResponse, newErr
}
newErr.model = v
}
return localVarReturnValue, localVarHTTPResponse, newErr
}
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr := GenericOpenAPIError{
body: localVarBody,
error: err.Error(),
}
return localVarReturnValue, localVarHTTPResponse, newErr
}
return localVarReturnValue, localVarHTTPResponse, nil
}
// ReadFlexibleGpuCatalogOpts Optional parameters for the method 'ReadFlexibleGpuCatalog'
type ReadFlexibleGpuCatalogOpts struct {
ReadFlexibleGpuCatalogRequest optional.Interface
}
/*
ReadFlexibleGpuCatalog Method for ReadFlexibleGpuCatalog
* @param ctx _context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
* @param optional nil or *ReadFlexibleGpuCatalogOpts - Optional Parameters:
* @param "ReadFlexibleGpuCatalogRequest" (optional.Interface of ReadFlexibleGpuCatalogRequest) -
@return ReadFlexibleGpuCatalogResponse
*/
func (a *FlexibleGpuApiService) ReadFlexibleGpuCatalog(ctx _context.Context, localVarOptionals *ReadFlexibleGpuCatalogOpts) (ReadFlexibleGpuCatalogResponse, *_nethttp.Response, error) {
var (
localVarHTTPMethod = _nethttp.MethodPost
localVarPostBody interface{}
localVarFormFileName string
localVarFileName string
localVarFileBytes []byte
localVarReturnValue ReadFlexibleGpuCatalogResponse
)
// create path and map variables
localVarPath := a.client.cfg.BasePath + "/ReadFlexibleGpuCatalog"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := _neturl.Values{}
localVarFormParams := _neturl.Values{}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{"application/json"}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{"application/json"}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
// body params
if localVarOptionals != nil && localVarOptionals.ReadFlexibleGpuCatalogRequest.IsSet() {
localVarOptionalReadFlexibleGpuCatalogRequest, localVarOptionalReadFlexibleGpuCatalogRequestok := localVarOptionals.ReadFlexibleGpuCatalogRequest.Value().(ReadFlexibleGpuCatalogRequest)
if !localVarOptionalReadFlexibleGpuCatalogRequestok {
return localVarReturnValue, nil, reportError("readFlexibleGpuCatalogRequest should be ReadFlexibleGpuCatalogRequest")
}
localVarPostBody = &localVarOptionalReadFlexibleGpuCatalogRequest
}
r, err := a.client.prepareRequest(ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFormFileName, localVarFileName, localVarFileBytes)
if err != nil {
return localVarReturnValue, nil, err
}
localVarHTTPResponse, err := a.client.callAPI(r)
if err != nil || localVarHTTPResponse == nil {
return localVarReturnValue, localVarHTTPResponse, err
}
localVarBody, err := _ioutil.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
if err != nil {
return localVarReturnValue, localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
if localVarHTTPResponse.StatusCode == 200 {
var v ReadFlexibleGpuCatalogResponse
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr.error = err.Error()
return localVarReturnValue, localVarHTTPResponse, newErr
}
newErr.model = v
}
return localVarReturnValue, localVarHTTPResponse, newErr
}
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr := GenericOpenAPIError{
body: localVarBody,
error: err.Error(),
}
return localVarReturnValue, localVarHTTPResponse, newErr
}
return localVarReturnValue, localVarHTTPResponse, nil
}
// ReadFlexibleGpusOpts Optional parameters for the method 'ReadFlexibleGpus'
type ReadFlexibleGpusOpts struct {
ReadFlexibleGpusRequest optional.Interface
}
/*
ReadFlexibleGpus Method for ReadFlexibleGpus
* @param ctx _context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
* @param optional nil or *ReadFlexibleGpusOpts - Optional Parameters:
* @param "ReadFlexibleGpusRequest" (optional.Interface of ReadFlexibleGpusRequest) -
@return ReadFlexibleGpusResponse
*/
func (a *FlexibleGpuApiService) ReadFlexibleGpus(ctx _context.Context, localVarOptionals *ReadFlexibleGpusOpts) (ReadFlexibleGpusResponse, *_nethttp.Response, error) {
var (
localVarHTTPMethod = _nethttp.MethodPost
localVarPostBody interface{}
localVarFormFileName string
localVarFileName string
localVarFileBytes []byte
localVarReturnValue ReadFlexibleGpusResponse
)
// create path and map variables
localVarPath := a.client.cfg.BasePath + "/ReadFlexibleGpus"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := _neturl.Values{}
localVarFormParams := _neturl.Values{}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{"application/json"}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{"application/json"}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
// body params
if localVarOptionals != nil && localVarOptionals.ReadFlexibleGpusRequest.IsSet() {
localVarOptionalReadFlexibleGpusRequest, localVarOptionalReadFlexibleGpusRequestok := localVarOptionals.ReadFlexibleGpusRequest.Value().(ReadFlexibleGpusRequest)
if !localVarOptionalReadFlexibleGpusRequestok {
return localVarReturnValue, nil, reportError("readFlexibleGpusRequest should be ReadFlexibleGpusRequest")
}
localVarPostBody = &localVarOptionalReadFlexibleGpusRequest
}
if ctx != nil {
// API Key Authentication
if auth, ok := ctx.Value(ContextAPIKey).(APIKey); ok {
var key string
if auth.Prefix != "" {
key = auth.Prefix + " " + auth.Key
} else {
key = auth.Key
}
localVarHeaderParams["Authorization"] = key
}
}
r, err := a.client.prepareRequest(ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFormFileName, localVarFileName, localVarFileBytes)
if err != nil {
return localVarReturnValue, nil, err
}
localVarHTTPResponse, err := a.client.callAPI(r)
if err != nil || localVarHTTPResponse == nil {
return localVarReturnValue, localVarHTTPResponse, err
}
localVarBody, err := _ioutil.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
if err != nil {
return localVarReturnValue, localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
if localVarHTTPResponse.StatusCode == 200 {
var v ReadFlexibleGpusResponse
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr.error = err.Error()
return localVarReturnValue, localVarHTTPResponse, newErr
}
newErr.model = v
}
return localVarReturnValue, localVarHTTPResponse, newErr
}
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr := GenericOpenAPIError{
body: localVarBody,
error: err.Error(),
}
return localVarReturnValue, localVarHTTPResponse, newErr
}
return localVarReturnValue, localVarHTTPResponse, nil
}
// UnlinkFlexibleGpuOpts Optional parameters for the method 'UnlinkFlexibleGpu'
type UnlinkFlexibleGpuOpts struct {
UnlinkFlexibleGpuRequest optional.Interface
}
/*
UnlinkFlexibleGpu Method for UnlinkFlexibleGpu
* @param ctx _context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
* @param optional nil or *UnlinkFlexibleGpuOpts - Optional Parameters:
* @param "UnlinkFlexibleGpuRequest" (optional.Interface of UnlinkFlexibleGpuRequest) -
@return UnlinkFlexibleGpuResponse
*/
func (a *FlexibleGpuApiService) UnlinkFlexibleGpu(ctx _context.Context, localVarOptionals *UnlinkFlexibleGpuOpts) (UnlinkFlexibleGpuResponse, *_nethttp.Response, error) {
var (
localVarHTTPMethod = _nethttp.MethodPost
localVarPostBody interface{}
localVarFormFileName string
localVarFileName string
localVarFileBytes []byte
localVarReturnValue UnlinkFlexibleGpuResponse
)
// create path and map variables
localVarPath := a.client.cfg.BasePath + "/UnlinkFlexibleGpu"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := _neturl.Values{}
localVarFormParams := _neturl.Values{}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{"application/json"}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{"application/json"}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
// body params
if localVarOptionals != nil && localVarOptionals.UnlinkFlexibleGpuRequest.IsSet() {
localVarOptionalUnlinkFlexibleGpuRequest, localVarOptionalUnlinkFlexibleGpuRequestok := localVarOptionals.UnlinkFlexibleGpuRequest.Value().(UnlinkFlexibleGpuRequest)
if !localVarOptionalUnlinkFlexibleGpuRequestok {
return localVarReturnValue, nil, reportError("unlinkFlexibleGpuRequest should be UnlinkFlexibleGpuRequest")
}
localVarPostBody = &localVarOptionalUnlinkFlexibleGpuRequest
}
if ctx != nil {
// API Key Authentication
if auth, ok := ctx.Value(ContextAPIKey).(APIKey); ok {
var key string
if auth.Prefix != "" {
key = auth.Prefix + " " + auth.Key
} else {
key = auth.Key
}
localVarHeaderParams["Authorization"] = key
}
}
r, err := a.client.prepareRequest(ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFormFileName, localVarFileName, localVarFileBytes)
if err != nil {
return localVarReturnValue, nil, err
}
localVarHTTPResponse, err := a.client.callAPI(r)
if err != nil || localVarHTTPResponse == nil {
return localVarReturnValue, localVarHTTPResponse, err
}
localVarBody, err := _ioutil.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
if err != nil {
return localVarReturnValue, localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
if localVarHTTPResponse.StatusCode == 200 {
var v UnlinkFlexibleGpuResponse
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr.error = err.Error()
return localVarReturnValue, localVarHTTPResponse, newErr
}
newErr.model = v
}
return localVarReturnValue, localVarHTTPResponse, newErr
}
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr := GenericOpenAPIError{
body: localVarBody,
error: err.Error(),
}
return localVarReturnValue, localVarHTTPResponse, newErr
}
return localVarReturnValue, localVarHTTPResponse, nil
}
// UpdateFlexibleGpuOpts Optional parameters for the method 'UpdateFlexibleGpu'
type UpdateFlexibleGpuOpts struct {
UpdateFlexibleGpuRequest optional.Interface
}
/*
UpdateFlexibleGpu Method for UpdateFlexibleGpu
* @param ctx _context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
* @param optional nil or *UpdateFlexibleGpuOpts - Optional Parameters:
* @param "UpdateFlexibleGpuRequest" (optional.Interface of UpdateFlexibleGpuRequest) -
@return UpdateFlexibleGpuResponse
*/
func (a *FlexibleGpuApiService) UpdateFlexibleGpu(ctx _context.Context, localVarOptionals *UpdateFlexibleGpuOpts) (UpdateFlexibleGpuResponse, *_nethttp.Response, error) {
var (
localVarHTTPMethod = _nethttp.MethodPost
localVarPostBody interface{}
localVarFormFileName string
localVarFileName string
localVarFileBytes []byte
localVarReturnValue UpdateFlexibleGpuResponse
)
// create path and map variables
localVarPath := a.client.cfg.BasePath + "/UpdateFlexibleGpu"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := _neturl.Values{}
localVarFormParams := _neturl.Values{}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{"application/json"}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{"application/json"}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
// body params
if localVarOptionals != nil && localVarOptionals.UpdateFlexibleGpuRequest.IsSet() {
localVarOptionalUpdateFlexibleGpuRequest, localVarOptionalUpdateFlexibleGpuRequestok := localVarOptionals.UpdateFlexibleGpuRequest.Value().(UpdateFlexibleGpuRequest)
if !localVarOptionalUpdateFlexibleGpuRequestok {
return localVarReturnValue, nil, reportError("updateFlexibleGpuRequest should be UpdateFlexibleGpuRequest")
}
localVarPostBody = &localVarOptionalUpdateFlexibleGpuRequest
}
if ctx != nil {
// API Key Authentication
if auth, ok := ctx.Value(ContextAPIKey).(APIKey); ok {
var key string
if auth.Prefix != "" {
key = auth.Prefix + " " + auth.Key
} else {
key = auth.Key
}
localVarHeaderParams["Authorization"] = key
}
}
r, err := a.client.prepareRequest(ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFormFileName, localVarFileName, localVarFileBytes)
if err != nil {
return localVarReturnValue, nil, err
}
localVarHTTPResponse, err := a.client.callAPI(r)
if err != nil || localVarHTTPResponse == nil {
return localVarReturnValue, localVarHTTPResponse, err
}
localVarBody, err := _ioutil.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
if err != nil {
return localVarReturnValue, localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
if localVarHTTPResponse.StatusCode == 200 {
var v UpdateFlexibleGpuResponse
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr.error = err.Error()
return localVarReturnValue, localVarHTTPResponse, newErr
}
newErr.model = v
}
return localVarReturnValue, localVarHTTPResponse, newErr
}
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr := GenericOpenAPIError{
body: localVarBody,
error: err.Error(),
}
return localVarReturnValue, localVarHTTPResponse, newErr
}
return localVarReturnValue, localVarHTTPResponse, nil
}

813
vendor/github.com/outscale/osc-sdk-go/osc/api_image.go generated vendored Normal file
View File

@ -0,0 +1,813 @@
/*
* 3DS OUTSCALE API
*
* Welcome to the 3DS OUTSCALE's API documentation.<br /><br /> The 3DS OUTSCALE API enables you to manage your resources in the 3DS OUTSCALE Cloud. This documentation describes the different actions available along with code examples.<br /><br /> Note that the 3DS OUTSCALE Cloud is compatible with Amazon Web Services (AWS) APIs, but some resources have different names in AWS than in the 3DS OUTSCALE API. You can find a list of the differences [here](https://wiki.outscale.net/display/EN/3DS+OUTSCALE+APIs+Reference).<br /><br /> You can also manage your resources using the [Cockpit](https://wiki.outscale.net/display/EN/About+Cockpit) web interface.
*
* API version: 1.2
* Contact: support@outscale.com
* Generated by: OpenAPI Generator (https://openapi-generator.tech)
*/
package osc
import (
_context "context"
_ioutil "io/ioutil"
_nethttp "net/http"
_neturl "net/url"
"github.com/antihax/optional"
)
// Linger please
var (
_ _context.Context
)
// ImageApiService ImageApi service
type ImageApiService service
// CreateImageOpts Optional parameters for the method 'CreateImage'
type CreateImageOpts struct {
CreateImageRequest optional.Interface
}
/*
CreateImage Method for CreateImage
* @param ctx _context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
* @param optional nil or *CreateImageOpts - Optional Parameters:
* @param "CreateImageRequest" (optional.Interface of CreateImageRequest) -
@return CreateImageResponse
*/
func (a *ImageApiService) CreateImage(ctx _context.Context, localVarOptionals *CreateImageOpts) (CreateImageResponse, *_nethttp.Response, error) {
var (
localVarHTTPMethod = _nethttp.MethodPost
localVarPostBody interface{}
localVarFormFileName string
localVarFileName string
localVarFileBytes []byte
localVarReturnValue CreateImageResponse
)
// create path and map variables
localVarPath := a.client.cfg.BasePath + "/CreateImage"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := _neturl.Values{}
localVarFormParams := _neturl.Values{}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{"application/json"}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{"application/json"}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
// body params
if localVarOptionals != nil && localVarOptionals.CreateImageRequest.IsSet() {
localVarOptionalCreateImageRequest, localVarOptionalCreateImageRequestok := localVarOptionals.CreateImageRequest.Value().(CreateImageRequest)
if !localVarOptionalCreateImageRequestok {
return localVarReturnValue, nil, reportError("createImageRequest should be CreateImageRequest")
}
localVarPostBody = &localVarOptionalCreateImageRequest
}
if ctx != nil {
// API Key Authentication
if auth, ok := ctx.Value(ContextAPIKey).(APIKey); ok {
var key string
if auth.Prefix != "" {
key = auth.Prefix + " " + auth.Key
} else {
key = auth.Key
}
localVarHeaderParams["Authorization"] = key
}
}
r, err := a.client.prepareRequest(ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFormFileName, localVarFileName, localVarFileBytes)
if err != nil {
return localVarReturnValue, nil, err
}
localVarHTTPResponse, err := a.client.callAPI(r)
if err != nil || localVarHTTPResponse == nil {
return localVarReturnValue, localVarHTTPResponse, err
}
localVarBody, err := _ioutil.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
if err != nil {
return localVarReturnValue, localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
if localVarHTTPResponse.StatusCode == 200 {
var v CreateImageResponse
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr.error = err.Error()
return localVarReturnValue, localVarHTTPResponse, newErr
}
newErr.model = v
return localVarReturnValue, localVarHTTPResponse, newErr
}
if localVarHTTPResponse.StatusCode == 400 {
var v ErrorResponse
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr.error = err.Error()
return localVarReturnValue, localVarHTTPResponse, newErr
}
newErr.model = v
return localVarReturnValue, localVarHTTPResponse, newErr
}
if localVarHTTPResponse.StatusCode == 401 {
var v ErrorResponse
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr.error = err.Error()
return localVarReturnValue, localVarHTTPResponse, newErr
}
newErr.model = v
return localVarReturnValue, localVarHTTPResponse, newErr
}
if localVarHTTPResponse.StatusCode == 500 {
var v ErrorResponse
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr.error = err.Error()
return localVarReturnValue, localVarHTTPResponse, newErr
}
newErr.model = v
}
return localVarReturnValue, localVarHTTPResponse, newErr
}
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr := GenericOpenAPIError{
body: localVarBody,
error: err.Error(),
}
return localVarReturnValue, localVarHTTPResponse, newErr
}
return localVarReturnValue, localVarHTTPResponse, nil
}
// CreateImageExportTaskOpts Optional parameters for the method 'CreateImageExportTask'
type CreateImageExportTaskOpts struct {
CreateImageExportTaskRequest optional.Interface
}
/*
CreateImageExportTask Method for CreateImageExportTask
* @param ctx _context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
* @param optional nil or *CreateImageExportTaskOpts - Optional Parameters:
* @param "CreateImageExportTaskRequest" (optional.Interface of CreateImageExportTaskRequest) -
@return CreateImageExportTaskResponse
*/
func (a *ImageApiService) CreateImageExportTask(ctx _context.Context, localVarOptionals *CreateImageExportTaskOpts) (CreateImageExportTaskResponse, *_nethttp.Response, error) {
var (
localVarHTTPMethod = _nethttp.MethodPost
localVarPostBody interface{}
localVarFormFileName string
localVarFileName string
localVarFileBytes []byte
localVarReturnValue CreateImageExportTaskResponse
)
// create path and map variables
localVarPath := a.client.cfg.BasePath + "/CreateImageExportTask"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := _neturl.Values{}
localVarFormParams := _neturl.Values{}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{"application/json"}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{"application/json"}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
// body params
if localVarOptionals != nil && localVarOptionals.CreateImageExportTaskRequest.IsSet() {
localVarOptionalCreateImageExportTaskRequest, localVarOptionalCreateImageExportTaskRequestok := localVarOptionals.CreateImageExportTaskRequest.Value().(CreateImageExportTaskRequest)
if !localVarOptionalCreateImageExportTaskRequestok {
return localVarReturnValue, nil, reportError("createImageExportTaskRequest should be CreateImageExportTaskRequest")
}
localVarPostBody = &localVarOptionalCreateImageExportTaskRequest
}
if ctx != nil {
// API Key Authentication
if auth, ok := ctx.Value(ContextAPIKey).(APIKey); ok {
var key string
if auth.Prefix != "" {
key = auth.Prefix + " " + auth.Key
} else {
key = auth.Key
}
localVarHeaderParams["Authorization"] = key
}
}
r, err := a.client.prepareRequest(ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFormFileName, localVarFileName, localVarFileBytes)
if err != nil {
return localVarReturnValue, nil, err
}
localVarHTTPResponse, err := a.client.callAPI(r)
if err != nil || localVarHTTPResponse == nil {
return localVarReturnValue, localVarHTTPResponse, err
}
localVarBody, err := _ioutil.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
if err != nil {
return localVarReturnValue, localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
if localVarHTTPResponse.StatusCode == 200 {
var v CreateImageExportTaskResponse
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr.error = err.Error()
return localVarReturnValue, localVarHTTPResponse, newErr
}
newErr.model = v
}
return localVarReturnValue, localVarHTTPResponse, newErr
}
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr := GenericOpenAPIError{
body: localVarBody,
error: err.Error(),
}
return localVarReturnValue, localVarHTTPResponse, newErr
}
return localVarReturnValue, localVarHTTPResponse, nil
}
// DeleteImageOpts Optional parameters for the method 'DeleteImage'
type DeleteImageOpts struct {
DeleteImageRequest optional.Interface
}
/*
DeleteImage Method for DeleteImage
* @param ctx _context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
* @param optional nil or *DeleteImageOpts - Optional Parameters:
* @param "DeleteImageRequest" (optional.Interface of DeleteImageRequest) -
@return DeleteImageResponse
*/
func (a *ImageApiService) DeleteImage(ctx _context.Context, localVarOptionals *DeleteImageOpts) (DeleteImageResponse, *_nethttp.Response, error) {
var (
localVarHTTPMethod = _nethttp.MethodPost
localVarPostBody interface{}
localVarFormFileName string
localVarFileName string
localVarFileBytes []byte
localVarReturnValue DeleteImageResponse
)
// create path and map variables
localVarPath := a.client.cfg.BasePath + "/DeleteImage"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := _neturl.Values{}
localVarFormParams := _neturl.Values{}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{"application/json"}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{"application/json"}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
// body params
if localVarOptionals != nil && localVarOptionals.DeleteImageRequest.IsSet() {
localVarOptionalDeleteImageRequest, localVarOptionalDeleteImageRequestok := localVarOptionals.DeleteImageRequest.Value().(DeleteImageRequest)
if !localVarOptionalDeleteImageRequestok {
return localVarReturnValue, nil, reportError("deleteImageRequest should be DeleteImageRequest")
}
localVarPostBody = &localVarOptionalDeleteImageRequest
}
if ctx != nil {
// API Key Authentication
if auth, ok := ctx.Value(ContextAPIKey).(APIKey); ok {
var key string
if auth.Prefix != "" {
key = auth.Prefix + " " + auth.Key
} else {
key = auth.Key
}
localVarHeaderParams["Authorization"] = key
}
}
r, err := a.client.prepareRequest(ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFormFileName, localVarFileName, localVarFileBytes)
if err != nil {
return localVarReturnValue, nil, err
}
localVarHTTPResponse, err := a.client.callAPI(r)
if err != nil || localVarHTTPResponse == nil {
return localVarReturnValue, localVarHTTPResponse, err
}
localVarBody, err := _ioutil.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
if err != nil {
return localVarReturnValue, localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
if localVarHTTPResponse.StatusCode == 200 {
var v DeleteImageResponse
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr.error = err.Error()
return localVarReturnValue, localVarHTTPResponse, newErr
}
newErr.model = v
return localVarReturnValue, localVarHTTPResponse, newErr
}
if localVarHTTPResponse.StatusCode == 400 {
var v ErrorResponse
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr.error = err.Error()
return localVarReturnValue, localVarHTTPResponse, newErr
}
newErr.model = v
return localVarReturnValue, localVarHTTPResponse, newErr
}
if localVarHTTPResponse.StatusCode == 401 {
var v ErrorResponse
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr.error = err.Error()
return localVarReturnValue, localVarHTTPResponse, newErr
}
newErr.model = v
return localVarReturnValue, localVarHTTPResponse, newErr
}
if localVarHTTPResponse.StatusCode == 500 {
var v ErrorResponse
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr.error = err.Error()
return localVarReturnValue, localVarHTTPResponse, newErr
}
newErr.model = v
}
return localVarReturnValue, localVarHTTPResponse, newErr
}
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr := GenericOpenAPIError{
body: localVarBody,
error: err.Error(),
}
return localVarReturnValue, localVarHTTPResponse, newErr
}
return localVarReturnValue, localVarHTTPResponse, nil
}
// ReadImageExportTasksOpts Optional parameters for the method 'ReadImageExportTasks'
type ReadImageExportTasksOpts struct {
ReadImageExportTasksRequest optional.Interface
}
/*
ReadImageExportTasks Method for ReadImageExportTasks
* @param ctx _context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
* @param optional nil or *ReadImageExportTasksOpts - Optional Parameters:
* @param "ReadImageExportTasksRequest" (optional.Interface of ReadImageExportTasksRequest) -
@return ReadImageExportTasksResponse
*/
func (a *ImageApiService) ReadImageExportTasks(ctx _context.Context, localVarOptionals *ReadImageExportTasksOpts) (ReadImageExportTasksResponse, *_nethttp.Response, error) {
var (
localVarHTTPMethod = _nethttp.MethodPost
localVarPostBody interface{}
localVarFormFileName string
localVarFileName string
localVarFileBytes []byte
localVarReturnValue ReadImageExportTasksResponse
)
// create path and map variables
localVarPath := a.client.cfg.BasePath + "/ReadImageExportTasks"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := _neturl.Values{}
localVarFormParams := _neturl.Values{}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{"application/json"}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{"application/json"}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
// body params
if localVarOptionals != nil && localVarOptionals.ReadImageExportTasksRequest.IsSet() {
localVarOptionalReadImageExportTasksRequest, localVarOptionalReadImageExportTasksRequestok := localVarOptionals.ReadImageExportTasksRequest.Value().(ReadImageExportTasksRequest)
if !localVarOptionalReadImageExportTasksRequestok {
return localVarReturnValue, nil, reportError("readImageExportTasksRequest should be ReadImageExportTasksRequest")
}
localVarPostBody = &localVarOptionalReadImageExportTasksRequest
}
if ctx != nil {
// API Key Authentication
if auth, ok := ctx.Value(ContextAPIKey).(APIKey); ok {
var key string
if auth.Prefix != "" {
key = auth.Prefix + " " + auth.Key
} else {
key = auth.Key
}
localVarHeaderParams["Authorization"] = key
}
}
r, err := a.client.prepareRequest(ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFormFileName, localVarFileName, localVarFileBytes)
if err != nil {
return localVarReturnValue, nil, err
}
localVarHTTPResponse, err := a.client.callAPI(r)
if err != nil || localVarHTTPResponse == nil {
return localVarReturnValue, localVarHTTPResponse, err
}
localVarBody, err := _ioutil.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
if err != nil {
return localVarReturnValue, localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
if localVarHTTPResponse.StatusCode == 200 {
var v ReadImageExportTasksResponse
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr.error = err.Error()
return localVarReturnValue, localVarHTTPResponse, newErr
}
newErr.model = v
}
return localVarReturnValue, localVarHTTPResponse, newErr
}
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr := GenericOpenAPIError{
body: localVarBody,
error: err.Error(),
}
return localVarReturnValue, localVarHTTPResponse, newErr
}
return localVarReturnValue, localVarHTTPResponse, nil
}
// ReadImagesOpts Optional parameters for the method 'ReadImages'
type ReadImagesOpts struct {
ReadImagesRequest optional.Interface
}
/*
ReadImages Method for ReadImages
* @param ctx _context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
* @param optional nil or *ReadImagesOpts - Optional Parameters:
* @param "ReadImagesRequest" (optional.Interface of ReadImagesRequest) -
@return ReadImagesResponse
*/
func (a *ImageApiService) ReadImages(ctx _context.Context, localVarOptionals *ReadImagesOpts) (ReadImagesResponse, *_nethttp.Response, error) {
var (
localVarHTTPMethod = _nethttp.MethodPost
localVarPostBody interface{}
localVarFormFileName string
localVarFileName string
localVarFileBytes []byte
localVarReturnValue ReadImagesResponse
)
// create path and map variables
localVarPath := a.client.cfg.BasePath + "/ReadImages"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := _neturl.Values{}
localVarFormParams := _neturl.Values{}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{"application/json"}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{"application/json"}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
// body params
if localVarOptionals != nil && localVarOptionals.ReadImagesRequest.IsSet() {
localVarOptionalReadImagesRequest, localVarOptionalReadImagesRequestok := localVarOptionals.ReadImagesRequest.Value().(ReadImagesRequest)
if !localVarOptionalReadImagesRequestok {
return localVarReturnValue, nil, reportError("readImagesRequest should be ReadImagesRequest")
}
localVarPostBody = &localVarOptionalReadImagesRequest
}
if ctx != nil {
// API Key Authentication
if auth, ok := ctx.Value(ContextAPIKey).(APIKey); ok {
var key string
if auth.Prefix != "" {
key = auth.Prefix + " " + auth.Key
} else {
key = auth.Key
}
localVarHeaderParams["Authorization"] = key
}
}
r, err := a.client.prepareRequest(ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFormFileName, localVarFileName, localVarFileBytes)
if err != nil {
return localVarReturnValue, nil, err
}
localVarHTTPResponse, err := a.client.callAPI(r)
if err != nil || localVarHTTPResponse == nil {
return localVarReturnValue, localVarHTTPResponse, err
}
localVarBody, err := _ioutil.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
if err != nil {
return localVarReturnValue, localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
if localVarHTTPResponse.StatusCode == 200 {
var v ReadImagesResponse
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr.error = err.Error()
return localVarReturnValue, localVarHTTPResponse, newErr
}
newErr.model = v
return localVarReturnValue, localVarHTTPResponse, newErr
}
if localVarHTTPResponse.StatusCode == 400 {
var v ErrorResponse
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr.error = err.Error()
return localVarReturnValue, localVarHTTPResponse, newErr
}
newErr.model = v
return localVarReturnValue, localVarHTTPResponse, newErr
}
if localVarHTTPResponse.StatusCode == 401 {
var v ErrorResponse
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr.error = err.Error()
return localVarReturnValue, localVarHTTPResponse, newErr
}
newErr.model = v
return localVarReturnValue, localVarHTTPResponse, newErr
}
if localVarHTTPResponse.StatusCode == 500 {
var v ErrorResponse
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr.error = err.Error()
return localVarReturnValue, localVarHTTPResponse, newErr
}
newErr.model = v
}
return localVarReturnValue, localVarHTTPResponse, newErr
}
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr := GenericOpenAPIError{
body: localVarBody,
error: err.Error(),
}
return localVarReturnValue, localVarHTTPResponse, newErr
}
return localVarReturnValue, localVarHTTPResponse, nil
}
// UpdateImageOpts Optional parameters for the method 'UpdateImage'
type UpdateImageOpts struct {
UpdateImageRequest optional.Interface
}
/*
UpdateImage Method for UpdateImage
* @param ctx _context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
* @param optional nil or *UpdateImageOpts - Optional Parameters:
* @param "UpdateImageRequest" (optional.Interface of UpdateImageRequest) -
@return UpdateImageResponse
*/
func (a *ImageApiService) UpdateImage(ctx _context.Context, localVarOptionals *UpdateImageOpts) (UpdateImageResponse, *_nethttp.Response, error) {
var (
localVarHTTPMethod = _nethttp.MethodPost
localVarPostBody interface{}
localVarFormFileName string
localVarFileName string
localVarFileBytes []byte
localVarReturnValue UpdateImageResponse
)
// create path and map variables
localVarPath := a.client.cfg.BasePath + "/UpdateImage"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := _neturl.Values{}
localVarFormParams := _neturl.Values{}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{"application/json"}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{"application/json"}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
// body params
if localVarOptionals != nil && localVarOptionals.UpdateImageRequest.IsSet() {
localVarOptionalUpdateImageRequest, localVarOptionalUpdateImageRequestok := localVarOptionals.UpdateImageRequest.Value().(UpdateImageRequest)
if !localVarOptionalUpdateImageRequestok {
return localVarReturnValue, nil, reportError("updateImageRequest should be UpdateImageRequest")
}
localVarPostBody = &localVarOptionalUpdateImageRequest
}
if ctx != nil {
// API Key Authentication
if auth, ok := ctx.Value(ContextAPIKey).(APIKey); ok {
var key string
if auth.Prefix != "" {
key = auth.Prefix + " " + auth.Key
} else {
key = auth.Key
}
localVarHeaderParams["Authorization"] = key
}
}
r, err := a.client.prepareRequest(ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFormFileName, localVarFileName, localVarFileBytes)
if err != nil {
return localVarReturnValue, nil, err
}
localVarHTTPResponse, err := a.client.callAPI(r)
if err != nil || localVarHTTPResponse == nil {
return localVarReturnValue, localVarHTTPResponse, err
}
localVarBody, err := _ioutil.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
if err != nil {
return localVarReturnValue, localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
if localVarHTTPResponse.StatusCode == 200 {
var v UpdateImageResponse
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr.error = err.Error()
return localVarReturnValue, localVarHTTPResponse, newErr
}
newErr.model = v
return localVarReturnValue, localVarHTTPResponse, newErr
}
if localVarHTTPResponse.StatusCode == 400 {
var v ErrorResponse
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr.error = err.Error()
return localVarReturnValue, localVarHTTPResponse, newErr
}
newErr.model = v
return localVarReturnValue, localVarHTTPResponse, newErr
}
if localVarHTTPResponse.StatusCode == 401 {
var v ErrorResponse
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr.error = err.Error()
return localVarReturnValue, localVarHTTPResponse, newErr
}
newErr.model = v
return localVarReturnValue, localVarHTTPResponse, newErr
}
if localVarHTTPResponse.StatusCode == 500 {
var v ErrorResponse
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr.error = err.Error()
return localVarReturnValue, localVarHTTPResponse, newErr
}
newErr.model = v
}
return localVarReturnValue, localVarHTTPResponse, newErr
}
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr := GenericOpenAPIError{
body: localVarBody,
error: err.Error(),
}
return localVarReturnValue, localVarHTTPResponse, newErr
}
return localVarReturnValue, localVarHTTPResponse, nil
}

732
vendor/github.com/outscale/osc-sdk-go/osc/api_internet_service.go generated vendored Normal file
View File

@ -0,0 +1,732 @@
/*
* 3DS OUTSCALE API
*
* Welcome to the 3DS OUTSCALE's API documentation.<br /><br /> The 3DS OUTSCALE API enables you to manage your resources in the 3DS OUTSCALE Cloud. This documentation describes the different actions available along with code examples.<br /><br /> Note that the 3DS OUTSCALE Cloud is compatible with Amazon Web Services (AWS) APIs, but some resources have different names in AWS than in the 3DS OUTSCALE API. You can find a list of the differences [here](https://wiki.outscale.net/display/EN/3DS+OUTSCALE+APIs+Reference).<br /><br /> You can also manage your resources using the [Cockpit](https://wiki.outscale.net/display/EN/About+Cockpit) web interface.
*
* API version: 1.2
* Contact: support@outscale.com
* Generated by: OpenAPI Generator (https://openapi-generator.tech)
*/
package osc
import (
_context "context"
_ioutil "io/ioutil"
_nethttp "net/http"
_neturl "net/url"
"github.com/antihax/optional"
)
// Linger please
var (
_ _context.Context
)
// InternetServiceApiService InternetServiceApi service
type InternetServiceApiService service
// CreateInternetServiceOpts Optional parameters for the method 'CreateInternetService'
type CreateInternetServiceOpts struct {
CreateInternetServiceRequest optional.Interface
}
/*
CreateInternetService Method for CreateInternetService
* @param ctx _context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
* @param optional nil or *CreateInternetServiceOpts - Optional Parameters:
* @param "CreateInternetServiceRequest" (optional.Interface of CreateInternetServiceRequest) -
@return CreateInternetServiceResponse
*/
func (a *InternetServiceApiService) CreateInternetService(ctx _context.Context, localVarOptionals *CreateInternetServiceOpts) (CreateInternetServiceResponse, *_nethttp.Response, error) {
var (
localVarHTTPMethod = _nethttp.MethodPost
localVarPostBody interface{}
localVarFormFileName string
localVarFileName string
localVarFileBytes []byte
localVarReturnValue CreateInternetServiceResponse
)
// create path and map variables
localVarPath := a.client.cfg.BasePath + "/CreateInternetService"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := _neturl.Values{}
localVarFormParams := _neturl.Values{}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{"application/json"}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{"application/json"}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
// body params
if localVarOptionals != nil && localVarOptionals.CreateInternetServiceRequest.IsSet() {
localVarOptionalCreateInternetServiceRequest, localVarOptionalCreateInternetServiceRequestok := localVarOptionals.CreateInternetServiceRequest.Value().(CreateInternetServiceRequest)
if !localVarOptionalCreateInternetServiceRequestok {
return localVarReturnValue, nil, reportError("createInternetServiceRequest should be CreateInternetServiceRequest")
}
localVarPostBody = &localVarOptionalCreateInternetServiceRequest
}
if ctx != nil {
// API Key Authentication
if auth, ok := ctx.Value(ContextAPIKey).(APIKey); ok {
var key string
if auth.Prefix != "" {
key = auth.Prefix + " " + auth.Key
} else {
key = auth.Key
}
localVarHeaderParams["Authorization"] = key
}
}
r, err := a.client.prepareRequest(ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFormFileName, localVarFileName, localVarFileBytes)
if err != nil {
return localVarReturnValue, nil, err
}
localVarHTTPResponse, err := a.client.callAPI(r)
if err != nil || localVarHTTPResponse == nil {
return localVarReturnValue, localVarHTTPResponse, err
}
localVarBody, err := _ioutil.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
if err != nil {
return localVarReturnValue, localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
if localVarHTTPResponse.StatusCode == 200 {
var v CreateInternetServiceResponse
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr.error = err.Error()
return localVarReturnValue, localVarHTTPResponse, newErr
}
newErr.model = v
return localVarReturnValue, localVarHTTPResponse, newErr
}
if localVarHTTPResponse.StatusCode == 400 {
var v ErrorResponse
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr.error = err.Error()
return localVarReturnValue, localVarHTTPResponse, newErr
}
newErr.model = v
return localVarReturnValue, localVarHTTPResponse, newErr
}
if localVarHTTPResponse.StatusCode == 401 {
var v ErrorResponse
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr.error = err.Error()
return localVarReturnValue, localVarHTTPResponse, newErr
}
newErr.model = v
return localVarReturnValue, localVarHTTPResponse, newErr
}
if localVarHTTPResponse.StatusCode == 500 {
var v ErrorResponse
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr.error = err.Error()
return localVarReturnValue, localVarHTTPResponse, newErr
}
newErr.model = v
}
return localVarReturnValue, localVarHTTPResponse, newErr
}
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr := GenericOpenAPIError{
body: localVarBody,
error: err.Error(),
}
return localVarReturnValue, localVarHTTPResponse, newErr
}
return localVarReturnValue, localVarHTTPResponse, nil
}
// DeleteInternetServiceOpts Optional parameters for the method 'DeleteInternetService'
type DeleteInternetServiceOpts struct {
DeleteInternetServiceRequest optional.Interface
}
/*
DeleteInternetService Method for DeleteInternetService
* @param ctx _context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
* @param optional nil or *DeleteInternetServiceOpts - Optional Parameters:
* @param "DeleteInternetServiceRequest" (optional.Interface of DeleteInternetServiceRequest) -
@return DeleteInternetServiceResponse
*/
func (a *InternetServiceApiService) DeleteInternetService(ctx _context.Context, localVarOptionals *DeleteInternetServiceOpts) (DeleteInternetServiceResponse, *_nethttp.Response, error) {
var (
localVarHTTPMethod = _nethttp.MethodPost
localVarPostBody interface{}
localVarFormFileName string
localVarFileName string
localVarFileBytes []byte
localVarReturnValue DeleteInternetServiceResponse
)
// create path and map variables
localVarPath := a.client.cfg.BasePath + "/DeleteInternetService"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := _neturl.Values{}
localVarFormParams := _neturl.Values{}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{"application/json"}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{"application/json"}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
// body params
if localVarOptionals != nil && localVarOptionals.DeleteInternetServiceRequest.IsSet() {
localVarOptionalDeleteInternetServiceRequest, localVarOptionalDeleteInternetServiceRequestok := localVarOptionals.DeleteInternetServiceRequest.Value().(DeleteInternetServiceRequest)
if !localVarOptionalDeleteInternetServiceRequestok {
return localVarReturnValue, nil, reportError("deleteInternetServiceRequest should be DeleteInternetServiceRequest")
}
localVarPostBody = &localVarOptionalDeleteInternetServiceRequest
}
if ctx != nil {
// API Key Authentication
if auth, ok := ctx.Value(ContextAPIKey).(APIKey); ok {
var key string
if auth.Prefix != "" {
key = auth.Prefix + " " + auth.Key
} else {
key = auth.Key
}
localVarHeaderParams["Authorization"] = key
}
}
r, err := a.client.prepareRequest(ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFormFileName, localVarFileName, localVarFileBytes)
if err != nil {
return localVarReturnValue, nil, err
}
localVarHTTPResponse, err := a.client.callAPI(r)
if err != nil || localVarHTTPResponse == nil {
return localVarReturnValue, localVarHTTPResponse, err
}
localVarBody, err := _ioutil.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
if err != nil {
return localVarReturnValue, localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
if localVarHTTPResponse.StatusCode == 200 {
var v DeleteInternetServiceResponse
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr.error = err.Error()
return localVarReturnValue, localVarHTTPResponse, newErr
}
newErr.model = v
return localVarReturnValue, localVarHTTPResponse, newErr
}
if localVarHTTPResponse.StatusCode == 400 {
var v ErrorResponse
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr.error = err.Error()
return localVarReturnValue, localVarHTTPResponse, newErr
}
newErr.model = v
return localVarReturnValue, localVarHTTPResponse, newErr
}
if localVarHTTPResponse.StatusCode == 401 {
var v ErrorResponse
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr.error = err.Error()
return localVarReturnValue, localVarHTTPResponse, newErr
}
newErr.model = v
return localVarReturnValue, localVarHTTPResponse, newErr
}
if localVarHTTPResponse.StatusCode == 500 {
var v ErrorResponse
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr.error = err.Error()
return localVarReturnValue, localVarHTTPResponse, newErr
}
newErr.model = v
}
return localVarReturnValue, localVarHTTPResponse, newErr
}
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr := GenericOpenAPIError{
body: localVarBody,
error: err.Error(),
}
return localVarReturnValue, localVarHTTPResponse, newErr
}
return localVarReturnValue, localVarHTTPResponse, nil
}
// LinkInternetServiceOpts Optional parameters for the method 'LinkInternetService'
type LinkInternetServiceOpts struct {
LinkInternetServiceRequest optional.Interface
}
/*
LinkInternetService Method for LinkInternetService
* @param ctx _context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
* @param optional nil or *LinkInternetServiceOpts - Optional Parameters:
* @param "LinkInternetServiceRequest" (optional.Interface of LinkInternetServiceRequest) -
@return LinkInternetServiceResponse
*/
func (a *InternetServiceApiService) LinkInternetService(ctx _context.Context, localVarOptionals *LinkInternetServiceOpts) (LinkInternetServiceResponse, *_nethttp.Response, error) {
var (
localVarHTTPMethod = _nethttp.MethodPost
localVarPostBody interface{}
localVarFormFileName string
localVarFileName string
localVarFileBytes []byte
localVarReturnValue LinkInternetServiceResponse
)
// create path and map variables
localVarPath := a.client.cfg.BasePath + "/LinkInternetService"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := _neturl.Values{}
localVarFormParams := _neturl.Values{}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{"application/json"}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{"application/json"}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
// body params
if localVarOptionals != nil && localVarOptionals.LinkInternetServiceRequest.IsSet() {
localVarOptionalLinkInternetServiceRequest, localVarOptionalLinkInternetServiceRequestok := localVarOptionals.LinkInternetServiceRequest.Value().(LinkInternetServiceRequest)
if !localVarOptionalLinkInternetServiceRequestok {
return localVarReturnValue, nil, reportError("linkInternetServiceRequest should be LinkInternetServiceRequest")
}
localVarPostBody = &localVarOptionalLinkInternetServiceRequest
}
if ctx != nil {
// API Key Authentication
if auth, ok := ctx.Value(ContextAPIKey).(APIKey); ok {
var key string
if auth.Prefix != "" {
key = auth.Prefix + " " + auth.Key
} else {
key = auth.Key
}
localVarHeaderParams["Authorization"] = key
}
}
r, err := a.client.prepareRequest(ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFormFileName, localVarFileName, localVarFileBytes)
if err != nil {
return localVarReturnValue, nil, err
}
localVarHTTPResponse, err := a.client.callAPI(r)
if err != nil || localVarHTTPResponse == nil {
return localVarReturnValue, localVarHTTPResponse, err
}
localVarBody, err := _ioutil.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
if err != nil {
return localVarReturnValue, localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
if localVarHTTPResponse.StatusCode == 200 {
var v LinkInternetServiceResponse
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr.error = err.Error()
return localVarReturnValue, localVarHTTPResponse, newErr
}
newErr.model = v
return localVarReturnValue, localVarHTTPResponse, newErr
}
if localVarHTTPResponse.StatusCode == 400 {
var v ErrorResponse
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr.error = err.Error()
return localVarReturnValue, localVarHTTPResponse, newErr
}
newErr.model = v
return localVarReturnValue, localVarHTTPResponse, newErr
}
if localVarHTTPResponse.StatusCode == 401 {
var v ErrorResponse
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr.error = err.Error()
return localVarReturnValue, localVarHTTPResponse, newErr
}
newErr.model = v
return localVarReturnValue, localVarHTTPResponse, newErr
}
if localVarHTTPResponse.StatusCode == 500 {
var v ErrorResponse
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr.error = err.Error()
return localVarReturnValue, localVarHTTPResponse, newErr
}
newErr.model = v
}
return localVarReturnValue, localVarHTTPResponse, newErr
}
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr := GenericOpenAPIError{
body: localVarBody,
error: err.Error(),
}
return localVarReturnValue, localVarHTTPResponse, newErr
}
return localVarReturnValue, localVarHTTPResponse, nil
}
// ReadInternetServicesOpts Optional parameters for the method 'ReadInternetServices'
type ReadInternetServicesOpts struct {
ReadInternetServicesRequest optional.Interface
}
/*
ReadInternetServices Method for ReadInternetServices
* @param ctx _context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
* @param optional nil or *ReadInternetServicesOpts - Optional Parameters:
* @param "ReadInternetServicesRequest" (optional.Interface of ReadInternetServicesRequest) -
@return ReadInternetServicesResponse
*/
func (a *InternetServiceApiService) ReadInternetServices(ctx _context.Context, localVarOptionals *ReadInternetServicesOpts) (ReadInternetServicesResponse, *_nethttp.Response, error) {
var (
localVarHTTPMethod = _nethttp.MethodPost
localVarPostBody interface{}
localVarFormFileName string
localVarFileName string
localVarFileBytes []byte
localVarReturnValue ReadInternetServicesResponse
)
// create path and map variables
localVarPath := a.client.cfg.BasePath + "/ReadInternetServices"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := _neturl.Values{}
localVarFormParams := _neturl.Values{}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{"application/json"}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{"application/json"}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
// body params
if localVarOptionals != nil && localVarOptionals.ReadInternetServicesRequest.IsSet() {
localVarOptionalReadInternetServicesRequest, localVarOptionalReadInternetServicesRequestok := localVarOptionals.ReadInternetServicesRequest.Value().(ReadInternetServicesRequest)
if !localVarOptionalReadInternetServicesRequestok {
return localVarReturnValue, nil, reportError("readInternetServicesRequest should be ReadInternetServicesRequest")
}
localVarPostBody = &localVarOptionalReadInternetServicesRequest
}
if ctx != nil {
// API Key Authentication
if auth, ok := ctx.Value(ContextAPIKey).(APIKey); ok {
var key string
if auth.Prefix != "" {
key = auth.Prefix + " " + auth.Key
} else {
key = auth.Key
}
localVarHeaderParams["Authorization"] = key
}
}
r, err := a.client.prepareRequest(ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFormFileName, localVarFileName, localVarFileBytes)
if err != nil {
return localVarReturnValue, nil, err
}
localVarHTTPResponse, err := a.client.callAPI(r)
if err != nil || localVarHTTPResponse == nil {
return localVarReturnValue, localVarHTTPResponse, err
}
localVarBody, err := _ioutil.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
if err != nil {
return localVarReturnValue, localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
if localVarHTTPResponse.StatusCode == 200 {
var v ReadInternetServicesResponse
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr.error = err.Error()
return localVarReturnValue, localVarHTTPResponse, newErr
}
newErr.model = v
return localVarReturnValue, localVarHTTPResponse, newErr
}
if localVarHTTPResponse.StatusCode == 400 {
var v ErrorResponse
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr.error = err.Error()
return localVarReturnValue, localVarHTTPResponse, newErr
}
newErr.model = v
return localVarReturnValue, localVarHTTPResponse, newErr
}
if localVarHTTPResponse.StatusCode == 401 {
var v ErrorResponse
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr.error = err.Error()
return localVarReturnValue, localVarHTTPResponse, newErr
}
newErr.model = v
return localVarReturnValue, localVarHTTPResponse, newErr
}
if localVarHTTPResponse.StatusCode == 500 {
var v ErrorResponse
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr.error = err.Error()
return localVarReturnValue, localVarHTTPResponse, newErr
}
newErr.model = v
}
return localVarReturnValue, localVarHTTPResponse, newErr
}
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr := GenericOpenAPIError{
body: localVarBody,
error: err.Error(),
}
return localVarReturnValue, localVarHTTPResponse, newErr
}
return localVarReturnValue, localVarHTTPResponse, nil
}
// UnlinkInternetServiceOpts Optional parameters for the method 'UnlinkInternetService'
type UnlinkInternetServiceOpts struct {
UnlinkInternetServiceRequest optional.Interface
}
/*
UnlinkInternetService Method for UnlinkInternetService
* @param ctx _context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
* @param optional nil or *UnlinkInternetServiceOpts - Optional Parameters:
* @param "UnlinkInternetServiceRequest" (optional.Interface of UnlinkInternetServiceRequest) -
@return UnlinkInternetServiceResponse
*/
func (a *InternetServiceApiService) UnlinkInternetService(ctx _context.Context, localVarOptionals *UnlinkInternetServiceOpts) (UnlinkInternetServiceResponse, *_nethttp.Response, error) {
var (
localVarHTTPMethod = _nethttp.MethodPost
localVarPostBody interface{}
localVarFormFileName string
localVarFileName string
localVarFileBytes []byte
localVarReturnValue UnlinkInternetServiceResponse
)
// create path and map variables
localVarPath := a.client.cfg.BasePath + "/UnlinkInternetService"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := _neturl.Values{}
localVarFormParams := _neturl.Values{}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{"application/json"}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{"application/json"}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
// body params
if localVarOptionals != nil && localVarOptionals.UnlinkInternetServiceRequest.IsSet() {
localVarOptionalUnlinkInternetServiceRequest, localVarOptionalUnlinkInternetServiceRequestok := localVarOptionals.UnlinkInternetServiceRequest.Value().(UnlinkInternetServiceRequest)
if !localVarOptionalUnlinkInternetServiceRequestok {
return localVarReturnValue, nil, reportError("unlinkInternetServiceRequest should be UnlinkInternetServiceRequest")
}
localVarPostBody = &localVarOptionalUnlinkInternetServiceRequest
}
if ctx != nil {
// API Key Authentication
if auth, ok := ctx.Value(ContextAPIKey).(APIKey); ok {
var key string
if auth.Prefix != "" {
key = auth.Prefix + " " + auth.Key
} else {
key = auth.Key
}
localVarHeaderParams["Authorization"] = key
}
}
r, err := a.client.prepareRequest(ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFormFileName, localVarFileName, localVarFileBytes)
if err != nil {
return localVarReturnValue, nil, err
}
localVarHTTPResponse, err := a.client.callAPI(r)
if err != nil || localVarHTTPResponse == nil {
return localVarReturnValue, localVarHTTPResponse, err
}
localVarBody, err := _ioutil.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
if err != nil {
return localVarReturnValue, localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
if localVarHTTPResponse.StatusCode == 200 {
var v UnlinkInternetServiceResponse
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr.error = err.Error()
return localVarReturnValue, localVarHTTPResponse, newErr
}
newErr.model = v
return localVarReturnValue, localVarHTTPResponse, newErr
}
if localVarHTTPResponse.StatusCode == 400 {
var v ErrorResponse
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr.error = err.Error()
return localVarReturnValue, localVarHTTPResponse, newErr
}
newErr.model = v
return localVarReturnValue, localVarHTTPResponse, newErr
}
if localVarHTTPResponse.StatusCode == 401 {
var v ErrorResponse
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr.error = err.Error()
return localVarReturnValue, localVarHTTPResponse, newErr
}
newErr.model = v
return localVarReturnValue, localVarHTTPResponse, newErr
}
if localVarHTTPResponse.StatusCode == 500 {
var v ErrorResponse
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr.error = err.Error()
return localVarReturnValue, localVarHTTPResponse, newErr
}
newErr.model = v
}
return localVarReturnValue, localVarHTTPResponse, newErr
}
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr := GenericOpenAPIError{
body: localVarBody,
error: err.Error(),
}
return localVarReturnValue, localVarHTTPResponse, newErr
}
return localVarReturnValue, localVarHTTPResponse, nil
}

Some files were not shown because too many files have changed in this diff Show More