1packagemain
+ 2
+ 3import(
+ 4"runtime"
+ 5
+ 6"go.anx.io/e5e"
+ 7)
+ 8
+ 9typeSumEventDatastruct{
+10Aint`json:"a"`
+11Bint`json:"b"`
+12}
+13
+14typeSumEventstruct{
+15e5e.Event
+16DataSumEventData`json:"data,omitempty"`
+17}
+18
+19// Using a custom `e5e.Context` class is optional and only needed to access the `Data` attribute on the
+20// context. This attribute may be used to get the return value of an authorizer function, for example. If access
+21// to the `Data` attribute is not needed, the `e5e.Context` type can be used on the entrypoint directly.
+22
+23typeSumContextDatastruct{
+24AuthKeystring`json:"auth_key"`
+25}
+26
+27typeSumContextstruct{
+28e5e.Context
+29DataSumContextData`json:"data,omitempty"`
+30}
+31
+32typeentrypointsstruct{}
+33
+34func(f*entrypoints)MyEntrypoint(eventSumEvent,contextSumContext)(e5e.Result,error){
+35returne5e.Result{
+36Status:200,
+37ResponseHeaders:map[string]string{
+38"x-custom-response-header":"This is a custom response header",
+39},
+40Data:map[string]interface{}{
+41"sum":event.Data.A+event.Data.B,
+42"version":runtime.Version(),
+43},
+44},nil
+45}
+46
+47funcmain(){
+48e5e.Start(&entrypoints{})
+49}
+
1packagemain
+ 2
+ 3import(
+ 4"runtime"
+ 5
+ 6"go.anx.io/e5e"
+ 7)
+ 8
+ 9typeSumEventDatastruct{
+10Aint`json:"a"`
+11Bint`json:"b"`
+12}
+13
+14typeSumEventstruct{
+15e5e.Event
+16DataSumEventData`json:"data,omitempty"`
+17}
+18
+19// Using a custom `e5e.Context` class is optional and only needed to access the `Data` attribute on the
+20// context. This attribute may be used to get the return value of an authorizer function, for example. If access
+21// to the `Data` attribute is not needed, the `e5e.Context` type can be used on the entrypoint directly.
+22
+23typeSumContextDatastruct{
+24AuthKeystring`json:"auth_key"`
+25}
+26
+27typeSumContextstruct{
+28e5e.Context
+29DataSumContextData`json:"data,omitempty"`
+30}
+31
+32typeentrypointsstruct{}
+33
+34func(f*entrypoints)MyEntrypoint(eventSumEvent,contextSumContext)(e5e.Result,error){
+35returne5e.Result{
+36Status:200,
+37ResponseHeaders:map[string]string{
+38"x-custom-response-header":"This is a custom response header",
+39},
+40Data:map[string]interface{}{
+41"sum":event.Data.A+event.Data.B,
+42"version":runtime.Version(),
+43},
+44},nil
+45}
+46
+47funcmain(){
+48e5e.Start(&entrypoints{})
+49}
+
1packagemain
+ 2
+ 3import(
+ 4"runtime"
+ 5
+ 6"go.anx.io/e5e"
+ 7)
+ 8
+ 9typeSumEventDatastruct{
+10Aint`json:"a"`
+11Bint`json:"b"`
+12}
+13
+14typeSumEventstruct{
+15e5e.Event
+16DataSumEventData`json:"data,omitempty"`
+17}
+18
+19// Using a custom `e5e.Context` class is optional and only needed to access the `Data` attribute on the
+20// context. This attribute may be used to get the return value of an authorizer function, for example. If access
+21// to the `Data` attribute is not needed, the `e5e.Context` type can be used on the entrypoint directly.
+22
+23typeSumContextDatastruct{
+24AuthKeystring`json:"auth_key"`
+25}
+26
+27typeSumContextstruct{
+28e5e.Context
+29DataSumContextData`json:"data,omitempty"`
+30}
+31
+32typeentrypointsstruct{}
+33
+34func(f*entrypoints)MyEntrypoint(eventSumEvent,contextSumContext)(e5e.Result,error){
+35returne5e.Result{
+36Status:200,
+37ResponseHeaders:map[string]string{
+38"x-custom-response-header":"This is a custom response header",
+39},
+40Data:map[string]interface{}{
+41"sum":event.Data.A+event.Data.B,
+42"version":runtime.Version(),
+43},
+44},nil
+45}
+46
+47funcmain(){
+48e5e.Start(&entrypoints{})
+49}
+
1packagemain
+ 2
+ 3import(
+ 4"runtime"
+ 5
+ 6"go.anx.io/e5e"
+ 7)
+ 8
+ 9typeSumEventDatastruct{
+10Aint`json:"a"`
+11Bint`json:"b"`
+12}
+13
+14typeSumEventstruct{
+15e5e.Event
+16DataSumEventData`json:"data,omitempty"`
+17}
+18
+19// Using a custom `e5e.Context` class is optional and only needed to access the `Data` attribute on the
+20// context. This attribute may be used to get the return value of an authorizer function, for example. If access
+21// to the `Data` attribute is not needed, the `e5e.Context` type can be used on the entrypoint directly.
+22
+23typeSumContextDatastruct{
+24AuthKeystring`json:"auth_key"`
+25}
+26
+27typeSumContextstruct{
+28e5e.Context
+29DataSumContextData`json:"data,omitempty"`
+30}
+31
+32typeentrypointsstruct{}
+33
+34func(f*entrypoints)MyEntrypoint(eventSumEvent,contextSumContext)(e5e.Result,error){
+35returne5e.Result{
+36Status:200,
+37ResponseHeaders:map[string]string{
+38"x-custom-response-header":"This is a custom response header",
+39},
+40Data:map[string]interface{}{
+41"sum":event.Data.A+event.Data.B,
+42"version":runtime.Version(),
+43},
+44},nil
+45}
+46
+47funcmain(){
+48e5e.Start(&entrypoints{})
+49}
+
1packagemain
+ 2
+ 3import(
+ 4"runtime"
+ 5
+ 6"go.anx.io/e5e"
+ 7)
+ 8
+ 9typeSumEventDatastruct{
+10Aint`json:"a"`
+11Bint`json:"b"`
+12}
+13
+14typeSumEventstruct{
+15e5e.Event
+16DataSumEventData`json:"data,omitempty"`
+17}
+18
+19// Using a custom `e5e.Context` class is optional and only needed to access the `Data` attribute on the
+20// context. This attribute may be used to get the return value of an authorizer function, for example. If access
+21// to the `Data` attribute is not needed, the `e5e.Context` type can be used on the entrypoint directly.
+22
+23typeSumContextDatastruct{
+24AuthKeystring`json:"auth_key"`
+25}
+26
+27typeSumContextstruct{
+28e5e.Context
+29DataSumContextData`json:"data,omitempty"`
+30}
+31
+32typeentrypointsstruct{}
+33
+34func(f*entrypoints)MyEntrypoint(eventSumEvent,contextSumContext)(e5e.Result,error){
+35returne5e.Result{
+36Status:200,
+37ResponseHeaders:map[string]string{
+38"x-custom-response-header":"This is a custom response header",
+39},
+40Data:map[string]interface{}{
+41"sum":event.Data.A+event.Data.B,
+42"version":runtime.Version(),
+43},
+44},nil
+45}
+46
+47funcmain(){
+48e5e.Start(&entrypoints{})
+49}
+
1packagemain
+ 2
+ 3import(
+ 4"runtime"
+ 5
+ 6"go.anx.io/e5e"
+ 7)
+ 8
+ 9typeSumEventDatastruct{
+10Aint`json:"a"`
+11Bint`json:"b"`
+12}
+13
+14typeSumEventstruct{
+15e5e.Event
+16DataSumEventData`json:"data,omitempty"`
+17}
+18
+19// Using a custom `e5e.Context` class is optional and only needed to access the `Data` attribute on the
+20// context. This attribute may be used to get the return value of an authorizer function, for example. If access
+21// to the `Data` attribute is not needed, the `e5e.Context` type can be used on the entrypoint directly.
+22
+23typeSumContextDatastruct{
+24AuthKeystring`json:"auth_key"`
+25}
+26
+27typeSumContextstruct{
+28e5e.Context
+29DataSumContextData`json:"data,omitempty"`
+30}
+31
+32typeentrypointsstruct{}
+33
+34func(f*entrypoints)MyEntrypoint(eventSumEvent,contextSumContext)(e5e.Result,error){
+35returne5e.Result{
+36Status:200,
+37ResponseHeaders:map[string]string{
+38"x-custom-response-header":"This is a custom response header",
+39},
+40Data:map[string]interface{}{
+41"sum":event.Data.A+event.Data.B,
+42"version":runtime.Version(),
+43},
+44},nil
+45}
+46
+47funcmain(){
+48e5e.Start(&entrypoints{})
+49}
+
+
+
+
+
+
\ No newline at end of file
diff --git a/go-anxcloud/README.md/index.html b/go-anxcloud/README.md/index.html
new file mode 100644
index 0000000000..0699bdaedd
--- /dev/null
+++ b/go-anxcloud/README.md/index.html
@@ -0,0 +1,346 @@
+
+
+
+ go.anx.io/go-anxcloud - Go Client for the Anexia API
+
+
+
+
+
+
+
+
+
+
+
go.anx.io/go-anxcloud
+
+
+
+
+
+
+
Go Client for the Anexia API
+
Go SDK for interacting with the Anexia Engine API.
+
Installing
+
To use the SDK, just add go.anx.io/go-anxcloud <version> to your Go module.
+
Getting started
+
Before using the SDK you should familiarize yourself with the Anexia Engine API.
+
The library is used in our terraform provider, check it out if you want some examples how to use it.
+
Example
+
Below is a short example using the new generic client in this package. Not all APIs can already be used with it, but we are working on that.
+Find more examples in the docs (linked to docs for
+main branch, not the latest (or any) release).
+
1packagemain
+ 2
+ 3import(
+ 4"context"
+ 5"log"
+ 6
+ 7"go.anx.io/go-anxcloud/pkg/api"
+ 8apiTypes"go.anx.io/go-anxcloud/pkg/api/types"
+ 9"go.anx.io/go-anxcloud/pkg/client"
+10
+11// apis usable with the generic client have their own package in a location analog to this
+12lbaasv1"go.anx.io/go-anxcloud/pkg/apis/lbaas/v1"
+13)
+14
+15funcmain(){
+16apiClient,err:=api.NewAPI(
+17api.WithClientOptions(
+18// Get auth token from ANEXIA_TOKEN environment variable.
+19// The boolean parameter specifies if the environment variable should be unset.
+20client.TokenFromEnv(false),
+21),
+22)
+23iferr!=nil{
+24log.Fatalf("Error creating ANX API client: %v",err)
+25}
+26
+27// let's list LBaaS backends of a known LoadBalancer
+28frontend:=lbaasv1.Frontend{
+29LoadBalancer:lbaasv1.LoadBalancer{Identifier:"285b954fdf2a449c8fdae01cc6074025"},
+30}
+31
+32varfrontendsapiTypes.ObjectChannel
+33err=apiClient.List(context.TODO(),&frontend,
+34// Listing can be done with either a page iterator or a channel, we use a channel here.
+35api.ObjectChannel(&frontends),
+36
+37// Most APIs only give a very small subset when listing resources, add this flag to
+38// get all attributes, at the cost of doing lots of API requests.
+39api.FullObjects(true),
+40)
+41iferr!=nil{
+42log.Fatalf("Error listing backends for LoadBalancer '%v': %v",frontend.LoadBalancer.Identifier,err)
+43}
+44
+45forretriever:=rangefrontends{
+46// reinitialise frontend every loop to reset pointers and avoid potential overwriting of data in the next loop
+47varfrontendlbaasv1.Frontend
+48iferr:=retriever(&frontend);err!=nil{
+49log.Fatalf("Error retrieving Frontend: %v",err)
+50}
+51
+52log.Printf("Got Frontend named '%v' with mode '%v'",frontend.Name,frontend.Mode)
+53}
+54}
+
This new generic client will one day be the only client in go-anxcloud. The legacy API-specific clients are deprecated and will be removed in the
+go-anxcloud release following the one with all APIs go-anxcloud supports usable with the generic client (so if the generic client in 0.5.0 supports
+at least everything there is another client for in go-anxcloud, 0.6.0 will drop the API-specific clients).
+
+
1packagemain
+ 2
+ 3import(
+ 4"context"
+ 5"fmt"
+ 6"time"
+ 7
+ 8anexia"go.anx.io/go-anxcloud/pkg"
+ 9"go.anx.io/go-anxcloud/pkg/client"
+10"go.anx.io/go-anxcloud/pkg/vsphere/provisioning/vm"
+11)
+12
+13funcmain(){
+14vlan:="<ID of the VLAN the VM should have access to>"
+15location:="<ID of the location the VM should be in>"
+16
+17// Create client using the auth token in environment variable ANEXIA_TOKEN and do not unset the environment variable.
+18c,err:=client.New(client.AuthFromEnv(false))
+19iferr!=nil{
+20panic(fmt.Sprintf("could not create client: %v",err))
+21}
+22
+23// Get some API.
+24provisioning:=anexia.NewAPI(c).VSphere().Provisioning()
+25
+26// Time out after 30 minutes. Yes it really takes that long sometimes.
+27ctx,cancel:=context.WithTimeout(context.Background(),30*time.Minute)
+28// Look for a free ip in the given VLAN. This IP is not reserved for you so better be quick.
+29ips,err:=provisioning.IPs().GetFree(ctx,location,vlan)
+30defercancel()
+31iferr!=nil{
+32panic(fmt.Sprintf("provisioning vm failed: %v",err))
+33}
+34iflen(ips)<1{
+35panic(fmt.Sprintf("no IPs left for testing in vlan"))
+36}
+37
+38// Create a NIC for the VM and connect it to the VLAN.
+39networkInterfaces:=[]vm.Network{{NICType:"vmxnet3",IPs:[]string{ips[0].Identifier},VLAN:vlan}}
+40// Create the definition of the new VM. The ID you see here is Flatcar.
+41definition:=vm.NewAPI(c).NewDefinition(location,"template","44b38284-6adb-430e-b4a4-1553e29f352f","developersfirstvm",2,2048,10,networkInterfaces)
+42definition.SSH="<your SSH pub key>"
+43
+44// Provision the VM.
+45provisionResponse,err:=provisioning.VM().Provision(ctx,definition)
+46iferr!=nil{
+47panic(fmt.Sprintf("provisioning vm failed: %v",err))
+48}
+49
+50// Wait for the VM to be ready.
+51_,err=provisioning.Progress().AwaitCompletion(ctx,provisionResponse.Identifier)
+52iferr!=nil{
+53panic(fmt.Sprintf("waiting for VM provisioning failed: %v",err))
+54}
+55}
+
+
+
+
+
+
\ No newline at end of file
diff --git a/go-anxcloud/README.md@SYSENG-867/cleanup-workflows-follow-up/index.html b/go-anxcloud/README.md@SYSENG-867/cleanup-workflows-follow-up/index.html
new file mode 100644
index 0000000000..5dff45d0da
--- /dev/null
+++ b/go-anxcloud/README.md@SYSENG-867/cleanup-workflows-follow-up/index.html
@@ -0,0 +1,346 @@
+
+
+
+ go.anx.io/go-anxcloud - Go Client for the Anexia API
+
+
+
+
+
+
+
+
+
+
+
go.anx.io/go-anxcloud
+
+
+
+
+
+
+
Go Client for the Anexia API
+
Go SDK for interacting with the Anexia Engine API.
+
Installing
+
To use the SDK, just add go.anx.io/go-anxcloud <version> to your Go module.
+
Getting started
+
Before using the SDK you should familiarize yourself with the Anexia Engine API.
+
The library is used in our terraform provider, check it out if you want some examples how to use it.
+
Example
+
Below is a short example using the new generic client in this package. Not all APIs can already be used with it, but we are working on that.
+Find more examples in the docs (linked to docs for
+main branch, not the latest (or any) release).
+
1packagemain
+ 2
+ 3import(
+ 4"context"
+ 5"log"
+ 6
+ 7"go.anx.io/go-anxcloud/pkg/api"
+ 8apiTypes"go.anx.io/go-anxcloud/pkg/api/types"
+ 9"go.anx.io/go-anxcloud/pkg/client"
+10
+11// apis usable with the generic client have their own package in a location analog to this
+12lbaasv1"go.anx.io/go-anxcloud/pkg/apis/lbaas/v1"
+13)
+14
+15funcmain(){
+16apiClient,err:=api.NewAPI(
+17api.WithClientOptions(
+18// Get auth token from ANEXIA_TOKEN environment variable.
+19// The boolean parameter specifies if the environment variable should be unset.
+20client.TokenFromEnv(false),
+21),
+22)
+23iferr!=nil{
+24log.Fatalf("Error creating ANX API client: %v",err)
+25}
+26
+27// let's list LBaaS backends of a known LoadBalancer
+28frontend:=lbaasv1.Frontend{
+29LoadBalancer:lbaasv1.LoadBalancer{Identifier:"285b954fdf2a449c8fdae01cc6074025"},
+30}
+31
+32varfrontendsapiTypes.ObjectChannel
+33err=apiClient.List(context.TODO(),&frontend,
+34// Listing can be done with either a page iterator or a channel, we use a channel here.
+35api.ObjectChannel(&frontends),
+36
+37// Most APIs only give a very small subset when listing resources, add this flag to
+38// get all attributes, at the cost of doing lots of API requests.
+39api.FullObjects(true),
+40)
+41iferr!=nil{
+42log.Fatalf("Error listing backends for LoadBalancer '%v': %v",frontend.LoadBalancer.Identifier,err)
+43}
+44
+45forretriever:=rangefrontends{
+46// reinitialise frontend every loop to reset pointers and avoid potential overwriting of data in the next loop
+47varfrontendlbaasv1.Frontend
+48iferr:=retriever(&frontend);err!=nil{
+49log.Fatalf("Error retrieving Frontend: %v",err)
+50}
+51
+52log.Printf("Got Frontend named '%v' with mode '%v'",frontend.Name,frontend.Mode)
+53}
+54}
+
This new generic client will one day be the only client in go-anxcloud. The legacy API-specific clients are deprecated and will be removed in the
+go-anxcloud release following the one with all APIs go-anxcloud supports usable with the generic client (so if the generic client in 0.5.0 supports
+at least everything there is another client for in go-anxcloud, 0.6.0 will drop the API-specific clients).
+
+
1packagemain
+ 2
+ 3import(
+ 4"context"
+ 5"fmt"
+ 6"time"
+ 7
+ 8anexia"go.anx.io/go-anxcloud/pkg"
+ 9"go.anx.io/go-anxcloud/pkg/client"
+10"go.anx.io/go-anxcloud/pkg/vsphere/provisioning/vm"
+11)
+12
+13funcmain(){
+14vlan:="<ID of the VLAN the VM should have access to>"
+15location:="<ID of the location the VM should be in>"
+16
+17// Create client using the auth token in environment variable ANEXIA_TOKEN and do not unset the environment variable.
+18c,err:=client.New(client.AuthFromEnv(false))
+19iferr!=nil{
+20panic(fmt.Sprintf("could not create client: %v",err))
+21}
+22
+23// Get some API.
+24provisioning:=anexia.NewAPI(c).VSphere().Provisioning()
+25
+26// Time out after 30 minutes. Yes it really takes that long sometimes.
+27ctx,cancel:=context.WithTimeout(context.Background(),30*time.Minute)
+28// Look for a free ip in the given VLAN. This IP is not reserved for you so better be quick.
+29ips,err:=provisioning.IPs().GetFree(ctx,location,vlan)
+30defercancel()
+31iferr!=nil{
+32panic(fmt.Sprintf("provisioning vm failed: %v",err))
+33}
+34iflen(ips)<1{
+35panic(fmt.Sprintf("no IPs left for testing in vlan"))
+36}
+37
+38// Create a NIC for the VM and connect it to the VLAN.
+39networkInterfaces:=[]vm.Network{{NICType:"vmxnet3",IPs:[]string{ips[0].Identifier},VLAN:vlan}}
+40// Create the definition of the new VM. The ID you see here is Flatcar.
+41definition:=vm.NewAPI(c).NewDefinition(location,"template","44b38284-6adb-430e-b4a4-1553e29f352f","developersfirstvm",2,2048,10,networkInterfaces)
+42definition.SSH="<your SSH pub key>"
+43
+44// Provision the VM.
+45provisionResponse,err:=provisioning.VM().Provision(ctx,definition)
+46iferr!=nil{
+47panic(fmt.Sprintf("provisioning vm failed: %v",err))
+48}
+49
+50// Wait for the VM to be ready.
+51_,err=provisioning.Progress().AwaitCompletion(ctx,provisionResponse.Identifier)
+52iferr!=nil{
+53panic(fmt.Sprintf("waiting for VM provisioning failed: %v",err))
+54}
+55}
+
+
+
+
+
+
\ No newline at end of file
diff --git a/go-anxcloud/README.md@SYSENG-867/cleanup-workflows-test-labeling/index.html b/go-anxcloud/README.md@SYSENG-867/cleanup-workflows-test-labeling/index.html
new file mode 100644
index 0000000000..a1faf785ac
--- /dev/null
+++ b/go-anxcloud/README.md@SYSENG-867/cleanup-workflows-test-labeling/index.html
@@ -0,0 +1,346 @@
+
+
+
+ go.anx.io/go-anxcloud - Go Client for the Anexia API
+
+
+
+
+
+
+
+
+
+
+
go.anx.io/go-anxcloud
+
+
+
+
+
+
+
Go Client for the Anexia API
+
Go SDK for interacting with the Anexia Engine API.
+
Installing
+
To use the SDK, just add go.anx.io/go-anxcloud <version> to your Go module.
+
Getting started
+
Before using the SDK you should familiarize yourself with the Anexia Engine API.
+
The library is used in our terraform provider, check it out if you want some examples how to use it.
+
Example
+
Below is a short example using the new generic client in this package. Not all APIs can already be used with it, but we are working on that.
+Find more examples in the docs (linked to docs for
+main branch, not the latest (or any) release).
+
1packagemain
+ 2
+ 3import(
+ 4"context"
+ 5"log"
+ 6
+ 7"go.anx.io/go-anxcloud/pkg/api"
+ 8apiTypes"go.anx.io/go-anxcloud/pkg/api/types"
+ 9"go.anx.io/go-anxcloud/pkg/client"
+10
+11// apis usable with the generic client have their own package in a location analog to this
+12lbaasv1"go.anx.io/go-anxcloud/pkg/apis/lbaas/v1"
+13)
+14
+15funcmain(){
+16apiClient,err:=api.NewAPI(
+17api.WithClientOptions(
+18// Get auth token from ANEXIA_TOKEN environment variable.
+19// The boolean parameter specifies if the environment variable should be unset.
+20client.TokenFromEnv(false),
+21),
+22)
+23iferr!=nil{
+24log.Fatalf("Error creating ANX API client: %v",err)
+25}
+26
+27// let's list LBaaS backends of a known LoadBalancer
+28frontend:=lbaasv1.Frontend{
+29LoadBalancer:lbaasv1.LoadBalancer{Identifier:"285b954fdf2a449c8fdae01cc6074025"},
+30}
+31
+32varfrontendsapiTypes.ObjectChannel
+33err=apiClient.List(context.TODO(),&frontend,
+34// Listing can be done with either a page iterator or a channel, we use a channel here.
+35api.ObjectChannel(&frontends),
+36
+37// Most APIs only give a very small subset when listing resources, add this flag to
+38// get all attributes, at the cost of doing lots of API requests.
+39api.FullObjects(true),
+40)
+41iferr!=nil{
+42log.Fatalf("Error listing backends for LoadBalancer '%v': %v",frontend.LoadBalancer.Identifier,err)
+43}
+44
+45forretriever:=rangefrontends{
+46// reinitialise frontend every loop to reset pointers and avoid potential overwriting of data in the next loop
+47varfrontendlbaasv1.Frontend
+48iferr:=retriever(&frontend);err!=nil{
+49log.Fatalf("Error retrieving Frontend: %v",err)
+50}
+51
+52log.Printf("Got Frontend named '%v' with mode '%v'",frontend.Name,frontend.Mode)
+53}
+54}
+
This new generic client will one day be the only client in go-anxcloud. The legacy API-specific clients are deprecated and will be removed in the
+go-anxcloud release following the one with all APIs go-anxcloud supports usable with the generic client (so if the generic client in 0.5.0 supports
+at least everything there is another client for in go-anxcloud, 0.6.0 will drop the API-specific clients).
+
+
1packagemain
+ 2
+ 3import(
+ 4"context"
+ 5"fmt"
+ 6"time"
+ 7
+ 8anexia"go.anx.io/go-anxcloud/pkg"
+ 9"go.anx.io/go-anxcloud/pkg/client"
+10"go.anx.io/go-anxcloud/pkg/vsphere/provisioning/vm"
+11)
+12
+13funcmain(){
+14vlan:="<ID of the VLAN the VM should have access to>"
+15location:="<ID of the location the VM should be in>"
+16
+17// Create client using the auth token in environment variable ANEXIA_TOKEN and do not unset the environment variable.
+18c,err:=client.New(client.AuthFromEnv(false))
+19iferr!=nil{
+20panic(fmt.Sprintf("could not create client: %v",err))
+21}
+22
+23// Get some API.
+24provisioning:=anexia.NewAPI(c).VSphere().Provisioning()
+25
+26// Time out after 30 minutes. Yes it really takes that long sometimes.
+27ctx,cancel:=context.WithTimeout(context.Background(),30*time.Minute)
+28// Look for a free ip in the given VLAN. This IP is not reserved for you so better be quick.
+29ips,err:=provisioning.IPs().GetFree(ctx,location,vlan)
+30defercancel()
+31iferr!=nil{
+32panic(fmt.Sprintf("provisioning vm failed: %v",err))
+33}
+34iflen(ips)<1{
+35panic(fmt.Sprintf("no IPs left for testing in vlan"))
+36}
+37
+38// Create a NIC for the VM and connect it to the VLAN.
+39networkInterfaces:=[]vm.Network{{NICType:"vmxnet3",IPs:[]string{ips[0].Identifier},VLAN:vlan}}
+40// Create the definition of the new VM. The ID you see here is Flatcar.
+41definition:=vm.NewAPI(c).NewDefinition(location,"template","44b38284-6adb-430e-b4a4-1553e29f352f","developersfirstvm",2,2048,10,networkInterfaces)
+42definition.SSH="<your SSH pub key>"
+43
+44// Provision the VM.
+45provisionResponse,err:=provisioning.VM().Provision(ctx,definition)
+46iferr!=nil{
+47panic(fmt.Sprintf("provisioning vm failed: %v",err))
+48}
+49
+50// Wait for the VM to be ready.
+51_,err=provisioning.Progress().AwaitCompletion(ctx,provisionResponse.Identifier)
+52iferr!=nil{
+53panic(fmt.Sprintf("waiting for VM provisioning failed: %v",err))
+54}
+55}
+
+
+
+
+
+
\ No newline at end of file
diff --git a/go-anxcloud/README.md@SYSENG-867/cleanup-workflows/index.html b/go-anxcloud/README.md@SYSENG-867/cleanup-workflows/index.html
new file mode 100644
index 0000000000..e490eaf0b6
--- /dev/null
+++ b/go-anxcloud/README.md@SYSENG-867/cleanup-workflows/index.html
@@ -0,0 +1,346 @@
+
+
+
+ go.anx.io/go-anxcloud - Go Client for the Anexia API
+
+
+
+
+
+
+
+
+
+
+
go.anx.io/go-anxcloud
+
+
+
+
+
+
+
Go Client for the Anexia API
+
Go SDK for interacting with the Anexia Engine API.
+
Installing
+
To use the SDK, just add go.anx.io/go-anxcloud <version> to your Go module.
+
Getting started
+
Before using the SDK you should familiarize yourself with the Anexia Engine API.
+
The library is used in our terraform provider, check it out if you want some examples how to use it.
+
Example
+
Below is a short example using the new generic client in this package. Not all APIs can already be used with it, but we are working on that.
+Find more examples in the docs (linked to docs for
+main branch, not the latest (or any) release).
+
1packagemain
+ 2
+ 3import(
+ 4"context"
+ 5"log"
+ 6
+ 7"go.anx.io/go-anxcloud/pkg/api"
+ 8apiTypes"go.anx.io/go-anxcloud/pkg/api/types"
+ 9"go.anx.io/go-anxcloud/pkg/client"
+10
+11// apis usable with the generic client have their own package in a location analog to this
+12lbaasv1"go.anx.io/go-anxcloud/pkg/apis/lbaas/v1"
+13)
+14
+15funcmain(){
+16apiClient,err:=api.NewAPI(
+17api.WithClientOptions(
+18// Get auth token from ANEXIA_TOKEN environment variable.
+19// The boolean parameter specifies if the environment variable should be unset.
+20client.TokenFromEnv(false),
+21),
+22)
+23iferr!=nil{
+24log.Fatalf("Error creating ANX API client: %v",err)
+25}
+26
+27// let's list LBaaS backends of a known LoadBalancer
+28frontend:=lbaasv1.Frontend{
+29LoadBalancer:lbaasv1.LoadBalancer{Identifier:"285b954fdf2a449c8fdae01cc6074025"},
+30}
+31
+32varfrontendsapiTypes.ObjectChannel
+33err=apiClient.List(context.TODO(),&frontend,
+34// Listing can be done with either a page iterator or a channel, we use a channel here.
+35api.ObjectChannel(&frontends),
+36
+37// Most APIs only give a very small subset when listing resources, add this flag to
+38// get all attributes, at the cost of doing lots of API requests.
+39api.FullObjects(true),
+40)
+41iferr!=nil{
+42log.Fatalf("Error listing backends for LoadBalancer '%v': %v",frontend.LoadBalancer.Identifier,err)
+43}
+44
+45forretriever:=rangefrontends{
+46// reinitialise frontend every loop to reset pointers and avoid potential overwriting of data in the next loop
+47varfrontendlbaasv1.Frontend
+48iferr:=retriever(&frontend);err!=nil{
+49log.Fatalf("Error retrieving Frontend: %v",err)
+50}
+51
+52log.Printf("Got Frontend named '%v' with mode '%v'",frontend.Name,frontend.Mode)
+53}
+54}
+
This new generic client will one day be the only client in go-anxcloud. The legacy API-specific clients are deprecated and will be removed in the
+go-anxcloud release following the one with all APIs go-anxcloud supports usable with the generic client (so if the generic client in 0.5.0 supports
+at least everything there is another client for in go-anxcloud, 0.6.0 will drop the API-specific clients).
+
+
1packagemain
+ 2
+ 3import(
+ 4"context"
+ 5"fmt"
+ 6"time"
+ 7
+ 8anexia"go.anx.io/go-anxcloud/pkg"
+ 9"go.anx.io/go-anxcloud/pkg/client"
+10"go.anx.io/go-anxcloud/pkg/vsphere/provisioning/vm"
+11)
+12
+13funcmain(){
+14vlan:="<ID of the VLAN the VM should have access to>"
+15location:="<ID of the location the VM should be in>"
+16
+17// Create client using the auth token in environment variable ANEXIA_TOKEN and do not unset the environment variable.
+18c,err:=client.New(client.AuthFromEnv(false))
+19iferr!=nil{
+20panic(fmt.Sprintf("could not create client: %v",err))
+21}
+22
+23// Get some API.
+24provisioning:=anexia.NewAPI(c).VSphere().Provisioning()
+25
+26// Time out after 30 minutes. Yes it really takes that long sometimes.
+27ctx,cancel:=context.WithTimeout(context.Background(),30*time.Minute)
+28// Look for a free ip in the given VLAN. This IP is not reserved for you so better be quick.
+29ips,err:=provisioning.IPs().GetFree(ctx,location,vlan)
+30defercancel()
+31iferr!=nil{
+32panic(fmt.Sprintf("provisioning vm failed: %v",err))
+33}
+34iflen(ips)<1{
+35panic(fmt.Sprintf("no IPs left for testing in vlan"))
+36}
+37
+38// Create a NIC for the VM and connect it to the VLAN.
+39networkInterfaces:=[]vm.Network{{NICType:"vmxnet3",IPs:[]string{ips[0].Identifier},VLAN:vlan}}
+40// Create the definition of the new VM. The ID you see here is Flatcar.
+41definition:=vm.NewAPI(c).NewDefinition(location,"template","44b38284-6adb-430e-b4a4-1553e29f352f","developersfirstvm",2,2048,10,networkInterfaces)
+42definition.SSH="<your SSH pub key>"
+43
+44// Provision the VM.
+45provisionResponse,err:=provisioning.VM().Provision(ctx,definition)
+46iferr!=nil{
+47panic(fmt.Sprintf("provisioning vm failed: %v",err))
+48}
+49
+50// Wait for the VM to be ready.
+51_,err=provisioning.Progress().AwaitCompletion(ctx,provisionResponse.Identifier)
+52iferr!=nil{
+53panic(fmt.Sprintf("waiting for VM provisioning failed: %v",err))
+54}
+55}
+
+
+
+
+
+
\ No newline at end of file
diff --git a/go-anxcloud/README.md@add-ds-res-based/index.html b/go-anxcloud/README.md@add-ds-res-based/index.html
new file mode 100644
index 0000000000..3b6f6229d2
--- /dev/null
+++ b/go-anxcloud/README.md@add-ds-res-based/index.html
@@ -0,0 +1,285 @@
+
+
+
+ go.anx.io/go-anxcloud - Go Client for the Anexia API
+
+
+
+
+
+
+
+
+
+
+
go.anx.io/go-anxcloud
+
+
+
+
+
+
Go Client for the Anexia API
+
Go SDK for interacting with the Anexia multi purpose API.
+
Installing
+
To use the SDK, just add github.com/anexia-it/go-anxcloud <version> to your Go module.
+
Getting started
+
Before using the SDK you should familiarize yourself with the API. See here for more info.
+I you crave for an example, take a look at the terraform provider for this project
+
Example
+
The following code shows how to create a VM. To be able to do that you need to set the environment variable ANEXIA_TOKEN to your access token.
+Afterwards you can run the following.
+
1packagemain
+ 2
+ 3import(
+ 4"context"
+ 5"fmt"
+ 6"time"
+ 7
+ 8anexia"github.com/anexia-it/go-anxcloud/pkg"
+ 9"github.com/anexia-it/go-anxcloud/pkg/client"
+10"github.com/anexia-it/go-anxcloud/pkg/vsphere/provisioning/vm"
+11)
+12
+13funcmain(){
+14vlan:="<ID of the VLAN the VM should have access to>"
+15location:="<ID of the location the VM should be in>"
+16
+17// Create client from environment variables, do not unset env afterwards.
+18c,err:=client.New(client.AuthFromEnv(false))
+19iferr!=nil{
+20panic(fmt.Sprintf("could not create client: %v",err))
+21}
+22
+23// Get some API.
+24provisioning:=anexia.NewAPI(c).VSphere().Provisioning()
+25
+26// Time out after 30 minutes. Yes it really takes that long sometimes.
+27ctx,cancel:=context.WithTimeout(context.Background(),30*time.Minute)
+28// Look for a free ip in the given VLAN. This IP is not reserved for you so better be quick.
+29ips,err:=provisioning.IPs().GetFree(ctx,location,vlan)
+30defercancel()
+31iferr!=nil{
+32panic(fmt.Sprintf("provisioning vm failed: %v",err))
+33}
+34iflen(ips)<1{
+35panic(fmt.Sprintf("no IPs left for testing in vlan"))
+36}
+37
+38// Create a NIC for the VM and connect it to the VLAN.
+39networkInterfaces:=[]vm.Network{{NICType:"vmxnet3",IPs:[]string{ips[0].Identifier},VLAN:vlan}}
+40// Create the definition of the new VM. The ID you see here is Flatcar.
+41definition:=vm.NewAPI(c).NewDefinition(location,"template","44b38284-6adb-430e-b4a4-1553e29f352f","developersfirstvm",2,2048,10,networkInterfaces)
+42definition.SSH="<your SSH pub key>"
+43
+44// Provision the VM.
+45provisionResponse,err:=provisioning.VM().Provision(ctx,definition)
+46iferr!=nil{
+47panic(fmt.Sprintf("provisioning vm failed: %v",err))
+48}
+49
+50// Wait for the VM to be ready.
+51_,err=provisioning.Progress().AwaitCompletion(ctx,provisionResponse.Identifier)
+52iferr!=nil{
+53panic(fmt.Sprintf("waiting for VM provisioning failed: %v",err))
+54}
+55}
+
+
+
+
+
\ No newline at end of file
diff --git a/go-anxcloud/README.md@add-ipam-reserve-specific/index.html b/go-anxcloud/README.md@add-ipam-reserve-specific/index.html
new file mode 100644
index 0000000000..399f21436a
--- /dev/null
+++ b/go-anxcloud/README.md@add-ipam-reserve-specific/index.html
@@ -0,0 +1,346 @@
+
+
+
+ go.anx.io/go-anxcloud - Go Client for the Anexia API
+
+
+
+
+
+
+
+
+
+
+
go.anx.io/go-anxcloud
+
+
+
+
+
+
+
Go Client for the Anexia API
+
Go SDK for interacting with the Anexia Engine API.
+
Installing
+
To use the SDK, just add go.anx.io/go-anxcloud <version> to your Go module.
+
Getting started
+
Before using the SDK you should familiarize yourself with the Anexia Engine API.
+
The library is used in our terraform provider, check it out if you want some examples how to use it.
+
Example
+
Below is a short example using the new generic client in this package. Not all APIs can already be used with it, but we are working on that.
+Find more examples in the docs (linked to docs for
+main branch, not the latest (or any) release).
+
1packagemain
+ 2
+ 3import(
+ 4"context"
+ 5"log"
+ 6
+ 7"go.anx.io/go-anxcloud/pkg/api"
+ 8apiTypes"go.anx.io/go-anxcloud/pkg/api/types"
+ 9"go.anx.io/go-anxcloud/pkg/client"
+10
+11// apis usable with the generic client have their own package in a location analog to this
+12lbaasv1"go.anx.io/go-anxcloud/pkg/apis/lbaas/v1"
+13)
+14
+15funcmain(){
+16apiClient,err:=api.NewAPI(
+17api.WithClientOptions(
+18// Get auth token from ANEXIA_TOKEN environment variable.
+19// The boolean parameter specifies if the environment variable should be unset.
+20client.TokenFromEnv(false),
+21),
+22)
+23iferr!=nil{
+24log.Fatalf("Error creating ANX API client: %v",err)
+25}
+26
+27// let's list LBaaS backends of a known LoadBalancer
+28frontend:=lbaasv1.Frontend{
+29LoadBalancer:&lbaasv1.LoadBalancer{Identifier:"285b954fdf2a449c8fdae01cc6074025"},
+30}
+31
+32varfrontendsapiTypes.ObjectChannel
+33err=apiClient.List(context.TODO(),&frontend,
+34// Listing can be done with either a page iterator or a channel, we use a channel here.
+35api.ObjectChannel(&frontends),
+36
+37// Most APIs only give a very small subset when listing resources, add this flag to
+38// get all attributes, at the cost of doing lots of API requests.
+39api.FullObjects(true),
+40)
+41iferr!=nil{
+42log.Fatalf("Error listing backends for LoadBalancer '%v': %v",frontend.LoadBalancer.Identifier,err)
+43}
+44
+45forretriever:=rangefrontends{
+46// reinitialise frontend every loop to reset pointers and avoid potential overwriting of data in the next loop
+47varfrontendlbaasv1.Frontend
+48iferr:=retriever(&frontend);err!=nil{
+49log.Fatalf("Error retrieving Frontend: %v",err)
+50}
+51
+52log.Printf("Got Frontend named '%v' with mode '%v'",frontend.Name,frontend.Mode)
+53}
+54}
+
This new generic client will one day be the only client in go-anxcloud. The legacy API-specific clients are deprecated and will be removed in the
+go-anxcloud release following the one with all APIs go-anxcloud supports usable with the generic client (so if the generic client in 0.5.0 supports
+at least everything there is another client for in go-anxcloud, 0.6.0 will drop the API-specific clients).
+
+
1packagemain
+ 2
+ 3import(
+ 4"context"
+ 5"fmt"
+ 6"time"
+ 7
+ 8anexia"go.anx.io/go-anxcloud/pkg"
+ 9"go.anx.io/go-anxcloud/pkg/client"
+10"go.anx.io/go-anxcloud/pkg/vsphere/provisioning/vm"
+11)
+12
+13funcmain(){
+14vlan:="<ID of the VLAN the VM should have access to>"
+15location:="<ID of the location the VM should be in>"
+16
+17// Create client using the auth token in environment variable ANEXIA_TOKEN and do not unset the environment variable.
+18c,err:=client.New(client.AuthFromEnv(false))
+19iferr!=nil{
+20panic(fmt.Sprintf("could not create client: %v",err))
+21}
+22
+23// Get some API.
+24provisioning:=anexia.NewAPI(c).VSphere().Provisioning()
+25
+26// Time out after 30 minutes. Yes it really takes that long sometimes.
+27ctx,cancel:=context.WithTimeout(context.Background(),30*time.Minute)
+28// Look for a free ip in the given VLAN. This IP is not reserved for you so better be quick.
+29ips,err:=provisioning.IPs().GetFree(ctx,location,vlan)
+30defercancel()
+31iferr!=nil{
+32panic(fmt.Sprintf("provisioning vm failed: %v",err))
+33}
+34iflen(ips)<1{
+35panic(fmt.Sprintf("no IPs left for testing in vlan"))
+36}
+37
+38// Create a NIC for the VM and connect it to the VLAN.
+39networkInterfaces:=[]vm.Network{{NICType:"vmxnet3",IPs:[]string{ips[0].Identifier},VLAN:vlan}}
+40// Create the definition of the new VM. The ID you see here is Flatcar.
+41definition:=vm.NewAPI(c).NewDefinition(location,"template","44b38284-6adb-430e-b4a4-1553e29f352f","developersfirstvm",2,2048,10,networkInterfaces)
+42definition.SSH="<your SSH pub key>"
+43
+44// Provision the VM.
+45provisionResponse,err:=provisioning.VM().Provision(ctx,definition)
+46iferr!=nil{
+47panic(fmt.Sprintf("provisioning vm failed: %v",err))
+48}
+49
+50// Wait for the VM to be ready.
+51_,err=provisioning.Progress().AwaitCompletion(ctx,provisionResponse.Identifier)
+52iferr!=nil{
+53panic(fmt.Sprintf("waiting for VM provisioning failed: %v",err))
+54}
+55}
+
+
+
+
+
+
\ No newline at end of file
diff --git a/go-anxcloud/README.md@feature/generic-api-lbaas-improvements/index.html b/go-anxcloud/README.md@feature/generic-api-lbaas-improvements/index.html
new file mode 100644
index 0000000000..0de07c2d95
--- /dev/null
+++ b/go-anxcloud/README.md@feature/generic-api-lbaas-improvements/index.html
@@ -0,0 +1,346 @@
+
+
+
+ go.anx.io/go-anxcloud - Go Client for the Anexia API
+
+
+
+
+
+
+
+
+
+
+
go.anx.io/go-anxcloud
+
+
+
+
+
+
+
Go Client for the Anexia API
+
Go SDK for interacting with the Anexia multi purpose API.
+
Installing
+
To use the SDK, just add github.com/anexia-it/go-anxcloud <version> to your Go module.
+
Getting started
+
Before using the SDK you should familiarize yourself with the API. See here for more info.
+I you crave for an example, take a look at the terraform provider for this project
+
Example
+
Below is a short example using the new generic client in this package. Not all APIs can already be used with it, but we are working on that.
+Find more examples in the docs (linked to docs for
+main branch, not the latest (or any) release).
+
1packagemain
+ 2
+ 3import(
+ 4"context"
+ 5"log"
+ 6
+ 7"github.com/anexia-it/go-anxcloud/pkg/api"
+ 8apiTypes"github.com/anexia-it/go-anxcloud/pkg/api/types"
+ 9"github.com/anexia-it/go-anxcloud/pkg/client"
+10
+11// apis usable with the generic client have their own package in a location analog to this
+12lbaasv1"github.com/anexia-it/go-anxcloud/pkg/apis/lbaas/v1"
+13)
+14
+15funcmain(){
+16apiClient,err:=api.NewAPI(
+17api.WithClientOptions(
+18// Get auth token from ANEXIA_TOKEN environment variable.
+19// The boolean parameter specifies if the environment variable should be unset.
+20client.TokenFromEnv(false),
+21),
+22)
+23iferr!=nil{
+24log.Fatalf("Error creating ANX API client: %v",err)
+25}
+26
+27// let's list LBaaS backends of a known LoadBalancer
+28frontend:=lbaasv1.Frontend{
+29LoadBalancer:lbaasv1.LoadBalancer{Identifier:"285b954fdf2a449c8fdae01cc6074025"},
+30}
+31
+32varfrontendsapiTypes.ObjectChannel
+33err=apiClient.List(context.TODO(),&frontend,
+34// Listing can be done with either a page iterator or a channel, we use a channel here.
+35api.ObjectChannel(&frontends),
+36
+37// Most APIs only give a very small subset when listing resources, add this flag to
+38// get all attributes, at the cost of doing lots of API requests.
+39api.FullObjects(true),
+40)
+41iferr!=nil{
+42log.Fatalf("Error listing backends for LoadBalancer '%v': %v",frontend.LoadBalancer.Identifier,err)
+43}
+44
+45forretriever:=rangefrontends{
+46// reinitialise frontend every loop to reset pointers and avoid potential overwriting of data in the next loop
+47varfrontendlbaasv1.Frontend
+48iferr:=retriever(&frontend);err!=nil{
+49log.Fatalf("Error retrieving Frontend: %v",err)
+50}
+51
+52log.Printf("Got Frontend named '%v' with mode '%v'",frontend.Name,frontend.Mode)
+53}
+54}
+
This new generic client will one day be the only client in go-anxcloud. The legacy API-specific clients are deprecated and will be removed in the
+go-anxcloud release following the one with all APIs go-anxcloud supports usable with the generic client (so if the generic client in 0.5.0 supports
+at least everything there is another client for in go-anxcloud, 0.6.0 will drop the API-specific clients).
+
+
1packagemain
+ 2
+ 3import(
+ 4"context"
+ 5"fmt"
+ 6"time"
+ 7
+ 8anexia"github.com/anexia-it/go-anxcloud/pkg"
+ 9"github.com/anexia-it/go-anxcloud/pkg/client"
+10"github.com/anexia-it/go-anxcloud/pkg/vsphere/provisioning/vm"
+11)
+12
+13funcmain(){
+14vlan:="<ID of the VLAN the VM should have access to>"
+15location:="<ID of the location the VM should be in>"
+16
+17// Create client using the auth token in environment variable ANEXIA_TOKEN and do not unset the environment variable.
+18c,err:=client.New(client.AuthFromEnv(false))
+19iferr!=nil{
+20panic(fmt.Sprintf("could not create client: %v",err))
+21}
+22
+23// Get some API.
+24provisioning:=anexia.NewAPI(c).VSphere().Provisioning()
+25
+26// Time out after 30 minutes. Yes it really takes that long sometimes.
+27ctx,cancel:=context.WithTimeout(context.Background(),30*time.Minute)
+28// Look for a free ip in the given VLAN. This IP is not reserved for you so better be quick.
+29ips,err:=provisioning.IPs().GetFree(ctx,location,vlan)
+30defercancel()
+31iferr!=nil{
+32panic(fmt.Sprintf("provisioning vm failed: %v",err))
+33}
+34iflen(ips)<1{
+35panic(fmt.Sprintf("no IPs left for testing in vlan"))
+36}
+37
+38// Create a NIC for the VM and connect it to the VLAN.
+39networkInterfaces:=[]vm.Network{{NICType:"vmxnet3",IPs:[]string{ips[0].Identifier},VLAN:vlan}}
+40// Create the definition of the new VM. The ID you see here is Flatcar.
+41definition:=vm.NewAPI(c).NewDefinition(location,"template","44b38284-6adb-430e-b4a4-1553e29f352f","developersfirstvm",2,2048,10,networkInterfaces)
+42definition.SSH="<your SSH pub key>"
+43
+44// Provision the VM.
+45provisionResponse,err:=provisioning.VM().Provision(ctx,definition)
+46iferr!=nil{
+47panic(fmt.Sprintf("provisioning vm failed: %v",err))
+48}
+49
+50// Wait for the VM to be ready.
+51_,err=provisioning.Progress().AwaitCompletion(ctx,provisionResponse.Identifier)
+52iferr!=nil{
+53panic(fmt.Sprintf("waiting for VM provisioning failed: %v",err))
+54}
+55}
+
+
+
+
+
+
\ No newline at end of file
diff --git a/go-anxcloud/README.md@github-actions-refactor-2/index.html b/go-anxcloud/README.md@github-actions-refactor-2/index.html
new file mode 100644
index 0000000000..ff438a790d
--- /dev/null
+++ b/go-anxcloud/README.md@github-actions-refactor-2/index.html
@@ -0,0 +1,346 @@
+
+
+
+ go.anx.io/go-anxcloud - Go Client for the Anexia API
+
+
+
+
+
+
+
+
+
+
+
go.anx.io/go-anxcloud
+
+
+
+
+
+
+
Go Client for the Anexia API
+
Go SDK for interacting with the Anexia Engine API.
+
Installing
+
To use the SDK, just add go.anx.io/go-anxcloud <version> to your Go module.
+
Getting started
+
Before using the SDK you should familiarize yourself with the Anexia Engine API.
+
The library is used in our terraform provider, check it out if you want some examples how to use it.
+
Example
+
Below is a short example using the new generic client in this package. Not all APIs can already be used with it, but we are working on that.
+Find more examples in the docs (linked to docs for
+main branch, not the latest (or any) release).
+
1packagemain
+ 2
+ 3import(
+ 4"context"
+ 5"log"
+ 6
+ 7"go.anx.io/go-anxcloud/pkg/api"
+ 8apiTypes"go.anx.io/go-anxcloud/pkg/api/types"
+ 9"go.anx.io/go-anxcloud/pkg/client"
+10
+11// apis usable with the generic client have their own package in a location analog to this
+12lbaasv1"go.anx.io/go-anxcloud/pkg/apis/lbaas/v1"
+13)
+14
+15funcmain(){
+16apiClient,err:=api.NewAPI(
+17api.WithClientOptions(
+18// Get auth token from ANEXIA_TOKEN environment variable.
+19// The boolean parameter specifies if the environment variable should be unset.
+20client.TokenFromEnv(false),
+21),
+22)
+23iferr!=nil{
+24log.Fatalf("Error creating ANX API client: %v",err)
+25}
+26
+27// let's list LBaaS backends of a known LoadBalancer
+28frontend:=lbaasv1.Frontend{
+29LoadBalancer:lbaasv1.LoadBalancer{Identifier:"285b954fdf2a449c8fdae01cc6074025"},
+30}
+31
+32varfrontendsapiTypes.ObjectChannel
+33err=apiClient.List(context.TODO(),&frontend,
+34// Listing can be done with either a page iterator or a channel, we use a channel here.
+35api.ObjectChannel(&frontends),
+36
+37// Most APIs only give a very small subset when listing resources, add this flag to
+38// get all attributes, at the cost of doing lots of API requests.
+39api.FullObjects(true),
+40)
+41iferr!=nil{
+42log.Fatalf("Error listing backends for LoadBalancer '%v': %v",frontend.LoadBalancer.Identifier,err)
+43}
+44
+45forretriever:=rangefrontends{
+46// reinitialise frontend every loop to reset pointers and avoid potential overwriting of data in the next loop
+47varfrontendlbaasv1.Frontend
+48iferr:=retriever(&frontend);err!=nil{
+49log.Fatalf("Error retrieving Frontend: %v",err)
+50}
+51
+52log.Printf("Got Frontend named '%v' with mode '%v'",frontend.Name,frontend.Mode)
+53}
+54}
+
This new generic client will one day be the only client in go-anxcloud. The legacy API-specific clients are deprecated and will be removed in the
+go-anxcloud release following the one with all APIs go-anxcloud supports usable with the generic client (so if the generic client in 0.5.0 supports
+at least everything there is another client for in go-anxcloud, 0.6.0 will drop the API-specific clients).
+
+
1packagemain
+ 2
+ 3import(
+ 4"context"
+ 5"fmt"
+ 6"time"
+ 7
+ 8anexia"go.anx.io/go-anxcloud/pkg"
+ 9"go.anx.io/go-anxcloud/pkg/client"
+10"go.anx.io/go-anxcloud/pkg/vsphere/provisioning/vm"
+11)
+12
+13funcmain(){
+14vlan:="<ID of the VLAN the VM should have access to>"
+15location:="<ID of the location the VM should be in>"
+16
+17// Create client using the auth token in environment variable ANEXIA_TOKEN and do not unset the environment variable.
+18c,err:=client.New(client.AuthFromEnv(false))
+19iferr!=nil{
+20panic(fmt.Sprintf("could not create client: %v",err))
+21}
+22
+23// Get some API.
+24provisioning:=anexia.NewAPI(c).VSphere().Provisioning()
+25
+26// Time out after 30 minutes. Yes it really takes that long sometimes.
+27ctx,cancel:=context.WithTimeout(context.Background(),30*time.Minute)
+28// Look for a free ip in the given VLAN. This IP is not reserved for you so better be quick.
+29ips,err:=provisioning.IPs().GetFree(ctx,location,vlan)
+30defercancel()
+31iferr!=nil{
+32panic(fmt.Sprintf("provisioning vm failed: %v",err))
+33}
+34iflen(ips)<1{
+35panic(fmt.Sprintf("no IPs left for testing in vlan"))
+36}
+37
+38// Create a NIC for the VM and connect it to the VLAN.
+39networkInterfaces:=[]vm.Network{{NICType:"vmxnet3",IPs:[]string{ips[0].Identifier},VLAN:vlan}}
+40// Create the definition of the new VM. The ID you see here is Flatcar.
+41definition:=vm.NewAPI(c).NewDefinition(location,"template","44b38284-6adb-430e-b4a4-1553e29f352f","developersfirstvm",2,2048,10,networkInterfaces)
+42definition.SSH="<your SSH pub key>"
+43
+44// Provision the VM.
+45provisionResponse,err:=provisioning.VM().Provision(ctx,definition)
+46iferr!=nil{
+47panic(fmt.Sprintf("provisioning vm failed: %v",err))
+48}
+49
+50// Wait for the VM to be ready.
+51_,err=provisioning.Progress().AwaitCompletion(ctx,provisionResponse.Identifier)
+52iferr!=nil{
+53panic(fmt.Sprintf("waiting for VM provisioning failed: %v",err))
+54}
+55}
+
+
+
+
+
+
\ No newline at end of file
diff --git a/go-anxcloud/README.md@github-actions-refactor/index.html b/go-anxcloud/README.md@github-actions-refactor/index.html
new file mode 100644
index 0000000000..7fe93318be
--- /dev/null
+++ b/go-anxcloud/README.md@github-actions-refactor/index.html
@@ -0,0 +1,346 @@
+
+
+
+ go.anx.io/go-anxcloud - Go Client for the Anexia API
+
+
+
+
+
+
+
+
+
+
+
go.anx.io/go-anxcloud
+
+
+
+
+
+
+
Go Client for the Anexia API
+
Go SDK for interacting with the Anexia Engine API.
+
Installing
+
To use the SDK, just add go.anx.io/go-anxcloud <version> to your Go module.
+
Getting started
+
Before using the SDK you should familiarize yourself with the Anexia Engine API.
+
The library is used in our terraform provider, check it out if you want some examples how to use it.
+
Example
+
Below is a short example using the new generic client in this package. Not all APIs can already be used with it, but we are working on that.
+Find more examples in the docs (linked to docs for
+main branch, not the latest (or any) release).
+
1packagemain
+ 2
+ 3import(
+ 4"context"
+ 5"log"
+ 6
+ 7"go.anx.io/go-anxcloud/pkg/api"
+ 8apiTypes"go.anx.io/go-anxcloud/pkg/api/types"
+ 9"go.anx.io/go-anxcloud/pkg/client"
+10
+11// apis usable with the generic client have their own package in a location analog to this
+12lbaasv1"go.anx.io/go-anxcloud/pkg/apis/lbaas/v1"
+13)
+14
+15funcmain(){
+16apiClient,err:=api.NewAPI(
+17api.WithClientOptions(
+18// Get auth token from ANEXIA_TOKEN environment variable.
+19// The boolean parameter specifies if the environment variable should be unset.
+20client.TokenFromEnv(false),
+21),
+22)
+23iferr!=nil{
+24log.Fatalf("Error creating ANX API client: %v",err)
+25}
+26
+27// let's list LBaaS backends of a known LoadBalancer
+28frontend:=lbaasv1.Frontend{
+29LoadBalancer:lbaasv1.LoadBalancer{Identifier:"285b954fdf2a449c8fdae01cc6074025"},
+30}
+31
+32varfrontendsapiTypes.ObjectChannel
+33err=apiClient.List(context.TODO(),&frontend,
+34// Listing can be done with either a page iterator or a channel, we use a channel here.
+35api.ObjectChannel(&frontends),
+36
+37// Most APIs only give a very small subset when listing resources, add this flag to
+38// get all attributes, at the cost of doing lots of API requests.
+39api.FullObjects(true),
+40)
+41iferr!=nil{
+42log.Fatalf("Error listing backends for LoadBalancer '%v': %v",frontend.LoadBalancer.Identifier,err)
+43}
+44
+45forretriever:=rangefrontends{
+46// reinitialise frontend every loop to reset pointers and avoid potential overwriting of data in the next loop
+47varfrontendlbaasv1.Frontend
+48iferr:=retriever(&frontend);err!=nil{
+49log.Fatalf("Error retrieving Frontend: %v",err)
+50}
+51
+52log.Printf("Got Frontend named '%v' with mode '%v'",frontend.Name,frontend.Mode)
+53}
+54}
+
This new generic client will one day be the only client in go-anxcloud. The legacy API-specific clients are deprecated and will be removed in the
+go-anxcloud release following the one with all APIs go-anxcloud supports usable with the generic client (so if the generic client in 0.5.0 supports
+at least everything there is another client for in go-anxcloud, 0.6.0 will drop the API-specific clients).
+
+
1packagemain
+ 2
+ 3import(
+ 4"context"
+ 5"fmt"
+ 6"time"
+ 7
+ 8anexia"go.anx.io/go-anxcloud/pkg"
+ 9"go.anx.io/go-anxcloud/pkg/client"
+10"go.anx.io/go-anxcloud/pkg/vsphere/provisioning/vm"
+11)
+12
+13funcmain(){
+14vlan:="<ID of the VLAN the VM should have access to>"
+15location:="<ID of the location the VM should be in>"
+16
+17// Create client using the auth token in environment variable ANEXIA_TOKEN and do not unset the environment variable.
+18c,err:=client.New(client.AuthFromEnv(false))
+19iferr!=nil{
+20panic(fmt.Sprintf("could not create client: %v",err))
+21}
+22
+23// Get some API.
+24provisioning:=anexia.NewAPI(c).VSphere().Provisioning()
+25
+26// Time out after 30 minutes. Yes it really takes that long sometimes.
+27ctx,cancel:=context.WithTimeout(context.Background(),30*time.Minute)
+28// Look for a free ip in the given VLAN. This IP is not reserved for you so better be quick.
+29ips,err:=provisioning.IPs().GetFree(ctx,location,vlan)
+30defercancel()
+31iferr!=nil{
+32panic(fmt.Sprintf("provisioning vm failed: %v",err))
+33}
+34iflen(ips)<1{
+35panic(fmt.Sprintf("no IPs left for testing in vlan"))
+36}
+37
+38// Create a NIC for the VM and connect it to the VLAN.
+39networkInterfaces:=[]vm.Network{{NICType:"vmxnet3",IPs:[]string{ips[0].Identifier},VLAN:vlan}}
+40// Create the definition of the new VM. The ID you see here is Flatcar.
+41definition:=vm.NewAPI(c).NewDefinition(location,"template","44b38284-6adb-430e-b4a4-1553e29f352f","developersfirstvm",2,2048,10,networkInterfaces)
+42definition.SSH="<your SSH pub key>"
+43
+44// Provision the VM.
+45provisionResponse,err:=provisioning.VM().Provision(ctx,definition)
+46iferr!=nil{
+47panic(fmt.Sprintf("provisioning vm failed: %v",err))
+48}
+49
+50// Wait for the VM to be ready.
+51_,err=provisioning.Progress().AwaitCompletion(ctx,provisionResponse.Identifier)
+52iferr!=nil{
+53panic(fmt.Sprintf("waiting for VM provisioning failed: %v",err))
+54}
+55}
+
+
+
+
+
+
\ No newline at end of file
diff --git a/go-anxcloud/README.md@lbaas-add-state/index.html b/go-anxcloud/README.md@lbaas-add-state/index.html
new file mode 100644
index 0000000000..adfa24322a
--- /dev/null
+++ b/go-anxcloud/README.md@lbaas-add-state/index.html
@@ -0,0 +1,286 @@
+
+
+
+ go.anx.io/go-anxcloud - Go Client for the Anexia API
+
+
+
+
+
+
+
+
+
+
+
go.anx.io/go-anxcloud
+
+
+
+
+
+
+
Go Client for the Anexia API
+
Go SDK for interacting with the Anexia multi purpose API.
+
Installing
+
To use the SDK, just add github.com/anexia-it/go-anxcloud <version> to your Go module.
+
Getting started
+
Before using the SDK you should familiarize yourself with the API. See here for more info.
+I you crave for an example, take a look at the terraform provider for this project
+
Example
+
The following code shows how to create a VM. To be able to do that you need to set the environment variable ANEXIA_TOKEN to your access token.
+Afterwards you can run the following.
+
1packagemain
+ 2
+ 3import(
+ 4"context"
+ 5"fmt"
+ 6"time"
+ 7
+ 8anexia"github.com/anexia-it/go-anxcloud/pkg"
+ 9"github.com/anexia-it/go-anxcloud/pkg/client"
+10"github.com/anexia-it/go-anxcloud/pkg/vsphere/provisioning/vm"
+11)
+12
+13funcmain(){
+14vlan:="<ID of the VLAN the VM should have access to>"
+15location:="<ID of the location the VM should be in>"
+16
+17// Create client from environment variables, do not unset env afterwards.
+18c,err:=client.New(client.AuthFromEnv(false))
+19iferr!=nil{
+20panic(fmt.Sprintf("could not create client: %v",err))
+21}
+22
+23// Get some API.
+24provisioning:=anexia.NewAPI(c).VSphere().Provisioning()
+25
+26// Time out after 30 minutes. Yes it really takes that long sometimes.
+27ctx,cancel:=context.WithTimeout(context.Background(),30*time.Minute)
+28// Look for a free ip in the given VLAN. This IP is not reserved for you so better be quick.
+29ips,err:=provisioning.IPs().GetFree(ctx,location,vlan)
+30defercancel()
+31iferr!=nil{
+32panic(fmt.Sprintf("provisioning vm failed: %v",err))
+33}
+34iflen(ips)<1{
+35panic(fmt.Sprintf("no IPs left for testing in vlan"))
+36}
+37
+38// Create a NIC for the VM and connect it to the VLAN.
+39networkInterfaces:=[]vm.Network{{NICType:"vmxnet3",IPs:[]string{ips[0].Identifier},VLAN:vlan}}
+40// Create the definition of the new VM. The ID you see here is Flatcar.
+41definition:=vm.NewAPI(c).NewDefinition(location,"template","44b38284-6adb-430e-b4a4-1553e29f352f","developersfirstvm",2,2048,10,networkInterfaces)
+42definition.SSH="<your SSH pub key>"
+43
+44// Provision the VM.
+45provisionResponse,err:=provisioning.VM().Provision(ctx,definition)
+46iferr!=nil{
+47panic(fmt.Sprintf("provisioning vm failed: %v",err))
+48}
+49
+50// Wait for the VM to be ready.
+51_,err=provisioning.Progress().AwaitCompletion(ctx,provisionResponse.Identifier)
+52iferr!=nil{
+53panic(fmt.Sprintf("waiting for VM provisioning failed: %v",err))
+54}
+55}
+
+
+
+
+
\ No newline at end of file
diff --git a/go-anxcloud/README.md@main/index.html b/go-anxcloud/README.md@main/index.html
new file mode 100644
index 0000000000..d189158e78
--- /dev/null
+++ b/go-anxcloud/README.md@main/index.html
@@ -0,0 +1,346 @@
+
+
+
+ go.anx.io/go-anxcloud - Go Client for the Anexia API
+
+
+
+
+
+
+
+
+
+
+
go.anx.io/go-anxcloud
+
+
+
+
+
+
+
Go Client for the Anexia API
+
Go SDK for interacting with the Anexia Engine API.
+
Installing
+
To use the SDK, just add go.anx.io/go-anxcloud <version> to your Go module.
+
Getting started
+
Before using the SDK you should familiarize yourself with the Anexia Engine API.
+
The library is used in our terraform provider, check it out if you want some examples how to use it.
+
Example
+
Below is a short example using the new generic client in this package. Not all APIs can already be used with it, but we are working on that.
+Find more examples in the docs (linked to docs for
+main branch, not the latest (or any) release).
+
1packagemain
+ 2
+ 3import(
+ 4"context"
+ 5"log"
+ 6
+ 7"go.anx.io/go-anxcloud/pkg/api"
+ 8apiTypes"go.anx.io/go-anxcloud/pkg/api/types"
+ 9"go.anx.io/go-anxcloud/pkg/client"
+10
+11// apis usable with the generic client have their own package in a location analog to this
+12lbaasv1"go.anx.io/go-anxcloud/pkg/apis/lbaas/v1"
+13)
+14
+15funcmain(){
+16apiClient,err:=api.NewAPI(
+17api.WithClientOptions(
+18// Get auth token from ANEXIA_TOKEN environment variable.
+19// The boolean parameter specifies if the environment variable should be unset.
+20client.TokenFromEnv(false),
+21),
+22)
+23iferr!=nil{
+24log.Fatalf("Error creating ANX API client: %v",err)
+25}
+26
+27// let's list LBaaS backends of a known LoadBalancer
+28frontend:=lbaasv1.Frontend{
+29LoadBalancer:&lbaasv1.LoadBalancer{Identifier:"285b954fdf2a449c8fdae01cc6074025"},
+30}
+31
+32varfrontendsapiTypes.ObjectChannel
+33err=apiClient.List(context.TODO(),&frontend,
+34// Listing can be done with either a page iterator or a channel, we use a channel here.
+35api.ObjectChannel(&frontends),
+36
+37// Most APIs only give a very small subset when listing resources, add this flag to
+38// get all attributes, at the cost of doing lots of API requests.
+39api.FullObjects(true),
+40)
+41iferr!=nil{
+42log.Fatalf("Error listing backends for LoadBalancer '%v': %v",frontend.LoadBalancer.Identifier,err)
+43}
+44
+45forretriever:=rangefrontends{
+46// reinitialise frontend every loop to reset pointers and avoid potential overwriting of data in the next loop
+47varfrontendlbaasv1.Frontend
+48iferr:=retriever(&frontend);err!=nil{
+49log.Fatalf("Error retrieving Frontend: %v",err)
+50}
+51
+52log.Printf("Got Frontend named '%v' with mode '%v'",frontend.Name,frontend.Mode)
+53}
+54}
+
This new generic client will one day be the only client in go-anxcloud. The legacy API-specific clients are deprecated and will be removed in the
+go-anxcloud release following the one with all APIs go-anxcloud supports usable with the generic client (so if the generic client in 0.5.0 supports
+at least everything there is another client for in go-anxcloud, 0.6.0 will drop the API-specific clients).
+
+
1packagemain
+ 2
+ 3import(
+ 4"context"
+ 5"fmt"
+ 6"time"
+ 7
+ 8anexia"go.anx.io/go-anxcloud/pkg"
+ 9"go.anx.io/go-anxcloud/pkg/client"
+10"go.anx.io/go-anxcloud/pkg/vsphere/provisioning/vm"
+11)
+12
+13funcmain(){
+14vlan:="<ID of the VLAN the VM should have access to>"
+15location:="<ID of the location the VM should be in>"
+16
+17// Create client using the auth token in environment variable ANEXIA_TOKEN and do not unset the environment variable.
+18c,err:=client.New(client.AuthFromEnv(false))
+19iferr!=nil{
+20panic(fmt.Sprintf("could not create client: %v",err))
+21}
+22
+23// Get some API.
+24provisioning:=anexia.NewAPI(c).VSphere().Provisioning()
+25
+26// Time out after 30 minutes. Yes it really takes that long sometimes.
+27ctx,cancel:=context.WithTimeout(context.Background(),30*time.Minute)
+28// Look for a free ip in the given VLAN. This IP is not reserved for you so better be quick.
+29ips,err:=provisioning.IPs().GetFree(ctx,location,vlan)
+30defercancel()
+31iferr!=nil{
+32panic(fmt.Sprintf("provisioning vm failed: %v",err))
+33}
+34iflen(ips)<1{
+35panic(fmt.Sprintf("no IPs left for testing in vlan"))
+36}
+37
+38// Create a NIC for the VM and connect it to the VLAN.
+39networkInterfaces:=[]vm.Network{{NICType:"vmxnet3",IPs:[]string{ips[0].Identifier},VLAN:vlan}}
+40// Create the definition of the new VM. The ID you see here is Flatcar.
+41definition:=vm.NewAPI(c).NewDefinition(location,"template","44b38284-6adb-430e-b4a4-1553e29f352f","developersfirstvm",2,2048,10,networkInterfaces)
+42definition.SSH="<your SSH pub key>"
+43
+44// Provision the VM.
+45provisionResponse,err:=provisioning.VM().Provision(ctx,definition)
+46iferr!=nil{
+47panic(fmt.Sprintf("provisioning vm failed: %v",err))
+48}
+49
+50// Wait for the VM to be ready.
+51_,err=provisioning.Progress().AwaitCompletion(ctx,provisionResponse.Identifier)
+52iferr!=nil{
+53panic(fmt.Sprintf("waiting for VM provisioning failed: %v",err))
+54}
+55}
+
+
+
+
+
+
\ No newline at end of file
diff --git a/go-anxcloud/README.md@syseng-1210/wip-deepcopy-generator/index.html b/go-anxcloud/README.md@syseng-1210/wip-deepcopy-generator/index.html
new file mode 100644
index 0000000000..e685e0abf9
--- /dev/null
+++ b/go-anxcloud/README.md@syseng-1210/wip-deepcopy-generator/index.html
@@ -0,0 +1,346 @@
+
+
+
+ go.anx.io/go-anxcloud - Go Client for the Anexia API
+
+
+
+
+
+
+
+
+
+
+
go.anx.io/go-anxcloud
+
+
+
+
+
+
+
Go Client for the Anexia API
+
Go SDK for interacting with the Anexia Engine API.
+
Installing
+
To use the SDK, just add go.anx.io/go-anxcloud <version> to your Go module.
+
Getting started
+
Before using the SDK you should familiarize yourself with the Anexia Engine API.
+
The library is used in our terraform provider, check it out if you want some examples how to use it.
+
Example
+
Below is a short example using the new generic client in this package. Not all APIs can already be used with it, but we are working on that.
+Find more examples in the docs (linked to docs for
+main branch, not the latest (or any) release).
+
1packagemain
+ 2
+ 3import(
+ 4"context"
+ 5"log"
+ 6
+ 7"go.anx.io/go-anxcloud/pkg/api"
+ 8apiTypes"go.anx.io/go-anxcloud/pkg/api/types"
+ 9"go.anx.io/go-anxcloud/pkg/client"
+10
+11// apis usable with the generic client have their own package in a location analog to this
+12lbaasv1"go.anx.io/go-anxcloud/pkg/apis/lbaas/v1"
+13)
+14
+15funcmain(){
+16apiClient,err:=api.NewAPI(
+17api.WithClientOptions(
+18// Get auth token from ANEXIA_TOKEN environment variable.
+19// The boolean parameter specifies if the environment variable should be unset.
+20client.TokenFromEnv(false),
+21),
+22)
+23iferr!=nil{
+24log.Fatalf("Error creating ANX API client: %v",err)
+25}
+26
+27// let's list LBaaS backends of a known LoadBalancer
+28frontend:=lbaasv1.Frontend{
+29LoadBalancer:lbaasv1.LoadBalancer{Identifier:"285b954fdf2a449c8fdae01cc6074025"},
+30}
+31
+32varfrontendsapiTypes.ObjectChannel
+33err=apiClient.List(context.TODO(),&frontend,
+34// Listing can be done with either a page iterator or a channel, we use a channel here.
+35api.ObjectChannel(&frontends),
+36
+37// Most APIs only give a very small subset when listing resources, add this flag to
+38// get all attributes, at the cost of doing lots of API requests.
+39api.FullObjects(true),
+40)
+41iferr!=nil{
+42log.Fatalf("Error listing backends for LoadBalancer '%v': %v",frontend.LoadBalancer.Identifier,err)
+43}
+44
+45forretriever:=rangefrontends{
+46// reinitialise frontend every loop to reset pointers and avoid potential overwriting of data in the next loop
+47varfrontendlbaasv1.Frontend
+48iferr:=retriever(&frontend);err!=nil{
+49log.Fatalf("Error retrieving Frontend: %v",err)
+50}
+51
+52log.Printf("Got Frontend named '%v' with mode '%v'",frontend.Name,frontend.Mode)
+53}
+54}
+
This new generic client will one day be the only client in go-anxcloud. The legacy API-specific clients are deprecated and will be removed in the
+go-anxcloud release following the one with all APIs go-anxcloud supports usable with the generic client (so if the generic client in 0.5.0 supports
+at least everything there is another client for in go-anxcloud, 0.6.0 will drop the API-specific clients).
+
+
1packagemain
+ 2
+ 3import(
+ 4"context"
+ 5"fmt"
+ 6"time"
+ 7
+ 8anexia"go.anx.io/go-anxcloud/pkg"
+ 9"go.anx.io/go-anxcloud/pkg/client"
+10"go.anx.io/go-anxcloud/pkg/vsphere/provisioning/vm"
+11)
+12
+13funcmain(){
+14vlan:="<ID of the VLAN the VM should have access to>"
+15location:="<ID of the location the VM should be in>"
+16
+17// Create client using the auth token in environment variable ANEXIA_TOKEN and do not unset the environment variable.
+18c,err:=client.New(client.AuthFromEnv(false))
+19iferr!=nil{
+20panic(fmt.Sprintf("could not create client: %v",err))
+21}
+22
+23// Get some API.
+24provisioning:=anexia.NewAPI(c).VSphere().Provisioning()
+25
+26// Time out after 30 minutes. Yes it really takes that long sometimes.
+27ctx,cancel:=context.WithTimeout(context.Background(),30*time.Minute)
+28// Look for a free ip in the given VLAN. This IP is not reserved for you so better be quick.
+29ips,err:=provisioning.IPs().GetFree(ctx,location,vlan)
+30defercancel()
+31iferr!=nil{
+32panic(fmt.Sprintf("provisioning vm failed: %v",err))
+33}
+34iflen(ips)<1{
+35panic(fmt.Sprintf("no IPs left for testing in vlan"))
+36}
+37
+38// Create a NIC for the VM and connect it to the VLAN.
+39networkInterfaces:=[]vm.Network{{NICType:"vmxnet3",IPs:[]string{ips[0].Identifier},VLAN:vlan}}
+40// Create the definition of the new VM. The ID you see here is Flatcar.
+41definition:=vm.NewAPI(c).NewDefinition(location,"template","44b38284-6adb-430e-b4a4-1553e29f352f","developersfirstvm",2,2048,10,networkInterfaces)
+42definition.SSH="<your SSH pub key>"
+43
+44// Provision the VM.
+45provisionResponse,err:=provisioning.VM().Provision(ctx,definition)
+46iferr!=nil{
+47panic(fmt.Sprintf("provisioning vm failed: %v",err))
+48}
+49
+50// Wait for the VM to be ready.
+51_,err=provisioning.Progress().AwaitCompletion(ctx,provisionResponse.Identifier)
+52iferr!=nil{
+53panic(fmt.Sprintf("waiting for VM provisioning failed: %v",err))
+54}
+55}
+
+
+
+
+
+
\ No newline at end of file
diff --git a/go-anxcloud/README.md@syseng-1358/automatic-resource-tagging-2/index.html b/go-anxcloud/README.md@syseng-1358/automatic-resource-tagging-2/index.html
new file mode 100644
index 0000000000..28c8e21ab2
--- /dev/null
+++ b/go-anxcloud/README.md@syseng-1358/automatic-resource-tagging-2/index.html
@@ -0,0 +1,346 @@
+
+
+
+ go.anx.io/go-anxcloud - Go Client for the Anexia API
+
+
+
+
+
+
+
+
+
+
+
go.anx.io/go-anxcloud
+
+
+
+
+
+
+
Go Client for the Anexia API
+
Go SDK for interacting with the Anexia Engine API.
+
Installing
+
To use the SDK, just add go.anx.io/go-anxcloud <version> to your Go module.
+
Getting started
+
Before using the SDK you should familiarize yourself with the Anexia Engine API.
+
The library is used in our terraform provider, check it out if you want some examples how to use it.
+
Example
+
Below is a short example using the new generic client in this package. Not all APIs can already be used with it, but we are working on that.
+Find more examples in the docs (linked to docs for
+main branch, not the latest (or any) release).
+
1packagemain
+ 2
+ 3import(
+ 4"context"
+ 5"log"
+ 6
+ 7"go.anx.io/go-anxcloud/pkg/api"
+ 8apiTypes"go.anx.io/go-anxcloud/pkg/api/types"
+ 9"go.anx.io/go-anxcloud/pkg/client"
+10
+11// apis usable with the generic client have their own package in a location analog to this
+12lbaasv1"go.anx.io/go-anxcloud/pkg/apis/lbaas/v1"
+13)
+14
+15funcmain(){
+16apiClient,err:=api.NewAPI(
+17api.WithClientOptions(
+18// Get auth token from ANEXIA_TOKEN environment variable.
+19// The boolean parameter specifies if the environment variable should be unset.
+20client.TokenFromEnv(false),
+21),
+22)
+23iferr!=nil{
+24log.Fatalf("Error creating ANX API client: %v",err)
+25}
+26
+27// let's list LBaaS backends of a known LoadBalancer
+28frontend:=lbaasv1.Frontend{
+29LoadBalancer:lbaasv1.LoadBalancer{Identifier:"285b954fdf2a449c8fdae01cc6074025"},
+30}
+31
+32varfrontendsapiTypes.ObjectChannel
+33err=apiClient.List(context.TODO(),&frontend,
+34// Listing can be done with either a page iterator or a channel, we use a channel here.
+35api.ObjectChannel(&frontends),
+36
+37// Most APIs only give a very small subset when listing resources, add this flag to
+38// get all attributes, at the cost of doing lots of API requests.
+39api.FullObjects(true),
+40)
+41iferr!=nil{
+42log.Fatalf("Error listing backends for LoadBalancer '%v': %v",frontend.LoadBalancer.Identifier,err)
+43}
+44
+45forretriever:=rangefrontends{
+46// reinitialise frontend every loop to reset pointers and avoid potential overwriting of data in the next loop
+47varfrontendlbaasv1.Frontend
+48iferr:=retriever(&frontend);err!=nil{
+49log.Fatalf("Error retrieving Frontend: %v",err)
+50}
+51
+52log.Printf("Got Frontend named '%v' with mode '%v'",frontend.Name,frontend.Mode)
+53}
+54}
+
This new generic client will one day be the only client in go-anxcloud. The legacy API-specific clients are deprecated and will be removed in the
+go-anxcloud release following the one with all APIs go-anxcloud supports usable with the generic client (so if the generic client in 0.5.0 supports
+at least everything there is another client for in go-anxcloud, 0.6.0 will drop the API-specific clients).
+
+
1packagemain
+ 2
+ 3import(
+ 4"context"
+ 5"fmt"
+ 6"time"
+ 7
+ 8anexia"go.anx.io/go-anxcloud/pkg"
+ 9"go.anx.io/go-anxcloud/pkg/client"
+10"go.anx.io/go-anxcloud/pkg/vsphere/provisioning/vm"
+11)
+12
+13funcmain(){
+14vlan:="<ID of the VLAN the VM should have access to>"
+15location:="<ID of the location the VM should be in>"
+16
+17// Create client using the auth token in environment variable ANEXIA_TOKEN and do not unset the environment variable.
+18c,err:=client.New(client.AuthFromEnv(false))
+19iferr!=nil{
+20panic(fmt.Sprintf("could not create client: %v",err))
+21}
+22
+23// Get some API.
+24provisioning:=anexia.NewAPI(c).VSphere().Provisioning()
+25
+26// Time out after 30 minutes. Yes it really takes that long sometimes.
+27ctx,cancel:=context.WithTimeout(context.Background(),30*time.Minute)
+28// Look for a free ip in the given VLAN. This IP is not reserved for you so better be quick.
+29ips,err:=provisioning.IPs().GetFree(ctx,location,vlan)
+30defercancel()
+31iferr!=nil{
+32panic(fmt.Sprintf("provisioning vm failed: %v",err))
+33}
+34iflen(ips)<1{
+35panic(fmt.Sprintf("no IPs left for testing in vlan"))
+36}
+37
+38// Create a NIC for the VM and connect it to the VLAN.
+39networkInterfaces:=[]vm.Network{{NICType:"vmxnet3",IPs:[]string{ips[0].Identifier},VLAN:vlan}}
+40// Create the definition of the new VM. The ID you see here is Flatcar.
+41definition:=vm.NewAPI(c).NewDefinition(location,"template","44b38284-6adb-430e-b4a4-1553e29f352f","developersfirstvm",2,2048,10,networkInterfaces)
+42definition.SSH="<your SSH pub key>"
+43
+44// Provision the VM.
+45provisionResponse,err:=provisioning.VM().Provision(ctx,definition)
+46iferr!=nil{
+47panic(fmt.Sprintf("provisioning vm failed: %v",err))
+48}
+49
+50// Wait for the VM to be ready.
+51_,err=provisioning.Progress().AwaitCompletion(ctx,provisionResponse.Identifier)
+52iferr!=nil{
+53panic(fmt.Sprintf("waiting for VM provisioning failed: %v",err))
+54}
+55}
+
+
+
+
+
+
\ No newline at end of file
diff --git a/go-anxcloud/README.md@syseng-679/vsphere-api/index.html b/go-anxcloud/README.md@syseng-679/vsphere-api/index.html
new file mode 100644
index 0000000000..888e5cca1a
--- /dev/null
+++ b/go-anxcloud/README.md@syseng-679/vsphere-api/index.html
@@ -0,0 +1,346 @@
+
+
+
+ go.anx.io/go-anxcloud - Go Client for the Anexia API
+
+
+
+
+
+
+
+
+
+
+
go.anx.io/go-anxcloud
+
+
+
+
+
+
+
Go Client for the Anexia API
+
Go SDK for interacting with the Anexia Engine API.
+
Installing
+
To use the SDK, just add go.anx.io/go-anxcloud <version> to your Go module.
+
Getting started
+
Before using the SDK you should familiarize yourself with the Anexia Engine API.
+
The library is used in our terraform provider, check it out if you want some examples how to use it.
+
Example
+
Below is a short example using the new generic client in this package. Not all APIs can already be used with it, but we are working on that.
+Find more examples in the docs (linked to docs for
+main branch, not the latest (or any) release).
+
1packagemain
+ 2
+ 3import(
+ 4"context"
+ 5"log"
+ 6
+ 7"go.anx.io/go-anxcloud/pkg/api"
+ 8apiTypes"go.anx.io/go-anxcloud/pkg/api/types"
+ 9"go.anx.io/go-anxcloud/pkg/client"
+10
+11// apis usable with the generic client have their own package in a location analog to this
+12lbaasv1"go.anx.io/go-anxcloud/pkg/apis/lbaas/v1"
+13)
+14
+15funcmain(){
+16apiClient,err:=api.NewAPI(
+17api.WithClientOptions(
+18// Get auth token from ANEXIA_TOKEN environment variable.
+19// The boolean parameter specifies if the environment variable should be unset.
+20client.TokenFromEnv(false),
+21),
+22)
+23iferr!=nil{
+24log.Fatalf("Error creating ANX API client: %v",err)
+25}
+26
+27// let's list LBaaS backends of a known LoadBalancer
+28frontend:=lbaasv1.Frontend{
+29LoadBalancer:lbaasv1.LoadBalancer{Identifier:"285b954fdf2a449c8fdae01cc6074025"},
+30}
+31
+32varfrontendsapiTypes.ObjectChannel
+33err=apiClient.List(context.TODO(),&frontend,
+34// Listing can be done with either a page iterator or a channel, we use a channel here.
+35api.ObjectChannel(&frontends),
+36
+37// Most APIs only give a very small subset when listing resources, add this flag to
+38// get all attributes, at the cost of doing lots of API requests.
+39api.FullObjects(true),
+40)
+41iferr!=nil{
+42log.Fatalf("Error listing backends for LoadBalancer '%v': %v",frontend.LoadBalancer.Identifier,err)
+43}
+44
+45forretriever:=rangefrontends{
+46// reinitialise frontend every loop to reset pointers and avoid potential overwriting of data in the next loop
+47varfrontendlbaasv1.Frontend
+48iferr:=retriever(&frontend);err!=nil{
+49log.Fatalf("Error retrieving Frontend: %v",err)
+50}
+51
+52log.Printf("Got Frontend named '%v' with mode '%v'",frontend.Name,frontend.Mode)
+53}
+54}
+
This new generic client will one day be the only client in go-anxcloud. The legacy API-specific clients are deprecated and will be removed in the
+go-anxcloud release following the one with all APIs go-anxcloud supports usable with the generic client (so if the generic client in 0.5.0 supports
+at least everything there is another client for in go-anxcloud, 0.6.0 will drop the API-specific clients).
+
+
1packagemain
+ 2
+ 3import(
+ 4"context"
+ 5"fmt"
+ 6"time"
+ 7
+ 8anexia"go.anx.io/go-anxcloud/pkg"
+ 9"go.anx.io/go-anxcloud/pkg/client"
+10"go.anx.io/go-anxcloud/pkg/vsphere/provisioning/vm"
+11)
+12
+13funcmain(){
+14vlan:="<ID of the VLAN the VM should have access to>"
+15location:="<ID of the location the VM should be in>"
+16
+17// Create client using the auth token in environment variable ANEXIA_TOKEN and do not unset the environment variable.
+18c,err:=client.New(client.AuthFromEnv(false))
+19iferr!=nil{
+20panic(fmt.Sprintf("could not create client: %v",err))
+21}
+22
+23// Get some API.
+24provisioning:=anexia.NewAPI(c).VSphere().Provisioning()
+25
+26// Time out after 30 minutes. Yes it really takes that long sometimes.
+27ctx,cancel:=context.WithTimeout(context.Background(),30*time.Minute)
+28// Look for a free ip in the given VLAN. This IP is not reserved for you so better be quick.
+29ips,err:=provisioning.IPs().GetFree(ctx,location,vlan)
+30defercancel()
+31iferr!=nil{
+32panic(fmt.Sprintf("provisioning vm failed: %v",err))
+33}
+34iflen(ips)<1{
+35panic(fmt.Sprintf("no IPs left for testing in vlan"))
+36}
+37
+38// Create a NIC for the VM and connect it to the VLAN.
+39networkInterfaces:=[]vm.Network{{NICType:"vmxnet3",IPs:[]string{ips[0].Identifier},VLAN:vlan}}
+40// Create the definition of the new VM. The ID you see here is Flatcar.
+41definition:=vm.NewAPI(c).NewDefinition(location,"template","44b38284-6adb-430e-b4a4-1553e29f352f","developersfirstvm",2,2048,10,networkInterfaces)
+42definition.SSH="<your SSH pub key>"
+43
+44// Provision the VM.
+45provisionResponse,err:=provisioning.VM().Provision(ctx,definition)
+46iferr!=nil{
+47panic(fmt.Sprintf("provisioning vm failed: %v",err))
+48}
+49
+50// Wait for the VM to be ready.
+51_,err=provisioning.Progress().AwaitCompletion(ctx,provisionResponse.Identifier)
+52iferr!=nil{
+53panic(fmt.Sprintf("waiting for VM provisioning failed: %v",err))
+54}
+55}
+
+
+
+
+
+
\ No newline at end of file
diff --git a/go-anxcloud/README.md@syseng-728/cancel-object-channel/index.html b/go-anxcloud/README.md@syseng-728/cancel-object-channel/index.html
new file mode 100644
index 0000000000..d6321c5cd3
--- /dev/null
+++ b/go-anxcloud/README.md@syseng-728/cancel-object-channel/index.html
@@ -0,0 +1,286 @@
+
+
+
+ go.anx.io/go-anxcloud - Go Client for the Anexia API
+
+
+
+
+
+
+
+
+
+
+
go.anx.io/go-anxcloud
+
+
+
+
+
+
+
Go Client for the Anexia API
+
Go SDK for interacting with the Anexia multi purpose API.
+
Installing
+
To use the SDK, just add github.com/anexia-it/go-anxcloud <version> to your Go module.
+
Getting started
+
Before using the SDK you should familiarize yourself with the API. See here for more info.
+I you crave for an example, take a look at the terraform provider for this project
+
Example
+
The following code shows how to create a VM. To be able to do that you need to set the environment variable ANEXIA_TOKEN to your access token.
+Afterwards you can run the following.
+
1packagemain
+ 2
+ 3import(
+ 4"context"
+ 5"fmt"
+ 6"time"
+ 7
+ 8anexia"github.com/anexia-it/go-anxcloud/pkg"
+ 9"github.com/anexia-it/go-anxcloud/pkg/client"
+10"github.com/anexia-it/go-anxcloud/pkg/vsphere/provisioning/vm"
+11)
+12
+13funcmain(){
+14vlan:="<ID of the VLAN the VM should have access to>"
+15location:="<ID of the location the VM should be in>"
+16
+17// Create client from environment variables, do not unset env afterwards.
+18c,err:=client.New(client.AuthFromEnv(false))
+19iferr!=nil{
+20panic(fmt.Sprintf("could not create client: %v",err))
+21}
+22
+23// Get some API.
+24provisioning:=anexia.NewAPI(c).VSphere().Provisioning()
+25
+26// Time out after 30 minutes. Yes it really takes that long sometimes.
+27ctx,cancel:=context.WithTimeout(context.Background(),30*time.Minute)
+28// Look for a free ip in the given VLAN. This IP is not reserved for you so better be quick.
+29ips,err:=provisioning.IPs().GetFree(ctx,location,vlan)
+30defercancel()
+31iferr!=nil{
+32panic(fmt.Sprintf("provisioning vm failed: %v",err))
+33}
+34iflen(ips)<1{
+35panic(fmt.Sprintf("no IPs left for testing in vlan"))
+36}
+37
+38// Create a NIC for the VM and connect it to the VLAN.
+39networkInterfaces:=[]vm.Network{{NICType:"vmxnet3",IPs:[]string{ips[0].Identifier},VLAN:vlan}}
+40// Create the definition of the new VM. The ID you see here is Flatcar.
+41definition:=vm.NewAPI(c).NewDefinition(location,"template","44b38284-6adb-430e-b4a4-1553e29f352f","developersfirstvm",2,2048,10,networkInterfaces)
+42definition.SSH="<your SSH pub key>"
+43
+44// Provision the VM.
+45provisionResponse,err:=provisioning.VM().Provision(ctx,definition)
+46iferr!=nil{
+47panic(fmt.Sprintf("provisioning vm failed: %v",err))
+48}
+49
+50// Wait for the VM to be ready.
+51_,err=provisioning.Progress().AwaitCompletion(ctx,provisionResponse.Identifier)
+52iferr!=nil{
+53panic(fmt.Sprintf("waiting for VM provisioning failed: %v",err))
+54}
+55}
+
+
+
+
+
\ No newline at end of file
diff --git a/go-anxcloud/README.md@syseng-923/ipam-generic-client/index.html b/go-anxcloud/README.md@syseng-923/ipam-generic-client/index.html
new file mode 100644
index 0000000000..9456ce13a5
--- /dev/null
+++ b/go-anxcloud/README.md@syseng-923/ipam-generic-client/index.html
@@ -0,0 +1,346 @@
+
+
+
+ go.anx.io/go-anxcloud - Go Client for the Anexia API
+
+
+
+
+
+
+
+
+
+
+
go.anx.io/go-anxcloud
+
+
+
+
+
+
+
Go Client for the Anexia API
+
Go SDK for interacting with the Anexia Engine API.
+
Installing
+
To use the SDK, just add go.anx.io/go-anxcloud <version> to your Go module.
+
Getting started
+
Before using the SDK you should familiarize yourself with the Anexia Engine API.
+
The library is used in our terraform provider, check it out if you want some examples how to use it.
+
Example
+
Below is a short example using the new generic client in this package. Not all APIs can already be used with it, but we are working on that.
+Find more examples in the docs (linked to docs for
+main branch, not the latest (or any) release).
+
1packagemain
+ 2
+ 3import(
+ 4"context"
+ 5"log"
+ 6
+ 7"go.anx.io/go-anxcloud/pkg/api"
+ 8apiTypes"go.anx.io/go-anxcloud/pkg/api/types"
+ 9"go.anx.io/go-anxcloud/pkg/client"
+10
+11// apis usable with the generic client have their own package in a location analog to this
+12lbaasv1"go.anx.io/go-anxcloud/pkg/apis/lbaas/v1"
+13)
+14
+15funcmain(){
+16apiClient,err:=api.NewAPI(
+17api.WithClientOptions(
+18// Get auth token from ANEXIA_TOKEN environment variable.
+19// The boolean parameter specifies if the environment variable should be unset.
+20client.TokenFromEnv(false),
+21),
+22)
+23iferr!=nil{
+24log.Fatalf("Error creating ANX API client: %v",err)
+25}
+26
+27// let's list LBaaS backends of a known LoadBalancer
+28frontend:=lbaasv1.Frontend{
+29LoadBalancer:lbaasv1.LoadBalancer{Identifier:"285b954fdf2a449c8fdae01cc6074025"},
+30}
+31
+32varfrontendsapiTypes.ObjectChannel
+33err=apiClient.List(context.TODO(),&frontend,
+34// Listing can be done with either a page iterator or a channel, we use a channel here.
+35api.ObjectChannel(&frontends),
+36
+37// Most APIs only give a very small subset when listing resources, add this flag to
+38// get all attributes, at the cost of doing lots of API requests.
+39api.FullObjects(true),
+40)
+41iferr!=nil{
+42log.Fatalf("Error listing backends for LoadBalancer '%v': %v",frontend.LoadBalancer.Identifier,err)
+43}
+44
+45forretriever:=rangefrontends{
+46// reinitialise frontend every loop to reset pointers and avoid potential overwriting of data in the next loop
+47varfrontendlbaasv1.Frontend
+48iferr:=retriever(&frontend);err!=nil{
+49log.Fatalf("Error retrieving Frontend: %v",err)
+50}
+51
+52log.Printf("Got Frontend named '%v' with mode '%v'",frontend.Name,frontend.Mode)
+53}
+54}
+
This new generic client will one day be the only client in go-anxcloud. The legacy API-specific clients are deprecated and will be removed in the
+go-anxcloud release following the one with all APIs go-anxcloud supports usable with the generic client (so if the generic client in 0.5.0 supports
+at least everything there is another client for in go-anxcloud, 0.6.0 will drop the API-specific clients).
+
+
1packagemain
+ 2
+ 3import(
+ 4"context"
+ 5"fmt"
+ 6"time"
+ 7
+ 8anexia"go.anx.io/go-anxcloud/pkg"
+ 9"go.anx.io/go-anxcloud/pkg/client"
+10"go.anx.io/go-anxcloud/pkg/vsphere/provisioning/vm"
+11)
+12
+13funcmain(){
+14vlan:="<ID of the VLAN the VM should have access to>"
+15location:="<ID of the location the VM should be in>"
+16
+17// Create client using the auth token in environment variable ANEXIA_TOKEN and do not unset the environment variable.
+18c,err:=client.New(client.AuthFromEnv(false))
+19iferr!=nil{
+20panic(fmt.Sprintf("could not create client: %v",err))
+21}
+22
+23// Get some API.
+24provisioning:=anexia.NewAPI(c).VSphere().Provisioning()
+25
+26// Time out after 30 minutes. Yes it really takes that long sometimes.
+27ctx,cancel:=context.WithTimeout(context.Background(),30*time.Minute)
+28// Look for a free ip in the given VLAN. This IP is not reserved for you so better be quick.
+29ips,err:=provisioning.IPs().GetFree(ctx,location,vlan)
+30defercancel()
+31iferr!=nil{
+32panic(fmt.Sprintf("provisioning vm failed: %v",err))
+33}
+34iflen(ips)<1{
+35panic(fmt.Sprintf("no IPs left for testing in vlan"))
+36}
+37
+38// Create a NIC for the VM and connect it to the VLAN.
+39networkInterfaces:=[]vm.Network{{NICType:"vmxnet3",IPs:[]string{ips[0].Identifier},VLAN:vlan}}
+40// Create the definition of the new VM. The ID you see here is Flatcar.
+41definition:=vm.NewAPI(c).NewDefinition(location,"template","44b38284-6adb-430e-b4a4-1553e29f352f","developersfirstvm",2,2048,10,networkInterfaces)
+42definition.SSH="<your SSH pub key>"
+43
+44// Provision the VM.
+45provisionResponse,err:=provisioning.VM().Provision(ctx,definition)
+46iferr!=nil{
+47panic(fmt.Sprintf("provisioning vm failed: %v",err))
+48}
+49
+50// Wait for the VM to be ready.
+51_,err=provisioning.Progress().AwaitCompletion(ctx,provisionResponse.Identifier)
+52iferr!=nil{
+53panic(fmt.Sprintf("waiting for VM provisioning failed: %v",err))
+54}
+55}
+
+
+
+
+
+
\ No newline at end of file
diff --git a/go-anxcloud/README.md@upgrade-go-1.20/index.html b/go-anxcloud/README.md@upgrade-go-1.20/index.html
new file mode 100644
index 0000000000..8ec2909242
--- /dev/null
+++ b/go-anxcloud/README.md@upgrade-go-1.20/index.html
@@ -0,0 +1,346 @@
+
+
+
+ go.anx.io/go-anxcloud - Go Client for the Anexia API
+
+
+
+
+
+
+
+
+
+
+
go.anx.io/go-anxcloud
+
+
+
+
+
+
+
Go Client for the Anexia API
+
Go SDK for interacting with the Anexia Engine API.
+
Installing
+
To use the SDK, just add go.anx.io/go-anxcloud <version> to your Go module.
+
Getting started
+
Before using the SDK you should familiarize yourself with the Anexia Engine API.
+
The library is used in our terraform provider, check it out if you want some examples how to use it.
+
Example
+
Below is a short example using the new generic client in this package. Not all APIs can already be used with it, but we are working on that.
+Find more examples in the docs (linked to docs for
+main branch, not the latest (or any) release).
+
1packagemain
+ 2
+ 3import(
+ 4"context"
+ 5"log"
+ 6
+ 7"go.anx.io/go-anxcloud/pkg/api"
+ 8apiTypes"go.anx.io/go-anxcloud/pkg/api/types"
+ 9"go.anx.io/go-anxcloud/pkg/client"
+10
+11// apis usable with the generic client have their own package in a location analog to this
+12lbaasv1"go.anx.io/go-anxcloud/pkg/apis/lbaas/v1"
+13)
+14
+15funcmain(){
+16apiClient,err:=api.NewAPI(
+17api.WithClientOptions(
+18// Get auth token from ANEXIA_TOKEN environment variable.
+19// The boolean parameter specifies if the environment variable should be unset.
+20client.TokenFromEnv(false),
+21),
+22)
+23iferr!=nil{
+24log.Fatalf("Error creating ANX API client: %v",err)
+25}
+26
+27// let's list LBaaS backends of a known LoadBalancer
+28frontend:=lbaasv1.Frontend{
+29LoadBalancer:&lbaasv1.LoadBalancer{Identifier:"285b954fdf2a449c8fdae01cc6074025"},
+30}
+31
+32varfrontendsapiTypes.ObjectChannel
+33err=apiClient.List(context.TODO(),&frontend,
+34// Listing can be done with either a page iterator or a channel, we use a channel here.
+35api.ObjectChannel(&frontends),
+36
+37// Most APIs only give a very small subset when listing resources, add this flag to
+38// get all attributes, at the cost of doing lots of API requests.
+39api.FullObjects(true),
+40)
+41iferr!=nil{
+42log.Fatalf("Error listing backends for LoadBalancer '%v': %v",frontend.LoadBalancer.Identifier,err)
+43}
+44
+45forretriever:=rangefrontends{
+46// reinitialise frontend every loop to reset pointers and avoid potential overwriting of data in the next loop
+47varfrontendlbaasv1.Frontend
+48iferr:=retriever(&frontend);err!=nil{
+49log.Fatalf("Error retrieving Frontend: %v",err)
+50}
+51
+52log.Printf("Got Frontend named '%v' with mode '%v'",frontend.Name,frontend.Mode)
+53}
+54}
+
This new generic client will one day be the only client in go-anxcloud. The legacy API-specific clients are deprecated and will be removed in the
+go-anxcloud release following the one with all APIs go-anxcloud supports usable with the generic client (so if the generic client in 0.5.0 supports
+at least everything there is another client for in go-anxcloud, 0.6.0 will drop the API-specific clients).
+
+
1packagemain
+ 2
+ 3import(
+ 4"context"
+ 5"fmt"
+ 6"time"
+ 7
+ 8anexia"go.anx.io/go-anxcloud/pkg"
+ 9"go.anx.io/go-anxcloud/pkg/client"
+10"go.anx.io/go-anxcloud/pkg/vsphere/provisioning/vm"
+11)
+12
+13funcmain(){
+14vlan:="<ID of the VLAN the VM should have access to>"
+15location:="<ID of the location the VM should be in>"
+16
+17// Create client using the auth token in environment variable ANEXIA_TOKEN and do not unset the environment variable.
+18c,err:=client.New(client.AuthFromEnv(false))
+19iferr!=nil{
+20panic(fmt.Sprintf("could not create client: %v",err))
+21}
+22
+23// Get some API.
+24provisioning:=anexia.NewAPI(c).VSphere().Provisioning()
+25
+26// Time out after 30 minutes. Yes it really takes that long sometimes.
+27ctx,cancel:=context.WithTimeout(context.Background(),30*time.Minute)
+28// Look for a free ip in the given VLAN. This IP is not reserved for you so better be quick.
+29ips,err:=provisioning.IPs().GetFree(ctx,location,vlan)
+30defercancel()
+31iferr!=nil{
+32panic(fmt.Sprintf("provisioning vm failed: %v",err))
+33}
+34iflen(ips)<1{
+35panic(fmt.Sprintf("no IPs left for testing in vlan"))
+36}
+37
+38// Create a NIC for the VM and connect it to the VLAN.
+39networkInterfaces:=[]vm.Network{{NICType:"vmxnet3",IPs:[]string{ips[0].Identifier},VLAN:vlan}}
+40// Create the definition of the new VM. The ID you see here is Flatcar.
+41definition:=vm.NewAPI(c).NewDefinition(location,"template","44b38284-6adb-430e-b4a4-1553e29f352f","developersfirstvm",2,2048,10,networkInterfaces)
+42definition.SSH="<your SSH pub key>"
+43
+44// Provision the VM.
+45provisionResponse,err:=provisioning.VM().Provision(ctx,definition)
+46iferr!=nil{
+47panic(fmt.Sprintf("provisioning vm failed: %v",err))
+48}
+49
+50// Wait for the VM to be ready.
+51_,err=provisioning.Progress().AwaitCompletion(ctx,provisionResponse.Identifier)
+52iferr!=nil{
+53panic(fmt.Sprintf("waiting for VM provisioning failed: %v",err))
+54}
+55}
+
+
+
+
+
+
\ No newline at end of file
diff --git a/go-anxcloud/README.md@v0.1.0/index.html b/go-anxcloud/README.md@v0.1.0/index.html
new file mode 100644
index 0000000000..63cc6bf58a
--- /dev/null
+++ b/go-anxcloud/README.md@v0.1.0/index.html
@@ -0,0 +1,221 @@
+
+
+
+ go.anx.io/go-anxcloud - anxcloud
+
+
+
+
+
+
+
+
+
+
+
go.anx.io/go-anxcloud
+
+
+
+
+
anxcloud
+
go client for anexia engine
+
+
+
+
+
\ No newline at end of file
diff --git a/go-anxcloud/README.md@v0.2.0/index.html b/go-anxcloud/README.md@v0.2.0/index.html
new file mode 100644
index 0000000000..10850cbb8d
--- /dev/null
+++ b/go-anxcloud/README.md@v0.2.0/index.html
@@ -0,0 +1,221 @@
+
+
+
+ go.anx.io/go-anxcloud - anxcloud
+
+
+
+
+
+
+
+
+
+
+
go.anx.io/go-anxcloud
+
+
+
+
+
anxcloud
+
go client for anexia engine
+
+
+
+
+
\ No newline at end of file
diff --git a/go-anxcloud/README.md@v0.3.0/index.html b/go-anxcloud/README.md@v0.3.0/index.html
new file mode 100644
index 0000000000..858b475672
--- /dev/null
+++ b/go-anxcloud/README.md@v0.3.0/index.html
@@ -0,0 +1,221 @@
+
+
+
+ go.anx.io/go-anxcloud - anxcloud
+
+
+
+
+
+
+
+
+
+
+
go.anx.io/go-anxcloud
+
+
+
+
+
anxcloud
+
go client for anexia engine
+
+
+
+
+
\ No newline at end of file
diff --git a/go-anxcloud/README.md@v0.3.1/index.html b/go-anxcloud/README.md@v0.3.1/index.html
new file mode 100644
index 0000000000..8613548b7f
--- /dev/null
+++ b/go-anxcloud/README.md@v0.3.1/index.html
@@ -0,0 +1,221 @@
+
+
+
+ go.anx.io/go-anxcloud - anxcloud
+
+
+
+
+
+
+
+
+
+
+
go.anx.io/go-anxcloud
+
+
+
+
+
anxcloud
+
go client for anexia engine
+
+
+
+
+
\ No newline at end of file
diff --git a/go-anxcloud/README.md@v0.3.10/index.html b/go-anxcloud/README.md@v0.3.10/index.html
new file mode 100644
index 0000000000..1cc99d881c
--- /dev/null
+++ b/go-anxcloud/README.md@v0.3.10/index.html
@@ -0,0 +1,285 @@
+
+
+
+ go.anx.io/go-anxcloud - Go Client for the Anexia API
+
+
+
+
+
+
+
+
+
+
+
go.anx.io/go-anxcloud
+
+
+
+
+
+
Go Client for the Anexia API
+
Go SDK for interacting with the Anexia multi purpose API.
+
Installing
+
To use the SDK, just add github.com/anexia-it/go-anxcloud <version> to your Go module.
+
Getting started
+
Before using the SDK you should familiarize yourself with the API. See here for more info.
+I you crave for an example, take a look at the terraform provider for this project
+
Example
+
The following code shows how to create a VM. To be able to do that you need to set the environment variable ANEXIA_TOKEN to your access token.
+Afterwards you can run the following.
+
1packagemain
+ 2
+ 3import(
+ 4"context"
+ 5"fmt"
+ 6"time"
+ 7
+ 8anexia"github.com/anexia-it/go-anxcloud/pkg"
+ 9"github.com/anexia-it/go-anxcloud/pkg/client"
+10"github.com/anexia-it/go-anxcloud/pkg/vsphere/provisioning/vm"
+11)
+12
+13funcmain(){
+14vlan:="<ID of the VLAN the VM should have access to>"
+15location:="<ID of the location the VM should be in>"
+16
+17// Create client from environment variables, do not unset env afterwards.
+18c,err:=client.New(client.AuthFromEnv(false))
+19iferr!=nil{
+20panic(fmt.Sprintf("could not create client: %v",err))
+21}
+22
+23// Get some API.
+24provisioning:=anexia.NewAPI(c).VSphere().Provisioning()
+25
+26// Time out after 30 minutes. Yes it really takes that long sometimes.
+27ctx,cancel:=context.WithTimeout(context.Background(),30*time.Minute)
+28// Look for a free ip in the given VLAN. This IP is not reserved for you so better be quick.
+29ips,err:=provisioning.IPs().GetFree(ctx,location,vlan)
+30defercancel()
+31iferr!=nil{
+32panic(fmt.Sprintf("provisioning vm failed: %v",err))
+33}
+34iflen(ips)<1{
+35panic(fmt.Sprintf("no IPs left for testing in vlan"))
+36}
+37
+38// Create a NIC for the VM and connect it to the VLAN.
+39networkInterfaces:=[]vm.Network{{NICType:"vmxnet3",IPs:[]string{ips[0].Identifier},VLAN:vlan}}
+40// Create the definition of the new VM. The ID you see here is Flatcar.
+41definition:=vm.NewAPI(c).NewDefinition(location,"template","44b38284-6adb-430e-b4a4-1553e29f352f","developersfirstvm",2,2048,10,networkInterfaces)
+42definition.SSH="<your SSH pub key>"
+43
+44// Provision the VM.
+45provisionResponse,err:=provisioning.VM().Provision(ctx,definition)
+46iferr!=nil{
+47panic(fmt.Sprintf("provisioning vm failed: %v",err))
+48}
+49
+50// Wait for the VM to be ready.
+51_,err=provisioning.Progress().AwaitCompletion(ctx,provisionResponse.Identifier)
+52iferr!=nil{
+53panic(fmt.Sprintf("waiting for VM provisioning failed: %v",err))
+54}
+55}
+
+
+
+
+
\ No newline at end of file
diff --git a/go-anxcloud/README.md@v0.3.11/index.html b/go-anxcloud/README.md@v0.3.11/index.html
new file mode 100644
index 0000000000..e21012604e
--- /dev/null
+++ b/go-anxcloud/README.md@v0.3.11/index.html
@@ -0,0 +1,285 @@
+
+
+
+ go.anx.io/go-anxcloud - Go Client for the Anexia API
+
+
+
+
+
+
+
+
+
+
+
go.anx.io/go-anxcloud
+
+
+
+
+
+
Go Client for the Anexia API
+
Go SDK for interacting with the Anexia multi purpose API.
+
Installing
+
To use the SDK, just add github.com/anexia-it/go-anxcloud <version> to your Go module.
+
Getting started
+
Before using the SDK you should familiarize yourself with the API. See here for more info.
+I you crave for an example, take a look at the terraform provider for this project
+
Example
+
The following code shows how to create a VM. To be able to do that you need to set the environment variable ANEXIA_TOKEN to your access token.
+Afterwards you can run the following.
+
1packagemain
+ 2
+ 3import(
+ 4"context"
+ 5"fmt"
+ 6"time"
+ 7
+ 8anexia"github.com/anexia-it/go-anxcloud/pkg"
+ 9"github.com/anexia-it/go-anxcloud/pkg/client"
+10"github.com/anexia-it/go-anxcloud/pkg/vsphere/provisioning/vm"
+11)
+12
+13funcmain(){
+14vlan:="<ID of the VLAN the VM should have access to>"
+15location:="<ID of the location the VM should be in>"
+16
+17// Create client from environment variables, do not unset env afterwards.
+18c,err:=client.New(client.AuthFromEnv(false))
+19iferr!=nil{
+20panic(fmt.Sprintf("could not create client: %v",err))
+21}
+22
+23// Get some API.
+24provisioning:=anexia.NewAPI(c).VSphere().Provisioning()
+25
+26// Time out after 30 minutes. Yes it really takes that long sometimes.
+27ctx,cancel:=context.WithTimeout(context.Background(),30*time.Minute)
+28// Look for a free ip in the given VLAN. This IP is not reserved for you so better be quick.
+29ips,err:=provisioning.IPs().GetFree(ctx,location,vlan)
+30defercancel()
+31iferr!=nil{
+32panic(fmt.Sprintf("provisioning vm failed: %v",err))
+33}
+34iflen(ips)<1{
+35panic(fmt.Sprintf("no IPs left for testing in vlan"))
+36}
+37
+38// Create a NIC for the VM and connect it to the VLAN.
+39networkInterfaces:=[]vm.Network{{NICType:"vmxnet3",IPs:[]string{ips[0].Identifier},VLAN:vlan}}
+40// Create the definition of the new VM. The ID you see here is Flatcar.
+41definition:=vm.NewAPI(c).NewDefinition(location,"template","44b38284-6adb-430e-b4a4-1553e29f352f","developersfirstvm",2,2048,10,networkInterfaces)
+42definition.SSH="<your SSH pub key>"
+43
+44// Provision the VM.
+45provisionResponse,err:=provisioning.VM().Provision(ctx,definition)
+46iferr!=nil{
+47panic(fmt.Sprintf("provisioning vm failed: %v",err))
+48}
+49
+50// Wait for the VM to be ready.
+51_,err=provisioning.Progress().AwaitCompletion(ctx,provisionResponse.Identifier)
+52iferr!=nil{
+53panic(fmt.Sprintf("waiting for VM provisioning failed: %v",err))
+54}
+55}
+
+
+
+
+
\ No newline at end of file
diff --git a/go-anxcloud/README.md@v0.3.12/index.html b/go-anxcloud/README.md@v0.3.12/index.html
new file mode 100644
index 0000000000..28a404ab03
--- /dev/null
+++ b/go-anxcloud/README.md@v0.3.12/index.html
@@ -0,0 +1,285 @@
+
+
+
+ go.anx.io/go-anxcloud - Go Client for the Anexia API
+
+
+
+
+
+
+
+
+
+
+
go.anx.io/go-anxcloud
+
+
+
+
+
+
Go Client for the Anexia API
+
Go SDK for interacting with the Anexia multi purpose API.
+
Installing
+
To use the SDK, just add github.com/anexia-it/go-anxcloud <version> to your Go module.
+
Getting started
+
Before using the SDK you should familiarize yourself with the API. See here for more info.
+I you crave for an example, take a look at the terraform provider for this project
+
Example
+
The following code shows how to create a VM. To be able to do that you need to set the environment variable ANEXIA_TOKEN to your access token.
+Afterwards you can run the following.
+
1packagemain
+ 2
+ 3import(
+ 4"context"
+ 5"fmt"
+ 6"time"
+ 7
+ 8anexia"github.com/anexia-it/go-anxcloud/pkg"
+ 9"github.com/anexia-it/go-anxcloud/pkg/client"
+10"github.com/anexia-it/go-anxcloud/pkg/vsphere/provisioning/vm"
+11)
+12
+13funcmain(){
+14vlan:="<ID of the VLAN the VM should have access to>"
+15location:="<ID of the location the VM should be in>"
+16
+17// Create client from environment variables, do not unset env afterwards.
+18c,err:=client.New(client.AuthFromEnv(false))
+19iferr!=nil{
+20panic(fmt.Sprintf("could not create client: %v",err))
+21}
+22
+23// Get some API.
+24provisioning:=anexia.NewAPI(c).VSphere().Provisioning()
+25
+26// Time out after 30 minutes. Yes it really takes that long sometimes.
+27ctx,cancel:=context.WithTimeout(context.Background(),30*time.Minute)
+28// Look for a free ip in the given VLAN. This IP is not reserved for you so better be quick.
+29ips,err:=provisioning.IPs().GetFree(ctx,location,vlan)
+30defercancel()
+31iferr!=nil{
+32panic(fmt.Sprintf("provisioning vm failed: %v",err))
+33}
+34iflen(ips)<1{
+35panic(fmt.Sprintf("no IPs left for testing in vlan"))
+36}
+37
+38// Create a NIC for the VM and connect it to the VLAN.
+39networkInterfaces:=[]vm.Network{{NICType:"vmxnet3",IPs:[]string{ips[0].Identifier},VLAN:vlan}}
+40// Create the definition of the new VM. The ID you see here is Flatcar.
+41definition:=vm.NewAPI(c).NewDefinition(location,"template","44b38284-6adb-430e-b4a4-1553e29f352f","developersfirstvm",2,2048,10,networkInterfaces)
+42definition.SSH="<your SSH pub key>"
+43
+44// Provision the VM.
+45provisionResponse,err:=provisioning.VM().Provision(ctx,definition)
+46iferr!=nil{
+47panic(fmt.Sprintf("provisioning vm failed: %v",err))
+48}
+49
+50// Wait for the VM to be ready.
+51_,err=provisioning.Progress().AwaitCompletion(ctx,provisionResponse.Identifier)
+52iferr!=nil{
+53panic(fmt.Sprintf("waiting for VM provisioning failed: %v",err))
+54}
+55}
+
+
+
+
+
\ No newline at end of file
diff --git a/go-anxcloud/README.md@v0.3.13/index.html b/go-anxcloud/README.md@v0.3.13/index.html
new file mode 100644
index 0000000000..14ae88c505
--- /dev/null
+++ b/go-anxcloud/README.md@v0.3.13/index.html
@@ -0,0 +1,285 @@
+
+
+
+ go.anx.io/go-anxcloud - Go Client for the Anexia API
+
+
+
+
+
+
+
+
+
+
+
go.anx.io/go-anxcloud
+
+
+
+
+
+
Go Client for the Anexia API
+
Go SDK for interacting with the Anexia multi purpose API.
+
Installing
+
To use the SDK, just add github.com/anexia-it/go-anxcloud <version> to your Go module.
+
Getting started
+
Before using the SDK you should familiarize yourself with the API. See here for more info.
+I you crave for an example, take a look at the terraform provider for this project
+
Example
+
The following code shows how to create a VM. To be able to do that you need to set the environment variable ANEXIA_TOKEN to your access token.
+Afterwards you can run the following.
+
1packagemain
+ 2
+ 3import(
+ 4"context"
+ 5"fmt"
+ 6"time"
+ 7
+ 8anexia"github.com/anexia-it/go-anxcloud/pkg"
+ 9"github.com/anexia-it/go-anxcloud/pkg/client"
+10"github.com/anexia-it/go-anxcloud/pkg/vsphere/provisioning/vm"
+11)
+12
+13funcmain(){
+14vlan:="<ID of the VLAN the VM should have access to>"
+15location:="<ID of the location the VM should be in>"
+16
+17// Create client from environment variables, do not unset env afterwards.
+18c,err:=client.New(client.AuthFromEnv(false))
+19iferr!=nil{
+20panic(fmt.Sprintf("could not create client: %v",err))
+21}
+22
+23// Get some API.
+24provisioning:=anexia.NewAPI(c).VSphere().Provisioning()
+25
+26// Time out after 30 minutes. Yes it really takes that long sometimes.
+27ctx,cancel:=context.WithTimeout(context.Background(),30*time.Minute)
+28// Look for a free ip in the given VLAN. This IP is not reserved for you so better be quick.
+29ips,err:=provisioning.IPs().GetFree(ctx,location,vlan)
+30defercancel()
+31iferr!=nil{
+32panic(fmt.Sprintf("provisioning vm failed: %v",err))
+33}
+34iflen(ips)<1{
+35panic(fmt.Sprintf("no IPs left for testing in vlan"))
+36}
+37
+38// Create a NIC for the VM and connect it to the VLAN.
+39networkInterfaces:=[]vm.Network{{NICType:"vmxnet3",IPs:[]string{ips[0].Identifier},VLAN:vlan}}
+40// Create the definition of the new VM. The ID you see here is Flatcar.
+41definition:=vm.NewAPI(c).NewDefinition(location,"template","44b38284-6adb-430e-b4a4-1553e29f352f","developersfirstvm",2,2048,10,networkInterfaces)
+42definition.SSH="<your SSH pub key>"
+43
+44// Provision the VM.
+45provisionResponse,err:=provisioning.VM().Provision(ctx,definition)
+46iferr!=nil{
+47panic(fmt.Sprintf("provisioning vm failed: %v",err))
+48}
+49
+50// Wait for the VM to be ready.
+51_,err=provisioning.Progress().AwaitCompletion(ctx,provisionResponse.Identifier)
+52iferr!=nil{
+53panic(fmt.Sprintf("waiting for VM provisioning failed: %v",err))
+54}
+55}
+
+
+
+
+
\ No newline at end of file
diff --git a/go-anxcloud/README.md@v0.3.14/index.html b/go-anxcloud/README.md@v0.3.14/index.html
new file mode 100644
index 0000000000..1e0de7c697
--- /dev/null
+++ b/go-anxcloud/README.md@v0.3.14/index.html
@@ -0,0 +1,285 @@
+
+
+
+ go.anx.io/go-anxcloud - Go Client for the Anexia API
+
+
+
+
+
+
+
+
+
+
+
go.anx.io/go-anxcloud
+
+
+
+
+
+
Go Client for the Anexia API
+
Go SDK for interacting with the Anexia multi purpose API.
+
Installing
+
To use the SDK, just add github.com/anexia-it/go-anxcloud <version> to your Go module.
+
Getting started
+
Before using the SDK you should familiarize yourself with the API. See here for more info.
+I you crave for an example, take a look at the terraform provider for this project
+
Example
+
The following code shows how to create a VM. To be able to do that you need to set the environment variable ANEXIA_TOKEN to your access token.
+Afterwards you can run the following.
+
1packagemain
+ 2
+ 3import(
+ 4"context"
+ 5"fmt"
+ 6"time"
+ 7
+ 8anexia"github.com/anexia-it/go-anxcloud/pkg"
+ 9"github.com/anexia-it/go-anxcloud/pkg/client"
+10"github.com/anexia-it/go-anxcloud/pkg/vsphere/provisioning/vm"
+11)
+12
+13funcmain(){
+14vlan:="<ID of the VLAN the VM should have access to>"
+15location:="<ID of the location the VM should be in>"
+16
+17// Create client from environment variables, do not unset env afterwards.
+18c,err:=client.New(client.AuthFromEnv(false))
+19iferr!=nil{
+20panic(fmt.Sprintf("could not create client: %v",err))
+21}
+22
+23// Get some API.
+24provisioning:=anexia.NewAPI(c).VSphere().Provisioning()
+25
+26// Time out after 30 minutes. Yes it really takes that long sometimes.
+27ctx,cancel:=context.WithTimeout(context.Background(),30*time.Minute)
+28// Look for a free ip in the given VLAN. This IP is not reserved for you so better be quick.
+29ips,err:=provisioning.IPs().GetFree(ctx,location,vlan)
+30defercancel()
+31iferr!=nil{
+32panic(fmt.Sprintf("provisioning vm failed: %v",err))
+33}
+34iflen(ips)<1{
+35panic(fmt.Sprintf("no IPs left for testing in vlan"))
+36}
+37
+38// Create a NIC for the VM and connect it to the VLAN.
+39networkInterfaces:=[]vm.Network{{NICType:"vmxnet3",IPs:[]string{ips[0].Identifier},VLAN:vlan}}
+40// Create the definition of the new VM. The ID you see here is Flatcar.
+41definition:=vm.NewAPI(c).NewDefinition(location,"template","44b38284-6adb-430e-b4a4-1553e29f352f","developersfirstvm",2,2048,10,networkInterfaces)
+42definition.SSH="<your SSH pub key>"
+43
+44// Provision the VM.
+45provisionResponse,err:=provisioning.VM().Provision(ctx,definition)
+46iferr!=nil{
+47panic(fmt.Sprintf("provisioning vm failed: %v",err))
+48}
+49
+50// Wait for the VM to be ready.
+51_,err=provisioning.Progress().AwaitCompletion(ctx,provisionResponse.Identifier)
+52iferr!=nil{
+53panic(fmt.Sprintf("waiting for VM provisioning failed: %v",err))
+54}
+55}
+
+
+
+
+
\ No newline at end of file
diff --git a/go-anxcloud/README.md@v0.3.15/index.html b/go-anxcloud/README.md@v0.3.15/index.html
new file mode 100644
index 0000000000..4d83b769ce
--- /dev/null
+++ b/go-anxcloud/README.md@v0.3.15/index.html
@@ -0,0 +1,285 @@
+
+
+
+ go.anx.io/go-anxcloud - Go Client for the Anexia API
+
+
+
+
+
+
+
+
+
+
+
go.anx.io/go-anxcloud
+
+
+
+
+
+
Go Client for the Anexia API
+
Go SDK for interacting with the Anexia multi purpose API.
+
Installing
+
To use the SDK, just add github.com/anexia-it/go-anxcloud <version> to your Go module.
+
Getting started
+
Before using the SDK you should familiarize yourself with the API. See here for more info.
+I you crave for an example, take a look at the terraform provider for this project
+
Example
+
The following code shows how to create a VM. To be able to do that you need to set the environment variable ANEXIA_TOKEN to your access token.
+Afterwards you can run the following.
+
1packagemain
+ 2
+ 3import(
+ 4"context"
+ 5"fmt"
+ 6"time"
+ 7
+ 8anexia"github.com/anexia-it/go-anxcloud/pkg"
+ 9"github.com/anexia-it/go-anxcloud/pkg/client"
+10"github.com/anexia-it/go-anxcloud/pkg/vsphere/provisioning/vm"
+11)
+12
+13funcmain(){
+14vlan:="<ID of the VLAN the VM should have access to>"
+15location:="<ID of the location the VM should be in>"
+16
+17// Create client from environment variables, do not unset env afterwards.
+18c,err:=client.New(client.AuthFromEnv(false))
+19iferr!=nil{
+20panic(fmt.Sprintf("could not create client: %v",err))
+21}
+22
+23// Get some API.
+24provisioning:=anexia.NewAPI(c).VSphere().Provisioning()
+25
+26// Time out after 30 minutes. Yes it really takes that long sometimes.
+27ctx,cancel:=context.WithTimeout(context.Background(),30*time.Minute)
+28// Look for a free ip in the given VLAN. This IP is not reserved for you so better be quick.
+29ips,err:=provisioning.IPs().GetFree(ctx,location,vlan)
+30defercancel()
+31iferr!=nil{
+32panic(fmt.Sprintf("provisioning vm failed: %v",err))
+33}
+34iflen(ips)<1{
+35panic(fmt.Sprintf("no IPs left for testing in vlan"))
+36}
+37
+38// Create a NIC for the VM and connect it to the VLAN.
+39networkInterfaces:=[]vm.Network{{NICType:"vmxnet3",IPs:[]string{ips[0].Identifier},VLAN:vlan}}
+40// Create the definition of the new VM. The ID you see here is Flatcar.
+41definition:=vm.NewAPI(c).NewDefinition(location,"template","44b38284-6adb-430e-b4a4-1553e29f352f","developersfirstvm",2,2048,10,networkInterfaces)
+42definition.SSH="<your SSH pub key>"
+43
+44// Provision the VM.
+45provisionResponse,err:=provisioning.VM().Provision(ctx,definition)
+46iferr!=nil{
+47panic(fmt.Sprintf("provisioning vm failed: %v",err))
+48}
+49
+50// Wait for the VM to be ready.
+51_,err=provisioning.Progress().AwaitCompletion(ctx,provisionResponse.Identifier)
+52iferr!=nil{
+53panic(fmt.Sprintf("waiting for VM provisioning failed: %v",err))
+54}
+55}
+
+
+
+
+
\ No newline at end of file
diff --git a/go-anxcloud/README.md@v0.3.16/index.html b/go-anxcloud/README.md@v0.3.16/index.html
new file mode 100644
index 0000000000..53ae0ca20c
--- /dev/null
+++ b/go-anxcloud/README.md@v0.3.16/index.html
@@ -0,0 +1,285 @@
+
+
+
+ go.anx.io/go-anxcloud - Go Client for the Anexia API
+
+
+
+
+
+
+
+
+
+
+
go.anx.io/go-anxcloud
+
+
+
+
+
+
Go Client for the Anexia API
+
Go SDK for interacting with the Anexia multi purpose API.
+
Installing
+
To use the SDK, just add github.com/anexia-it/go-anxcloud <version> to your Go module.
+
Getting started
+
Before using the SDK you should familiarize yourself with the API. See here for more info.
+I you crave for an example, take a look at the terraform provider for this project
+
Example
+
The following code shows how to create a VM. To be able to do that you need to set the environment variable ANEXIA_TOKEN to your access token.
+Afterwards you can run the following.
+
1packagemain
+ 2
+ 3import(
+ 4"context"
+ 5"fmt"
+ 6"time"
+ 7
+ 8anexia"github.com/anexia-it/go-anxcloud/pkg"
+ 9"github.com/anexia-it/go-anxcloud/pkg/client"
+10"github.com/anexia-it/go-anxcloud/pkg/vsphere/provisioning/vm"
+11)
+12
+13funcmain(){
+14vlan:="<ID of the VLAN the VM should have access to>"
+15location:="<ID of the location the VM should be in>"
+16
+17// Create client from environment variables, do not unset env afterwards.
+18c,err:=client.New(client.AuthFromEnv(false))
+19iferr!=nil{
+20panic(fmt.Sprintf("could not create client: %v",err))
+21}
+22
+23// Get some API.
+24provisioning:=anexia.NewAPI(c).VSphere().Provisioning()
+25
+26// Time out after 30 minutes. Yes it really takes that long sometimes.
+27ctx,cancel:=context.WithTimeout(context.Background(),30*time.Minute)
+28// Look for a free ip in the given VLAN. This IP is not reserved for you so better be quick.
+29ips,err:=provisioning.IPs().GetFree(ctx,location,vlan)
+30defercancel()
+31iferr!=nil{
+32panic(fmt.Sprintf("provisioning vm failed: %v",err))
+33}
+34iflen(ips)<1{
+35panic(fmt.Sprintf("no IPs left for testing in vlan"))
+36}
+37
+38// Create a NIC for the VM and connect it to the VLAN.
+39networkInterfaces:=[]vm.Network{{NICType:"vmxnet3",IPs:[]string{ips[0].Identifier},VLAN:vlan}}
+40// Create the definition of the new VM. The ID you see here is Flatcar.
+41definition:=vm.NewAPI(c).NewDefinition(location,"template","44b38284-6adb-430e-b4a4-1553e29f352f","developersfirstvm",2,2048,10,networkInterfaces)
+42definition.SSH="<your SSH pub key>"
+43
+44// Provision the VM.
+45provisionResponse,err:=provisioning.VM().Provision(ctx,definition)
+46iferr!=nil{
+47panic(fmt.Sprintf("provisioning vm failed: %v",err))
+48}
+49
+50// Wait for the VM to be ready.
+51_,err=provisioning.Progress().AwaitCompletion(ctx,provisionResponse.Identifier)
+52iferr!=nil{
+53panic(fmt.Sprintf("waiting for VM provisioning failed: %v",err))
+54}
+55}
+
+
+
+
+
\ No newline at end of file
diff --git a/go-anxcloud/README.md@v0.3.17/index.html b/go-anxcloud/README.md@v0.3.17/index.html
new file mode 100644
index 0000000000..d7380ed999
--- /dev/null
+++ b/go-anxcloud/README.md@v0.3.17/index.html
@@ -0,0 +1,285 @@
+
+
+
+ go.anx.io/go-anxcloud - Go Client for the Anexia API
+
+
+
+
+
+
+
+
+
+
+
go.anx.io/go-anxcloud
+
+
+
+
+
+
Go Client for the Anexia API
+
Go SDK for interacting with the Anexia multi purpose API.
+
Installing
+
To use the SDK, just add github.com/anexia-it/go-anxcloud <version> to your Go module.
+
Getting started
+
Before using the SDK you should familiarize yourself with the API. See here for more info.
+I you crave for an example, take a look at the terraform provider for this project
+
Example
+
The following code shows how to create a VM. To be able to do that you need to set the environment variable ANEXIA_TOKEN to your access token.
+Afterwards you can run the following.
+
1packagemain
+ 2
+ 3import(
+ 4"context"
+ 5"fmt"
+ 6"time"
+ 7
+ 8anexia"github.com/anexia-it/go-anxcloud/pkg"
+ 9"github.com/anexia-it/go-anxcloud/pkg/client"
+10"github.com/anexia-it/go-anxcloud/pkg/vsphere/provisioning/vm"
+11)
+12
+13funcmain(){
+14vlan:="<ID of the VLAN the VM should have access to>"
+15location:="<ID of the location the VM should be in>"
+16
+17// Create client from environment variables, do not unset env afterwards.
+18c,err:=client.New(client.AuthFromEnv(false))
+19iferr!=nil{
+20panic(fmt.Sprintf("could not create client: %v",err))
+21}
+22
+23// Get some API.
+24provisioning:=anexia.NewAPI(c).VSphere().Provisioning()
+25
+26// Time out after 30 minutes. Yes it really takes that long sometimes.
+27ctx,cancel:=context.WithTimeout(context.Background(),30*time.Minute)
+28// Look for a free ip in the given VLAN. This IP is not reserved for you so better be quick.
+29ips,err:=provisioning.IPs().GetFree(ctx,location,vlan)
+30defercancel()
+31iferr!=nil{
+32panic(fmt.Sprintf("provisioning vm failed: %v",err))
+33}
+34iflen(ips)<1{
+35panic(fmt.Sprintf("no IPs left for testing in vlan"))
+36}
+37
+38// Create a NIC for the VM and connect it to the VLAN.
+39networkInterfaces:=[]vm.Network{{NICType:"vmxnet3",IPs:[]string{ips[0].Identifier},VLAN:vlan}}
+40// Create the definition of the new VM. The ID you see here is Flatcar.
+41definition:=vm.NewAPI(c).NewDefinition(location,"template","44b38284-6adb-430e-b4a4-1553e29f352f","developersfirstvm",2,2048,10,networkInterfaces)
+42definition.SSH="<your SSH pub key>"
+43
+44// Provision the VM.
+45provisionResponse,err:=provisioning.VM().Provision(ctx,definition)
+46iferr!=nil{
+47panic(fmt.Sprintf("provisioning vm failed: %v",err))
+48}
+49
+50// Wait for the VM to be ready.
+51_,err=provisioning.Progress().AwaitCompletion(ctx,provisionResponse.Identifier)
+52iferr!=nil{
+53panic(fmt.Sprintf("waiting for VM provisioning failed: %v",err))
+54}
+55}
+
+
+
+
+
\ No newline at end of file
diff --git a/go-anxcloud/README.md@v0.3.18/index.html b/go-anxcloud/README.md@v0.3.18/index.html
new file mode 100644
index 0000000000..1d527ac7f0
--- /dev/null
+++ b/go-anxcloud/README.md@v0.3.18/index.html
@@ -0,0 +1,285 @@
+
+
+
+ go.anx.io/go-anxcloud - Go Client for the Anexia API
+
+
+
+
+
+
+
+
+
+
+
go.anx.io/go-anxcloud
+
+
+
+
+
+
Go Client for the Anexia API
+
Go SDK for interacting with the Anexia multi purpose API.
+
Installing
+
To use the SDK, just add github.com/anexia-it/go-anxcloud <version> to your Go module.
+
Getting started
+
Before using the SDK you should familiarize yourself with the API. See here for more info.
+I you crave for an example, take a look at the terraform provider for this project
+
Example
+
The following code shows how to create a VM. To be able to do that you need to set the environment variable ANEXIA_TOKEN to your access token.
+Afterwards you can run the following.
+
1packagemain
+ 2
+ 3import(
+ 4"context"
+ 5"fmt"
+ 6"time"
+ 7
+ 8anexia"github.com/anexia-it/go-anxcloud/pkg"
+ 9"github.com/anexia-it/go-anxcloud/pkg/client"
+10"github.com/anexia-it/go-anxcloud/pkg/vsphere/provisioning/vm"
+11)
+12
+13funcmain(){
+14vlan:="<ID of the VLAN the VM should have access to>"
+15location:="<ID of the location the VM should be in>"
+16
+17// Create client from environment variables, do not unset env afterwards.
+18c,err:=client.New(client.AuthFromEnv(false))
+19iferr!=nil{
+20panic(fmt.Sprintf("could not create client: %v",err))
+21}
+22
+23// Get some API.
+24provisioning:=anexia.NewAPI(c).VSphere().Provisioning()
+25
+26// Time out after 30 minutes. Yes it really takes that long sometimes.
+27ctx,cancel:=context.WithTimeout(context.Background(),30*time.Minute)
+28// Look for a free ip in the given VLAN. This IP is not reserved for you so better be quick.
+29ips,err:=provisioning.IPs().GetFree(ctx,location,vlan)
+30defercancel()
+31iferr!=nil{
+32panic(fmt.Sprintf("provisioning vm failed: %v",err))
+33}
+34iflen(ips)<1{
+35panic(fmt.Sprintf("no IPs left for testing in vlan"))
+36}
+37
+38// Create a NIC for the VM and connect it to the VLAN.
+39networkInterfaces:=[]vm.Network{{NICType:"vmxnet3",IPs:[]string{ips[0].Identifier},VLAN:vlan}}
+40// Create the definition of the new VM. The ID you see here is Flatcar.
+41definition:=vm.NewAPI(c).NewDefinition(location,"template","44b38284-6adb-430e-b4a4-1553e29f352f","developersfirstvm",2,2048,10,networkInterfaces)
+42definition.SSH="<your SSH pub key>"
+43
+44// Provision the VM.
+45provisionResponse,err:=provisioning.VM().Provision(ctx,definition)
+46iferr!=nil{
+47panic(fmt.Sprintf("provisioning vm failed: %v",err))
+48}
+49
+50// Wait for the VM to be ready.
+51_,err=provisioning.Progress().AwaitCompletion(ctx,provisionResponse.Identifier)
+52iferr!=nil{
+53panic(fmt.Sprintf("waiting for VM provisioning failed: %v",err))
+54}
+55}
+
+
+
+
+
\ No newline at end of file
diff --git a/go-anxcloud/README.md@v0.3.19/index.html b/go-anxcloud/README.md@v0.3.19/index.html
new file mode 100644
index 0000000000..f00bde3637
--- /dev/null
+++ b/go-anxcloud/README.md@v0.3.19/index.html
@@ -0,0 +1,285 @@
+
+
+
+ go.anx.io/go-anxcloud - Go Client for the Anexia API
+
+
+
+
+
+
+
+
+
+
+
go.anx.io/go-anxcloud
+
+
+
+
+
+
Go Client for the Anexia API
+
Go SDK for interacting with the Anexia multi purpose API.
+
Installing
+
To use the SDK, just add github.com/anexia-it/go-anxcloud <version> to your Go module.
+
Getting started
+
Before using the SDK you should familiarize yourself with the API. See here for more info.
+I you crave for an example, take a look at the terraform provider for this project
+
Example
+
The following code shows how to create a VM. To be able to do that you need to set the environment variable ANEXIA_TOKEN to your access token.
+Afterwards you can run the following.
+
1packagemain
+ 2
+ 3import(
+ 4"context"
+ 5"fmt"
+ 6"time"
+ 7
+ 8anexia"github.com/anexia-it/go-anxcloud/pkg"
+ 9"github.com/anexia-it/go-anxcloud/pkg/client"
+10"github.com/anexia-it/go-anxcloud/pkg/vsphere/provisioning/vm"
+11)
+12
+13funcmain(){
+14vlan:="<ID of the VLAN the VM should have access to>"
+15location:="<ID of the location the VM should be in>"
+16
+17// Create client from environment variables, do not unset env afterwards.
+18c,err:=client.New(client.AuthFromEnv(false))
+19iferr!=nil{
+20panic(fmt.Sprintf("could not create client: %v",err))
+21}
+22
+23// Get some API.
+24provisioning:=anexia.NewAPI(c).VSphere().Provisioning()
+25
+26// Time out after 30 minutes. Yes it really takes that long sometimes.
+27ctx,cancel:=context.WithTimeout(context.Background(),30*time.Minute)
+28// Look for a free ip in the given VLAN. This IP is not reserved for you so better be quick.
+29ips,err:=provisioning.IPs().GetFree(ctx,location,vlan)
+30defercancel()
+31iferr!=nil{
+32panic(fmt.Sprintf("provisioning vm failed: %v",err))
+33}
+34iflen(ips)<1{
+35panic(fmt.Sprintf("no IPs left for testing in vlan"))
+36}
+37
+38// Create a NIC for the VM and connect it to the VLAN.
+39networkInterfaces:=[]vm.Network{{NICType:"vmxnet3",IPs:[]string{ips[0].Identifier},VLAN:vlan}}
+40// Create the definition of the new VM. The ID you see here is Flatcar.
+41definition:=vm.NewAPI(c).NewDefinition(location,"template","44b38284-6adb-430e-b4a4-1553e29f352f","developersfirstvm",2,2048,10,networkInterfaces)
+42definition.SSH="<your SSH pub key>"
+43
+44// Provision the VM.
+45provisionResponse,err:=provisioning.VM().Provision(ctx,definition)
+46iferr!=nil{
+47panic(fmt.Sprintf("provisioning vm failed: %v",err))
+48}
+49
+50// Wait for the VM to be ready.
+51_,err=provisioning.Progress().AwaitCompletion(ctx,provisionResponse.Identifier)
+52iferr!=nil{
+53panic(fmt.Sprintf("waiting for VM provisioning failed: %v",err))
+54}
+55}
+
+
+
+
+
\ No newline at end of file
diff --git a/go-anxcloud/README.md@v0.3.2/index.html b/go-anxcloud/README.md@v0.3.2/index.html
new file mode 100644
index 0000000000..bc2fa54ec6
--- /dev/null
+++ b/go-anxcloud/README.md@v0.3.2/index.html
@@ -0,0 +1,221 @@
+
+
+
+ go.anx.io/go-anxcloud - anxcloud
+
+
+
+
+
+
+
+
+
+
+
go.anx.io/go-anxcloud
+
+
+
+
+
anxcloud
+
go client for anexia engine
+
+
+
+
+
\ No newline at end of file
diff --git a/go-anxcloud/README.md@v0.3.20/index.html b/go-anxcloud/README.md@v0.3.20/index.html
new file mode 100644
index 0000000000..1ff87f6392
--- /dev/null
+++ b/go-anxcloud/README.md@v0.3.20/index.html
@@ -0,0 +1,285 @@
+
+
+
+ go.anx.io/go-anxcloud - Go Client for the Anexia API
+
+
+
+
+
+
+
+
+
+
+
go.anx.io/go-anxcloud
+
+
+
+
+
+
Go Client for the Anexia API
+
Go SDK for interacting with the Anexia multi purpose API.
+
Installing
+
To use the SDK, just add github.com/anexia-it/go-anxcloud <version> to your Go module.
+
Getting started
+
Before using the SDK you should familiarize yourself with the API. See here for more info.
+I you crave for an example, take a look at the terraform provider for this project
+
Example
+
The following code shows how to create a VM. To be able to do that you need to set the environment variable ANEXIA_TOKEN to your access token.
+Afterwards you can run the following.
+
1packagemain
+ 2
+ 3import(
+ 4"context"
+ 5"fmt"
+ 6"time"
+ 7
+ 8anexia"github.com/anexia-it/go-anxcloud/pkg"
+ 9"github.com/anexia-it/go-anxcloud/pkg/client"
+10"github.com/anexia-it/go-anxcloud/pkg/vsphere/provisioning/vm"
+11)
+12
+13funcmain(){
+14vlan:="<ID of the VLAN the VM should have access to>"
+15location:="<ID of the location the VM should be in>"
+16
+17// Create client from environment variables, do not unset env afterwards.
+18c,err:=client.New(client.AuthFromEnv(false))
+19iferr!=nil{
+20panic(fmt.Sprintf("could not create client: %v",err))
+21}
+22
+23// Get some API.
+24provisioning:=anexia.NewAPI(c).VSphere().Provisioning()
+25
+26// Time out after 30 minutes. Yes it really takes that long sometimes.
+27ctx,cancel:=context.WithTimeout(context.Background(),30*time.Minute)
+28// Look for a free ip in the given VLAN. This IP is not reserved for you so better be quick.
+29ips,err:=provisioning.IPs().GetFree(ctx,location,vlan)
+30defercancel()
+31iferr!=nil{
+32panic(fmt.Sprintf("provisioning vm failed: %v",err))
+33}
+34iflen(ips)<1{
+35panic(fmt.Sprintf("no IPs left for testing in vlan"))
+36}
+37
+38// Create a NIC for the VM and connect it to the VLAN.
+39networkInterfaces:=[]vm.Network{{NICType:"vmxnet3",IPs:[]string{ips[0].Identifier},VLAN:vlan}}
+40// Create the definition of the new VM. The ID you see here is Flatcar.
+41definition:=vm.NewAPI(c).NewDefinition(location,"template","44b38284-6adb-430e-b4a4-1553e29f352f","developersfirstvm",2,2048,10,networkInterfaces)
+42definition.SSH="<your SSH pub key>"
+43
+44// Provision the VM.
+45provisionResponse,err:=provisioning.VM().Provision(ctx,definition)
+46iferr!=nil{
+47panic(fmt.Sprintf("provisioning vm failed: %v",err))
+48}
+49
+50// Wait for the VM to be ready.
+51_,err=provisioning.Progress().AwaitCompletion(ctx,provisionResponse.Identifier)
+52iferr!=nil{
+53panic(fmt.Sprintf("waiting for VM provisioning failed: %v",err))
+54}
+55}
+
+
+
+
+
\ No newline at end of file
diff --git a/go-anxcloud/README.md@v0.3.21/index.html b/go-anxcloud/README.md@v0.3.21/index.html
new file mode 100644
index 0000000000..1ab4c5e634
--- /dev/null
+++ b/go-anxcloud/README.md@v0.3.21/index.html
@@ -0,0 +1,285 @@
+
+
+
+ go.anx.io/go-anxcloud - Go Client for the Anexia API
+
+
+
+
+
+
+
+
+
+
+
go.anx.io/go-anxcloud
+
+
+
+
+
+
Go Client for the Anexia API
+
Go SDK for interacting with the Anexia multi purpose API.
+
Installing
+
To use the SDK, just add github.com/anexia-it/go-anxcloud <version> to your Go module.
+
Getting started
+
Before using the SDK you should familiarize yourself with the API. See here for more info.
+I you crave for an example, take a look at the terraform provider for this project
+
Example
+
The following code shows how to create a VM. To be able to do that you need to set the environment variable ANEXIA_TOKEN to your access token.
+Afterwards you can run the following.
+
1packagemain
+ 2
+ 3import(
+ 4"context"
+ 5"fmt"
+ 6"time"
+ 7
+ 8anexia"github.com/anexia-it/go-anxcloud/pkg"
+ 9"github.com/anexia-it/go-anxcloud/pkg/client"
+10"github.com/anexia-it/go-anxcloud/pkg/vsphere/provisioning/vm"
+11)
+12
+13funcmain(){
+14vlan:="<ID of the VLAN the VM should have access to>"
+15location:="<ID of the location the VM should be in>"
+16
+17// Create client from environment variables, do not unset env afterwards.
+18c,err:=client.New(client.AuthFromEnv(false))
+19iferr!=nil{
+20panic(fmt.Sprintf("could not create client: %v",err))
+21}
+22
+23// Get some API.
+24provisioning:=anexia.NewAPI(c).VSphere().Provisioning()
+25
+26// Time out after 30 minutes. Yes it really takes that long sometimes.
+27ctx,cancel:=context.WithTimeout(context.Background(),30*time.Minute)
+28// Look for a free ip in the given VLAN. This IP is not reserved for you so better be quick.
+29ips,err:=provisioning.IPs().GetFree(ctx,location,vlan)
+30defercancel()
+31iferr!=nil{
+32panic(fmt.Sprintf("provisioning vm failed: %v",err))
+33}
+34iflen(ips)<1{
+35panic(fmt.Sprintf("no IPs left for testing in vlan"))
+36}
+37
+38// Create a NIC for the VM and connect it to the VLAN.
+39networkInterfaces:=[]vm.Network{{NICType:"vmxnet3",IPs:[]string{ips[0].Identifier},VLAN:vlan}}
+40// Create the definition of the new VM. The ID you see here is Flatcar.
+41definition:=vm.NewAPI(c).NewDefinition(location,"template","44b38284-6adb-430e-b4a4-1553e29f352f","developersfirstvm",2,2048,10,networkInterfaces)
+42definition.SSH="<your SSH pub key>"
+43
+44// Provision the VM.
+45provisionResponse,err:=provisioning.VM().Provision(ctx,definition)
+46iferr!=nil{
+47panic(fmt.Sprintf("provisioning vm failed: %v",err))
+48}
+49
+50// Wait for the VM to be ready.
+51_,err=provisioning.Progress().AwaitCompletion(ctx,provisionResponse.Identifier)
+52iferr!=nil{
+53panic(fmt.Sprintf("waiting for VM provisioning failed: %v",err))
+54}
+55}
+
+
+
+
+
\ No newline at end of file
diff --git a/go-anxcloud/README.md@v0.3.22/index.html b/go-anxcloud/README.md@v0.3.22/index.html
new file mode 100644
index 0000000000..87bc2be756
--- /dev/null
+++ b/go-anxcloud/README.md@v0.3.22/index.html
@@ -0,0 +1,285 @@
+
+
+
+ go.anx.io/go-anxcloud - Go Client for the Anexia API
+
+
+
+
+
+
+
+
+
+
+
go.anx.io/go-anxcloud
+
+
+
+
+
+
Go Client for the Anexia API
+
Go SDK for interacting with the Anexia multi purpose API.
+
Installing
+
To use the SDK, just add github.com/anexia-it/go-anxcloud <version> to your Go module.
+
Getting started
+
Before using the SDK you should familiarize yourself with the API. See here for more info.
+I you crave for an example, take a look at the terraform provider for this project
+
Example
+
The following code shows how to create a VM. To be able to do that you need to set the environment variable ANEXIA_TOKEN to your access token.
+Afterwards you can run the following.
+
1packagemain
+ 2
+ 3import(
+ 4"context"
+ 5"fmt"
+ 6"time"
+ 7
+ 8anexia"github.com/anexia-it/go-anxcloud/pkg"
+ 9"github.com/anexia-it/go-anxcloud/pkg/client"
+10"github.com/anexia-it/go-anxcloud/pkg/vsphere/provisioning/vm"
+11)
+12
+13funcmain(){
+14vlan:="<ID of the VLAN the VM should have access to>"
+15location:="<ID of the location the VM should be in>"
+16
+17// Create client from environment variables, do not unset env afterwards.
+18c,err:=client.New(client.AuthFromEnv(false))
+19iferr!=nil{
+20panic(fmt.Sprintf("could not create client: %v",err))
+21}
+22
+23// Get some API.
+24provisioning:=anexia.NewAPI(c).VSphere().Provisioning()
+25
+26// Time out after 30 minutes. Yes it really takes that long sometimes.
+27ctx,cancel:=context.WithTimeout(context.Background(),30*time.Minute)
+28// Look for a free ip in the given VLAN. This IP is not reserved for you so better be quick.
+29ips,err:=provisioning.IPs().GetFree(ctx,location,vlan)
+30defercancel()
+31iferr!=nil{
+32panic(fmt.Sprintf("provisioning vm failed: %v",err))
+33}
+34iflen(ips)<1{
+35panic(fmt.Sprintf("no IPs left for testing in vlan"))
+36}
+37
+38// Create a NIC for the VM and connect it to the VLAN.
+39networkInterfaces:=[]vm.Network{{NICType:"vmxnet3",IPs:[]string{ips[0].Identifier},VLAN:vlan}}
+40// Create the definition of the new VM. The ID you see here is Flatcar.
+41definition:=vm.NewAPI(c).NewDefinition(location,"template","44b38284-6adb-430e-b4a4-1553e29f352f","developersfirstvm",2,2048,10,networkInterfaces)
+42definition.SSH="<your SSH pub key>"
+43
+44// Provision the VM.
+45provisionResponse,err:=provisioning.VM().Provision(ctx,definition)
+46iferr!=nil{
+47panic(fmt.Sprintf("provisioning vm failed: %v",err))
+48}
+49
+50// Wait for the VM to be ready.
+51_,err=provisioning.Progress().AwaitCompletion(ctx,provisionResponse.Identifier)
+52iferr!=nil{
+53panic(fmt.Sprintf("waiting for VM provisioning failed: %v",err))
+54}
+55}
+
+
+
+
+
\ No newline at end of file
diff --git a/go-anxcloud/README.md@v0.3.23/index.html b/go-anxcloud/README.md@v0.3.23/index.html
new file mode 100644
index 0000000000..e398a91b7e
--- /dev/null
+++ b/go-anxcloud/README.md@v0.3.23/index.html
@@ -0,0 +1,285 @@
+
+
+
+ go.anx.io/go-anxcloud - Go Client for the Anexia API
+
+
+
+
+
+
+
+
+
+
+
go.anx.io/go-anxcloud
+
+
+
+
+
+
Go Client for the Anexia API
+
Go SDK for interacting with the Anexia multi purpose API.
+
Installing
+
To use the SDK, just add github.com/anexia-it/go-anxcloud <version> to your Go module.
+
Getting started
+
Before using the SDK you should familiarize yourself with the API. See here for more info.
+I you crave for an example, take a look at the terraform provider for this project
+
Example
+
The following code shows how to create a VM. To be able to do that you need to set the environment variable ANEXIA_TOKEN to your access token.
+Afterwards you can run the following.
+
1packagemain
+ 2
+ 3import(
+ 4"context"
+ 5"fmt"
+ 6"time"
+ 7
+ 8anexia"github.com/anexia-it/go-anxcloud/pkg"
+ 9"github.com/anexia-it/go-anxcloud/pkg/client"
+10"github.com/anexia-it/go-anxcloud/pkg/vsphere/provisioning/vm"
+11)
+12
+13funcmain(){
+14vlan:="<ID of the VLAN the VM should have access to>"
+15location:="<ID of the location the VM should be in>"
+16
+17// Create client from environment variables, do not unset env afterwards.
+18c,err:=client.New(client.AuthFromEnv(false))
+19iferr!=nil{
+20panic(fmt.Sprintf("could not create client: %v",err))
+21}
+22
+23// Get some API.
+24provisioning:=anexia.NewAPI(c).VSphere().Provisioning()
+25
+26// Time out after 30 minutes. Yes it really takes that long sometimes.
+27ctx,cancel:=context.WithTimeout(context.Background(),30*time.Minute)
+28// Look for a free ip in the given VLAN. This IP is not reserved for you so better be quick.
+29ips,err:=provisioning.IPs().GetFree(ctx,location,vlan)
+30defercancel()
+31iferr!=nil{
+32panic(fmt.Sprintf("provisioning vm failed: %v",err))
+33}
+34iflen(ips)<1{
+35panic(fmt.Sprintf("no IPs left for testing in vlan"))
+36}
+37
+38// Create a NIC for the VM and connect it to the VLAN.
+39networkInterfaces:=[]vm.Network{{NICType:"vmxnet3",IPs:[]string{ips[0].Identifier},VLAN:vlan}}
+40// Create the definition of the new VM. The ID you see here is Flatcar.
+41definition:=vm.NewAPI(c).NewDefinition(location,"template","44b38284-6adb-430e-b4a4-1553e29f352f","developersfirstvm",2,2048,10,networkInterfaces)
+42definition.SSH="<your SSH pub key>"
+43
+44// Provision the VM.
+45provisionResponse,err:=provisioning.VM().Provision(ctx,definition)
+46iferr!=nil{
+47panic(fmt.Sprintf("provisioning vm failed: %v",err))
+48}
+49
+50// Wait for the VM to be ready.
+51_,err=provisioning.Progress().AwaitCompletion(ctx,provisionResponse.Identifier)
+52iferr!=nil{
+53panic(fmt.Sprintf("waiting for VM provisioning failed: %v",err))
+54}
+55}
+
+
+
+
+
\ No newline at end of file
diff --git a/go-anxcloud/README.md@v0.3.24/index.html b/go-anxcloud/README.md@v0.3.24/index.html
new file mode 100644
index 0000000000..affc0d1e18
--- /dev/null
+++ b/go-anxcloud/README.md@v0.3.24/index.html
@@ -0,0 +1,285 @@
+
+
+
+ go.anx.io/go-anxcloud - Go Client for the Anexia API
+
+
+
+
+
+
+
+
+
+
+
go.anx.io/go-anxcloud
+
+
+
+
+
+
Go Client for the Anexia API
+
Go SDK for interacting with the Anexia multi purpose API.
+
Installing
+
To use the SDK, just add github.com/anexia-it/go-anxcloud <version> to your Go module.
+
Getting started
+
Before using the SDK you should familiarize yourself with the API. See here for more info.
+I you crave for an example, take a look at the terraform provider for this project
+
Example
+
The following code shows how to create a VM. To be able to do that you need to set the environment variable ANEXIA_TOKEN to your access token.
+Afterwards you can run the following.
+
1packagemain
+ 2
+ 3import(
+ 4"context"
+ 5"fmt"
+ 6"time"
+ 7
+ 8anexia"github.com/anexia-it/go-anxcloud/pkg"
+ 9"github.com/anexia-it/go-anxcloud/pkg/client"
+10"github.com/anexia-it/go-anxcloud/pkg/vsphere/provisioning/vm"
+11)
+12
+13funcmain(){
+14vlan:="<ID of the VLAN the VM should have access to>"
+15location:="<ID of the location the VM should be in>"
+16
+17// Create client from environment variables, do not unset env afterwards.
+18c,err:=client.New(client.AuthFromEnv(false))
+19iferr!=nil{
+20panic(fmt.Sprintf("could not create client: %v",err))
+21}
+22
+23// Get some API.
+24provisioning:=anexia.NewAPI(c).VSphere().Provisioning()
+25
+26// Time out after 30 minutes. Yes it really takes that long sometimes.
+27ctx,cancel:=context.WithTimeout(context.Background(),30*time.Minute)
+28// Look for a free ip in the given VLAN. This IP is not reserved for you so better be quick.
+29ips,err:=provisioning.IPs().GetFree(ctx,location,vlan)
+30defercancel()
+31iferr!=nil{
+32panic(fmt.Sprintf("provisioning vm failed: %v",err))
+33}
+34iflen(ips)<1{
+35panic(fmt.Sprintf("no IPs left for testing in vlan"))
+36}
+37
+38// Create a NIC for the VM and connect it to the VLAN.
+39networkInterfaces:=[]vm.Network{{NICType:"vmxnet3",IPs:[]string{ips[0].Identifier},VLAN:vlan}}
+40// Create the definition of the new VM. The ID you see here is Flatcar.
+41definition:=vm.NewAPI(c).NewDefinition(location,"template","44b38284-6adb-430e-b4a4-1553e29f352f","developersfirstvm",2,2048,10,networkInterfaces)
+42definition.SSH="<your SSH pub key>"
+43
+44// Provision the VM.
+45provisionResponse,err:=provisioning.VM().Provision(ctx,definition)
+46iferr!=nil{
+47panic(fmt.Sprintf("provisioning vm failed: %v",err))
+48}
+49
+50// Wait for the VM to be ready.
+51_,err=provisioning.Progress().AwaitCompletion(ctx,provisionResponse.Identifier)
+52iferr!=nil{
+53panic(fmt.Sprintf("waiting for VM provisioning failed: %v",err))
+54}
+55}
+
+
+
+
+
\ No newline at end of file
diff --git a/go-anxcloud/README.md@v0.3.25/index.html b/go-anxcloud/README.md@v0.3.25/index.html
new file mode 100644
index 0000000000..59a125ba6c
--- /dev/null
+++ b/go-anxcloud/README.md@v0.3.25/index.html
@@ -0,0 +1,285 @@
+
+
+
+ go.anx.io/go-anxcloud - Go Client for the Anexia API
+
+
+
+
+
+
+
+
+
+
+
go.anx.io/go-anxcloud
+
+
+
+
+
+
Go Client for the Anexia API
+
Go SDK for interacting with the Anexia multi purpose API.
+
Installing
+
To use the SDK, just add github.com/anexia-it/go-anxcloud <version> to your Go module.
+
Getting started
+
Before using the SDK you should familiarize yourself with the API. See here for more info.
+I you crave for an example, take a look at the terraform provider for this project
+
Example
+
The following code shows how to create a VM. To be able to do that you need to set the environment variable ANEXIA_TOKEN to your access token.
+Afterwards you can run the following.
+
1packagemain
+ 2
+ 3import(
+ 4"context"
+ 5"fmt"
+ 6"time"
+ 7
+ 8anexia"github.com/anexia-it/go-anxcloud/pkg"
+ 9"github.com/anexia-it/go-anxcloud/pkg/client"
+10"github.com/anexia-it/go-anxcloud/pkg/vsphere/provisioning/vm"
+11)
+12
+13funcmain(){
+14vlan:="<ID of the VLAN the VM should have access to>"
+15location:="<ID of the location the VM should be in>"
+16
+17// Create client from environment variables, do not unset env afterwards.
+18c,err:=client.New(client.AuthFromEnv(false))
+19iferr!=nil{
+20panic(fmt.Sprintf("could not create client: %v",err))
+21}
+22
+23// Get some API.
+24provisioning:=anexia.NewAPI(c).VSphere().Provisioning()
+25
+26// Time out after 30 minutes. Yes it really takes that long sometimes.
+27ctx,cancel:=context.WithTimeout(context.Background(),30*time.Minute)
+28// Look for a free ip in the given VLAN. This IP is not reserved for you so better be quick.
+29ips,err:=provisioning.IPs().GetFree(ctx,location,vlan)
+30defercancel()
+31iferr!=nil{
+32panic(fmt.Sprintf("provisioning vm failed: %v",err))
+33}
+34iflen(ips)<1{
+35panic(fmt.Sprintf("no IPs left for testing in vlan"))
+36}
+37
+38// Create a NIC for the VM and connect it to the VLAN.
+39networkInterfaces:=[]vm.Network{{NICType:"vmxnet3",IPs:[]string{ips[0].Identifier},VLAN:vlan}}
+40// Create the definition of the new VM. The ID you see here is Flatcar.
+41definition:=vm.NewAPI(c).NewDefinition(location,"template","44b38284-6adb-430e-b4a4-1553e29f352f","developersfirstvm",2,2048,10,networkInterfaces)
+42definition.SSH="<your SSH pub key>"
+43
+44// Provision the VM.
+45provisionResponse,err:=provisioning.VM().Provision(ctx,definition)
+46iferr!=nil{
+47panic(fmt.Sprintf("provisioning vm failed: %v",err))
+48}
+49
+50// Wait for the VM to be ready.
+51_,err=provisioning.Progress().AwaitCompletion(ctx,provisionResponse.Identifier)
+52iferr!=nil{
+53panic(fmt.Sprintf("waiting for VM provisioning failed: %v",err))
+54}
+55}
+
+
+
+
+
\ No newline at end of file
diff --git a/go-anxcloud/README.md@v0.3.26/index.html b/go-anxcloud/README.md@v0.3.26/index.html
new file mode 100644
index 0000000000..f759a7d52e
--- /dev/null
+++ b/go-anxcloud/README.md@v0.3.26/index.html
@@ -0,0 +1,285 @@
+
+
+
+ go.anx.io/go-anxcloud - Go Client for the Anexia API
+
+
+
+
+
+
+
+
+
+
+
go.anx.io/go-anxcloud
+
+
+
+
+
+
Go Client for the Anexia API
+
Go SDK for interacting with the Anexia multi purpose API.
+
Installing
+
To use the SDK, just add github.com/anexia-it/go-anxcloud <version> to your Go module.
+
Getting started
+
Before using the SDK you should familiarize yourself with the API. See here for more info.
+I you crave for an example, take a look at the terraform provider for this project
+
Example
+
The following code shows how to create a VM. To be able to do that you need to set the environment variable ANEXIA_TOKEN to your access token.
+Afterwards you can run the following.
+
1packagemain
+ 2
+ 3import(
+ 4"context"
+ 5"fmt"
+ 6"time"
+ 7
+ 8anexia"github.com/anexia-it/go-anxcloud/pkg"
+ 9"github.com/anexia-it/go-anxcloud/pkg/client"
+10"github.com/anexia-it/go-anxcloud/pkg/vsphere/provisioning/vm"
+11)
+12
+13funcmain(){
+14vlan:="<ID of the VLAN the VM should have access to>"
+15location:="<ID of the location the VM should be in>"
+16
+17// Create client from environment variables, do not unset env afterwards.
+18c,err:=client.New(client.AuthFromEnv(false))
+19iferr!=nil{
+20panic(fmt.Sprintf("could not create client: %v",err))
+21}
+22
+23// Get some API.
+24provisioning:=anexia.NewAPI(c).VSphere().Provisioning()
+25
+26// Time out after 30 minutes. Yes it really takes that long sometimes.
+27ctx,cancel:=context.WithTimeout(context.Background(),30*time.Minute)
+28// Look for a free ip in the given VLAN. This IP is not reserved for you so better be quick.
+29ips,err:=provisioning.IPs().GetFree(ctx,location,vlan)
+30defercancel()
+31iferr!=nil{
+32panic(fmt.Sprintf("provisioning vm failed: %v",err))
+33}
+34iflen(ips)<1{
+35panic(fmt.Sprintf("no IPs left for testing in vlan"))
+36}
+37
+38// Create a NIC for the VM and connect it to the VLAN.
+39networkInterfaces:=[]vm.Network{{NICType:"vmxnet3",IPs:[]string{ips[0].Identifier},VLAN:vlan}}
+40// Create the definition of the new VM. The ID you see here is Flatcar.
+41definition:=vm.NewAPI(c).NewDefinition(location,"template","44b38284-6adb-430e-b4a4-1553e29f352f","developersfirstvm",2,2048,10,networkInterfaces)
+42definition.SSH="<your SSH pub key>"
+43
+44// Provision the VM.
+45provisionResponse,err:=provisioning.VM().Provision(ctx,definition)
+46iferr!=nil{
+47panic(fmt.Sprintf("provisioning vm failed: %v",err))
+48}
+49
+50// Wait for the VM to be ready.
+51_,err=provisioning.Progress().AwaitCompletion(ctx,provisionResponse.Identifier)
+52iferr!=nil{
+53panic(fmt.Sprintf("waiting for VM provisioning failed: %v",err))
+54}
+55}
+
+
+
+
+
\ No newline at end of file
diff --git a/go-anxcloud/README.md@v0.3.27/index.html b/go-anxcloud/README.md@v0.3.27/index.html
new file mode 100644
index 0000000000..34e5470b14
--- /dev/null
+++ b/go-anxcloud/README.md@v0.3.27/index.html
@@ -0,0 +1,285 @@
+
+
+
+ go.anx.io/go-anxcloud - Go Client for the Anexia API
+
+
+
+
+
+
+
+
+
+
+
go.anx.io/go-anxcloud
+
+
+
+
+
+
Go Client for the Anexia API
+
Go SDK for interacting with the Anexia multi purpose API.
+
Installing
+
To use the SDK, just add github.com/anexia-it/go-anxcloud <version> to your Go module.
+
Getting started
+
Before using the SDK you should familiarize yourself with the API. See here for more info.
+I you crave for an example, take a look at the terraform provider for this project
+
Example
+
The following code shows how to create a VM. To be able to do that you need to set the environment variable ANEXIA_TOKEN to your access token.
+Afterwards you can run the following.
+
1packagemain
+ 2
+ 3import(
+ 4"context"
+ 5"fmt"
+ 6"time"
+ 7
+ 8anexia"github.com/anexia-it/go-anxcloud/pkg"
+ 9"github.com/anexia-it/go-anxcloud/pkg/client"
+10"github.com/anexia-it/go-anxcloud/pkg/vsphere/provisioning/vm"
+11)
+12
+13funcmain(){
+14vlan:="<ID of the VLAN the VM should have access to>"
+15location:="<ID of the location the VM should be in>"
+16
+17// Create client from environment variables, do not unset env afterwards.
+18c,err:=client.New(client.AuthFromEnv(false))
+19iferr!=nil{
+20panic(fmt.Sprintf("could not create client: %v",err))
+21}
+22
+23// Get some API.
+24provisioning:=anexia.NewAPI(c).VSphere().Provisioning()
+25
+26// Time out after 30 minutes. Yes it really takes that long sometimes.
+27ctx,cancel:=context.WithTimeout(context.Background(),30*time.Minute)
+28// Look for a free ip in the given VLAN. This IP is not reserved for you so better be quick.
+29ips,err:=provisioning.IPs().GetFree(ctx,location,vlan)
+30defercancel()
+31iferr!=nil{
+32panic(fmt.Sprintf("provisioning vm failed: %v",err))
+33}
+34iflen(ips)<1{
+35panic(fmt.Sprintf("no IPs left for testing in vlan"))
+36}
+37
+38// Create a NIC for the VM and connect it to the VLAN.
+39networkInterfaces:=[]vm.Network{{NICType:"vmxnet3",IPs:[]string{ips[0].Identifier},VLAN:vlan}}
+40// Create the definition of the new VM. The ID you see here is Flatcar.
+41definition:=vm.NewAPI(c).NewDefinition(location,"template","44b38284-6adb-430e-b4a4-1553e29f352f","developersfirstvm",2,2048,10,networkInterfaces)
+42definition.SSH="<your SSH pub key>"
+43
+44// Provision the VM.
+45provisionResponse,err:=provisioning.VM().Provision(ctx,definition)
+46iferr!=nil{
+47panic(fmt.Sprintf("provisioning vm failed: %v",err))
+48}
+49
+50// Wait for the VM to be ready.
+51_,err=provisioning.Progress().AwaitCompletion(ctx,provisionResponse.Identifier)
+52iferr!=nil{
+53panic(fmt.Sprintf("waiting for VM provisioning failed: %v",err))
+54}
+55}
+
+
+
+
+
\ No newline at end of file
diff --git a/go-anxcloud/README.md@v0.3.28/index.html b/go-anxcloud/README.md@v0.3.28/index.html
new file mode 100644
index 0000000000..d4ef4fa548
--- /dev/null
+++ b/go-anxcloud/README.md@v0.3.28/index.html
@@ -0,0 +1,285 @@
+
+
+
+ go.anx.io/go-anxcloud - Go Client for the Anexia API
+
+
+
+
+
+
+
+
+
+
+
go.anx.io/go-anxcloud
+
+
+
+
+
+
Go Client for the Anexia API
+
Go SDK for interacting with the Anexia multi purpose API.
+
Installing
+
To use the SDK, just add github.com/anexia-it/go-anxcloud <version> to your Go module.
+
Getting started
+
Before using the SDK you should familiarize yourself with the API. See here for more info.
+I you crave for an example, take a look at the terraform provider for this project
+
Example
+
The following code shows how to create a VM. To be able to do that you need to set the environment variable ANEXIA_TOKEN to your access token.
+Afterwards you can run the following.
+
1packagemain
+ 2
+ 3import(
+ 4"context"
+ 5"fmt"
+ 6"time"
+ 7
+ 8anexia"github.com/anexia-it/go-anxcloud/pkg"
+ 9"github.com/anexia-it/go-anxcloud/pkg/client"
+10"github.com/anexia-it/go-anxcloud/pkg/vsphere/provisioning/vm"
+11)
+12
+13funcmain(){
+14vlan:="<ID of the VLAN the VM should have access to>"
+15location:="<ID of the location the VM should be in>"
+16
+17// Create client from environment variables, do not unset env afterwards.
+18c,err:=client.New(client.AuthFromEnv(false))
+19iferr!=nil{
+20panic(fmt.Sprintf("could not create client: %v",err))
+21}
+22
+23// Get some API.
+24provisioning:=anexia.NewAPI(c).VSphere().Provisioning()
+25
+26// Time out after 30 minutes. Yes it really takes that long sometimes.
+27ctx,cancel:=context.WithTimeout(context.Background(),30*time.Minute)
+28// Look for a free ip in the given VLAN. This IP is not reserved for you so better be quick.
+29ips,err:=provisioning.IPs().GetFree(ctx,location,vlan)
+30defercancel()
+31iferr!=nil{
+32panic(fmt.Sprintf("provisioning vm failed: %v",err))
+33}
+34iflen(ips)<1{
+35panic(fmt.Sprintf("no IPs left for testing in vlan"))
+36}
+37
+38// Create a NIC for the VM and connect it to the VLAN.
+39networkInterfaces:=[]vm.Network{{NICType:"vmxnet3",IPs:[]string{ips[0].Identifier},VLAN:vlan}}
+40// Create the definition of the new VM. The ID you see here is Flatcar.
+41definition:=vm.NewAPI(c).NewDefinition(location,"template","44b38284-6adb-430e-b4a4-1553e29f352f","developersfirstvm",2,2048,10,networkInterfaces)
+42definition.SSH="<your SSH pub key>"
+43
+44// Provision the VM.
+45provisionResponse,err:=provisioning.VM().Provision(ctx,definition)
+46iferr!=nil{
+47panic(fmt.Sprintf("provisioning vm failed: %v",err))
+48}
+49
+50// Wait for the VM to be ready.
+51_,err=provisioning.Progress().AwaitCompletion(ctx,provisionResponse.Identifier)
+52iferr!=nil{
+53panic(fmt.Sprintf("waiting for VM provisioning failed: %v",err))
+54}
+55}
+
+
+
+
+
\ No newline at end of file
diff --git a/go-anxcloud/README.md@v0.3.3/index.html b/go-anxcloud/README.md@v0.3.3/index.html
new file mode 100644
index 0000000000..ff45b97f4a
--- /dev/null
+++ b/go-anxcloud/README.md@v0.3.3/index.html
@@ -0,0 +1,221 @@
+
+
+
+ go.anx.io/go-anxcloud - anxcloud
+
+
+
+
+
+
+
+
+
+
+
go.anx.io/go-anxcloud
+
+
+
+
+
anxcloud
+
go client for anexia engine
+
+
+
+
+
\ No newline at end of file
diff --git a/go-anxcloud/README.md@v0.3.4/index.html b/go-anxcloud/README.md@v0.3.4/index.html
new file mode 100644
index 0000000000..2d586b3d6a
--- /dev/null
+++ b/go-anxcloud/README.md@v0.3.4/index.html
@@ -0,0 +1,221 @@
+
+
+
+ go.anx.io/go-anxcloud - anxcloud
+
+
+
+
+
+
+
+
+
+
+
go.anx.io/go-anxcloud
+
+
+
+
+
anxcloud
+
go client for anexia engine
+
+
+
+
+
\ No newline at end of file
diff --git a/go-anxcloud/README.md@v0.3.5/index.html b/go-anxcloud/README.md@v0.3.5/index.html
new file mode 100644
index 0000000000..4846cd99d5
--- /dev/null
+++ b/go-anxcloud/README.md@v0.3.5/index.html
@@ -0,0 +1,285 @@
+
+
+
+ go.anx.io/go-anxcloud - Go Client for the Anexia API
+
+
+
+
+
+
+
+
+
+
+
go.anx.io/go-anxcloud
+
+
+
+
+
+
Go Client for the Anexia API
+
Go SDK for interacting with the Anexia multi purpose API.
+
Installing
+
To use the SDK, just add github.com/anexia-it/go-anxcloud <version> to your Go module.
+
Getting started
+
Before using the SDK you should familiarize yourself with the API. See here for more info.
+I you crave for an example, take a look at the terraform provider for this project
+
Example
+
The following code shows how to create a VM. To be able to do that you need to set the environment variable ANEXIA_TOKEN to your access token.
+Afterwards you can run the following.
+
1packagemain
+ 2
+ 3import(
+ 4"context"
+ 5"fmt"
+ 6"time"
+ 7
+ 8anexia"github.com/anexia-it/go-anxcloud/pkg"
+ 9"github.com/anexia-it/go-anxcloud/pkg/client"
+10"github.com/anexia-it/go-anxcloud/pkg/vsphere/provisioning/vm"
+11)
+12
+13funcmain(){
+14vlan:="<ID of the VLAN the VM should have access to>"
+15location:="<ID of the location the VM should be in>"
+16
+17// Create client from environment variables, do not unset env afterwards.
+18c,err:=client.New(client.AuthFromEnv(false))
+19iferr!=nil{
+20panic(fmt.Sprintf("could not create client: %v",err))
+21}
+22
+23// Get some API.
+24provisioning:=anexia.NewAPI(c).VSphere().Provisioning()
+25
+26// Time out after 30 minutes. Yes it really takes that long sometimes.
+27ctx,cancel:=context.WithTimeout(context.Background(),30*time.Minute)
+28// Look for a free ip in the given VLAN. This IP is not reserved for you so better be quick.
+29ips,err:=provisioning.IPs().GetFree(ctx,location,vlan)
+30defercancel()
+31iferr!=nil{
+32panic(fmt.Sprintf("provisioning vm failed: %v",err))
+33}
+34iflen(ips)<1{
+35panic(fmt.Sprintf("no IPs left for testing in vlan"))
+36}
+37
+38// Create a NIC for the VM and connect it to the VLAN.
+39networkInterfaces:=[]vm.Network{{NICType:"vmxnet3",IPs:[]string{ips[0].Identifier},VLAN:vlan}}
+40// Create the definition of the new VM. The ID you see here is Flatcar.
+41definition:=vm.NewAPI(c).NewDefinition(location,"template","44b38284-6adb-430e-b4a4-1553e29f352f","developersfirstvm",2,2048,10,networkInterfaces)
+42definition.SSH="<your SSH pub key>"
+43
+44// Provision the VM.
+45provisionResponse,err:=provisioning.VM().Provision(ctx,definition)
+46iferr!=nil{
+47panic(fmt.Sprintf("provisioning vm failed: %v",err))
+48}
+49
+50// Wait for the VM to be ready.
+51_,err=provisioning.Progress().AwaitCompletion(ctx,provisionResponse.Identifier)
+52iferr!=nil{
+53panic(fmt.Sprintf("waiting for VM provisioning failed: %v",err))
+54}
+55}
+
+
+
+
+
\ No newline at end of file
diff --git a/go-anxcloud/README.md@v0.3.6/index.html b/go-anxcloud/README.md@v0.3.6/index.html
new file mode 100644
index 0000000000..60682075ab
--- /dev/null
+++ b/go-anxcloud/README.md@v0.3.6/index.html
@@ -0,0 +1,285 @@
+
+
+
+ go.anx.io/go-anxcloud - Go Client for the Anexia API
+
+
+
+
+
+
+
+
+
+
+
go.anx.io/go-anxcloud
+
+
+
+
+
+
Go Client for the Anexia API
+
Go SDK for interacting with the Anexia multi purpose API.
+
Installing
+
To use the SDK, just add github.com/anexia-it/go-anxcloud <version> to your Go module.
+
Getting started
+
Before using the SDK you should familiarize yourself with the API. See here for more info.
+I you crave for an example, take a look at the terraform provider for this project
+
Example
+
The following code shows how to create a VM. To be able to do that you need to set the environment variable ANEXIA_TOKEN to your access token.
+Afterwards you can run the following.
+
1packagemain
+ 2
+ 3import(
+ 4"context"
+ 5"fmt"
+ 6"time"
+ 7
+ 8anexia"github.com/anexia-it/go-anxcloud/pkg"
+ 9"github.com/anexia-it/go-anxcloud/pkg/client"
+10"github.com/anexia-it/go-anxcloud/pkg/vsphere/provisioning/vm"
+11)
+12
+13funcmain(){
+14vlan:="<ID of the VLAN the VM should have access to>"
+15location:="<ID of the location the VM should be in>"
+16
+17// Create client from environment variables, do not unset env afterwards.
+18c,err:=client.New(client.AuthFromEnv(false))
+19iferr!=nil{
+20panic(fmt.Sprintf("could not create client: %v",err))
+21}
+22
+23// Get some API.
+24provisioning:=anexia.NewAPI(c).VSphere().Provisioning()
+25
+26// Time out after 30 minutes. Yes it really takes that long sometimes.
+27ctx,cancel:=context.WithTimeout(context.Background(),30*time.Minute)
+28// Look for a free ip in the given VLAN. This IP is not reserved for you so better be quick.
+29ips,err:=provisioning.IPs().GetFree(ctx,location,vlan)
+30defercancel()
+31iferr!=nil{
+32panic(fmt.Sprintf("provisioning vm failed: %v",err))
+33}
+34iflen(ips)<1{
+35panic(fmt.Sprintf("no IPs left for testing in vlan"))
+36}
+37
+38// Create a NIC for the VM and connect it to the VLAN.
+39networkInterfaces:=[]vm.Network{{NICType:"vmxnet3",IPs:[]string{ips[0].Identifier},VLAN:vlan}}
+40// Create the definition of the new VM. The ID you see here is Flatcar.
+41definition:=vm.NewAPI(c).NewDefinition(location,"template","44b38284-6adb-430e-b4a4-1553e29f352f","developersfirstvm",2,2048,10,networkInterfaces)
+42definition.SSH="<your SSH pub key>"
+43
+44// Provision the VM.
+45provisionResponse,err:=provisioning.VM().Provision(ctx,definition)
+46iferr!=nil{
+47panic(fmt.Sprintf("provisioning vm failed: %v",err))
+48}
+49
+50// Wait for the VM to be ready.
+51_,err=provisioning.Progress().AwaitCompletion(ctx,provisionResponse.Identifier)
+52iferr!=nil{
+53panic(fmt.Sprintf("waiting for VM provisioning failed: %v",err))
+54}
+55}
+
+
+
+
+
\ No newline at end of file
diff --git a/go-anxcloud/README.md@v0.3.7/index.html b/go-anxcloud/README.md@v0.3.7/index.html
new file mode 100644
index 0000000000..df277097fa
--- /dev/null
+++ b/go-anxcloud/README.md@v0.3.7/index.html
@@ -0,0 +1,285 @@
+
+
+
+ go.anx.io/go-anxcloud - Go Client for the Anexia API
+
+
+
+
+
+
+
+
+
+
+
go.anx.io/go-anxcloud
+
+
+
+
+
+
Go Client for the Anexia API
+
Go SDK for interacting with the Anexia multi purpose API.
+
Installing
+
To use the SDK, just add github.com/anexia-it/go-anxcloud <version> to your Go module.
+
Getting started
+
Before using the SDK you should familiarize yourself with the API. See here for more info.
+I you crave for an example, take a look at the terraform provider for this project
+
Example
+
The following code shows how to create a VM. To be able to do that you need to set the environment variable ANEXIA_TOKEN to your access token.
+Afterwards you can run the following.
+
1packagemain
+ 2
+ 3import(
+ 4"context"
+ 5"fmt"
+ 6"time"
+ 7
+ 8anexia"github.com/anexia-it/go-anxcloud/pkg"
+ 9"github.com/anexia-it/go-anxcloud/pkg/client"
+10"github.com/anexia-it/go-anxcloud/pkg/vsphere/provisioning/vm"
+11)
+12
+13funcmain(){
+14vlan:="<ID of the VLAN the VM should have access to>"
+15location:="<ID of the location the VM should be in>"
+16
+17// Create client from environment variables, do not unset env afterwards.
+18c,err:=client.New(client.AuthFromEnv(false))
+19iferr!=nil{
+20panic(fmt.Sprintf("could not create client: %v",err))
+21}
+22
+23// Get some API.
+24provisioning:=anexia.NewAPI(c).VSphere().Provisioning()
+25
+26// Time out after 30 minutes. Yes it really takes that long sometimes.
+27ctx,cancel:=context.WithTimeout(context.Background(),30*time.Minute)
+28// Look for a free ip in the given VLAN. This IP is not reserved for you so better be quick.
+29ips,err:=provisioning.IPs().GetFree(ctx,location,vlan)
+30defercancel()
+31iferr!=nil{
+32panic(fmt.Sprintf("provisioning vm failed: %v",err))
+33}
+34iflen(ips)<1{
+35panic(fmt.Sprintf("no IPs left for testing in vlan"))
+36}
+37
+38// Create a NIC for the VM and connect it to the VLAN.
+39networkInterfaces:=[]vm.Network{{NICType:"vmxnet3",IPs:[]string{ips[0].Identifier},VLAN:vlan}}
+40// Create the definition of the new VM. The ID you see here is Flatcar.
+41definition:=vm.NewAPI(c).NewDefinition(location,"template","44b38284-6adb-430e-b4a4-1553e29f352f","developersfirstvm",2,2048,10,networkInterfaces)
+42definition.SSH="<your SSH pub key>"
+43
+44// Provision the VM.
+45provisionResponse,err:=provisioning.VM().Provision(ctx,definition)
+46iferr!=nil{
+47panic(fmt.Sprintf("provisioning vm failed: %v",err))
+48}
+49
+50// Wait for the VM to be ready.
+51_,err=provisioning.Progress().AwaitCompletion(ctx,provisionResponse.Identifier)
+52iferr!=nil{
+53panic(fmt.Sprintf("waiting for VM provisioning failed: %v",err))
+54}
+55}
+
+
+
+
+
\ No newline at end of file
diff --git a/go-anxcloud/README.md@v0.3.8/index.html b/go-anxcloud/README.md@v0.3.8/index.html
new file mode 100644
index 0000000000..bc469d923e
--- /dev/null
+++ b/go-anxcloud/README.md@v0.3.8/index.html
@@ -0,0 +1,285 @@
+
+
+
+ go.anx.io/go-anxcloud - Go Client for the Anexia API
+
+
+
+
+
+
+
+
+
+
+
go.anx.io/go-anxcloud
+
+
+
+
+
+
Go Client for the Anexia API
+
Go SDK for interacting with the Anexia multi purpose API.
+
Installing
+
To use the SDK, just add github.com/anexia-it/go-anxcloud <version> to your Go module.
+
Getting started
+
Before using the SDK you should familiarize yourself with the API. See here for more info.
+I you crave for an example, take a look at the terraform provider for this project
+
Example
+
The following code shows how to create a VM. To be able to do that you need to set the environment variable ANEXIA_TOKEN to your access token.
+Afterwards you can run the following.
+
1packagemain
+ 2
+ 3import(
+ 4"context"
+ 5"fmt"
+ 6"time"
+ 7
+ 8anexia"github.com/anexia-it/go-anxcloud/pkg"
+ 9"github.com/anexia-it/go-anxcloud/pkg/client"
+10"github.com/anexia-it/go-anxcloud/pkg/vsphere/provisioning/vm"
+11)
+12
+13funcmain(){
+14vlan:="<ID of the VLAN the VM should have access to>"
+15location:="<ID of the location the VM should be in>"
+16
+17// Create client from environment variables, do not unset env afterwards.
+18c,err:=client.New(client.AuthFromEnv(false))
+19iferr!=nil{
+20panic(fmt.Sprintf("could not create client: %v",err))
+21}
+22
+23// Get some API.
+24provisioning:=anexia.NewAPI(c).VSphere().Provisioning()
+25
+26// Time out after 30 minutes. Yes it really takes that long sometimes.
+27ctx,cancel:=context.WithTimeout(context.Background(),30*time.Minute)
+28// Look for a free ip in the given VLAN. This IP is not reserved for you so better be quick.
+29ips,err:=provisioning.IPs().GetFree(ctx,location,vlan)
+30defercancel()
+31iferr!=nil{
+32panic(fmt.Sprintf("provisioning vm failed: %v",err))
+33}
+34iflen(ips)<1{
+35panic(fmt.Sprintf("no IPs left for testing in vlan"))
+36}
+37
+38// Create a NIC for the VM and connect it to the VLAN.
+39networkInterfaces:=[]vm.Network{{NICType:"vmxnet3",IPs:[]string{ips[0].Identifier},VLAN:vlan}}
+40// Create the definition of the new VM. The ID you see here is Flatcar.
+41definition:=vm.NewAPI(c).NewDefinition(location,"template","44b38284-6adb-430e-b4a4-1553e29f352f","developersfirstvm",2,2048,10,networkInterfaces)
+42definition.SSH="<your SSH pub key>"
+43
+44// Provision the VM.
+45provisionResponse,err:=provisioning.VM().Provision(ctx,definition)
+46iferr!=nil{
+47panic(fmt.Sprintf("provisioning vm failed: %v",err))
+48}
+49
+50// Wait for the VM to be ready.
+51_,err=provisioning.Progress().AwaitCompletion(ctx,provisionResponse.Identifier)
+52iferr!=nil{
+53panic(fmt.Sprintf("waiting for VM provisioning failed: %v",err))
+54}
+55}
+
+
+
+
+
\ No newline at end of file
diff --git a/go-anxcloud/README.md@v0.3.9/index.html b/go-anxcloud/README.md@v0.3.9/index.html
new file mode 100644
index 0000000000..8ed7ba0fbf
--- /dev/null
+++ b/go-anxcloud/README.md@v0.3.9/index.html
@@ -0,0 +1,285 @@
+
+
+
+ go.anx.io/go-anxcloud - Go Client for the Anexia API
+
+
+
+
+
+
+
+
+
+
+
go.anx.io/go-anxcloud
+
+
+
+
+
+
Go Client for the Anexia API
+
Go SDK for interacting with the Anexia multi purpose API.
+
Installing
+
To use the SDK, just add github.com/anexia-it/go-anxcloud <version> to your Go module.
+
Getting started
+
Before using the SDK you should familiarize yourself with the API. See here for more info.
+I you crave for an example, take a look at the terraform provider for this project
+
Example
+
The following code shows how to create a VM. To be able to do that you need to set the environment variable ANEXIA_TOKEN to your access token.
+Afterwards you can run the following.
+
1packagemain
+ 2
+ 3import(
+ 4"context"
+ 5"fmt"
+ 6"time"
+ 7
+ 8anexia"github.com/anexia-it/go-anxcloud/pkg"
+ 9"github.com/anexia-it/go-anxcloud/pkg/client"
+10"github.com/anexia-it/go-anxcloud/pkg/vsphere/provisioning/vm"
+11)
+12
+13funcmain(){
+14vlan:="<ID of the VLAN the VM should have access to>"
+15location:="<ID of the location the VM should be in>"
+16
+17// Create client from environment variables, do not unset env afterwards.
+18c,err:=client.New(client.AuthFromEnv(false))
+19iferr!=nil{
+20panic(fmt.Sprintf("could not create client: %v",err))
+21}
+22
+23// Get some API.
+24provisioning:=anexia.NewAPI(c).VSphere().Provisioning()
+25
+26// Time out after 30 minutes. Yes it really takes that long sometimes.
+27ctx,cancel:=context.WithTimeout(context.Background(),30*time.Minute)
+28// Look for a free ip in the given VLAN. This IP is not reserved for you so better be quick.
+29ips,err:=provisioning.IPs().GetFree(ctx,location,vlan)
+30defercancel()
+31iferr!=nil{
+32panic(fmt.Sprintf("provisioning vm failed: %v",err))
+33}
+34iflen(ips)<1{
+35panic(fmt.Sprintf("no IPs left for testing in vlan"))
+36}
+37
+38// Create a NIC for the VM and connect it to the VLAN.
+39networkInterfaces:=[]vm.Network{{NICType:"vmxnet3",IPs:[]string{ips[0].Identifier},VLAN:vlan}}
+40// Create the definition of the new VM. The ID you see here is Flatcar.
+41definition:=vm.NewAPI(c).NewDefinition(location,"template","44b38284-6adb-430e-b4a4-1553e29f352f","developersfirstvm",2,2048,10,networkInterfaces)
+42definition.SSH="<your SSH pub key>"
+43
+44// Provision the VM.
+45provisionResponse,err:=provisioning.VM().Provision(ctx,definition)
+46iferr!=nil{
+47panic(fmt.Sprintf("provisioning vm failed: %v",err))
+48}
+49
+50// Wait for the VM to be ready.
+51_,err=provisioning.Progress().AwaitCompletion(ctx,provisionResponse.Identifier)
+52iferr!=nil{
+53panic(fmt.Sprintf("waiting for VM provisioning failed: %v",err))
+54}
+55}
+
+
+
+
+
\ No newline at end of file
diff --git a/go-anxcloud/README.md@v0.4.0/index.html b/go-anxcloud/README.md@v0.4.0/index.html
new file mode 100644
index 0000000000..5053ddfd14
--- /dev/null
+++ b/go-anxcloud/README.md@v0.4.0/index.html
@@ -0,0 +1,346 @@
+
+
+
+ go.anx.io/go-anxcloud - Go Client for the Anexia API
+
+
+
+
+
+
+
+
+
+
+
go.anx.io/go-anxcloud
+
+
+
+
+
+
+
Go Client for the Anexia API
+
Go SDK for interacting with the Anexia Engine API.
+
Installing
+
To use the SDK, just add go.anx.io/go-anxcloud <version> to your Go module.
+
Getting started
+
Before using the SDK you should familiarize yourself with the Anexia Engine API.
+
The library is used in our terraform provider, check it out if you want some examples how to use it.
+
Example
+
Below is a short example using the new generic client in this package. Not all APIs can already be used with it, but we are working on that.
+Find more examples in the docs (linked to docs for
+main branch, not the latest (or any) release).
+
1packagemain
+ 2
+ 3import(
+ 4"context"
+ 5"log"
+ 6
+ 7"go.anx.io/go-anxcloud/pkg/api"
+ 8apiTypes"go.anx.io/go-anxcloud/pkg/api/types"
+ 9"go.anx.io/go-anxcloud/pkg/client"
+10
+11// apis usable with the generic client have their own package in a location analog to this
+12lbaasv1"go.anx.io/go-anxcloud/pkg/apis/lbaas/v1"
+13)
+14
+15funcmain(){
+16apiClient,err:=api.NewAPI(
+17api.WithClientOptions(
+18// Get auth token from ANEXIA_TOKEN environment variable.
+19// The boolean parameter specifies if the environment variable should be unset.
+20client.TokenFromEnv(false),
+21),
+22)
+23iferr!=nil{
+24log.Fatalf("Error creating ANX API client: %v",err)
+25}
+26
+27// let's list LBaaS backends of a known LoadBalancer
+28frontend:=lbaasv1.Frontend{
+29LoadBalancer:lbaasv1.LoadBalancer{Identifier:"285b954fdf2a449c8fdae01cc6074025"},
+30}
+31
+32varfrontendsapiTypes.ObjectChannel
+33err=apiClient.List(context.TODO(),&frontend,
+34// Listing can be done with either a page iterator or a channel, we use a channel here.
+35api.ObjectChannel(&frontends),
+36
+37// Most APIs only give a very small subset when listing resources, add this flag to
+38// get all attributes, at the cost of doing lots of API requests.
+39api.FullObjects(true),
+40)
+41iferr!=nil{
+42log.Fatalf("Error listing backends for LoadBalancer '%v': %v",frontend.LoadBalancer.Identifier,err)
+43}
+44
+45forretriever:=rangefrontends{
+46// reinitialise frontend every loop to reset pointers and avoid potential overwriting of data in the next loop
+47varfrontendlbaasv1.Frontend
+48iferr:=retriever(&frontend);err!=nil{
+49log.Fatalf("Error retrieving Frontend: %v",err)
+50}
+51
+52log.Printf("Got Frontend named '%v' with mode '%v'",frontend.Name,frontend.Mode)
+53}
+54}
+
This new generic client will one day be the only client in go-anxcloud. The legacy API-specific clients are deprecated and will be removed in the
+go-anxcloud release following the one with all APIs go-anxcloud supports usable with the generic client (so if the generic client in 0.5.0 supports
+at least everything there is another client for in go-anxcloud, 0.6.0 will drop the API-specific clients).
+
+
1packagemain
+ 2
+ 3import(
+ 4"context"
+ 5"fmt"
+ 6"time"
+ 7
+ 8anexia"go.anx.io/go-anxcloud/pkg"
+ 9"go.anx.io/go-anxcloud/pkg/client"
+10"go.anx.io/go-anxcloud/pkg/vsphere/provisioning/vm"
+11)
+12
+13funcmain(){
+14vlan:="<ID of the VLAN the VM should have access to>"
+15location:="<ID of the location the VM should be in>"
+16
+17// Create client using the auth token in environment variable ANEXIA_TOKEN and do not unset the environment variable.
+18c,err:=client.New(client.AuthFromEnv(false))
+19iferr!=nil{
+20panic(fmt.Sprintf("could not create client: %v",err))
+21}
+22
+23// Get some API.
+24provisioning:=anexia.NewAPI(c).VSphere().Provisioning()
+25
+26// Time out after 30 minutes. Yes it really takes that long sometimes.
+27ctx,cancel:=context.WithTimeout(context.Background(),30*time.Minute)
+28// Look for a free ip in the given VLAN. This IP is not reserved for you so better be quick.
+29ips,err:=provisioning.IPs().GetFree(ctx,location,vlan)
+30defercancel()
+31iferr!=nil{
+32panic(fmt.Sprintf("provisioning vm failed: %v",err))
+33}
+34iflen(ips)<1{
+35panic(fmt.Sprintf("no IPs left for testing in vlan"))
+36}
+37
+38// Create a NIC for the VM and connect it to the VLAN.
+39networkInterfaces:=[]vm.Network{{NICType:"vmxnet3",IPs:[]string{ips[0].Identifier},VLAN:vlan}}
+40// Create the definition of the new VM. The ID you see here is Flatcar.
+41definition:=vm.NewAPI(c).NewDefinition(location,"template","44b38284-6adb-430e-b4a4-1553e29f352f","developersfirstvm",2,2048,10,networkInterfaces)
+42definition.SSH="<your SSH pub key>"
+43
+44// Provision the VM.
+45provisionResponse,err:=provisioning.VM().Provision(ctx,definition)
+46iferr!=nil{
+47panic(fmt.Sprintf("provisioning vm failed: %v",err))
+48}
+49
+50// Wait for the VM to be ready.
+51_,err=provisioning.Progress().AwaitCompletion(ctx,provisionResponse.Identifier)
+52iferr!=nil{
+53panic(fmt.Sprintf("waiting for VM provisioning failed: %v",err))
+54}
+55}
+
+
+
+
+
+
\ No newline at end of file
diff --git a/go-anxcloud/README.md@v0.4.1/index.html b/go-anxcloud/README.md@v0.4.1/index.html
new file mode 100644
index 0000000000..4ffba78fba
--- /dev/null
+++ b/go-anxcloud/README.md@v0.4.1/index.html
@@ -0,0 +1,346 @@
+
+
+
+ go.anx.io/go-anxcloud - Go Client for the Anexia API
+
+
+
+
+
+
+
+
+
+
+
go.anx.io/go-anxcloud
+
+
+
+
+
+
+
Go Client for the Anexia API
+
Go SDK for interacting with the Anexia Engine API.
+
Installing
+
To use the SDK, just add go.anx.io/go-anxcloud <version> to your Go module.
+
Getting started
+
Before using the SDK you should familiarize yourself with the Anexia Engine API.
+
The library is used in our terraform provider, check it out if you want some examples how to use it.
+
Example
+
Below is a short example using the new generic client in this package. Not all APIs can already be used with it, but we are working on that.
+Find more examples in the docs (linked to docs for
+main branch, not the latest (or any) release).
+
1packagemain
+ 2
+ 3import(
+ 4"context"
+ 5"log"
+ 6
+ 7"go.anx.io/go-anxcloud/pkg/api"
+ 8apiTypes"go.anx.io/go-anxcloud/pkg/api/types"
+ 9"go.anx.io/go-anxcloud/pkg/client"
+10
+11// apis usable with the generic client have their own package in a location analog to this
+12lbaasv1"go.anx.io/go-anxcloud/pkg/apis/lbaas/v1"
+13)
+14
+15funcmain(){
+16apiClient,err:=api.NewAPI(
+17api.WithClientOptions(
+18// Get auth token from ANEXIA_TOKEN environment variable.
+19// The boolean parameter specifies if the environment variable should be unset.
+20client.TokenFromEnv(false),
+21),
+22)
+23iferr!=nil{
+24log.Fatalf("Error creating ANX API client: %v",err)
+25}
+26
+27// let's list LBaaS backends of a known LoadBalancer
+28frontend:=lbaasv1.Frontend{
+29LoadBalancer:lbaasv1.LoadBalancer{Identifier:"285b954fdf2a449c8fdae01cc6074025"},
+30}
+31
+32varfrontendsapiTypes.ObjectChannel
+33err=apiClient.List(context.TODO(),&frontend,
+34// Listing can be done with either a page iterator or a channel, we use a channel here.
+35api.ObjectChannel(&frontends),
+36
+37// Most APIs only give a very small subset when listing resources, add this flag to
+38// get all attributes, at the cost of doing lots of API requests.
+39api.FullObjects(true),
+40)
+41iferr!=nil{
+42log.Fatalf("Error listing backends for LoadBalancer '%v': %v",frontend.LoadBalancer.Identifier,err)
+43}
+44
+45forretriever:=rangefrontends{
+46// reinitialise frontend every loop to reset pointers and avoid potential overwriting of data in the next loop
+47varfrontendlbaasv1.Frontend
+48iferr:=retriever(&frontend);err!=nil{
+49log.Fatalf("Error retrieving Frontend: %v",err)
+50}
+51
+52log.Printf("Got Frontend named '%v' with mode '%v'",frontend.Name,frontend.Mode)
+53}
+54}
+
This new generic client will one day be the only client in go-anxcloud. The legacy API-specific clients are deprecated and will be removed in the
+go-anxcloud release following the one with all APIs go-anxcloud supports usable with the generic client (so if the generic client in 0.5.0 supports
+at least everything there is another client for in go-anxcloud, 0.6.0 will drop the API-specific clients).
+
+
1packagemain
+ 2
+ 3import(
+ 4"context"
+ 5"fmt"
+ 6"time"
+ 7
+ 8anexia"go.anx.io/go-anxcloud/pkg"
+ 9"go.anx.io/go-anxcloud/pkg/client"
+10"go.anx.io/go-anxcloud/pkg/vsphere/provisioning/vm"
+11)
+12
+13funcmain(){
+14vlan:="<ID of the VLAN the VM should have access to>"
+15location:="<ID of the location the VM should be in>"
+16
+17// Create client using the auth token in environment variable ANEXIA_TOKEN and do not unset the environment variable.
+18c,err:=client.New(client.AuthFromEnv(false))
+19iferr!=nil{
+20panic(fmt.Sprintf("could not create client: %v",err))
+21}
+22
+23// Get some API.
+24provisioning:=anexia.NewAPI(c).VSphere().Provisioning()
+25
+26// Time out after 30 minutes. Yes it really takes that long sometimes.
+27ctx,cancel:=context.WithTimeout(context.Background(),30*time.Minute)
+28// Look for a free ip in the given VLAN. This IP is not reserved for you so better be quick.
+29ips,err:=provisioning.IPs().GetFree(ctx,location,vlan)
+30defercancel()
+31iferr!=nil{
+32panic(fmt.Sprintf("provisioning vm failed: %v",err))
+33}
+34iflen(ips)<1{
+35panic(fmt.Sprintf("no IPs left for testing in vlan"))
+36}
+37
+38// Create a NIC for the VM and connect it to the VLAN.
+39networkInterfaces:=[]vm.Network{{NICType:"vmxnet3",IPs:[]string{ips[0].Identifier},VLAN:vlan}}
+40// Create the definition of the new VM. The ID you see here is Flatcar.
+41definition:=vm.NewAPI(c).NewDefinition(location,"template","44b38284-6adb-430e-b4a4-1553e29f352f","developersfirstvm",2,2048,10,networkInterfaces)
+42definition.SSH="<your SSH pub key>"
+43
+44// Provision the VM.
+45provisionResponse,err:=provisioning.VM().Provision(ctx,definition)
+46iferr!=nil{
+47panic(fmt.Sprintf("provisioning vm failed: %v",err))
+48}
+49
+50// Wait for the VM to be ready.
+51_,err=provisioning.Progress().AwaitCompletion(ctx,provisionResponse.Identifier)
+52iferr!=nil{
+53panic(fmt.Sprintf("waiting for VM provisioning failed: %v",err))
+54}
+55}
+
+
+
+
+
+
\ No newline at end of file
diff --git a/go-anxcloud/README.md@v0.4.2/index.html b/go-anxcloud/README.md@v0.4.2/index.html
new file mode 100644
index 0000000000..c204d05fd7
--- /dev/null
+++ b/go-anxcloud/README.md@v0.4.2/index.html
@@ -0,0 +1,346 @@
+
+
+
+ go.anx.io/go-anxcloud - Go Client for the Anexia API
+
+
+
+
+
+
+
+
+
+
+
go.anx.io/go-anxcloud
+
+
+
+
+
+
+
Go Client for the Anexia API
+
Go SDK for interacting with the Anexia Engine API.
+
Installing
+
To use the SDK, just add go.anx.io/go-anxcloud <version> to your Go module.
+
Getting started
+
Before using the SDK you should familiarize yourself with the Anexia Engine API.
+
The library is used in our terraform provider, check it out if you want some examples how to use it.
+
Example
+
Below is a short example using the new generic client in this package. Not all APIs can already be used with it, but we are working on that.
+Find more examples in the docs (linked to docs for
+main branch, not the latest (or any) release).
+
1packagemain
+ 2
+ 3import(
+ 4"context"
+ 5"log"
+ 6
+ 7"go.anx.io/go-anxcloud/pkg/api"
+ 8apiTypes"go.anx.io/go-anxcloud/pkg/api/types"
+ 9"go.anx.io/go-anxcloud/pkg/client"
+10
+11// apis usable with the generic client have their own package in a location analog to this
+12lbaasv1"go.anx.io/go-anxcloud/pkg/apis/lbaas/v1"
+13)
+14
+15funcmain(){
+16apiClient,err:=api.NewAPI(
+17api.WithClientOptions(
+18// Get auth token from ANEXIA_TOKEN environment variable.
+19// The boolean parameter specifies if the environment variable should be unset.
+20client.TokenFromEnv(false),
+21),
+22)
+23iferr!=nil{
+24log.Fatalf("Error creating ANX API client: %v",err)
+25}
+26
+27// let's list LBaaS backends of a known LoadBalancer
+28frontend:=lbaasv1.Frontend{
+29LoadBalancer:lbaasv1.LoadBalancer{Identifier:"285b954fdf2a449c8fdae01cc6074025"},
+30}
+31
+32varfrontendsapiTypes.ObjectChannel
+33err=apiClient.List(context.TODO(),&frontend,
+34// Listing can be done with either a page iterator or a channel, we use a channel here.
+35api.ObjectChannel(&frontends),
+36
+37// Most APIs only give a very small subset when listing resources, add this flag to
+38// get all attributes, at the cost of doing lots of API requests.
+39api.FullObjects(true),
+40)
+41iferr!=nil{
+42log.Fatalf("Error listing backends for LoadBalancer '%v': %v",frontend.LoadBalancer.Identifier,err)
+43}
+44
+45forretriever:=rangefrontends{
+46// reinitialise frontend every loop to reset pointers and avoid potential overwriting of data in the next loop
+47varfrontendlbaasv1.Frontend
+48iferr:=retriever(&frontend);err!=nil{
+49log.Fatalf("Error retrieving Frontend: %v",err)
+50}
+51
+52log.Printf("Got Frontend named '%v' with mode '%v'",frontend.Name,frontend.Mode)
+53}
+54}
+
This new generic client will one day be the only client in go-anxcloud. The legacy API-specific clients are deprecated and will be removed in the
+go-anxcloud release following the one with all APIs go-anxcloud supports usable with the generic client (so if the generic client in 0.5.0 supports
+at least everything there is another client for in go-anxcloud, 0.6.0 will drop the API-specific clients).
+
+
1packagemain
+ 2
+ 3import(
+ 4"context"
+ 5"fmt"
+ 6"time"
+ 7
+ 8anexia"go.anx.io/go-anxcloud/pkg"
+ 9"go.anx.io/go-anxcloud/pkg/client"
+10"go.anx.io/go-anxcloud/pkg/vsphere/provisioning/vm"
+11)
+12
+13funcmain(){
+14vlan:="<ID of the VLAN the VM should have access to>"
+15location:="<ID of the location the VM should be in>"
+16
+17// Create client using the auth token in environment variable ANEXIA_TOKEN and do not unset the environment variable.
+18c,err:=client.New(client.AuthFromEnv(false))
+19iferr!=nil{
+20panic(fmt.Sprintf("could not create client: %v",err))
+21}
+22
+23// Get some API.
+24provisioning:=anexia.NewAPI(c).VSphere().Provisioning()
+25
+26// Time out after 30 minutes. Yes it really takes that long sometimes.
+27ctx,cancel:=context.WithTimeout(context.Background(),30*time.Minute)
+28// Look for a free ip in the given VLAN. This IP is not reserved for you so better be quick.
+29ips,err:=provisioning.IPs().GetFree(ctx,location,vlan)
+30defercancel()
+31iferr!=nil{
+32panic(fmt.Sprintf("provisioning vm failed: %v",err))
+33}
+34iflen(ips)<1{
+35panic(fmt.Sprintf("no IPs left for testing in vlan"))
+36}
+37
+38// Create a NIC for the VM and connect it to the VLAN.
+39networkInterfaces:=[]vm.Network{{NICType:"vmxnet3",IPs:[]string{ips[0].Identifier},VLAN:vlan}}
+40// Create the definition of the new VM. The ID you see here is Flatcar.
+41definition:=vm.NewAPI(c).NewDefinition(location,"template","44b38284-6adb-430e-b4a4-1553e29f352f","developersfirstvm",2,2048,10,networkInterfaces)
+42definition.SSH="<your SSH pub key>"
+43
+44// Provision the VM.
+45provisionResponse,err:=provisioning.VM().Provision(ctx,definition)
+46iferr!=nil{
+47panic(fmt.Sprintf("provisioning vm failed: %v",err))
+48}
+49
+50// Wait for the VM to be ready.
+51_,err=provisioning.Progress().AwaitCompletion(ctx,provisionResponse.Identifier)
+52iferr!=nil{
+53panic(fmt.Sprintf("waiting for VM provisioning failed: %v",err))
+54}
+55}
+
+
+
+
+
+
\ No newline at end of file
diff --git a/go-anxcloud/README.md@v0.4.3/index.html b/go-anxcloud/README.md@v0.4.3/index.html
new file mode 100644
index 0000000000..0c10e3d273
--- /dev/null
+++ b/go-anxcloud/README.md@v0.4.3/index.html
@@ -0,0 +1,346 @@
+
+
+
+ go.anx.io/go-anxcloud - Go Client for the Anexia API
+
+
+
+
+
+
+
+
+
+
+
go.anx.io/go-anxcloud
+
+
+
+
+
+
+
Go Client for the Anexia API
+
Go SDK for interacting with the Anexia Engine API.
+
Installing
+
To use the SDK, just add go.anx.io/go-anxcloud <version> to your Go module.
+
Getting started
+
Before using the SDK you should familiarize yourself with the Anexia Engine API.
+
The library is used in our terraform provider, check it out if you want some examples how to use it.
+
Example
+
Below is a short example using the new generic client in this package. Not all APIs can already be used with it, but we are working on that.
+Find more examples in the docs (linked to docs for
+main branch, not the latest (or any) release).
+
1packagemain
+ 2
+ 3import(
+ 4"context"
+ 5"log"
+ 6
+ 7"go.anx.io/go-anxcloud/pkg/api"
+ 8apiTypes"go.anx.io/go-anxcloud/pkg/api/types"
+ 9"go.anx.io/go-anxcloud/pkg/client"
+10
+11// apis usable with the generic client have their own package in a location analog to this
+12lbaasv1"go.anx.io/go-anxcloud/pkg/apis/lbaas/v1"
+13)
+14
+15funcmain(){
+16apiClient,err:=api.NewAPI(
+17api.WithClientOptions(
+18// Get auth token from ANEXIA_TOKEN environment variable.
+19// The boolean parameter specifies if the environment variable should be unset.
+20client.TokenFromEnv(false),
+21),
+22)
+23iferr!=nil{
+24log.Fatalf("Error creating ANX API client: %v",err)
+25}
+26
+27// let's list LBaaS backends of a known LoadBalancer
+28frontend:=lbaasv1.Frontend{
+29LoadBalancer:lbaasv1.LoadBalancer{Identifier:"285b954fdf2a449c8fdae01cc6074025"},
+30}
+31
+32varfrontendsapiTypes.ObjectChannel
+33err=apiClient.List(context.TODO(),&frontend,
+34// Listing can be done with either a page iterator or a channel, we use a channel here.
+35api.ObjectChannel(&frontends),
+36
+37// Most APIs only give a very small subset when listing resources, add this flag to
+38// get all attributes, at the cost of doing lots of API requests.
+39api.FullObjects(true),
+40)
+41iferr!=nil{
+42log.Fatalf("Error listing backends for LoadBalancer '%v': %v",frontend.LoadBalancer.Identifier,err)
+43}
+44
+45forretriever:=rangefrontends{
+46// reinitialise frontend every loop to reset pointers and avoid potential overwriting of data in the next loop
+47varfrontendlbaasv1.Frontend
+48iferr:=retriever(&frontend);err!=nil{
+49log.Fatalf("Error retrieving Frontend: %v",err)
+50}
+51
+52log.Printf("Got Frontend named '%v' with mode '%v'",frontend.Name,frontend.Mode)
+53}
+54}
+
This new generic client will one day be the only client in go-anxcloud. The legacy API-specific clients are deprecated and will be removed in the
+go-anxcloud release following the one with all APIs go-anxcloud supports usable with the generic client (so if the generic client in 0.5.0 supports
+at least everything there is another client for in go-anxcloud, 0.6.0 will drop the API-specific clients).
+
+
1packagemain
+ 2
+ 3import(
+ 4"context"
+ 5"fmt"
+ 6"time"
+ 7
+ 8anexia"go.anx.io/go-anxcloud/pkg"
+ 9"go.anx.io/go-anxcloud/pkg/client"
+10"go.anx.io/go-anxcloud/pkg/vsphere/provisioning/vm"
+11)
+12
+13funcmain(){
+14vlan:="<ID of the VLAN the VM should have access to>"
+15location:="<ID of the location the VM should be in>"
+16
+17// Create client using the auth token in environment variable ANEXIA_TOKEN and do not unset the environment variable.
+18c,err:=client.New(client.AuthFromEnv(false))
+19iferr!=nil{
+20panic(fmt.Sprintf("could not create client: %v",err))
+21}
+22
+23// Get some API.
+24provisioning:=anexia.NewAPI(c).VSphere().Provisioning()
+25
+26// Time out after 30 minutes. Yes it really takes that long sometimes.
+27ctx,cancel:=context.WithTimeout(context.Background(),30*time.Minute)
+28// Look for a free ip in the given VLAN. This IP is not reserved for you so better be quick.
+29ips,err:=provisioning.IPs().GetFree(ctx,location,vlan)
+30defercancel()
+31iferr!=nil{
+32panic(fmt.Sprintf("provisioning vm failed: %v",err))
+33}
+34iflen(ips)<1{
+35panic(fmt.Sprintf("no IPs left for testing in vlan"))
+36}
+37
+38// Create a NIC for the VM and connect it to the VLAN.
+39networkInterfaces:=[]vm.Network{{NICType:"vmxnet3",IPs:[]string{ips[0].Identifier},VLAN:vlan}}
+40// Create the definition of the new VM. The ID you see here is Flatcar.
+41definition:=vm.NewAPI(c).NewDefinition(location,"template","44b38284-6adb-430e-b4a4-1553e29f352f","developersfirstvm",2,2048,10,networkInterfaces)
+42definition.SSH="<your SSH pub key>"
+43
+44// Provision the VM.
+45provisionResponse,err:=provisioning.VM().Provision(ctx,definition)
+46iferr!=nil{
+47panic(fmt.Sprintf("provisioning vm failed: %v",err))
+48}
+49
+50// Wait for the VM to be ready.
+51_,err=provisioning.Progress().AwaitCompletion(ctx,provisionResponse.Identifier)
+52iferr!=nil{
+53panic(fmt.Sprintf("waiting for VM provisioning failed: %v",err))
+54}
+55}
+
+
+
+
+
+
\ No newline at end of file
diff --git a/go-anxcloud/README.md@v0.4.4/index.html b/go-anxcloud/README.md@v0.4.4/index.html
new file mode 100644
index 0000000000..02e565e577
--- /dev/null
+++ b/go-anxcloud/README.md@v0.4.4/index.html
@@ -0,0 +1,346 @@
+
+
+
+ go.anx.io/go-anxcloud - Go Client for the Anexia API
+
+
+
+
+
+
+
+
+
+
+
go.anx.io/go-anxcloud
+
+
+
+
+
+
+
Go Client for the Anexia API
+
Go SDK for interacting with the Anexia Engine API.
+
Installing
+
To use the SDK, just add go.anx.io/go-anxcloud <version> to your Go module.
+
Getting started
+
Before using the SDK you should familiarize yourself with the Anexia Engine API.
+
The library is used in our terraform provider, check it out if you want some examples how to use it.
+
Example
+
Below is a short example using the new generic client in this package. Not all APIs can already be used with it, but we are working on that.
+Find more examples in the docs (linked to docs for
+main branch, not the latest (or any) release).
+
1packagemain
+ 2
+ 3import(
+ 4"context"
+ 5"log"
+ 6
+ 7"go.anx.io/go-anxcloud/pkg/api"
+ 8apiTypes"go.anx.io/go-anxcloud/pkg/api/types"
+ 9"go.anx.io/go-anxcloud/pkg/client"
+10
+11// apis usable with the generic client have their own package in a location analog to this
+12lbaasv1"go.anx.io/go-anxcloud/pkg/apis/lbaas/v1"
+13)
+14
+15funcmain(){
+16apiClient,err:=api.NewAPI(
+17api.WithClientOptions(
+18// Get auth token from ANEXIA_TOKEN environment variable.
+19// The boolean parameter specifies if the environment variable should be unset.
+20client.TokenFromEnv(false),
+21),
+22)
+23iferr!=nil{
+24log.Fatalf("Error creating ANX API client: %v",err)
+25}
+26
+27// let's list LBaaS backends of a known LoadBalancer
+28frontend:=lbaasv1.Frontend{
+29LoadBalancer:lbaasv1.LoadBalancer{Identifier:"285b954fdf2a449c8fdae01cc6074025"},
+30}
+31
+32varfrontendsapiTypes.ObjectChannel
+33err=apiClient.List(context.TODO(),&frontend,
+34// Listing can be done with either a page iterator or a channel, we use a channel here.
+35api.ObjectChannel(&frontends),
+36
+37// Most APIs only give a very small subset when listing resources, add this flag to
+38// get all attributes, at the cost of doing lots of API requests.
+39api.FullObjects(true),
+40)
+41iferr!=nil{
+42log.Fatalf("Error listing backends for LoadBalancer '%v': %v",frontend.LoadBalancer.Identifier,err)
+43}
+44
+45forretriever:=rangefrontends{
+46// reinitialise frontend every loop to reset pointers and avoid potential overwriting of data in the next loop
+47varfrontendlbaasv1.Frontend
+48iferr:=retriever(&frontend);err!=nil{
+49log.Fatalf("Error retrieving Frontend: %v",err)
+50}
+51
+52log.Printf("Got Frontend named '%v' with mode '%v'",frontend.Name,frontend.Mode)
+53}
+54}
+
This new generic client will one day be the only client in go-anxcloud. The legacy API-specific clients are deprecated and will be removed in the
+go-anxcloud release following the one with all APIs go-anxcloud supports usable with the generic client (so if the generic client in 0.5.0 supports
+at least everything there is another client for in go-anxcloud, 0.6.0 will drop the API-specific clients).
+
+
1packagemain
+ 2
+ 3import(
+ 4"context"
+ 5"fmt"
+ 6"time"
+ 7
+ 8anexia"go.anx.io/go-anxcloud/pkg"
+ 9"go.anx.io/go-anxcloud/pkg/client"
+10"go.anx.io/go-anxcloud/pkg/vsphere/provisioning/vm"
+11)
+12
+13funcmain(){
+14vlan:="<ID of the VLAN the VM should have access to>"
+15location:="<ID of the location the VM should be in>"
+16
+17// Create client using the auth token in environment variable ANEXIA_TOKEN and do not unset the environment variable.
+18c,err:=client.New(client.AuthFromEnv(false))
+19iferr!=nil{
+20panic(fmt.Sprintf("could not create client: %v",err))
+21}
+22
+23// Get some API.
+24provisioning:=anexia.NewAPI(c).VSphere().Provisioning()
+25
+26// Time out after 30 minutes. Yes it really takes that long sometimes.
+27ctx,cancel:=context.WithTimeout(context.Background(),30*time.Minute)
+28// Look for a free ip in the given VLAN. This IP is not reserved for you so better be quick.
+29ips,err:=provisioning.IPs().GetFree(ctx,location,vlan)
+30defercancel()
+31iferr!=nil{
+32panic(fmt.Sprintf("provisioning vm failed: %v",err))
+33}
+34iflen(ips)<1{
+35panic(fmt.Sprintf("no IPs left for testing in vlan"))
+36}
+37
+38// Create a NIC for the VM and connect it to the VLAN.
+39networkInterfaces:=[]vm.Network{{NICType:"vmxnet3",IPs:[]string{ips[0].Identifier},VLAN:vlan}}
+40// Create the definition of the new VM. The ID you see here is Flatcar.
+41definition:=vm.NewAPI(c).NewDefinition(location,"template","44b38284-6adb-430e-b4a4-1553e29f352f","developersfirstvm",2,2048,10,networkInterfaces)
+42definition.SSH="<your SSH pub key>"
+43
+44// Provision the VM.
+45provisionResponse,err:=provisioning.VM().Provision(ctx,definition)
+46iferr!=nil{
+47panic(fmt.Sprintf("provisioning vm failed: %v",err))
+48}
+49
+50// Wait for the VM to be ready.
+51_,err=provisioning.Progress().AwaitCompletion(ctx,provisionResponse.Identifier)
+52iferr!=nil{
+53panic(fmt.Sprintf("waiting for VM provisioning failed: %v",err))
+54}
+55}
+
+
+
+
+
+
\ No newline at end of file
diff --git a/go-anxcloud/README.md@v0.4.5/index.html b/go-anxcloud/README.md@v0.4.5/index.html
new file mode 100644
index 0000000000..20497163a5
--- /dev/null
+++ b/go-anxcloud/README.md@v0.4.5/index.html
@@ -0,0 +1,346 @@
+
+
+
+ go.anx.io/go-anxcloud - Go Client for the Anexia API
+
+
+
+
+
+
+
+
+
+
+
go.anx.io/go-anxcloud
+
+
+
+
+
+
+
Go Client for the Anexia API
+
Go SDK for interacting with the Anexia Engine API.
+
Installing
+
To use the SDK, just add go.anx.io/go-anxcloud <version> to your Go module.
+
Getting started
+
Before using the SDK you should familiarize yourself with the Anexia Engine API.
+
The library is used in our terraform provider, check it out if you want some examples how to use it.
+
Example
+
Below is a short example using the new generic client in this package. Not all APIs can already be used with it, but we are working on that.
+Find more examples in the docs (linked to docs for
+main branch, not the latest (or any) release).
+
1packagemain
+ 2
+ 3import(
+ 4"context"
+ 5"log"
+ 6
+ 7"go.anx.io/go-anxcloud/pkg/api"
+ 8apiTypes"go.anx.io/go-anxcloud/pkg/api/types"
+ 9"go.anx.io/go-anxcloud/pkg/client"
+10
+11// apis usable with the generic client have their own package in a location analog to this
+12lbaasv1"go.anx.io/go-anxcloud/pkg/apis/lbaas/v1"
+13)
+14
+15funcmain(){
+16apiClient,err:=api.NewAPI(
+17api.WithClientOptions(
+18// Get auth token from ANEXIA_TOKEN environment variable.
+19// The boolean parameter specifies if the environment variable should be unset.
+20client.TokenFromEnv(false),
+21),
+22)
+23iferr!=nil{
+24log.Fatalf("Error creating ANX API client: %v",err)
+25}
+26
+27// let's list LBaaS backends of a known LoadBalancer
+28frontend:=lbaasv1.Frontend{
+29LoadBalancer:lbaasv1.LoadBalancer{Identifier:"285b954fdf2a449c8fdae01cc6074025"},
+30}
+31
+32varfrontendsapiTypes.ObjectChannel
+33err=apiClient.List(context.TODO(),&frontend,
+34// Listing can be done with either a page iterator or a channel, we use a channel here.
+35api.ObjectChannel(&frontends),
+36
+37// Most APIs only give a very small subset when listing resources, add this flag to
+38// get all attributes, at the cost of doing lots of API requests.
+39api.FullObjects(true),
+40)
+41iferr!=nil{
+42log.Fatalf("Error listing backends for LoadBalancer '%v': %v",frontend.LoadBalancer.Identifier,err)
+43}
+44
+45forretriever:=rangefrontends{
+46// reinitialise frontend every loop to reset pointers and avoid potential overwriting of data in the next loop
+47varfrontendlbaasv1.Frontend
+48iferr:=retriever(&frontend);err!=nil{
+49log.Fatalf("Error retrieving Frontend: %v",err)
+50}
+51
+52log.Printf("Got Frontend named '%v' with mode '%v'",frontend.Name,frontend.Mode)
+53}
+54}
+
This new generic client will one day be the only client in go-anxcloud. The legacy API-specific clients are deprecated and will be removed in the
+go-anxcloud release following the one with all APIs go-anxcloud supports usable with the generic client (so if the generic client in 0.5.0 supports
+at least everything there is another client for in go-anxcloud, 0.6.0 will drop the API-specific clients).
+
+
1packagemain
+ 2
+ 3import(
+ 4"context"
+ 5"fmt"
+ 6"time"
+ 7
+ 8anexia"go.anx.io/go-anxcloud/pkg"
+ 9"go.anx.io/go-anxcloud/pkg/client"
+10"go.anx.io/go-anxcloud/pkg/vsphere/provisioning/vm"
+11)
+12
+13funcmain(){
+14vlan:="<ID of the VLAN the VM should have access to>"
+15location:="<ID of the location the VM should be in>"
+16
+17// Create client using the auth token in environment variable ANEXIA_TOKEN and do not unset the environment variable.
+18c,err:=client.New(client.AuthFromEnv(false))
+19iferr!=nil{
+20panic(fmt.Sprintf("could not create client: %v",err))
+21}
+22
+23// Get some API.
+24provisioning:=anexia.NewAPI(c).VSphere().Provisioning()
+25
+26// Time out after 30 minutes. Yes it really takes that long sometimes.
+27ctx,cancel:=context.WithTimeout(context.Background(),30*time.Minute)
+28// Look for a free ip in the given VLAN. This IP is not reserved for you so better be quick.
+29ips,err:=provisioning.IPs().GetFree(ctx,location,vlan)
+30defercancel()
+31iferr!=nil{
+32panic(fmt.Sprintf("provisioning vm failed: %v",err))
+33}
+34iflen(ips)<1{
+35panic(fmt.Sprintf("no IPs left for testing in vlan"))
+36}
+37
+38// Create a NIC for the VM and connect it to the VLAN.
+39networkInterfaces:=[]vm.Network{{NICType:"vmxnet3",IPs:[]string{ips[0].Identifier},VLAN:vlan}}
+40// Create the definition of the new VM. The ID you see here is Flatcar.
+41definition:=vm.NewAPI(c).NewDefinition(location,"template","44b38284-6adb-430e-b4a4-1553e29f352f","developersfirstvm",2,2048,10,networkInterfaces)
+42definition.SSH="<your SSH pub key>"
+43
+44// Provision the VM.
+45provisionResponse,err:=provisioning.VM().Provision(ctx,definition)
+46iferr!=nil{
+47panic(fmt.Sprintf("provisioning vm failed: %v",err))
+48}
+49
+50// Wait for the VM to be ready.
+51_,err=provisioning.Progress().AwaitCompletion(ctx,provisionResponse.Identifier)
+52iferr!=nil{
+53panic(fmt.Sprintf("waiting for VM provisioning failed: %v",err))
+54}
+55}
+
+
+
+
+
+
\ No newline at end of file
diff --git a/go-anxcloud/README.md@v0.4.6/index.html b/go-anxcloud/README.md@v0.4.6/index.html
new file mode 100644
index 0000000000..5459f56637
--- /dev/null
+++ b/go-anxcloud/README.md@v0.4.6/index.html
@@ -0,0 +1,346 @@
+
+
+
+ go.anx.io/go-anxcloud - Go Client for the Anexia API
+
+
+
+
+
+
+
+
+
+
+
go.anx.io/go-anxcloud
+
+
+
+
+
+
+
Go Client for the Anexia API
+
Go SDK for interacting with the Anexia Engine API.
+
Installing
+
To use the SDK, just add go.anx.io/go-anxcloud <version> to your Go module.
+
Getting started
+
Before using the SDK you should familiarize yourself with the Anexia Engine API.
+
The library is used in our terraform provider, check it out if you want some examples how to use it.
+
Example
+
Below is a short example using the new generic client in this package. Not all APIs can already be used with it, but we are working on that.
+Find more examples in the docs (linked to docs for
+main branch, not the latest (or any) release).
+
1packagemain
+ 2
+ 3import(
+ 4"context"
+ 5"log"
+ 6
+ 7"go.anx.io/go-anxcloud/pkg/api"
+ 8apiTypes"go.anx.io/go-anxcloud/pkg/api/types"
+ 9"go.anx.io/go-anxcloud/pkg/client"
+10
+11// apis usable with the generic client have their own package in a location analog to this
+12lbaasv1"go.anx.io/go-anxcloud/pkg/apis/lbaas/v1"
+13)
+14
+15funcmain(){
+16apiClient,err:=api.NewAPI(
+17api.WithClientOptions(
+18// Get auth token from ANEXIA_TOKEN environment variable.
+19// The boolean parameter specifies if the environment variable should be unset.
+20client.TokenFromEnv(false),
+21),
+22)
+23iferr!=nil{
+24log.Fatalf("Error creating ANX API client: %v",err)
+25}
+26
+27// let's list LBaaS backends of a known LoadBalancer
+28frontend:=lbaasv1.Frontend{
+29LoadBalancer:lbaasv1.LoadBalancer{Identifier:"285b954fdf2a449c8fdae01cc6074025"},
+30}
+31
+32varfrontendsapiTypes.ObjectChannel
+33err=apiClient.List(context.TODO(),&frontend,
+34// Listing can be done with either a page iterator or a channel, we use a channel here.
+35api.ObjectChannel(&frontends),
+36
+37// Most APIs only give a very small subset when listing resources, add this flag to
+38// get all attributes, at the cost of doing lots of API requests.
+39api.FullObjects(true),
+40)
+41iferr!=nil{
+42log.Fatalf("Error listing backends for LoadBalancer '%v': %v",frontend.LoadBalancer.Identifier,err)
+43}
+44
+45forretriever:=rangefrontends{
+46// reinitialise frontend every loop to reset pointers and avoid potential overwriting of data in the next loop
+47varfrontendlbaasv1.Frontend
+48iferr:=retriever(&frontend);err!=nil{
+49log.Fatalf("Error retrieving Frontend: %v",err)
+50}
+51
+52log.Printf("Got Frontend named '%v' with mode '%v'",frontend.Name,frontend.Mode)
+53}
+54}
+
This new generic client will one day be the only client in go-anxcloud. The legacy API-specific clients are deprecated and will be removed in the
+go-anxcloud release following the one with all APIs go-anxcloud supports usable with the generic client (so if the generic client in 0.5.0 supports
+at least everything there is another client for in go-anxcloud, 0.6.0 will drop the API-specific clients).
+
+
1packagemain
+ 2
+ 3import(
+ 4"context"
+ 5"fmt"
+ 6"time"
+ 7
+ 8anexia"go.anx.io/go-anxcloud/pkg"
+ 9"go.anx.io/go-anxcloud/pkg/client"
+10"go.anx.io/go-anxcloud/pkg/vsphere/provisioning/vm"
+11)
+12
+13funcmain(){
+14vlan:="<ID of the VLAN the VM should have access to>"
+15location:="<ID of the location the VM should be in>"
+16
+17// Create client using the auth token in environment variable ANEXIA_TOKEN and do not unset the environment variable.
+18c,err:=client.New(client.AuthFromEnv(false))
+19iferr!=nil{
+20panic(fmt.Sprintf("could not create client: %v",err))
+21}
+22
+23// Get some API.
+24provisioning:=anexia.NewAPI(c).VSphere().Provisioning()
+25
+26// Time out after 30 minutes. Yes it really takes that long sometimes.
+27ctx,cancel:=context.WithTimeout(context.Background(),30*time.Minute)
+28// Look for a free ip in the given VLAN. This IP is not reserved for you so better be quick.
+29ips,err:=provisioning.IPs().GetFree(ctx,location,vlan)
+30defercancel()
+31iferr!=nil{
+32panic(fmt.Sprintf("provisioning vm failed: %v",err))
+33}
+34iflen(ips)<1{
+35panic(fmt.Sprintf("no IPs left for testing in vlan"))
+36}
+37
+38// Create a NIC for the VM and connect it to the VLAN.
+39networkInterfaces:=[]vm.Network{{NICType:"vmxnet3",IPs:[]string{ips[0].Identifier},VLAN:vlan}}
+40// Create the definition of the new VM. The ID you see here is Flatcar.
+41definition:=vm.NewAPI(c).NewDefinition(location,"template","44b38284-6adb-430e-b4a4-1553e29f352f","developersfirstvm",2,2048,10,networkInterfaces)
+42definition.SSH="<your SSH pub key>"
+43
+44// Provision the VM.
+45provisionResponse,err:=provisioning.VM().Provision(ctx,definition)
+46iferr!=nil{
+47panic(fmt.Sprintf("provisioning vm failed: %v",err))
+48}
+49
+50// Wait for the VM to be ready.
+51_,err=provisioning.Progress().AwaitCompletion(ctx,provisionResponse.Identifier)
+52iferr!=nil{
+53panic(fmt.Sprintf("waiting for VM provisioning failed: %v",err))
+54}
+55}
+
+
+
+
+
+
\ No newline at end of file
diff --git a/go-anxcloud/README.md@v0.5.0/index.html b/go-anxcloud/README.md@v0.5.0/index.html
new file mode 100644
index 0000000000..d6843defd0
--- /dev/null
+++ b/go-anxcloud/README.md@v0.5.0/index.html
@@ -0,0 +1,346 @@
+
+
+
+ go.anx.io/go-anxcloud - Go Client for the Anexia API
+
+
+
+
+
+
+
+
+
+
+
go.anx.io/go-anxcloud
+
+
+
+
+
+
+
Go Client for the Anexia API
+
Go SDK for interacting with the Anexia Engine API.
+
Installing
+
To use the SDK, just add go.anx.io/go-anxcloud <version> to your Go module.
+
Getting started
+
Before using the SDK you should familiarize yourself with the Anexia Engine API.
+
The library is used in our terraform provider, check it out if you want some examples how to use it.
+
Example
+
Below is a short example using the new generic client in this package. Not all APIs can already be used with it, but we are working on that.
+Find more examples in the docs (linked to docs for
+main branch, not the latest (or any) release).
+
1packagemain
+ 2
+ 3import(
+ 4"context"
+ 5"log"
+ 6
+ 7"go.anx.io/go-anxcloud/pkg/api"
+ 8apiTypes"go.anx.io/go-anxcloud/pkg/api/types"
+ 9"go.anx.io/go-anxcloud/pkg/client"
+10
+11// apis usable with the generic client have their own package in a location analog to this
+12lbaasv1"go.anx.io/go-anxcloud/pkg/apis/lbaas/v1"
+13)
+14
+15funcmain(){
+16apiClient,err:=api.NewAPI(
+17api.WithClientOptions(
+18// Get auth token from ANEXIA_TOKEN environment variable.
+19// The boolean parameter specifies if the environment variable should be unset.
+20client.TokenFromEnv(false),
+21),
+22)
+23iferr!=nil{
+24log.Fatalf("Error creating ANX API client: %v",err)
+25}
+26
+27// let's list LBaaS backends of a known LoadBalancer
+28frontend:=lbaasv1.Frontend{
+29LoadBalancer:lbaasv1.LoadBalancer{Identifier:"285b954fdf2a449c8fdae01cc6074025"},
+30}
+31
+32varfrontendsapiTypes.ObjectChannel
+33err=apiClient.List(context.TODO(),&frontend,
+34// Listing can be done with either a page iterator or a channel, we use a channel here.
+35api.ObjectChannel(&frontends),
+36
+37// Most APIs only give a very small subset when listing resources, add this flag to
+38// get all attributes, at the cost of doing lots of API requests.
+39api.FullObjects(true),
+40)
+41iferr!=nil{
+42log.Fatalf("Error listing backends for LoadBalancer '%v': %v",frontend.LoadBalancer.Identifier,err)
+43}
+44
+45forretriever:=rangefrontends{
+46// reinitialise frontend every loop to reset pointers and avoid potential overwriting of data in the next loop
+47varfrontendlbaasv1.Frontend
+48iferr:=retriever(&frontend);err!=nil{
+49log.Fatalf("Error retrieving Frontend: %v",err)
+50}
+51
+52log.Printf("Got Frontend named '%v' with mode '%v'",frontend.Name,frontend.Mode)
+53}
+54}
+
This new generic client will one day be the only client in go-anxcloud. The legacy API-specific clients are deprecated and will be removed in the
+go-anxcloud release following the one with all APIs go-anxcloud supports usable with the generic client (so if the generic client in 0.5.0 supports
+at least everything there is another client for in go-anxcloud, 0.6.0 will drop the API-specific clients).
+
+
1packagemain
+ 2
+ 3import(
+ 4"context"
+ 5"fmt"
+ 6"time"
+ 7
+ 8anexia"go.anx.io/go-anxcloud/pkg"
+ 9"go.anx.io/go-anxcloud/pkg/client"
+10"go.anx.io/go-anxcloud/pkg/vsphere/provisioning/vm"
+11)
+12
+13funcmain(){
+14vlan:="<ID of the VLAN the VM should have access to>"
+15location:="<ID of the location the VM should be in>"
+16
+17// Create client using the auth token in environment variable ANEXIA_TOKEN and do not unset the environment variable.
+18c,err:=client.New(client.AuthFromEnv(false))
+19iferr!=nil{
+20panic(fmt.Sprintf("could not create client: %v",err))
+21}
+22
+23// Get some API.
+24provisioning:=anexia.NewAPI(c).VSphere().Provisioning()
+25
+26// Time out after 30 minutes. Yes it really takes that long sometimes.
+27ctx,cancel:=context.WithTimeout(context.Background(),30*time.Minute)
+28// Look for a free ip in the given VLAN. This IP is not reserved for you so better be quick.
+29ips,err:=provisioning.IPs().GetFree(ctx,location,vlan)
+30defercancel()
+31iferr!=nil{
+32panic(fmt.Sprintf("provisioning vm failed: %v",err))
+33}
+34iflen(ips)<1{
+35panic(fmt.Sprintf("no IPs left for testing in vlan"))
+36}
+37
+38// Create a NIC for the VM and connect it to the VLAN.
+39networkInterfaces:=[]vm.Network{{NICType:"vmxnet3",IPs:[]string{ips[0].Identifier},VLAN:vlan}}
+40// Create the definition of the new VM. The ID you see here is Flatcar.
+41definition:=vm.NewAPI(c).NewDefinition(location,"template","44b38284-6adb-430e-b4a4-1553e29f352f","developersfirstvm",2,2048,10,networkInterfaces)
+42definition.SSH="<your SSH pub key>"
+43
+44// Provision the VM.
+45provisionResponse,err:=provisioning.VM().Provision(ctx,definition)
+46iferr!=nil{
+47panic(fmt.Sprintf("provisioning vm failed: %v",err))
+48}
+49
+50// Wait for the VM to be ready.
+51_,err=provisioning.Progress().AwaitCompletion(ctx,provisionResponse.Identifier)
+52iferr!=nil{
+53panic(fmt.Sprintf("waiting for VM provisioning failed: %v",err))
+54}
+55}
+
+
+
+
+
+
\ No newline at end of file
diff --git a/go-anxcloud/README.md@v0.5.1/index.html b/go-anxcloud/README.md@v0.5.1/index.html
new file mode 100644
index 0000000000..6f8f4fde9f
--- /dev/null
+++ b/go-anxcloud/README.md@v0.5.1/index.html
@@ -0,0 +1,346 @@
+
+
+
+ go.anx.io/go-anxcloud - Go Client for the Anexia API
+
+
+
+
+
+
+
+
+
+
+
go.anx.io/go-anxcloud
+
+
+
+
+
+
+
Go Client for the Anexia API
+
Go SDK for interacting with the Anexia Engine API.
+
Installing
+
To use the SDK, just add go.anx.io/go-anxcloud <version> to your Go module.
+
Getting started
+
Before using the SDK you should familiarize yourself with the Anexia Engine API.
+
The library is used in our terraform provider, check it out if you want some examples how to use it.
+
Example
+
Below is a short example using the new generic client in this package. Not all APIs can already be used with it, but we are working on that.
+Find more examples in the docs (linked to docs for
+main branch, not the latest (or any) release).
+
1packagemain
+ 2
+ 3import(
+ 4"context"
+ 5"log"
+ 6
+ 7"go.anx.io/go-anxcloud/pkg/api"
+ 8apiTypes"go.anx.io/go-anxcloud/pkg/api/types"
+ 9"go.anx.io/go-anxcloud/pkg/client"
+10
+11// apis usable with the generic client have their own package in a location analog to this
+12lbaasv1"go.anx.io/go-anxcloud/pkg/apis/lbaas/v1"
+13)
+14
+15funcmain(){
+16apiClient,err:=api.NewAPI(
+17api.WithClientOptions(
+18// Get auth token from ANEXIA_TOKEN environment variable.
+19// The boolean parameter specifies if the environment variable should be unset.
+20client.TokenFromEnv(false),
+21),
+22)
+23iferr!=nil{
+24log.Fatalf("Error creating ANX API client: %v",err)
+25}
+26
+27// let's list LBaaS backends of a known LoadBalancer
+28frontend:=lbaasv1.Frontend{
+29LoadBalancer:lbaasv1.LoadBalancer{Identifier:"285b954fdf2a449c8fdae01cc6074025"},
+30}
+31
+32varfrontendsapiTypes.ObjectChannel
+33err=apiClient.List(context.TODO(),&frontend,
+34// Listing can be done with either a page iterator or a channel, we use a channel here.
+35api.ObjectChannel(&frontends),
+36
+37// Most APIs only give a very small subset when listing resources, add this flag to
+38// get all attributes, at the cost of doing lots of API requests.
+39api.FullObjects(true),
+40)
+41iferr!=nil{
+42log.Fatalf("Error listing backends for LoadBalancer '%v': %v",frontend.LoadBalancer.Identifier,err)
+43}
+44
+45forretriever:=rangefrontends{
+46// reinitialise frontend every loop to reset pointers and avoid potential overwriting of data in the next loop
+47varfrontendlbaasv1.Frontend
+48iferr:=retriever(&frontend);err!=nil{
+49log.Fatalf("Error retrieving Frontend: %v",err)
+50}
+51
+52log.Printf("Got Frontend named '%v' with mode '%v'",frontend.Name,frontend.Mode)
+53}
+54}
+
This new generic client will one day be the only client in go-anxcloud. The legacy API-specific clients are deprecated and will be removed in the
+go-anxcloud release following the one with all APIs go-anxcloud supports usable with the generic client (so if the generic client in 0.5.0 supports
+at least everything there is another client for in go-anxcloud, 0.6.0 will drop the API-specific clients).
+
+
1packagemain
+ 2
+ 3import(
+ 4"context"
+ 5"fmt"
+ 6"time"
+ 7
+ 8anexia"go.anx.io/go-anxcloud/pkg"
+ 9"go.anx.io/go-anxcloud/pkg/client"
+10"go.anx.io/go-anxcloud/pkg/vsphere/provisioning/vm"
+11)
+12
+13funcmain(){
+14vlan:="<ID of the VLAN the VM should have access to>"
+15location:="<ID of the location the VM should be in>"
+16
+17// Create client using the auth token in environment variable ANEXIA_TOKEN and do not unset the environment variable.
+18c,err:=client.New(client.AuthFromEnv(false))
+19iferr!=nil{
+20panic(fmt.Sprintf("could not create client: %v",err))
+21}
+22
+23// Get some API.
+24provisioning:=anexia.NewAPI(c).VSphere().Provisioning()
+25
+26// Time out after 30 minutes. Yes it really takes that long sometimes.
+27ctx,cancel:=context.WithTimeout(context.Background(),30*time.Minute)
+28// Look for a free ip in the given VLAN. This IP is not reserved for you so better be quick.
+29ips,err:=provisioning.IPs().GetFree(ctx,location,vlan)
+30defercancel()
+31iferr!=nil{
+32panic(fmt.Sprintf("provisioning vm failed: %v",err))
+33}
+34iflen(ips)<1{
+35panic(fmt.Sprintf("no IPs left for testing in vlan"))
+36}
+37
+38// Create a NIC for the VM and connect it to the VLAN.
+39networkInterfaces:=[]vm.Network{{NICType:"vmxnet3",IPs:[]string{ips[0].Identifier},VLAN:vlan}}
+40// Create the definition of the new VM. The ID you see here is Flatcar.
+41definition:=vm.NewAPI(c).NewDefinition(location,"template","44b38284-6adb-430e-b4a4-1553e29f352f","developersfirstvm",2,2048,10,networkInterfaces)
+42definition.SSH="<your SSH pub key>"
+43
+44// Provision the VM.
+45provisionResponse,err:=provisioning.VM().Provision(ctx,definition)
+46iferr!=nil{
+47panic(fmt.Sprintf("provisioning vm failed: %v",err))
+48}
+49
+50// Wait for the VM to be ready.
+51_,err=provisioning.Progress().AwaitCompletion(ctx,provisionResponse.Identifier)
+52iferr!=nil{
+53panic(fmt.Sprintf("waiting for VM provisioning failed: %v",err))
+54}
+55}
+
+
+
+
+
+
\ No newline at end of file
diff --git a/go-anxcloud/README.md@v0.5.2/index.html b/go-anxcloud/README.md@v0.5.2/index.html
new file mode 100644
index 0000000000..8cd2d7cea9
--- /dev/null
+++ b/go-anxcloud/README.md@v0.5.2/index.html
@@ -0,0 +1,346 @@
+
+
+
+ go.anx.io/go-anxcloud - Go Client for the Anexia API
+
+
+
+
+
+
+
+
+
+
+
go.anx.io/go-anxcloud
+
+
+
+
+
+
+
Go Client for the Anexia API
+
Go SDK for interacting with the Anexia Engine API.
+
Installing
+
To use the SDK, just add go.anx.io/go-anxcloud <version> to your Go module.
+
Getting started
+
Before using the SDK you should familiarize yourself with the Anexia Engine API.
+
The library is used in our terraform provider, check it out if you want some examples how to use it.
+
Example
+
Below is a short example using the new generic client in this package. Not all APIs can already be used with it, but we are working on that.
+Find more examples in the docs (linked to docs for
+main branch, not the latest (or any) release).
+
1packagemain
+ 2
+ 3import(
+ 4"context"
+ 5"log"
+ 6
+ 7"go.anx.io/go-anxcloud/pkg/api"
+ 8apiTypes"go.anx.io/go-anxcloud/pkg/api/types"
+ 9"go.anx.io/go-anxcloud/pkg/client"
+10
+11// apis usable with the generic client have their own package in a location analog to this
+12lbaasv1"go.anx.io/go-anxcloud/pkg/apis/lbaas/v1"
+13)
+14
+15funcmain(){
+16apiClient,err:=api.NewAPI(
+17api.WithClientOptions(
+18// Get auth token from ANEXIA_TOKEN environment variable.
+19// The boolean parameter specifies if the environment variable should be unset.
+20client.TokenFromEnv(false),
+21),
+22)
+23iferr!=nil{
+24log.Fatalf("Error creating ANX API client: %v",err)
+25}
+26
+27// let's list LBaaS backends of a known LoadBalancer
+28frontend:=lbaasv1.Frontend{
+29LoadBalancer:lbaasv1.LoadBalancer{Identifier:"285b954fdf2a449c8fdae01cc6074025"},
+30}
+31
+32varfrontendsapiTypes.ObjectChannel
+33err=apiClient.List(context.TODO(),&frontend,
+34// Listing can be done with either a page iterator or a channel, we use a channel here.
+35api.ObjectChannel(&frontends),
+36
+37// Most APIs only give a very small subset when listing resources, add this flag to
+38// get all attributes, at the cost of doing lots of API requests.
+39api.FullObjects(true),
+40)
+41iferr!=nil{
+42log.Fatalf("Error listing backends for LoadBalancer '%v': %v",frontend.LoadBalancer.Identifier,err)
+43}
+44
+45forretriever:=rangefrontends{
+46// reinitialise frontend every loop to reset pointers and avoid potential overwriting of data in the next loop
+47varfrontendlbaasv1.Frontend
+48iferr:=retriever(&frontend);err!=nil{
+49log.Fatalf("Error retrieving Frontend: %v",err)
+50}
+51
+52log.Printf("Got Frontend named '%v' with mode '%v'",frontend.Name,frontend.Mode)
+53}
+54}
+
This new generic client will one day be the only client in go-anxcloud. The legacy API-specific clients are deprecated and will be removed in the
+go-anxcloud release following the one with all APIs go-anxcloud supports usable with the generic client (so if the generic client in 0.5.0 supports
+at least everything there is another client for in go-anxcloud, 0.6.0 will drop the API-specific clients).
+
+
1packagemain
+ 2
+ 3import(
+ 4"context"
+ 5"fmt"
+ 6"time"
+ 7
+ 8anexia"go.anx.io/go-anxcloud/pkg"
+ 9"go.anx.io/go-anxcloud/pkg/client"
+10"go.anx.io/go-anxcloud/pkg/vsphere/provisioning/vm"
+11)
+12
+13funcmain(){
+14vlan:="<ID of the VLAN the VM should have access to>"
+15location:="<ID of the location the VM should be in>"
+16
+17// Create client using the auth token in environment variable ANEXIA_TOKEN and do not unset the environment variable.
+18c,err:=client.New(client.AuthFromEnv(false))
+19iferr!=nil{
+20panic(fmt.Sprintf("could not create client: %v",err))
+21}
+22
+23// Get some API.
+24provisioning:=anexia.NewAPI(c).VSphere().Provisioning()
+25
+26// Time out after 30 minutes. Yes it really takes that long sometimes.
+27ctx,cancel:=context.WithTimeout(context.Background(),30*time.Minute)
+28// Look for a free ip in the given VLAN. This IP is not reserved for you so better be quick.
+29ips,err:=provisioning.IPs().GetFree(ctx,location,vlan)
+30defercancel()
+31iferr!=nil{
+32panic(fmt.Sprintf("provisioning vm failed: %v",err))
+33}
+34iflen(ips)<1{
+35panic(fmt.Sprintf("no IPs left for testing in vlan"))
+36}
+37
+38// Create a NIC for the VM and connect it to the VLAN.
+39networkInterfaces:=[]vm.Network{{NICType:"vmxnet3",IPs:[]string{ips[0].Identifier},VLAN:vlan}}
+40// Create the definition of the new VM. The ID you see here is Flatcar.
+41definition:=vm.NewAPI(c).NewDefinition(location,"template","44b38284-6adb-430e-b4a4-1553e29f352f","developersfirstvm",2,2048,10,networkInterfaces)
+42definition.SSH="<your SSH pub key>"
+43
+44// Provision the VM.
+45provisionResponse,err:=provisioning.VM().Provision(ctx,definition)
+46iferr!=nil{
+47panic(fmt.Sprintf("provisioning vm failed: %v",err))
+48}
+49
+50// Wait for the VM to be ready.
+51_,err=provisioning.Progress().AwaitCompletion(ctx,provisionResponse.Identifier)
+52iferr!=nil{
+53panic(fmt.Sprintf("waiting for VM provisioning failed: %v",err))
+54}
+55}
+
+
+
+
+
+
\ No newline at end of file
diff --git a/go-anxcloud/README.md@v0.5.3/index.html b/go-anxcloud/README.md@v0.5.3/index.html
new file mode 100644
index 0000000000..0699bdaedd
--- /dev/null
+++ b/go-anxcloud/README.md@v0.5.3/index.html
@@ -0,0 +1,346 @@
+
+
+
+ go.anx.io/go-anxcloud - Go Client for the Anexia API
+
+
+
+
+
+
+
+
+
+
+
go.anx.io/go-anxcloud
+
+
+
+
+
+
+
Go Client for the Anexia API
+
Go SDK for interacting with the Anexia Engine API.
+
Installing
+
To use the SDK, just add go.anx.io/go-anxcloud <version> to your Go module.
+
Getting started
+
Before using the SDK you should familiarize yourself with the Anexia Engine API.
+
The library is used in our terraform provider, check it out if you want some examples how to use it.
+
Example
+
Below is a short example using the new generic client in this package. Not all APIs can already be used with it, but we are working on that.
+Find more examples in the docs (linked to docs for
+main branch, not the latest (or any) release).
+
1packagemain
+ 2
+ 3import(
+ 4"context"
+ 5"log"
+ 6
+ 7"go.anx.io/go-anxcloud/pkg/api"
+ 8apiTypes"go.anx.io/go-anxcloud/pkg/api/types"
+ 9"go.anx.io/go-anxcloud/pkg/client"
+10
+11// apis usable with the generic client have their own package in a location analog to this
+12lbaasv1"go.anx.io/go-anxcloud/pkg/apis/lbaas/v1"
+13)
+14
+15funcmain(){
+16apiClient,err:=api.NewAPI(
+17api.WithClientOptions(
+18// Get auth token from ANEXIA_TOKEN environment variable.
+19// The boolean parameter specifies if the environment variable should be unset.
+20client.TokenFromEnv(false),
+21),
+22)
+23iferr!=nil{
+24log.Fatalf("Error creating ANX API client: %v",err)
+25}
+26
+27// let's list LBaaS backends of a known LoadBalancer
+28frontend:=lbaasv1.Frontend{
+29LoadBalancer:lbaasv1.LoadBalancer{Identifier:"285b954fdf2a449c8fdae01cc6074025"},
+30}
+31
+32varfrontendsapiTypes.ObjectChannel
+33err=apiClient.List(context.TODO(),&frontend,
+34// Listing can be done with either a page iterator or a channel, we use a channel here.
+35api.ObjectChannel(&frontends),
+36
+37// Most APIs only give a very small subset when listing resources, add this flag to
+38// get all attributes, at the cost of doing lots of API requests.
+39api.FullObjects(true),
+40)
+41iferr!=nil{
+42log.Fatalf("Error listing backends for LoadBalancer '%v': %v",frontend.LoadBalancer.Identifier,err)
+43}
+44
+45forretriever:=rangefrontends{
+46// reinitialise frontend every loop to reset pointers and avoid potential overwriting of data in the next loop
+47varfrontendlbaasv1.Frontend
+48iferr:=retriever(&frontend);err!=nil{
+49log.Fatalf("Error retrieving Frontend: %v",err)
+50}
+51
+52log.Printf("Got Frontend named '%v' with mode '%v'",frontend.Name,frontend.Mode)
+53}
+54}
+
This new generic client will one day be the only client in go-anxcloud. The legacy API-specific clients are deprecated and will be removed in the
+go-anxcloud release following the one with all APIs go-anxcloud supports usable with the generic client (so if the generic client in 0.5.0 supports
+at least everything there is another client for in go-anxcloud, 0.6.0 will drop the API-specific clients).
+
+
1packagemain
+ 2
+ 3import(
+ 4"context"
+ 5"fmt"
+ 6"time"
+ 7
+ 8anexia"go.anx.io/go-anxcloud/pkg"
+ 9"go.anx.io/go-anxcloud/pkg/client"
+10"go.anx.io/go-anxcloud/pkg/vsphere/provisioning/vm"
+11)
+12
+13funcmain(){
+14vlan:="<ID of the VLAN the VM should have access to>"
+15location:="<ID of the location the VM should be in>"
+16
+17// Create client using the auth token in environment variable ANEXIA_TOKEN and do not unset the environment variable.
+18c,err:=client.New(client.AuthFromEnv(false))
+19iferr!=nil{
+20panic(fmt.Sprintf("could not create client: %v",err))
+21}
+22
+23// Get some API.
+24provisioning:=anexia.NewAPI(c).VSphere().Provisioning()
+25
+26// Time out after 30 minutes. Yes it really takes that long sometimes.
+27ctx,cancel:=context.WithTimeout(context.Background(),30*time.Minute)
+28// Look for a free ip in the given VLAN. This IP is not reserved for you so better be quick.
+29ips,err:=provisioning.IPs().GetFree(ctx,location,vlan)
+30defercancel()
+31iferr!=nil{
+32panic(fmt.Sprintf("provisioning vm failed: %v",err))
+33}
+34iflen(ips)<1{
+35panic(fmt.Sprintf("no IPs left for testing in vlan"))
+36}
+37
+38// Create a NIC for the VM and connect it to the VLAN.
+39networkInterfaces:=[]vm.Network{{NICType:"vmxnet3",IPs:[]string{ips[0].Identifier},VLAN:vlan}}
+40// Create the definition of the new VM. The ID you see here is Flatcar.
+41definition:=vm.NewAPI(c).NewDefinition(location,"template","44b38284-6adb-430e-b4a4-1553e29f352f","developersfirstvm",2,2048,10,networkInterfaces)
+42definition.SSH="<your SSH pub key>"
+43
+44// Provision the VM.
+45provisionResponse,err:=provisioning.VM().Provision(ctx,definition)
+46iferr!=nil{
+47panic(fmt.Sprintf("provisioning vm failed: %v",err))
+48}
+49
+50// Wait for the VM to be ready.
+51_,err=provisioning.Progress().AwaitCompletion(ctx,provisionResponse.Identifier)
+52iferr!=nil{
+53panic(fmt.Sprintf("waiting for VM provisioning failed: %v",err))
+54}
+55}
+
+
+
+
+
+
\ No newline at end of file
diff --git a/go-anxcloud/index.html b/go-anxcloud/index.html
new file mode 100644
index 0000000000..0699bdaedd
--- /dev/null
+++ b/go-anxcloud/index.html
@@ -0,0 +1,346 @@
+
+
+
+ go.anx.io/go-anxcloud - Go Client for the Anexia API
+
+
+
+
+
+
+
+
+
+
+
go.anx.io/go-anxcloud
+
+
+
+
+
+
+
Go Client for the Anexia API
+
Go SDK for interacting with the Anexia Engine API.
+
Installing
+
To use the SDK, just add go.anx.io/go-anxcloud <version> to your Go module.
+
Getting started
+
Before using the SDK you should familiarize yourself with the Anexia Engine API.
+
The library is used in our terraform provider, check it out if you want some examples how to use it.
+
Example
+
Below is a short example using the new generic client in this package. Not all APIs can already be used with it, but we are working on that.
+Find more examples in the docs (linked to docs for
+main branch, not the latest (or any) release).
+
1packagemain
+ 2
+ 3import(
+ 4"context"
+ 5"log"
+ 6
+ 7"go.anx.io/go-anxcloud/pkg/api"
+ 8apiTypes"go.anx.io/go-anxcloud/pkg/api/types"
+ 9"go.anx.io/go-anxcloud/pkg/client"
+10
+11// apis usable with the generic client have their own package in a location analog to this
+12lbaasv1"go.anx.io/go-anxcloud/pkg/apis/lbaas/v1"
+13)
+14
+15funcmain(){
+16apiClient,err:=api.NewAPI(
+17api.WithClientOptions(
+18// Get auth token from ANEXIA_TOKEN environment variable.
+19// The boolean parameter specifies if the environment variable should be unset.
+20client.TokenFromEnv(false),
+21),
+22)
+23iferr!=nil{
+24log.Fatalf("Error creating ANX API client: %v",err)
+25}
+26
+27// let's list LBaaS backends of a known LoadBalancer
+28frontend:=lbaasv1.Frontend{
+29LoadBalancer:lbaasv1.LoadBalancer{Identifier:"285b954fdf2a449c8fdae01cc6074025"},
+30}
+31
+32varfrontendsapiTypes.ObjectChannel
+33err=apiClient.List(context.TODO(),&frontend,
+34// Listing can be done with either a page iterator or a channel, we use a channel here.
+35api.ObjectChannel(&frontends),
+36
+37// Most APIs only give a very small subset when listing resources, add this flag to
+38// get all attributes, at the cost of doing lots of API requests.
+39api.FullObjects(true),
+40)
+41iferr!=nil{
+42log.Fatalf("Error listing backends for LoadBalancer '%v': %v",frontend.LoadBalancer.Identifier,err)
+43}
+44
+45forretriever:=rangefrontends{
+46// reinitialise frontend every loop to reset pointers and avoid potential overwriting of data in the next loop
+47varfrontendlbaasv1.Frontend
+48iferr:=retriever(&frontend);err!=nil{
+49log.Fatalf("Error retrieving Frontend: %v",err)
+50}
+51
+52log.Printf("Got Frontend named '%v' with mode '%v'",frontend.Name,frontend.Mode)
+53}
+54}
+
This new generic client will one day be the only client in go-anxcloud. The legacy API-specific clients are deprecated and will be removed in the
+go-anxcloud release following the one with all APIs go-anxcloud supports usable with the generic client (so if the generic client in 0.5.0 supports
+at least everything there is another client for in go-anxcloud, 0.6.0 will drop the API-specific clients).
+
+
1packagemain
+ 2
+ 3import(
+ 4"context"
+ 5"fmt"
+ 6"time"
+ 7
+ 8anexia"go.anx.io/go-anxcloud/pkg"
+ 9"go.anx.io/go-anxcloud/pkg/client"
+10"go.anx.io/go-anxcloud/pkg/vsphere/provisioning/vm"
+11)
+12
+13funcmain(){
+14vlan:="<ID of the VLAN the VM should have access to>"
+15location:="<ID of the location the VM should be in>"
+16
+17// Create client using the auth token in environment variable ANEXIA_TOKEN and do not unset the environment variable.
+18c,err:=client.New(client.AuthFromEnv(false))
+19iferr!=nil{
+20panic(fmt.Sprintf("could not create client: %v",err))
+21}
+22
+23// Get some API.
+24provisioning:=anexia.NewAPI(c).VSphere().Provisioning()
+25
+26// Time out after 30 minutes. Yes it really takes that long sometimes.
+27ctx,cancel:=context.WithTimeout(context.Background(),30*time.Minute)
+28// Look for a free ip in the given VLAN. This IP is not reserved for you so better be quick.
+29ips,err:=provisioning.IPs().GetFree(ctx,location,vlan)
+30defercancel()
+31iferr!=nil{
+32panic(fmt.Sprintf("provisioning vm failed: %v",err))
+33}
+34iflen(ips)<1{
+35panic(fmt.Sprintf("no IPs left for testing in vlan"))
+36}
+37
+38// Create a NIC for the VM and connect it to the VLAN.
+39networkInterfaces:=[]vm.Network{{NICType:"vmxnet3",IPs:[]string{ips[0].Identifier},VLAN:vlan}}
+40// Create the definition of the new VM. The ID you see here is Flatcar.
+41definition:=vm.NewAPI(c).NewDefinition(location,"template","44b38284-6adb-430e-b4a4-1553e29f352f","developersfirstvm",2,2048,10,networkInterfaces)
+42definition.SSH="<your SSH pub key>"
+43
+44// Provision the VM.
+45provisionResponse,err:=provisioning.VM().Provision(ctx,definition)
+46iferr!=nil{
+47panic(fmt.Sprintf("provisioning vm failed: %v",err))
+48}
+49
+50// Wait for the VM to be ready.
+51_,err=provisioning.Progress().AwaitCompletion(ctx,provisionResponse.Identifier)
+52iferr!=nil{
+53panic(fmt.Sprintf("waiting for VM provisioning failed: %v",err))
+54}
+55}
+
+
+
+
+
+
\ No newline at end of file
diff --git a/go-cloudlog/README.md/index.html b/go-cloudlog/README.md/index.html
new file mode 100644
index 0000000000..4ed08d3fcd
--- /dev/null
+++ b/go-cloudlog/README.md/index.html
@@ -0,0 +1,111 @@
+
+
+
+ go.anx.io/go-cloudlog - go-cloudlog
+
+
+
+
+
+
+
+
+
+
+
go.anx.io/go-cloudlog
+
+
+
+ The highest tagged major version is v2.
+
+
+
+
go-cloudlog
+
+
+
+
+
go-cloudlog is a client library for Anexia CloudLog.
+
Currently it only provides to push events to CloudLog.
+
+
+
+
\ No newline at end of file
diff --git a/index.html b/index.html
new file mode 100644
index 0000000000..5dc586c277
--- /dev/null
+++ b/index.html
@@ -0,0 +1,65 @@
+
+
+
+
+ go.anx.io - go packages by Anexia
+
+
+
+
+
+
+
+
+
+
+ go.anx.io - go packages by Anexia
+
+
+
+
Hello world!
+
This website lists a collection of our Go packages, making them available via our vanity URL.
+
There might be more packages not added to this website, looking at our GitHub
+is a good way to find all of them (the link filters for things written in Go).
+
+
