github/kubernetes
1
0
Fork 0
mirror of https://github.com/k3s-io/kubernetes.git synced 2025-07-22 11:21:47 +00:00
Code Issues Projects Releases Wiki Activity

Merge pull request #40160 from wlan0/credentialprovider

Browse Source 
Automatic merge from submit-queue

add rancher credential provider

This adds rancher as a credential provider in kubernetes.

@erictune This might be a good opportunity to discuss adding a provision for people to have their own credential providers that is similar to the new cloud provider changes (https://github.com/kubernetes/community/pull/128). WDYT?

```
release-note
Added Rancher Credential Provider to use Rancher Registry credentials when running in a Rancher cluster
```
This commit is contained in:
Kubernetes Submit Queue 2017-04-07 22:12:18 -07:00 committed by GitHub
commit 67029858ae
169 changed files with 20811 additions and 29 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

9
Godeps/Godeps.json generated
View File

@ -1536,6 +1536,10 @@
"ImportPath": "github.com/gorilla/mux",
"Rev": "8096f47503459bcc74d1f4c487b7e6e42e5746b5"
},
{
"ImportPath": "github.com/gorilla/websocket",
"Rev": "6eb6ad425a89d9da7a5549bc6da8f79ba5c17844"
},
{
"ImportPath": "github.com/grpc-ecosystem/grpc-gateway/runtime",
"Comment": "v1.0.0-8-gf52d055",
@ -2222,6 +2226,11 @@
"Comment": "v1.0.0-1012-ge00690e",
"Rev": "e00690e87603abe613e9f02c816c7c4bef82e063"
},
{
"ImportPath": "github.com/rancher/go-rancher/client",
"Comment": "v0.1.0-196-g09693a8",
"Rev": "09693a8743ba5ee58c58c1b1e8a4abd17af00d45"
},
{
"ImportPath": "github.com/renstrom/dedent",
"Comment": "v1.0.0-3-g020d11c",

215
Godeps/LICENSES generated
View File

@ -53331,6 +53331,36 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
================================================================================
================================================================================
= vendor/github.com/gorilla/websocket licensed under: =
Copyright (c) 2013 The Gorilla WebSocket Authors. All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
Redistributions of source code must retain the above copyright notice, this
list of conditions and the following disclaimer.
Redistributions in binary form must reproduce the above copyright notice,
this list of conditions and the following disclaimer in the documentation
and/or other materials provided with the distribution.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
= vendor/github.com/gorilla/websocket/LICENSE c007b54a1743d596f46b2748d9f8c044 -
================================================================================
================================================================================
= vendor/github.com/grpc-ecosystem/grpc-gateway/runtime licensed under: =
@ -72197,6 +72227,191 @@ specific language governing permissions and limitations under the License.
================================================================================
================================================================================
= vendor/github.com/rancher/go-rancher/client licensed under: =
Apache License
Version 2.0, January 2004
http://www.apache.org/licenses/
TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
1. Definitions.
"License" shall mean the terms and conditions for use, reproduction,
and distribution as defined by Sections 1 through 9 of this document.
"Licensor" shall mean the copyright owner or entity authorized by
the copyright owner that is granting the License.
"Legal Entity" shall mean the union of the acting entity and all
other entities that control, are controlled by, or are under common
control with that entity. For the purposes of this definition,
"control" means (i) the power, direct or indirect, to cause the
direction or management of such entity, whether by contract or
otherwise, or (ii) ownership of fifty percent (50%) or more of the
outstanding shares, or (iii) beneficial ownership of such entity.
"You" (or "Your") shall mean an individual or Legal Entity
exercising permissions granted by this License.
"Source" form shall mean the preferred form for making modifications,
including but not limited to software source code, documentation
source, and configuration files.
"Object" form shall mean any form resulting from mechanical
transformation or translation of a Source form, including but
not limited to compiled object code, generated documentation,
and conversions to other media types.
"Work" shall mean the work of authorship, whether in Source or
Object form, made available under the License, as indicated by a
copyright notice that is included in or attached to the work
(an example is provided in the Appendix below).
"Derivative Works" shall mean any work, whether in Source or Object
form, that is based on (or derived from) the Work and for which the
editorial revisions, annotations, elaborations, or other modifications
represent, as a whole, an original work of authorship. For the purposes
of this License, Derivative Works shall not include works that remain
separable from, or merely link (or bind by name) to the interfaces of,
the Work and Derivative Works thereof.
"Contribution" shall mean any work of authorship, including
the original version of the Work and any modifications or additions
to that Work or Derivative Works thereof, that is intentionally
submitted to Licensor for inclusion in the Work by the copyright owner
or by an individual or Legal Entity authorized to submit on behalf of
the copyright owner. For the purposes of this definition, "submitted"
means any form of electronic, verbal, or written communication sent
to the Licensor or its representatives, including but not limited to
communication on electronic mailing lists, source code control systems,
and issue tracking systems that are managed by, or on behalf of, the
Licensor for the purpose of discussing and improving the Work, but
excluding communication that is conspicuously marked or otherwise
designated in writing by the copyright owner as "Not a Contribution."
"Contributor" shall mean Licensor and any individual or Legal Entity
on behalf of whom a Contribution has been received by Licensor and
subsequently incorporated within the Work.
2. Grant of Copyright License. Subject to the terms and conditions of
this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
copyright license to reproduce, prepare Derivative Works of,
publicly display, publicly perform, sublicense, and distribute the
Work and such Derivative Works in Source or Object form.
3. Grant of Patent License. Subject to the terms and conditions of
this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
(except as stated in this section) patent license to make, have made,
use, offer to sell, sell, import, and otherwise transfer the Work,
where such license applies only to those patent claims licensable
by such Contributor that are necessarily infringed by their
Contribution(s) alone or by combination of their Contribution(s)
with the Work to which such Contribution(s) was submitted. If You
institute patent litigation against any entity (including a
cross-claim or counterclaim in a lawsuit) alleging that the Work
or a Contribution incorporated within the Work constitutes direct
or contributory patent infringement, then any patent licenses
granted to You under this License for that Work shall terminate
as of the date such litigation is filed.
4. Redistribution. You may reproduce and distribute copies of the
Work or Derivative Works thereof in any medium, with or without
modifications, and in Source or Object form, provided that You
meet the following conditions:
(a) You must give any other recipients of the Work or
Derivative Works a copy of this License; and
(b) You must cause any modified files to carry prominent notices
stating that You changed the files; and
(c) You must retain, in the Source form of any Derivative Works
that You distribute, all copyright, patent, trademark, and
attribution notices from the Source form of the Work,
excluding those notices that do not pertain to any part of
the Derivative Works; and
(d) If the Work includes a "NOTICE" text file as part of its
distribution, then any Derivative Works that You distribute must
include a readable copy of the attribution notices contained
within such NOTICE file, excluding those notices that do not
pertain to any part of the Derivative Works, in at least one
of the following places: within a NOTICE text file distributed
as part of the Derivative Works; within the Source form or
documentation, if provided along with the Derivative Works; or,
within a display generated by the Derivative Works, if and
wherever such third-party notices normally appear. The contents
of the NOTICE file are for informational purposes only and
do not modify the License. You may add Your own attribution
notices within Derivative Works that You distribute, alongside
or as an addendum to the NOTICE text from the Work, provided
that such additional attribution notices cannot be construed
as modifying the License.
You may add Your own copyright statement to Your modifications and
may provide additional or different license terms and conditions
for use, reproduction, or distribution of Your modifications, or
for any such Derivative Works as a whole, provided Your use,
reproduction, and distribution of the Work otherwise complies with
the conditions stated in this License.
5. Submission of Contributions. Unless You explicitly state otherwise,
any Contribution intentionally submitted for inclusion in the Work
by You to the Licensor shall be under the terms and conditions of
this License, without any additional terms or conditions.
Notwithstanding the above, nothing herein shall supersede or modify
the terms of any separate license agreement you may have executed
with Licensor regarding such Contributions.
6. Trademarks. This License does not grant permission to use the trade
names, trademarks, service marks, or product names of the Licensor,
except as required for reasonable and customary use in describing the
origin of the Work and reproducing the content of the NOTICE file.
7. Disclaimer of Warranty. Unless required by applicable law or
agreed to in writing, Licensor provides the Work (and each
Contributor provides its Contributions) on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
implied, including, without limitation, any warranties or conditions
of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
PARTICULAR PURPOSE. You are solely responsible for determining the
appropriateness of using or redistributing the Work and assume any
risks associated with Your exercise of permissions under this License.
8. Limitation of Liability. In no event and under no legal theory,
whether in tort (including negligence), contract, or otherwise,
unless required by applicable law (such as deliberate and grossly
negligent acts) or agreed to in writing, shall any Contributor be
liable to You for damages, including any direct, indirect, special,
incidental, or consequential damages of any character arising as a
result of this License or out of the use or inability to use the
Work (including but not limited to damages for loss of goodwill,
work stoppage, computer failure or malfunction, or any and all
other commercial damages or losses), even if such Contributor
has been advised of the possibility of such damages.
9. Accepting Warranty or Additional Liability. While redistributing
the Work or Derivative Works thereof, You may choose to offer,
and charge a fee for, acceptance of support, warranty, indemnity,
or other liability obligations and/or rights consistent with this
License. However, in accepting such obligations, You may act only
on Your own behalf and on Your sole responsibility, not on behalf
of any other Contributor, and only if You agree to indemnify,
defend, and hold each Contributor harmless for any liability
incurred by, or claims asserted against, such Contributor by reason
of your accepting any such warranty or additional liability.
END OF TERMS AND CONDITIONS
= vendor/github.com/rancher/go-rancher/LICENSE 2ee41112a44fe7014dce33e26468ba93 -
================================================================================
================================================================================
= vendor/github.com/renstrom/dedent licensed under: =

1
cmd/kubelet/app/BUILD
View File

@ -48,6 +48,7 @@ go_library(
"//pkg/credentialprovider/aws:go_default_library",
"//pkg/credentialprovider/azure:go_default_library",
"//pkg/credentialprovider/gcp:go_default_library",
"//pkg/credentialprovider/rancher:go_default_library",
"//pkg/features:go_default_library",
"//pkg/kubelet:go_default_library",
"//pkg/kubelet/cadvisor:go_default_library",

1
cmd/kubelet/app/plugins.go
View File

@ -22,6 +22,7 @@ import (
_ "k8s.io/kubernetes/pkg/credentialprovider/aws"
_ "k8s.io/kubernetes/pkg/credentialprovider/azure"
_ "k8s.io/kubernetes/pkg/credentialprovider/gcp"
_ "k8s.io/kubernetes/pkg/credentialprovider/rancher"
// Network plugins
"k8s.io/kubernetes/pkg/kubelet/network"
"k8s.io/kubernetes/pkg/kubelet/network/cni"

1
pkg/credentialprovider/BUILD
View File

@ -51,6 +51,7 @@ filegroup(
"//pkg/credentialprovider/aws:all-srcs",
"//pkg/credentialprovider/azure:all-srcs",
"//pkg/credentialprovider/gcp:all-srcs",
"//pkg/credentialprovider/rancher:all-srcs",
],
tags = ["automanaged"],
)

47
pkg/credentialprovider/rancher/BUILD Normal file
View File

@ -0,0 +1,47 @@
package(default_visibility = ["//visibility:public"])
licenses(["notice"])
load(
"@io_bazel_rules_go//go:def.bzl",
"go_library",
"go_test",
)
go_test(
name = "go_default_test",
srcs = ["rancher_registry_credentials_test.go"],
library = ":go_default_library",
tags = ["automanaged"],
deps = [
"//pkg/credentialprovider:go_default_library",
"//vendor:github.com/rancher/go-rancher/client",
],
)
go_library(
name = "go_default_library",
srcs = [
"doc.go",
"rancher_registry_credentials.go",
],
tags = ["automanaged"],
deps = [
"//pkg/credentialprovider:go_default_library",
"//vendor:github.com/golang/glog",
"//vendor:github.com/rancher/go-rancher/client",
],
)
filegroup(
name = "package-srcs",
srcs = glob(["**"]),
tags = ["automanaged"],
visibility = ["//visibility:private"],
)
filegroup(
name = "all-srcs",
srcs = [":package-srcs"],
tags = ["automanaged"],
)

17
pkg/credentialprovider/rancher/doc.go Normal file
View File

@ -0,0 +1,17 @@
/*
Copyright 2017 The Kubernetes Authors.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
package rancher_credentials

145
pkg/credentialprovider/rancher/rancher_registry_credentials.go Normal file
View File

@ -0,0 +1,145 @@
/*
Copyright 2014 The Kubernetes Authors.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
package rancher_credentials
import (
"os"
"time"
"github.com/golang/glog"
"github.com/rancher/go-rancher/client"
"k8s.io/kubernetes/pkg/credentialprovider"
)
// rancher provider
type rancherProvider struct {
credGetter credentialsGetter
}
// credentials getter from Rancher private registry
type rancherCredentialsGetter struct {
client *client.RancherClient
}
type rConfig struct {
Global configGlobal
}
// An interface for testing purposes.
type credentialsGetter interface {
getCredentials() []registryCredential
}
type configGlobal struct {
CattleURL string `gcfg:"cattle-url"`
CattleAccessKey string `gcfg:"cattle-access-key"`
CattleSecretKey string `gcfg:"cattle-secret-key"`
}
type registryCredential struct {
credential *client.RegistryCredential
serverIP string
}
var rancherGetter = &rancherCredentialsGetter{}
func init() {
credentialprovider.RegisterCredentialProvider("rancher-registry-creds",
&credentialprovider.CachingDockerConfigProvider{
Provider: &rancherProvider{rancherGetter},
Lifetime: 30 * time.Second,
})
}
func (p *rancherProvider) Enabled() bool {
client, err := getRancherClient()
if err != nil {
return false
}
if client == nil {
return false
}
rancherGetter.client = client
return true
}
// LazyProvide implements DockerConfigProvider. Should never be called.
func (p *rancherProvider) LazyProvide() *credentialprovider.DockerConfigEntry {
return nil
}
// Provide implements DockerConfigProvider.Provide, refreshing Rancher tokens on demand
func (p *rancherProvider) Provide() credentialprovider.DockerConfig {
cfg := credentialprovider.DockerConfig{}
for _, cred := range p.credGetter.getCredentials() {
entry := credentialprovider.DockerConfigEntry{
Username: cred.credential.PublicValue,
Password: cred.credential.SecretValue,
Email: cred.credential.Email,
}
cfg[cred.serverIP] = entry
}
return cfg
}
func (g *rancherCredentialsGetter) getCredentials() []registryCredential {
var registryCreds []registryCredential
credColl, err := g.client.RegistryCredential.List(client.NewListOpts())
if err != nil {
glog.Errorf("Failed to pull registry credentials from rancher %v", err)
return registryCreds
}
for _, cred := range credColl.Data {
registry := &client.Registry{}
if err = g.client.GetLink(cred.Resource, "registry", registry); err != nil {
glog.Errorf("Failed to pull registry from rancher %v", err)
return registryCreds
}
registryCred := registryCredential{
credential: &cred,
serverIP: registry.ServerAddress,
}
registryCreds = append(registryCreds, registryCred)
}
return registryCreds
}
func getRancherClient() (*client.RancherClient, error) {
url := os.Getenv("CATTLE_URL")
accessKey := os.Getenv("CATTLE_ACCESS_KEY")
secretKey := os.Getenv("CATTLE_SECRET_KEY")
if url == "" || accessKey == "" || secretKey == "" {
return nil, nil
}
conf := rConfig{
Global: configGlobal{
CattleURL: url,
CattleAccessKey: accessKey,
CattleSecretKey: secretKey,
},
}
return client.NewRancherClient(&client.ClientOpts{
Url: conf.Global.CattleURL,
AccessKey: conf.Global.CattleAccessKey,
SecretKey: conf.Global.CattleSecretKey,
})
}

120
pkg/credentialprovider/rancher/rancher_registry_credentials_test.go Normal file
View File

@ -0,0 +1,120 @@
/*
Copyright 2014 The Kubernetes Authors.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
package rancher_credentials
import (
"path"
"testing"
"github.com/rancher/go-rancher/client"
"k8s.io/kubernetes/pkg/credentialprovider"
)
const username = "foo"
const password = "qwerty"
const email = "foo@bar.baz"
var serverAddresses = []string{"quay.io", "192.168.5.0"}
type testCredentialsGetter struct {
client *client.RancherClient
}
func (p *testCredentialsGetter) getCredentials() []registryCredential {
var registryCreds []registryCredential
for _, serverAddress := range serverAddresses {
cred := &client.RegistryCredential{
PublicValue: username,
SecretValue: password,
Email: email,
}
registryCred := registryCredential{
credential: cred,
serverIP: serverAddress,
}
registryCreds = append(registryCreds, registryCred)
}
return registryCreds
}
func TestRancherCredentialsProvide(t *testing.T) {
image := "foo/bar"
url := "http://localhost:8080"
accessKey := "B481F55E0C48C546E094"
secretKey := "dND2fBcytWWvCRJ8LvqnYcjyNfEkaikvfVxk2C5r"
conf := rConfig{
Global: configGlobal{
CattleURL: url,
CattleAccessKey: accessKey,
CattleSecretKey: secretKey,
},
}
rancherClient, _ := client.NewRancherClient(&client.ClientOpts{
Url: conf.Global.CattleURL,
AccessKey: conf.Global.CattleAccessKey,
SecretKey: conf.Global.CattleSecretKey,
})
testGetter := &testCredentialsGetter{
client: rancherClient,
}
provider := &rancherProvider{
credGetter: testGetter,
}
keyring := &credentialprovider.BasicDockerKeyring{}
keyring.Add(provider.Provide())
for _, registry := range serverAddresses {
fullImagePath := path.Join(registry, image)
creds, ok := keyring.Lookup(fullImagePath)
if !ok {
t.Errorf("Didn't find expected image: %s", fullImagePath)
return
}
if len(creds) > 1 {
t.Errorf("Expected 1 result, received %v", len(creds))
}
val := creds[0]
if username != val.Username {
t.Errorf("Unexpected username value, want: %s, got: %s", username, val.Username)
}
if password != val.Password {
t.Errorf("Unexpected password value, want: %s, got: %s", password, val.Password)
}
if email != val.Email {
t.Errorf("Unexpected email value, want: %s, got: %s", email, val.Email)
}
}
// try to fetch non-existing registry
fullImagePath := path.Join("1.1.1.1", image)
_, ok := keyring.Lookup(fullImagePath)
if ok {
t.Errorf("Found non-existing image: %s", fullImagePath)
}
return
}

229
vendor/BUILD vendored
View File

@ -1107,35 +1107,6 @@ go_library(
tags = ["automanaged"],
)
go_library(
name = "github.com/codedellemc/goscaleio",
srcs = [
"github.com/codedellemc/goscaleio/api.go",
"github.com/codedellemc/goscaleio/certs.go",
"github.com/codedellemc/goscaleio/device.go",
"github.com/codedellemc/goscaleio/instance.go",
"github.com/codedellemc/goscaleio/protectiondomain.go",
"github.com/codedellemc/goscaleio/scsiinitiator.go",
"github.com/codedellemc/goscaleio/sdc.go",
"github.com/codedellemc/goscaleio/sds.go",
"github.com/codedellemc/goscaleio/storagepool.go",
"github.com/codedellemc/goscaleio/system.go",
"github.com/codedellemc/goscaleio/user.go",
"github.com/codedellemc/goscaleio/volume.go",
],
tags = ["automanaged"],
deps = [
"//vendor:github.com/Sirupsen/logrus",
"//vendor:github.com/codedellemc/goscaleio/types/v1",
],
)
go_library(
name = "github.com/codedellemc/goscaleio/types/v1",
srcs = ["github.com/codedellemc/goscaleio/types/v1/types.go"],
tags = ["automanaged"],
)
go_library(
name = "github.com/codegangsta/negroni",
srcs = [
@ -16364,6 +16335,206 @@ filegroup(
tags = ["automanaged"],
)
go_library(
name = "github.com/gorilla/websocket",
srcs = [
"github.com/gorilla/websocket/client.go",
"github.com/gorilla/websocket/conn.go",
"github.com/gorilla/websocket/doc.go",
"github.com/gorilla/websocket/json.go",
"github.com/gorilla/websocket/server.go",
"github.com/gorilla/websocket/util.go",
],
tags = ["automanaged"],
)
go_library(
name = "github.com/rancher/go-rancher/client",
srcs = [
"github.com/rancher/go-rancher/client/client.go",
"github.com/rancher/go-rancher/client/common.go",
"github.com/rancher/go-rancher/client/generated_account.go",
"github.com/rancher/go-rancher/client/generated_active_setting.go",
"github.com/rancher/go-rancher/client/generated_add_outputs_input.go",
"github.com/rancher/go-rancher/client/generated_add_remove_load_balancer_service_link_input.go",
"github.com/rancher/go-rancher/client/generated_add_remove_service_link_input.go",
"github.com/rancher/go-rancher/client/generated_agent.go",
"github.com/rancher/go-rancher/client/generated_amazonec2config.go",
"github.com/rancher/go-rancher/client/generated_api_key.go",
"github.com/rancher/go-rancher/client/generated_audit_log.go",
"github.com/rancher/go-rancher/client/generated_azure_config.go",
"github.com/rancher/go-rancher/client/generated_azureadconfig.go",
"github.com/rancher/go-rancher/client/generated_backup.go",
"github.com/rancher/go-rancher/client/generated_backup_target.go",
"github.com/rancher/go-rancher/client/generated_base_machine_config.go",
"github.com/rancher/go-rancher/client/generated_blkio_device_option.go",
"github.com/rancher/go-rancher/client/generated_certificate.go",
"github.com/rancher/go-rancher/client/generated_change_secret_input.go",
"github.com/rancher/go-rancher/client/generated_client.go",
"github.com/rancher/go-rancher/client/generated_compose_config.go",
"github.com/rancher/go-rancher/client/generated_compose_config_input.go",
"github.com/rancher/go-rancher/client/generated_compose_project.go",
"github.com/rancher/go-rancher/client/generated_compose_service.go",
"github.com/rancher/go-rancher/client/generated_config_item.go",
"github.com/rancher/go-rancher/client/generated_config_item_status.go",
"github.com/rancher/go-rancher/client/generated_container.go",
"github.com/rancher/go-rancher/client/generated_container_event.go",
"github.com/rancher/go-rancher/client/generated_container_exec.go",
"github.com/rancher/go-rancher/client/generated_container_logs.go",
"github.com/rancher/go-rancher/client/generated_container_proxy.go",
"github.com/rancher/go-rancher/client/generated_credential.go",
"github.com/rancher/go-rancher/client/generated_databasechangelog.go",
"github.com/rancher/go-rancher/client/generated_databasechangeloglock.go",
"github.com/rancher/go-rancher/client/generated_digitalocean_config.go",
"github.com/rancher/go-rancher/client/generated_dns_service.go",
"github.com/rancher/go-rancher/client/generated_docker_build.go",
"github.com/rancher/go-rancher/client/generated_dynamic_schema.go",
"github.com/rancher/go-rancher/client/generated_environment.go",
"github.com/rancher/go-rancher/client/generated_environment_upgrade.go",
"github.com/rancher/go-rancher/client/generated_extension_implementation.go",
"github.com/rancher/go-rancher/client/generated_extension_point.go",
"github.com/rancher/go-rancher/client/generated_external_dns_event.go",
"github.com/rancher/go-rancher/client/generated_external_event.go",
"github.com/rancher/go-rancher/client/generated_external_handler.go",
"github.com/rancher/go-rancher/client/generated_external_handler_external_handler_process_map.go",
"github.com/rancher/go-rancher/client/generated_external_handler_process.go",
"github.com/rancher/go-rancher/client/generated_external_handler_process_config.go",
"github.com/rancher/go-rancher/client/generated_external_host_event.go",
"github.com/rancher/go-rancher/client/generated_external_service.go",
"github.com/rancher/go-rancher/client/generated_external_service_event.go",
"github.com/rancher/go-rancher/client/generated_external_storage_pool_event.go",
"github.com/rancher/go-rancher/client/generated_external_volume_event.go",
"github.com/rancher/go-rancher/client/generated_field_documentation.go",
"github.com/rancher/go-rancher/client/generated_githubconfig.go",
"github.com/rancher/go-rancher/client/generated_ha_config.go",
"github.com/rancher/go-rancher/client/generated_ha_config_input.go",
"github.com/rancher/go-rancher/client/generated_haproxy_config.go",
"github.com/rancher/go-rancher/client/generated_healthcheck_instance_host_map.go",
"github.com/rancher/go-rancher/client/generated_host.go",
"github.com/rancher/go-rancher/client/generated_host_access.go",
"github.com/rancher/go-rancher/client/generated_host_api_proxy_token.go",
"github.com/rancher/go-rancher/client/generated_identity.go",
"github.com/rancher/go-rancher/client/generated_image.go",
"github.com/rancher/go-rancher/client/generated_in_service_upgrade_strategy.go",
"github.com/rancher/go-rancher/client/generated_instance.go",
"github.com/rancher/go-rancher/client/generated_instance_console.go",
"github.com/rancher/go-rancher/client/generated_instance_console_input.go",
"github.com/rancher/go-rancher/client/generated_instance_health_check.go",
"github.com/rancher/go-rancher/client/generated_instance_link.go",
"github.com/rancher/go-rancher/client/generated_instance_stop.go",
"github.com/rancher/go-rancher/client/generated_ip_address.go",
"github.com/rancher/go-rancher/client/generated_ip_address_associate_input.go",
"github.com/rancher/go-rancher/client/generated_kubernetes_service.go",
"github.com/rancher/go-rancher/client/generated_kubernetes_stack.go",
"github.com/rancher/go-rancher/client/generated_kubernetes_stack_upgrade.go",
"github.com/rancher/go-rancher/client/generated_label.go",
"github.com/rancher/go-rancher/client/generated_launch_config.go",
"github.com/rancher/go-rancher/client/generated_ldapconfig.go",
"github.com/rancher/go-rancher/client/generated_load_balancer_app_cookie_stickiness_policy.go",
"github.com/rancher/go-rancher/client/generated_load_balancer_config.go",
"github.com/rancher/go-rancher/client/generated_load_balancer_cookie_stickiness_policy.go",
"github.com/rancher/go-rancher/client/generated_load_balancer_service.go",
"github.com/rancher/go-rancher/client/generated_load_balancer_service_link.go",
"github.com/rancher/go-rancher/client/generated_local_auth_config.go",
"github.com/rancher/go-rancher/client/generated_log_config.go",
"github.com/rancher/go-rancher/client/generated_machine.go",
"github.com/rancher/go-rancher/client/generated_machine_driver.go",
"github.com/rancher/go-rancher/client/generated_mount.go",
"github.com/rancher/go-rancher/client/generated_network.go",
"github.com/rancher/go-rancher/client/generated_nfs_config.go",
"github.com/rancher/go-rancher/client/generated_openldapconfig.go",
"github.com/rancher/go-rancher/client/generated_packet_config.go",
"github.com/rancher/go-rancher/client/generated_password.go",
"github.com/rancher/go-rancher/client/generated_physical_host.go",
"github.com/rancher/go-rancher/client/generated_port.go",
"github.com/rancher/go-rancher/client/generated_process_definition.go",
"github.com/rancher/go-rancher/client/generated_process_execution.go",
"github.com/rancher/go-rancher/client/generated_process_instance.go",
"github.com/rancher/go-rancher/client/generated_project.go",
"github.com/rancher/go-rancher/client/generated_project_member.go",
"github.com/rancher/go-rancher/client/generated_public_endpoint.go",
"github.com/rancher/go-rancher/client/generated_publish.go",
"github.com/rancher/go-rancher/client/generated_pull_task.go",
"github.com/rancher/go-rancher/client/generated_recreate_on_quorum_strategy_config.go",
"github.com/rancher/go-rancher/client/generated_register.go",
"github.com/rancher/go-rancher/client/generated_registration_token.go",
"github.com/rancher/go-rancher/client/generated_registry.go",
"github.com/rancher/go-rancher/client/generated_registry_credential.go",
"github.com/rancher/go-rancher/client/generated_resource_definition.go",
"github.com/rancher/go-rancher/client/generated_restart_policy.go",
"github.com/rancher/go-rancher/client/generated_restore_from_backup_input.go",
"github.com/rancher/go-rancher/client/generated_revert_to_snapshot_input.go",
"github.com/rancher/go-rancher/client/generated_rolling_restart_strategy.go",
"github.com/rancher/go-rancher/client/generated_scale_policy.go",
"github.com/rancher/go-rancher/client/generated_secondary_launch_config.go",
"github.com/rancher/go-rancher/client/generated_service.go",
"github.com/rancher/go-rancher/client/generated_service_consume_map.go",
"github.com/rancher/go-rancher/client/generated_service_event.go",
"github.com/rancher/go-rancher/client/generated_service_expose_map.go",
"github.com/rancher/go-rancher/client/generated_service_link.go",
"github.com/rancher/go-rancher/client/generated_service_proxy.go",
"github.com/rancher/go-rancher/client/generated_service_restart.go",
"github.com/rancher/go-rancher/client/generated_service_upgrade.go",
"github.com/rancher/go-rancher/client/generated_service_upgrade_strategy.go",
"github.com/rancher/go-rancher/client/generated_services_port_range.go",
"github.com/rancher/go-rancher/client/generated_set_labels_input.go",
"github.com/rancher/go-rancher/client/generated_set_load_balancer_service_links_input.go",
"github.com/rancher/go-rancher/client/generated_set_project_members_input.go",
"github.com/rancher/go-rancher/client/generated_set_service_links_input.go",
"github.com/rancher/go-rancher/client/generated_setting.go",
"github.com/rancher/go-rancher/client/generated_snapshot.go",
"github.com/rancher/go-rancher/client/generated_snapshot_backup_input.go",
"github.com/rancher/go-rancher/client/generated_state_transition.go",
"github.com/rancher/go-rancher/client/generated_stats_access.go",
"github.com/rancher/go-rancher/client/generated_storage_pool.go",
"github.com/rancher/go-rancher/client/generated_subscribe.go",
"github.com/rancher/go-rancher/client/generated_task.go",
"github.com/rancher/go-rancher/client/generated_task_instance.go",
"github.com/rancher/go-rancher/client/generated_to_service_upgrade_strategy.go",
"github.com/rancher/go-rancher/client/generated_type_documentation.go",
"github.com/rancher/go-rancher/client/generated_virtual_machine.go",
"github.com/rancher/go-rancher/client/generated_virtual_machine_disk.go",
"github.com/rancher/go-rancher/client/generated_volume.go",
"github.com/rancher/go-rancher/client/generated_volume_snapshot_input.go",
"github.com/rancher/go-rancher/client/schemas.go",
"github.com/rancher/go-rancher/client/types.go",
],
tags = ["automanaged"],
deps = [
"//vendor:github.com/gorilla/websocket",
"//vendor:github.com/pkg/errors",
],
)
go_library(
name = "github.com/codedellemc/goscaleio",
srcs = [
"github.com/codedellemc/goscaleio/api.go",
"github.com/codedellemc/goscaleio/certs.go",
"github.com/codedellemc/goscaleio/device.go",
"github.com/codedellemc/goscaleio/instance.go",
"github.com/codedellemc/goscaleio/protectiondomain.go",
"github.com/codedellemc/goscaleio/scsiinitiator.go",
"github.com/codedellemc/goscaleio/sdc.go",
"github.com/codedellemc/goscaleio/sds.go",
"github.com/codedellemc/goscaleio/storagepool.go",
"github.com/codedellemc/goscaleio/system.go",
"github.com/codedellemc/goscaleio/user.go",
"github.com/codedellemc/goscaleio/volume.go",
],
tags = ["automanaged"],
deps = [
"//vendor:github.com/Sirupsen/logrus",
"//vendor:github.com/codedellemc/goscaleio/types/v1",
],
)
go_library(
name = "github.com/codedellemc/goscaleio/types/v1",
srcs = ["github.com/codedellemc/goscaleio/types/v1/types.go"],
tags = ["automanaged"],
)
go_test(
name = "k8s.io/kube-aggregator/pkg/controllers/autoregister_test",
srcs = ["k8s.io/kube-aggregator/pkg/controllers/autoregister/autoregister_controller_test.go"],

22
vendor/github.com/gorilla/websocket/.gitignore generated vendored Normal file
View File

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

6
vendor/github.com/gorilla/websocket/.travis.yml generated vendored Normal file
View File

@ -0,0 +1,6 @@
language: go
go:
- 1.1
- 1.2
- tip

8
vendor/github.com/gorilla/websocket/AUTHORS generated vendored Normal file
View File

@ -0,0 +1,8 @@
# This is the official list of Gorilla WebSocket authors for copyright
# purposes.
#
# Please keep the list sorted.
Gary Burd <gary@beagledreams.com>
Joachim Bauch <mail@joachim-bauch.de>

22
vendor/github.com/gorilla/websocket/LICENSE generated vendored Normal file
View File

@ -0,0 +1,22 @@
Copyright (c) 2013 The Gorilla WebSocket Authors. All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
Redistributions of source code must retain the above copyright notice, this
list of conditions and the following disclaimer.
Redistributions in binary form must reproduce the above copyright notice,
this list of conditions and the following disclaimer in the documentation
and/or other materials provided with the distribution.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

59
vendor/github.com/gorilla/websocket/README.md generated vendored Normal file
View File

@ -0,0 +1,59 @@
# Gorilla WebSocket
Gorilla WebSocket is a [Go](http://golang.org/) implementation of the
[WebSocket](http://www.rfc-editor.org/rfc/rfc6455.txt) protocol.
### Documentation
* [API Reference](http://godoc.org/github.com/gorilla/websocket)
* [Chat example](https://github.com/gorilla/websocket/tree/master/examples/chat)
* [File watch example](https://github.com/gorilla/websocket/tree/master/examples/filewatch)
### Status
The Gorilla WebSocket package provides a complete and tested implementation of
the [WebSocket](http://www.rfc-editor.org/rfc/rfc6455.txt) protocol. The
package API is stable.
### Installation
go get github.com/gorilla/websocket
### Protocol Compliance
The Gorilla WebSocket package passes the server tests in the [Autobahn Test
Suite](http://autobahn.ws/testsuite) using the application in the [examples/autobahn
subdirectory](https://github.com/gorilla/websocket/tree/master/examples/autobahn).
### Gorilla WebSocket compared with other packages
<table>
<tr>
<th></th>
<th><a href="http://godoc.org/github.com/gorilla/websocket">github.com/gorilla</a></th>
<th><a href="http://godoc.org/golang.org/x/net/websocket">golang.org/x/net</a></th>
</tr>
<tr>
<tr><td colspan="3"><a href="http://tools.ietf.org/html/rfc6455">RFC 6455</a> Features</td></tr>
<tr><td>Passes <a href="http://autobahn.ws/testsuite/">Autobahn Test Suite</a></td><td><a href="https://github.com/gorilla/websocket/tree/master/examples/autobahn">Yes</a></td><td>No</td></tr>
<tr><td>Receive <a href="https://tools.ietf.org/html/rfc6455#section-5.4">fragmented</a> message<td>Yes</td><td><a href="https://code.google.com/p/go/issues/detail?id=7632">No</a>, see note 1</td></tr>
<tr><td>Send <a href="https://tools.ietf.org/html/rfc6455#section-5.5.1">close</a> message</td><td><a href="http://godoc.org/github.com/gorilla/websocket#hdr-Control_Messages">Yes</a></td><td><a href="https://code.google.com/p/go/issues/detail?id=4588">No</a></td></tr>
<tr><td>Send <a href="https://tools.ietf.org/html/rfc6455#section-5.5.2">pings</a> and receive <a href="https://tools.ietf.org/html/rfc6455#section-5.5.3">pongs</a></td><td><a href="http://godoc.org/github.com/gorilla/websocket#hdr-Control_Messages">Yes</a></td><td>No</td></tr>
<tr><td>Get the <a href="https://tools.ietf.org/html/rfc6455#section-5.6">type</a> of a received data message</td><td>Yes</td><td>Yes, see note 2</td></tr>
<tr><td colspan="3">Other Features</tr></td>
<tr><td>Limit size of received message</td><td><a href="http://godoc.org/github.com/gorilla/websocket#Conn.SetReadLimit">Yes</a></td><td><a href="https://code.google.com/p/go/issues/detail?id=5082">No</a></td></tr>
<tr><td>Read message using io.Reader</td><td><a href="http://godoc.org/github.com/gorilla/websocket#Conn.NextReader">Yes</a></td><td>No, see note 3</td></tr>
<tr><td>Write message using io.WriteCloser</td><td><a href="http://godoc.org/github.com/gorilla/websocket#Conn.NextWriter">Yes</a></td><td>No, see note 3</td></tr>
</table>
Notes:
1. Large messages are fragmented in [Chrome's new WebSocket implementation](http://www.ietf.org/mail-archive/web/hybi/current/msg10503.html).
2. The application can get the type of a received data message by implementing
a [Codec marshal](http://godoc.org/golang.org/x/net/websocket#Codec.Marshal)
function.
3. The go.net io.Reader and io.Writer operate across WebSocket frame boundaries.
Read returns when the input buffer is full or a frame boundary is
encountered. Each call to Write sends a single frame message. The Gorilla
io.Reader and io.WriteCloser operate on a single WebSocket message.

269
vendor/github.com/gorilla/websocket/client.go generated vendored Normal file
View File

@ -0,0 +1,269 @@
// Copyright 2013 The Gorilla WebSocket Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
package websocket
import (
"bytes"
"crypto/tls"
"errors"
"io"
"io/ioutil"
"net"
"net/http"
"net/url"
"strings"
"time"
)
// ErrBadHandshake is returned when the server response to opening handshake is
// invalid.
var ErrBadHandshake = errors.New("websocket: bad handshake")
// NewClient creates a new client connection using the given net connection.
// The URL u specifies the host and request URI. Use requestHeader to specify
// the origin (Origin), subprotocols (Sec-WebSocket-Protocol) and cookies
// (Cookie). Use the response.Header to get the selected subprotocol
// (Sec-WebSocket-Protocol) and cookies (Set-Cookie).
//
// If the WebSocket handshake fails, ErrBadHandshake is returned along with a
// non-nil *http.Response so that callers can handle redirects, authentication,
// etc.
func NewClient(netConn net.Conn, u *url.URL, requestHeader http.Header, readBufSize, writeBufSize int) (c *Conn, response *http.Response, err error) {
challengeKey, err := generateChallengeKey()
if err != nil {
return nil, nil, err
}
acceptKey := computeAcceptKey(challengeKey)
c = newConn(netConn, false, readBufSize, writeBufSize)
p := c.writeBuf[:0]
p = append(p, "GET "...)
p = append(p, u.RequestURI()...)
p = append(p, " HTTP/1.1\r\nHost: "...)
p = append(p, u.Host...)
// "Upgrade" is capitalized for servers that do not use case insensitive
// comparisons on header tokens.
p = append(p, "\r\nUpgrade: websocket\r\nConnection: Upgrade\r\nSec-WebSocket-Version: 13\r\nSec-WebSocket-Key: "...)
p = append(p, challengeKey...)
p = append(p, "\r\n"...)
for k, vs := range requestHeader {
for _, v := range vs {
p = append(p, k...)
p = append(p, ": "...)
p = append(p, v...)
p = append(p, "\r\n"...)
}
}
p = append(p, "\r\n"...)
if _, err := netConn.Write(p); err != nil {
return nil, nil, err
}
resp, err := http.ReadResponse(c.br, &http.Request{Method: "GET", URL: u})
if err != nil {
return nil, nil, err
}
if resp.StatusCode != 101 ||
!strings.EqualFold(resp.Header.Get("Upgrade"), "websocket") ||
!strings.EqualFold(resp.Header.Get("Connection"), "upgrade") ||
resp.Header.Get("Sec-Websocket-Accept") != acceptKey {
return nil, resp, ErrBadHandshake
}
c.subprotocol = resp.Header.Get("Sec-Websocket-Protocol")
return c, resp, nil
}
// A Dialer contains options for connecting to WebSocket server.
type Dialer struct {
// NetDial specifies the dial function for creating TCP connections. If
// NetDial is nil, net.Dial is used.
NetDial func(network, addr string) (net.Conn, error)
// TLSClientConfig specifies the TLS configuration to use with tls.Client.
// If nil, the default configuration is used.
TLSClientConfig *tls.Config
// HandshakeTimeout specifies the duration for the handshake to complete.
HandshakeTimeout time.Duration
// Input and output buffer sizes. If the buffer size is zero, then a
// default value of 4096 is used.
ReadBufferSize, WriteBufferSize int
// Subprotocols specifies the client's requested subprotocols.
Subprotocols []string
}
var errMalformedURL = errors.New("malformed ws or wss URL")
// parseURL parses the URL. The url.Parse function is not used here because
// url.Parse mangles the path.
func parseURL(s string) (*url.URL, error) {
// From the RFC:
//
// ws-URI = "ws:" "//" host [ ":" port ] path [ "?" query ]
// wss-URI = "wss:" "//" host [ ":" port ] path [ "?" query ]
//
// We don't use the net/url parser here because the dialer interface does
// not provide a way for applications to work around percent deocding in
// the net/url parser.
var u url.URL
switch {
case strings.HasPrefix(s, "ws://"):
u.Scheme = "ws"
s = s[len("ws://"):]
case strings.HasPrefix(s, "wss://"):
u.Scheme = "wss"
s = s[len("wss://"):]
default:
return nil, errMalformedURL
}
u.Host = s
u.Opaque = "/"
if i := strings.Index(s, "/"); i >= 0 {
u.Host = s[:i]
u.Opaque = s[i:]
}
if strings.Contains(u.Host, "@") {
// WebSocket URIs do not contain user information.
return nil, errMalformedURL
}
return &u, nil
}
func hostPortNoPort(u *url.URL) (hostPort, hostNoPort string) {
hostPort = u.Host
hostNoPort = u.Host
if i := strings.LastIndex(u.Host, ":"); i > strings.LastIndex(u.Host, "]") {
hostNoPort = hostNoPort[:i]
} else {
if u.Scheme == "wss" {
hostPort += ":443"
} else {
hostPort += ":80"
}
}
return hostPort, hostNoPort
}
// DefaultDialer is a dialer with all fields set to the default zero values.
var DefaultDialer *Dialer
// Dial creates a new client connection. Use requestHeader to specify the
// origin (Origin), subprotocols (Sec-WebSocket-Protocol) and cookies (Cookie).
// Use the response.Header to get the selected subprotocol
// (Sec-WebSocket-Protocol) and cookies (Set-Cookie).
//
// If the WebSocket handshake fails, ErrBadHandshake is returned along with a
// non-nil *http.Response so that callers can handle redirects, authentication,
// etcetera. The response body may not contain the entire response and does not
// need to be closed by the application.
func (d *Dialer) Dial(urlStr string, requestHeader http.Header) (*Conn, *http.Response, error) {
u, err := parseURL(urlStr)
if err != nil {
return nil, nil, err
}
hostPort, hostNoPort := hostPortNoPort(u)
if d == nil {
d = &Dialer{}
}
var deadline time.Time
if d.HandshakeTimeout != 0 {
deadline = time.Now().Add(d.HandshakeTimeout)
}
netDial := d.NetDial
if netDial == nil {
netDialer := &net.Dialer{Deadline: deadline}
netDial = netDialer.Dial
}
netConn, err := netDial("tcp", hostPort)
if err != nil {
return nil, nil, err
}
defer func() {
if netConn != nil {
netConn.Close()
}
}()
if err := netConn.SetDeadline(deadline); err != nil {
return nil, nil, err
}
if u.Scheme == "wss" {
cfg := d.TLSClientConfig
if cfg == nil {
cfg = &tls.Config{ServerName: hostNoPort}
} else if cfg.ServerName == "" {
shallowCopy := *cfg
cfg = &shallowCopy
cfg.ServerName = hostNoPort
}
tlsConn := tls.Client(netConn, cfg)
netConn = tlsConn
if err := tlsConn.Handshake(); err != nil {
return nil, nil, err
}
if !cfg.InsecureSkipVerify {
if err := tlsConn.VerifyHostname(cfg.ServerName); err != nil {
return nil, nil, err
}
}
}
if len(d.Subprotocols) > 0 {
h := http.Header{}
for k, v := range requestHeader {
h[k] = v
}
h.Set("Sec-Websocket-Protocol", strings.Join(d.Subprotocols, ", "))
requestHeader = h
}
if len(requestHeader["Host"]) > 0 {
// This can be used to supply a Host: header which is different from
// the dial address.
u.Host = requestHeader.Get("Host")
// Drop "Host" header
h := http.Header{}
for k, v := range requestHeader {
if k == "Host" {
continue
}
h[k] = v
}
requestHeader = h
}
conn, resp, err := NewClient(netConn, u, requestHeader, d.ReadBufferSize, d.WriteBufferSize)
if err != nil {
if err == ErrBadHandshake {
// Before closing the network connection on return from this
// function, slurp up some of the response to aid application
// debugging.
buf := make([]byte, 1024)
n, _ := io.ReadFull(resp.Body, buf)
resp.Body = ioutil.NopCloser(bytes.NewReader(buf[:n]))
}
return nil, resp, err
}
netConn.SetDeadline(time.Time{})
netConn = nil // to avoid close in defer.
return conn, resp, nil
}

825
vendor/github.com/gorilla/websocket/conn.go generated vendored Normal file
View File

@ -0,0 +1,825 @@
// Copyright 2013 The Gorilla WebSocket Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
package websocket
import (
"bufio"
"encoding/binary"
"errors"
"io"
"io/ioutil"
"math/rand"
"net"
"strconv"
"time"
)
const (
maxFrameHeaderSize = 2 + 8 + 4 // Fixed header + length + mask
maxControlFramePayloadSize = 125
finalBit = 1 << 7
maskBit = 1 << 7
writeWait = time.Second
defaultReadBufferSize = 4096
defaultWriteBufferSize = 4096
continuationFrame = 0
noFrame = -1
)
// Close codes defined in RFC 6455, section 11.7.
const (
CloseNormalClosure = 1000
CloseGoingAway = 1001
CloseProtocolError = 1002
CloseUnsupportedData = 1003
CloseNoStatusReceived = 1005
CloseAbnormalClosure = 1006
CloseInvalidFramePayloadData = 1007
ClosePolicyViolation = 1008
CloseMessageTooBig = 1009
CloseMandatoryExtension = 1010
CloseInternalServerErr = 1011
CloseTLSHandshake = 1015
)
// The message types are defined in RFC 6455, section 11.8.
const (
// TextMessage denotes a text data message. The text message payload is
// interpreted as UTF-8 encoded text data.
TextMessage = 1
// BinaryMessage denotes a binary data message.
BinaryMessage = 2
// CloseMessage denotes a close control message. The optional message
// payload contains a numeric code and text. Use the FormatCloseMessage
// function to format a close message payload.
CloseMessage = 8
// PingMessage denotes a ping control message. The optional message payload
// is UTF-8 encoded text.
PingMessage = 9
// PongMessage denotes a ping control message. The optional message payload
// is UTF-8 encoded text.
PongMessage = 10
)
// ErrCloseSent is returned when the application writes a message to the
// connection after sending a close message.
var ErrCloseSent = errors.New("websocket: close sent")
// ErrReadLimit is returned when reading a message that is larger than the
// read limit set for the connection.
var ErrReadLimit = errors.New("websocket: read limit exceeded")
// netError satisfies the net Error interface.
type netError struct {
msg string
temporary bool
timeout bool
}
func (e *netError) Error() string { return e.msg }
func (e *netError) Temporary() bool { return e.temporary }
func (e *netError) Timeout() bool { return e.timeout }
// closeError represents close frame.
type closeError struct {
code int
text string
}
func (e *closeError) Error() string {
return "websocket: close " + strconv.Itoa(e.code) + " " + e.text
}
var (
errWriteTimeout = &netError{msg: "websocket: write timeout", timeout: true}
errUnexpectedEOF = &closeError{code: CloseAbnormalClosure, text: io.ErrUnexpectedEOF.Error()}
errBadWriteOpCode = errors.New("websocket: bad write message type")
errWriteClosed = errors.New("websocket: write closed")
errInvalidControlFrame = errors.New("websocket: invalid control frame")
)
func hideTempErr(err error) error {
if e, ok := err.(net.Error); ok && e.Temporary() {
err = &netError{msg: e.Error(), timeout: e.Timeout()}
}
return err
}
func isControl(frameType int) bool {
return frameType == CloseMessage || frameType == PingMessage || frameType == PongMessage
}
func isData(frameType int) bool {
return frameType == TextMessage || frameType == BinaryMessage
}
func maskBytes(key [4]byte, pos int, b []byte) int {
for i := range b {
b[i] ^= key[pos&3]
pos++
}
return pos & 3
}
func newMaskKey() [4]byte {
n := rand.Uint32()
return [4]byte{byte(n), byte(n >> 8), byte(n >> 16), byte(n >> 24)}
}
// Conn represents a WebSocket connection.
type Conn struct {
conn net.Conn
isServer bool
subprotocol string
// Write fields
mu chan bool // used as mutex to protect write to conn and closeSent
closeSent bool // true if close message was sent
// Message writer fields.
writeErr error
writeBuf []byte // frame is constructed in this buffer.
writePos int // end of data in writeBuf.
writeFrameType int // type of the current frame.
writeSeq int // incremented to invalidate message writers.
writeDeadline time.Time
// Read fields
readErr error
br *bufio.Reader
readRemaining int64 // bytes remaining in current frame.
readFinal bool // true the current message has more frames.
readSeq int // incremented to invalidate message readers.
readLength int64 // Message size.
readLimit int64 // Maximum message size.
readMaskPos int
readMaskKey [4]byte
handlePong func(string) error
handlePing func(string) error
}
func newConn(conn net.Conn, isServer bool, readBufferSize, writeBufferSize int) *Conn {
mu := make(chan bool, 1)
mu <- true
if readBufferSize == 0 {
readBufferSize = defaultReadBufferSize
}
if writeBufferSize == 0 {
writeBufferSize = defaultWriteBufferSize
}
c := &Conn{
isServer: isServer,
br: bufio.NewReaderSize(conn, readBufferSize),
conn: conn,
mu: mu,
readFinal: true,
writeBuf: make([]byte, writeBufferSize+maxFrameHeaderSize),
writeFrameType: noFrame,
writePos: maxFrameHeaderSize,
}
c.SetPingHandler(nil)
c.SetPongHandler(nil)
return c
}
// Subprotocol returns the negotiated protocol for the connection.
func (c *Conn) Subprotocol() string {
return c.subprotocol
}
// Close closes the underlying network connection without sending or waiting for a close frame.
func (c *Conn) Close() error {
return c.conn.Close()
}
// LocalAddr returns the local network address.
func (c *Conn) LocalAddr() net.Addr {
return c.conn.LocalAddr()
}
// RemoteAddr returns the remote network address.
func (c *Conn) RemoteAddr() net.Addr {
return c.conn.RemoteAddr()
}
// Write methods
func (c *Conn) write(frameType int, deadline time.Time, bufs ...[]byte) error {
<-c.mu
defer func() { c.mu <- true }()
if c.closeSent {
return ErrCloseSent
} else if frameType == CloseMessage {
c.closeSent = true
}
c.conn.SetWriteDeadline(deadline)
for _, buf := range bufs {
if len(buf) > 0 {
n, err := c.conn.Write(buf)
if n != len(buf) {
// Close on partial write.
c.conn.Close()
}
if err != nil {
return err
}
}
}
return nil
}
// WriteControl writes a control message with the given deadline. The allowed
// message types are CloseMessage, PingMessage and PongMessage.
func (c *Conn) WriteControl(messageType int, data []byte, deadline time.Time) error {
if !isControl(messageType) {
return errBadWriteOpCode
}
if len(data) > maxControlFramePayloadSize {
return errInvalidControlFrame
}
b0 := byte(messageType) | finalBit
b1 := byte(len(data))
if !c.isServer {
b1 |= maskBit
}
buf := make([]byte, 0, maxFrameHeaderSize+maxControlFramePayloadSize)
buf = append(buf, b0, b1)
if c.isServer {
buf = append(buf, data...)
} else {
key := newMaskKey()
buf = append(buf, key[:]...)
buf = append(buf, data...)
maskBytes(key, 0, buf[6:])
}
d := time.Hour * 1000
if !deadline.IsZero() {
d = deadline.Sub(time.Now())
if d < 0 {
return errWriteTimeout
}
}
timer := time.NewTimer(d)
select {
case <-c.mu:
timer.Stop()
case <-timer.C:
return errWriteTimeout
}
defer func() { c.mu <- true }()
if c.closeSent {
return ErrCloseSent
} else if messageType == CloseMessage {
c.closeSent = true
}
c.conn.SetWriteDeadline(deadline)
n, err := c.conn.Write(buf)
if n != 0 && n != len(buf) {
c.conn.Close()
}
return err
}
// NextWriter returns a writer for the next message to send. The writer's
// Close method flushes the complete message to the network.
//
// There can be at most one open writer on a connection. NextWriter closes the
// previous writer if the application has not already done so.
//
// The NextWriter method and the writers returned from the method cannot be
// accessed by more than one goroutine at a time.
func (c *Conn) NextWriter(messageType int) (io.WriteCloser, error) {
if c.writeErr != nil {
return nil, c.writeErr
}
if c.writeFrameType != noFrame {
if err := c.flushFrame(true, nil); err != nil {
return nil, err
}
}
if !isControl(messageType) && !isData(messageType) {
return nil, errBadWriteOpCode
}
c.writeFrameType = messageType
return messageWriter{c, c.writeSeq}, nil
}
func (c *Conn) flushFrame(final bool, extra []byte) error {
length := c.writePos - maxFrameHeaderSize + len(extra)
// Check for invalid control frames.
if isControl(c.writeFrameType) &&
(!final || length > maxControlFramePayloadSize) {
c.writeSeq++
c.writeFrameType = noFrame
c.writePos = maxFrameHeaderSize
return errInvalidControlFrame
}
b0 := byte(c.writeFrameType)
if final {
b0 |= finalBit
}
b1 := byte(0)
if !c.isServer {
b1 |= maskBit
}
// Assume that the frame starts at beginning of c.writeBuf.
framePos := 0
if c.isServer {
// Adjust up if mask not included in the header.
framePos = 4
}
switch {
case length >= 65536:
c.writeBuf[framePos] = b0
c.writeBuf[framePos+1] = b1 | 127
binary.BigEndian.PutUint64(c.writeBuf[framePos+2:], uint64(length))
case length > 125:
framePos += 6
c.writeBuf[framePos] = b0
c.writeBuf[framePos+1] = b1 | 126
binary.BigEndian.PutUint16(c.writeBuf[framePos+2:], uint16(length))
default:
framePos += 8
c.writeBuf[framePos] = b0
c.writeBuf[framePos+1] = b1 | byte(length)
}
if !c.isServer {
key := newMaskKey()
copy(c.writeBuf[maxFrameHeaderSize-4:], key[:])
maskBytes(key, 0, c.writeBuf[maxFrameHeaderSize:c.writePos])
if len(extra) > 0 {
c.writeErr = errors.New("websocket: internal error, extra used in client mode")
return c.writeErr
}
}
// Write the buffers to the connection.
c.writeErr = c.write(c.writeFrameType, c.writeDeadline, c.writeBuf[framePos:c.writePos], extra)
// Setup for next frame.
c.writePos = maxFrameHeaderSize
c.writeFrameType = continuationFrame
if final {
c.writeSeq++
c.writeFrameType = noFrame
}
return c.writeErr
}
type messageWriter struct {
c *Conn
seq int
}
func (w messageWriter) err() error {
c := w.c
if c.writeSeq != w.seq {
return errWriteClosed
}
if c.writeErr != nil {
return c.writeErr
}
return nil
}
func (w messageWriter) ncopy(max int) (int, error) {
n := len(w.c.writeBuf) - w.c.writePos
if n <= 0 {
if err := w.c.flushFrame(false, nil); err != nil {
return 0, err
}
n = len(w.c.writeBuf) - w.c.writePos
}
if n > max {
n = max
}
return n, nil
}
func (w messageWriter) write(final bool, p []byte) (int, error) {
if err := w.err(); err != nil {
return 0, err
}
if len(p) > 2*len(w.c.writeBuf) && w.c.isServer {
// Don't buffer large messages.
err := w.c.flushFrame(final, p)
if err != nil {
return 0, err
}
return len(p), nil
}
nn := len(p)
for len(p) > 0 {
n, err := w.ncopy(len(p))
if err != nil {
return 0, err
}
copy(w.c.writeBuf[w.c.writePos:], p[:n])
w.c.writePos += n
p = p[n:]
}
return nn, nil
}
func (w messageWriter) Write(p []byte) (int, error) {
return w.write(false, p)
}
func (w messageWriter) WriteString(p string) (int, error) {
if err := w.err(); err != nil {
return 0, err
}
nn := len(p)
for len(p) > 0 {
n, err := w.ncopy(len(p))
if err != nil {
return 0, err
}
copy(w.c.writeBuf[w.c.writePos:], p[:n])
w.c.writePos += n
p = p[n:]
}
return nn, nil
}
func (w messageWriter) ReadFrom(r io.Reader) (nn int64, err error) {
if err := w.err(); err != nil {
return 0, err
}
for {
if w.c.writePos == len(w.c.writeBuf) {
err = w.c.flushFrame(false, nil)
if err != nil {
break
}
}
var n int
n, err = r.Read(w.c.writeBuf[w.c.writePos:])
w.c.writePos += n
nn += int64(n)
if err != nil {
if err == io.EOF {
err = nil
}
break
}
}
return nn, err
}
func (w messageWriter) Close() error {
if err := w.err(); err != nil {
return err
}
return w.c.flushFrame(true, nil)
}
// WriteMessage is a helper method for getting a writer using NextWriter,
// writing the message and closing the writer.
func (c *Conn) WriteMessage(messageType int, data []byte) error {
wr, err := c.NextWriter(messageType)
if err != nil {
return err
}
w := wr.(messageWriter)
if _, err := w.write(true, data); err != nil {
return err
}
if c.writeSeq == w.seq {
if err := c.flushFrame(true, nil); err != nil {
return err
}
}
return nil
}
// SetWriteDeadline sets the write deadline on the underlying network
// connection. After a write has timed out, the websocket state is corrupt and
// all future writes will return an error. A zero value for t means writes will
// not time out.
func (c *Conn) SetWriteDeadline(t time.Time) error {
c.writeDeadline = t
return nil
}
// Read methods
// readFull is like io.ReadFull except that io.EOF is never returned.
func (c *Conn) readFull(p []byte) (err error) {
var n int
for n < len(p) && err == nil {
var nn int
nn, err = c.br.Read(p[n:])
n += nn
}
if n == len(p) {
err = nil
} else if err == io.EOF {
err = errUnexpectedEOF
}
return
}
func (c *Conn) advanceFrame() (int, error) {
// 1. Skip remainder of previous frame.
if c.readRemaining > 0 {
if _, err := io.CopyN(ioutil.Discard, c.br, c.readRemaining); err != nil {
return noFrame, err
}
}
// 2. Read and parse first two bytes of frame header.
var b [8]byte
if err := c.readFull(b[:2]); err != nil {
return noFrame, err
}
final := b[0]&finalBit != 0
frameType := int(b[0] & 0xf)
reserved := int((b[0] >> 4) & 0x7)
mask := b[1]&maskBit != 0
c.readRemaining = int64(b[1] & 0x7f)
if reserved != 0 {
return noFrame, c.handleProtocolError("unexpected reserved bits " + strconv.Itoa(reserved))
}
switch frameType {
case CloseMessage, PingMessage, PongMessage:
if c.readRemaining > maxControlFramePayloadSize {
return noFrame, c.handleProtocolError("control frame length > 125")
}
if !final {
return noFrame, c.handleProtocolError("control frame not final")
}
case TextMessage, BinaryMessage:
if !c.readFinal {
return noFrame, c.handleProtocolError("message start before final message frame")
}
c.readFinal = final
case continuationFrame:
if c.readFinal {
return noFrame, c.handleProtocolError("continuation after final message frame")
}
c.readFinal = final
default:
return noFrame, c.handleProtocolError("unknown opcode " + strconv.Itoa(frameType))
}
// 3. Read and parse frame length.
switch c.readRemaining {
case 126:
if err := c.readFull(b[:2]); err != nil {
return noFrame, err
}
c.readRemaining = int64(binary.BigEndian.Uint16(b[:2]))
case 127:
if err := c.readFull(b[:8]); err != nil {
return noFrame, err
}
c.readRemaining = int64(binary.BigEndian.Uint64(b[:8]))
}
// 4. Handle frame masking.
if mask != c.isServer {
return noFrame, c.handleProtocolError("incorrect mask flag")
}
if mask {
c.readMaskPos = 0
if err := c.readFull(c.readMaskKey[:]); err != nil {
return noFrame, err
}
}
// 5. For text and binary messages, enforce read limit and return.
if frameType == continuationFrame || frameType == TextMessage || frameType == BinaryMessage {
c.readLength += c.readRemaining
if c.readLimit > 0 && c.readLength > c.readLimit {
c.WriteControl(CloseMessage, FormatCloseMessage(CloseMessageTooBig, ""), time.Now().Add(writeWait))
return noFrame, ErrReadLimit
}
return frameType, nil
}
// 6. Read control frame payload.
var payload []byte
if c.readRemaining > 0 {
payload = make([]byte, c.readRemaining)
c.readRemaining = 0
if err := c.readFull(payload); err != nil {
return noFrame, err
}
if c.isServer {
maskBytes(c.readMaskKey, 0, payload)
}
}
// 7. Process control frame payload.
switch frameType {
case PongMessage:
if err := c.handlePong(string(payload)); err != nil {
return noFrame, err
}
case PingMessage:
if err := c.handlePing(string(payload)); err != nil {
return noFrame, err
}
case CloseMessage:
c.WriteControl(CloseMessage, []byte{}, time.Now().Add(writeWait))
closeCode := CloseNoStatusReceived
closeText := ""
if len(payload) >= 2 {
closeCode = int(binary.BigEndian.Uint16(payload))
closeText = string(payload[2:])
}
switch closeCode {
case CloseNormalClosure, CloseGoingAway:
return noFrame, io.EOF
default:
return noFrame, &closeError{code: closeCode, text: closeText}
}
}
return frameType, nil
}
func (c *Conn) handleProtocolError(message string) error {
c.WriteControl(CloseMessage, FormatCloseMessage(CloseProtocolError, message), time.Now().Add(writeWait))
return errors.New("websocket: " + message)
}
// NextReader returns the next data message received from the peer. The
// returned messageType is either TextMessage or BinaryMessage.
//
// There can be at most one open reader on a connection. NextReader discards
// the previous message if the application has not already consumed it.
//
// The NextReader method and the readers returned from the method cannot be
// accessed by more than one goroutine at a time.
func (c *Conn) NextReader() (messageType int, r io.Reader, err error) {
c.readSeq++
c.readLength = 0
for c.readErr == nil {
frameType, err := c.advanceFrame()
if err != nil {
c.readErr = hideTempErr(err)
break
}
if frameType == TextMessage || frameType == BinaryMessage {
return frameType, messageReader{c, c.readSeq}, nil
}
}
return noFrame, nil, c.readErr
}
type messageReader struct {
c *Conn
seq int
}
func (r messageReader) Read(b []byte) (int, error) {
if r.seq != r.c.readSeq {
return 0, io.EOF
}
for r.c.readErr == nil {
if r.c.readRemaining > 0 {
if int64(len(b)) > r.c.readRemaining {
b = b[:r.c.readRemaining]
}
n, err := r.c.br.Read(b)
r.c.readErr = hideTempErr(err)
if r.c.isServer {
r.c.readMaskPos = maskBytes(r.c.readMaskKey, r.c.readMaskPos, b[:n])
}
r.c.readRemaining -= int64(n)
return n, r.c.readErr
}
if r.c.readFinal {
r.c.readSeq++
return 0, io.EOF
}
frameType, err := r.c.advanceFrame()
switch {
case err != nil:
r.c.readErr = hideTempErr(err)
case frameType == TextMessage || frameType == BinaryMessage:
r.c.readErr = errors.New("websocket: internal error, unexpected text or binary in Reader")
}
}
err := r.c.readErr
if err == io.EOF && r.seq == r.c.readSeq {
err = errUnexpectedEOF
}
return 0, err
}
// ReadMessage is a helper method for getting a reader using NextReader and
// reading from that reader to a buffer.
func (c *Conn) ReadMessage() (messageType int, p []byte, err error) {
var r io.Reader
messageType, r, err = c.NextReader()
if err != nil {
return messageType, nil, err
}
p, err = ioutil.ReadAll(r)
return messageType, p, err
}
// SetReadDeadline sets the read deadline on the underlying network connection.
// After a read has timed out, the websocket connection state is corrupt and
// all future reads will return an error. A zero value for t means reads will
// not time out.
func (c *Conn) SetReadDeadline(t time.Time) error {
return c.conn.SetReadDeadline(t)
}
// SetReadLimit sets the maximum size for a message read from the peer. If a
// message exceeds the limit, the connection sends a close frame to the peer
// and returns ErrReadLimit to the application.
func (c *Conn) SetReadLimit(limit int64) {
c.readLimit = limit
}
// SetPingHandler sets the handler for ping messages received from the peer.
// The default ping handler sends a pong to the peer.
func (c *Conn) SetPingHandler(h func(string) error) {
if h == nil {
h = func(message string) error {
c.WriteControl(PongMessage, []byte(message), time.Now().Add(writeWait))
return nil
}
}
c.handlePing = h
}
// SetPongHandler sets the handler for pong messages received from the peer.
// The default pong handler does nothing.
func (c *Conn) SetPongHandler(h func(string) error) {
if h == nil {
h = func(string) error { return nil }
}
c.handlePong = h
}
// UnderlyingConn returns the internal net.Conn. This can be used to further
// modifications to connection specific flags.
func (c *Conn) UnderlyingConn() net.Conn {
return c.conn
}
// FormatCloseMessage formats closeCode and text as a WebSocket close message.
func FormatCloseMessage(closeCode int, text string) []byte {
buf := make([]byte, 2+len(text))
binary.BigEndian.PutUint16(buf, uint16(closeCode))
copy(buf[2:], text)
return buf
}

148
vendor/github.com/gorilla/websocket/doc.go generated vendored Normal file
View File

@ -0,0 +1,148 @@
// Copyright 2013 The Gorilla WebSocket Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
// Package websocket implements the WebSocket protocol defined in RFC 6455.
//
// Overview
//
// The Conn type represents a WebSocket connection. A server application uses
// the Upgrade function from an Upgrader object with a HTTP request handler
// to get a pointer to a Conn:
//
// var upgrader = websocket.Upgrader{
// ReadBufferSize: 1024,
// WriteBufferSize: 1024,
// }
//
// func handler(w http.ResponseWriter, r *http.Request) {
// conn, err := upgrader.Upgrade(w, r, nil)
// if err != nil {
// log.Println(err)
// return
// }
// ... Use conn to send and receive messages.
// }
//
// Call the connection's WriteMessage and ReadMessage methods to send and
// receive messages as a slice of bytes. This snippet of code shows how to echo
// messages using these methods:
//
// for {
// messageType, p, err := conn.ReadMessage()
// if err != nil {
// return
// }
// if err = conn.WriteMessage(messageType, p); err != nil {
// return err
// }
// }
//
// In above snippet of code, p is a []byte and messageType is an int with value
// websocket.BinaryMessage or websocket.TextMessage.
//
// An application can also send and receive messages using the io.WriteCloser
// and io.Reader interfaces. To send a message, call the connection NextWriter
// method to get an io.WriteCloser, write the message to the writer and close
// the writer when done. To receive a message, call the connection NextReader
// method to get an io.Reader and read until io.EOF is returned. This snippet
// snippet shows how to echo messages using the NextWriter and NextReader
// methods:
//
// for {
// messageType, r, err := conn.NextReader()
// if err != nil {
// return
// }
// w, err := conn.NextWriter(messageType)
// if err != nil {
// return err
// }
// if _, err := io.Copy(w, r); err != nil {
// return err
// }
// if err := w.Close(); err != nil {
// return err
// }
// }
//
// Data Messages
//
// The WebSocket protocol distinguishes between text and binary data messages.
// Text messages are interpreted as UTF-8 encoded text. The interpretation of
// binary messages is left to the application.
//
// This package uses the TextMessage and BinaryMessage integer constants to
// identify the two data message types. The ReadMessage and NextReader methods
// return the type of the received message. The messageType argument to the
// WriteMessage and NextWriter methods specifies the type of a sent message.
//
// It is the application's responsibility to ensure that text messages are
// valid UTF-8 encoded text.
//
// Control Messages
//
// The WebSocket protocol defines three types of control messages: close, ping
// and pong. Call the connection WriteControl, WriteMessage or NextWriter
// methods to send a control message to the peer.
//
// Connections handle received ping and pong messages by invoking a callback
// function set with SetPingHandler and SetPongHandler methods. These callback
// functions can be invoked from the ReadMessage method, the NextReader method
// or from a call to the data message reader returned from NextReader.
//
// Connections handle received close messages by returning an error from the
// ReadMessage method, the NextReader method or from a call to the data message
// reader returned from NextReader.
//
// Concurrency
//
// Connections do not support concurrent calls to the write methods
// (NextWriter, SetWriteDeadline, WriteMessage) or concurrent calls to the read
// methods methods (NextReader, SetReadDeadline, ReadMessage). Connections do
// support a concurrent reader and writer.
//
// The Close and WriteControl methods can be called concurrently with all other
// methods.
//
// Read is Required
//
// The application must read the connection to process ping and close messages
// sent from the peer. If the application is not otherwise interested in
// messages from the peer, then the application should start a goroutine to read
// and discard messages from the peer. A simple example is:
//
// func readLoop(c *websocket.Conn) {
// for {
// if _, _, err := c.NextReader(); err != nil {
// c.Close()
// break
// }
// }
// }
//
// Origin Considerations
//
// Web browsers allow Javascript applications to open a WebSocket connection to
// any host. It's up to the server to enforce an origin policy using the Origin
// request header sent by the browser.
//
// The Upgrader calls the function specified in the CheckOrigin field to check
// the origin. If the CheckOrigin function returns false, then the Upgrade
// method fails the WebSocket handshake with HTTP status 403.
//
// If the CheckOrigin field is nil, then the Upgrader uses a safe default: fail
// the handshake if the Origin request header is present and not equal to the
// Host request header.
//
// An application can allow connections from any origin by specifying a
// function that always returns true:
//
// var upgrader = websocket.Upgrader{
// CheckOrigin: func(r *http.Request) bool { return true },
// }
//
// The deprecated Upgrade function does not enforce an origin policy. It's the
// application's responsibility to check the Origin header before calling
// Upgrade.
package websocket

57
vendor/github.com/gorilla/websocket/json.go generated vendored Normal file
View File

@ -0,0 +1,57 @@
// Copyright 2013 The Gorilla WebSocket Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
package websocket
import (
"encoding/json"
"io"
)
// WriteJSON is deprecated, use c.WriteJSON instead.
func WriteJSON(c *Conn, v interface{}) error {
return c.WriteJSON(v)
}
// WriteJSON writes the JSON encoding of v to the connection.
//
// See the documentation for encoding/json Marshal for details about the
// conversion of Go values to JSON.
func (c *Conn) WriteJSON(v interface{}) error {
w, err := c.NextWriter(TextMessage)
if err != nil {
return err
}
err1 := json.NewEncoder(w).Encode(v)
err2 := w.Close()
if err1 != nil {
return err1
}
return err2
}
// ReadJSON is deprecated, use c.ReadJSON instead.
func ReadJSON(c *Conn, v interface{}) error {
return c.ReadJSON(v)
}
// ReadJSON reads the next JSON-encoded message from the connection and stores
// it in the value pointed to by v.
//
// See the documentation for the encoding/json Unmarshal function for details
// about the conversion of JSON to a Go value.
func (c *Conn) ReadJSON(v interface{}) error {
_, r, err := c.NextReader()
if err != nil {
return err
}
err = json.NewDecoder(r).Decode(v)
if err == io.EOF {
// Decode returns io.EOF when the message is empty or all whitespace.
// Convert to io.ErrUnexpectedEOF so that application can distinguish
// between an error reading the JSON value and the connection closing.
err = io.ErrUnexpectedEOF
}
return err
}

247
vendor/github.com/gorilla/websocket/server.go generated vendored Normal file
View File

@ -0,0 +1,247 @@
// Copyright 2013 The Gorilla WebSocket Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
package websocket
import (
"bufio"
"errors"
"net"
"net/http"
"net/url"
"strings"
"time"
)
// HandshakeError describes an error with the handshake from the peer.
type HandshakeError struct {
message string
}
func (e HandshakeError) Error() string { return e.message }
// Upgrader specifies parameters for upgrading an HTTP connection to a
// WebSocket connection.
type Upgrader struct {
// HandshakeTimeout specifies the duration for the handshake to complete.
HandshakeTimeout time.Duration
// ReadBufferSize and WriteBufferSize specify I/O buffer sizes. If a buffer
// size is zero, then a default value of 4096 is used. The I/O buffer sizes
// do not limit the size of the messages that can be sent or received.
ReadBufferSize, WriteBufferSize int
// Subprotocols specifies the server's supported protocols in order of
// preference. If this field is set, then the Upgrade method negotiates a
// subprotocol by selecting the first match in this list with a protocol
// requested by the client.
Subprotocols []string
// Error specifies the function for generating HTTP error responses. If Error
// is nil, then http.Error is used to generate the HTTP response.
Error func(w http.ResponseWriter, r *http.Request, status int, reason error)
// CheckOrigin returns true if the request Origin header is acceptable. If
// CheckOrigin is nil, the host in the Origin header must not be set or
// must match the host of the request.
CheckOrigin func(r *http.Request) bool
}
func (u *Upgrader) returnError(w http.ResponseWriter, r *http.Request, status int, reason string) (*Conn, error) {
err := HandshakeError{reason}
if u.Error != nil {
u.Error(w, r, status, err)
} else {
http.Error(w, http.StatusText(status), status)
}
return nil, err
}
// checkSameOrigin returns true if the origin is not set or is equal to the request host.
func checkSameOrigin(r *http.Request) bool {
origin := r.Header["Origin"]
if len(origin) == 0 {
return true
}
u, err := url.Parse(origin[0])
if err != nil {
return false
}
return u.Host == r.Host
}
func (u *Upgrader) selectSubprotocol(r *http.Request, responseHeader http.Header) string {
if u.Subprotocols != nil {
clientProtocols := Subprotocols(r)
for _, serverProtocol := range u.Subprotocols {
for _, clientProtocol := range clientProtocols {
if clientProtocol == serverProtocol {
return clientProtocol
}
}
}
} else if responseHeader != nil {
return responseHeader.Get("Sec-Websocket-Protocol")
}
return ""
}
// Upgrade upgrades the HTTP server connection to the WebSocket protocol.
//
// The responseHeader is included in the response to the client's upgrade
// request. Use the responseHeader to specify cookies (Set-Cookie) and the
// application negotiated subprotocol (Sec-Websocket-Protocol).
func (u *Upgrader) Upgrade(w http.ResponseWriter, r *http.Request, responseHeader http.Header) (*Conn, error) {
if values := r.Header["Sec-Websocket-Version"]; len(values) == 0 || values[0] != "13" {
return u.returnError(w, r, http.StatusBadRequest, "websocket: version != 13")
}
if !tokenListContainsValue(r.Header, "Connection", "upgrade") {
return u.returnError(w, r, http.StatusBadRequest, "websocket: could not find connection header with token 'upgrade'")
}
if !tokenListContainsValue(r.Header, "Upgrade", "websocket") {
return u.returnError(w, r, http.StatusBadRequest, "websocket: could not find upgrade header with token 'websocket'")
}
checkOrigin := u.CheckOrigin
if checkOrigin == nil {
checkOrigin = checkSameOrigin
}
if !checkOrigin(r) {
return u.returnError(w, r, http.StatusForbidden, "websocket: origin not allowed")
}
challengeKey := r.Header.Get("Sec-Websocket-Key")
if challengeKey == "" {
return u.returnError(w, r, http.StatusBadRequest, "websocket: key missing or blank")
}
subprotocol := u.selectSubprotocol(r, responseHeader)
var (
netConn net.Conn
br *bufio.Reader
err error
)
h, ok := w.(http.Hijacker)
if !ok {
return u.returnError(w, r, http.StatusInternalServerError, "websocket: response does not implement http.Hijacker")
}
var rw *bufio.ReadWriter
netConn, rw, err = h.Hijack()
if err != nil {
return u.returnError(w, r, http.StatusInternalServerError, err.Error())
}
br = rw.Reader
if br.Buffered() > 0 {
netConn.Close()
return nil, errors.New("websocket: client sent data before handshake is complete")
}
c := newConn(netConn, true, u.ReadBufferSize, u.WriteBufferSize)
c.subprotocol = subprotocol
p := c.writeBuf[:0]
p = append(p, "HTTP/1.1 101 Switching Protocols\r\nUpgrade: websocket\r\nConnection: Upgrade\r\nSec-WebSocket-Accept: "...)
p = append(p, computeAcceptKey(challengeKey)...)
p = append(p, "\r\n"...)
if c.subprotocol != "" {
p = append(p, "Sec-Websocket-Protocol: "...)
p = append(p, c.subprotocol...)
p = append(p, "\r\n"...)
}
for k, vs := range responseHeader {
if k == "Sec-Websocket-Protocol" {
continue
}
for _, v := range vs {
p = append(p, k...)
p = append(p, ": "...)
for i := 0; i < len(v); i++ {
b := v[i]
if b <= 31 {
// prevent response splitting.
b = ' '
}
p = append(p, b)
}
p = append(p, "\r\n"...)
}
}
p = append(p, "\r\n"...)
// Clear deadlines set by HTTP server.
netConn.SetDeadline(time.Time{})
if u.HandshakeTimeout > 0 {
netConn.SetWriteDeadline(time.Now().Add(u.HandshakeTimeout))
}
if _, err = netConn.Write(p); err != nil {
netConn.Close()
return nil, err
}
if u.HandshakeTimeout > 0 {
netConn.SetWriteDeadline(time.Time{})
}
return c, nil
}
// Upgrade upgrades the HTTP server connection to the WebSocket protocol.
//
// This function is deprecated, use websocket.Upgrader instead.
//
// The application is responsible for checking the request origin before
// calling Upgrade. An example implementation of the same origin policy is:
//
// if req.Header.Get("Origin") != "http://"+req.Host {
// http.Error(w, "Origin not allowed", 403)
// return
// }
//
// If the endpoint supports subprotocols, then the application is responsible
// for negotiating the protocol used on the connection. Use the Subprotocols()
// function to get the subprotocols requested by the client. Use the
// Sec-Websocket-Protocol response header to specify the subprotocol selected
// by the application.
//
// The responseHeader is included in the response to the client's upgrade
// request. Use the responseHeader to specify cookies (Set-Cookie) and the
// negotiated subprotocol (Sec-Websocket-Protocol).
//
// The connection buffers IO to the underlying network connection. The
// readBufSize and writeBufSize parameters specify the size of the buffers to
// use. Messages can be larger than the buffers.
//
// If the request is not a valid WebSocket handshake, then Upgrade returns an
// error of type HandshakeError. Applications should handle this error by
// replying to the client with an HTTP error response.
func Upgrade(w http.ResponseWriter, r *http.Request, responseHeader http.Header, readBufSize, writeBufSize int) (*Conn, error) {
u := Upgrader{ReadBufferSize: readBufSize, WriteBufferSize: writeBufSize}
u.Error = func(w http.ResponseWriter, r *http.Request, status int, reason error) {
// don't return errors to maintain backwards compatibility
}
u.CheckOrigin = func(r *http.Request) bool {
// allow all connections by default
return true
}
return u.Upgrade(w, r, responseHeader)
}
// Subprotocols returns the subprotocols requested by the client in the
// Sec-Websocket-Protocol header.
func Subprotocols(r *http.Request) []string {
h := strings.TrimSpace(r.Header.Get("Sec-Websocket-Protocol"))
if h == "" {
return nil
}
protocols := strings.Split(h, ",")
for i := range protocols {
protocols[i] = strings.TrimSpace(protocols[i])
}
return protocols
}

44
vendor/github.com/gorilla/websocket/util.go generated vendored Normal file
View File

@ -0,0 +1,44 @@
// Copyright 2013 The Gorilla WebSocket Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
package websocket
import (
"crypto/rand"
"crypto/sha1"
"encoding/base64"
"io"
"net/http"
"strings"
)
// tokenListContainsValue returns true if the 1#token header with the given
// name contains token.
func tokenListContainsValue(header http.Header, name string, value string) bool {
for _, v := range header[name] {
for _, s := range strings.Split(v, ",") {
if strings.EqualFold(value, strings.TrimSpace(s)) {
return true
}
}
}
return false
}
var keyGUID = []byte("258EAFA5-E914-47DA-95CA-C5AB0DC85B11")
func computeAcceptKey(challengeKey string) string {
h := sha1.New()
h.Write([]byte(challengeKey))
h.Write(keyGUID)
return base64.StdEncoding.EncodeToString(h.Sum(nil))
}
func generateChallengeKey() (string, error) {
p := make([]byte, 16)
if _, err := io.ReadFull(rand.Reader, p); err != nil {
return "", err
}
return base64.StdEncoding.EncodeToString(p), nil
}

177
vendor/github.com/rancher/go-rancher/LICENSE generated vendored Normal file
View File

@ -0,0 +1,177 @@
Apache License
Version 2.0, January 2004
http://www.apache.org/licenses/
TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
1. Definitions.
"License" shall mean the terms and conditions for use, reproduction,
and distribution as defined by Sections 1 through 9 of this document.
"Licensor" shall mean the copyright owner or entity authorized by
the copyright owner that is granting the License.
"Legal Entity" shall mean the union of the acting entity and all
other entities that control, are controlled by, or are under common
control with that entity. For the purposes of this definition,
"control" means (i) the power, direct or indirect, to cause the
direction or management of such entity, whether by contract or
otherwise, or (ii) ownership of fifty percent (50%) or more of the
outstanding shares, or (iii) beneficial ownership of such entity.
"You" (or "Your") shall mean an individual or Legal Entity
exercising permissions granted by this License.
"Source" form shall mean the preferred form for making modifications,
including but not limited to software source code, documentation
source, and configuration files.
"Object" form shall mean any form resulting from mechanical
transformation or translation of a Source form, including but
not limited to compiled object code, generated documentation,
and conversions to other media types.
"Work" shall mean the work of authorship, whether in Source or
Object form, made available under the License, as indicated by a
copyright notice that is included in or attached to the work
(an example is provided in the Appendix below).
"Derivative Works" shall mean any work, whether in Source or Object
form, that is based on (or derived from) the Work and for which the
editorial revisions, annotations, elaborations, or other modifications
represent, as a whole, an original work of authorship. For the purposes
of this License, Derivative Works shall not include works that remain
separable from, or merely link (or bind by name) to the interfaces of,
the Work and Derivative Works thereof.
"Contribution" shall mean any work of authorship, including
the original version of the Work and any modifications or additions
to that Work or Derivative Works thereof, that is intentionally
submitted to Licensor for inclusion in the Work by the copyright owner
or by an individual or Legal Entity authorized to submit on behalf of
the copyright owner. For the purposes of this definition, "submitted"
means any form of electronic, verbal, or written communication sent
to the Licensor or its representatives, including but not limited to
communication on electronic mailing lists, source code control systems,
and issue tracking systems that are managed by, or on behalf of, the
Licensor for the purpose of discussing and improving the Work, but
excluding communication that is conspicuously marked or otherwise
designated in writing by the copyright owner as "Not a Contribution."
"Contributor" shall mean Licensor and any individual or Legal Entity
on behalf of whom a Contribution has been received by Licensor and
subsequently incorporated within the Work.
2. Grant of Copyright License. Subject to the terms and conditions of
this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
copyright license to reproduce, prepare Derivative Works of,
publicly display, publicly perform, sublicense, and distribute the
Work and such Derivative Works in Source or Object form.
3. Grant of Patent License. Subject to the terms and conditions of
this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
(except as stated in this section) patent license to make, have made,
use, offer to sell, sell, import, and otherwise transfer the Work,
where such license applies only to those patent claims licensable
by such Contributor that are necessarily infringed by their
Contribution(s) alone or by combination of their Contribution(s)
with the Work to which such Contribution(s) was submitted. If You
institute patent litigation against any entity (including a
cross-claim or counterclaim in a lawsuit) alleging that the Work
or a Contribution incorporated within the Work constitutes direct
or contributory patent infringement, then any patent licenses
granted to You under this License for that Work shall terminate
as of the date such litigation is filed.
4. Redistribution. You may reproduce and distribute copies of the
Work or Derivative Works thereof in any medium, with or without
modifications, and in Source or Object form, provided that You
meet the following conditions:
(a) You must give any other recipients of the Work or
Derivative Works a copy of this License; and
(b) You must cause any modified files to carry prominent notices
stating that You changed the files; and
(c) You must retain, in the Source form of any Derivative Works
that You distribute, all copyright, patent, trademark, and
attribution notices from the Source form of the Work,
excluding those notices that do not pertain to any part of
the Derivative Works; and
(d) If the Work includes a "NOTICE" text file as part of its
distribution, then any Derivative Works that You distribute must
include a readable copy of the attribution notices contained
within such NOTICE file, excluding those notices that do not
pertain to any part of the Derivative Works, in at least one
of the following places: within a NOTICE text file distributed
as part of the Derivative Works; within the Source form or
documentation, if provided along with the Derivative Works; or,
within a display generated by the Derivative Works, if and
wherever such third-party notices normally appear. The contents
of the NOTICE file are for informational purposes only and
do not modify the License. You may add Your own attribution
notices within Derivative Works that You distribute, alongside
or as an addendum to the NOTICE text from the Work, provided
that such additional attribution notices cannot be construed
as modifying the License.
You may add Your own copyright statement to Your modifications and
may provide additional or different license terms and conditions
for use, reproduction, or distribution of Your modifications, or
for any such Derivative Works as a whole, provided Your use,
reproduction, and distribution of the Work otherwise complies with
the conditions stated in this License.
5. Submission of Contributions. Unless You explicitly state otherwise,
any Contribution intentionally submitted for inclusion in the Work
by You to the Licensor shall be under the terms and conditions of
this License, without any additional terms or conditions.
Notwithstanding the above, nothing herein shall supersede or modify
the terms of any separate license agreement you may have executed
with Licensor regarding such Contributions.
6. Trademarks. This License does not grant permission to use the trade
names, trademarks, service marks, or product names of the Licensor,
except as required for reasonable and customary use in describing the
origin of the Work and reproducing the content of the NOTICE file.
7. Disclaimer of Warranty. Unless required by applicable law or
agreed to in writing, Licensor provides the Work (and each
Contributor provides its Contributions) on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
implied, including, without limitation, any warranties or conditions
of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
PARTICULAR PURPOSE. You are solely responsible for determining the
appropriateness of using or redistributing the Work and assume any
risks associated with Your exercise of permissions under this License.
8. Limitation of Liability. In no event and under no legal theory,
whether in tort (including negligence), contract, or otherwise,
unless required by applicable law (such as deliberate and grossly
negligent acts) or agreed to in writing, shall any Contributor be
liable to You for damages, including any direct, indirect, special,
incidental, or consequential damages of any character arising as a
result of this License or out of the use or inability to use the
Work (including but not limited to damages for loss of goodwill,
work stoppage, computer failure or malfunction, or any and all
other commercial damages or losses), even if such Contributor
has been advised of the possibility of such damages.
9. Accepting Warranty or Additional Liability. While redistributing
the Work or Derivative Works thereof, You may choose to offer,
and charge a fee for, acceptance of support, warranty, indemnity,
or other liability obligations and/or rights consistent with this
License. However, in accepting such obligations, You may act only
on Your own behalf and on Your sole responsibility, not on behalf
of any other Contributor, and only if You agree to indemnify,
defend, and hold each Contributor harmless for any liability
incurred by, or claims asserted against, such Contributor by reason
of your accepting any such warranty or additional liability.
END OF TERMS AND CONDITIONS

35
vendor/github.com/rancher/go-rancher/client/client.go generated vendored Normal file
View File

@ -0,0 +1,35 @@
package client
import (
"net/http"
"github.com/gorilla/websocket"
)
type RancherBaseClientImpl struct {
Opts *ClientOpts
Schemas *Schemas
Types map[string]Schema
}
type RancherBaseClient interface {
Websocket(string, map[string][]string) (*websocket.Conn, *http.Response, error)
List(string, *ListOpts, interface{}) error
Post(string, interface{}, interface{}) error
GetLink(Resource, string, interface{}) error
Create(string, interface{}, interface{}) error
Update(string, *Resource, interface{}, interface{}) error
ById(string, string, interface{}) error
Delete(*Resource) error
Reload(*Resource, interface{}) error
Action(string, string, *Resource, interface{}, interface{}) error
doGet(string, *ListOpts, interface{}) error
doList(string, *ListOpts, interface{}) error
doModify(string, string, interface{}, interface{}) error
doCreate(string, interface{}, interface{}) error
doUpdate(string, *Resource, interface{}, interface{}) error
doById(string, string, interface{}) error
doResourceDelete(string, *Resource) error
doAction(string, string, *Resource, interface{}, interface{}) error
}

571
vendor/github.com/rancher/go-rancher/client/common.go generated vendored Normal file
View File

@ -0,0 +1,571 @@
package client
import (
"bytes"
"encoding/json"
"fmt"
"io"
"io/ioutil"
"net/http"
"net/url"
"os"
"regexp"
"time"
"github.com/gorilla/websocket"
"github.com/pkg/errors"
)
const (
SELF = "self"
COLLECTION = "collection"
)
var (
debug = false
dialer = &websocket.Dialer{}
)
type ClientOpts struct {
Url string
AccessKey string
SecretKey string
Timeout time.Duration
}
type ApiError struct {
StatusCode int
Url string
Msg string
Status string
Body string
}
func (e *ApiError) Error() string {
return e.Msg
}
func IsNotFound(err error) bool {
apiError, ok := err.(*ApiError)
if !ok {
return false
}
return apiError.StatusCode == http.StatusNotFound
}
func newApiError(resp *http.Response, url string) *ApiError {
contents, err := ioutil.ReadAll(resp.Body)
var body string
if err != nil {
body = "Unreadable body."
} else {
body = string(contents)
}
data := map[string]interface{}{}
if json.Unmarshal(contents, &data) == nil {
delete(data, "id")
delete(data, "links")
delete(data, "actions")
delete(data, "type")
delete(data, "status")
buf := &bytes.Buffer{}
for k, v := range data {
if v == nil {
continue
}
if buf.Len() > 0 {
buf.WriteString(", ")
}
fmt.Fprintf(buf, "%s=%v", k, v)
}
body = buf.String()
}
formattedMsg := fmt.Sprintf("Bad response statusCode [%d]. Status [%s]. Body: [%s] from [%s]",
resp.StatusCode, resp.Status, body, url)
return &ApiError{
Url: url,
Msg: formattedMsg,
StatusCode: resp.StatusCode,
Status: resp.Status,
Body: body,
}
}
func contains(array []string, item string) bool {
for _, check := range array {
if check == item {
return true
}
}
return false
}
func appendFilters(urlString string, filters map[string]interface{}) (string, error) {
if len(filters) == 0 {
return urlString, nil
}
u, err := url.Parse(urlString)
if err != nil {
return "", err
}
q := u.Query()
for k, v := range filters {
if l, ok := v.([]string); ok {
for _, v := range l {
q.Add(k, v)
}
} else {
q.Add(k, fmt.Sprintf("%v", v))
}
}
u.RawQuery = q.Encode()
return u.String(), nil
}
func setupRancherBaseClient(rancherClient *RancherBaseClientImpl, opts *ClientOpts) error {
if opts.Timeout == 0 {
opts.Timeout = time.Second * 10
}
client := &http.Client{Timeout: opts.Timeout}
req, err := http.NewRequest("GET", opts.Url, nil)
if err != nil {
return err
}
req.SetBasicAuth(opts.AccessKey, opts.SecretKey)
resp, err := client.Do(req)
if err != nil {
return err
}
defer resp.Body.Close()
if resp.StatusCode != 200 {
return newApiError(resp, opts.Url)
}
schemasUrls := resp.Header.Get("X-API-Schemas")
if len(schemasUrls) == 0 {
return errors.New("Failed to find schema at [" + opts.Url + "]")
}
if schemasUrls != opts.Url {
req, err = http.NewRequest("GET", schemasUrls, nil)
req.SetBasicAuth(opts.AccessKey, opts.SecretKey)
if err != nil {
return err
}
resp, err = client.Do(req)
if err != nil {
return err
}
defer resp.Body.Close()
if resp.StatusCode != 200 {
return newApiError(resp, opts.Url)
}
}
var schemas Schemas
bytes, err := ioutil.ReadAll(resp.Body)
if err != nil {
return err
}
err = json.Unmarshal(bytes, &schemas)
if err != nil {
return err
}
rancherClient.Opts = opts
rancherClient.Schemas = &schemas
for _, schema := range schemas.Data {
rancherClient.Types[schema.Id] = schema
}
return nil
}
func NewListOpts() *ListOpts {
return &ListOpts{
Filters: map[string]interface{}{},
}
}
func (rancherClient *RancherBaseClientImpl) setupRequest(req *http.Request) {
req.SetBasicAuth(rancherClient.Opts.AccessKey, rancherClient.Opts.SecretKey)
}
func (rancherClient *RancherBaseClientImpl) newHttpClient() *http.Client {
if rancherClient.Opts.Timeout == 0 {
rancherClient.Opts.Timeout = time.Second * 10
}
return &http.Client{Timeout: rancherClient.Opts.Timeout}
}
func (rancherClient *RancherBaseClientImpl) doDelete(url string) error {
client := rancherClient.newHttpClient()
req, err := http.NewRequest("DELETE", url, nil)
if err != nil {
return err
}
rancherClient.setupRequest(req)
resp, err := client.Do(req)
if err != nil {
return err
}
defer resp.Body.Close()
io.Copy(ioutil.Discard, resp.Body)
if resp.StatusCode >= 300 {
return newApiError(resp, url)
}
return nil
}
func (rancherClient *RancherBaseClientImpl) Websocket(url string, headers map[string][]string) (*websocket.Conn, *http.Response, error) {
return dialer.Dial(url, http.Header(headers))
}
func (rancherClient *RancherBaseClientImpl) doGet(url string, opts *ListOpts, respObject interface{}) error {
if opts == nil {
opts = NewListOpts()
}
url, err := appendFilters(url, opts.Filters)
if err != nil {
return err
}
if debug {
fmt.Println("GET " + url)
}
client := rancherClient.newHttpClient()
req, err := http.NewRequest("GET", url, nil)
if err != nil {
return err
}
rancherClient.setupRequest(req)
resp, err := client.Do(req)
if err != nil {
return err
}
defer resp.Body.Close()
if resp.StatusCode != 200 {
return newApiError(resp, url)
}
byteContent, err := ioutil.ReadAll(resp.Body)
if err != nil {
return err
}
if debug {
fmt.Println("Response <= " + string(byteContent))
}
if err := json.Unmarshal(byteContent, respObject); err != nil {
return errors.Wrap(err, fmt.Sprintf("Failed to parse: %s", byteContent))
}
return nil
}
func (rancherClient *RancherBaseClientImpl) List(schemaType string, opts *ListOpts, respObject interface{}) error {
return rancherClient.doList(schemaType, opts, respObject)
}
func (rancherClient *RancherBaseClientImpl) doList(schemaType string, opts *ListOpts, respObject interface{}) error {
schema, ok := rancherClient.Types[schemaType]
if !ok {
return errors.New("Unknown schema type [" + schemaType + "]")
}
if !contains(schema.CollectionMethods, "GET") {
return errors.New("Resource type [" + schemaType + "] is not listable")
}
collectionUrl, ok := schema.Links[COLLECTION]
if !ok {
return errors.New("Failed to find collection URL for [" + schemaType + "]")
}
return rancherClient.doGet(collectionUrl, opts, respObject)
}
func (rancherClient *RancherBaseClientImpl) Post(url string, createObj interface{}, respObject interface{}) error {
return rancherClient.doModify("POST", url, createObj, respObject)
}
func (rancherClient *RancherBaseClientImpl) GetLink(resource Resource, link string, respObject interface{}) error {
url := resource.Links[link]
if url == "" {
return fmt.Errorf("Failed to find link: %s", link)
}
return rancherClient.doGet(url, &ListOpts{}, respObject)
}
func (rancherClient *RancherBaseClientImpl) doModify(method string, url string, createObj interface{}, respObject interface{}) error {
bodyContent, err := json.Marshal(createObj)
if err != nil {
return err
}
if debug {
fmt.Println(method + " " + url)
fmt.Println("Request => " + string(bodyContent))
}
client := rancherClient.newHttpClient()
req, err := http.NewRequest(method, url, bytes.NewBuffer(bodyContent))
if err != nil {
return err
}
rancherClient.setupRequest(req)
req.Header.Set("Content-Type", "application/json")
req.Header.Set("Content-Length", string(len(bodyContent)))
resp, err := client.Do(req)
if err != nil {
return err
}
defer resp.Body.Close()
if resp.StatusCode >= 300 {
return newApiError(resp, url)
}
byteContent, err := ioutil.ReadAll(resp.Body)
if err != nil {
return err
}
if len(byteContent) > 0 {
if debug {
fmt.Println("Response <= " + string(byteContent))
}
return json.Unmarshal(byteContent, respObject)
}
return nil
}
func (rancherClient *RancherBaseClientImpl) Create(schemaType string, createObj interface{}, respObject interface{}) error {
return rancherClient.doCreate(schemaType, createObj, respObject)
}
func (rancherClient *RancherBaseClientImpl) doCreate(schemaType string, createObj interface{}, respObject interface{}) error {
if createObj == nil {
createObj = map[string]string{}
}
if respObject == nil {
respObject = &map[string]interface{}{}
}
schema, ok := rancherClient.Types[schemaType]
if !ok {
return errors.New("Unknown schema type [" + schemaType + "]")
}
if !contains(schema.CollectionMethods, "POST") {
return errors.New("Resource type [" + schemaType + "] is not creatable")
}
var collectionUrl string
collectionUrl, ok = schema.Links[COLLECTION]
if !ok {
// return errors.New("Failed to find collection URL for [" + schemaType + "]")
// This is a hack to address https://github.com/rancher/cattle/issues/254
re := regexp.MustCompile("schemas.*")
collectionUrl = re.ReplaceAllString(schema.Links[SELF], schema.PluralName)
}
return rancherClient.doModify("POST", collectionUrl, createObj, respObject)
}
func (rancherClient *RancherBaseClientImpl) Update(schemaType string, existing *Resource, updates interface{}, respObject interface{}) error {
return rancherClient.doUpdate(schemaType, existing, updates, respObject)
}
func (rancherClient *RancherBaseClientImpl) doUpdate(schemaType string, existing *Resource, updates interface{}, respObject interface{}) error {
if existing == nil {
return errors.New("Existing object is nil")
}
selfUrl, ok := existing.Links[SELF]
if !ok {
return errors.New(fmt.Sprintf("Failed to find self URL of [%v]", existing))
}
if updates == nil {
updates = map[string]string{}
}
if respObject == nil {
respObject = &map[string]interface{}{}
}
schema, ok := rancherClient.Types[schemaType]
if !ok {
return errors.New("Unknown schema type [" + schemaType + "]")
}
if !contains(schema.ResourceMethods, "PUT") {
return errors.New("Resource type [" + schemaType + "] is not updatable")
}
return rancherClient.doModify("PUT", selfUrl, updates, respObject)
}
func (rancherClient *RancherBaseClientImpl) ById(schemaType string, id string, respObject interface{}) error {
return rancherClient.doById(schemaType, id, respObject)
}
func (rancherClient *RancherBaseClientImpl) doById(schemaType string, id string, respObject interface{}) error {
schema, ok := rancherClient.Types[schemaType]
if !ok {
return errors.New("Unknown schema type [" + schemaType + "]")
}
if !contains(schema.ResourceMethods, "GET") {
return errors.New("Resource type [" + schemaType + "] can not be looked up by ID")
}
collectionUrl, ok := schema.Links[COLLECTION]
if !ok {
return errors.New("Failed to find collection URL for [" + schemaType + "]")
}
err := rancherClient.doGet(collectionUrl+"/"+id, nil, respObject)
//TODO check for 404 and return nil, nil
return err
}
func (rancherClient *RancherBaseClientImpl) Delete(existing *Resource) error {
if existing == nil {
return nil
}
return rancherClient.doResourceDelete(existing.Type, existing)
}
func (rancherClient *RancherBaseClientImpl) doResourceDelete(schemaType string, existing *Resource) error {
schema, ok := rancherClient.Types[schemaType]
if !ok {
return errors.New("Unknown schema type [" + schemaType + "]")
}
if !contains(schema.ResourceMethods, "DELETE") {
return errors.New("Resource type [" + schemaType + "] can not be deleted")
}
selfUrl, ok := existing.Links[SELF]
if !ok {
return errors.New(fmt.Sprintf("Failed to find self URL of [%v]", existing))
}
return rancherClient.doDelete(selfUrl)
}
func (rancherClient *RancherBaseClientImpl) Reload(existing *Resource, output interface{}) error {
selfUrl, ok := existing.Links[SELF]
if !ok {
return errors.New(fmt.Sprintf("Failed to find self URL of [%v]", existing))
}
return rancherClient.doGet(selfUrl, NewListOpts(), output)
}
func (rancherClient *RancherBaseClientImpl) Action(schemaType string, action string,
existing *Resource, inputObject, respObject interface{}) error {
return rancherClient.doAction(schemaType, action, existing, inputObject, respObject)
}
func (rancherClient *RancherBaseClientImpl) doAction(schemaType string, action string,
existing *Resource, inputObject, respObject interface{}) error {
if existing == nil {
return errors.New("Existing object is nil")
}
actionUrl, ok := existing.Actions[action]
if !ok {
return errors.New(fmt.Sprintf("Action [%v] not available on [%v]", action, existing))
}
_, ok = rancherClient.Types[schemaType]
if !ok {
return errors.New("Unknown schema type [" + schemaType + "]")
}
var input io.Reader
if inputObject != nil {
bodyContent, err := json.Marshal(inputObject)
if err != nil {
return err
}
if debug {
fmt.Println("Request => " + string(bodyContent))
}
input = bytes.NewBuffer(bodyContent)
}
client := rancherClient.newHttpClient()
req, err := http.NewRequest("POST", actionUrl, input)
if err != nil {
return err
}
rancherClient.setupRequest(req)
req.Header.Set("Content-Type", "application/json")
req.Header.Set("Content-Length", "0")
resp, err := client.Do(req)
if err != nil {
return err
}
defer resp.Body.Close()
if resp.StatusCode >= 300 {
return newApiError(resp, actionUrl)
}
byteContent, err := ioutil.ReadAll(resp.Body)
if err != nil {
return err
}
if debug {
fmt.Println("Response <= " + string(byteContent))
}
return json.Unmarshal(byteContent, respObject)
}
func init() {
debug = os.Getenv("RANCHER_CLIENT_DEBUG") == "true"
if debug {
fmt.Println("Rancher client debug on")
}
}

172
vendor/github.com/rancher/go-rancher/client/generated_account.go generated vendored Normal file
View File

@ -0,0 +1,172 @@
package client
const (
ACCOUNT_TYPE = "account"
)
type Account struct {
Resource
Created string `json:"created,omitempty" yaml:"created,omitempty"`
Data map[string]interface{} `json:"data,omitempty" yaml:"data,omitempty"`
Description string `json:"description,omitempty" yaml:"description,omitempty"`
ExternalId string `json:"externalId,omitempty" yaml:"external_id,omitempty"`
ExternalIdType string `json:"externalIdType,omitempty" yaml:"external_id_type,omitempty"`
Identity string `json:"identity,omitempty" yaml:"identity,omitempty"`
Kind string `json:"kind,omitempty" yaml:"kind,omitempty"`
Name string `json:"name,omitempty" yaml:"name,omitempty"`
RemoveTime string `json:"removeTime,omitempty" yaml:"remove_time,omitempty"`
Removed string `json:"removed,omitempty" yaml:"removed,omitempty"`
State string `json:"state,omitempty" yaml:"state,omitempty"`
Transitioning string `json:"transitioning,omitempty" yaml:"transitioning,omitempty"`
TransitioningMessage string `json:"transitioningMessage,omitempty" yaml:"transitioning_message,omitempty"`
TransitioningProgress int64 `json:"transitioningProgress,omitempty" yaml:"transitioning_progress,omitempty"`
Uuid string `json:"uuid,omitempty" yaml:"uuid,omitempty"`
}
type AccountCollection struct {
Collection
Data []Account `json:"data,omitempty"`
}
type AccountClient struct {
rancherClient *RancherClient
}
type AccountOperations interface {
List(opts *ListOpts) (*AccountCollection, error)
Create(opts *Account) (*Account, error)
Update(existing *Account, updates interface{}) (*Account, error)
ById(id string) (*Account, error)
Delete(container *Account) error
ActionActivate(*Account) (*Account, error)
ActionCreate(*Account) (*Account, error)
ActionDeactivate(*Account) (*Account, error)
ActionPurge(*Account) (*Account, error)
ActionRemove(*Account) (*Account, error)
ActionRestore(*Account) (*Account, error)
ActionUpdate(*Account) (*Account, error)
}
func newAccountClient(rancherClient *RancherClient) *AccountClient {
return &AccountClient{
rancherClient: rancherClient,
}
}
func (c *AccountClient) Create(container *Account) (*Account, error) {
resp := &Account{}
err := c.rancherClient.doCreate(ACCOUNT_TYPE, container, resp)
return resp, err
}
func (c *AccountClient) Update(existing *Account, updates interface{}) (*Account, error) {
resp := &Account{}
err := c.rancherClient.doUpdate(ACCOUNT_TYPE, &existing.Resource, updates, resp)
return resp, err
}
func (c *AccountClient) List(opts *ListOpts) (*AccountCollection, error) {
resp := &AccountCollection{}
err := c.rancherClient.doList(ACCOUNT_TYPE, opts, resp)
return resp, err
}
func (c *AccountClient) ById(id string) (*Account, error) {
resp := &Account{}
err := c.rancherClient.doById(ACCOUNT_TYPE, id, resp)
if apiError, ok := err.(*ApiError); ok {
if apiError.StatusCode == 404 {
return nil, nil
}
}
return resp, err
}
func (c *AccountClient) Delete(container *Account) error {
return c.rancherClient.doResourceDelete(ACCOUNT_TYPE, &container.Resource)
}
func (c *AccountClient) ActionActivate(resource *Account) (*Account, error) {
resp := &Account{}
err := c.rancherClient.doAction(ACCOUNT_TYPE, "activate", &resource.Resource, nil, resp)
return resp, err
}
func (c *AccountClient) ActionCreate(resource *Account) (*Account, error) {
resp := &Account{}
err := c.rancherClient.doAction(ACCOUNT_TYPE, "create", &resource.Resource, nil, resp)
return resp, err
}
func (c *AccountClient) ActionDeactivate(resource *Account) (*Account, error) {
resp := &Account{}
err := c.rancherClient.doAction(ACCOUNT_TYPE, "deactivate", &resource.Resource, nil, resp)
return resp, err
}
func (c *AccountClient) ActionPurge(resource *Account) (*Account, error) {
resp := &Account{}
err := c.rancherClient.doAction(ACCOUNT_TYPE, "purge", &resource.Resource, nil, resp)
return resp, err
}
func (c *AccountClient) ActionRemove(resource *Account) (*Account, error) {
resp := &Account{}
err := c.rancherClient.doAction(ACCOUNT_TYPE, "remove", &resource.Resource, nil, resp)
return resp, err
}
func (c *AccountClient) ActionRestore(resource *Account) (*Account, error) {
resp := &Account{}
err := c.rancherClient.doAction(ACCOUNT_TYPE, "restore", &resource.Resource, nil, resp)
return resp, err
}
func (c *AccountClient) ActionUpdate(resource *Account) (*Account, error) {
resp := &Account{}
err := c.rancherClient.doAction(ACCOUNT_TYPE, "update", &resource.Resource, nil, resp)
return resp, err
}

75
vendor/github.com/rancher/go-rancher/client/generated_active_setting.go generated vendored Normal file
View File

@ -0,0 +1,75 @@
package client
const (
ACTIVE_SETTING_TYPE = "activeSetting"
)
type ActiveSetting struct {
Resource
ActiveValue interface{} `json:"activeValue,omitempty" yaml:"active_value,omitempty"`
InDb bool `json:"inDb,omitempty" yaml:"in_db,omitempty"`
Name string `json:"name,omitempty" yaml:"name,omitempty"`
Source string `json:"source,omitempty" yaml:"source,omitempty"`
Value string `json:"value,omitempty" yaml:"value,omitempty"`
}
type ActiveSettingCollection struct {
Collection
Data []ActiveSetting `json:"data,omitempty"`
}
type ActiveSettingClient struct {
rancherClient *RancherClient
}
type ActiveSettingOperations interface {
List(opts *ListOpts) (*ActiveSettingCollection, error)
Create(opts *ActiveSetting) (*ActiveSetting, error)
Update(existing *ActiveSetting, updates interface{}) (*ActiveSetting, error)
ById(id string) (*ActiveSetting, error)
Delete(container *ActiveSetting) error
}
func newActiveSettingClient(rancherClient *RancherClient) *ActiveSettingClient {
return &ActiveSettingClient{
rancherClient: rancherClient,
}
}
func (c *ActiveSettingClient) Create(container *ActiveSetting) (*ActiveSetting, error) {
resp := &ActiveSetting{}
err := c.rancherClient.doCreate(ACTIVE_SETTING_TYPE, container, resp)
return resp, err
}
func (c *ActiveSettingClient) Update(existing *ActiveSetting, updates interface{}) (*ActiveSetting, error) {
resp := &ActiveSetting{}
err := c.rancherClient.doUpdate(ACTIVE_SETTING_TYPE, &existing.Resource, updates, resp)
return resp, err
}
func (c *ActiveSettingClient) List(opts *ListOpts) (*ActiveSettingCollection, error) {
resp := &ActiveSettingCollection{}
err := c.rancherClient.doList(ACTIVE_SETTING_TYPE, opts, resp)
return resp, err
}
func (c *ActiveSettingClient) ById(id string) (*ActiveSetting, error) {
resp := &ActiveSetting{}
err := c.rancherClient.doById(ACTIVE_SETTING_TYPE, id, resp)
if apiError, ok := err.(*ApiError); ok {
if apiError.StatusCode == 404 {
return nil, nil
}
}
return resp, err
}
func (c *ActiveSettingClient) Delete(container *ActiveSetting) error {
return c.rancherClient.doResourceDelete(ACTIVE_SETTING_TYPE, &container.Resource)
}

67
vendor/github.com/rancher/go-rancher/client/generated_add_outputs_input.go generated vendored Normal file
View File

@ -0,0 +1,67 @@
package client
const (
ADD_OUTPUTS_INPUT_TYPE = "addOutputsInput"
)
type AddOutputsInput struct {
Resource
Outputs map[string]interface{} `json:"outputs,omitempty" yaml:"outputs,omitempty"`
}
type AddOutputsInputCollection struct {
Collection
Data []AddOutputsInput `json:"data,omitempty"`
}
type AddOutputsInputClient struct {
rancherClient *RancherClient
}
type AddOutputsInputOperations interface {
List(opts *ListOpts) (*AddOutputsInputCollection, error)
Create(opts *AddOutputsInput) (*AddOutputsInput, error)
Update(existing *AddOutputsInput, updates interface{}) (*AddOutputsInput, error)
ById(id string) (*AddOutputsInput, error)
Delete(container *AddOutputsInput) error
}
func newAddOutputsInputClient(rancherClient *RancherClient) *AddOutputsInputClient {
return &AddOutputsInputClient{
rancherClient: rancherClient,
}
}
func (c *AddOutputsInputClient) Create(container *AddOutputsInput) (*AddOutputsInput, error) {
resp := &AddOutputsInput{}
err := c.rancherClient.doCreate(ADD_OUTPUTS_INPUT_TYPE, container, resp)
return resp, err
}
func (c *AddOutputsInputClient) Update(existing *AddOutputsInput, updates interface{}) (*AddOutputsInput, error) {
resp := &AddOutputsInput{}
err := c.rancherClient.doUpdate(ADD_OUTPUTS_INPUT_TYPE, &existing.Resource, updates, resp)
return resp, err
}
func (c *AddOutputsInputClient) List(opts *ListOpts) (*AddOutputsInputCollection, error) {
resp := &AddOutputsInputCollection{}
err := c.rancherClient.doList(ADD_OUTPUTS_INPUT_TYPE, opts, resp)
return resp, err
}
func (c *AddOutputsInputClient) ById(id string) (*AddOutputsInput, error) {
resp := &AddOutputsInput{}
err := c.rancherClient.doById(ADD_OUTPUTS_INPUT_TYPE, id, resp)
if apiError, ok := err.(*ApiError); ok {
if apiError.StatusCode == 404 {
return nil, nil
}
}
return resp, err
}
func (c *AddOutputsInputClient) Delete(container *AddOutputsInput) error {
return c.rancherClient.doResourceDelete(ADD_OUTPUTS_INPUT_TYPE, &container.Resource)
}

67
vendor/github.com/rancher/go-rancher/client/generated_add_remove_load_balancer_service_link_input.go generated vendored Normal file
View File

@ -0,0 +1,67 @@
package client
const (
ADD_REMOVE_LOAD_BALANCER_SERVICE_LINK_INPUT_TYPE = "addRemoveLoadBalancerServiceLinkInput"
)
type AddRemoveLoadBalancerServiceLinkInput struct {
Resource
ServiceLink LoadBalancerServiceLink `json:"serviceLink,omitempty" yaml:"service_link,omitempty"`
}
type AddRemoveLoadBalancerServiceLinkInputCollection struct {
Collection
Data []AddRemoveLoadBalancerServiceLinkInput `json:"data,omitempty"`
}
type AddRemoveLoadBalancerServiceLinkInputClient struct {
rancherClient *RancherClient
}
type AddRemoveLoadBalancerServiceLinkInputOperations interface {
List(opts *ListOpts) (*AddRemoveLoadBalancerServiceLinkInputCollection, error)
Create(opts *AddRemoveLoadBalancerServiceLinkInput) (*AddRemoveLoadBalancerServiceLinkInput, error)
Update(existing *AddRemoveLoadBalancerServiceLinkInput, updates interface{}) (*AddRemoveLoadBalancerServiceLinkInput, error)
ById(id string) (*AddRemoveLoadBalancerServiceLinkInput, error)
Delete(container *AddRemoveLoadBalancerServiceLinkInput) error
}
func newAddRemoveLoadBalancerServiceLinkInputClient(rancherClient *RancherClient) *AddRemoveLoadBalancerServiceLinkInputClient {
return &AddRemoveLoadBalancerServiceLinkInputClient{
rancherClient: rancherClient,
}
}
func (c *AddRemoveLoadBalancerServiceLinkInputClient) Create(container *AddRemoveLoadBalancerServiceLinkInput) (*AddRemoveLoadBalancerServiceLinkInput, error) {
resp := &AddRemoveLoadBalancerServiceLinkInput{}
err := c.rancherClient.doCreate(ADD_REMOVE_LOAD_BALANCER_SERVICE_LINK_INPUT_TYPE, container, resp)
return resp, err
}
func (c *AddRemoveLoadBalancerServiceLinkInputClient) Update(existing *AddRemoveLoadBalancerServiceLinkInput, updates interface{}) (*AddRemoveLoadBalancerServiceLinkInput, error) {
resp := &AddRemoveLoadBalancerServiceLinkInput{}
err := c.rancherClient.doUpdate(ADD_REMOVE_LOAD_BALANCER_SERVICE_LINK_INPUT_TYPE, &existing.Resource, updates, resp)
return resp, err
}
func (c *AddRemoveLoadBalancerServiceLinkInputClient) List(opts *ListOpts) (*AddRemoveLoadBalancerServiceLinkInputCollection, error) {
resp := &AddRemoveLoadBalancerServiceLinkInputCollection{}
err := c.rancherClient.doList(ADD_REMOVE_LOAD_BALANCER_SERVICE_LINK_INPUT_TYPE, opts, resp)
return resp, err
}
func (c *AddRemoveLoadBalancerServiceLinkInputClient) ById(id string) (*AddRemoveLoadBalancerServiceLinkInput, error) {
resp := &AddRemoveLoadBalancerServiceLinkInput{}
err := c.rancherClient.doById(ADD_REMOVE_LOAD_BALANCER_SERVICE_LINK_INPUT_TYPE, id, resp)
if apiError, ok := err.(*ApiError); ok {
if apiError.StatusCode == 404 {
return nil, nil
}
}
return resp, err
}
func (c *AddRemoveLoadBalancerServiceLinkInputClient) Delete(container *AddRemoveLoadBalancerServiceLinkInput) error {
return c.rancherClient.doResourceDelete(ADD_REMOVE_LOAD_BALANCER_SERVICE_LINK_INPUT_TYPE, &container.Resource)
}

67
vendor/github.com/rancher/go-rancher/client/generated_add_remove_service_link_input.go generated vendored Normal file
View File

@ -0,0 +1,67 @@
package client
const (
ADD_REMOVE_SERVICE_LINK_INPUT_TYPE = "addRemoveServiceLinkInput"
)
type AddRemoveServiceLinkInput struct {
Resource
ServiceLink ServiceLink `json:"serviceLink,omitempty" yaml:"service_link,omitempty"`
}
type AddRemoveServiceLinkInputCollection struct {
Collection
Data []AddRemoveServiceLinkInput `json:"data,omitempty"`
}
type AddRemoveServiceLinkInputClient struct {
rancherClient *RancherClient
}
type AddRemoveServiceLinkInputOperations interface {
List(opts *ListOpts) (*AddRemoveServiceLinkInputCollection, error)
Create(opts *AddRemoveServiceLinkInput) (*AddRemoveServiceLinkInput, error)
Update(existing *AddRemoveServiceLinkInput, updates interface{}) (*AddRemoveServiceLinkInput, error)
ById(id string) (*AddRemoveServiceLinkInput, error)
Delete(container *AddRemoveServiceLinkInput) error
}
func newAddRemoveServiceLinkInputClient(rancherClient *RancherClient) *AddRemoveServiceLinkInputClient {
return &AddRemoveServiceLinkInputClient{
rancherClient: rancherClient,
}
}
func (c *AddRemoveServiceLinkInputClient) Create(container *AddRemoveServiceLinkInput) (*AddRemoveServiceLinkInput, error) {
resp := &AddRemoveServiceLinkInput{}
err := c.rancherClient.doCreate(ADD_REMOVE_SERVICE_LINK_INPUT_TYPE, container, resp)
return resp, err
}
func (c *AddRemoveServiceLinkInputClient) Update(existing *AddRemoveServiceLinkInput, updates interface{}) (*AddRemoveServiceLinkInput, error) {
resp := &AddRemoveServiceLinkInput{}
err := c.rancherClient.doUpdate(ADD_REMOVE_SERVICE_LINK_INPUT_TYPE, &existing.Resource, updates, resp)
return resp, err
}
func (c *AddRemoveServiceLinkInputClient) List(opts *ListOpts) (*AddRemoveServiceLinkInputCollection, error) {
resp := &AddRemoveServiceLinkInputCollection{}
err := c.rancherClient.doList(ADD_REMOVE_SERVICE_LINK_INPUT_TYPE, opts, resp)
return resp, err
}
func (c *AddRemoveServiceLinkInputClient) ById(id string) (*AddRemoveServiceLinkInput, error) {
resp := &AddRemoveServiceLinkInput{}
err := c.rancherClient.doById(ADD_REMOVE_SERVICE_LINK_INPUT_TYPE, id, resp)
if apiError, ok := err.(*ApiError); ok {
if apiError.StatusCode == 404 {
return nil, nil
}
}
return resp, err
}
func (c *AddRemoveServiceLinkInputClient) Delete(container *AddRemoveServiceLinkInput) error {
return c.rancherClient.doResourceDelete(ADD_REMOVE_SERVICE_LINK_INPUT_TYPE, &container.Resource)
}

194
vendor/github.com/rancher/go-rancher/client/generated_agent.go generated vendored Normal file
View File

@ -0,0 +1,194 @@
package client
const (
AGENT_TYPE = "agent"
)
type Agent struct {
Resource
AccountId string `json:"accountId,omitempty" yaml:"account_id,omitempty"`
Created string `json:"created,omitempty" yaml:"created,omitempty"`
Data map[string]interface{} `json:"data,omitempty" yaml:"data,omitempty"`
Description string `json:"description,omitempty" yaml:"description,omitempty"`
Kind string `json:"kind,omitempty" yaml:"kind,omitempty"`
ManagedConfig bool `json:"managedConfig,omitempty" yaml:"managed_config,omitempty"`
Name string `json:"name,omitempty" yaml:"name,omitempty"`
RemoveTime string `json:"removeTime,omitempty" yaml:"remove_time,omitempty"`
Removed string `json:"removed,omitempty" yaml:"removed,omitempty"`
State string `json:"state,omitempty" yaml:"state,omitempty"`
Transitioning string `json:"transitioning,omitempty" yaml:"transitioning,omitempty"`
TransitioningMessage string `json:"transitioningMessage,omitempty" yaml:"transitioning_message,omitempty"`
TransitioningProgress int64 `json:"transitioningProgress,omitempty" yaml:"transitioning_progress,omitempty"`
Uri string `json:"uri,omitempty" yaml:"uri,omitempty"`
Uuid string `json:"uuid,omitempty" yaml:"uuid,omitempty"`
}
type AgentCollection struct {
Collection
Data []Agent `json:"data,omitempty"`
}
type AgentClient struct {
rancherClient *RancherClient
}
type AgentOperations interface {
List(opts *ListOpts) (*AgentCollection, error)
Create(opts *Agent) (*Agent, error)
Update(existing *Agent, updates interface{}) (*Agent, error)
ById(id string) (*Agent, error)
Delete(container *Agent) error
ActionActivate(*Agent) (*Agent, error)
ActionCreate(*Agent) (*Agent, error)
ActionDeactivate(*Agent) (*Agent, error)
ActionDisconnect(*Agent) (*Agent, error)
ActionPurge(*Agent) (*Agent, error)
ActionReconnect(*Agent) (*Agent, error)
ActionRemove(*Agent) (*Agent, error)
ActionRestore(*Agent) (*Agent, error)
ActionUpdate(*Agent) (*Agent, error)
}
func newAgentClient(rancherClient *RancherClient) *AgentClient {
return &AgentClient{
rancherClient: rancherClient,
}
}
func (c *AgentClient) Create(container *Agent) (*Agent, error) {
resp := &Agent{}
err := c.rancherClient.doCreate(AGENT_TYPE, container, resp)
return resp, err
}
func (c *AgentClient) Update(existing *Agent, updates interface{}) (*Agent, error) {
resp := &Agent{}
err := c.rancherClient.doUpdate(AGENT_TYPE, &existing.Resource, updates, resp)
return resp, err
}
func (c *AgentClient) List(opts *ListOpts) (*AgentCollection, error) {
resp := &AgentCollection{}
err := c.rancherClient.doList(AGENT_TYPE, opts, resp)
return resp, err
}
func (c *AgentClient) ById(id string) (*Agent, error) {
resp := &Agent{}
err := c.rancherClient.doById(AGENT_TYPE, id, resp)
if apiError, ok := err.(*ApiError); ok {
if apiError.StatusCode == 404 {
return nil, nil
}
}
return resp, err
}
func (c *AgentClient) Delete(container *Agent) error {
return c.rancherClient.doResourceDelete(AGENT_TYPE, &container.Resource)
}
func (c *AgentClient) ActionActivate(resource *Agent) (*Agent, error) {
resp := &Agent{}
err := c.rancherClient.doAction(AGENT_TYPE, "activate", &resource.Resource, nil, resp)
return resp, err
}
func (c *AgentClient) ActionCreate(resource *Agent) (*Agent, error) {
resp := &Agent{}
err := c.rancherClient.doAction(AGENT_TYPE, "create", &resource.Resource, nil, resp)
return resp, err
}
func (c *AgentClient) ActionDeactivate(resource *Agent) (*Agent, error) {
resp := &Agent{}
err := c.rancherClient.doAction(AGENT_TYPE, "deactivate", &resource.Resource, nil, resp)
return resp, err
}
func (c *AgentClient) ActionDisconnect(resource *Agent) (*Agent, error) {
resp := &Agent{}
err := c.rancherClient.doAction(AGENT_TYPE, "disconnect", &resource.Resource, nil, resp)
return resp, err
}
func (c *AgentClient) ActionPurge(resource *Agent) (*Agent, error) {
resp := &Agent{}
err := c.rancherClient.doAction(AGENT_TYPE, "purge", &resource.Resource, nil, resp)
return resp, err
}
func (c *AgentClient) ActionReconnect(resource *Agent) (*Agent, error) {
resp := &Agent{}
err := c.rancherClient.doAction(AGENT_TYPE, "reconnect", &resource.Resource, nil, resp)
return resp, err
}
func (c *AgentClient) ActionRemove(resource *Agent) (*Agent, error) {
resp := &Agent{}
err := c.rancherClient.doAction(AGENT_TYPE, "remove", &resource.Resource, nil, resp)
return resp, err
}
func (c *AgentClient) ActionRestore(resource *Agent) (*Agent, error) {
resp := &Agent{}
err := c.rancherClient.doAction(AGENT_TYPE, "restore", &resource.Resource, nil, resp)
return resp, err
}
func (c *AgentClient) ActionUpdate(resource *Agent) (*Agent, error) {
resp := &Agent{}
err := c.rancherClient.doAction(AGENT_TYPE, "update", &resource.Resource, nil, resp)
return resp, err
}

121
vendor/github.com/rancher/go-rancher/client/generated_amazonec2config.go generated vendored Normal file
View File

@ -0,0 +1,121 @@
package client
const (
AMAZONEC2CONFIG_TYPE = "amazonec2Config"
)
type Amazonec2Config struct {
Resource
AccessKey string `json:"accessKey,omitempty" yaml:"access_key,omitempty"`
Ami string `json:"ami,omitempty" yaml:"ami,omitempty"`
DeviceName string `json:"deviceName,omitempty" yaml:"device_name,omitempty"`
Endpoint string `json:"endpoint,omitempty" yaml:"endpoint,omitempty"`
IamInstanceProfile string `json:"iamInstanceProfile,omitempty" yaml:"iam_instance_profile,omitempty"`
InsecureTransport bool `json:"insecureTransport,omitempty" yaml:"insecure_transport,omitempty"`
InstanceType string `json:"instanceType,omitempty" yaml:"instance_type,omitempty"`
KeypairName string `json:"keypairName,omitempty" yaml:"keypair_name,omitempty"`
Monitoring bool `json:"monitoring,omitempty" yaml:"monitoring,omitempty"`
OpenPort []string `json:"openPort,omitempty" yaml:"open_port,omitempty"`
PrivateAddressOnly bool `json:"privateAddressOnly,omitempty" yaml:"private_address_only,omitempty"`
Region string `json:"region,omitempty" yaml:"region,omitempty"`
RequestSpotInstance bool `json:"requestSpotInstance,omitempty" yaml:"request_spot_instance,omitempty"`
Retries string `json:"retries,omitempty" yaml:"retries,omitempty"`
RootSize string `json:"rootSize,omitempty" yaml:"root_size,omitempty"`
SecretKey string `json:"secretKey,omitempty" yaml:"secret_key,omitempty"`
SecurityGroup []string `json:"securityGroup,omitempty" yaml:"security_group,omitempty"`
SessionToken string `json:"sessionToken,omitempty" yaml:"session_token,omitempty"`
SpotPrice string `json:"spotPrice,omitempty" yaml:"spot_price,omitempty"`
SshKeypath string `json:"sshKeypath,omitempty" yaml:"ssh_keypath,omitempty"`
SshUser string `json:"sshUser,omitempty" yaml:"ssh_user,omitempty"`
SubnetId string `json:"subnetId,omitempty" yaml:"subnet_id,omitempty"`
Tags string `json:"tags,omitempty" yaml:"tags,omitempty"`
UseEbsOptimizedInstance bool `json:"useEbsOptimizedInstance,omitempty" yaml:"use_ebs_optimized_instance,omitempty"`
UsePrivateAddress bool `json:"usePrivateAddress,omitempty" yaml:"use_private_address,omitempty"`
VolumeType string `json:"volumeType,omitempty" yaml:"volume_type,omitempty"`
VpcId string `json:"vpcId,omitempty" yaml:"vpc_id,omitempty"`
Zone string `json:"zone,omitempty" yaml:"zone,omitempty"`
}
type Amazonec2ConfigCollection struct {
Collection
Data []Amazonec2Config `json:"data,omitempty"`
}
type Amazonec2ConfigClient struct {
rancherClient *RancherClient
}
type Amazonec2ConfigOperations interface {
List(opts *ListOpts) (*Amazonec2ConfigCollection, error)
Create(opts *Amazonec2Config) (*Amazonec2Config, error)
Update(existing *Amazonec2Config, updates interface{}) (*Amazonec2Config, error)
ById(id string) (*Amazonec2Config, error)
Delete(container *Amazonec2Config) error
}
func newAmazonec2ConfigClient(rancherClient *RancherClient) *Amazonec2ConfigClient {
return &Amazonec2ConfigClient{
rancherClient: rancherClient,
}
}
func (c *Amazonec2ConfigClient) Create(container *Amazonec2Config) (*Amazonec2Config, error) {
resp := &Amazonec2Config{}
err := c.rancherClient.doCreate(AMAZONEC2CONFIG_TYPE, container, resp)
return resp, err
}
func (c *Amazonec2ConfigClient) Update(existing *Amazonec2Config, updates interface{}) (*Amazonec2Config, error) {
resp := &Amazonec2Config{}
err := c.rancherClient.doUpdate(AMAZONEC2CONFIG_TYPE, &existing.Resource, updates, resp)
return resp, err
}
func (c *Amazonec2ConfigClient) List(opts *ListOpts) (*Amazonec2ConfigCollection, error) {
resp := &Amazonec2ConfigCollection{}
err := c.rancherClient.doList(AMAZONEC2CONFIG_TYPE, opts, resp)
return resp, err
}
func (c *Amazonec2ConfigClient) ById(id string) (*Amazonec2Config, error) {
resp := &Amazonec2Config{}
err := c.rancherClient.doById(AMAZONEC2CONFIG_TYPE, id, resp)
if apiError, ok := err.(*ApiError); ok {
if apiError.StatusCode == 404 {
return nil, nil
}
}
return resp, err
}
func (c *Amazonec2ConfigClient) Delete(container *Amazonec2Config) error {
return c.rancherClient.doResourceDelete(AMAZONEC2CONFIG_TYPE, &container.Resource)
}

161
vendor/github.com/rancher/go-rancher/client/generated_api_key.go generated vendored Normal file
View File

@ -0,0 +1,161 @@
package client
const (
API_KEY_TYPE = "apiKey"
)
type ApiKey struct {
Resource
AccountId string `json:"accountId,omitempty" yaml:"account_id,omitempty"`
Created string `json:"created,omitempty" yaml:"created,omitempty"`
Data map[string]interface{} `json:"data,omitempty" yaml:"data,omitempty"`
Description string `json:"description,omitempty" yaml:"description,omitempty"`
Kind string `json:"kind,omitempty" yaml:"kind,omitempty"`
Name string `json:"name,omitempty" yaml:"name,omitempty"`
PublicValue string `json:"publicValue,omitempty" yaml:"public_value,omitempty"`
RemoveTime string `json:"removeTime,omitempty" yaml:"remove_time,omitempty"`
Removed string `json:"removed,omitempty" yaml:"removed,omitempty"`
SecretValue string `json:"secretValue,omitempty" yaml:"secret_value,omitempty"`
State string `json:"state,omitempty" yaml:"state,omitempty"`
Transitioning string `json:"transitioning,omitempty" yaml:"transitioning,omitempty"`
TransitioningMessage string `json:"transitioningMessage,omitempty" yaml:"transitioning_message,omitempty"`
TransitioningProgress int64 `json:"transitioningProgress,omitempty" yaml:"transitioning_progress,omitempty"`
Uuid string `json:"uuid,omitempty" yaml:"uuid,omitempty"`
}
type ApiKeyCollection struct {
Collection
Data []ApiKey `json:"data,omitempty"`
}
type ApiKeyClient struct {
rancherClient *RancherClient
}
type ApiKeyOperations interface {
List(opts *ListOpts) (*ApiKeyCollection, error)
Create(opts *ApiKey) (*ApiKey, error)
Update(existing *ApiKey, updates interface{}) (*ApiKey, error)
ById(id string) (*ApiKey, error)
Delete(container *ApiKey) error
ActionActivate(*ApiKey) (*Credential, error)
ActionCreate(*ApiKey) (*Credential, error)
ActionDeactivate(*ApiKey) (*Credential, error)
ActionPurge(*ApiKey) (*Credential, error)
ActionRemove(*ApiKey) (*Credential, error)
ActionUpdate(*ApiKey) (*Credential, error)
}
func newApiKeyClient(rancherClient *RancherClient) *ApiKeyClient {
return &ApiKeyClient{
rancherClient: rancherClient,
}
}
func (c *ApiKeyClient) Create(container *ApiKey) (*ApiKey, error) {
resp := &ApiKey{}
err := c.rancherClient.doCreate(API_KEY_TYPE, container, resp)
return resp, err
}
func (c *ApiKeyClient) Update(existing *ApiKey, updates interface{}) (*ApiKey, error) {
resp := &ApiKey{}
err := c.rancherClient.doUpdate(API_KEY_TYPE, &existing.Resource, updates, resp)
return resp, err
}
func (c *ApiKeyClient) List(opts *ListOpts) (*ApiKeyCollection, error) {
resp := &ApiKeyCollection{}
err := c.rancherClient.doList(API_KEY_TYPE, opts, resp)
return resp, err
}
func (c *ApiKeyClient) ById(id string) (*ApiKey, error) {
resp := &ApiKey{}
err := c.rancherClient.doById(API_KEY_TYPE, id, resp)
if apiError, ok := err.(*ApiError); ok {
if apiError.StatusCode == 404 {
return nil, nil
}
}
return resp, err
}
func (c *ApiKeyClient) Delete(container *ApiKey) error {
return c.rancherClient.doResourceDelete(API_KEY_TYPE, &container.Resource)
}
func (c *ApiKeyClient) ActionActivate(resource *ApiKey) (*Credential, error) {
resp := &Credential{}
err := c.rancherClient.doAction(API_KEY_TYPE, "activate", &resource.Resource, nil, resp)
return resp, err
}
func (c *ApiKeyClient) ActionCreate(resource *ApiKey) (*Credential, error) {
resp := &Credential{}
err := c.rancherClient.doAction(API_KEY_TYPE, "create", &resource.Resource, nil, resp)
return resp, err
}
func (c *ApiKeyClient) ActionDeactivate(resource *ApiKey) (*Credential, error) {
resp := &Credential{}
err := c.rancherClient.doAction(API_KEY_TYPE, "deactivate", &resource.Resource, nil, resp)
return resp, err
}
func (c *ApiKeyClient) ActionPurge(resource *ApiKey) (*Credential, error) {
resp := &Credential{}
err := c.rancherClient.doAction(API_KEY_TYPE, "purge", &resource.Resource, nil, resp)
return resp, err
}
func (c *ApiKeyClient) ActionRemove(resource *ApiKey) (*Credential, error) {
resp := &Credential{}
err := c.rancherClient.doAction(API_KEY_TYPE, "remove", &resource.Resource, nil, resp)
return resp, err
}
func (c *ApiKeyClient) ActionUpdate(resource *ApiKey) (*Credential, error) {
resp := &Credential{}
err := c.rancherClient.doAction(API_KEY_TYPE, "update", &resource.Resource, nil, resp)
return resp, err
}

93
vendor/github.com/rancher/go-rancher/client/generated_audit_log.go generated vendored Normal file
View File

@ -0,0 +1,93 @@
package client
const (
AUDIT_LOG_TYPE = "auditLog"
)
type AuditLog struct {
Resource
AccountId string `json:"accountId,omitempty" yaml:"account_id,omitempty"`
AuthType string `json:"authType,omitempty" yaml:"auth_type,omitempty"`
AuthenticatedAsAccountId string `json:"authenticatedAsAccountId,omitempty" yaml:"authenticated_as_account_id,omitempty"`
AuthenticatedAsIdentityId string `json:"authenticatedAsIdentityId,omitempty" yaml:"authenticated_as_identity_id,omitempty"`
ClientIp string `json:"clientIp,omitempty" yaml:"client_ip,omitempty"`
Created string `json:"created,omitempty" yaml:"created,omitempty"`
Description string `json:"description,omitempty" yaml:"description,omitempty"`
EventType string `json:"eventType,omitempty" yaml:"event_type,omitempty"`
Kind string `json:"kind,omitempty" yaml:"kind,omitempty"`
RequestObject string `json:"requestObject,omitempty" yaml:"request_object,omitempty"`
ResourceId int64 `json:"resourceId,omitempty" yaml:"resource_id,omitempty"`
ResourceType string `json:"resourceType,omitempty" yaml:"resource_type,omitempty"`
ResponseCode string `json:"responseCode,omitempty" yaml:"response_code,omitempty"`
ResponseObject string `json:"responseObject,omitempty" yaml:"response_object,omitempty"`
}
type AuditLogCollection struct {
Collection
Data []AuditLog `json:"data,omitempty"`
}
type AuditLogClient struct {
rancherClient *RancherClient
}
type AuditLogOperations interface {
List(opts *ListOpts) (*AuditLogCollection, error)
Create(opts *AuditLog) (*AuditLog, error)
Update(existing *AuditLog, updates interface{}) (*AuditLog, error)
ById(id string) (*AuditLog, error)
Delete(container *AuditLog) error
}
func newAuditLogClient(rancherClient *RancherClient) *AuditLogClient {
return &AuditLogClient{
rancherClient: rancherClient,
}
}
func (c *AuditLogClient) Create(container *AuditLog) (*AuditLog, error) {
resp := &AuditLog{}
err := c.rancherClient.doCreate(AUDIT_LOG_TYPE, container, resp)
return resp, err
}
func (c *AuditLogClient) Update(existing *AuditLog, updates interface{}) (*AuditLog, error) {
resp := &AuditLog{}
err := c.rancherClient.doUpdate(AUDIT_LOG_TYPE, &existing.Resource, updates, resp)
return resp, err
}
func (c *AuditLogClient) List(opts *ListOpts) (*AuditLogCollection, error) {
resp := &AuditLogCollection{}
err := c.rancherClient.doList(AUDIT_LOG_TYPE, opts, resp)
return resp, err
}
func (c *AuditLogClient) ById(id string) (*AuditLog, error) {
resp := &AuditLog{}
err := c.rancherClient.doById(AUDIT_LOG_TYPE, id, resp)
if apiError, ok := err.(*ApiError); ok {
if apiError.StatusCode == 404 {
return nil, nil
}
}
return resp, err
}
func (c *AuditLogClient) Delete(container *AuditLog) error {
return c.rancherClient.doResourceDelete(AUDIT_LOG_TYPE, &container.Resource)
}

107
vendor/github.com/rancher/go-rancher/client/generated_azure_config.go generated vendored Normal file
View File

@ -0,0 +1,107 @@
package client
const (
AZURE_CONFIG_TYPE = "azureConfig"
)
type AzureConfig struct {
Resource
AvailabilitySet string `json:"availabilitySet,omitempty" yaml:"availability_set,omitempty"`
ClientId string `json:"clientId,omitempty" yaml:"client_id,omitempty"`
ClientSecret string `json:"clientSecret,omitempty" yaml:"client_secret,omitempty"`
CustomData string `json:"customData,omitempty" yaml:"custom_data,omitempty"`
DockerPort string `json:"dockerPort,omitempty" yaml:"docker_port,omitempty"`
Environment string `json:"environment,omitempty" yaml:"environment,omitempty"`
Image string `json:"image,omitempty" yaml:"image,omitempty"`
Location string `json:"location,omitempty" yaml:"location,omitempty"`
NoPublicIp bool `json:"noPublicIp,omitempty" yaml:"no_public_ip,omitempty"`
OpenPort []string `json:"openPort,omitempty" yaml:"open_port,omitempty"`
PrivateIpAddress string `json:"privateIpAddress,omitempty" yaml:"private_ip_address,omitempty"`
ResourceGroup string `json:"resourceGroup,omitempty" yaml:"resource_group,omitempty"`
Size string `json:"size,omitempty" yaml:"size,omitempty"`
SshUser string `json:"sshUser,omitempty" yaml:"ssh_user,omitempty"`
StaticPublicIp bool `json:"staticPublicIp,omitempty" yaml:"static_public_ip,omitempty"`
StorageType string `json:"storageType,omitempty" yaml:"storage_type,omitempty"`
Subnet string `json:"subnet,omitempty" yaml:"subnet,omitempty"`
SubnetPrefix string `json:"subnetPrefix,omitempty" yaml:"subnet_prefix,omitempty"`
SubscriptionId string `json:"subscriptionId,omitempty" yaml:"subscription_id,omitempty"`
UsePrivateIp bool `json:"usePrivateIp,omitempty" yaml:"use_private_ip,omitempty"`
Vnet string `json:"vnet,omitempty" yaml:"vnet,omitempty"`
}
type AzureConfigCollection struct {
Collection
Data []AzureConfig `json:"data,omitempty"`
}
type AzureConfigClient struct {
rancherClient *RancherClient
}
type AzureConfigOperations interface {
List(opts *ListOpts) (*AzureConfigCollection, error)
Create(opts *AzureConfig) (*AzureConfig, error)
Update(existing *AzureConfig, updates interface{}) (*AzureConfig, error)
ById(id string) (*AzureConfig, error)
Delete(container *AzureConfig) error
}
func newAzureConfigClient(rancherClient *RancherClient) *AzureConfigClient {
return &AzureConfigClient{
rancherClient: rancherClient,
}
}
func (c *AzureConfigClient) Create(container *AzureConfig) (*AzureConfig, error) {
resp := &AzureConfig{}
err := c.rancherClient.doCreate(AZURE_CONFIG_TYPE, container, resp)
return resp, err
}
func (c *AzureConfigClient) Update(existing *AzureConfig, updates interface{}) (*AzureConfig, error) {
resp := &AzureConfig{}
err := c.rancherClient.doUpdate(AZURE_CONFIG_TYPE, &existing.Resource, updates, resp)
return resp, err
}
func (c *AzureConfigClient) List(opts *ListOpts) (*AzureConfigCollection, error) {
resp := &AzureConfigCollection{}
err := c.rancherClient.doList(AZURE_CONFIG_TYPE, opts, resp)
return resp, err
}
func (c *AzureConfigClient) ById(id string) (*AzureConfig, error) {
resp := &AzureConfig{}
err := c.rancherClient.doById(AZURE_CONFIG_TYPE, id, resp)
if apiError, ok := err.(*ApiError); ok {
if apiError.StatusCode == 404 {
return nil, nil
}
}
return resp, err
}
func (c *AzureConfigClient) Delete(container *AzureConfig) error {
return c.rancherClient.doResourceDelete(AZURE_CONFIG_TYPE, &container.Resource)
}

81
vendor/github.com/rancher/go-rancher/client/generated_azureadconfig.go generated vendored Normal file
View File

@ -0,0 +1,81 @@
package client
const (
AZUREADCONFIG_TYPE = "azureadconfig"
)
type Azureadconfig struct {
Resource
AccessMode string `json:"accessMode,omitempty" yaml:"access_mode,omitempty"`
AdminAccountPassword string `json:"adminAccountPassword,omitempty" yaml:"admin_account_password,omitempty"`
AdminAccountUsername string `json:"adminAccountUsername,omitempty" yaml:"admin_account_username,omitempty"`
ClientId string `json:"clientId,omitempty" yaml:"client_id,omitempty"`
Domain string `json:"domain,omitempty" yaml:"domain,omitempty"`
Enabled bool `json:"enabled,omitempty" yaml:"enabled,omitempty"`
Name string `json:"name,omitempty" yaml:"name,omitempty"`
TenantId string `json:"tenantId,omitempty" yaml:"tenant_id,omitempty"`
}
type AzureadconfigCollection struct {
Collection
Data []Azureadconfig `json:"data,omitempty"`
}
type AzureadconfigClient struct {
rancherClient *RancherClient
}
type AzureadconfigOperations interface {
List(opts *ListOpts) (*AzureadconfigCollection, error)
Create(opts *Azureadconfig) (*Azureadconfig, error)
Update(existing *Azureadconfig, updates interface{}) (*Azureadconfig, error)
ById(id string) (*Azureadconfig, error)
Delete(container *Azureadconfig) error
}
func newAzureadconfigClient(rancherClient *RancherClient) *AzureadconfigClient {
return &AzureadconfigClient{
rancherClient: rancherClient,
}
}
func (c *AzureadconfigClient) Create(container *Azureadconfig) (*Azureadconfig, error) {
resp := &Azureadconfig{}
err := c.rancherClient.doCreate(AZUREADCONFIG_TYPE, container, resp)
return resp, err
}
func (c *AzureadconfigClient) Update(existing *Azureadconfig, updates interface{}) (*Azureadconfig, error) {
resp := &Azureadconfig{}
err := c.rancherClient.doUpdate(AZUREADCONFIG_TYPE, &existing.Resource, updates, resp)
return resp, err
}
func (c *AzureadconfigClient) List(opts *ListOpts) (*AzureadconfigCollection, error) {
resp := &AzureadconfigCollection{}
err := c.rancherClient.doList(AZUREADCONFIG_TYPE, opts, resp)
return resp, err
}
func (c *AzureadconfigClient) ById(id string) (*Azureadconfig, error) {
resp := &Azureadconfig{}
err := c.rancherClient.doById(AZUREADCONFIG_TYPE, id, resp)
if apiError, ok := err.(*ApiError); ok {
if apiError.StatusCode == 404 {
return nil, nil
}
}
return resp, err
}
func (c *AzureadconfigClient) Delete(container *Azureadconfig) error {
return c.rancherClient.doResourceDelete(AZUREADCONFIG_TYPE, &container.Resource)
}

121
vendor/github.com/rancher/go-rancher/client/generated_backup.go generated vendored Normal file
View File

@ -0,0 +1,121 @@
package client
const (
BACKUP_TYPE = "backup"
)
type Backup struct {
Resource
AccountId string `json:"accountId,omitempty" yaml:"account_id,omitempty"`
BackupTargetId string `json:"backupTargetId,omitempty" yaml:"backup_target_id,omitempty"`
Created string `json:"created,omitempty" yaml:"created,omitempty"`
Data map[string]interface{} `json:"data,omitempty" yaml:"data,omitempty"`
Description string `json:"description,omitempty" yaml:"description,omitempty"`
Kind string `json:"kind,omitempty" yaml:"kind,omitempty"`
Name string `json:"name,omitempty" yaml:"name,omitempty"`
RemoveTime string `json:"removeTime,omitempty" yaml:"remove_time,omitempty"`
Removed string `json:"removed,omitempty" yaml:"removed,omitempty"`
SnapshotId string `json:"snapshotId,omitempty" yaml:"snapshot_id,omitempty"`
State string `json:"state,omitempty" yaml:"state,omitempty"`
Transitioning string `json:"transitioning,omitempty" yaml:"transitioning,omitempty"`
TransitioningMessage string `json:"transitioningMessage,omitempty" yaml:"transitioning_message,omitempty"`
TransitioningProgress int64 `json:"transitioningProgress,omitempty" yaml:"transitioning_progress,omitempty"`
Uri string `json:"uri,omitempty" yaml:"uri,omitempty"`
Uuid string `json:"uuid,omitempty" yaml:"uuid,omitempty"`
VolumeId string `json:"volumeId,omitempty" yaml:"volume_id,omitempty"`
}
type BackupCollection struct {
Collection
Data []Backup `json:"data,omitempty"`
}
type BackupClient struct {
rancherClient *RancherClient
}
type BackupOperations interface {
List(opts *ListOpts) (*BackupCollection, error)
Create(opts *Backup) (*Backup, error)
Update(existing *Backup, updates interface{}) (*Backup, error)
ById(id string) (*Backup, error)
Delete(container *Backup) error
ActionCreate(*Backup) (*Backup, error)
ActionRemove(*Backup) (*Backup, error)
}
func newBackupClient(rancherClient *RancherClient) *BackupClient {
return &BackupClient{
rancherClient: rancherClient,
}
}
func (c *BackupClient) Create(container *Backup) (*Backup, error) {
resp := &Backup{}
err := c.rancherClient.doCreate(BACKUP_TYPE, container, resp)
return resp, err
}
func (c *BackupClient) Update(existing *Backup, updates interface{}) (*Backup, error) {
resp := &Backup{}
err := c.rancherClient.doUpdate(BACKUP_TYPE, &existing.Resource, updates, resp)
return resp, err
}
func (c *BackupClient) List(opts *ListOpts) (*BackupCollection, error) {
resp := &BackupCollection{}
err := c.rancherClient.doList(BACKUP_TYPE, opts, resp)
return resp, err
}
func (c *BackupClient) ById(id string) (*Backup, error) {
resp := &Backup{}
err := c.rancherClient.doById(BACKUP_TYPE, id, resp)
if apiError, ok := err.(*ApiError); ok {
if apiError.StatusCode == 404 {
return nil, nil
}
}
return resp, err
}
func (c *BackupClient) Delete(container *Backup) error {
return c.rancherClient.doResourceDelete(BACKUP_TYPE, &container.Resource)
}
func (c *BackupClient) ActionCreate(resource *Backup) (*Backup, error) {
resp := &Backup{}
err := c.rancherClient.doAction(BACKUP_TYPE, "create", &resource.Resource, nil, resp)
return resp, err
}
func (c *BackupClient) ActionRemove(resource *Backup) (*Backup, error) {
resp := &Backup{}
err := c.rancherClient.doAction(BACKUP_TYPE, "remove", &resource.Resource, nil, resp)
return resp, err
}

115
vendor/github.com/rancher/go-rancher/client/generated_backup_target.go generated vendored Normal file
View File

@ -0,0 +1,115 @@
package client
const (
BACKUP_TARGET_TYPE = "backupTarget"
)
type BackupTarget struct {
Resource
AccountId string `json:"accountId,omitempty" yaml:"account_id,omitempty"`
Created string `json:"created,omitempty" yaml:"created,omitempty"`
Data map[string]interface{} `json:"data,omitempty" yaml:"data,omitempty"`
Description string `json:"description,omitempty" yaml:"description,omitempty"`
Kind string `json:"kind,omitempty" yaml:"kind,omitempty"`
Name string `json:"name,omitempty" yaml:"name,omitempty"`
NfsConfig *NfsConfig `json:"nfsConfig,omitempty" yaml:"nfs_config,omitempty"`
RemoveTime string `json:"removeTime,omitempty" yaml:"remove_time,omitempty"`
Removed string `json:"removed,omitempty" yaml:"removed,omitempty"`
State string `json:"state,omitempty" yaml:"state,omitempty"`
Transitioning string `json:"transitioning,omitempty" yaml:"transitioning,omitempty"`
TransitioningMessage string `json:"transitioningMessage,omitempty" yaml:"transitioning_message,omitempty"`
TransitioningProgress int64 `json:"transitioningProgress,omitempty" yaml:"transitioning_progress,omitempty"`
Uuid string `json:"uuid,omitempty" yaml:"uuid,omitempty"`
}
type BackupTargetCollection struct {
Collection
Data []BackupTarget `json:"data,omitempty"`
}
type BackupTargetClient struct {
rancherClient *RancherClient
}
type BackupTargetOperations interface {
List(opts *ListOpts) (*BackupTargetCollection, error)
Create(opts *BackupTarget) (*BackupTarget, error)
Update(existing *BackupTarget, updates interface{}) (*BackupTarget, error)
ById(id string) (*BackupTarget, error)
Delete(container *BackupTarget) error
ActionCreate(*BackupTarget) (*BackupTarget, error)
ActionRemove(*BackupTarget) (*BackupTarget, error)
}
func newBackupTargetClient(rancherClient *RancherClient) *BackupTargetClient {
return &BackupTargetClient{
rancherClient: rancherClient,
}
}
func (c *BackupTargetClient) Create(container *BackupTarget) (*BackupTarget, error) {
resp := &BackupTarget{}
err := c.rancherClient.doCreate(BACKUP_TARGET_TYPE, container, resp)
return resp, err
}
func (c *BackupTargetClient) Update(existing *BackupTarget, updates interface{}) (*BackupTarget, error) {
resp := &BackupTarget{}
err := c.rancherClient.doUpdate(BACKUP_TARGET_TYPE, &existing.Resource, updates, resp)
return resp, err
}
func (c *BackupTargetClient) List(opts *ListOpts) (*BackupTargetCollection, error) {
resp := &BackupTargetCollection{}
err := c.rancherClient.doList(BACKUP_TARGET_TYPE, opts, resp)
return resp, err
}
func (c *BackupTargetClient) ById(id string) (*BackupTarget, error) {
resp := &BackupTarget{}
err := c.rancherClient.doById(BACKUP_TARGET_TYPE, id, resp)
if apiError, ok := err.(*ApiError); ok {
if apiError.StatusCode == 404 {
return nil, nil
}
}
return resp, err
}
func (c *BackupTargetClient) Delete(container *BackupTarget) error {
return c.rancherClient.doResourceDelete(BACKUP_TARGET_TYPE, &container.Resource)
}
func (c *BackupTargetClient) ActionCreate(resource *BackupTarget) (*BackupTarget, error) {
resp := &BackupTarget{}
err := c.rancherClient.doAction(BACKUP_TARGET_TYPE, "create", &resource.Resource, nil, resp)
return resp, err
}
func (c *BackupTargetClient) ActionRemove(resource *BackupTarget) (*BackupTarget, error) {
resp := &BackupTarget{}
err := c.rancherClient.doAction(BACKUP_TARGET_TYPE, "remove", &resource.Resource, nil, resp)
return resp, err
}

65
vendor/github.com/rancher/go-rancher/client/generated_base_machine_config.go generated vendored Normal file
View File

@ -0,0 +1,65 @@
package client
const (
BASE_MACHINE_CONFIG_TYPE = "baseMachineConfig"
)
type BaseMachineConfig struct {
Resource
}
type BaseMachineConfigCollection struct {
Collection
Data []BaseMachineConfig `json:"data,omitempty"`
}
type BaseMachineConfigClient struct {
rancherClient *RancherClient
}
type BaseMachineConfigOperations interface {
List(opts *ListOpts) (*BaseMachineConfigCollection, error)
Create(opts *BaseMachineConfig) (*BaseMachineConfig, error)
Update(existing *BaseMachineConfig, updates interface{}) (*BaseMachineConfig, error)
ById(id string) (*BaseMachineConfig, error)
Delete(container *BaseMachineConfig) error
}
func newBaseMachineConfigClient(rancherClient *RancherClient) *BaseMachineConfigClient {
return &BaseMachineConfigClient{
rancherClient: rancherClient,
}
}
func (c *BaseMachineConfigClient) Create(container *BaseMachineConfig) (*BaseMachineConfig, error) {
resp := &BaseMachineConfig{}
err := c.rancherClient.doCreate(BASE_MACHINE_CONFIG_TYPE, container, resp)
return resp, err
}
func (c *BaseMachineConfigClient) Update(existing *BaseMachineConfig, updates interface{}) (*BaseMachineConfig, error) {
resp := &BaseMachineConfig{}
err := c.rancherClient.doUpdate(BASE_MACHINE_CONFIG_TYPE, &existing.Resource, updates, resp)
return resp, err
}
func (c *BaseMachineConfigClient) List(opts *ListOpts) (*BaseMachineConfigCollection, error) {
resp := &BaseMachineConfigCollection{}
err := c.rancherClient.doList(BASE_MACHINE_CONFIG_TYPE, opts, resp)
return resp, err
}
func (c *BaseMachineConfigClient) ById(id string) (*BaseMachineConfig, error) {
resp := &BaseMachineConfig{}
err := c.rancherClient.doById(BASE_MACHINE_CONFIG_TYPE, id, resp)
if apiError, ok := err.(*ApiError); ok {
if apiError.StatusCode == 404 {
return nil, nil
}
}
return resp, err
}
func (c *BaseMachineConfigClient) Delete(container *BaseMachineConfig) error {
return c.rancherClient.doResourceDelete(BASE_MACHINE_CONFIG_TYPE, &container.Resource)
}

75
vendor/github.com/rancher/go-rancher/client/generated_blkio_device_option.go generated vendored Normal file
View File

@ -0,0 +1,75 @@
package client
const (
BLKIO_DEVICE_OPTION_TYPE = "blkioDeviceOption"
)
type BlkioDeviceOption struct {
Resource
ReadBps int64 `json:"readBps,omitempty" yaml:"read_bps,omitempty"`
ReadIops int64 `json:"readIops,omitempty" yaml:"read_iops,omitempty"`
Weight int64 `json:"weight,omitempty" yaml:"weight,omitempty"`
WriteBps int64 `json:"writeBps,omitempty" yaml:"write_bps,omitempty"`
WriteIops int64 `json:"writeIops,omitempty" yaml:"write_iops,omitempty"`
}
type BlkioDeviceOptionCollection struct {
Collection
Data []BlkioDeviceOption `json:"data,omitempty"`
}
type BlkioDeviceOptionClient struct {
rancherClient *RancherClient
}
type BlkioDeviceOptionOperations interface {
List(opts *ListOpts) (*BlkioDeviceOptionCollection, error)
Create(opts *BlkioDeviceOption) (*BlkioDeviceOption, error)
Update(existing *BlkioDeviceOption, updates interface{}) (*BlkioDeviceOption, error)
ById(id string) (*BlkioDeviceOption, error)
Delete(container *BlkioDeviceOption) error
}
func newBlkioDeviceOptionClient(rancherClient *RancherClient) *BlkioDeviceOptionClient {
return &BlkioDeviceOptionClient{
rancherClient: rancherClient,
}
}
func (c *BlkioDeviceOptionClient) Create(container *BlkioDeviceOption) (*BlkioDeviceOption, error) {
resp := &BlkioDeviceOption{}
err := c.rancherClient.doCreate(BLKIO_DEVICE_OPTION_TYPE, container, resp)
return resp, err
}
func (c *BlkioDeviceOptionClient) Update(existing *BlkioDeviceOption, updates interface{}) (*BlkioDeviceOption, error) {
resp := &BlkioDeviceOption{}
err := c.rancherClient.doUpdate(BLKIO_DEVICE_OPTION_TYPE, &existing.Resource, updates, resp)
return resp, err
}
func (c *BlkioDeviceOptionClient) List(opts *ListOpts) (*BlkioDeviceOptionCollection, error) {
resp := &BlkioDeviceOptionCollection{}
err := c.rancherClient.doList(BLKIO_DEVICE_OPTION_TYPE, opts, resp)
return resp, err
}
func (c *BlkioDeviceOptionClient) ById(id string) (*BlkioDeviceOption, error) {
resp := &BlkioDeviceOption{}
err := c.rancherClient.doById(BLKIO_DEVICE_OPTION_TYPE, id, resp)
if apiError, ok := err.(*ApiError); ok {
if apiError.StatusCode == 404 {
return nil, nil
}
}
return resp, err
}
func (c *BlkioDeviceOptionClient) Delete(container *BlkioDeviceOption) error {
return c.rancherClient.doResourceDelete(BLKIO_DEVICE_OPTION_TYPE, &container.Resource)
}

150
vendor/github.com/rancher/go-rancher/client/generated_certificate.go generated vendored Normal file
View File

@ -0,0 +1,150 @@
package client
const (
CERTIFICATE_TYPE = "certificate"
)
type Certificate struct {
Resource
AccountId string `json:"accountId,omitempty" yaml:"account_id,omitempty"`
Algorithm string `json:"algorithm,omitempty" yaml:"algorithm,omitempty"`
CN string `json:"cN,omitempty" yaml:"cn,omitempty"`
Cert string `json:"cert,omitempty" yaml:"cert,omitempty"`
CertChain string `json:"certChain,omitempty" yaml:"cert_chain,omitempty"`
CertFingerprint string `json:"certFingerprint,omitempty" yaml:"cert_fingerprint,omitempty"`
Created string `json:"created,omitempty" yaml:"created,omitempty"`
Data map[string]interface{} `json:"data,omitempty" yaml:"data,omitempty"`
Description string `json:"description,omitempty" yaml:"description,omitempty"`
ExpiresAt string `json:"expiresAt,omitempty" yaml:"expires_at,omitempty"`
IssuedAt string `json:"issuedAt,omitempty" yaml:"issued_at,omitempty"`
Issuer string `json:"issuer,omitempty" yaml:"issuer,omitempty"`
Key string `json:"key,omitempty" yaml:"key,omitempty"`
KeySize int64 `json:"keySize,omitempty" yaml:"key_size,omitempty"`
Kind string `json:"kind,omitempty" yaml:"kind,omitempty"`
Name string `json:"name,omitempty" yaml:"name,omitempty"`
RemoveTime string `json:"removeTime,omitempty" yaml:"remove_time,omitempty"`
Removed string `json:"removed,omitempty" yaml:"removed,omitempty"`
SerialNumber string `json:"serialNumber,omitempty" yaml:"serial_number,omitempty"`
State string `json:"state,omitempty" yaml:"state,omitempty"`
SubjectAlternativeNames []string `json:"subjectAlternativeNames,omitempty" yaml:"subject_alternative_names,omitempty"`
Transitioning string `json:"transitioning,omitempty" yaml:"transitioning,omitempty"`
TransitioningMessage string `json:"transitioningMessage,omitempty" yaml:"transitioning_message,omitempty"`
TransitioningProgress int64 `json:"transitioningProgress,omitempty" yaml:"transitioning_progress,omitempty"`
Uuid string `json:"uuid,omitempty" yaml:"uuid,omitempty"`
Version string `json:"version,omitempty" yaml:"version,omitempty"`
}
type CertificateCollection struct {
Collection
Data []Certificate `json:"data,omitempty"`
}
type CertificateClient struct {
rancherClient *RancherClient
}
type CertificateOperations interface {
List(opts *ListOpts) (*CertificateCollection, error)
Create(opts *Certificate) (*Certificate, error)
Update(existing *Certificate, updates interface{}) (*Certificate, error)
ById(id string) (*Certificate, error)
Delete(container *Certificate) error
ActionCreate(*Certificate) (*Certificate, error)
ActionRemove(*Certificate) (*Certificate, error)
ActionUpdate(*Certificate) (*Certificate, error)
}
func newCertificateClient(rancherClient *RancherClient) *CertificateClient {
return &CertificateClient{
rancherClient: rancherClient,
}
}
func (c *CertificateClient) Create(container *Certificate) (*Certificate, error) {
resp := &Certificate{}
err := c.rancherClient.doCreate(CERTIFICATE_TYPE, container, resp)
return resp, err
}
func (c *CertificateClient) Update(existing *Certificate, updates interface{}) (*Certificate, error) {
resp := &Certificate{}
err := c.rancherClient.doUpdate(CERTIFICATE_TYPE, &existing.Resource, updates, resp)
return resp, err
}
func (c *CertificateClient) List(opts *ListOpts) (*CertificateCollection, error) {
resp := &CertificateCollection{}
err := c.rancherClient.doList(CERTIFICATE_TYPE, opts, resp)
return resp, err
}
func (c *CertificateClient) ById(id string) (*Certificate, error) {
resp := &Certificate{}
err := c.rancherClient.doById(CERTIFICATE_TYPE, id, resp)
if apiError, ok := err.(*ApiError); ok {
if apiError.StatusCode == 404 {
return nil, nil
}
}
return resp, err
}
func (c *CertificateClient) Delete(container *Certificate) error {
return c.rancherClient.doResourceDelete(CERTIFICATE_TYPE, &container.Resource)
}
func (c *CertificateClient) ActionCreate(resource *Certificate) (*Certificate, error) {
resp := &Certificate{}
err := c.rancherClient.doAction(CERTIFICATE_TYPE, "create", &resource.Resource, nil, resp)
return resp, err
}
func (c *CertificateClient) ActionRemove(resource *Certificate) (*Certificate, error) {
resp := &Certificate{}
err := c.rancherClient.doAction(CERTIFICATE_TYPE, "remove", &resource.Resource, nil, resp)
return resp, err
}
func (c *CertificateClient) ActionUpdate(resource *Certificate) (*Certificate, error) {
resp := &Certificate{}
err := c.rancherClient.doAction(CERTIFICATE_TYPE, "update", &resource.Resource, nil, resp)
return resp, err
}

69
vendor/github.com/rancher/go-rancher/client/generated_change_secret_input.go generated vendored Normal file
View File

@ -0,0 +1,69 @@
package client
const (
CHANGE_SECRET_INPUT_TYPE = "changeSecretInput"
)
type ChangeSecretInput struct {
Resource
NewSecret string `json:"newSecret,omitempty" yaml:"new_secret,omitempty"`
OldSecret string `json:"oldSecret,omitempty" yaml:"old_secret,omitempty"`
}
type ChangeSecretInputCollection struct {
Collection
Data []ChangeSecretInput `json:"data,omitempty"`
}
type ChangeSecretInputClient struct {
rancherClient *RancherClient
}
type ChangeSecretInputOperations interface {
List(opts *ListOpts) (*ChangeSecretInputCollection, error)
Create(opts *ChangeSecretInput) (*ChangeSecretInput, error)
Update(existing *ChangeSecretInput, updates interface{}) (*ChangeSecretInput, error)
ById(id string) (*ChangeSecretInput, error)
Delete(container *ChangeSecretInput) error
}
func newChangeSecretInputClient(rancherClient *RancherClient) *ChangeSecretInputClient {
return &ChangeSecretInputClient{
rancherClient: rancherClient,
}
}
func (c *ChangeSecretInputClient) Create(container *ChangeSecretInput) (*ChangeSecretInput, error) {
resp := &ChangeSecretInput{}
err := c.rancherClient.doCreate(CHANGE_SECRET_INPUT_TYPE, container, resp)
return resp, err
}
func (c *ChangeSecretInputClient) Update(existing *ChangeSecretInput, updates interface{}) (*ChangeSecretInput, error) {
resp := &ChangeSecretInput{}
err := c.rancherClient.doUpdate(CHANGE_SECRET_INPUT_TYPE, &existing.Resource, updates, resp)
return resp, err
}
func (c *ChangeSecretInputClient) List(opts *ListOpts) (*ChangeSecretInputCollection, error) {
resp := &ChangeSecretInputCollection{}
err := c.rancherClient.doList(CHANGE_SECRET_INPUT_TYPE, opts, resp)
return resp, err
}
func (c *ChangeSecretInputClient) ById(id string) (*ChangeSecretInput, error) {
resp := &ChangeSecretInput{}
err := c.rancherClient.doById(CHANGE_SECRET_INPUT_TYPE, id, resp)
if apiError, ok := err.(*ApiError); ok {
if apiError.StatusCode == 404 {
return nil, nil
}
}
return resp, err
}
func (c *ChangeSecretInputClient) Delete(container *ChangeSecretInput) error {
return c.rancherClient.doResourceDelete(CHANGE_SECRET_INPUT_TYPE, &container.Resource)
}

313
vendor/github.com/rancher/go-rancher/client/generated_client.go generated vendored Normal file
View File

@ -0,0 +1,313 @@
package client
type RancherClient struct {
RancherBaseClient
Account AccountOperations
ActiveSetting ActiveSettingOperations
AddOutputsInput AddOutputsInputOperations
AddRemoveLoadBalancerServiceLinkInput AddRemoveLoadBalancerServiceLinkInputOperations
AddRemoveServiceLinkInput AddRemoveServiceLinkInputOperations
Agent AgentOperations
Amazonec2Config Amazonec2ConfigOperations
ApiKey ApiKeyOperations
AuditLog AuditLogOperations
AzureConfig AzureConfigOperations
Azureadconfig AzureadconfigOperations
Backup BackupOperations
BackupTarget BackupTargetOperations
BaseMachineConfig BaseMachineConfigOperations
BlkioDeviceOption BlkioDeviceOptionOperations
Certificate CertificateOperations
ChangeSecretInput ChangeSecretInputOperations
ComposeConfig ComposeConfigOperations
ComposeConfigInput ComposeConfigInputOperations
ComposeProject ComposeProjectOperations
ComposeService ComposeServiceOperations
ConfigItem ConfigItemOperations
ConfigItemStatus ConfigItemStatusOperations
Container ContainerOperations
ContainerEvent ContainerEventOperations
ContainerExec ContainerExecOperations
ContainerLogs ContainerLogsOperations
ContainerProxy ContainerProxyOperations
Credential CredentialOperations
Databasechangelog DatabasechangelogOperations
Databasechangeloglock DatabasechangeloglockOperations
DigitaloceanConfig DigitaloceanConfigOperations
DnsService DnsServiceOperations
DockerBuild DockerBuildOperations
DynamicSchema DynamicSchemaOperations
Environment EnvironmentOperations
EnvironmentUpgrade EnvironmentUpgradeOperations
ExtensionImplementation ExtensionImplementationOperations
ExtensionPoint ExtensionPointOperations
ExternalDnsEvent ExternalDnsEventOperations
ExternalEvent ExternalEventOperations
ExternalHandler ExternalHandlerOperations
ExternalHandlerExternalHandlerProcessMap ExternalHandlerExternalHandlerProcessMapOperations
ExternalHandlerProcess ExternalHandlerProcessOperations
ExternalHandlerProcessConfig ExternalHandlerProcessConfigOperations
ExternalHostEvent ExternalHostEventOperations
ExternalService ExternalServiceOperations
ExternalServiceEvent ExternalServiceEventOperations
ExternalStoragePoolEvent ExternalStoragePoolEventOperations
ExternalVolumeEvent ExternalVolumeEventOperations
FieldDocumentation FieldDocumentationOperations
Githubconfig GithubconfigOperations
HaConfig HaConfigOperations
HaConfigInput HaConfigInputOperations
HaproxyConfig HaproxyConfigOperations
HealthcheckInstanceHostMap HealthcheckInstanceHostMapOperations
Host HostOperations
HostAccess HostAccessOperations
HostApiProxyToken HostApiProxyTokenOperations
Identity IdentityOperations
Image ImageOperations
InServiceUpgradeStrategy InServiceUpgradeStrategyOperations
Instance InstanceOperations
InstanceConsole InstanceConsoleOperations
InstanceConsoleInput InstanceConsoleInputOperations
InstanceHealthCheck InstanceHealthCheckOperations
InstanceLink InstanceLinkOperations
InstanceStop InstanceStopOperations
IpAddress IpAddressOperations
IpAddressAssociateInput IpAddressAssociateInputOperations
KubernetesService KubernetesServiceOperations
KubernetesStack KubernetesStackOperations
KubernetesStackUpgrade KubernetesStackUpgradeOperations
Label LabelOperations
LaunchConfig LaunchConfigOperations
Ldapconfig LdapconfigOperations
LoadBalancerAppCookieStickinessPolicy LoadBalancerAppCookieStickinessPolicyOperations
LoadBalancerConfig LoadBalancerConfigOperations
LoadBalancerCookieStickinessPolicy LoadBalancerCookieStickinessPolicyOperations
LoadBalancerService LoadBalancerServiceOperations
LoadBalancerServiceLink LoadBalancerServiceLinkOperations
LocalAuthConfig LocalAuthConfigOperations
LogConfig LogConfigOperations
Machine MachineOperations
MachineDriver MachineDriverOperations
Mount MountOperations
Network NetworkOperations
NfsConfig NfsConfigOperations
Openldapconfig OpenldapconfigOperations
PacketConfig PacketConfigOperations
Password PasswordOperations
PhysicalHost PhysicalHostOperations
Port PortOperations
ProcessDefinition ProcessDefinitionOperations
ProcessExecution ProcessExecutionOperations
ProcessInstance ProcessInstanceOperations
Project ProjectOperations
ProjectMember ProjectMemberOperations
PublicEndpoint PublicEndpointOperations
Publish PublishOperations
PullTask PullTaskOperations
RecreateOnQuorumStrategyConfig RecreateOnQuorumStrategyConfigOperations
Register RegisterOperations
RegistrationToken RegistrationTokenOperations
Registry RegistryOperations
RegistryCredential RegistryCredentialOperations
ResourceDefinition ResourceDefinitionOperations
RestartPolicy RestartPolicyOperations
RestoreFromBackupInput RestoreFromBackupInputOperations
RevertToSnapshotInput RevertToSnapshotInputOperations
RollingRestartStrategy RollingRestartStrategyOperations
ScalePolicy ScalePolicyOperations
SecondaryLaunchConfig SecondaryLaunchConfigOperations
Service ServiceOperations
ServiceConsumeMap ServiceConsumeMapOperations
ServiceEvent ServiceEventOperations
ServiceExposeMap ServiceExposeMapOperations
ServiceLink ServiceLinkOperations
ServiceProxy ServiceProxyOperations
ServiceRestart ServiceRestartOperations
ServiceUpgrade ServiceUpgradeOperations
ServiceUpgradeStrategy ServiceUpgradeStrategyOperations
ServicesPortRange ServicesPortRangeOperations
SetLabelsInput SetLabelsInputOperations
SetLoadBalancerServiceLinksInput SetLoadBalancerServiceLinksInputOperations
SetProjectMembersInput SetProjectMembersInputOperations
SetServiceLinksInput SetServiceLinksInputOperations
Setting SettingOperations
Snapshot SnapshotOperations
SnapshotBackupInput SnapshotBackupInputOperations
StateTransition StateTransitionOperations
StatsAccess StatsAccessOperations
StoragePool StoragePoolOperations
Subscribe SubscribeOperations
Task TaskOperations
TaskInstance TaskInstanceOperations
ToServiceUpgradeStrategy ToServiceUpgradeStrategyOperations
TypeDocumentation TypeDocumentationOperations
VirtualMachine VirtualMachineOperations
VirtualMachineDisk VirtualMachineDiskOperations
Volume VolumeOperations
VolumeSnapshotInput VolumeSnapshotInputOperations
}
func constructClient(rancherBaseClient *RancherBaseClientImpl) *RancherClient {
client := &RancherClient{
RancherBaseClient: rancherBaseClient,
}
client.Account = newAccountClient(client)
client.ActiveSetting = newActiveSettingClient(client)
client.AddOutputsInput = newAddOutputsInputClient(client)
client.AddRemoveLoadBalancerServiceLinkInput = newAddRemoveLoadBalancerServiceLinkInputClient(client)
client.AddRemoveServiceLinkInput = newAddRemoveServiceLinkInputClient(client)
client.Agent = newAgentClient(client)
client.Amazonec2Config = newAmazonec2ConfigClient(client)
client.ApiKey = newApiKeyClient(client)
client.AuditLog = newAuditLogClient(client)
client.AzureConfig = newAzureConfigClient(client)
client.Azureadconfig = newAzureadconfigClient(client)
client.Backup = newBackupClient(client)
client.BackupTarget = newBackupTargetClient(client)
client.BaseMachineConfig = newBaseMachineConfigClient(client)
client.BlkioDeviceOption = newBlkioDeviceOptionClient(client)
client.Certificate = newCertificateClient(client)
client.ChangeSecretInput = newChangeSecretInputClient(client)
client.ComposeConfig = newComposeConfigClient(client)
client.ComposeConfigInput = newComposeConfigInputClient(client)
client.ComposeProject = newComposeProjectClient(client)
client.ComposeService = newComposeServiceClient(client)
client.ConfigItem = newConfigItemClient(client)
client.ConfigItemStatus = newConfigItemStatusClient(client)
client.Container = newContainerClient(client)
client.ContainerEvent = newContainerEventClient(client)
client.ContainerExec = newContainerExecClient(client)
client.ContainerLogs = newContainerLogsClient(client)
client.ContainerProxy = newContainerProxyClient(client)
client.Credential = newCredentialClient(client)
client.Databasechangelog = newDatabasechangelogClient(client)
client.Databasechangeloglock = newDatabasechangeloglockClient(client)
client.DigitaloceanConfig = newDigitaloceanConfigClient(client)
client.DnsService = newDnsServiceClient(client)
client.DockerBuild = newDockerBuildClient(client)
client.DynamicSchema = newDynamicSchemaClient(client)
client.Environment = newEnvironmentClient(client)
client.EnvironmentUpgrade = newEnvironmentUpgradeClient(client)
client.ExtensionImplementation = newExtensionImplementationClient(client)
client.ExtensionPoint = newExtensionPointClient(client)
client.ExternalDnsEvent = newExternalDnsEventClient(client)
client.ExternalEvent = newExternalEventClient(client)
client.ExternalHandler = newExternalHandlerClient(client)
client.ExternalHandlerExternalHandlerProcessMap = newExternalHandlerExternalHandlerProcessMapClient(client)
client.ExternalHandlerProcess = newExternalHandlerProcessClient(client)
client.ExternalHandlerProcessConfig = newExternalHandlerProcessConfigClient(client)
client.ExternalHostEvent = newExternalHostEventClient(client)
client.ExternalService = newExternalServiceClient(client)
client.ExternalServiceEvent = newExternalServiceEventClient(client)
client.ExternalStoragePoolEvent = newExternalStoragePoolEventClient(client)
client.ExternalVolumeEvent = newExternalVolumeEventClient(client)
client.FieldDocumentation = newFieldDocumentationClient(client)
client.Githubconfig = newGithubconfigClient(client)
client.HaConfig = newHaConfigClient(client)
client.HaConfigInput = newHaConfigInputClient(client)
client.HaproxyConfig = newHaproxyConfigClient(client)
client.HealthcheckInstanceHostMap = newHealthcheckInstanceHostMapClient(client)
client.Host = newHostClient(client)
client.HostAccess = newHostAccessClient(client)
client.HostApiProxyToken = newHostApiProxyTokenClient(client)
client.Identity = newIdentityClient(client)
client.Image = newImageClient(client)
client.InServiceUpgradeStrategy = newInServiceUpgradeStrategyClient(client)
client.Instance = newInstanceClient(client)
client.InstanceConsole = newInstanceConsoleClient(client)
client.InstanceConsoleInput = newInstanceConsoleInputClient(client)
client.InstanceHealthCheck = newInstanceHealthCheckClient(client)
client.InstanceLink = newInstanceLinkClient(client)
client.InstanceStop = newInstanceStopClient(client)
client.IpAddress = newIpAddressClient(client)
client.IpAddressAssociateInput = newIpAddressAssociateInputClient(client)
client.KubernetesService = newKubernetesServiceClient(client)
client.KubernetesStack = newKubernetesStackClient(client)
client.KubernetesStackUpgrade = newKubernetesStackUpgradeClient(client)
client.Label = newLabelClient(client)
client.LaunchConfig = newLaunchConfigClient(client)
client.Ldapconfig = newLdapconfigClient(client)
client.LoadBalancerAppCookieStickinessPolicy = newLoadBalancerAppCookieStickinessPolicyClient(client)
client.LoadBalancerConfig = newLoadBalancerConfigClient(client)
client.LoadBalancerCookieStickinessPolicy = newLoadBalancerCookieStickinessPolicyClient(client)
client.LoadBalancerService = newLoadBalancerServiceClient(client)
client.LoadBalancerServiceLink = newLoadBalancerServiceLinkClient(client)
client.LocalAuthConfig = newLocalAuthConfigClient(client)
client.LogConfig = newLogConfigClient(client)
client.Machine = newMachineClient(client)
client.MachineDriver = newMachineDriverClient(client)
client.Mount = newMountClient(client)
client.Network = newNetworkClient(client)
client.NfsConfig = newNfsConfigClient(client)
client.Openldapconfig = newOpenldapconfigClient(client)
client.PacketConfig = newPacketConfigClient(client)
client.Password = newPasswordClient(client)
client.PhysicalHost = newPhysicalHostClient(client)
client.Port = newPortClient(client)
client.ProcessDefinition = newProcessDefinitionClient(client)
client.ProcessExecution = newProcessExecutionClient(client)
client.ProcessInstance = newProcessInstanceClient(client)
client.Project = newProjectClient(client)
client.ProjectMember = newProjectMemberClient(client)
client.PublicEndpoint = newPublicEndpointClient(client)
client.Publish = newPublishClient(client)
client.PullTask = newPullTaskClient(client)
client.RecreateOnQuorumStrategyConfig = newRecreateOnQuorumStrategyConfigClient(client)
client.Register = newRegisterClient(client)
client.RegistrationToken = newRegistrationTokenClient(client)
client.Registry = newRegistryClient(client)
client.RegistryCredential = newRegistryCredentialClient(client)
client.ResourceDefinition = newResourceDefinitionClient(client)
client.RestartPolicy = newRestartPolicyClient(client)
client.RestoreFromBackupInput = newRestoreFromBackupInputClient(client)
client.RevertToSnapshotInput = newRevertToSnapshotInputClient(client)
client.RollingRestartStrategy = newRollingRestartStrategyClient(client)
client.ScalePolicy = newScalePolicyClient(client)
client.SecondaryLaunchConfig = newSecondaryLaunchConfigClient(client)
client.Service = newServiceClient(client)
client.ServiceConsumeMap = newServiceConsumeMapClient(client)
client.ServiceEvent = newServiceEventClient(client)
client.ServiceExposeMap = newServiceExposeMapClient(client)
client.ServiceLink = newServiceLinkClient(client)
client.ServiceProxy = newServiceProxyClient(client)
client.ServiceRestart = newServiceRestartClient(client)
client.ServiceUpgrade = newServiceUpgradeClient(client)
client.ServiceUpgradeStrategy = newServiceUpgradeStrategyClient(client)
client.ServicesPortRange = newServicesPortRangeClient(client)
client.SetLabelsInput = newSetLabelsInputClient(client)
client.SetLoadBalancerServiceLinksInput = newSetLoadBalancerServiceLinksInputClient(client)
client.SetProjectMembersInput = newSetProjectMembersInputClient(client)
client.SetServiceLinksInput = newSetServiceLinksInputClient(client)
client.Setting = newSettingClient(client)
client.Snapshot = newSnapshotClient(client)
client.SnapshotBackupInput = newSnapshotBackupInputClient(client)
client.StateTransition = newStateTransitionClient(client)
client.StatsAccess = newStatsAccessClient(client)
client.StoragePool = newStoragePoolClient(client)
client.Subscribe = newSubscribeClient(client)
client.Task = newTaskClient(client)
client.TaskInstance = newTaskInstanceClient(client)
client.ToServiceUpgradeStrategy = newToServiceUpgradeStrategyClient(client)
client.TypeDocumentation = newTypeDocumentationClient(client)
client.VirtualMachine = newVirtualMachineClient(client)
client.VirtualMachineDisk = newVirtualMachineDiskClient(client)
client.Volume = newVolumeClient(client)
client.VolumeSnapshotInput = newVolumeSnapshotInputClient(client)
return client
}
func NewRancherClient(opts *ClientOpts) (*RancherClient, error) {
rancherBaseClient := &RancherBaseClientImpl{
Types: map[string]Schema{},
}
client := constructClient(rancherBaseClient)
err := setupRancherBaseClient(rancherBaseClient, opts)
if err != nil {
return nil, err
}
return client, nil
}

69
vendor/github.com/rancher/go-rancher/client/generated_compose_config.go generated vendored Normal file
View File

@ -0,0 +1,69 @@
package client
const (
COMPOSE_CONFIG_TYPE = "composeConfig"
)
type ComposeConfig struct {
Resource
DockerComposeConfig string `json:"dockerComposeConfig,omitempty" yaml:"docker_compose_config,omitempty"`
RancherComposeConfig string `json:"rancherComposeConfig,omitempty" yaml:"rancher_compose_config,omitempty"`
}
type ComposeConfigCollection struct {
Collection
Data []ComposeConfig `json:"data,omitempty"`
}
type ComposeConfigClient struct {
rancherClient *RancherClient
}
type ComposeConfigOperations interface {
List(opts *ListOpts) (*ComposeConfigCollection, error)
Create(opts *ComposeConfig) (*ComposeConfig, error)
Update(existing *ComposeConfig, updates interface{}) (*ComposeConfig, error)
ById(id string) (*ComposeConfig, error)
Delete(container *ComposeConfig) error
}
func newComposeConfigClient(rancherClient *RancherClient) *ComposeConfigClient {
return &ComposeConfigClient{
rancherClient: rancherClient,
}
}
func (c *ComposeConfigClient) Create(container *ComposeConfig) (*ComposeConfig, error) {
resp := &ComposeConfig{}
err := c.rancherClient.doCreate(COMPOSE_CONFIG_TYPE, container, resp)
return resp, err
}
func (c *ComposeConfigClient) Update(existing *ComposeConfig, updates interface{}) (*ComposeConfig, error) {
resp := &ComposeConfig{}
err := c.rancherClient.doUpdate(COMPOSE_CONFIG_TYPE, &existing.Resource, updates, resp)
return resp, err
}
func (c *ComposeConfigClient) List(opts *ListOpts) (*ComposeConfigCollection, error) {
resp := &ComposeConfigCollection{}
err := c.rancherClient.doList(COMPOSE_CONFIG_TYPE, opts, resp)
return resp, err
}
func (c *ComposeConfigClient) ById(id string) (*ComposeConfig, error) {
resp := &ComposeConfig{}
err := c.rancherClient.doById(COMPOSE_CONFIG_TYPE, id, resp)
if apiError, ok := err.(*ApiError); ok {
if apiError.StatusCode == 404 {
return nil, nil
}
}
return resp, err
}
func (c *ComposeConfigClient) Delete(container *ComposeConfig) error {
return c.rancherClient.doResourceDelete(COMPOSE_CONFIG_TYPE, &container.Resource)
}

67
vendor/github.com/rancher/go-rancher/client/generated_compose_config_input.go generated vendored Normal file
View File

@ -0,0 +1,67 @@
package client
const (
COMPOSE_CONFIG_INPUT_TYPE = "composeConfigInput"
)
type ComposeConfigInput struct {
Resource
ServiceIds []string `json:"serviceIds,omitempty" yaml:"service_ids,omitempty"`
}
type ComposeConfigInputCollection struct {
Collection
Data []ComposeConfigInput `json:"data,omitempty"`
}
type ComposeConfigInputClient struct {
rancherClient *RancherClient
}
type ComposeConfigInputOperations interface {
List(opts *ListOpts) (*ComposeConfigInputCollection, error)
Create(opts *ComposeConfigInput) (*ComposeConfigInput, error)
Update(existing *ComposeConfigInput, updates interface{}) (*ComposeConfigInput, error)
ById(id string) (*ComposeConfigInput, error)
Delete(container *ComposeConfigInput) error
}
func newComposeConfigInputClient(rancherClient *RancherClient) *ComposeConfigInputClient {
return &ComposeConfigInputClient{
rancherClient: rancherClient,
}
}
func (c *ComposeConfigInputClient) Create(container *ComposeConfigInput) (*ComposeConfigInput, error) {
resp := &ComposeConfigInput{}
err := c.rancherClient.doCreate(COMPOSE_CONFIG_INPUT_TYPE, container, resp)
return resp, err
}
func (c *ComposeConfigInputClient) Update(existing *ComposeConfigInput, updates interface{}) (*ComposeConfigInput, error) {
resp := &ComposeConfigInput{}
err := c.rancherClient.doUpdate(COMPOSE_CONFIG_INPUT_TYPE, &existing.Resource, updates, resp)
return resp, err
}
func (c *ComposeConfigInputClient) List(opts *ListOpts) (*ComposeConfigInputCollection, error) {
resp := &ComposeConfigInputCollection{}
err := c.rancherClient.doList(COMPOSE_CONFIG_INPUT_TYPE, opts, resp)
return resp, err
}
func (c *ComposeConfigInputClient) ById(id string) (*ComposeConfigInput, error) {
resp := &ComposeConfigInput{}
err := c.rancherClient.doById(COMPOSE_CONFIG_INPUT_TYPE, id, resp)
if apiError, ok := err.(*ApiError); ok {
if apiError.StatusCode == 404 {
return nil, nil
}
}
return resp, err
}
func (c *ComposeConfigInputClient) Delete(container *ComposeConfigInput) error {
return c.rancherClient.doResourceDelete(COMPOSE_CONFIG_INPUT_TYPE, &container.Resource)
}

180
vendor/github.com/rancher/go-rancher/client/generated_compose_project.go generated vendored Normal file
View File

@ -0,0 +1,180 @@
package client
const (
COMPOSE_PROJECT_TYPE = "composeProject"
)
type ComposeProject struct {
Resource
AccountId string `json:"accountId,omitempty" yaml:"account_id,omitempty"`
Created string `json:"created,omitempty" yaml:"created,omitempty"`
Data map[string]interface{} `json:"data,omitempty" yaml:"data,omitempty"`
Description string `json:"description,omitempty" yaml:"description,omitempty"`
Environment map[string]interface{} `json:"environment,omitempty" yaml:"environment,omitempty"`
ExternalId string `json:"externalId,omitempty" yaml:"external_id,omitempty"`
HealthState string `json:"healthState,omitempty" yaml:"health_state,omitempty"`
Kind string `json:"kind,omitempty" yaml:"kind,omitempty"`
Name string `json:"name,omitempty" yaml:"name,omitempty"`
PreviousEnvironment map[string]interface{} `json:"previousEnvironment,omitempty" yaml:"previous_environment,omitempty"`
PreviousExternalId string `json:"previousExternalId,omitempty" yaml:"previous_external_id,omitempty"`
RemoveTime string `json:"removeTime,omitempty" yaml:"remove_time,omitempty"`
Removed string `json:"removed,omitempty" yaml:"removed,omitempty"`
State string `json:"state,omitempty" yaml:"state,omitempty"`
Templates map[string]interface{} `json:"templates,omitempty" yaml:"templates,omitempty"`
Transitioning string `json:"transitioning,omitempty" yaml:"transitioning,omitempty"`
TransitioningMessage string `json:"transitioningMessage,omitempty" yaml:"transitioning_message,omitempty"`
TransitioningProgress int64 `json:"transitioningProgress,omitempty" yaml:"transitioning_progress,omitempty"`
Uuid string `json:"uuid,omitempty" yaml:"uuid,omitempty"`
}
type ComposeProjectCollection struct {
Collection
Data []ComposeProject `json:"data,omitempty"`
}
type ComposeProjectClient struct {
rancherClient *RancherClient
}
type ComposeProjectOperations interface {
List(opts *ListOpts) (*ComposeProjectCollection, error)
Create(opts *ComposeProject) (*ComposeProject, error)
Update(existing *ComposeProject, updates interface{}) (*ComposeProject, error)
ById(id string) (*ComposeProject, error)
Delete(container *ComposeProject) error
ActionCancelrollback(*ComposeProject) (*Environment, error)
ActionCancelupgrade(*ComposeProject) (*Environment, error)
ActionCreate(*ComposeProject) (*Environment, error)
ActionError(*ComposeProject) (*Environment, error)
ActionFinishupgrade(*ComposeProject) (*Environment, error)
ActionRemove(*ComposeProject) (*Environment, error)
ActionRollback(*ComposeProject) (*Environment, error)
}
func newComposeProjectClient(rancherClient *RancherClient) *ComposeProjectClient {
return &ComposeProjectClient{
rancherClient: rancherClient,
}
}
func (c *ComposeProjectClient) Create(container *ComposeProject) (*ComposeProject, error) {
resp := &ComposeProject{}
err := c.rancherClient.doCreate(COMPOSE_PROJECT_TYPE, container, resp)
return resp, err
}
func (c *ComposeProjectClient) Update(existing *ComposeProject, updates interface{}) (*ComposeProject, error) {
resp := &ComposeProject{}
err := c.rancherClient.doUpdate(COMPOSE_PROJECT_TYPE, &existing.Resource, updates, resp)
return resp, err
}
func (c *ComposeProjectClient) List(opts *ListOpts) (*ComposeProjectCollection, error) {
resp := &ComposeProjectCollection{}
err := c.rancherClient.doList(COMPOSE_PROJECT_TYPE, opts, resp)
return resp, err
}
func (c *ComposeProjectClient) ById(id string) (*ComposeProject, error) {
resp := &ComposeProject{}
err := c.rancherClient.doById(COMPOSE_PROJECT_TYPE, id, resp)
if apiError, ok := err.(*ApiError); ok {
if apiError.StatusCode == 404 {
return nil, nil
}
}
return resp, err
}
func (c *ComposeProjectClient) Delete(container *ComposeProject) error {
return c.rancherClient.doResourceDelete(COMPOSE_PROJECT_TYPE, &container.Resource)
}
func (c *ComposeProjectClient) ActionCancelrollback(resource *ComposeProject) (*Environment, error) {
resp := &Environment{}
err := c.rancherClient.doAction(COMPOSE_PROJECT_TYPE, "cancelrollback", &resource.Resource, nil, resp)
return resp, err
}
func (c *ComposeProjectClient) ActionCancelupgrade(resource *ComposeProject) (*Environment, error) {
resp := &Environment{}
err := c.rancherClient.doAction(COMPOSE_PROJECT_TYPE, "cancelupgrade", &resource.Resource, nil, resp)
return resp, err
}
func (c *ComposeProjectClient) ActionCreate(resource *ComposeProject) (*Environment, error) {
resp := &Environment{}
err := c.rancherClient.doAction(COMPOSE_PROJECT_TYPE, "create", &resource.Resource, nil, resp)
return resp, err
}
func (c *ComposeProjectClient) ActionError(resource *ComposeProject) (*Environment, error) {
resp := &Environment{}
err := c.rancherClient.doAction(COMPOSE_PROJECT_TYPE, "error", &resource.Resource, nil, resp)
return resp, err
}
func (c *ComposeProjectClient) ActionFinishupgrade(resource *ComposeProject) (*Environment, error) {
resp := &Environment{}
err := c.rancherClient.doAction(COMPOSE_PROJECT_TYPE, "finishupgrade", &resource.Resource, nil, resp)
return resp, err
}
func (c *ComposeProjectClient) ActionRemove(resource *ComposeProject) (*Environment, error) {
resp := &Environment{}
err := c.rancherClient.doAction(COMPOSE_PROJECT_TYPE, "remove", &resource.Resource, nil, resp)
return resp, err
}
func (c *ComposeProjectClient) ActionRollback(resource *ComposeProject) (*Environment, error) {
resp := &Environment{}
err := c.rancherClient.doAction(COMPOSE_PROJECT_TYPE, "rollback", &resource.Resource, nil, resp)
return resp, err
}

194
vendor/github.com/rancher/go-rancher/client/generated_compose_service.go generated vendored Normal file
View File

@ -0,0 +1,194 @@
package client
const (
COMPOSE_SERVICE_TYPE = "composeService"
)
type ComposeService struct {
Resource
AccountId string `json:"accountId,omitempty" yaml:"account_id,omitempty"`
Created string `json:"created,omitempty" yaml:"created,omitempty"`
CurrentScale int64 `json:"currentScale,omitempty" yaml:"current_scale,omitempty"`
Data map[string]interface{} `json:"data,omitempty" yaml:"data,omitempty"`
Description string `json:"description,omitempty" yaml:"description,omitempty"`
EnvironmentId string `json:"environmentId,omitempty" yaml:"environment_id,omitempty"`
ExternalId string `json:"externalId,omitempty" yaml:"external_id,omitempty"`
Fqdn string `json:"fqdn,omitempty" yaml:"fqdn,omitempty"`
HealthState string `json:"healthState,omitempty" yaml:"health_state,omitempty"`
Kind string `json:"kind,omitempty" yaml:"kind,omitempty"`
LaunchConfig *LaunchConfig `json:"launchConfig,omitempty" yaml:"launch_config,omitempty"`
Name string `json:"name,omitempty" yaml:"name,omitempty"`
PublicEndpoints []interface{} `json:"publicEndpoints,omitempty" yaml:"public_endpoints,omitempty"`
RemoveTime string `json:"removeTime,omitempty" yaml:"remove_time,omitempty"`
Removed string `json:"removed,omitempty" yaml:"removed,omitempty"`
Scale int64 `json:"scale,omitempty" yaml:"scale,omitempty"`
ScalePolicy *ScalePolicy `json:"scalePolicy,omitempty" yaml:"scale_policy,omitempty"`
SelectorContainer string `json:"selectorContainer,omitempty" yaml:"selector_container,omitempty"`
SelectorLink string `json:"selectorLink,omitempty" yaml:"selector_link,omitempty"`
StartOnCreate bool `json:"startOnCreate,omitempty" yaml:"start_on_create,omitempty"`
State string `json:"state,omitempty" yaml:"state,omitempty"`
Transitioning string `json:"transitioning,omitempty" yaml:"transitioning,omitempty"`
TransitioningMessage string `json:"transitioningMessage,omitempty" yaml:"transitioning_message,omitempty"`
TransitioningProgress int64 `json:"transitioningProgress,omitempty" yaml:"transitioning_progress,omitempty"`
Uuid string `json:"uuid,omitempty" yaml:"uuid,omitempty"`
Vip string `json:"vip,omitempty" yaml:"vip,omitempty"`
}
type ComposeServiceCollection struct {
Collection
Data []ComposeService `json:"data,omitempty"`
}
type ComposeServiceClient struct {
rancherClient *RancherClient
}
type ComposeServiceOperations interface {
List(opts *ListOpts) (*ComposeServiceCollection, error)
Create(opts *ComposeService) (*ComposeService, error)
Update(existing *ComposeService, updates interface{}) (*ComposeService, error)
ById(id string) (*ComposeService, error)
Delete(container *ComposeService) error
ActionActivate(*ComposeService) (*Service, error)
ActionCancelrollback(*ComposeService) (*Service, error)
ActionCancelupgrade(*ComposeService) (*Service, error)
ActionCreate(*ComposeService) (*Service, error)
ActionFinishupgrade(*ComposeService) (*Service, error)
ActionRemove(*ComposeService) (*Service, error)
ActionRollback(*ComposeService) (*Service, error)
}
func newComposeServiceClient(rancherClient *RancherClient) *ComposeServiceClient {
return &ComposeServiceClient{
rancherClient: rancherClient,
}
}
func (c *ComposeServiceClient) Create(container *ComposeService) (*ComposeService, error) {
resp := &ComposeService{}
err := c.rancherClient.doCreate(COMPOSE_SERVICE_TYPE, container, resp)
return resp, err
}
func (c *ComposeServiceClient) Update(existing *ComposeService, updates interface{}) (*ComposeService, error) {
resp := &ComposeService{}
err := c.rancherClient.doUpdate(COMPOSE_SERVICE_TYPE, &existing.Resource, updates, resp)
return resp, err
}
func (c *ComposeServiceClient) List(opts *ListOpts) (*ComposeServiceCollection, error) {
resp := &ComposeServiceCollection{}
err := c.rancherClient.doList(COMPOSE_SERVICE_TYPE, opts, resp)
return resp, err
}
func (c *ComposeServiceClient) ById(id string) (*ComposeService, error) {
resp := &ComposeService{}
err := c.rancherClient.doById(COMPOSE_SERVICE_TYPE, id, resp)
if apiError, ok := err.(*ApiError); ok {
if apiError.StatusCode == 404 {
return nil, nil
}
}
return resp, err
}
func (c *ComposeServiceClient) Delete(container *ComposeService) error {
return c.rancherClient.doResourceDelete(COMPOSE_SERVICE_TYPE, &container.Resource)
}
func (c *ComposeServiceClient) ActionActivate(resource *ComposeService) (*Service, error) {
resp := &Service{}
err := c.rancherClient.doAction(COMPOSE_SERVICE_TYPE, "activate", &resource.Resource, nil, resp)
return resp, err
}
func (c *ComposeServiceClient) ActionCancelrollback(resource *ComposeService) (*Service, error) {
resp := &Service{}
err := c.rancherClient.doAction(COMPOSE_SERVICE_TYPE, "cancelrollback", &resource.Resource, nil, resp)
return resp, err
}
func (c *ComposeServiceClient) ActionCancelupgrade(resource *ComposeService) (*Service, error) {
resp := &Service{}
err := c.rancherClient.doAction(COMPOSE_SERVICE_TYPE, "cancelupgrade", &resource.Resource, nil, resp)
return resp, err
}
func (c *ComposeServiceClient) ActionCreate(resource *ComposeService) (*Service, error) {
resp := &Service{}
err := c.rancherClient.doAction(COMPOSE_SERVICE_TYPE, "create", &resource.Resource, nil, resp)
return resp, err
}
func (c *ComposeServiceClient) ActionFinishupgrade(resource *ComposeService) (*Service, error) {
resp := &Service{}
err := c.rancherClient.doAction(COMPOSE_SERVICE_TYPE, "finishupgrade", &resource.Resource, nil, resp)
return resp, err
}
func (c *ComposeServiceClient) ActionRemove(resource *ComposeService) (*Service, error) {
resp := &Service{}
err := c.rancherClient.doAction(COMPOSE_SERVICE_TYPE, "remove", &resource.Resource, nil, resp)
return resp, err
}
func (c *ComposeServiceClient) ActionRollback(resource *ComposeService) (*Service, error) {
resp := &Service{}
err := c.rancherClient.doAction(COMPOSE_SERVICE_TYPE, "rollback", &resource.Resource, nil, resp)
return resp, err
}

69
vendor/github.com/rancher/go-rancher/client/generated_config_item.go generated vendored Normal file
View File

@ -0,0 +1,69 @@
package client
const (
CONFIG_ITEM_TYPE = "configItem"
)
type ConfigItem struct {
Resource
Name string `json:"name,omitempty" yaml:"name,omitempty"`
SourceVersion string `json:"sourceVersion,omitempty" yaml:"source_version,omitempty"`
}
type ConfigItemCollection struct {
Collection
Data []ConfigItem `json:"data,omitempty"`
}
type ConfigItemClient struct {
rancherClient *RancherClient
}
type ConfigItemOperations interface {
List(opts *ListOpts) (*ConfigItemCollection, error)
Create(opts *ConfigItem) (*ConfigItem, error)
Update(existing *ConfigItem, updates interface{}) (*ConfigItem, error)
ById(id string) (*ConfigItem, error)
Delete(container *ConfigItem) error
}
func newConfigItemClient(rancherClient *RancherClient) *ConfigItemClient {
return &ConfigItemClient{
rancherClient: rancherClient,
}
}
func (c *ConfigItemClient) Create(container *ConfigItem) (*ConfigItem, error) {
resp := &ConfigItem{}
err := c.rancherClient.doCreate(CONFIG_ITEM_TYPE, container, resp)
return resp, err
}
func (c *ConfigItemClient) Update(existing *ConfigItem, updates interface{}) (*ConfigItem, error) {
resp := &ConfigItem{}
err := c.rancherClient.doUpdate(CONFIG_ITEM_TYPE, &existing.Resource, updates, resp)
return resp, err
}
func (c *ConfigItemClient) List(opts *ListOpts) (*ConfigItemCollection, error) {
resp := &ConfigItemCollection{}
err := c.rancherClient.doList(CONFIG_ITEM_TYPE, opts, resp)
return resp, err
}
func (c *ConfigItemClient) ById(id string) (*ConfigItem, error) {
resp := &ConfigItem{}
err := c.rancherClient.doById(CONFIG_ITEM_TYPE, id, resp)
if apiError, ok := err.(*ApiError); ok {
if apiError.StatusCode == 404 {
return nil, nil
}
}
return resp, err
}
func (c *ConfigItemClient) Delete(container *ConfigItem) error {
return c.rancherClient.doResourceDelete(CONFIG_ITEM_TYPE, &container.Resource)
}

81
vendor/github.com/rancher/go-rancher/client/generated_config_item_status.go generated vendored Normal file
View File

@ -0,0 +1,81 @@
package client
const (
CONFIG_ITEM_STATUS_TYPE = "configItemStatus"
)
type ConfigItemStatus struct {
Resource
AccountId string `json:"accountId,omitempty" yaml:"account_id,omitempty"`
AgentId string `json:"agentId,omitempty" yaml:"agent_id,omitempty"`
AppliedUpdated string `json:"appliedUpdated,omitempty" yaml:"applied_updated,omitempty"`
AppliedVersion int64 `json:"appliedVersion,omitempty" yaml:"applied_version,omitempty"`
Name string `json:"name,omitempty" yaml:"name,omitempty"`
RequestedUpdated string `json:"requestedUpdated,omitempty" yaml:"requested_updated,omitempty"`
RequestedVersion int64 `json:"requestedVersion,omitempty" yaml:"requested_version,omitempty"`
SourceVersion string `json:"sourceVersion,omitempty" yaml:"source_version,omitempty"`
}
type ConfigItemStatusCollection struct {
Collection
Data []ConfigItemStatus `json:"data,omitempty"`
}
type ConfigItemStatusClient struct {
rancherClient *RancherClient
}
type ConfigItemStatusOperations interface {
List(opts *ListOpts) (*ConfigItemStatusCollection, error)
Create(opts *ConfigItemStatus) (*ConfigItemStatus, error)
Update(existing *ConfigItemStatus, updates interface{}) (*ConfigItemStatus, error)
ById(id string) (*ConfigItemStatus, error)
Delete(container *ConfigItemStatus) error
}
func newConfigItemStatusClient(rancherClient *RancherClient) *ConfigItemStatusClient {
return &ConfigItemStatusClient{
rancherClient: rancherClient,
}
}
func (c *ConfigItemStatusClient) Create(container *ConfigItemStatus) (*ConfigItemStatus, error) {
resp := &ConfigItemStatus{}
err := c.rancherClient.doCreate(CONFIG_ITEM_STATUS_TYPE, container, resp)
return resp, err
}
func (c *ConfigItemStatusClient) Update(existing *ConfigItemStatus, updates interface{}) (*ConfigItemStatus, error) {
resp := &ConfigItemStatus{}
err := c.rancherClient.doUpdate(CONFIG_ITEM_STATUS_TYPE, &existing.Resource, updates, resp)
return resp, err
}
func (c *ConfigItemStatusClient) List(opts *ListOpts) (*ConfigItemStatusCollection, error) {
resp := &ConfigItemStatusCollection{}
err := c.rancherClient.doList(CONFIG_ITEM_STATUS_TYPE, opts, resp)
return resp, err
}
func (c *ConfigItemStatusClient) ById(id string) (*ConfigItemStatus, error) {
resp := &ConfigItemStatus{}
err := c.rancherClient.doById(CONFIG_ITEM_STATUS_TYPE, id, resp)
if apiError, ok := err.(*ApiError); ok {
if apiError.StatusCode == 404 {
return nil, nil
}
}
return resp, err
}
func (c *ConfigItemStatusClient) Delete(container *ConfigItemStatus) error {
return c.rancherClient.doResourceDelete(CONFIG_ITEM_STATUS_TYPE, &container.Resource)
}

431
vendor/github.com/rancher/go-rancher/client/generated_container.go generated vendored Normal file
View File

@ -0,0 +1,431 @@
package client
const (
CONTAINER_TYPE = "container"
)
type Container struct {
Resource
AccountId string `json:"accountId,omitempty" yaml:"account_id,omitempty"`
AgentId string `json:"agentId,omitempty" yaml:"agent_id,omitempty"`
AllocationState string `json:"allocationState,omitempty" yaml:"allocation_state,omitempty"`
BlkioDeviceOptions map[string]interface{} `json:"blkioDeviceOptions,omitempty" yaml:"blkio_device_options,omitempty"`
Build *DockerBuild `json:"build,omitempty" yaml:"build,omitempty"`
CapAdd []string `json:"capAdd,omitempty" yaml:"cap_add,omitempty"`
CapDrop []string `json:"capDrop,omitempty" yaml:"cap_drop,omitempty"`
Command []string `json:"command,omitempty" yaml:"command,omitempty"`
Count int64 `json:"count,omitempty" yaml:"count,omitempty"`
CpuSet string `json:"cpuSet,omitempty" yaml:"cpu_set,omitempty"`
CpuShares int64 `json:"cpuShares,omitempty" yaml:"cpu_shares,omitempty"`
CreateIndex int64 `json:"createIndex,omitempty" yaml:"create_index,omitempty"`
Created string `json:"created,omitempty" yaml:"created,omitempty"`
Data map[string]interface{} `json:"data,omitempty" yaml:"data,omitempty"`
DataVolumeMounts map[string]interface{} `json:"dataVolumeMounts,omitempty" yaml:"data_volume_mounts,omitempty"`
DataVolumes []string `json:"dataVolumes,omitempty" yaml:"data_volumes,omitempty"`
DataVolumesFrom []string `json:"dataVolumesFrom,omitempty" yaml:"data_volumes_from,omitempty"`
DeploymentUnitUuid string `json:"deploymentUnitUuid,omitempty" yaml:"deployment_unit_uuid,omitempty"`
Description string `json:"description,omitempty" yaml:"description,omitempty"`
Devices []string `json:"devices,omitempty" yaml:"devices,omitempty"`
Dns []string `json:"dns,omitempty" yaml:"dns,omitempty"`
DnsSearch []string `json:"dnsSearch,omitempty" yaml:"dns_search,omitempty"`
DomainName string `json:"domainName,omitempty" yaml:"domain_name,omitempty"`
EntryPoint []string `json:"entryPoint,omitempty" yaml:"entry_point,omitempty"`
Environment map[string]interface{} `json:"environment,omitempty" yaml:"environment,omitempty"`
Expose []string `json:"expose,omitempty" yaml:"expose,omitempty"`
ExternalId string `json:"externalId,omitempty" yaml:"external_id,omitempty"`
ExtraHosts []string `json:"extraHosts,omitempty" yaml:"extra_hosts,omitempty"`
FirstRunning string `json:"firstRunning,omitempty" yaml:"first_running,omitempty"`
HealthCheck *InstanceHealthCheck `json:"healthCheck,omitempty" yaml:"health_check,omitempty"`
HealthState string `json:"healthState,omitempty" yaml:"health_state,omitempty"`
HostId string `json:"hostId,omitempty" yaml:"host_id,omitempty"`
Hostname string `json:"hostname,omitempty" yaml:"hostname,omitempty"`
ImageUuid string `json:"imageUuid,omitempty" yaml:"image_uuid,omitempty"`
InstanceLinks map[string]interface{} `json:"instanceLinks,omitempty" yaml:"instance_links,omitempty"`
Kind string `json:"kind,omitempty" yaml:"kind,omitempty"`
Labels map[string]interface{} `json:"labels,omitempty" yaml:"labels,omitempty"`
LogConfig *LogConfig `json:"logConfig,omitempty" yaml:"log_config,omitempty"`
LxcConf map[string]interface{} `json:"lxcConf,omitempty" yaml:"lxc_conf,omitempty"`
Memory int64 `json:"memory,omitempty" yaml:"memory,omitempty"`
MemorySwap int64 `json:"memorySwap,omitempty" yaml:"memory_swap,omitempty"`
Name string `json:"name,omitempty" yaml:"name,omitempty"`
NativeContainer bool `json:"nativeContainer,omitempty" yaml:"native_container,omitempty"`
NetworkContainerId string `json:"networkContainerId,omitempty" yaml:"network_container_id,omitempty"`
NetworkIds []string `json:"networkIds,omitempty" yaml:"network_ids,omitempty"`
NetworkMode string `json:"networkMode,omitempty" yaml:"network_mode,omitempty"`
PidMode string `json:"pidMode,omitempty" yaml:"pid_mode,omitempty"`
Ports []string `json:"ports,omitempty" yaml:"ports,omitempty"`
PrimaryIpAddress string `json:"primaryIpAddress,omitempty" yaml:"primary_ip_address,omitempty"`
Privileged bool `json:"privileged,omitempty" yaml:"privileged,omitempty"`
PublishAllPorts bool `json:"publishAllPorts,omitempty" yaml:"publish_all_ports,omitempty"`
ReadOnly bool `json:"readOnly,omitempty" yaml:"read_only,omitempty"`
RegistryCredentialId string `json:"registryCredentialId,omitempty" yaml:"registry_credential_id,omitempty"`
RemoveTime string `json:"removeTime,omitempty" yaml:"remove_time,omitempty"`
Removed string `json:"removed,omitempty" yaml:"removed,omitempty"`
RequestedHostId string `json:"requestedHostId,omitempty" yaml:"requested_host_id,omitempty"`
RestartPolicy *RestartPolicy `json:"restartPolicy,omitempty" yaml:"restart_policy,omitempty"`
SecurityOpt []string `json:"securityOpt,omitempty" yaml:"security_opt,omitempty"`
StartCount int64 `json:"startCount,omitempty" yaml:"start_count,omitempty"`
StartOnCreate bool `json:"startOnCreate,omitempty" yaml:"start_on_create,omitempty"`
State string `json:"state,omitempty" yaml:"state,omitempty"`
StdinOpen bool `json:"stdinOpen,omitempty" yaml:"stdin_open,omitempty"`
SystemContainer string `json:"systemContainer,omitempty" yaml:"system_container,omitempty"`
Token string `json:"token,omitempty" yaml:"token,omitempty"`
Transitioning string `json:"transitioning,omitempty" yaml:"transitioning,omitempty"`
TransitioningMessage string `json:"transitioningMessage,omitempty" yaml:"transitioning_message,omitempty"`
TransitioningProgress int64 `json:"transitioningProgress,omitempty" yaml:"transitioning_progress,omitempty"`
Tty bool `json:"tty,omitempty" yaml:"tty,omitempty"`
User string `json:"user,omitempty" yaml:"user,omitempty"`
Uuid string `json:"uuid,omitempty" yaml:"uuid,omitempty"`
Version string `json:"version,omitempty" yaml:"version,omitempty"`
VolumeDriver string `json:"volumeDriver,omitempty" yaml:"volume_driver,omitempty"`
WorkingDir string `json:"workingDir,omitempty" yaml:"working_dir,omitempty"`
}
type ContainerCollection struct {
Collection
Data []Container `json:"data,omitempty"`
}
type ContainerClient struct {
rancherClient *RancherClient
}
type ContainerOperations interface {
List(opts *ListOpts) (*ContainerCollection, error)
Create(opts *Container) (*Container, error)
Update(existing *Container, updates interface{}) (*Container, error)
ById(id string) (*Container, error)
Delete(container *Container) error
ActionAllocate(*Container) (*Instance, error)
ActionConsole(*Container, *InstanceConsoleInput) (*InstanceConsole, error)
ActionCreate(*Container) (*Instance, error)
ActionDeallocate(*Container) (*Instance, error)
ActionError(*Container) (*Instance, error)
ActionExecute(*Container, *ContainerExec) (*HostAccess, error)
ActionLogs(*Container, *ContainerLogs) (*HostAccess, error)
ActionMigrate(*Container) (*Instance, error)
ActionProxy(*Container, *ContainerProxy) (*HostAccess, error)
ActionPurge(*Container) (*Instance, error)
ActionRemove(*Container) (*Instance, error)
ActionRestart(*Container) (*Instance, error)
ActionRestore(*Container) (*Instance, error)
ActionSetlabels(*Container, *SetLabelsInput) (*Container, error)
ActionStart(*Container) (*Instance, error)
ActionStop(*Container, *InstanceStop) (*Instance, error)
ActionUpdate(*Container) (*Instance, error)
ActionUpdatehealthy(*Container) (*Instance, error)
ActionUpdatereinitializing(*Container) (*Instance, error)
ActionUpdateunhealthy(*Container) (*Instance, error)
}
func newContainerClient(rancherClient *RancherClient) *ContainerClient {
return &ContainerClient{
rancherClient: rancherClient,
}
}
func (c *ContainerClient) Create(container *Container) (*Container, error) {
resp := &Container{}
err := c.rancherClient.doCreate(CONTAINER_TYPE, container, resp)
return resp, err
}
func (c *ContainerClient) Update(existing *Container, updates interface{}) (*Container, error) {
resp := &Container{}
err := c.rancherClient.doUpdate(CONTAINER_TYPE, &existing.Resource, updates, resp)
return resp, err
}
func (c *ContainerClient) List(opts *ListOpts) (*ContainerCollection, error) {
resp := &ContainerCollection{}
err := c.rancherClient.doList(CONTAINER_TYPE, opts, resp)
return resp, err
}
func (c *ContainerClient) ById(id string) (*Container, error) {
resp := &Container{}
err := c.rancherClient.doById(CONTAINER_TYPE, id, resp)
if apiError, ok := err.(*ApiError); ok {
if apiError.StatusCode == 404 {
return nil, nil
}
}
return resp, err
}
func (c *ContainerClient) Delete(container *Container) error {
return c.rancherClient.doResourceDelete(CONTAINER_TYPE, &container.Resource)
}
func (c *ContainerClient) ActionAllocate(resource *Container) (*Instance, error) {
resp := &Instance{}
err := c.rancherClient.doAction(CONTAINER_TYPE, "allocate", &resource.Resource, nil, resp)
return resp, err
}
func (c *ContainerClient) ActionConsole(resource *Container, input *InstanceConsoleInput) (*InstanceConsole, error) {
resp := &InstanceConsole{}
err := c.rancherClient.doAction(CONTAINER_TYPE, "console", &resource.Resource, input, resp)
return resp, err
}
func (c *ContainerClient) ActionCreate(resource *Container) (*Instance, error) {
resp := &Instance{}
err := c.rancherClient.doAction(CONTAINER_TYPE, "create", &resource.Resource, nil, resp)
return resp, err
}
func (c *ContainerClient) ActionDeallocate(resource *Container) (*Instance, error) {
resp := &Instance{}
err := c.rancherClient.doAction(CONTAINER_TYPE, "deallocate", &resource.Resource, nil, resp)
return resp, err
}
func (c *ContainerClient) ActionError(resource *Container) (*Instance, error) {
resp := &Instance{}
err := c.rancherClient.doAction(CONTAINER_TYPE, "error", &resource.Resource, nil, resp)
return resp, err
}
func (c *ContainerClient) ActionExecute(resource *Container, input *ContainerExec) (*HostAccess, error) {
resp := &HostAccess{}
err := c.rancherClient.doAction(CONTAINER_TYPE, "execute", &resource.Resource, input, resp)
return resp, err
}
func (c *ContainerClient) ActionLogs(resource *Container, input *ContainerLogs) (*HostAccess, error) {
resp := &HostAccess{}
err := c.rancherClient.doAction(CONTAINER_TYPE, "logs", &resource.Resource, input, resp)
return resp, err
}
func (c *ContainerClient) ActionMigrate(resource *Container) (*Instance, error) {
resp := &Instance{}
err := c.rancherClient.doAction(CONTAINER_TYPE, "migrate", &resource.Resource, nil, resp)
return resp, err
}
func (c *ContainerClient) ActionProxy(resource *Container, input *ContainerProxy) (*HostAccess, error) {
resp := &HostAccess{}
err := c.rancherClient.doAction(CONTAINER_TYPE, "proxy", &resource.Resource, input, resp)
return resp, err
}
func (c *ContainerClient) ActionPurge(resource *Container) (*Instance, error) {
resp := &Instance{}
err := c.rancherClient.doAction(CONTAINER_TYPE, "purge", &resource.Resource, nil, resp)
return resp, err
}
func (c *ContainerClient) ActionRemove(resource *Container) (*Instance, error) {
resp := &Instance{}
err := c.rancherClient.doAction(CONTAINER_TYPE, "remove", &resource.Resource, nil, resp)
return resp, err
}
func (c *ContainerClient) ActionRestart(resource *Container) (*Instance, error) {
resp := &Instance{}
err := c.rancherClient.doAction(CONTAINER_TYPE, "restart", &resource.Resource, nil, resp)
return resp, err
}
func (c *ContainerClient) ActionRestore(resource *Container) (*Instance, error) {
resp := &Instance{}
err := c.rancherClient.doAction(CONTAINER_TYPE, "restore", &resource.Resource, nil, resp)
return resp, err
}
func (c *ContainerClient) ActionSetlabels(resource *Container, input *SetLabelsInput) (*Container, error) {
resp := &Container{}
err := c.rancherClient.doAction(CONTAINER_TYPE, "setlabels", &resource.Resource, input, resp)
return resp, err
}
func (c *ContainerClient) ActionStart(resource *Container) (*Instance, error) {
resp := &Instance{}
err := c.rancherClient.doAction(CONTAINER_TYPE, "start", &resource.Resource, nil, resp)
return resp, err
}
func (c *ContainerClient) ActionStop(resource *Container, input *InstanceStop) (*Instance, error) {
resp := &Instance{}
err := c.rancherClient.doAction(CONTAINER_TYPE, "stop", &resource.Resource, input, resp)
return resp, err
}
func (c *ContainerClient) ActionUpdate(resource *Container) (*Instance, error) {
resp := &Instance{}
err := c.rancherClient.doAction(CONTAINER_TYPE, "update", &resource.Resource, nil, resp)
return resp, err
}
func (c *ContainerClient) ActionUpdatehealthy(resource *Container) (*Instance, error) {
resp := &Instance{}
err := c.rancherClient.doAction(CONTAINER_TYPE, "updatehealthy", &resource.Resource, nil, resp)
return resp, err
}
func (c *ContainerClient) ActionUpdatereinitializing(resource *Container) (*Instance, error) {
resp := &Instance{}
err := c.rancherClient.doAction(CONTAINER_TYPE, "updatereinitializing", &resource.Resource, nil, resp)
return resp, err
}
func (c *ContainerClient) ActionUpdateunhealthy(resource *Container) (*Instance, error) {
resp := &Instance{}
err := c.rancherClient.doAction(CONTAINER_TYPE, "updateunhealthy", &resource.Resource, nil, resp)
return resp, err
}

117
vendor/github.com/rancher/go-rancher/client/generated_container_event.go generated vendored Normal file
View File

@ -0,0 +1,117 @@
package client
const (
CONTAINER_EVENT_TYPE = "containerEvent"
)
type ContainerEvent struct {
Resource
AccountId string `json:"accountId,omitempty" yaml:"account_id,omitempty"`
Created string `json:"created,omitempty" yaml:"created,omitempty"`
Data map[string]interface{} `json:"data,omitempty" yaml:"data,omitempty"`
DockerInspect interface{} `json:"dockerInspect,omitempty" yaml:"docker_inspect,omitempty"`
ExternalFrom string `json:"externalFrom,omitempty" yaml:"external_from,omitempty"`
ExternalId string `json:"externalId,omitempty" yaml:"external_id,omitempty"`
ExternalStatus string `json:"externalStatus,omitempty" yaml:"external_status,omitempty"`
ExternalTimestamp int64 `json:"externalTimestamp,omitempty" yaml:"external_timestamp,omitempty"`
HostId string `json:"hostId,omitempty" yaml:"host_id,omitempty"`
Kind string `json:"kind,omitempty" yaml:"kind,omitempty"`
ReportedHostUuid string `json:"reportedHostUuid,omitempty" yaml:"reported_host_uuid,omitempty"`
State string `json:"state,omitempty" yaml:"state,omitempty"`
Transitioning string `json:"transitioning,omitempty" yaml:"transitioning,omitempty"`
TransitioningMessage string `json:"transitioningMessage,omitempty" yaml:"transitioning_message,omitempty"`
TransitioningProgress int64 `json:"transitioningProgress,omitempty" yaml:"transitioning_progress,omitempty"`
}
type ContainerEventCollection struct {
Collection
Data []ContainerEvent `json:"data,omitempty"`
}
type ContainerEventClient struct {
rancherClient *RancherClient
}
type ContainerEventOperations interface {
List(opts *ListOpts) (*ContainerEventCollection, error)
Create(opts *ContainerEvent) (*ContainerEvent, error)
Update(existing *ContainerEvent, updates interface{}) (*ContainerEvent, error)
ById(id string) (*ContainerEvent, error)
Delete(container *ContainerEvent) error
ActionCreate(*ContainerEvent) (*ContainerEvent, error)
ActionRemove(*ContainerEvent) (*ContainerEvent, error)
}
func newContainerEventClient(rancherClient *RancherClient) *ContainerEventClient {
return &ContainerEventClient{
rancherClient: rancherClient,
}
}
func (c *ContainerEventClient) Create(container *ContainerEvent) (*ContainerEvent, error) {
resp := &ContainerEvent{}
err := c.rancherClient.doCreate(CONTAINER_EVENT_TYPE, container, resp)
return resp, err
}
func (c *ContainerEventClient) Update(existing *ContainerEvent, updates interface{}) (*ContainerEvent, error) {
resp := &ContainerEvent{}
err := c.rancherClient.doUpdate(CONTAINER_EVENT_TYPE, &existing.Resource, updates, resp)
return resp, err
}
func (c *ContainerEventClient) List(opts *ListOpts) (*ContainerEventCollection, error) {
resp := &ContainerEventCollection{}
err := c.rancherClient.doList(CONTAINER_EVENT_TYPE, opts, resp)
return resp, err
}
func (c *ContainerEventClient) ById(id string) (*ContainerEvent, error) {
resp := &ContainerEvent{}
err := c.rancherClient.doById(CONTAINER_EVENT_TYPE, id, resp)
if apiError, ok := err.(*ApiError); ok {
if apiError.StatusCode == 404 {
return nil, nil
}
}
return resp, err
}
func (c *ContainerEventClient) Delete(container *ContainerEvent) error {
return c.rancherClient.doResourceDelete(CONTAINER_EVENT_TYPE, &container.Resource)
}
func (c *ContainerEventClient) ActionCreate(resource *ContainerEvent) (*ContainerEvent, error) {
resp := &ContainerEvent{}
err := c.rancherClient.doAction(CONTAINER_EVENT_TYPE, "create", &resource.Resource, nil, resp)
return resp, err
}
func (c *ContainerEventClient) ActionRemove(resource *ContainerEvent) (*ContainerEvent, error) {
resp := &ContainerEvent{}
err := c.rancherClient.doAction(CONTAINER_EVENT_TYPE, "remove", &resource.Resource, nil, resp)
return resp, err
}

73
vendor/github.com/rancher/go-rancher/client/generated_container_exec.go generated vendored Normal file
View File

@ -0,0 +1,73 @@
package client
const (
CONTAINER_EXEC_TYPE = "containerExec"
)
type ContainerExec struct {
Resource
AttachStdin bool `json:"attachStdin,omitempty" yaml:"attach_stdin,omitempty"`
AttachStdout bool `json:"attachStdout,omitempty" yaml:"attach_stdout,omitempty"`
Command []string `json:"command,omitempty" yaml:"command,omitempty"`
Tty bool `json:"tty,omitempty" yaml:"tty,omitempty"`
}
type ContainerExecCollection struct {
Collection
Data []ContainerExec `json:"data,omitempty"`
}
type ContainerExecClient struct {
rancherClient *RancherClient
}
type ContainerExecOperations interface {
List(opts *ListOpts) (*ContainerExecCollection, error)
Create(opts *ContainerExec) (*ContainerExec, error)
Update(existing *ContainerExec, updates interface{}) (*ContainerExec, error)
ById(id string) (*ContainerExec, error)
Delete(container *ContainerExec) error
}
func newContainerExecClient(rancherClient *RancherClient) *ContainerExecClient {
return &ContainerExecClient{
rancherClient: rancherClient,
}
}
func (c *ContainerExecClient) Create(container *ContainerExec) (*ContainerExec, error) {
resp := &ContainerExec{}
err := c.rancherClient.doCreate(CONTAINER_EXEC_TYPE, container, resp)
return resp, err
}
func (c *ContainerExecClient) Update(existing *ContainerExec, updates interface{}) (*ContainerExec, error) {
resp := &ContainerExec{}
err := c.rancherClient.doUpdate(CONTAINER_EXEC_TYPE, &existing.Resource, updates, resp)
return resp, err
}
func (c *ContainerExecClient) List(opts *ListOpts) (*ContainerExecCollection, error) {
resp := &ContainerExecCollection{}
err := c.rancherClient.doList(CONTAINER_EXEC_TYPE, opts, resp)
return resp, err
}
func (c *ContainerExecClient) ById(id string) (*ContainerExec, error) {
resp := &ContainerExec{}
err := c.rancherClient.doById(CONTAINER_EXEC_TYPE, id, resp)
if apiError, ok := err.(*ApiError); ok {
if apiError.StatusCode == 404 {
return nil, nil
}
}
return resp, err
}
func (c *ContainerExecClient) Delete(container *ContainerExec) error {
return c.rancherClient.doResourceDelete(CONTAINER_EXEC_TYPE, &container.Resource)
}

69
vendor/github.com/rancher/go-rancher/client/generated_container_logs.go generated vendored Normal file
View File

@ -0,0 +1,69 @@
package client
const (
CONTAINER_LOGS_TYPE = "containerLogs"
)
type ContainerLogs struct {
Resource
Follow bool `json:"follow,omitempty" yaml:"follow,omitempty"`
Lines int64 `json:"lines,omitempty" yaml:"lines,omitempty"`
}
type ContainerLogsCollection struct {
Collection
Data []ContainerLogs `json:"data,omitempty"`
}
type ContainerLogsClient struct {
rancherClient *RancherClient
}
type ContainerLogsOperations interface {
List(opts *ListOpts) (*ContainerLogsCollection, error)
Create(opts *ContainerLogs) (*ContainerLogs, error)
Update(existing *ContainerLogs, updates interface{}) (*ContainerLogs, error)
ById(id string) (*ContainerLogs, error)
Delete(container *ContainerLogs) error
}
func newContainerLogsClient(rancherClient *RancherClient) *ContainerLogsClient {
return &ContainerLogsClient{
rancherClient: rancherClient,
}
}
func (c *ContainerLogsClient) Create(container *ContainerLogs) (*ContainerLogs, error) {
resp := &ContainerLogs{}
err := c.rancherClient.doCreate(CONTAINER_LOGS_TYPE, container, resp)
return resp, err
}
func (c *ContainerLogsClient) Update(existing *ContainerLogs, updates interface{}) (*ContainerLogs, error) {
resp := &ContainerLogs{}
err := c.rancherClient.doUpdate(CONTAINER_LOGS_TYPE, &existing.Resource, updates, resp)
return resp, err
}
func (c *ContainerLogsClient) List(opts *ListOpts) (*ContainerLogsCollection, error) {
resp := &ContainerLogsCollection{}
err := c.rancherClient.doList(CONTAINER_LOGS_TYPE, opts, resp)
return resp, err
}
func (c *ContainerLogsClient) ById(id string) (*ContainerLogs, error) {
resp := &ContainerLogs{}
err := c.rancherClient.doById(CONTAINER_LOGS_TYPE, id, resp)
if apiError, ok := err.(*ApiError); ok {
if apiError.StatusCode == 404 {
return nil, nil
}
}
return resp, err
}
func (c *ContainerLogsClient) Delete(container *ContainerLogs) error {
return c.rancherClient.doResourceDelete(CONTAINER_LOGS_TYPE, &container.Resource)
}

69
vendor/github.com/rancher/go-rancher/client/generated_container_proxy.go generated vendored Normal file
View File

@ -0,0 +1,69 @@
package client
const (
CONTAINER_PROXY_TYPE = "containerProxy"
)
type ContainerProxy struct {
Resource
Port int64 `json:"port,omitempty" yaml:"port,omitempty"`
Scheme string `json:"scheme,omitempty" yaml:"scheme,omitempty"`
}
type ContainerProxyCollection struct {
Collection
Data []ContainerProxy `json:"data,omitempty"`
}
type ContainerProxyClient struct {
rancherClient *RancherClient
}
type ContainerProxyOperations interface {
List(opts *ListOpts) (*ContainerProxyCollection, error)
Create(opts *ContainerProxy) (*ContainerProxy, error)
Update(existing *ContainerProxy, updates interface{}) (*ContainerProxy, error)
ById(id string) (*ContainerProxy, error)
Delete(container *ContainerProxy) error
}
func newContainerProxyClient(rancherClient *RancherClient) *ContainerProxyClient {
return &ContainerProxyClient{
rancherClient: rancherClient,
}
}
func (c *ContainerProxyClient) Create(container *ContainerProxy) (*ContainerProxy, error) {
resp := &ContainerProxy{}
err := c.rancherClient.doCreate(CONTAINER_PROXY_TYPE, container, resp)
return resp, err
}
func (c *ContainerProxyClient) Update(existing *ContainerProxy, updates interface{}) (*ContainerProxy, error) {
resp := &ContainerProxy{}
err := c.rancherClient.doUpdate(CONTAINER_PROXY_TYPE, &existing.Resource, updates, resp)
return resp, err
}
func (c *ContainerProxyClient) List(opts *ListOpts) (*ContainerProxyCollection, error) {
resp := &ContainerProxyCollection{}
err := c.rancherClient.doList(CONTAINER_PROXY_TYPE, opts, resp)
return resp, err
}
func (c *ContainerProxyClient) ById(id string) (*ContainerProxy, error) {
resp := &ContainerProxy{}
err := c.rancherClient.doById(CONTAINER_PROXY_TYPE, id, resp)
if apiError, ok := err.(*ApiError); ok {
if apiError.StatusCode == 404 {
return nil, nil
}
}
return resp, err
}
func (c *ContainerProxyClient) Delete(container *ContainerProxy) error {
return c.rancherClient.doResourceDelete(CONTAINER_PROXY_TYPE, &container.Resource)
}

161
vendor/github.com/rancher/go-rancher/client/generated_credential.go generated vendored Normal file
View File

@ -0,0 +1,161 @@
package client
const (
CREDENTIAL_TYPE = "credential"
)
type Credential struct {
Resource
AccountId string `json:"accountId,omitempty" yaml:"account_id,omitempty"`
Created string `json:"created,omitempty" yaml:"created,omitempty"`
Data map[string]interface{} `json:"data,omitempty" yaml:"data,omitempty"`
Description string `json:"description,omitempty" yaml:"description,omitempty"`
Kind string `json:"kind,omitempty" yaml:"kind,omitempty"`
Name string `json:"name,omitempty" yaml:"name,omitempty"`
PublicValue string `json:"publicValue,omitempty" yaml:"public_value,omitempty"`
RemoveTime string `json:"removeTime,omitempty" yaml:"remove_time,omitempty"`
Removed string `json:"removed,omitempty" yaml:"removed,omitempty"`
SecretValue string `json:"secretValue,omitempty" yaml:"secret_value,omitempty"`
State string `json:"state,omitempty" yaml:"state,omitempty"`
Transitioning string `json:"transitioning,omitempty" yaml:"transitioning,omitempty"`
TransitioningMessage string `json:"transitioningMessage,omitempty" yaml:"transitioning_message,omitempty"`
TransitioningProgress int64 `json:"transitioningProgress,omitempty" yaml:"transitioning_progress,omitempty"`
Uuid string `json:"uuid,omitempty" yaml:"uuid,omitempty"`
}
type CredentialCollection struct {
Collection
Data []Credential `json:"data,omitempty"`
}
type CredentialClient struct {
rancherClient *RancherClient
}
type CredentialOperations interface {
List(opts *ListOpts) (*CredentialCollection, error)
Create(opts *Credential) (*Credential, error)
Update(existing *Credential, updates interface{}) (*Credential, error)
ById(id string) (*Credential, error)
Delete(container *Credential) error
ActionActivate(*Credential) (*Credential, error)
ActionCreate(*Credential) (*Credential, error)
ActionDeactivate(*Credential) (*Credential, error)
ActionPurge(*Credential) (*Credential, error)
ActionRemove(*Credential) (*Credential, error)
ActionUpdate(*Credential) (*Credential, error)
}
func newCredentialClient(rancherClient *RancherClient) *CredentialClient {
return &CredentialClient{
rancherClient: rancherClient,
}
}
func (c *CredentialClient) Create(container *Credential) (*Credential, error) {
resp := &Credential{}
err := c.rancherClient.doCreate(CREDENTIAL_TYPE, container, resp)
return resp, err
}
func (c *CredentialClient) Update(existing *Credential, updates interface{}) (*Credential, error) {
resp := &Credential{}
err := c.rancherClient.doUpdate(CREDENTIAL_TYPE, &existing.Resource, updates, resp)
return resp, err
}
func (c *CredentialClient) List(opts *ListOpts) (*CredentialCollection, error) {
resp := &CredentialCollection{}
err := c.rancherClient.doList(CREDENTIAL_TYPE, opts, resp)
return resp, err
}
func (c *CredentialClient) ById(id string) (*Credential, error) {
resp := &Credential{}
err := c.rancherClient.doById(CREDENTIAL_TYPE, id, resp)
if apiError, ok := err.(*ApiError); ok {
if apiError.StatusCode == 404 {
return nil, nil
}
}
return resp, err
}
func (c *CredentialClient) Delete(container *Credential) error {
return c.rancherClient.doResourceDelete(CREDENTIAL_TYPE, &container.Resource)
}
func (c *CredentialClient) ActionActivate(resource *Credential) (*Credential, error) {
resp := &Credential{}
err := c.rancherClient.doAction(CREDENTIAL_TYPE, "activate", &resource.Resource, nil, resp)
return resp, err
}
func (c *CredentialClient) ActionCreate(resource *Credential) (*Credential, error) {
resp := &Credential{}
err := c.rancherClient.doAction(CREDENTIAL_TYPE, "create", &resource.Resource, nil, resp)
return resp, err
}
func (c *CredentialClient) ActionDeactivate(resource *Credential) (*Credential, error) {
resp := &Credential{}
err := c.rancherClient.doAction(CREDENTIAL_TYPE, "deactivate", &resource.Resource, nil, resp)
return resp, err
}
func (c *CredentialClient) ActionPurge(resource *Credential) (*Credential, error) {
resp := &Credential{}
err := c.rancherClient.doAction(CREDENTIAL_TYPE, "purge", &resource.Resource, nil, resp)
return resp, err
}
func (c *CredentialClient) ActionRemove(resource *Credential) (*Credential, error) {
resp := &Credential{}
err := c.rancherClient.doAction(CREDENTIAL_TYPE, "remove", &resource.Resource, nil, resp)
return resp, err
}
func (c *CredentialClient) ActionUpdate(resource *Credential) (*Credential, error) {
resp := &Credential{}
err := c.rancherClient.doAction(CREDENTIAL_TYPE, "update", &resource.Resource, nil, resp)
return resp, err
}

85
vendor/github.com/rancher/go-rancher/client/generated_databasechangelog.go generated vendored Normal file
View File

@ -0,0 +1,85 @@
package client
const (
DATABASECHANGELOG_TYPE = "databasechangelog"
)
type Databasechangelog struct {
Resource
Author string `json:"author,omitempty" yaml:"author,omitempty"`
Comments string `json:"comments,omitempty" yaml:"comments,omitempty"`
Dateexecuted string `json:"dateexecuted,omitempty" yaml:"dateexecuted,omitempty"`
Description string `json:"description,omitempty" yaml:"description,omitempty"`
Exectype string `json:"exectype,omitempty" yaml:"exectype,omitempty"`
Filename string `json:"filename,omitempty" yaml:"filename,omitempty"`
Liquibase string `json:"liquibase,omitempty" yaml:"liquibase,omitempty"`
Md5sum string `json:"md5sum,omitempty" yaml:"md5sum,omitempty"`
Orderexecuted int64 `json:"orderexecuted,omitempty" yaml:"orderexecuted,omitempty"`
Tag string `json:"tag,omitempty" yaml:"tag,omitempty"`
}
type DatabasechangelogCollection struct {
Collection
Data []Databasechangelog `json:"data,omitempty"`
}
type DatabasechangelogClient struct {
rancherClient *RancherClient
}
type DatabasechangelogOperations interface {
List(opts *ListOpts) (*DatabasechangelogCollection, error)
Create(opts *Databasechangelog) (*Databasechangelog, error)
Update(existing *Databasechangelog, updates interface{}) (*Databasechangelog, error)
ById(id string) (*Databasechangelog, error)
Delete(container *Databasechangelog) error
}
func newDatabasechangelogClient(rancherClient *RancherClient) *DatabasechangelogClient {
return &DatabasechangelogClient{
rancherClient: rancherClient,
}
}
func (c *DatabasechangelogClient) Create(container *Databasechangelog) (*Databasechangelog, error) {
resp := &Databasechangelog{}
err := c.rancherClient.doCreate(DATABASECHANGELOG_TYPE, container, resp)
return resp, err
}
func (c *DatabasechangelogClient) Update(existing *Databasechangelog, updates interface{}) (*Databasechangelog, error) {
resp := &Databasechangelog{}
err := c.rancherClient.doUpdate(DATABASECHANGELOG_TYPE, &existing.Resource, updates, resp)
return resp, err
}
func (c *DatabasechangelogClient) List(opts *ListOpts) (*DatabasechangelogCollection, error) {
resp := &DatabasechangelogCollection{}
err := c.rancherClient.doList(DATABASECHANGELOG_TYPE, opts, resp)
return resp, err
}
func (c *DatabasechangelogClient) ById(id string) (*Databasechangelog, error) {
resp := &Databasechangelog{}
err := c.rancherClient.doById(DATABASECHANGELOG_TYPE, id, resp)
if apiError, ok := err.(*ApiError); ok {
if apiError.StatusCode == 404 {
return nil, nil
}
}
return resp, err
}
func (c *DatabasechangelogClient) Delete(container *Databasechangelog) error {
return c.rancherClient.doResourceDelete(DATABASECHANGELOG_TYPE, &container.Resource)
}

71
vendor/github.com/rancher/go-rancher/client/generated_databasechangeloglock.go generated vendored Normal file
View File

@ -0,0 +1,71 @@
package client
const (
DATABASECHANGELOGLOCK_TYPE = "databasechangeloglock"
)
type Databasechangeloglock struct {
Resource
Locked bool `json:"locked,omitempty" yaml:"locked,omitempty"`
Lockedby string `json:"lockedby,omitempty" yaml:"lockedby,omitempty"`
Lockgranted string `json:"lockgranted,omitempty" yaml:"lockgranted,omitempty"`
}
type DatabasechangeloglockCollection struct {
Collection
Data []Databasechangeloglock `json:"data,omitempty"`
}
type DatabasechangeloglockClient struct {
rancherClient *RancherClient
}
type DatabasechangeloglockOperations interface {
List(opts *ListOpts) (*DatabasechangeloglockCollection, error)
Create(opts *Databasechangeloglock) (*Databasechangeloglock, error)
Update(existing *Databasechangeloglock, updates interface{}) (*Databasechangeloglock, error)
ById(id string) (*Databasechangeloglock, error)
Delete(container *Databasechangeloglock) error
}
func newDatabasechangeloglockClient(rancherClient *RancherClient) *DatabasechangeloglockClient {
return &DatabasechangeloglockClient{
rancherClient: rancherClient,
}
}
func (c *DatabasechangeloglockClient) Create(container *Databasechangeloglock) (*Databasechangeloglock, error) {
resp := &Databasechangeloglock{}
err := c.rancherClient.doCreate(DATABASECHANGELOGLOCK_TYPE, container, resp)
return resp, err
}
func (c *DatabasechangeloglockClient) Update(existing *Databasechangeloglock, updates interface{}) (*Databasechangeloglock, error) {
resp := &Databasechangeloglock{}
err := c.rancherClient.doUpdate(DATABASECHANGELOGLOCK_TYPE, &existing.Resource, updates, resp)
return resp, err
}
func (c *DatabasechangeloglockClient) List(opts *ListOpts) (*DatabasechangeloglockCollection, error) {
resp := &DatabasechangeloglockCollection{}
err := c.rancherClient.doList(DATABASECHANGELOGLOCK_TYPE, opts, resp)
return resp, err
}
func (c *DatabasechangeloglockClient) ById(id string) (*Databasechangeloglock, error) {
resp := &Databasechangeloglock{}
err := c.rancherClient.doById(DATABASECHANGELOGLOCK_TYPE, id, resp)
if apiError, ok := err.(*ApiError); ok {
if apiError.StatusCode == 404 {
return nil, nil
}
}
return resp, err
}
func (c *DatabasechangeloglockClient) Delete(container *Databasechangeloglock) error {
return c.rancherClient.doResourceDelete(DATABASECHANGELOGLOCK_TYPE, &container.Resource)
}

87
vendor/github.com/rancher/go-rancher/client/generated_digitalocean_config.go generated vendored Normal file
View File

@ -0,0 +1,87 @@
package client
const (
DIGITALOCEAN_CONFIG_TYPE = "digitaloceanConfig"
)
type DigitaloceanConfig struct {
Resource
AccessToken string `json:"accessToken,omitempty" yaml:"access_token,omitempty"`
Backups bool `json:"backups,omitempty" yaml:"backups,omitempty"`
Image string `json:"image,omitempty" yaml:"image,omitempty"`
Ipv6 bool `json:"ipv6,omitempty" yaml:"ipv6,omitempty"`
PrivateNetworking bool `json:"privateNetworking,omitempty" yaml:"private_networking,omitempty"`
Region string `json:"region,omitempty" yaml:"region,omitempty"`
Size string `json:"size,omitempty" yaml:"size,omitempty"`
SshKeyFingerprint string `json:"sshKeyFingerprint,omitempty" yaml:"ssh_key_fingerprint,omitempty"`
SshPort string `json:"sshPort,omitempty" yaml:"ssh_port,omitempty"`
SshUser string `json:"sshUser,omitempty" yaml:"ssh_user,omitempty"`
Userdata string `json:"userdata,omitempty" yaml:"userdata,omitempty"`
}
type DigitaloceanConfigCollection struct {
Collection
Data []DigitaloceanConfig `json:"data,omitempty"`
}
type DigitaloceanConfigClient struct {
rancherClient *RancherClient
}
type DigitaloceanConfigOperations interface {
List(opts *ListOpts) (*DigitaloceanConfigCollection, error)
Create(opts *DigitaloceanConfig) (*DigitaloceanConfig, error)
Update(existing *DigitaloceanConfig, updates interface{}) (*DigitaloceanConfig, error)
ById(id string) (*DigitaloceanConfig, error)
Delete(container *DigitaloceanConfig) error
}
func newDigitaloceanConfigClient(rancherClient *RancherClient) *DigitaloceanConfigClient {
return &DigitaloceanConfigClient{
rancherClient: rancherClient,
}
}
func (c *DigitaloceanConfigClient) Create(container *DigitaloceanConfig) (*DigitaloceanConfig, error) {
resp := &DigitaloceanConfig{}
err := c.rancherClient.doCreate(DIGITALOCEAN_CONFIG_TYPE, container, resp)
return resp, err
}
func (c *DigitaloceanConfigClient) Update(existing *DigitaloceanConfig, updates interface{}) (*DigitaloceanConfig, error) {
resp := &DigitaloceanConfig{}
err := c.rancherClient.doUpdate(DIGITALOCEAN_CONFIG_TYPE, &existing.Resource, updates, resp)
return resp, err
}
func (c *DigitaloceanConfigClient) List(opts *ListOpts) (*DigitaloceanConfigCollection, error) {
resp := &DigitaloceanConfigCollection{}
err := c.rancherClient.doList(DIGITALOCEAN_CONFIG_TYPE, opts, resp)
return resp, err
}
func (c *DigitaloceanConfigClient) ById(id string) (*DigitaloceanConfig, error) {
resp := &DigitaloceanConfig{}
err := c.rancherClient.doById(DIGITALOCEAN_CONFIG_TYPE, id, resp)
if apiError, ok := err.(*ApiError); ok {
if apiError.StatusCode == 404 {
return nil, nil
}
}
return resp, err
}
func (c *DigitaloceanConfigClient) Delete(container *DigitaloceanConfig) error {
return c.rancherClient.doResourceDelete(DIGITALOCEAN_CONFIG_TYPE, &container.Resource)
}

267
vendor/github.com/rancher/go-rancher/client/generated_dns_service.go generated vendored Normal file
View File

@ -0,0 +1,267 @@
package client
const (
DNS_SERVICE_TYPE = "dnsService"
)
type DnsService struct {
Resource
AccountId string `json:"accountId,omitempty" yaml:"account_id,omitempty"`
AssignServiceIpAddress bool `json:"assignServiceIpAddress,omitempty" yaml:"assign_service_ip_address,omitempty"`
Created string `json:"created,omitempty" yaml:"created,omitempty"`
Data map[string]interface{} `json:"data,omitempty" yaml:"data,omitempty"`
Description string `json:"description,omitempty" yaml:"description,omitempty"`
EnvironmentId string `json:"environmentId,omitempty" yaml:"environment_id,omitempty"`
ExternalId string `json:"externalId,omitempty" yaml:"external_id,omitempty"`
Fqdn string `json:"fqdn,omitempty" yaml:"fqdn,omitempty"`
HealthState string `json:"healthState,omitempty" yaml:"health_state,omitempty"`
Kind string `json:"kind,omitempty" yaml:"kind,omitempty"`
LaunchConfig *LaunchConfig `json:"launchConfig,omitempty" yaml:"launch_config,omitempty"`
Metadata map[string]interface{} `json:"metadata,omitempty" yaml:"metadata,omitempty"`
Name string `json:"name,omitempty" yaml:"name,omitempty"`
RemoveTime string `json:"removeTime,omitempty" yaml:"remove_time,omitempty"`
Removed string `json:"removed,omitempty" yaml:"removed,omitempty"`
RetainIp bool `json:"retainIp,omitempty" yaml:"retain_ip,omitempty"`
SelectorLink string `json:"selectorLink,omitempty" yaml:"selector_link,omitempty"`
StartOnCreate bool `json:"startOnCreate,omitempty" yaml:"start_on_create,omitempty"`
State string `json:"state,omitempty" yaml:"state,omitempty"`
Transitioning string `json:"transitioning,omitempty" yaml:"transitioning,omitempty"`
TransitioningMessage string `json:"transitioningMessage,omitempty" yaml:"transitioning_message,omitempty"`
TransitioningProgress int64 `json:"transitioningProgress,omitempty" yaml:"transitioning_progress,omitempty"`
Upgrade *ServiceUpgrade `json:"upgrade,omitempty" yaml:"upgrade,omitempty"`
Uuid string `json:"uuid,omitempty" yaml:"uuid,omitempty"`
}
type DnsServiceCollection struct {
Collection
Data []DnsService `json:"data,omitempty"`
}
type DnsServiceClient struct {
rancherClient *RancherClient
}
type DnsServiceOperations interface {
List(opts *ListOpts) (*DnsServiceCollection, error)
Create(opts *DnsService) (*DnsService, error)
Update(existing *DnsService, updates interface{}) (*DnsService, error)
ById(id string) (*DnsService, error)
Delete(container *DnsService) error
ActionActivate(*DnsService) (*Service, error)
ActionAddservicelink(*DnsService, *AddRemoveServiceLinkInput) (*Service, error)
ActionCancelrollback(*DnsService) (*Service, error)
ActionCancelupgrade(*DnsService) (*Service, error)
ActionCreate(*DnsService) (*Service, error)
ActionDeactivate(*DnsService) (*Service, error)
ActionFinishupgrade(*DnsService) (*Service, error)
ActionRemove(*DnsService) (*Service, error)
ActionRemoveservicelink(*DnsService, *AddRemoveServiceLinkInput) (*Service, error)
ActionRestart(*DnsService, *ServiceRestart) (*Service, error)
ActionRollback(*DnsService) (*Service, error)
ActionSetservicelinks(*DnsService, *SetServiceLinksInput) (*Service, error)
ActionUpdate(*DnsService) (*Service, error)
ActionUpgrade(*DnsService, *ServiceUpgrade) (*Service, error)
}
func newDnsServiceClient(rancherClient *RancherClient) *DnsServiceClient {
return &DnsServiceClient{
rancherClient: rancherClient,
}
}
func (c *DnsServiceClient) Create(container *DnsService) (*DnsService, error) {
resp := &DnsService{}
err := c.rancherClient.doCreate(DNS_SERVICE_TYPE, container, resp)
return resp, err
}
func (c *DnsServiceClient) Update(existing *DnsService, updates interface{}) (*DnsService, error) {
resp := &DnsService{}
err := c.rancherClient.doUpdate(DNS_SERVICE_TYPE, &existing.Resource, updates, resp)
return resp, err
}
func (c *DnsServiceClient) List(opts *ListOpts) (*DnsServiceCollection, error) {
resp := &DnsServiceCollection{}
err := c.rancherClient.doList(DNS_SERVICE_TYPE, opts, resp)
return resp, err
}
func (c *DnsServiceClient) ById(id string) (*DnsService, error) {
resp := &DnsService{}
err := c.rancherClient.doById(DNS_SERVICE_TYPE, id, resp)
if apiError, ok := err.(*ApiError); ok {
if apiError.StatusCode == 404 {
return nil, nil
}
}
return resp, err
}
func (c *DnsServiceClient) Delete(container *DnsService) error {
return c.rancherClient.doResourceDelete(DNS_SERVICE_TYPE, &container.Resource)
}
func (c *DnsServiceClient) ActionActivate(resource *DnsService) (*Service, error) {
resp := &Service{}
err := c.rancherClient.doAction(DNS_SERVICE_TYPE, "activate", &resource.Resource, nil, resp)
return resp, err
}
func (c *DnsServiceClient) ActionAddservicelink(resource *DnsService, input *AddRemoveServiceLinkInput) (*Service, error) {
resp := &Service{}
err := c.rancherClient.doAction(DNS_SERVICE_TYPE, "addservicelink", &resource.Resource, input, resp)
return resp, err
}
func (c *DnsServiceClient) ActionCancelrollback(resource *DnsService) (*Service, error) {
resp := &Service{}
err := c.rancherClient.doAction(DNS_SERVICE_TYPE, "cancelrollback", &resource.Resource, nil, resp)
return resp, err
}
func (c *DnsServiceClient) ActionCancelupgrade(resource *DnsService) (*Service, error) {
resp := &Service{}
err := c.rancherClient.doAction(DNS_SERVICE_TYPE, "cancelupgrade", &resource.Resource, nil, resp)
return resp, err
}
func (c *DnsServiceClient) ActionCreate(resource *DnsService) (*Service, error) {
resp := &Service{}
err := c.rancherClient.doAction(DNS_SERVICE_TYPE, "create", &resource.Resource, nil, resp)
return resp, err
}
func (c *DnsServiceClient) ActionDeactivate(resource *DnsService) (*Service, error) {
resp := &Service{}
err := c.rancherClient.doAction(DNS_SERVICE_TYPE, "deactivate", &resource.Resource, nil, resp)
return resp, err
}
func (c *DnsServiceClient) ActionFinishupgrade(resource *DnsService) (*Service, error) {
resp := &Service{}
err := c.rancherClient.doAction(DNS_SERVICE_TYPE, "finishupgrade", &resource.Resource, nil, resp)
return resp, err
}
func (c *DnsServiceClient) ActionRemove(resource *DnsService) (*Service, error) {
resp := &Service{}
err := c.rancherClient.doAction(DNS_SERVICE_TYPE, "remove", &resource.Resource, nil, resp)
return resp, err
}
func (c *DnsServiceClient) ActionRemoveservicelink(resource *DnsService, input *AddRemoveServiceLinkInput) (*Service, error) {
resp := &Service{}
err := c.rancherClient.doAction(DNS_SERVICE_TYPE, "removeservicelink", &resource.Resource, input, resp)
return resp, err
}
func (c *DnsServiceClient) ActionRestart(resource *DnsService, input *ServiceRestart) (*Service, error) {
resp := &Service{}
err := c.rancherClient.doAction(DNS_SERVICE_TYPE, "restart", &resource.Resource, input, resp)
return resp, err
}
func (c *DnsServiceClient) ActionRollback(resource *DnsService) (*Service, error) {
resp := &Service{}
err := c.rancherClient.doAction(DNS_SERVICE_TYPE, "rollback", &resource.Resource, nil, resp)
return resp, err
}
func (c *DnsServiceClient) ActionSetservicelinks(resource *DnsService, input *SetServiceLinksInput) (*Service, error) {
resp := &Service{}
err := c.rancherClient.doAction(DNS_SERVICE_TYPE, "setservicelinks", &resource.Resource, input, resp)
return resp, err
}
func (c *DnsServiceClient) ActionUpdate(resource *DnsService) (*Service, error) {
resp := &Service{}
err := c.rancherClient.doAction(DNS_SERVICE_TYPE, "update", &resource.Resource, nil, resp)
return resp, err
}
func (c *DnsServiceClient) ActionUpgrade(resource *DnsService, input *ServiceUpgrade) (*Service, error) {
resp := &Service{}
err := c.rancherClient.doAction(DNS_SERVICE_TYPE, "upgrade", &resource.Resource, input, resp)
return resp, err
}

77
vendor/github.com/rancher/go-rancher/client/generated_docker_build.go generated vendored Normal file
View File

@ -0,0 +1,77 @@
package client
const (
DOCKER_BUILD_TYPE = "dockerBuild"
)
type DockerBuild struct {
Resource
Context string `json:"context,omitempty" yaml:"context,omitempty"`
Dockerfile string `json:"dockerfile,omitempty" yaml:"dockerfile,omitempty"`
Forcerm bool `json:"forcerm,omitempty" yaml:"forcerm,omitempty"`
Nocache bool `json:"nocache,omitempty" yaml:"nocache,omitempty"`
Remote string `json:"remote,omitempty" yaml:"remote,omitempty"`
Rm bool `json:"rm,omitempty" yaml:"rm,omitempty"`
}
type DockerBuildCollection struct {
Collection
Data []DockerBuild `json:"data,omitempty"`
}
type DockerBuildClient struct {
rancherClient *RancherClient
}
type DockerBuildOperations interface {
List(opts *ListOpts) (*DockerBuildCollection, error)
Create(opts *DockerBuild) (*DockerBuild, error)
Update(existing *DockerBuild, updates interface{}) (*DockerBuild, error)
ById(id string) (*DockerBuild, error)
Delete(container *DockerBuild) error
}
func newDockerBuildClient(rancherClient *RancherClient) *DockerBuildClient {
return &DockerBuildClient{
rancherClient: rancherClient,
}
}
func (c *DockerBuildClient) Create(container *DockerBuild) (*DockerBuild, error) {
resp := &DockerBuild{}
err := c.rancherClient.doCreate(DOCKER_BUILD_TYPE, container, resp)
return resp, err
}
func (c *DockerBuildClient) Update(existing *DockerBuild, updates interface{}) (*DockerBuild, error) {
resp := &DockerBuild{}
err := c.rancherClient.doUpdate(DOCKER_BUILD_TYPE, &existing.Resource, updates, resp)
return resp, err
}
func (c *DockerBuildClient) List(opts *ListOpts) (*DockerBuildCollection, error) {
resp := &DockerBuildCollection{}
err := c.rancherClient.doList(DOCKER_BUILD_TYPE, opts, resp)
return resp, err
}
func (c *DockerBuildClient) ById(id string) (*DockerBuild, error) {
resp := &DockerBuild{}
err := c.rancherClient.doById(DOCKER_BUILD_TYPE, id, resp)
if apiError, ok := err.(*ApiError); ok {
if apiError.StatusCode == 404 {
return nil, nil
}
}
return resp, err
}
func (c *DockerBuildClient) Delete(container *DockerBuild) error {
return c.rancherClient.doResourceDelete(DOCKER_BUILD_TYPE, &container.Resource)
}

117
vendor/github.com/rancher/go-rancher/client/generated_dynamic_schema.go generated vendored Normal file
View File

@ -0,0 +1,117 @@
package client
const (
DYNAMIC_SCHEMA_TYPE = "dynamicSchema"
)
type DynamicSchema struct {
Resource
AccountId string `json:"accountId,omitempty" yaml:"account_id,omitempty"`
Created string `json:"created,omitempty" yaml:"created,omitempty"`
Data map[string]interface{} `json:"data,omitempty" yaml:"data,omitempty"`
Definition string `json:"definition,omitempty" yaml:"definition,omitempty"`
Description string `json:"description,omitempty" yaml:"description,omitempty"`
Kind string `json:"kind,omitempty" yaml:"kind,omitempty"`
Name string `json:"name,omitempty" yaml:"name,omitempty"`
Parent string `json:"parent,omitempty" yaml:"parent,omitempty"`
Removed string `json:"removed,omitempty" yaml:"removed,omitempty"`
Roles []string `json:"roles,omitempty" yaml:"roles,omitempty"`
State string `json:"state,omitempty" yaml:"state,omitempty"`
Transitioning string `json:"transitioning,omitempty" yaml:"transitioning,omitempty"`
TransitioningMessage string `json:"transitioningMessage,omitempty" yaml:"transitioning_message,omitempty"`
TransitioningProgress int64 `json:"transitioningProgress,omitempty" yaml:"transitioning_progress,omitempty"`
Uuid string `json:"uuid,omitempty" yaml:"uuid,omitempty"`
}
type DynamicSchemaCollection struct {
Collection
Data []DynamicSchema `json:"data,omitempty"`
}
type DynamicSchemaClient struct {
rancherClient *RancherClient
}
type DynamicSchemaOperations interface {
List(opts *ListOpts) (*DynamicSchemaCollection, error)
Create(opts *DynamicSchema) (*DynamicSchema, error)
Update(existing *DynamicSchema, updates interface{}) (*DynamicSchema, error)
ById(id string) (*DynamicSchema, error)
Delete(container *DynamicSchema) error
ActionCreate(*DynamicSchema) (*DynamicSchema, error)
ActionRemove(*DynamicSchema) (*DynamicSchema, error)
}
func newDynamicSchemaClient(rancherClient *RancherClient) *DynamicSchemaClient {
return &DynamicSchemaClient{
rancherClient: rancherClient,
}
}
func (c *DynamicSchemaClient) Create(container *DynamicSchema) (*DynamicSchema, error) {
resp := &DynamicSchema{}
err := c.rancherClient.doCreate(DYNAMIC_SCHEMA_TYPE, container, resp)
return resp, err
}
func (c *DynamicSchemaClient) Update(existing *DynamicSchema, updates interface{}) (*DynamicSchema, error) {
resp := &DynamicSchema{}
err := c.rancherClient.doUpdate(DYNAMIC_SCHEMA_TYPE, &existing.Resource, updates, resp)
return resp, err
}
func (c *DynamicSchemaClient) List(opts *ListOpts) (*DynamicSchemaCollection, error) {
resp := &DynamicSchemaCollection{}
err := c.rancherClient.doList(DYNAMIC_SCHEMA_TYPE, opts, resp)
return resp, err
}
func (c *DynamicSchemaClient) ById(id string) (*DynamicSchema, error) {
resp := &DynamicSchema{}
err := c.rancherClient.doById(DYNAMIC_SCHEMA_TYPE, id, resp)
if apiError, ok := err.(*ApiError); ok {
if apiError.StatusCode == 404 {
return nil, nil
}
}
return resp, err
}
func (c *DynamicSchemaClient) Delete(container *DynamicSchema) error {
return c.rancherClient.doResourceDelete(DYNAMIC_SCHEMA_TYPE, &container.Resource)
}
func (c *DynamicSchemaClient) ActionCreate(resource *DynamicSchema) (*DynamicSchema, error) {
resp := &DynamicSchema{}
err := c.rancherClient.doAction(DYNAMIC_SCHEMA_TYPE, "create", &resource.Resource, nil, resp)
return resp, err
}
func (c *DynamicSchemaClient) ActionRemove(resource *DynamicSchema) (*DynamicSchema, error) {
resp := &DynamicSchema{}
err := c.rancherClient.doAction(DYNAMIC_SCHEMA_TYPE, "remove", &resource.Resource, nil, resp)
return resp, err
}

252
vendor/github.com/rancher/go-rancher/client/generated_environment.go generated vendored Normal file
View File

@ -0,0 +1,252 @@
package client
const (
ENVIRONMENT_TYPE = "environment"
)
type Environment struct {
Resource
AccountId string `json:"accountId,omitempty" yaml:"account_id,omitempty"`
Created string `json:"created,omitempty" yaml:"created,omitempty"`
Data map[string]interface{} `json:"data,omitempty" yaml:"data,omitempty"`
Description string `json:"description,omitempty" yaml:"description,omitempty"`
DockerCompose string `json:"dockerCompose,omitempty" yaml:"docker_compose,omitempty"`
Environment map[string]interface{} `json:"environment,omitempty" yaml:"environment,omitempty"`
ExternalId string `json:"externalId,omitempty" yaml:"external_id,omitempty"`
HealthState string `json:"healthState,omitempty" yaml:"health_state,omitempty"`
Kind string `json:"kind,omitempty" yaml:"kind,omitempty"`
Name string `json:"name,omitempty" yaml:"name,omitempty"`
Outputs map[string]interface{} `json:"outputs,omitempty" yaml:"outputs,omitempty"`
PreviousEnvironment map[string]interface{} `json:"previousEnvironment,omitempty" yaml:"previous_environment,omitempty"`
PreviousExternalId string `json:"previousExternalId,omitempty" yaml:"previous_external_id,omitempty"`
RancherCompose string `json:"rancherCompose,omitempty" yaml:"rancher_compose,omitempty"`
RemoveTime string `json:"removeTime,omitempty" yaml:"remove_time,omitempty"`
Removed string `json:"removed,omitempty" yaml:"removed,omitempty"`
StartOnCreate bool `json:"startOnCreate,omitempty" yaml:"start_on_create,omitempty"`
State string `json:"state,omitempty" yaml:"state,omitempty"`
Transitioning string `json:"transitioning,omitempty" yaml:"transitioning,omitempty"`
TransitioningMessage string `json:"transitioningMessage,omitempty" yaml:"transitioning_message,omitempty"`
TransitioningProgress int64 `json:"transitioningProgress,omitempty" yaml:"transitioning_progress,omitempty"`
Uuid string `json:"uuid,omitempty" yaml:"uuid,omitempty"`
}
type EnvironmentCollection struct {
Collection
Data []Environment `json:"data,omitempty"`
}
type EnvironmentClient struct {
rancherClient *RancherClient
}
type EnvironmentOperations interface {
List(opts *ListOpts) (*EnvironmentCollection, error)
Create(opts *Environment) (*Environment, error)
Update(existing *Environment, updates interface{}) (*Environment, error)
ById(id string) (*Environment, error)
Delete(container *Environment) error
ActionActivateservices(*Environment) (*Environment, error)
ActionAddoutputs(*Environment, *AddOutputsInput) (*Environment, error)
ActionCancelrollback(*Environment) (*Environment, error)
ActionCancelupgrade(*Environment) (*Environment, error)
ActionCreate(*Environment) (*Environment, error)
ActionDeactivateservices(*Environment) (*Environment, error)
ActionError(*Environment) (*Environment, error)
ActionExportconfig(*Environment, *ComposeConfigInput) (*ComposeConfig, error)
ActionFinishupgrade(*Environment) (*Environment, error)
ActionRemove(*Environment) (*Environment, error)
ActionRollback(*Environment) (*Environment, error)
ActionUpdate(*Environment) (*Environment, error)
ActionUpgrade(*Environment, *EnvironmentUpgrade) (*Environment, error)
}
func newEnvironmentClient(rancherClient *RancherClient) *EnvironmentClient {
return &EnvironmentClient{
rancherClient: rancherClient,
}
}
func (c *EnvironmentClient) Create(container *Environment) (*Environment, error) {
resp := &Environment{}
err := c.rancherClient.doCreate(ENVIRONMENT_TYPE, container, resp)
return resp, err
}
func (c *EnvironmentClient) Update(existing *Environment, updates interface{}) (*Environment, error) {
resp := &Environment{}
err := c.rancherClient.doUpdate(ENVIRONMENT_TYPE, &existing.Resource, updates, resp)
return resp, err
}
func (c *EnvironmentClient) List(opts *ListOpts) (*EnvironmentCollection, error) {
resp := &EnvironmentCollection{}
err := c.rancherClient.doList(ENVIRONMENT_TYPE, opts, resp)
return resp, err
}
func (c *EnvironmentClient) ById(id string) (*Environment, error) {
resp := &Environment{}
err := c.rancherClient.doById(ENVIRONMENT_TYPE, id, resp)
if apiError, ok := err.(*ApiError); ok {
if apiError.StatusCode == 404 {
return nil, nil
}
}
return resp, err
}
func (c *EnvironmentClient) Delete(container *Environment) error {
return c.rancherClient.doResourceDelete(ENVIRONMENT_TYPE, &container.Resource)
}
func (c *EnvironmentClient) ActionActivateservices(resource *Environment) (*Environment, error) {
resp := &Environment{}
err := c.rancherClient.doAction(ENVIRONMENT_TYPE, "activateservices", &resource.Resource, nil, resp)
return resp, err
}
func (c *EnvironmentClient) ActionAddoutputs(resource *Environment, input *AddOutputsInput) (*Environment, error) {
resp := &Environment{}
err := c.rancherClient.doAction(ENVIRONMENT_TYPE, "addoutputs", &resource.Resource, input, resp)
return resp, err
}
func (c *EnvironmentClient) ActionCancelrollback(resource *Environment) (*Environment, error) {
resp := &Environment{}
err := c.rancherClient.doAction(ENVIRONMENT_TYPE, "cancelrollback", &resource.Resource, nil, resp)
return resp, err
}
func (c *EnvironmentClient) ActionCancelupgrade(resource *Environment) (*Environment, error) {
resp := &Environment{}
err := c.rancherClient.doAction(ENVIRONMENT_TYPE, "cancelupgrade", &resource.Resource, nil, resp)
return resp, err
}
func (c *EnvironmentClient) ActionCreate(resource *Environment) (*Environment, error) {
resp := &Environment{}
err := c.rancherClient.doAction(ENVIRONMENT_TYPE, "create", &resource.Resource, nil, resp)
return resp, err
}
func (c *EnvironmentClient) ActionDeactivateservices(resource *Environment) (*Environment, error) {
resp := &Environment{}
err := c.rancherClient.doAction(ENVIRONMENT_TYPE, "deactivateservices", &resource.Resource, nil, resp)
return resp, err
}
func (c *EnvironmentClient) ActionError(resource *Environment) (*Environment, error) {
resp := &Environment{}
err := c.rancherClient.doAction(ENVIRONMENT_TYPE, "error", &resource.Resource, nil, resp)
return resp, err
}
func (c *EnvironmentClient) ActionExportconfig(resource *Environment, input *ComposeConfigInput) (*ComposeConfig, error) {
resp := &ComposeConfig{}
err := c.rancherClient.doAction(ENVIRONMENT_TYPE, "exportconfig", &resource.Resource, input, resp)
return resp, err
}
func (c *EnvironmentClient) ActionFinishupgrade(resource *Environment) (*Environment, error) {
resp := &Environment{}
err := c.rancherClient.doAction(ENVIRONMENT_TYPE, "finishupgrade", &resource.Resource, nil, resp)
return resp, err
}
func (c *EnvironmentClient) ActionRemove(resource *Environment) (*Environment, error) {
resp := &Environment{}
err := c.rancherClient.doAction(ENVIRONMENT_TYPE, "remove", &resource.Resource, nil, resp)
return resp, err
}
func (c *EnvironmentClient) ActionRollback(resource *Environment) (*Environment, error) {
resp := &Environment{}
err := c.rancherClient.doAction(ENVIRONMENT_TYPE, "rollback", &resource.Resource, nil, resp)
return resp, err
}
func (c *EnvironmentClient) ActionUpdate(resource *Environment) (*Environment, error) {
resp := &Environment{}
err := c.rancherClient.doAction(ENVIRONMENT_TYPE, "update", &resource.Resource, nil, resp)
return resp, err
}
func (c *EnvironmentClient) ActionUpgrade(resource *Environment, input *EnvironmentUpgrade) (*Environment, error) {
resp := &Environment{}
err := c.rancherClient.doAction(ENVIRONMENT_TYPE, "upgrade", &resource.Resource, input, resp)
return resp, err
}

73
vendor/github.com/rancher/go-rancher/client/generated_environment_upgrade.go generated vendored Normal file
View File

@ -0,0 +1,73 @@
package client
const (
ENVIRONMENT_UPGRADE_TYPE = "environmentUpgrade"
)
type EnvironmentUpgrade struct {
Resource
DockerCompose string `json:"dockerCompose,omitempty" yaml:"docker_compose,omitempty"`
Environment map[string]interface{} `json:"environment,omitempty" yaml:"environment,omitempty"`
ExternalId string `json:"externalId,omitempty" yaml:"external_id,omitempty"`
RancherCompose string `json:"rancherCompose,omitempty" yaml:"rancher_compose,omitempty"`
}
type EnvironmentUpgradeCollection struct {
Collection
Data []EnvironmentUpgrade `json:"data,omitempty"`
}
type EnvironmentUpgradeClient struct {
rancherClient *RancherClient
}
type EnvironmentUpgradeOperations interface {
List(opts *ListOpts) (*EnvironmentUpgradeCollection, error)
Create(opts *EnvironmentUpgrade) (*EnvironmentUpgrade, error)
Update(existing *EnvironmentUpgrade, updates interface{}) (*EnvironmentUpgrade, error)
ById(id string) (*EnvironmentUpgrade, error)
Delete(container *EnvironmentUpgrade) error
}
func newEnvironmentUpgradeClient(rancherClient *RancherClient) *EnvironmentUpgradeClient {
return &EnvironmentUpgradeClient{
rancherClient: rancherClient,
}
}
func (c *EnvironmentUpgradeClient) Create(container *EnvironmentUpgrade) (*EnvironmentUpgrade, error) {
resp := &EnvironmentUpgrade{}
err := c.rancherClient.doCreate(ENVIRONMENT_UPGRADE_TYPE, container, resp)
return resp, err
}
func (c *EnvironmentUpgradeClient) Update(existing *EnvironmentUpgrade, updates interface{}) (*EnvironmentUpgrade, error) {
resp := &EnvironmentUpgrade{}
err := c.rancherClient.doUpdate(ENVIRONMENT_UPGRADE_TYPE, &existing.Resource, updates, resp)
return resp, err
}
func (c *EnvironmentUpgradeClient) List(opts *ListOpts) (*EnvironmentUpgradeCollection, error) {
resp := &EnvironmentUpgradeCollection{}
err := c.rancherClient.doList(ENVIRONMENT_UPGRADE_TYPE, opts, resp)
return resp, err
}
func (c *EnvironmentUpgradeClient) ById(id string) (*EnvironmentUpgrade, error) {
resp := &EnvironmentUpgrade{}
err := c.rancherClient.doById(ENVIRONMENT_UPGRADE_TYPE, id, resp)
if apiError, ok := err.(*ApiError); ok {
if apiError.StatusCode == 404 {
return nil, nil
}
}
return resp, err
}
func (c *EnvironmentUpgradeClient) Delete(container *EnvironmentUpgrade) error {
return c.rancherClient.doResourceDelete(ENVIRONMENT_UPGRADE_TYPE, &container.Resource)
}

71
vendor/github.com/rancher/go-rancher/client/generated_extension_implementation.go generated vendored Normal file
View File

@ -0,0 +1,71 @@
package client
const (
EXTENSION_IMPLEMENTATION_TYPE = "extensionImplementation"
)
type ExtensionImplementation struct {
Resource
ClassName string `json:"className,omitempty" yaml:"class_name,omitempty"`
Name string `json:"name,omitempty" yaml:"name,omitempty"`
Properties map[string]interface{} `json:"properties,omitempty" yaml:"properties,omitempty"`
}
type ExtensionImplementationCollection struct {
Collection
Data []ExtensionImplementation `json:"data,omitempty"`
}
type ExtensionImplementationClient struct {
rancherClient *RancherClient
}
type ExtensionImplementationOperations interface {
List(opts *ListOpts) (*ExtensionImplementationCollection, error)
Create(opts *ExtensionImplementation) (*ExtensionImplementation, error)
Update(existing *ExtensionImplementation, updates interface{}) (*ExtensionImplementation, error)
ById(id string) (*ExtensionImplementation, error)
Delete(container *ExtensionImplementation) error
}
func newExtensionImplementationClient(rancherClient *RancherClient) *ExtensionImplementationClient {
return &ExtensionImplementationClient{
rancherClient: rancherClient,
}
}
func (c *ExtensionImplementationClient) Create(container *ExtensionImplementation) (*ExtensionImplementation, error) {
resp := &ExtensionImplementation{}
err := c.rancherClient.doCreate(EXTENSION_IMPLEMENTATION_TYPE, container, resp)
return resp, err
}
func (c *ExtensionImplementationClient) Update(existing *ExtensionImplementation, updates interface{}) (*ExtensionImplementation, error) {
resp := &ExtensionImplementation{}
err := c.rancherClient.doUpdate(EXTENSION_IMPLEMENTATION_TYPE, &existing.Resource, updates, resp)
return resp, err
}
func (c *ExtensionImplementationClient) List(opts *ListOpts) (*ExtensionImplementationCollection, error) {
resp := &ExtensionImplementationCollection{}
err := c.rancherClient.doList(EXTENSION_IMPLEMENTATION_TYPE, opts, resp)
return resp, err
}
func (c *ExtensionImplementationClient) ById(id string) (*ExtensionImplementation, error) {
resp := &ExtensionImplementation{}
err := c.rancherClient.doById(EXTENSION_IMPLEMENTATION_TYPE, id, resp)
if apiError, ok := err.(*ApiError); ok {
if apiError.StatusCode == 404 {
return nil, nil
}
}
return resp, err
}
func (c *ExtensionImplementationClient) Delete(container *ExtensionImplementation) error {
return c.rancherClient.doResourceDelete(EXTENSION_IMPLEMENTATION_TYPE, &container.Resource)
}

75
vendor/github.com/rancher/go-rancher/client/generated_extension_point.go generated vendored Normal file
View File

@ -0,0 +1,75 @@
package client
const (
EXTENSION_POINT_TYPE = "extensionPoint"
)
type ExtensionPoint struct {
Resource
ExcludeSetting string `json:"excludeSetting,omitempty" yaml:"exclude_setting,omitempty"`
Implementations []interface{} `json:"implementations,omitempty" yaml:"implementations,omitempty"`
IncludeSetting string `json:"includeSetting,omitempty" yaml:"include_setting,omitempty"`
ListSetting string `json:"listSetting,omitempty" yaml:"list_setting,omitempty"`
Name string `json:"name,omitempty" yaml:"name,omitempty"`
}
type ExtensionPointCollection struct {
Collection
Data []ExtensionPoint `json:"data,omitempty"`
}
type ExtensionPointClient struct {
rancherClient *RancherClient
}
type ExtensionPointOperations interface {
List(opts *ListOpts) (*ExtensionPointCollection, error)
Create(opts *ExtensionPoint) (*ExtensionPoint, error)
Update(existing *ExtensionPoint, updates interface{}) (*ExtensionPoint, error)
ById(id string) (*ExtensionPoint, error)
Delete(container *ExtensionPoint) error
}
func newExtensionPointClient(rancherClient *RancherClient) *ExtensionPointClient {
return &ExtensionPointClient{
rancherClient: rancherClient,
}
}
func (c *ExtensionPointClient) Create(container *ExtensionPoint) (*ExtensionPoint, error) {
resp := &ExtensionPoint{}
err := c.rancherClient.doCreate(EXTENSION_POINT_TYPE, container, resp)
return resp, err
}
func (c *ExtensionPointClient) Update(existing *ExtensionPoint, updates interface{}) (*ExtensionPoint, error) {
resp := &ExtensionPoint{}
err := c.rancherClient.doUpdate(EXTENSION_POINT_TYPE, &existing.Resource, updates, resp)
return resp, err
}
func (c *ExtensionPointClient) List(opts *ListOpts) (*ExtensionPointCollection, error) {
resp := &ExtensionPointCollection{}
err := c.rancherClient.doList(EXTENSION_POINT_TYPE, opts, resp)
return resp, err
}
func (c *ExtensionPointClient) ById(id string) (*ExtensionPoint, error) {
resp := &ExtensionPoint{}
err := c.rancherClient.doById(EXTENSION_POINT_TYPE, id, resp)
if apiError, ok := err.(*ApiError); ok {
if apiError.StatusCode == 404 {
return nil, nil
}
}
return resp, err
}
func (c *ExtensionPointClient) Delete(container *ExtensionPoint) error {
return c.rancherClient.doResourceDelete(EXTENSION_POINT_TYPE, &container.Resource)
}

117
vendor/github.com/rancher/go-rancher/client/generated_external_dns_event.go generated vendored Normal file
View File

@ -0,0 +1,117 @@
package client
const (
EXTERNAL_DNS_EVENT_TYPE = "externalDnsEvent"
)
type ExternalDnsEvent struct {
Resource
AccountId string `json:"accountId,omitempty" yaml:"account_id,omitempty"`
Created string `json:"created,omitempty" yaml:"created,omitempty"`
Data map[string]interface{} `json:"data,omitempty" yaml:"data,omitempty"`
EventType string `json:"eventType,omitempty" yaml:"event_type,omitempty"`
ExternalId string `json:"externalId,omitempty" yaml:"external_id,omitempty"`
Fqdn string `json:"fqdn,omitempty" yaml:"fqdn,omitempty"`
Kind string `json:"kind,omitempty" yaml:"kind,omitempty"`
ReportedAccountId string `json:"reportedAccountId,omitempty" yaml:"reported_account_id,omitempty"`
ServiceName string `json:"serviceName,omitempty" yaml:"service_name,omitempty"`
StackName string `json:"stackName,omitempty" yaml:"stack_name,omitempty"`
State string `json:"state,omitempty" yaml:"state,omitempty"`
Transitioning string `json:"transitioning,omitempty" yaml:"transitioning,omitempty"`
TransitioningMessage string `json:"transitioningMessage,omitempty" yaml:"transitioning_message,omitempty"`
TransitioningProgress int64 `json:"transitioningProgress,omitempty" yaml:"transitioning_progress,omitempty"`
Uuid string `json:"uuid,omitempty" yaml:"uuid,omitempty"`
}
type ExternalDnsEventCollection struct {
Collection
Data []ExternalDnsEvent `json:"data,omitempty"`
}
type ExternalDnsEventClient struct {
rancherClient *RancherClient
}
type ExternalDnsEventOperations interface {
List(opts *ListOpts) (*ExternalDnsEventCollection, error)
Create(opts *ExternalDnsEvent) (*ExternalDnsEvent, error)
Update(existing *ExternalDnsEvent, updates interface{}) (*ExternalDnsEvent, error)
ById(id string) (*ExternalDnsEvent, error)
Delete(container *ExternalDnsEvent) error
ActionCreate(*ExternalDnsEvent) (*ExternalEvent, error)
ActionRemove(*ExternalDnsEvent) (*ExternalEvent, error)
}
func newExternalDnsEventClient(rancherClient *RancherClient) *ExternalDnsEventClient {
return &ExternalDnsEventClient{
rancherClient: rancherClient,
}
}
func (c *ExternalDnsEventClient) Create(container *ExternalDnsEvent) (*ExternalDnsEvent, error) {
resp := &ExternalDnsEvent{}
err := c.rancherClient.doCreate(EXTERNAL_DNS_EVENT_TYPE, container, resp)
return resp, err
}
func (c *ExternalDnsEventClient) Update(existing *ExternalDnsEvent, updates interface{}) (*ExternalDnsEvent, error) {
resp := &ExternalDnsEvent{}
err := c.rancherClient.doUpdate(EXTERNAL_DNS_EVENT_TYPE, &existing.Resource, updates, resp)
return resp, err
}
func (c *ExternalDnsEventClient) List(opts *ListOpts) (*ExternalDnsEventCollection, error) {
resp := &ExternalDnsEventCollection{}
err := c.rancherClient.doList(EXTERNAL_DNS_EVENT_TYPE, opts, resp)
return resp, err
}
func (c *ExternalDnsEventClient) ById(id string) (*ExternalDnsEvent, error) {
resp := &ExternalDnsEvent{}
err := c.rancherClient.doById(EXTERNAL_DNS_EVENT_TYPE, id, resp)
if apiError, ok := err.(*ApiError); ok {
if apiError.StatusCode == 404 {
return nil, nil
}
}
return resp, err
}
func (c *ExternalDnsEventClient) Delete(container *ExternalDnsEvent) error {
return c.rancherClient.doResourceDelete(EXTERNAL_DNS_EVENT_TYPE, &container.Resource)
}
func (c *ExternalDnsEventClient) ActionCreate(resource *ExternalDnsEvent) (*ExternalEvent, error) {
resp := &ExternalEvent{}
err := c.rancherClient.doAction(EXTERNAL_DNS_EVENT_TYPE, "create", &resource.Resource, nil, resp)
return resp, err
}
func (c *ExternalDnsEventClient) ActionRemove(resource *ExternalDnsEvent) (*ExternalEvent, error) {
resp := &ExternalEvent{}
err := c.rancherClient.doAction(EXTERNAL_DNS_EVENT_TYPE, "remove", &resource.Resource, nil, resp)
return resp, err
}

111
vendor/github.com/rancher/go-rancher/client/generated_external_event.go generated vendored Normal file
View File

@ -0,0 +1,111 @@
package client
const (
EXTERNAL_EVENT_TYPE = "externalEvent"
)
type ExternalEvent struct {
Resource
AccountId string `json:"accountId,omitempty" yaml:"account_id,omitempty"`
Created string `json:"created,omitempty" yaml:"created,omitempty"`
Data map[string]interface{} `json:"data,omitempty" yaml:"data,omitempty"`
EventType string `json:"eventType,omitempty" yaml:"event_type,omitempty"`
ExternalId string `json:"externalId,omitempty" yaml:"external_id,omitempty"`
Kind string `json:"kind,omitempty" yaml:"kind,omitempty"`
ReportedAccountId string `json:"reportedAccountId,omitempty" yaml:"reported_account_id,omitempty"`
State string `json:"state,omitempty" yaml:"state,omitempty"`
Transitioning string `json:"transitioning,omitempty" yaml:"transitioning,omitempty"`
TransitioningMessage string `json:"transitioningMessage,omitempty" yaml:"transitioning_message,omitempty"`
TransitioningProgress int64 `json:"transitioningProgress,omitempty" yaml:"transitioning_progress,omitempty"`
Uuid string `json:"uuid,omitempty" yaml:"uuid,omitempty"`
}
type ExternalEventCollection struct {
Collection
Data []ExternalEvent `json:"data,omitempty"`
}
type ExternalEventClient struct {
rancherClient *RancherClient
}
type ExternalEventOperations interface {
List(opts *ListOpts) (*ExternalEventCollection, error)
Create(opts *ExternalEvent) (*ExternalEvent, error)
Update(existing *ExternalEvent, updates interface{}) (*ExternalEvent, error)
ById(id string) (*ExternalEvent, error)
Delete(container *ExternalEvent) error
ActionCreate(*ExternalEvent) (*ExternalEvent, error)
ActionRemove(*ExternalEvent) (*ExternalEvent, error)
}
func newExternalEventClient(rancherClient *RancherClient) *ExternalEventClient {
return &ExternalEventClient{
rancherClient: rancherClient,
}
}
func (c *ExternalEventClient) Create(container *ExternalEvent) (*ExternalEvent, error) {
resp := &ExternalEvent{}
err := c.rancherClient.doCreate(EXTERNAL_EVENT_TYPE, container, resp)
return resp, err
}
func (c *ExternalEventClient) Update(existing *ExternalEvent, updates interface{}) (*ExternalEvent, error) {
resp := &ExternalEvent{}
err := c.rancherClient.doUpdate(EXTERNAL_EVENT_TYPE, &existing.Resource, updates, resp)
return resp, err
}
func (c *ExternalEventClient) List(opts *ListOpts) (*ExternalEventCollection, error) {
resp := &ExternalEventCollection{}
err := c.rancherClient.doList(EXTERNAL_EVENT_TYPE, opts, resp)
return resp, err
}
func (c *ExternalEventClient) ById(id string) (*ExternalEvent, error) {
resp := &ExternalEvent{}
err := c.rancherClient.doById(EXTERNAL_EVENT_TYPE, id, resp)
if apiError, ok := err.(*ApiError); ok {
if apiError.StatusCode == 404 {
return nil, nil
}
}
return resp, err
}
func (c *ExternalEventClient) Delete(container *ExternalEvent) error {
return c.rancherClient.doResourceDelete(EXTERNAL_EVENT_TYPE, &container.Resource)
}
func (c *ExternalEventClient) ActionCreate(resource *ExternalEvent) (*ExternalEvent, error) {
resp := &ExternalEvent{}
err := c.rancherClient.doAction(EXTERNAL_EVENT_TYPE, "create", &resource.Resource, nil, resp)
return resp, err
}
func (c *ExternalEventClient) ActionRemove(resource *ExternalEvent) (*ExternalEvent, error) {
resp := &ExternalEvent{}
err := c.rancherClient.doAction(EXTERNAL_EVENT_TYPE, "remove", &resource.Resource, nil, resp)
return resp, err
}

174
vendor/github.com/rancher/go-rancher/client/generated_external_handler.go generated vendored Normal file
View File

@ -0,0 +1,174 @@
package client
const (
EXTERNAL_HANDLER_TYPE = "externalHandler"
)
type ExternalHandler struct {
Resource
Created string `json:"created,omitempty" yaml:"created,omitempty"`
Data map[string]interface{} `json:"data,omitempty" yaml:"data,omitempty"`
Description string `json:"description,omitempty" yaml:"description,omitempty"`
Kind string `json:"kind,omitempty" yaml:"kind,omitempty"`
Name string `json:"name,omitempty" yaml:"name,omitempty"`
Priority int64 `json:"priority,omitempty" yaml:"priority,omitempty"`
ProcessConfigs []interface{} `json:"processConfigs,omitempty" yaml:"process_configs,omitempty"`
RemoveTime string `json:"removeTime,omitempty" yaml:"remove_time,omitempty"`
Removed string `json:"removed,omitempty" yaml:"removed,omitempty"`
Retries int64 `json:"retries,omitempty" yaml:"retries,omitempty"`
State string `json:"state,omitempty" yaml:"state,omitempty"`
TimeoutMillis int64 `json:"timeoutMillis,omitempty" yaml:"timeout_millis,omitempty"`
Transitioning string `json:"transitioning,omitempty" yaml:"transitioning,omitempty"`
TransitioningMessage string `json:"transitioningMessage,omitempty" yaml:"transitioning_message,omitempty"`
TransitioningProgress int64 `json:"transitioningProgress,omitempty" yaml:"transitioning_progress,omitempty"`
Uuid string `json:"uuid,omitempty" yaml:"uuid,omitempty"`
}
type ExternalHandlerCollection struct {
Collection
Data []ExternalHandler `json:"data,omitempty"`
}
type ExternalHandlerClient struct {
rancherClient *RancherClient
}
type ExternalHandlerOperations interface {
List(opts *ListOpts) (*ExternalHandlerCollection, error)
Create(opts *ExternalHandler) (*ExternalHandler, error)
Update(existing *ExternalHandler, updates interface{}) (*ExternalHandler, error)
ById(id string) (*ExternalHandler, error)
Delete(container *ExternalHandler) error
ActionActivate(*ExternalHandler) (*ExternalHandler, error)
ActionCreate(*ExternalHandler) (*ExternalHandler, error)
ActionDeactivate(*ExternalHandler) (*ExternalHandler, error)
ActionPurge(*ExternalHandler) (*ExternalHandler, error)
ActionRemove(*ExternalHandler) (*ExternalHandler, error)
ActionRestore(*ExternalHandler) (*ExternalHandler, error)
ActionUpdate(*ExternalHandler) (*ExternalHandler, error)
}
func newExternalHandlerClient(rancherClient *RancherClient) *ExternalHandlerClient {
return &ExternalHandlerClient{
rancherClient: rancherClient,
}
}
func (c *ExternalHandlerClient) Create(container *ExternalHandler) (*ExternalHandler, error) {
resp := &ExternalHandler{}
err := c.rancherClient.doCreate(EXTERNAL_HANDLER_TYPE, container, resp)
return resp, err
}
func (c *ExternalHandlerClient) Update(existing *ExternalHandler, updates interface{}) (*ExternalHandler, error) {
resp := &ExternalHandler{}
err := c.rancherClient.doUpdate(EXTERNAL_HANDLER_TYPE, &existing.Resource, updates, resp)
return resp, err
}
func (c *ExternalHandlerClient) List(opts *ListOpts) (*ExternalHandlerCollection, error) {
resp := &ExternalHandlerCollection{}
err := c.rancherClient.doList(EXTERNAL_HANDLER_TYPE, opts, resp)
return resp, err
}
func (c *ExternalHandlerClient) ById(id string) (*ExternalHandler, error) {
resp := &ExternalHandler{}
err := c.rancherClient.doById(EXTERNAL_HANDLER_TYPE, id, resp)
if apiError, ok := err.(*ApiError); ok {
if apiError.StatusCode == 404 {
return nil, nil
}
}
return resp, err
}
func (c *ExternalHandlerClient) Delete(container *ExternalHandler) error {
return c.rancherClient.doResourceDelete(EXTERNAL_HANDLER_TYPE, &container.Resource)
}
func (c *ExternalHandlerClient) ActionActivate(resource *ExternalHandler) (*ExternalHandler, error) {
resp := &ExternalHandler{}
err := c.rancherClient.doAction(EXTERNAL_HANDLER_TYPE, "activate", &resource.Resource, nil, resp)
return resp, err
}
func (c *ExternalHandlerClient) ActionCreate(resource *ExternalHandler) (*ExternalHandler, error) {
resp := &ExternalHandler{}
err := c.rancherClient.doAction(EXTERNAL_HANDLER_TYPE, "create", &resource.Resource, nil, resp)
return resp, err
}
func (c *ExternalHandlerClient) ActionDeactivate(resource *ExternalHandler) (*ExternalHandler, error) {
resp := &ExternalHandler{}
err := c.rancherClient.doAction(EXTERNAL_HANDLER_TYPE, "deactivate", &resource.Resource, nil, resp)
return resp, err
}
func (c *ExternalHandlerClient) ActionPurge(resource *ExternalHandler) (*ExternalHandler, error) {
resp := &ExternalHandler{}
err := c.rancherClient.doAction(EXTERNAL_HANDLER_TYPE, "purge", &resource.Resource, nil, resp)
return resp, err
}
func (c *ExternalHandlerClient) ActionRemove(resource *ExternalHandler) (*ExternalHandler, error) {
resp := &ExternalHandler{}
err := c.rancherClient.doAction(EXTERNAL_HANDLER_TYPE, "remove", &resource.Resource, nil, resp)
return resp, err
}
func (c *ExternalHandlerClient) ActionRestore(resource *ExternalHandler) (*ExternalHandler, error) {
resp := &ExternalHandler{}
err := c.rancherClient.doAction(EXTERNAL_HANDLER_TYPE, "restore", &resource.Resource, nil, resp)
return resp, err
}
func (c *ExternalHandlerClient) ActionUpdate(resource *ExternalHandler) (*ExternalHandler, error) {
resp := &ExternalHandler{}
err := c.rancherClient.doAction(EXTERNAL_HANDLER_TYPE, "update", &resource.Resource, nil, resp)
return resp, err
}

172
vendor/github.com/rancher/go-rancher/client/generated_external_handler_external_handler_process_map.go generated vendored Normal file
View File

@ -0,0 +1,172 @@
package client
const (
EXTERNAL_HANDLER_EXTERNAL_HANDLER_PROCESS_MAP_TYPE = "externalHandlerExternalHandlerProcessMap"
)
type ExternalHandlerExternalHandlerProcessMap struct {
Resource
Created string `json:"created,omitempty" yaml:"created,omitempty"`
Data map[string]interface{} `json:"data,omitempty" yaml:"data,omitempty"`
Description string `json:"description,omitempty" yaml:"description,omitempty"`
ExternalHandlerId string `json:"externalHandlerId,omitempty" yaml:"external_handler_id,omitempty"`
ExternalHandlerProcessId string `json:"externalHandlerProcessId,omitempty" yaml:"external_handler_process_id,omitempty"`
Kind string `json:"kind,omitempty" yaml:"kind,omitempty"`
Name string `json:"name,omitempty" yaml:"name,omitempty"`
OnError string `json:"onError,omitempty" yaml:"on_error,omitempty"`
RemoveTime string `json:"removeTime,omitempty" yaml:"remove_time,omitempty"`
Removed string `json:"removed,omitempty" yaml:"removed,omitempty"`
State string `json:"state,omitempty" yaml:"state,omitempty"`
Transitioning string `json:"transitioning,omitempty" yaml:"transitioning,omitempty"`
TransitioningMessage string `json:"transitioningMessage,omitempty" yaml:"transitioning_message,omitempty"`
TransitioningProgress int64 `json:"transitioningProgress,omitempty" yaml:"transitioning_progress,omitempty"`
Uuid string `json:"uuid,omitempty" yaml:"uuid,omitempty"`
}
type ExternalHandlerExternalHandlerProcessMapCollection struct {
Collection
Data []ExternalHandlerExternalHandlerProcessMap `json:"data,omitempty"`
}
type ExternalHandlerExternalHandlerProcessMapClient struct {
rancherClient *RancherClient
}
type ExternalHandlerExternalHandlerProcessMapOperations interface {
List(opts *ListOpts) (*ExternalHandlerExternalHandlerProcessMapCollection, error)
Create(opts *ExternalHandlerExternalHandlerProcessMap) (*ExternalHandlerExternalHandlerProcessMap, error)
Update(existing *ExternalHandlerExternalHandlerProcessMap, updates interface{}) (*ExternalHandlerExternalHandlerProcessMap, error)
ById(id string) (*ExternalHandlerExternalHandlerProcessMap, error)
Delete(container *ExternalHandlerExternalHandlerProcessMap) error
ActionActivate(*ExternalHandlerExternalHandlerProcessMap) (*ExternalHandlerExternalHandlerProcessMap, error)
ActionCreate(*ExternalHandlerExternalHandlerProcessMap) (*ExternalHandlerExternalHandlerProcessMap, error)
ActionDeactivate(*ExternalHandlerExternalHandlerProcessMap) (*ExternalHandlerExternalHandlerProcessMap, error)
ActionPurge(*ExternalHandlerExternalHandlerProcessMap) (*ExternalHandlerExternalHandlerProcessMap, error)
ActionRemove(*ExternalHandlerExternalHandlerProcessMap) (*ExternalHandlerExternalHandlerProcessMap, error)
ActionRestore(*ExternalHandlerExternalHandlerProcessMap) (*ExternalHandlerExternalHandlerProcessMap, error)
ActionUpdate(*ExternalHandlerExternalHandlerProcessMap) (*ExternalHandlerExternalHandlerProcessMap, error)
}
func newExternalHandlerExternalHandlerProcessMapClient(rancherClient *RancherClient) *ExternalHandlerExternalHandlerProcessMapClient {
return &ExternalHandlerExternalHandlerProcessMapClient{
rancherClient: rancherClient,
}
}
func (c *ExternalHandlerExternalHandlerProcessMapClient) Create(container *ExternalHandlerExternalHandlerProcessMap) (*ExternalHandlerExternalHandlerProcessMap, error) {
resp := &ExternalHandlerExternalHandlerProcessMap{}
err := c.rancherClient.doCreate(EXTERNAL_HANDLER_EXTERNAL_HANDLER_PROCESS_MAP_TYPE, container, resp)
return resp, err
}
func (c *ExternalHandlerExternalHandlerProcessMapClient) Update(existing *ExternalHandlerExternalHandlerProcessMap, updates interface{}) (*ExternalHandlerExternalHandlerProcessMap, error) {
resp := &ExternalHandlerExternalHandlerProcessMap{}
err := c.rancherClient.doUpdate(EXTERNAL_HANDLER_EXTERNAL_HANDLER_PROCESS_MAP_TYPE, &existing.Resource, updates, resp)
return resp, err
}
func (c *ExternalHandlerExternalHandlerProcessMapClient) List(opts *ListOpts) (*ExternalHandlerExternalHandlerProcessMapCollection, error) {
resp := &ExternalHandlerExternalHandlerProcessMapCollection{}
err := c.rancherClient.doList(EXTERNAL_HANDLER_EXTERNAL_HANDLER_PROCESS_MAP_TYPE, opts, resp)
return resp, err
}
func (c *ExternalHandlerExternalHandlerProcessMapClient) ById(id string) (*ExternalHandlerExternalHandlerProcessMap, error) {
resp := &ExternalHandlerExternalHandlerProcessMap{}
err := c.rancherClient.doById(EXTERNAL_HANDLER_EXTERNAL_HANDLER_PROCESS_MAP_TYPE, id, resp)
if apiError, ok := err.(*ApiError); ok {
if apiError.StatusCode == 404 {
return nil, nil
}
}
return resp, err
}
func (c *ExternalHandlerExternalHandlerProcessMapClient) Delete(container *ExternalHandlerExternalHandlerProcessMap) error {
return c.rancherClient.doResourceDelete(EXTERNAL_HANDLER_EXTERNAL_HANDLER_PROCESS_MAP_TYPE, &container.Resource)
}
func (c *ExternalHandlerExternalHandlerProcessMapClient) ActionActivate(resource *ExternalHandlerExternalHandlerProcessMap) (*ExternalHandlerExternalHandlerProcessMap, error) {
resp := &ExternalHandlerExternalHandlerProcessMap{}
err := c.rancherClient.doAction(EXTERNAL_HANDLER_EXTERNAL_HANDLER_PROCESS_MAP_TYPE, "activate", &resource.Resource, nil, resp)
return resp, err
}
func (c *ExternalHandlerExternalHandlerProcessMapClient) ActionCreate(resource *ExternalHandlerExternalHandlerProcessMap) (*ExternalHandlerExternalHandlerProcessMap, error) {
resp := &ExternalHandlerExternalHandlerProcessMap{}
err := c.rancherClient.doAction(EXTERNAL_HANDLER_EXTERNAL_HANDLER_PROCESS_MAP_TYPE, "create", &resource.Resource, nil, resp)
return resp, err
}
func (c *ExternalHandlerExternalHandlerProcessMapClient) ActionDeactivate(resource *ExternalHandlerExternalHandlerProcessMap) (*ExternalHandlerExternalHandlerProcessMap, error) {
resp := &ExternalHandlerExternalHandlerProcessMap{}
err := c.rancherClient.doAction(EXTERNAL_HANDLER_EXTERNAL_HANDLER_PROCESS_MAP_TYPE, "deactivate", &resource.Resource, nil, resp)
return resp, err
}
func (c *ExternalHandlerExternalHandlerProcessMapClient) ActionPurge(resource *ExternalHandlerExternalHandlerProcessMap) (*ExternalHandlerExternalHandlerProcessMap, error) {
resp := &ExternalHandlerExternalHandlerProcessMap{}
err := c.rancherClient.doAction(EXTERNAL_HANDLER_EXTERNAL_HANDLER_PROCESS_MAP_TYPE, "purge", &resource.Resource, nil, resp)
return resp, err
}
func (c *ExternalHandlerExternalHandlerProcessMapClient) ActionRemove(resource *ExternalHandlerExternalHandlerProcessMap) (*ExternalHandlerExternalHandlerProcessMap, error) {
resp := &ExternalHandlerExternalHandlerProcessMap{}
err := c.rancherClient.doAction(EXTERNAL_HANDLER_EXTERNAL_HANDLER_PROCESS_MAP_TYPE, "remove", &resource.Resource, nil, resp)
return resp, err
}
func (c *ExternalHandlerExternalHandlerProcessMapClient) ActionRestore(resource *ExternalHandlerExternalHandlerProcessMap) (*ExternalHandlerExternalHandlerProcessMap, error) {
resp := &ExternalHandlerExternalHandlerProcessMap{}
err := c.rancherClient.doAction(EXTERNAL_HANDLER_EXTERNAL_HANDLER_PROCESS_MAP_TYPE, "restore", &resource.Resource, nil, resp)
return resp, err
}
func (c *ExternalHandlerExternalHandlerProcessMapClient) ActionUpdate(resource *ExternalHandlerExternalHandlerProcessMap) (*ExternalHandlerExternalHandlerProcessMap, error) {
resp := &ExternalHandlerExternalHandlerProcessMap{}
err := c.rancherClient.doAction(EXTERNAL_HANDLER_EXTERNAL_HANDLER_PROCESS_MAP_TYPE, "update", &resource.Resource, nil, resp)
return resp, err
}

166
vendor/github.com/rancher/go-rancher/client/generated_external_handler_process.go generated vendored Normal file
View File

@ -0,0 +1,166 @@
package client
const (
EXTERNAL_HANDLER_PROCESS_TYPE = "externalHandlerProcess"
)
type ExternalHandlerProcess struct {
Resource
Created string `json:"created,omitempty" yaml:"created,omitempty"`
Data map[string]interface{} `json:"data,omitempty" yaml:"data,omitempty"`
Description string `json:"description,omitempty" yaml:"description,omitempty"`
Kind string `json:"kind,omitempty" yaml:"kind,omitempty"`
Name string `json:"name,omitempty" yaml:"name,omitempty"`
RemoveTime string `json:"removeTime,omitempty" yaml:"remove_time,omitempty"`
Removed string `json:"removed,omitempty" yaml:"removed,omitempty"`
State string `json:"state,omitempty" yaml:"state,omitempty"`
Transitioning string `json:"transitioning,omitempty" yaml:"transitioning,omitempty"`
TransitioningMessage string `json:"transitioningMessage,omitempty" yaml:"transitioning_message,omitempty"`
TransitioningProgress int64 `json:"transitioningProgress,omitempty" yaml:"transitioning_progress,omitempty"`
Uuid string `json:"uuid,omitempty" yaml:"uuid,omitempty"`
}
type ExternalHandlerProcessCollection struct {
Collection
Data []ExternalHandlerProcess `json:"data,omitempty"`
}
type ExternalHandlerProcessClient struct {
rancherClient *RancherClient
}
type ExternalHandlerProcessOperations interface {
List(opts *ListOpts) (*ExternalHandlerProcessCollection, error)
Create(opts *ExternalHandlerProcess) (*ExternalHandlerProcess, error)
Update(existing *ExternalHandlerProcess, updates interface{}) (*ExternalHandlerProcess, error)
ById(id string) (*ExternalHandlerProcess, error)
Delete(container *ExternalHandlerProcess) error
ActionActivate(*ExternalHandlerProcess) (*ExternalHandlerProcess, error)
ActionCreate(*ExternalHandlerProcess) (*ExternalHandlerProcess, error)
ActionDeactivate(*ExternalHandlerProcess) (*ExternalHandlerProcess, error)
ActionPurge(*ExternalHandlerProcess) (*ExternalHandlerProcess, error)
ActionRemove(*ExternalHandlerProcess) (*ExternalHandlerProcess, error)
ActionRestore(*ExternalHandlerProcess) (*ExternalHandlerProcess, error)
ActionUpdate(*ExternalHandlerProcess) (*ExternalHandlerProcess, error)
}
func newExternalHandlerProcessClient(rancherClient *RancherClient) *ExternalHandlerProcessClient {
return &ExternalHandlerProcessClient{
rancherClient: rancherClient,
}
}
func (c *ExternalHandlerProcessClient) Create(container *ExternalHandlerProcess) (*ExternalHandlerProcess, error) {
resp := &ExternalHandlerProcess{}
err := c.rancherClient.doCreate(EXTERNAL_HANDLER_PROCESS_TYPE, container, resp)
return resp, err
}
func (c *ExternalHandlerProcessClient) Update(existing *ExternalHandlerProcess, updates interface{}) (*ExternalHandlerProcess, error) {
resp := &ExternalHandlerProcess{}
err := c.rancherClient.doUpdate(EXTERNAL_HANDLER_PROCESS_TYPE, &existing.Resource, updates, resp)
return resp, err
}
func (c *ExternalHandlerProcessClient) List(opts *ListOpts) (*ExternalHandlerProcessCollection, error) {
resp := &ExternalHandlerProcessCollection{}
err := c.rancherClient.doList(EXTERNAL_HANDLER_PROCESS_TYPE, opts, resp)
return resp, err
}
func (c *ExternalHandlerProcessClient) ById(id string) (*ExternalHandlerProcess, error) {
resp := &ExternalHandlerProcess{}
err := c.rancherClient.doById(EXTERNAL_HANDLER_PROCESS_TYPE, id, resp)
if apiError, ok := err.(*ApiError); ok {
if apiError.StatusCode == 404 {
return nil, nil
}
}
return resp, err
}
func (c *ExternalHandlerProcessClient) Delete(container *ExternalHandlerProcess) error {
return c.rancherClient.doResourceDelete(EXTERNAL_HANDLER_PROCESS_TYPE, &container.Resource)
}
func (c *ExternalHandlerProcessClient) ActionActivate(resource *ExternalHandlerProcess) (*ExternalHandlerProcess, error) {
resp := &ExternalHandlerProcess{}
err := c.rancherClient.doAction(EXTERNAL_HANDLER_PROCESS_TYPE, "activate", &resource.Resource, nil, resp)
return resp, err
}
func (c *ExternalHandlerProcessClient) ActionCreate(resource *ExternalHandlerProcess) (*ExternalHandlerProcess, error) {
resp := &ExternalHandlerProcess{}
err := c.rancherClient.doAction(EXTERNAL_HANDLER_PROCESS_TYPE, "create", &resource.Resource, nil, resp)
return resp, err
}
func (c *ExternalHandlerProcessClient) ActionDeactivate(resource *ExternalHandlerProcess) (*ExternalHandlerProcess, error) {
resp := &ExternalHandlerProcess{}
err := c.rancherClient.doAction(EXTERNAL_HANDLER_PROCESS_TYPE, "deactivate", &resource.Resource, nil, resp)
return resp, err
}
func (c *ExternalHandlerProcessClient) ActionPurge(resource *ExternalHandlerProcess) (*ExternalHandlerProcess, error) {
resp := &ExternalHandlerProcess{}
err := c.rancherClient.doAction(EXTERNAL_HANDLER_PROCESS_TYPE, "purge", &resource.Resource, nil, resp)
return resp, err
}
func (c *ExternalHandlerProcessClient) ActionRemove(resource *ExternalHandlerProcess) (*ExternalHandlerProcess, error) {
resp := &ExternalHandlerProcess{}
err := c.rancherClient.doAction(EXTERNAL_HANDLER_PROCESS_TYPE, "remove", &resource.Resource, nil, resp)
return resp, err
}
func (c *ExternalHandlerProcessClient) ActionRestore(resource *ExternalHandlerProcess) (*ExternalHandlerProcess, error) {
resp := &ExternalHandlerProcess{}
err := c.rancherClient.doAction(EXTERNAL_HANDLER_PROCESS_TYPE, "restore", &resource.Resource, nil, resp)
return resp, err
}
func (c *ExternalHandlerProcessClient) ActionUpdate(resource *ExternalHandlerProcess) (*ExternalHandlerProcess, error) {
resp := &ExternalHandlerProcess{}
err := c.rancherClient.doAction(EXTERNAL_HANDLER_PROCESS_TYPE, "update", &resource.Resource, nil, resp)
return resp, err
}

69
vendor/github.com/rancher/go-rancher/client/generated_external_handler_process_config.go generated vendored Normal file
View File

@ -0,0 +1,69 @@
package client
const (
EXTERNAL_HANDLER_PROCESS_CONFIG_TYPE = "externalHandlerProcessConfig"
)
type ExternalHandlerProcessConfig struct {
Resource
Name string `json:"name,omitempty" yaml:"name,omitempty"`
OnError string `json:"onError,omitempty" yaml:"on_error,omitempty"`
}
type ExternalHandlerProcessConfigCollection struct {
Collection
Data []ExternalHandlerProcessConfig `json:"data,omitempty"`
}
type ExternalHandlerProcessConfigClient struct {
rancherClient *RancherClient
}
type ExternalHandlerProcessConfigOperations interface {
List(opts *ListOpts) (*ExternalHandlerProcessConfigCollection, error)
Create(opts *ExternalHandlerProcessConfig) (*ExternalHandlerProcessConfig, error)
Update(existing *ExternalHandlerProcessConfig, updates interface{}) (*ExternalHandlerProcessConfig, error)
ById(id string) (*ExternalHandlerProcessConfig, error)
Delete(container *ExternalHandlerProcessConfig) error
}
func newExternalHandlerProcessConfigClient(rancherClient *RancherClient) *ExternalHandlerProcessConfigClient {
return &ExternalHandlerProcessConfigClient{
rancherClient: rancherClient,
}
}
func (c *ExternalHandlerProcessConfigClient) Create(container *ExternalHandlerProcessConfig) (*ExternalHandlerProcessConfig, error) {
resp := &ExternalHandlerProcessConfig{}
err := c.rancherClient.doCreate(EXTERNAL_HANDLER_PROCESS_CONFIG_TYPE, container, resp)
return resp, err
}
func (c *ExternalHandlerProcessConfigClient) Update(existing *ExternalHandlerProcessConfig, updates interface{}) (*ExternalHandlerProcessConfig, error) {
resp := &ExternalHandlerProcessConfig{}
err := c.rancherClient.doUpdate(EXTERNAL_HANDLER_PROCESS_CONFIG_TYPE, &existing.Resource, updates, resp)
return resp, err
}
func (c *ExternalHandlerProcessConfigClient) List(opts *ListOpts) (*ExternalHandlerProcessConfigCollection, error) {
resp := &ExternalHandlerProcessConfigCollection{}
err := c.rancherClient.doList(EXTERNAL_HANDLER_PROCESS_CONFIG_TYPE, opts, resp)
return resp, err
}
func (c *ExternalHandlerProcessConfigClient) ById(id string) (*ExternalHandlerProcessConfig, error) {
resp := &ExternalHandlerProcessConfig{}
err := c.rancherClient.doById(EXTERNAL_HANDLER_PROCESS_CONFIG_TYPE, id, resp)
if apiError, ok := err.(*ApiError); ok {
if apiError.StatusCode == 404 {
return nil, nil
}
}
return resp, err
}
func (c *ExternalHandlerProcessConfigClient) Delete(container *ExternalHandlerProcessConfig) error {
return c.rancherClient.doResourceDelete(EXTERNAL_HANDLER_PROCESS_CONFIG_TYPE, &container.Resource)
}

117
vendor/github.com/rancher/go-rancher/client/generated_external_host_event.go generated vendored Normal file
View File

@ -0,0 +1,117 @@
package client
const (
EXTERNAL_HOST_EVENT_TYPE = "externalHostEvent"
)
type ExternalHostEvent struct {
Resource
AccountId string `json:"accountId,omitempty" yaml:"account_id,omitempty"`
Created string `json:"created,omitempty" yaml:"created,omitempty"`
Data map[string]interface{} `json:"data,omitempty" yaml:"data,omitempty"`
DeleteHost bool `json:"deleteHost,omitempty" yaml:"delete_host,omitempty"`
EventType string `json:"eventType,omitempty" yaml:"event_type,omitempty"`
ExternalId string `json:"externalId,omitempty" yaml:"external_id,omitempty"`
HostId string `json:"hostId,omitempty" yaml:"host_id,omitempty"`
HostLabel string `json:"hostLabel,omitempty" yaml:"host_label,omitempty"`
Kind string `json:"kind,omitempty" yaml:"kind,omitempty"`
ReportedAccountId string `json:"reportedAccountId,omitempty" yaml:"reported_account_id,omitempty"`
State string `json:"state,omitempty" yaml:"state,omitempty"`
Transitioning string `json:"transitioning,omitempty" yaml:"transitioning,omitempty"`
TransitioningMessage string `json:"transitioningMessage,omitempty" yaml:"transitioning_message,omitempty"`
TransitioningProgress int64 `json:"transitioningProgress,omitempty" yaml:"transitioning_progress,omitempty"`
Uuid string `json:"uuid,omitempty" yaml:"uuid,omitempty"`
}
type ExternalHostEventCollection struct {
Collection
Data []ExternalHostEvent `json:"data,omitempty"`
}
type ExternalHostEventClient struct {
rancherClient *RancherClient
}
type ExternalHostEventOperations interface {
List(opts *ListOpts) (*ExternalHostEventCollection, error)
Create(opts *ExternalHostEvent) (*ExternalHostEvent, error)
Update(existing *ExternalHostEvent, updates interface{}) (*ExternalHostEvent, error)
ById(id string) (*ExternalHostEvent, error)
Delete(container *ExternalHostEvent) error
ActionCreate(*ExternalHostEvent) (*ExternalEvent, error)
ActionRemove(*ExternalHostEvent) (*ExternalEvent, error)
}
func newExternalHostEventClient(rancherClient *RancherClient) *ExternalHostEventClient {
return &ExternalHostEventClient{
rancherClient: rancherClient,
}
}
func (c *ExternalHostEventClient) Create(container *ExternalHostEvent) (*ExternalHostEvent, error) {
resp := &ExternalHostEvent{}
err := c.rancherClient.doCreate(EXTERNAL_HOST_EVENT_TYPE, container, resp)
return resp, err
}
func (c *ExternalHostEventClient) Update(existing *ExternalHostEvent, updates interface{}) (*ExternalHostEvent, error) {
resp := &ExternalHostEvent{}
err := c.rancherClient.doUpdate(EXTERNAL_HOST_EVENT_TYPE, &existing.Resource, updates, resp)
return resp, err
}
func (c *ExternalHostEventClient) List(opts *ListOpts) (*ExternalHostEventCollection, error) {
resp := &ExternalHostEventCollection{}
err := c.rancherClient.doList(EXTERNAL_HOST_EVENT_TYPE, opts, resp)
return resp, err
}
func (c *ExternalHostEventClient) ById(id string) (*ExternalHostEvent, error) {
resp := &ExternalHostEvent{}
err := c.rancherClient.doById(EXTERNAL_HOST_EVENT_TYPE, id, resp)
if apiError, ok := err.(*ApiError); ok {
if apiError.StatusCode == 404 {
return nil, nil
}
}
return resp, err
}
func (c *ExternalHostEventClient) Delete(container *ExternalHostEvent) error {
return c.rancherClient.doResourceDelete(EXTERNAL_HOST_EVENT_TYPE, &container.Resource)
}
func (c *ExternalHostEventClient) ActionCreate(resource *ExternalHostEvent) (*ExternalEvent, error) {
resp := &ExternalEvent{}
err := c.rancherClient.doAction(EXTERNAL_HOST_EVENT_TYPE, "create", &resource.Resource, nil, resp)
return resp, err
}
func (c *ExternalHostEventClient) ActionRemove(resource *ExternalHostEvent) (*ExternalEvent, error) {
resp := &ExternalEvent{}
err := c.rancherClient.doAction(EXTERNAL_HOST_EVENT_TYPE, "remove", &resource.Resource, nil, resp)
return resp, err
}

234
vendor/github.com/rancher/go-rancher/client/generated_external_service.go generated vendored Normal file
View File

@ -0,0 +1,234 @@
package client
const (
EXTERNAL_SERVICE_TYPE = "externalService"
)
type ExternalService struct {
Resource
AccountId string `json:"accountId,omitempty" yaml:"account_id,omitempty"`
Created string `json:"created,omitempty" yaml:"created,omitempty"`
Data map[string]interface{} `json:"data,omitempty" yaml:"data,omitempty"`
Description string `json:"description,omitempty" yaml:"description,omitempty"`
EnvironmentId string `json:"environmentId,omitempty" yaml:"environment_id,omitempty"`
ExternalId string `json:"externalId,omitempty" yaml:"external_id,omitempty"`
ExternalIpAddresses []string `json:"externalIpAddresses,omitempty" yaml:"external_ip_addresses,omitempty"`
Fqdn string `json:"fqdn,omitempty" yaml:"fqdn,omitempty"`
HealthCheck *InstanceHealthCheck `json:"healthCheck,omitempty" yaml:"health_check,omitempty"`
HealthState string `json:"healthState,omitempty" yaml:"health_state,omitempty"`
Hostname string `json:"hostname,omitempty" yaml:"hostname,omitempty"`
Kind string `json:"kind,omitempty" yaml:"kind,omitempty"`
LaunchConfig *LaunchConfig `json:"launchConfig,omitempty" yaml:"launch_config,omitempty"`
Metadata map[string]interface{} `json:"metadata,omitempty" yaml:"metadata,omitempty"`
Name string `json:"name,omitempty" yaml:"name,omitempty"`
RemoveTime string `json:"removeTime,omitempty" yaml:"remove_time,omitempty"`
Removed string `json:"removed,omitempty" yaml:"removed,omitempty"`
StartOnCreate bool `json:"startOnCreate,omitempty" yaml:"start_on_create,omitempty"`
State string `json:"state,omitempty" yaml:"state,omitempty"`
Transitioning string `json:"transitioning,omitempty" yaml:"transitioning,omitempty"`
TransitioningMessage string `json:"transitioningMessage,omitempty" yaml:"transitioning_message,omitempty"`
TransitioningProgress int64 `json:"transitioningProgress,omitempty" yaml:"transitioning_progress,omitempty"`
Upgrade *ServiceUpgrade `json:"upgrade,omitempty" yaml:"upgrade,omitempty"`
Uuid string `json:"uuid,omitempty" yaml:"uuid,omitempty"`
}
type ExternalServiceCollection struct {
Collection
Data []ExternalService `json:"data,omitempty"`
}
type ExternalServiceClient struct {
rancherClient *RancherClient
}
type ExternalServiceOperations interface {
List(opts *ListOpts) (*ExternalServiceCollection, error)
Create(opts *ExternalService) (*ExternalService, error)
Update(existing *ExternalService, updates interface{}) (*ExternalService, error)
ById(id string) (*ExternalService, error)
Delete(container *ExternalService) error
ActionActivate(*ExternalService) (*Service, error)
ActionCancelrollback(*ExternalService) (*Service, error)
ActionCancelupgrade(*ExternalService) (*Service, error)
ActionCreate(*ExternalService) (*Service, error)
ActionDeactivate(*ExternalService) (*Service, error)
ActionFinishupgrade(*ExternalService) (*Service, error)
ActionRemove(*ExternalService) (*Service, error)
ActionRestart(*ExternalService, *ServiceRestart) (*Service, error)
ActionRollback(*ExternalService) (*Service, error)
ActionUpdate(*ExternalService) (*Service, error)
ActionUpgrade(*ExternalService, *ServiceUpgrade) (*Service, error)
}
func newExternalServiceClient(rancherClient *RancherClient) *ExternalServiceClient {
return &ExternalServiceClient{
rancherClient: rancherClient,
}
}
func (c *ExternalServiceClient) Create(container *ExternalService) (*ExternalService, error) {
resp := &ExternalService{}
err := c.rancherClient.doCreate(EXTERNAL_SERVICE_TYPE, container, resp)
return resp, err
}
func (c *ExternalServiceClient) Update(existing *ExternalService, updates interface{}) (*ExternalService, error) {
resp := &ExternalService{}
err := c.rancherClient.doUpdate(EXTERNAL_SERVICE_TYPE, &existing.Resource, updates, resp)
return resp, err
}
func (c *ExternalServiceClient) List(opts *ListOpts) (*ExternalServiceCollection, error) {
resp := &ExternalServiceCollection{}
err := c.rancherClient.doList(EXTERNAL_SERVICE_TYPE, opts, resp)
return resp, err
}
func (c *ExternalServiceClient) ById(id string) (*ExternalService, error) {
resp := &ExternalService{}
err := c.rancherClient.doById(EXTERNAL_SERVICE_TYPE, id, resp)
if apiError, ok := err.(*ApiError); ok {
if apiError.StatusCode == 404 {
return nil, nil
}
}
return resp, err
}
func (c *ExternalServiceClient) Delete(container *ExternalService) error {
return c.rancherClient.doResourceDelete(EXTERNAL_SERVICE_TYPE, &container.Resource)
}
func (c *ExternalServiceClient) ActionActivate(resource *ExternalService) (*Service, error) {
resp := &Service{}
err := c.rancherClient.doAction(EXTERNAL_SERVICE_TYPE, "activate", &resource.Resource, nil, resp)
return resp, err
}
func (c *ExternalServiceClient) ActionCancelrollback(resource *ExternalService) (*Service, error) {
resp := &Service{}
err := c.rancherClient.doAction(EXTERNAL_SERVICE_TYPE, "cancelrollback", &resource.Resource, nil, resp)
return resp, err
}
func (c *ExternalServiceClient) ActionCancelupgrade(resource *ExternalService) (*Service, error) {
resp := &Service{}
err := c.rancherClient.doAction(EXTERNAL_SERVICE_TYPE, "cancelupgrade", &resource.Resource, nil, resp)
return resp, err
}
func (c *ExternalServiceClient) ActionCreate(resource *ExternalService) (*Service, error) {
resp := &Service{}
err := c.rancherClient.doAction(EXTERNAL_SERVICE_TYPE, "create", &resource.Resource, nil, resp)
return resp, err
}
func (c *ExternalServiceClient) ActionDeactivate(resource *ExternalService) (*Service, error) {
resp := &Service{}
err := c.rancherClient.doAction(EXTERNAL_SERVICE_TYPE, "deactivate", &resource.Resource, nil, resp)
return resp, err
}
func (c *ExternalServiceClient) ActionFinishupgrade(resource *ExternalService) (*Service, error) {
resp := &Service{}
err := c.rancherClient.doAction(EXTERNAL_SERVICE_TYPE, "finishupgrade", &resource.Resource, nil, resp)
return resp, err
}
func (c *ExternalServiceClient) ActionRemove(resource *ExternalService) (*Service, error) {
resp := &Service{}
err := c.rancherClient.doAction(EXTERNAL_SERVICE_TYPE, "remove", &resource.Resource, nil, resp)
return resp, err
}
func (c *ExternalServiceClient) ActionRestart(resource *ExternalService, input *ServiceRestart) (*Service, error) {
resp := &Service{}
err := c.rancherClient.doAction(EXTERNAL_SERVICE_TYPE, "restart", &resource.Resource, input, resp)
return resp, err
}
func (c *ExternalServiceClient) ActionRollback(resource *ExternalService) (*Service, error) {
resp := &Service{}
err := c.rancherClient.doAction(EXTERNAL_SERVICE_TYPE, "rollback", &resource.Resource, nil, resp)
return resp, err
}
func (c *ExternalServiceClient) ActionUpdate(resource *ExternalService) (*Service, error) {
resp := &Service{}
err := c.rancherClient.doAction(EXTERNAL_SERVICE_TYPE, "update", &resource.Resource, nil, resp)
return resp, err
}
func (c *ExternalServiceClient) ActionUpgrade(resource *ExternalService, input *ServiceUpgrade) (*Service, error) {
resp := &Service{}
err := c.rancherClient.doAction(EXTERNAL_SERVICE_TYPE, "upgrade", &resource.Resource, input, resp)
return resp, err
}

115
vendor/github.com/rancher/go-rancher/client/generated_external_service_event.go generated vendored Normal file
View File

@ -0,0 +1,115 @@
package client
const (
EXTERNAL_SERVICE_EVENT_TYPE = "externalServiceEvent"
)
type ExternalServiceEvent struct {
Resource
AccountId string `json:"accountId,omitempty" yaml:"account_id,omitempty"`
Created string `json:"created,omitempty" yaml:"created,omitempty"`
Data map[string]interface{} `json:"data,omitempty" yaml:"data,omitempty"`
Environment interface{} `json:"environment,omitempty" yaml:"environment,omitempty"`
EventType string `json:"eventType,omitempty" yaml:"event_type,omitempty"`
ExternalId string `json:"externalId,omitempty" yaml:"external_id,omitempty"`
Kind string `json:"kind,omitempty" yaml:"kind,omitempty"`
ReportedAccountId string `json:"reportedAccountId,omitempty" yaml:"reported_account_id,omitempty"`
Service interface{} `json:"service,omitempty" yaml:"service,omitempty"`
State string `json:"state,omitempty" yaml:"state,omitempty"`
Transitioning string `json:"transitioning,omitempty" yaml:"transitioning,omitempty"`
TransitioningMessage string `json:"transitioningMessage,omitempty" yaml:"transitioning_message,omitempty"`
TransitioningProgress int64 `json:"transitioningProgress,omitempty" yaml:"transitioning_progress,omitempty"`
Uuid string `json:"uuid,omitempty" yaml:"uuid,omitempty"`
}
type ExternalServiceEventCollection struct {
Collection
Data []ExternalServiceEvent `json:"data,omitempty"`
}
type ExternalServiceEventClient struct {
rancherClient *RancherClient
}
type ExternalServiceEventOperations interface {
List(opts *ListOpts) (*ExternalServiceEventCollection, error)
Create(opts *ExternalServiceEvent) (*ExternalServiceEvent, error)
Update(existing *ExternalServiceEvent, updates interface{}) (*ExternalServiceEvent, error)
ById(id string) (*ExternalServiceEvent, error)
Delete(container *ExternalServiceEvent) error
ActionCreate(*ExternalServiceEvent) (*ExternalEvent, error)
ActionRemove(*ExternalServiceEvent) (*ExternalEvent, error)
}
func newExternalServiceEventClient(rancherClient *RancherClient) *ExternalServiceEventClient {
return &ExternalServiceEventClient{
rancherClient: rancherClient,
}
}
func (c *ExternalServiceEventClient) Create(container *ExternalServiceEvent) (*ExternalServiceEvent, error) {
resp := &ExternalServiceEvent{}
err := c.rancherClient.doCreate(EXTERNAL_SERVICE_EVENT_TYPE, container, resp)
return resp, err
}
func (c *ExternalServiceEventClient) Update(existing *ExternalServiceEvent, updates interface{}) (*ExternalServiceEvent, error) {
resp := &ExternalServiceEvent{}
err := c.rancherClient.doUpdate(EXTERNAL_SERVICE_EVENT_TYPE, &existing.Resource, updates, resp)
return resp, err
}
func (c *ExternalServiceEventClient) List(opts *ListOpts) (*ExternalServiceEventCollection, error) {
resp := &ExternalServiceEventCollection{}
err := c.rancherClient.doList(EXTERNAL_SERVICE_EVENT_TYPE, opts, resp)
return resp, err
}
func (c *ExternalServiceEventClient) ById(id string) (*ExternalServiceEvent, error) {
resp := &ExternalServiceEvent{}
err := c.rancherClient.doById(EXTERNAL_SERVICE_EVENT_TYPE, id, resp)
if apiError, ok := err.(*ApiError); ok {
if apiError.StatusCode == 404 {
return nil, nil
}
}
return resp, err
}
func (c *ExternalServiceEventClient) Delete(container *ExternalServiceEvent) error {
return c.rancherClient.doResourceDelete(EXTERNAL_SERVICE_EVENT_TYPE, &container.Resource)
}
func (c *ExternalServiceEventClient) ActionCreate(resource *ExternalServiceEvent) (*ExternalEvent, error) {
resp := &ExternalEvent{}
err := c.rancherClient.doAction(EXTERNAL_SERVICE_EVENT_TYPE, "create", &resource.Resource, nil, resp)
return resp, err
}
func (c *ExternalServiceEventClient) ActionRemove(resource *ExternalServiceEvent) (*ExternalEvent, error) {
resp := &ExternalEvent{}
err := c.rancherClient.doAction(EXTERNAL_SERVICE_EVENT_TYPE, "remove", &resource.Resource, nil, resp)
return resp, err
}

115
vendor/github.com/rancher/go-rancher/client/generated_external_storage_pool_event.go generated vendored Normal file
View File

@ -0,0 +1,115 @@
package client
const (
EXTERNAL_STORAGE_POOL_EVENT_TYPE = "externalStoragePoolEvent"
)
type ExternalStoragePoolEvent struct {
Resource
AccountId string `json:"accountId,omitempty" yaml:"account_id,omitempty"`
Created string `json:"created,omitempty" yaml:"created,omitempty"`
Data map[string]interface{} `json:"data,omitempty" yaml:"data,omitempty"`
EventType string `json:"eventType,omitempty" yaml:"event_type,omitempty"`
ExternalId string `json:"externalId,omitempty" yaml:"external_id,omitempty"`
HostUuids []string `json:"hostUuids,omitempty" yaml:"host_uuids,omitempty"`
Kind string `json:"kind,omitempty" yaml:"kind,omitempty"`
ReportedAccountId string `json:"reportedAccountId,omitempty" yaml:"reported_account_id,omitempty"`
State string `json:"state,omitempty" yaml:"state,omitempty"`
StoragePool StoragePool `json:"storagePool,omitempty" yaml:"storage_pool,omitempty"`
Transitioning string `json:"transitioning,omitempty" yaml:"transitioning,omitempty"`
TransitioningMessage string `json:"transitioningMessage,omitempty" yaml:"transitioning_message,omitempty"`
TransitioningProgress int64 `json:"transitioningProgress,omitempty" yaml:"transitioning_progress,omitempty"`
Uuid string `json:"uuid,omitempty" yaml:"uuid,omitempty"`
}
type ExternalStoragePoolEventCollection struct {
Collection
Data []ExternalStoragePoolEvent `json:"data,omitempty"`
}
type ExternalStoragePoolEventClient struct {
rancherClient *RancherClient
}
type ExternalStoragePoolEventOperations interface {
List(opts *ListOpts) (*ExternalStoragePoolEventCollection, error)
Create(opts *ExternalStoragePoolEvent) (*ExternalStoragePoolEvent, error)
Update(existing *ExternalStoragePoolEvent, updates interface{}) (*ExternalStoragePoolEvent, error)
ById(id string) (*ExternalStoragePoolEvent, error)
Delete(container *ExternalStoragePoolEvent) error
ActionCreate(*ExternalStoragePoolEvent) (*ExternalEvent, error)
ActionRemove(*ExternalStoragePoolEvent) (*ExternalEvent, error)
}
func newExternalStoragePoolEventClient(rancherClient *RancherClient) *ExternalStoragePoolEventClient {
return &ExternalStoragePoolEventClient{
rancherClient: rancherClient,
}
}
func (c *ExternalStoragePoolEventClient) Create(container *ExternalStoragePoolEvent) (*ExternalStoragePoolEvent, error) {
resp := &ExternalStoragePoolEvent{}
err := c.rancherClient.doCreate(EXTERNAL_STORAGE_POOL_EVENT_TYPE, container, resp)
return resp, err
}
func (c *ExternalStoragePoolEventClient) Update(existing *ExternalStoragePoolEvent, updates interface{}) (*ExternalStoragePoolEvent, error) {
resp := &ExternalStoragePoolEvent{}
err := c.rancherClient.doUpdate(EXTERNAL_STORAGE_POOL_EVENT_TYPE, &existing.Resource, updates, resp)
return resp, err
}
func (c *ExternalStoragePoolEventClient) List(opts *ListOpts) (*ExternalStoragePoolEventCollection, error) {
resp := &ExternalStoragePoolEventCollection{}
err := c.rancherClient.doList(EXTERNAL_STORAGE_POOL_EVENT_TYPE, opts, resp)
return resp, err
}
func (c *ExternalStoragePoolEventClient) ById(id string) (*ExternalStoragePoolEvent, error) {
resp := &ExternalStoragePoolEvent{}
err := c.rancherClient.doById(EXTERNAL_STORAGE_POOL_EVENT_TYPE, id, resp)
if apiError, ok := err.(*ApiError); ok {
if apiError.StatusCode == 404 {
return nil, nil
}
}
return resp, err
}
func (c *ExternalStoragePoolEventClient) Delete(container *ExternalStoragePoolEvent) error {
return c.rancherClient.doResourceDelete(EXTERNAL_STORAGE_POOL_EVENT_TYPE, &container.Resource)
}
func (c *ExternalStoragePoolEventClient) ActionCreate(resource *ExternalStoragePoolEvent) (*ExternalEvent, error) {
resp := &ExternalEvent{}
err := c.rancherClient.doAction(EXTERNAL_STORAGE_POOL_EVENT_TYPE, "create", &resource.Resource, nil, resp)
return resp, err
}
func (c *ExternalStoragePoolEventClient) ActionRemove(resource *ExternalStoragePoolEvent) (*ExternalEvent, error) {
resp := &ExternalEvent{}
err := c.rancherClient.doAction(EXTERNAL_STORAGE_POOL_EVENT_TYPE, "remove", &resource.Resource, nil, resp)
return resp, err
}

113
vendor/github.com/rancher/go-rancher/client/generated_external_volume_event.go generated vendored Normal file
View File

@ -0,0 +1,113 @@
package client
const (
EXTERNAL_VOLUME_EVENT_TYPE = "externalVolumeEvent"
)
type ExternalVolumeEvent struct {
Resource
AccountId string `json:"accountId,omitempty" yaml:"account_id,omitempty"`
Created string `json:"created,omitempty" yaml:"created,omitempty"`
Data map[string]interface{} `json:"data,omitempty" yaml:"data,omitempty"`
EventType string `json:"eventType,omitempty" yaml:"event_type,omitempty"`
ExternalId string `json:"externalId,omitempty" yaml:"external_id,omitempty"`
Kind string `json:"kind,omitempty" yaml:"kind,omitempty"`
ReportedAccountId string `json:"reportedAccountId,omitempty" yaml:"reported_account_id,omitempty"`
State string `json:"state,omitempty" yaml:"state,omitempty"`
Transitioning string `json:"transitioning,omitempty" yaml:"transitioning,omitempty"`
TransitioningMessage string `json:"transitioningMessage,omitempty" yaml:"transitioning_message,omitempty"`
TransitioningProgress int64 `json:"transitioningProgress,omitempty" yaml:"transitioning_progress,omitempty"`
Uuid string `json:"uuid,omitempty" yaml:"uuid,omitempty"`
Volume Volume `json:"volume,omitempty" yaml:"volume,omitempty"`
}
type ExternalVolumeEventCollection struct {
Collection
Data []ExternalVolumeEvent `json:"data,omitempty"`
}
type ExternalVolumeEventClient struct {
rancherClient *RancherClient
}
type ExternalVolumeEventOperations interface {
List(opts *ListOpts) (*ExternalVolumeEventCollection, error)
Create(opts *ExternalVolumeEvent) (*ExternalVolumeEvent, error)
Update(existing *ExternalVolumeEvent, updates interface{}) (*ExternalVolumeEvent, error)
ById(id string) (*ExternalVolumeEvent, error)
Delete(container *ExternalVolumeEvent) error
ActionCreate(*ExternalVolumeEvent) (*ExternalEvent, error)
ActionRemove(*ExternalVolumeEvent) (*ExternalEvent, error)
}
func newExternalVolumeEventClient(rancherClient *RancherClient) *ExternalVolumeEventClient {
return &ExternalVolumeEventClient{
rancherClient: rancherClient,
}
}
func (c *ExternalVolumeEventClient) Create(container *ExternalVolumeEvent) (*ExternalVolumeEvent, error) {
resp := &ExternalVolumeEvent{}
err := c.rancherClient.doCreate(EXTERNAL_VOLUME_EVENT_TYPE, container, resp)
return resp, err
}
func (c *ExternalVolumeEventClient) Update(existing *ExternalVolumeEvent, updates interface{}) (*ExternalVolumeEvent, error) {
resp := &ExternalVolumeEvent{}
err := c.rancherClient.doUpdate(EXTERNAL_VOLUME_EVENT_TYPE, &existing.Resource, updates, resp)
return resp, err
}
func (c *ExternalVolumeEventClient) List(opts *ListOpts) (*ExternalVolumeEventCollection, error) {
resp := &ExternalVolumeEventCollection{}
err := c.rancherClient.doList(EXTERNAL_VOLUME_EVENT_TYPE, opts, resp)
return resp, err
}
func (c *ExternalVolumeEventClient) ById(id string) (*ExternalVolumeEvent, error) {
resp := &ExternalVolumeEvent{}
err := c.rancherClient.doById(EXTERNAL_VOLUME_EVENT_TYPE, id, resp)
if apiError, ok := err.(*ApiError); ok {
if apiError.StatusCode == 404 {
return nil, nil
}
}
return resp, err
}
func (c *ExternalVolumeEventClient) Delete(container *ExternalVolumeEvent) error {
return c.rancherClient.doResourceDelete(EXTERNAL_VOLUME_EVENT_TYPE, &container.Resource)
}
func (c *ExternalVolumeEventClient) ActionCreate(resource *ExternalVolumeEvent) (*ExternalEvent, error) {
resp := &ExternalEvent{}
err := c.rancherClient.doAction(EXTERNAL_VOLUME_EVENT_TYPE, "create", &resource.Resource, nil, resp)
return resp, err
}
func (c *ExternalVolumeEventClient) ActionRemove(resource *ExternalVolumeEvent) (*ExternalEvent, error) {
resp := &ExternalEvent{}
err := c.rancherClient.doAction(EXTERNAL_VOLUME_EVENT_TYPE, "remove", &resource.Resource, nil, resp)
return resp, err
}

67
vendor/github.com/rancher/go-rancher/client/generated_field_documentation.go generated vendored Normal file
View File

@ -0,0 +1,67 @@
package client
const (
FIELD_DOCUMENTATION_TYPE = "fieldDocumentation"
)
type FieldDocumentation struct {
Resource
Description string `json:"description,omitempty" yaml:"description,omitempty"`
}
type FieldDocumentationCollection struct {
Collection
Data []FieldDocumentation `json:"data,omitempty"`
}
type FieldDocumentationClient struct {
rancherClient *RancherClient
}
type FieldDocumentationOperations interface {
List(opts *ListOpts) (*FieldDocumentationCollection, error)
Create(opts *FieldDocumentation) (*FieldDocumentation, error)
Update(existing *FieldDocumentation, updates interface{}) (*FieldDocumentation, error)
ById(id string) (*FieldDocumentation, error)
Delete(container *FieldDocumentation) error
}
func newFieldDocumentationClient(rancherClient *RancherClient) *FieldDocumentationClient {
return &FieldDocumentationClient{
rancherClient: rancherClient,
}
}
func (c *FieldDocumentationClient) Create(container *FieldDocumentation) (*FieldDocumentation, error) {
resp := &FieldDocumentation{}
err := c.rancherClient.doCreate(FIELD_DOCUMENTATION_TYPE, container, resp)
return resp, err
}
func (c *FieldDocumentationClient) Update(existing *FieldDocumentation, updates interface{}) (*FieldDocumentation, error) {
resp := &FieldDocumentation{}
err := c.rancherClient.doUpdate(FIELD_DOCUMENTATION_TYPE, &existing.Resource, updates, resp)
return resp, err
}
func (c *FieldDocumentationClient) List(opts *ListOpts) (*FieldDocumentationCollection, error) {
resp := &FieldDocumentationCollection{}
err := c.rancherClient.doList(FIELD_DOCUMENTATION_TYPE, opts, resp)
return resp, err
}
func (c *FieldDocumentationClient) ById(id string) (*FieldDocumentation, error) {
resp := &FieldDocumentation{}
err := c.rancherClient.doById(FIELD_DOCUMENTATION_TYPE, id, resp)
if apiError, ok := err.(*ApiError); ok {
if apiError.StatusCode == 404 {
return nil, nil
}
}
return resp, err
}
func (c *FieldDocumentationClient) Delete(container *FieldDocumentation) error {
return c.rancherClient.doResourceDelete(FIELD_DOCUMENTATION_TYPE, &container.Resource)
}

81
vendor/github.com/rancher/go-rancher/client/generated_githubconfig.go generated vendored Normal file
View File

@ -0,0 +1,81 @@
package client
const (
GITHUBCONFIG_TYPE = "githubconfig"
)
type Githubconfig struct {
Resource
AccessMode string `json:"accessMode,omitempty" yaml:"access_mode,omitempty"`
AllowedIdentities []interface{} `json:"allowedIdentities,omitempty" yaml:"allowed_identities,omitempty"`
ClientId string `json:"clientId,omitempty" yaml:"client_id,omitempty"`
ClientSecret string `json:"clientSecret,omitempty" yaml:"client_secret,omitempty"`
Enabled bool `json:"enabled,omitempty" yaml:"enabled,omitempty"`
Hostname string `json:"hostname,omitempty" yaml:"hostname,omitempty"`
Name string `json:"name,omitempty" yaml:"name,omitempty"`
Scheme string `json:"scheme,omitempty" yaml:"scheme,omitempty"`
}
type GithubconfigCollection struct {
Collection
Data []Githubconfig `json:"data,omitempty"`
}
type GithubconfigClient struct {
rancherClient *RancherClient
}
type GithubconfigOperations interface {
List(opts *ListOpts) (*GithubconfigCollection, error)
Create(opts *Githubconfig) (*Githubconfig, error)
Update(existing *Githubconfig, updates interface{}) (*Githubconfig, error)
ById(id string) (*Githubconfig, error)
Delete(container *Githubconfig) error
}
func newGithubconfigClient(rancherClient *RancherClient) *GithubconfigClient {
return &GithubconfigClient{
rancherClient: rancherClient,
}
}
func (c *GithubconfigClient) Create(container *Githubconfig) (*Githubconfig, error) {
resp := &Githubconfig{}
err := c.rancherClient.doCreate(GITHUBCONFIG_TYPE, container, resp)
return resp, err
}
func (c *GithubconfigClient) Update(existing *Githubconfig, updates interface{}) (*Githubconfig, error) {
resp := &Githubconfig{}
err := c.rancherClient.doUpdate(GITHUBCONFIG_TYPE, &existing.Resource, updates, resp)
return resp, err
}
func (c *GithubconfigClient) List(opts *ListOpts) (*GithubconfigCollection, error) {
resp := &GithubconfigCollection{}
err := c.rancherClient.doList(GITHUBCONFIG_TYPE, opts, resp)
return resp, err
}
func (c *GithubconfigClient) ById(id string) (*Githubconfig, error) {
resp := &Githubconfig{}
err := c.rancherClient.doById(GITHUBCONFIG_TYPE, id, resp)
if apiError, ok := err.(*ApiError); ok {
if apiError.StatusCode == 404 {
return nil, nil
}
}
return resp, err
}
func (c *GithubconfigClient) Delete(container *Githubconfig) error {
return c.rancherClient.doResourceDelete(GITHUBCONFIG_TYPE, &container.Resource)
}

73
vendor/github.com/rancher/go-rancher/client/generated_ha_config.go generated vendored Normal file
View File

@ -0,0 +1,73 @@
package client
const (
HA_CONFIG_TYPE = "haConfig"
)
type HaConfig struct {
Resource
ClusterSize int64 `json:"clusterSize,omitempty" yaml:"cluster_size,omitempty"`
DbHost string `json:"dbHost,omitempty" yaml:"db_host,omitempty"`
DbSize int64 `json:"dbSize,omitempty" yaml:"db_size,omitempty"`
Enabled bool `json:"enabled,omitempty" yaml:"enabled,omitempty"`
}
type HaConfigCollection struct {
Collection
Data []HaConfig `json:"data,omitempty"`
}
type HaConfigClient struct {
rancherClient *RancherClient
}
type HaConfigOperations interface {
List(opts *ListOpts) (*HaConfigCollection, error)
Create(opts *HaConfig) (*HaConfig, error)
Update(existing *HaConfig, updates interface{}) (*HaConfig, error)
ById(id string) (*HaConfig, error)
Delete(container *HaConfig) error
}
func newHaConfigClient(rancherClient *RancherClient) *HaConfigClient {
return &HaConfigClient{
rancherClient: rancherClient,
}
}
func (c *HaConfigClient) Create(container *HaConfig) (*HaConfig, error) {
resp := &HaConfig{}
err := c.rancherClient.doCreate(HA_CONFIG_TYPE, container, resp)
return resp, err
}
func (c *HaConfigClient) Update(existing *HaConfig, updates interface{}) (*HaConfig, error) {
resp := &HaConfig{}
err := c.rancherClient.doUpdate(HA_CONFIG_TYPE, &existing.Resource, updates, resp)
return resp, err
}
func (c *HaConfigClient) List(opts *ListOpts) (*HaConfigCollection, error) {
resp := &HaConfigCollection{}
err := c.rancherClient.doList(HA_CONFIG_TYPE, opts, resp)
return resp, err
}
func (c *HaConfigClient) ById(id string) (*HaConfig, error) {
resp := &HaConfig{}
err := c.rancherClient.doById(HA_CONFIG_TYPE, id, resp)
if apiError, ok := err.(*ApiError); ok {
if apiError.StatusCode == 404 {
return nil, nil
}
}
return resp, err
}
func (c *HaConfigClient) Delete(container *HaConfig) error {
return c.rancherClient.doResourceDelete(HA_CONFIG_TYPE, &container.Resource)
}

97
vendor/github.com/rancher/go-rancher/client/generated_ha_config_input.go generated vendored Normal file
View File

@ -0,0 +1,97 @@
package client
const (
HA_CONFIG_INPUT_TYPE = "haConfigInput"
)
type HaConfigInput struct {
Resource
Cert string `json:"cert,omitempty" yaml:"cert,omitempty"`
CertChain string `json:"certChain,omitempty" yaml:"cert_chain,omitempty"`
ClusterSize int64 `json:"clusterSize,omitempty" yaml:"cluster_size,omitempty"`
HostRegistrationUrl string `json:"hostRegistrationUrl,omitempty" yaml:"host_registration_url,omitempty"`
HttpEnabled bool `json:"httpEnabled,omitempty" yaml:"http_enabled,omitempty"`
HttpPort int64 `json:"httpPort,omitempty" yaml:"http_port,omitempty"`
HttpsPort int64 `json:"httpsPort,omitempty" yaml:"https_port,omitempty"`
Key string `json:"key,omitempty" yaml:"key,omitempty"`
PpHttpPort int64 `json:"ppHttpPort,omitempty" yaml:"pp_http_port,omitempty"`
PpHttpsPort int64 `json:"ppHttpsPort,omitempty" yaml:"pp_https_port,omitempty"`
RedisPort int64 `json:"redisPort,omitempty" yaml:"redis_port,omitempty"`
SwarmEnabled bool `json:"swarmEnabled,omitempty" yaml:"swarm_enabled,omitempty"`
SwarmPort int64 `json:"swarmPort,omitempty" yaml:"swarm_port,omitempty"`
ZookeeperClientPort int64 `json:"zookeeperClientPort,omitempty" yaml:"zookeeper_client_port,omitempty"`
ZookeeperLeaderPort int64 `json:"zookeeperLeaderPort,omitempty" yaml:"zookeeper_leader_port,omitempty"`
ZookeeperQuorumPort int64 `json:"zookeeperQuorumPort,omitempty" yaml:"zookeeper_quorum_port,omitempty"`
}
type HaConfigInputCollection struct {
Collection
Data []HaConfigInput `json:"data,omitempty"`
}
type HaConfigInputClient struct {
rancherClient *RancherClient
}
type HaConfigInputOperations interface {
List(opts *ListOpts) (*HaConfigInputCollection, error)
Create(opts *HaConfigInput) (*HaConfigInput, error)
Update(existing *HaConfigInput, updates interface{}) (*HaConfigInput, error)
ById(id string) (*HaConfigInput, error)
Delete(container *HaConfigInput) error
}
func newHaConfigInputClient(rancherClient *RancherClient) *HaConfigInputClient {
return &HaConfigInputClient{
rancherClient: rancherClient,
}
}
func (c *HaConfigInputClient) Create(container *HaConfigInput) (*HaConfigInput, error) {
resp := &HaConfigInput{}
err := c.rancherClient.doCreate(HA_CONFIG_INPUT_TYPE, container, resp)
return resp, err
}
func (c *HaConfigInputClient) Update(existing *HaConfigInput, updates interface{}) (*HaConfigInput, error) {
resp := &HaConfigInput{}
err := c.rancherClient.doUpdate(HA_CONFIG_INPUT_TYPE, &existing.Resource, updates, resp)
return resp, err
}
func (c *HaConfigInputClient) List(opts *ListOpts) (*HaConfigInputCollection, error) {
resp := &HaConfigInputCollection{}
err := c.rancherClient.doList(HA_CONFIG_INPUT_TYPE, opts, resp)
return resp, err
}
func (c *HaConfigInputClient) ById(id string) (*HaConfigInput, error) {
resp := &HaConfigInput{}
err := c.rancherClient.doById(HA_CONFIG_INPUT_TYPE, id, resp)
if apiError, ok := err.(*ApiError); ok {
if apiError.StatusCode == 404 {
return nil, nil
}
}
return resp, err
}
func (c *HaConfigInputClient) Delete(container *HaConfigInput) error {
return c.rancherClient.doResourceDelete(HA_CONFIG_INPUT_TYPE, &container.Resource)
}

69
vendor/github.com/rancher/go-rancher/client/generated_haproxy_config.go generated vendored Normal file
View File

@ -0,0 +1,69 @@
package client
const (
HAPROXY_CONFIG_TYPE = "haproxyConfig"
)
type HaproxyConfig struct {
Resource
Defaults string `json:"defaults,omitempty" yaml:"defaults,omitempty"`
Global string `json:"global,omitempty" yaml:"global,omitempty"`
}
type HaproxyConfigCollection struct {
Collection
Data []HaproxyConfig `json:"data,omitempty"`
}
type HaproxyConfigClient struct {
rancherClient *RancherClient
}
type HaproxyConfigOperations interface {
List(opts *ListOpts) (*HaproxyConfigCollection, error)
Create(opts *HaproxyConfig) (*HaproxyConfig, error)
Update(existing *HaproxyConfig, updates interface{}) (*HaproxyConfig, error)
ById(id string) (*HaproxyConfig, error)
Delete(container *HaproxyConfig) error
}
func newHaproxyConfigClient(rancherClient *RancherClient) *HaproxyConfigClient {
return &HaproxyConfigClient{
rancherClient: rancherClient,
}
}
func (c *HaproxyConfigClient) Create(container *HaproxyConfig) (*HaproxyConfig, error) {
resp := &HaproxyConfig{}
err := c.rancherClient.doCreate(HAPROXY_CONFIG_TYPE, container, resp)
return resp, err
}
func (c *HaproxyConfigClient) Update(existing *HaproxyConfig, updates interface{}) (*HaproxyConfig, error) {
resp := &HaproxyConfig{}
err := c.rancherClient.doUpdate(HAPROXY_CONFIG_TYPE, &existing.Resource, updates, resp)
return resp, err
}
func (c *HaproxyConfigClient) List(opts *ListOpts) (*HaproxyConfigCollection, error) {
resp := &HaproxyConfigCollection{}
err := c.rancherClient.doList(HAPROXY_CONFIG_TYPE, opts, resp)
return resp, err
}
func (c *HaproxyConfigClient) ById(id string) (*HaproxyConfig, error) {
resp := &HaproxyConfig{}
err := c.rancherClient.doById(HAPROXY_CONFIG_TYPE, id, resp)
if apiError, ok := err.(*ApiError); ok {
if apiError.StatusCode == 404 {
return nil, nil
}
}
return resp, err
}
func (c *HaproxyConfigClient) Delete(container *HaproxyConfig) error {
return c.rancherClient.doResourceDelete(HAPROXY_CONFIG_TYPE, &container.Resource)
}

119
vendor/github.com/rancher/go-rancher/client/generated_healthcheck_instance_host_map.go generated vendored Normal file
View File

@ -0,0 +1,119 @@
package client
const (
HEALTHCHECK_INSTANCE_HOST_MAP_TYPE = "healthcheckInstanceHostMap"
)
type HealthcheckInstanceHostMap struct {
Resource
AccountId string `json:"accountId,omitempty" yaml:"account_id,omitempty"`
Created string `json:"created,omitempty" yaml:"created,omitempty"`
Data map[string]interface{} `json:"data,omitempty" yaml:"data,omitempty"`
Description string `json:"description,omitempty" yaml:"description,omitempty"`
HealthState string `json:"healthState,omitempty" yaml:"health_state,omitempty"`
HostId string `json:"hostId,omitempty" yaml:"host_id,omitempty"`
InstanceId string `json:"instanceId,omitempty" yaml:"instance_id,omitempty"`
Kind string `json:"kind,omitempty" yaml:"kind,omitempty"`
Name string `json:"name,omitempty" yaml:"name,omitempty"`
RemoveTime string `json:"removeTime,omitempty" yaml:"remove_time,omitempty"`
Removed string `json:"removed,omitempty" yaml:"removed,omitempty"`
State string `json:"state,omitempty" yaml:"state,omitempty"`
Transitioning string `json:"transitioning,omitempty" yaml:"transitioning,omitempty"`
TransitioningMessage string `json:"transitioningMessage,omitempty" yaml:"transitioning_message,omitempty"`
TransitioningProgress int64 `json:"transitioningProgress,omitempty" yaml:"transitioning_progress,omitempty"`
Uuid string `json:"uuid,omitempty" yaml:"uuid,omitempty"`
}
type HealthcheckInstanceHostMapCollection struct {
Collection
Data []HealthcheckInstanceHostMap `json:"data,omitempty"`
}
type HealthcheckInstanceHostMapClient struct {
rancherClient *RancherClient
}
type HealthcheckInstanceHostMapOperations interface {
List(opts *ListOpts) (*HealthcheckInstanceHostMapCollection, error)
Create(opts *HealthcheckInstanceHostMap) (*HealthcheckInstanceHostMap, error)
Update(existing *HealthcheckInstanceHostMap, updates interface{}) (*HealthcheckInstanceHostMap, error)
ById(id string) (*HealthcheckInstanceHostMap, error)
Delete(container *HealthcheckInstanceHostMap) error
ActionCreate(*HealthcheckInstanceHostMap) (*HealthcheckInstanceHostMap, error)
ActionRemove(*HealthcheckInstanceHostMap) (*HealthcheckInstanceHostMap, error)
}
func newHealthcheckInstanceHostMapClient(rancherClient *RancherClient) *HealthcheckInstanceHostMapClient {
return &HealthcheckInstanceHostMapClient{
rancherClient: rancherClient,
}
}
func (c *HealthcheckInstanceHostMapClient) Create(container *HealthcheckInstanceHostMap) (*HealthcheckInstanceHostMap, error) {
resp := &HealthcheckInstanceHostMap{}
err := c.rancherClient.doCreate(HEALTHCHECK_INSTANCE_HOST_MAP_TYPE, container, resp)
return resp, err
}
func (c *HealthcheckInstanceHostMapClient) Update(existing *HealthcheckInstanceHostMap, updates interface{}) (*HealthcheckInstanceHostMap, error) {
resp := &HealthcheckInstanceHostMap{}
err := c.rancherClient.doUpdate(HEALTHCHECK_INSTANCE_HOST_MAP_TYPE, &existing.Resource, updates, resp)
return resp, err
}
func (c *HealthcheckInstanceHostMapClient) List(opts *ListOpts) (*HealthcheckInstanceHostMapCollection, error) {
resp := &HealthcheckInstanceHostMapCollection{}
err := c.rancherClient.doList(HEALTHCHECK_INSTANCE_HOST_MAP_TYPE, opts, resp)
return resp, err
}
func (c *HealthcheckInstanceHostMapClient) ById(id string) (*HealthcheckInstanceHostMap, error) {
resp := &HealthcheckInstanceHostMap{}
err := c.rancherClient.doById(HEALTHCHECK_INSTANCE_HOST_MAP_TYPE, id, resp)
if apiError, ok := err.(*ApiError); ok {
if apiError.StatusCode == 404 {
return nil, nil
}
}
return resp, err
}
func (c *HealthcheckInstanceHostMapClient) Delete(container *HealthcheckInstanceHostMap) error {
return c.rancherClient.doResourceDelete(HEALTHCHECK_INSTANCE_HOST_MAP_TYPE, &container.Resource)
}
func (c *HealthcheckInstanceHostMapClient) ActionCreate(resource *HealthcheckInstanceHostMap) (*HealthcheckInstanceHostMap, error) {
resp := &HealthcheckInstanceHostMap{}
err := c.rancherClient.doAction(HEALTHCHECK_INSTANCE_HOST_MAP_TYPE, "create", &resource.Resource, nil, resp)
return resp, err
}
func (c *HealthcheckInstanceHostMapClient) ActionRemove(resource *HealthcheckInstanceHostMap) (*HealthcheckInstanceHostMap, error) {
resp := &HealthcheckInstanceHostMap{}
err := c.rancherClient.doAction(HEALTHCHECK_INSTANCE_HOST_MAP_TYPE, "remove", &resource.Resource, nil, resp)
return resp, err
}

197
vendor/github.com/rancher/go-rancher/client/generated_host.go generated vendored Normal file
View File

@ -0,0 +1,197 @@
package client
const (
HOST_TYPE = "host"
)
type Host struct {
Resource
AccountId string `json:"accountId,omitempty" yaml:"account_id,omitempty"`
AgentId string `json:"agentId,omitempty" yaml:"agent_id,omitempty"`
AgentState string `json:"agentState,omitempty" yaml:"agent_state,omitempty"`
ApiProxy string `json:"apiProxy,omitempty" yaml:"api_proxy,omitempty"`
ComputeTotal int64 `json:"computeTotal,omitempty" yaml:"compute_total,omitempty"`
Created string `json:"created,omitempty" yaml:"created,omitempty"`
Data map[string]interface{} `json:"data,omitempty" yaml:"data,omitempty"`
Description string `json:"description,omitempty" yaml:"description,omitempty"`
Hostname string `json:"hostname,omitempty" yaml:"hostname,omitempty"`
Info interface{} `json:"info,omitempty" yaml:"info,omitempty"`
Kind string `json:"kind,omitempty" yaml:"kind,omitempty"`
Labels map[string]interface{} `json:"labels,omitempty" yaml:"labels,omitempty"`
Name string `json:"name,omitempty" yaml:"name,omitempty"`
PhysicalHostId string `json:"physicalHostId,omitempty" yaml:"physical_host_id,omitempty"`
PublicEndpoints []interface{} `json:"publicEndpoints,omitempty" yaml:"public_endpoints,omitempty"`
RemoveTime string `json:"removeTime,omitempty" yaml:"remove_time,omitempty"`
Removed string `json:"removed,omitempty" yaml:"removed,omitempty"`
State string `json:"state,omitempty" yaml:"state,omitempty"`
Transitioning string `json:"transitioning,omitempty" yaml:"transitioning,omitempty"`
TransitioningMessage string `json:"transitioningMessage,omitempty" yaml:"transitioning_message,omitempty"`
TransitioningProgress int64 `json:"transitioningProgress,omitempty" yaml:"transitioning_progress,omitempty"`
Uuid string `json:"uuid,omitempty" yaml:"uuid,omitempty"`
}
type HostCollection struct {
Collection
Data []Host `json:"data,omitempty"`
}
type HostClient struct {
rancherClient *RancherClient
}
type HostOperations interface {
List(opts *ListOpts) (*HostCollection, error)
Create(opts *Host) (*Host, error)
Update(existing *Host, updates interface{}) (*Host, error)
ById(id string) (*Host, error)
Delete(container *Host) error
ActionActivate(*Host) (*Host, error)
ActionCreate(*Host) (*Host, error)
ActionDeactivate(*Host) (*Host, error)
ActionDockersocket(*Host) (*HostAccess, error)
ActionPurge(*Host) (*Host, error)
ActionRemove(*Host) (*Host, error)
ActionRestore(*Host) (*Host, error)
ActionUpdate(*Host) (*Host, error)
}
func newHostClient(rancherClient *RancherClient) *HostClient {
return &HostClient{
rancherClient: rancherClient,
}
}
func (c *HostClient) Create(container *Host) (*Host, error) {
resp := &Host{}
err := c.rancherClient.doCreate(HOST_TYPE, container, resp)
return resp, err
}
func (c *HostClient) Update(existing *Host, updates interface{}) (*Host, error) {
resp := &Host{}
err := c.rancherClient.doUpdate(HOST_TYPE, &existing.Resource, updates, resp)
return resp, err
}
func (c *HostClient) List(opts *ListOpts) (*HostCollection, error) {
resp := &HostCollection{}
err := c.rancherClient.doList(HOST_TYPE, opts, resp)
return resp, err
}
func (c *HostClient) ById(id string) (*Host, error) {
resp := &Host{}
err := c.rancherClient.doById(HOST_TYPE, id, resp)
if apiError, ok := err.(*ApiError); ok {
if apiError.StatusCode == 404 {
return nil, nil
}
}
return resp, err
}
func (c *HostClient) Delete(container *Host) error {
return c.rancherClient.doResourceDelete(HOST_TYPE, &container.Resource)
}
func (c *HostClient) ActionActivate(resource *Host) (*Host, error) {
resp := &Host{}
err := c.rancherClient.doAction(HOST_TYPE, "activate", &resource.Resource, nil, resp)
return resp, err
}
func (c *HostClient) ActionCreate(resource *Host) (*Host, error) {
resp := &Host{}
err := c.rancherClient.doAction(HOST_TYPE, "create", &resource.Resource, nil, resp)
return resp, err
}
func (c *HostClient) ActionDeactivate(resource *Host) (*Host, error) {
resp := &Host{}
err := c.rancherClient.doAction(HOST_TYPE, "deactivate", &resource.Resource, nil, resp)
return resp, err
}
func (c *HostClient) ActionDockersocket(resource *Host) (*HostAccess, error) {
resp := &HostAccess{}
err := c.rancherClient.doAction(HOST_TYPE, "dockersocket", &resource.Resource, nil, resp)
return resp, err
}
func (c *HostClient) ActionPurge(resource *Host) (*Host, error) {
resp := &Host{}
err := c.rancherClient.doAction(HOST_TYPE, "purge", &resource.Resource, nil, resp)
return resp, err
}
func (c *HostClient) ActionRemove(resource *Host) (*Host, error) {
resp := &Host{}
err := c.rancherClient.doAction(HOST_TYPE, "remove", &resource.Resource, nil, resp)
return resp, err
}
func (c *HostClient) ActionRestore(resource *Host) (*Host, error) {
resp := &Host{}
err := c.rancherClient.doAction(HOST_TYPE, "restore", &resource.Resource, nil, resp)
return resp, err
}
func (c *HostClient) ActionUpdate(resource *Host) (*Host, error) {
resp := &Host{}
err := c.rancherClient.doAction(HOST_TYPE, "update", &resource.Resource, nil, resp)
return resp, err
}

69
vendor/github.com/rancher/go-rancher/client/generated_host_access.go generated vendored Normal file
View File

@ -0,0 +1,69 @@
package client
const (
HOST_ACCESS_TYPE = "hostAccess"
)
type HostAccess struct {
Resource
Token string `json:"token,omitempty" yaml:"token,omitempty"`
Url string `json:"url,omitempty" yaml:"url,omitempty"`
}
type HostAccessCollection struct {
Collection
Data []HostAccess `json:"data,omitempty"`
}
type HostAccessClient struct {
rancherClient *RancherClient
}
type HostAccessOperations interface {
List(opts *ListOpts) (*HostAccessCollection, error)
Create(opts *HostAccess) (*HostAccess, error)
Update(existing *HostAccess, updates interface{}) (*HostAccess, error)
ById(id string) (*HostAccess, error)
Delete(container *HostAccess) error
}
func newHostAccessClient(rancherClient *RancherClient) *HostAccessClient {
return &HostAccessClient{
rancherClient: rancherClient,
}
}
func (c *HostAccessClient) Create(container *HostAccess) (*HostAccess, error) {
resp := &HostAccess{}
err := c.rancherClient.doCreate(HOST_ACCESS_TYPE, container, resp)
return resp, err
}
func (c *HostAccessClient) Update(existing *HostAccess, updates interface{}) (*HostAccess, error) {
resp := &HostAccess{}
err := c.rancherClient.doUpdate(HOST_ACCESS_TYPE, &existing.Resource, updates, resp)
return resp, err
}
func (c *HostAccessClient) List(opts *ListOpts) (*HostAccessCollection, error) {
resp := &HostAccessCollection{}
err := c.rancherClient.doList(HOST_ACCESS_TYPE, opts, resp)
return resp, err
}
func (c *HostAccessClient) ById(id string) (*HostAccess, error) {
resp := &HostAccess{}
err := c.rancherClient.doById(HOST_ACCESS_TYPE, id, resp)
if apiError, ok := err.(*ApiError); ok {
if apiError.StatusCode == 404 {
return nil, nil
}
}
return resp, err
}
func (c *HostAccessClient) Delete(container *HostAccess) error {
return c.rancherClient.doResourceDelete(HOST_ACCESS_TYPE, &container.Resource)
}

71
vendor/github.com/rancher/go-rancher/client/generated_host_api_proxy_token.go generated vendored Normal file
View File

@ -0,0 +1,71 @@
package client
const (
HOST_API_PROXY_TOKEN_TYPE = "hostApiProxyToken"
)
type HostApiProxyToken struct {
Resource
ReportedUuid string `json:"reportedUuid,omitempty" yaml:"reported_uuid,omitempty"`
Token string `json:"token,omitempty" yaml:"token,omitempty"`
Url string `json:"url,omitempty" yaml:"url,omitempty"`
}
type HostApiProxyTokenCollection struct {
Collection
Data []HostApiProxyToken `json:"data,omitempty"`
}
type HostApiProxyTokenClient struct {
rancherClient *RancherClient
}
type HostApiProxyTokenOperations interface {
List(opts *ListOpts) (*HostApiProxyTokenCollection, error)
Create(opts *HostApiProxyToken) (*HostApiProxyToken, error)
Update(existing *HostApiProxyToken, updates interface{}) (*HostApiProxyToken, error)
ById(id string) (*HostApiProxyToken, error)
Delete(container *HostApiProxyToken) error
}
func newHostApiProxyTokenClient(rancherClient *RancherClient) *HostApiProxyTokenClient {
return &HostApiProxyTokenClient{
rancherClient: rancherClient,
}
}
func (c *HostApiProxyTokenClient) Create(container *HostApiProxyToken) (*HostApiProxyToken, error) {
resp := &HostApiProxyToken{}
err := c.rancherClient.doCreate(HOST_API_PROXY_TOKEN_TYPE, container, resp)
return resp, err
}
func (c *HostApiProxyTokenClient) Update(existing *HostApiProxyToken, updates interface{}) (*HostApiProxyToken, error) {
resp := &HostApiProxyToken{}
err := c.rancherClient.doUpdate(HOST_API_PROXY_TOKEN_TYPE, &existing.Resource, updates, resp)
return resp, err
}
func (c *HostApiProxyTokenClient) List(opts *ListOpts) (*HostApiProxyTokenCollection, error) {
resp := &HostApiProxyTokenCollection{}
err := c.rancherClient.doList(HOST_API_PROXY_TOKEN_TYPE, opts, resp)
return resp, err
}
func (c *HostApiProxyTokenClient) ById(id string) (*HostApiProxyToken, error) {
resp := &HostApiProxyToken{}
err := c.rancherClient.doById(HOST_API_PROXY_TOKEN_TYPE, id, resp)
if apiError, ok := err.(*ApiError); ok {
if apiError.StatusCode == 404 {
return nil, nil
}
}
return resp, err
}
func (c *HostApiProxyTokenClient) Delete(container *HostApiProxyToken) error {
return c.rancherClient.doResourceDelete(HOST_API_PROXY_TOKEN_TYPE, &container.Resource)
}

83
vendor/github.com/rancher/go-rancher/client/generated_identity.go generated vendored Normal file
View File

@ -0,0 +1,83 @@
package client
const (
IDENTITY_TYPE = "identity"
)
type Identity struct {
Resource
All string `json:"all,omitempty" yaml:"all,omitempty"`
ExternalId string `json:"externalId,omitempty" yaml:"external_id,omitempty"`
ExternalIdType string `json:"externalIdType,omitempty" yaml:"external_id_type,omitempty"`
Login string `json:"login,omitempty" yaml:"login,omitempty"`
Name string `json:"name,omitempty" yaml:"name,omitempty"`
ProfilePicture string `json:"profilePicture,omitempty" yaml:"profile_picture,omitempty"`
ProfileUrl string `json:"profileUrl,omitempty" yaml:"profile_url,omitempty"`
ProjectId string `json:"projectId,omitempty" yaml:"project_id,omitempty"`
Role string `json:"role,omitempty" yaml:"role,omitempty"`
}
type IdentityCollection struct {
Collection
Data []Identity `json:"data,omitempty"`
}
type IdentityClient struct {
rancherClient *RancherClient
}
type IdentityOperations interface {
List(opts *ListOpts) (*IdentityCollection, error)
Create(opts *Identity) (*Identity, error)
Update(existing *Identity, updates interface{}) (*Identity, error)
ById(id string) (*Identity, error)
Delete(container *Identity) error
}
func newIdentityClient(rancherClient *RancherClient) *IdentityClient {
return &IdentityClient{
rancherClient: rancherClient,
}
}
func (c *IdentityClient) Create(container *Identity) (*Identity, error) {
resp := &Identity{}
err := c.rancherClient.doCreate(IDENTITY_TYPE, container, resp)
return resp, err
}
func (c *IdentityClient) Update(existing *Identity, updates interface{}) (*Identity, error) {
resp := &Identity{}
err := c.rancherClient.doUpdate(IDENTITY_TYPE, &existing.Resource, updates, resp)
return resp, err
}
func (c *IdentityClient) List(opts *ListOpts) (*IdentityCollection, error) {
resp := &IdentityCollection{}
err := c.rancherClient.doList(IDENTITY_TYPE, opts, resp)
return resp, err
}
func (c *IdentityClient) ById(id string) (*Identity, error) {
resp := &Identity{}
err := c.rancherClient.doById(IDENTITY_TYPE, id, resp)
if apiError, ok := err.(*ApiError); ok {
if apiError.StatusCode == 404 {
return nil, nil
}
}
return resp, err
}
func (c *IdentityClient) Delete(container *Identity) error {
return c.rancherClient.doResourceDelete(IDENTITY_TYPE, &container.Resource)
}

168
vendor/github.com/rancher/go-rancher/client/generated_image.go generated vendored Normal file
View File

@ -0,0 +1,168 @@
package client
const (
IMAGE_TYPE = "image"
)
type Image struct {
Resource
AccountId string `json:"accountId,omitempty" yaml:"account_id,omitempty"`
Created string `json:"created,omitempty" yaml:"created,omitempty"`
Data map[string]interface{} `json:"data,omitempty" yaml:"data,omitempty"`
Description string `json:"description,omitempty" yaml:"description,omitempty"`
Kind string `json:"kind,omitempty" yaml:"kind,omitempty"`
Name string `json:"name,omitempty" yaml:"name,omitempty"`
RemoveTime string `json:"removeTime,omitempty" yaml:"remove_time,omitempty"`
Removed string `json:"removed,omitempty" yaml:"removed,omitempty"`
State string `json:"state,omitempty" yaml:"state,omitempty"`
Transitioning string `json:"transitioning,omitempty" yaml:"transitioning,omitempty"`
TransitioningMessage string `json:"transitioningMessage,omitempty" yaml:"transitioning_message,omitempty"`
TransitioningProgress int64 `json:"transitioningProgress,omitempty" yaml:"transitioning_progress,omitempty"`
Uuid string `json:"uuid,omitempty" yaml:"uuid,omitempty"`
}
type ImageCollection struct {
Collection
Data []Image `json:"data,omitempty"`
}
type ImageClient struct {
rancherClient *RancherClient
}
type ImageOperations interface {
List(opts *ListOpts) (*ImageCollection, error)
Create(opts *Image) (*Image, error)
Update(existing *Image, updates interface{}) (*Image, error)
ById(id string) (*Image, error)
Delete(container *Image) error
ActionActivate(*Image) (*Image, error)
ActionCreate(*Image) (*Image, error)
ActionDeactivate(*Image) (*Image, error)
ActionPurge(*Image) (*Image, error)
ActionRemove(*Image) (*Image, error)
ActionRestore(*Image) (*Image, error)
ActionUpdate(*Image) (*Image, error)
}
func newImageClient(rancherClient *RancherClient) *ImageClient {
return &ImageClient{
rancherClient: rancherClient,
}
}
func (c *ImageClient) Create(container *Image) (*Image, error) {
resp := &Image{}
err := c.rancherClient.doCreate(IMAGE_TYPE, container, resp)
return resp, err
}
func (c *ImageClient) Update(existing *Image, updates interface{}) (*Image, error) {
resp := &Image{}
err := c.rancherClient.doUpdate(IMAGE_TYPE, &existing.Resource, updates, resp)
return resp, err
}
func (c *ImageClient) List(opts *ListOpts) (*ImageCollection, error) {
resp := &ImageCollection{}
err := c.rancherClient.doList(IMAGE_TYPE, opts, resp)
return resp, err
}
func (c *ImageClient) ById(id string) (*Image, error) {
resp := &Image{}
err := c.rancherClient.doById(IMAGE_TYPE, id, resp)
if apiError, ok := err.(*ApiError); ok {
if apiError.StatusCode == 404 {
return nil, nil
}
}
return resp, err
}
func (c *ImageClient) Delete(container *Image) error {
return c.rancherClient.doResourceDelete(IMAGE_TYPE, &container.Resource)
}
func (c *ImageClient) ActionActivate(resource *Image) (*Image, error) {
resp := &Image{}
err := c.rancherClient.doAction(IMAGE_TYPE, "activate", &resource.Resource, nil, resp)
return resp, err
}
func (c *ImageClient) ActionCreate(resource *Image) (*Image, error) {
resp := &Image{}
err := c.rancherClient.doAction(IMAGE_TYPE, "create", &resource.Resource, nil, resp)
return resp, err
}
func (c *ImageClient) ActionDeactivate(resource *Image) (*Image, error) {
resp := &Image{}
err := c.rancherClient.doAction(IMAGE_TYPE, "deactivate", &resource.Resource, nil, resp)
return resp, err
}
func (c *ImageClient) ActionPurge(resource *Image) (*Image, error) {
resp := &Image{}
err := c.rancherClient.doAction(IMAGE_TYPE, "purge", &resource.Resource, nil, resp)
return resp, err
}
func (c *ImageClient) ActionRemove(resource *Image) (*Image, error) {
resp := &Image{}
err := c.rancherClient.doAction(IMAGE_TYPE, "remove", &resource.Resource, nil, resp)
return resp, err
}
func (c *ImageClient) ActionRestore(resource *Image) (*Image, error) {
resp := &Image{}
err := c.rancherClient.doAction(IMAGE_TYPE, "restore", &resource.Resource, nil, resp)
return resp, err
}
func (c *ImageClient) ActionUpdate(resource *Image) (*Image, error) {
resp := &Image{}
err := c.rancherClient.doAction(IMAGE_TYPE, "update", &resource.Resource, nil, resp)
return resp, err
}

79
vendor/github.com/rancher/go-rancher/client/generated_in_service_upgrade_strategy.go generated vendored Normal file
View File

@ -0,0 +1,79 @@
package client
const (
IN_SERVICE_UPGRADE_STRATEGY_TYPE = "inServiceUpgradeStrategy"
)
type InServiceUpgradeStrategy struct {
Resource
BatchSize int64 `json:"batchSize,omitempty" yaml:"batch_size,omitempty"`
IntervalMillis int64 `json:"intervalMillis,omitempty" yaml:"interval_millis,omitempty"`
LaunchConfig *LaunchConfig `json:"launchConfig,omitempty" yaml:"launch_config,omitempty"`
PreviousLaunchConfig *LaunchConfig `json:"previousLaunchConfig,omitempty" yaml:"previous_launch_config,omitempty"`
PreviousSecondaryLaunchConfigs []interface{} `json:"previousSecondaryLaunchConfigs,omitempty" yaml:"previous_secondary_launch_configs,omitempty"`
SecondaryLaunchConfigs []interface{} `json:"secondaryLaunchConfigs,omitempty" yaml:"secondary_launch_configs,omitempty"`
StartFirst bool `json:"startFirst,omitempty" yaml:"start_first,omitempty"`
}
type InServiceUpgradeStrategyCollection struct {
Collection
Data []InServiceUpgradeStrategy `json:"data,omitempty"`
}
type InServiceUpgradeStrategyClient struct {
rancherClient *RancherClient
}
type InServiceUpgradeStrategyOperations interface {
List(opts *ListOpts) (*InServiceUpgradeStrategyCollection, error)
Create(opts *InServiceUpgradeStrategy) (*InServiceUpgradeStrategy, error)
Update(existing *InServiceUpgradeStrategy, updates interface{}) (*InServiceUpgradeStrategy, error)
ById(id string) (*InServiceUpgradeStrategy, error)
Delete(container *InServiceUpgradeStrategy) error
}
func newInServiceUpgradeStrategyClient(rancherClient *RancherClient) *InServiceUpgradeStrategyClient {
return &InServiceUpgradeStrategyClient{
rancherClient: rancherClient,
}
}
func (c *InServiceUpgradeStrategyClient) Create(container *InServiceUpgradeStrategy) (*InServiceUpgradeStrategy, error) {
resp := &InServiceUpgradeStrategy{}
err := c.rancherClient.doCreate(IN_SERVICE_UPGRADE_STRATEGY_TYPE, container, resp)
return resp, err
}
func (c *InServiceUpgradeStrategyClient) Update(existing *InServiceUpgradeStrategy, updates interface{}) (*InServiceUpgradeStrategy, error) {
resp := &InServiceUpgradeStrategy{}
err := c.rancherClient.doUpdate(IN_SERVICE_UPGRADE_STRATEGY_TYPE, &existing.Resource, updates, resp)
return resp, err
}
func (c *InServiceUpgradeStrategyClient) List(opts *ListOpts) (*InServiceUpgradeStrategyCollection, error) {
resp := &InServiceUpgradeStrategyCollection{}
err := c.rancherClient.doList(IN_SERVICE_UPGRADE_STRATEGY_TYPE, opts, resp)
return resp, err
}
func (c *InServiceUpgradeStrategyClient) ById(id string) (*InServiceUpgradeStrategy, error) {
resp := &InServiceUpgradeStrategy{}
err := c.rancherClient.doById(IN_SERVICE_UPGRADE_STRATEGY_TYPE, id, resp)
if apiError, ok := err.(*ApiError); ok {
if apiError.StatusCode == 404 {
return nil, nil
}
}
return resp, err
}
func (c *InServiceUpgradeStrategyClient) Delete(container *InServiceUpgradeStrategy) error {
return c.rancherClient.doResourceDelete(IN_SERVICE_UPGRADE_STRATEGY_TYPE, &container.Resource)
}

271
vendor/github.com/rancher/go-rancher/client/generated_instance.go generated vendored Normal file
View File

@ -0,0 +1,271 @@
package client
const (
INSTANCE_TYPE = "instance"
)
type Instance struct {
Resource
AccountId string `json:"accountId,omitempty" yaml:"account_id,omitempty"`
Created string `json:"created,omitempty" yaml:"created,omitempty"`
Data map[string]interface{} `json:"data,omitempty" yaml:"data,omitempty"`
Description string `json:"description,omitempty" yaml:"description,omitempty"`
ExternalId string `json:"externalId,omitempty" yaml:"external_id,omitempty"`
HostId string `json:"hostId,omitempty" yaml:"host_id,omitempty"`
Kind string `json:"kind,omitempty" yaml:"kind,omitempty"`
Name string `json:"name,omitempty" yaml:"name,omitempty"`
RemoveTime string `json:"removeTime,omitempty" yaml:"remove_time,omitempty"`
Removed string `json:"removed,omitempty" yaml:"removed,omitempty"`
State string `json:"state,omitempty" yaml:"state,omitempty"`
Transitioning string `json:"transitioning,omitempty" yaml:"transitioning,omitempty"`
TransitioningMessage string `json:"transitioningMessage,omitempty" yaml:"transitioning_message,omitempty"`
TransitioningProgress int64 `json:"transitioningProgress,omitempty" yaml:"transitioning_progress,omitempty"`
Uuid string `json:"uuid,omitempty" yaml:"uuid,omitempty"`
}
type InstanceCollection struct {
Collection
Data []Instance `json:"data,omitempty"`
}
type InstanceClient struct {
rancherClient *RancherClient
}
type InstanceOperations interface {
List(opts *ListOpts) (*InstanceCollection, error)
Create(opts *Instance) (*Instance, error)
Update(existing *Instance, updates interface{}) (*Instance, error)
ById(id string) (*Instance, error)
Delete(container *Instance) error
ActionAllocate(*Instance) (*Instance, error)
ActionConsole(*Instance, *InstanceConsoleInput) (*InstanceConsole, error)
ActionCreate(*Instance) (*Instance, error)
ActionDeallocate(*Instance) (*Instance, error)
ActionError(*Instance) (*Instance, error)
ActionMigrate(*Instance) (*Instance, error)
ActionPurge(*Instance) (*Instance, error)
ActionRemove(*Instance) (*Instance, error)
ActionRestart(*Instance) (*Instance, error)
ActionRestore(*Instance) (*Instance, error)
ActionStart(*Instance) (*Instance, error)
ActionStop(*Instance, *InstanceStop) (*Instance, error)
ActionUpdate(*Instance) (*Instance, error)
ActionUpdatehealthy(*Instance) (*Instance, error)
ActionUpdatereinitializing(*Instance) (*Instance, error)
ActionUpdateunhealthy(*Instance) (*Instance, error)
}
func newInstanceClient(rancherClient *RancherClient) *InstanceClient {
return &InstanceClient{
rancherClient: rancherClient,
}
}
func (c *InstanceClient) Create(container *Instance) (*Instance, error) {
resp := &Instance{}
err := c.rancherClient.doCreate(INSTANCE_TYPE, container, resp)
return resp, err
}
func (c *InstanceClient) Update(existing *Instance, updates interface{}) (*Instance, error) {
resp := &Instance{}
err := c.rancherClient.doUpdate(INSTANCE_TYPE, &existing.Resource, updates, resp)
return resp, err
}
func (c *InstanceClient) List(opts *ListOpts) (*InstanceCollection, error) {
resp := &InstanceCollection{}
err := c.rancherClient.doList(INSTANCE_TYPE, opts, resp)
return resp, err
}
func (c *InstanceClient) ById(id string) (*Instance, error) {
resp := &Instance{}
err := c.rancherClient.doById(INSTANCE_TYPE, id, resp)
if apiError, ok := err.(*ApiError); ok {
if apiError.StatusCode == 404 {
return nil, nil
}
}
return resp, err
}
func (c *InstanceClient) Delete(container *Instance) error {
return c.rancherClient.doResourceDelete(INSTANCE_TYPE, &container.Resource)
}
func (c *InstanceClient) ActionAllocate(resource *Instance) (*Instance, error) {
resp := &Instance{}
err := c.rancherClient.doAction(INSTANCE_TYPE, "allocate", &resource.Resource, nil, resp)
return resp, err
}
func (c *InstanceClient) ActionConsole(resource *Instance, input *InstanceConsoleInput) (*InstanceConsole, error) {
resp := &InstanceConsole{}
err := c.rancherClient.doAction(INSTANCE_TYPE, "console", &resource.Resource, input, resp)
return resp, err
}
func (c *InstanceClient) ActionCreate(resource *Instance) (*Instance, error) {
resp := &Instance{}
err := c.rancherClient.doAction(INSTANCE_TYPE, "create", &resource.Resource, nil, resp)
return resp, err
}
func (c *InstanceClient) ActionDeallocate(resource *Instance) (*Instance, error) {
resp := &Instance{}
err := c.rancherClient.doAction(INSTANCE_TYPE, "deallocate", &resource.Resource, nil, resp)
return resp, err
}
func (c *InstanceClient) ActionError(resource *Instance) (*Instance, error) {
resp := &Instance{}
err := c.rancherClient.doAction(INSTANCE_TYPE, "error", &resource.Resource, nil, resp)
return resp, err
}
func (c *InstanceClient) ActionMigrate(resource *Instance) (*Instance, error) {
resp := &Instance{}
err := c.rancherClient.doAction(INSTANCE_TYPE, "migrate", &resource.Resource, nil, resp)
return resp, err
}
func (c *InstanceClient) ActionPurge(resource *Instance) (*Instance, error) {
resp := &Instance{}
err := c.rancherClient.doAction(INSTANCE_TYPE, "purge", &resource.Resource, nil, resp)
return resp, err
}
func (c *InstanceClient) ActionRemove(resource *Instance) (*Instance, error) {
resp := &Instance{}
err := c.rancherClient.doAction(INSTANCE_TYPE, "remove", &resource.Resource, nil, resp)
return resp, err
}
func (c *InstanceClient) ActionRestart(resource *Instance) (*Instance, error) {
resp := &Instance{}
err := c.rancherClient.doAction(INSTANCE_TYPE, "restart", &resource.Resource, nil, resp)
return resp, err
}
func (c *InstanceClient) ActionRestore(resource *Instance) (*Instance, error) {
resp := &Instance{}
err := c.rancherClient.doAction(INSTANCE_TYPE, "restore", &resource.Resource, nil, resp)
return resp, err
}
func (c *InstanceClient) ActionStart(resource *Instance) (*Instance, error) {
resp := &Instance{}
err := c.rancherClient.doAction(INSTANCE_TYPE, "start", &resource.Resource, nil, resp)
return resp, err
}
func (c *InstanceClient) ActionStop(resource *Instance, input *InstanceStop) (*Instance, error) {
resp := &Instance{}
err := c.rancherClient.doAction(INSTANCE_TYPE, "stop", &resource.Resource, input, resp)
return resp, err
}
func (c *InstanceClient) ActionUpdate(resource *Instance) (*Instance, error) {
resp := &Instance{}
err := c.rancherClient.doAction(INSTANCE_TYPE, "update", &resource.Resource, nil, resp)
return resp, err
}
func (c *InstanceClient) ActionUpdatehealthy(resource *Instance) (*Instance, error) {
resp := &Instance{}
err := c.rancherClient.doAction(INSTANCE_TYPE, "updatehealthy", &resource.Resource, nil, resp)
return resp, err
}
func (c *InstanceClient) ActionUpdatereinitializing(resource *Instance) (*Instance, error) {
resp := &Instance{}
err := c.rancherClient.doAction(INSTANCE_TYPE, "updatereinitializing", &resource.Resource, nil, resp)
return resp, err
}
func (c *InstanceClient) ActionUpdateunhealthy(resource *Instance) (*Instance, error) {
resp := &Instance{}
err := c.rancherClient.doAction(INSTANCE_TYPE, "updateunhealthy", &resource.Resource, nil, resp)
return resp, err
}

71
vendor/github.com/rancher/go-rancher/client/generated_instance_console.go generated vendored Normal file
View File

@ -0,0 +1,71 @@
package client
const (
INSTANCE_CONSOLE_TYPE = "instanceConsole"
)
type InstanceConsole struct {
Resource
Kind string `json:"kind,omitempty" yaml:"kind,omitempty"`
Password string `json:"password,omitempty" yaml:"password,omitempty"`
Url string `json:"url,omitempty" yaml:"url,omitempty"`
}
type InstanceConsoleCollection struct {
Collection
Data []InstanceConsole `json:"data,omitempty"`
}
type InstanceConsoleClient struct {
rancherClient *RancherClient
}
type InstanceConsoleOperations interface {
List(opts *ListOpts) (*InstanceConsoleCollection, error)
Create(opts *InstanceConsole) (*InstanceConsole, error)
Update(existing *InstanceConsole, updates interface{}) (*InstanceConsole, error)
ById(id string) (*InstanceConsole, error)
Delete(container *InstanceConsole) error
}
func newInstanceConsoleClient(rancherClient *RancherClient) *InstanceConsoleClient {
return &InstanceConsoleClient{
rancherClient: rancherClient,
}
}
func (c *InstanceConsoleClient) Create(container *InstanceConsole) (*InstanceConsole, error) {
resp := &InstanceConsole{}
err := c.rancherClient.doCreate(INSTANCE_CONSOLE_TYPE, container, resp)
return resp, err
}
func (c *InstanceConsoleClient) Update(existing *InstanceConsole, updates interface{}) (*InstanceConsole, error) {
resp := &InstanceConsole{}
err := c.rancherClient.doUpdate(INSTANCE_CONSOLE_TYPE, &existing.Resource, updates, resp)
return resp, err
}
func (c *InstanceConsoleClient) List(opts *ListOpts) (*InstanceConsoleCollection, error) {
resp := &InstanceConsoleCollection{}
err := c.rancherClient.doList(INSTANCE_CONSOLE_TYPE, opts, resp)
return resp, err
}
func (c *InstanceConsoleClient) ById(id string) (*InstanceConsole, error) {
resp := &InstanceConsole{}
err := c.rancherClient.doById(INSTANCE_CONSOLE_TYPE, id, resp)
if apiError, ok := err.(*ApiError); ok {
if apiError.StatusCode == 404 {
return nil, nil
}
}
return resp, err
}
func (c *InstanceConsoleClient) Delete(container *InstanceConsole) error {
return c.rancherClient.doResourceDelete(INSTANCE_CONSOLE_TYPE, &container.Resource)
}

65
vendor/github.com/rancher/go-rancher/client/generated_instance_console_input.go generated vendored Normal file
View File

@ -0,0 +1,65 @@
package client
const (
INSTANCE_CONSOLE_INPUT_TYPE = "instanceConsoleInput"
)
type InstanceConsoleInput struct {
Resource
}
type InstanceConsoleInputCollection struct {
Collection
Data []InstanceConsoleInput `json:"data,omitempty"`
}
type InstanceConsoleInputClient struct {
rancherClient *RancherClient
}
type InstanceConsoleInputOperations interface {
List(opts *ListOpts) (*InstanceConsoleInputCollection, error)
Create(opts *InstanceConsoleInput) (*InstanceConsoleInput, error)
Update(existing *InstanceConsoleInput, updates interface{}) (*InstanceConsoleInput, error)
ById(id string) (*InstanceConsoleInput, error)
Delete(container *InstanceConsoleInput) error
}
func newInstanceConsoleInputClient(rancherClient *RancherClient) *InstanceConsoleInputClient {
return &InstanceConsoleInputClient{
rancherClient: rancherClient,
}
}
func (c *InstanceConsoleInputClient) Create(container *InstanceConsoleInput) (*InstanceConsoleInput, error) {
resp := &InstanceConsoleInput{}
err := c.rancherClient.doCreate(INSTANCE_CONSOLE_INPUT_TYPE, container, resp)
return resp, err
}
func (c *InstanceConsoleInputClient) Update(existing *InstanceConsoleInput, updates interface{}) (*InstanceConsoleInput, error) {
resp := &InstanceConsoleInput{}
err := c.rancherClient.doUpdate(INSTANCE_CONSOLE_INPUT_TYPE, &existing.Resource, updates, resp)
return resp, err
}
func (c *InstanceConsoleInputClient) List(opts *ListOpts) (*InstanceConsoleInputCollection, error) {
resp := &InstanceConsoleInputCollection{}
err := c.rancherClient.doList(INSTANCE_CONSOLE_INPUT_TYPE, opts, resp)
return resp, err
}
func (c *InstanceConsoleInputClient) ById(id string) (*InstanceConsoleInput, error) {
resp := &InstanceConsoleInput{}
err := c.rancherClient.doById(INSTANCE_CONSOLE_INPUT_TYPE, id, resp)
if apiError, ok := err.(*ApiError); ok {
if apiError.StatusCode == 404 {
return nil, nil
}
}
return resp, err
}
func (c *InstanceConsoleInputClient) Delete(container *InstanceConsoleInput) error {
return c.rancherClient.doResourceDelete(INSTANCE_CONSOLE_INPUT_TYPE, &container.Resource)
}

87
vendor/github.com/rancher/go-rancher/client/generated_instance_health_check.go generated vendored Normal file
View File

@ -0,0 +1,87 @@
package client
const (
INSTANCE_HEALTH_CHECK_TYPE = "instanceHealthCheck"
)
type InstanceHealthCheck struct {
Resource
HealthyThreshold int64 `json:"healthyThreshold,omitempty" yaml:"healthy_threshold,omitempty"`
InitializingTimeout int64 `json:"initializingTimeout,omitempty" yaml:"initializing_timeout,omitempty"`
Interval int64 `json:"interval,omitempty" yaml:"interval,omitempty"`
Name string `json:"name,omitempty" yaml:"name,omitempty"`
Port int64 `json:"port,omitempty" yaml:"port,omitempty"`
RecreateOnQuorumStrategyConfig *RecreateOnQuorumStrategyConfig `json:"recreateOnQuorumStrategyConfig,omitempty" yaml:"recreate_on_quorum_strategy_config,omitempty"`
ReinitializingTimeout int64 `json:"reinitializingTimeout,omitempty" yaml:"reinitializing_timeout,omitempty"`
RequestLine string `json:"requestLine,omitempty" yaml:"request_line,omitempty"`
ResponseTimeout int64 `json:"responseTimeout,omitempty" yaml:"response_timeout,omitempty"`
Strategy string `json:"strategy,omitempty" yaml:"strategy,omitempty"`
UnhealthyThreshold int64 `json:"unhealthyThreshold,omitempty" yaml:"unhealthy_threshold,omitempty"`
}
type InstanceHealthCheckCollection struct {
Collection
Data []InstanceHealthCheck `json:"data,omitempty"`
}
type InstanceHealthCheckClient struct {
rancherClient *RancherClient
}
type InstanceHealthCheckOperations interface {
List(opts *ListOpts) (*InstanceHealthCheckCollection, error)
Create(opts *InstanceHealthCheck) (*InstanceHealthCheck, error)
Update(existing *InstanceHealthCheck, updates interface{}) (*InstanceHealthCheck, error)
ById(id string) (*InstanceHealthCheck, error)
Delete(container *InstanceHealthCheck) error
}
func newInstanceHealthCheckClient(rancherClient *RancherClient) *InstanceHealthCheckClient {
return &InstanceHealthCheckClient{
rancherClient: rancherClient,
}
}
func (c *InstanceHealthCheckClient) Create(container *InstanceHealthCheck) (*InstanceHealthCheck, error) {
resp := &InstanceHealthCheck{}
err := c.rancherClient.doCreate(INSTANCE_HEALTH_CHECK_TYPE, container, resp)
return resp, err
}
func (c *InstanceHealthCheckClient) Update(existing *InstanceHealthCheck, updates interface{}) (*InstanceHealthCheck, error) {
resp := &InstanceHealthCheck{}
err := c.rancherClient.doUpdate(INSTANCE_HEALTH_CHECK_TYPE, &existing.Resource, updates, resp)
return resp, err
}
func (c *InstanceHealthCheckClient) List(opts *ListOpts) (*InstanceHealthCheckCollection, error) {
resp := &InstanceHealthCheckCollection{}
err := c.rancherClient.doList(INSTANCE_HEALTH_CHECK_TYPE, opts, resp)
return resp, err
}
func (c *InstanceHealthCheckClient) ById(id string) (*InstanceHealthCheck, error) {
resp := &InstanceHealthCheck{}
err := c.rancherClient.doById(INSTANCE_HEALTH_CHECK_TYPE, id, resp)
if apiError, ok := err.(*ApiError); ok {
if apiError.StatusCode == 404 {
return nil, nil
}
}
return resp, err
}
func (c *InstanceHealthCheckClient) Delete(container *InstanceHealthCheck) error {
return c.rancherClient.doResourceDelete(INSTANCE_HEALTH_CHECK_TYPE, &container.Resource)
}

176
vendor/github.com/rancher/go-rancher/client/generated_instance_link.go generated vendored Normal file
View File

@ -0,0 +1,176 @@
package client
const (
INSTANCE_LINK_TYPE = "instanceLink"
)
type InstanceLink struct {
Resource
AccountId string `json:"accountId,omitempty" yaml:"account_id,omitempty"`
Created string `json:"created,omitempty" yaml:"created,omitempty"`
Data map[string]interface{} `json:"data,omitempty" yaml:"data,omitempty"`
Description string `json:"description,omitempty" yaml:"description,omitempty"`
InstanceId string `json:"instanceId,omitempty" yaml:"instance_id,omitempty"`
Kind string `json:"kind,omitempty" yaml:"kind,omitempty"`
LinkName string `json:"linkName,omitempty" yaml:"link_name,omitempty"`
Name string `json:"name,omitempty" yaml:"name,omitempty"`
Ports []interface{} `json:"ports,omitempty" yaml:"ports,omitempty"`
RemoveTime string `json:"removeTime,omitempty" yaml:"remove_time,omitempty"`
Removed string `json:"removed,omitempty" yaml:"removed,omitempty"`
State string `json:"state,omitempty" yaml:"state,omitempty"`
TargetInstanceId string `json:"targetInstanceId,omitempty" yaml:"target_instance_id,omitempty"`
Transitioning string `json:"transitioning,omitempty" yaml:"transitioning,omitempty"`
TransitioningMessage string `json:"transitioningMessage,omitempty" yaml:"transitioning_message,omitempty"`
TransitioningProgress int64 `json:"transitioningProgress,omitempty" yaml:"transitioning_progress,omitempty"`
Uuid string `json:"uuid,omitempty" yaml:"uuid,omitempty"`
}
type InstanceLinkCollection struct {
Collection
Data []InstanceLink `json:"data,omitempty"`
}
type InstanceLinkClient struct {
rancherClient *RancherClient
}
type InstanceLinkOperations interface {
List(opts *ListOpts) (*InstanceLinkCollection, error)
Create(opts *InstanceLink) (*InstanceLink, error)
Update(existing *InstanceLink, updates interface{}) (*InstanceLink, error)
ById(id string) (*InstanceLink, error)
Delete(container *InstanceLink) error
ActionActivate(*InstanceLink) (*InstanceLink, error)
ActionCreate(*InstanceLink) (*InstanceLink, error)
ActionDeactivate(*InstanceLink) (*InstanceLink, error)
ActionPurge(*InstanceLink) (*InstanceLink, error)
ActionRemove(*InstanceLink) (*InstanceLink, error)
ActionRestore(*InstanceLink) (*InstanceLink, error)
ActionUpdate(*InstanceLink) (*InstanceLink, error)
}
func newInstanceLinkClient(rancherClient *RancherClient) *InstanceLinkClient {
return &InstanceLinkClient{
rancherClient: rancherClient,
}
}
func (c *InstanceLinkClient) Create(container *InstanceLink) (*InstanceLink, error) {
resp := &InstanceLink{}
err := c.rancherClient.doCreate(INSTANCE_LINK_TYPE, container, resp)
return resp, err
}
func (c *InstanceLinkClient) Update(existing *InstanceLink, updates interface{}) (*InstanceLink, error) {
resp := &InstanceLink{}
err := c.rancherClient.doUpdate(INSTANCE_LINK_TYPE, &existing.Resource, updates, resp)
return resp, err
}
func (c *InstanceLinkClient) List(opts *ListOpts) (*InstanceLinkCollection, error) {
resp := &InstanceLinkCollection{}
err := c.rancherClient.doList(INSTANCE_LINK_TYPE, opts, resp)
return resp, err
}
func (c *InstanceLinkClient) ById(id string) (*InstanceLink, error) {
resp := &InstanceLink{}
err := c.rancherClient.doById(INSTANCE_LINK_TYPE, id, resp)
if apiError, ok := err.(*ApiError); ok {
if apiError.StatusCode == 404 {
return nil, nil
}
}
return resp, err
}
func (c *InstanceLinkClient) Delete(container *InstanceLink) error {
return c.rancherClient.doResourceDelete(INSTANCE_LINK_TYPE, &container.Resource)
}
func (c *InstanceLinkClient) ActionActivate(resource *InstanceLink) (*InstanceLink, error) {
resp := &InstanceLink{}
err := c.rancherClient.doAction(INSTANCE_LINK_TYPE, "activate", &resource.Resource, nil, resp)
return resp, err
}
func (c *InstanceLinkClient) ActionCreate(resource *InstanceLink) (*InstanceLink, error) {
resp := &InstanceLink{}
err := c.rancherClient.doAction(INSTANCE_LINK_TYPE, "create", &resource.Resource, nil, resp)
return resp, err
}
func (c *InstanceLinkClient) ActionDeactivate(resource *InstanceLink) (*InstanceLink, error) {
resp := &InstanceLink{}
err := c.rancherClient.doAction(INSTANCE_LINK_TYPE, "deactivate", &resource.Resource, nil, resp)
return resp, err
}
func (c *InstanceLinkClient) ActionPurge(resource *InstanceLink) (*InstanceLink, error) {
resp := &InstanceLink{}
err := c.rancherClient.doAction(INSTANCE_LINK_TYPE, "purge", &resource.Resource, nil, resp)
return resp, err
}
func (c *InstanceLinkClient) ActionRemove(resource *InstanceLink) (*InstanceLink, error) {
resp := &InstanceLink{}
err := c.rancherClient.doAction(INSTANCE_LINK_TYPE, "remove", &resource.Resource, nil, resp)
return resp, err
}
func (c *InstanceLinkClient) ActionRestore(resource *InstanceLink) (*InstanceLink, error) {
resp := &InstanceLink{}
err := c.rancherClient.doAction(INSTANCE_LINK_TYPE, "restore", &resource.Resource, nil, resp)
return resp, err
}
func (c *InstanceLinkClient) ActionUpdate(resource *InstanceLink) (*InstanceLink, error) {
resp := &InstanceLink{}
err := c.rancherClient.doAction(INSTANCE_LINK_TYPE, "update", &resource.Resource, nil, resp)
return resp, err
}

69
vendor/github.com/rancher/go-rancher/client/generated_instance_stop.go generated vendored Normal file
View File

@ -0,0 +1,69 @@
package client
const (
INSTANCE_STOP_TYPE = "instanceStop"
)
type InstanceStop struct {
Resource
Remove bool `json:"remove,omitempty" yaml:"remove,omitempty"`
Timeout int64 `json:"timeout,omitempty" yaml:"timeout,omitempty"`
}
type InstanceStopCollection struct {
Collection
Data []InstanceStop `json:"data,omitempty"`
}
type InstanceStopClient struct {
rancherClient *RancherClient
}
type InstanceStopOperations interface {
List(opts *ListOpts) (*InstanceStopCollection, error)
Create(opts *InstanceStop) (*InstanceStop, error)
Update(existing *InstanceStop, updates interface{}) (*InstanceStop, error)
ById(id string) (*InstanceStop, error)
Delete(container *InstanceStop) error
}
func newInstanceStopClient(rancherClient *RancherClient) *InstanceStopClient {
return &InstanceStopClient{
rancherClient: rancherClient,
}
}
func (c *InstanceStopClient) Create(container *InstanceStop) (*InstanceStop, error) {
resp := &InstanceStop{}
err := c.rancherClient.doCreate(INSTANCE_STOP_TYPE, container, resp)
return resp, err
}
func (c *InstanceStopClient) Update(existing *InstanceStop, updates interface{}) (*InstanceStop, error) {
resp := &InstanceStop{}
err := c.rancherClient.doUpdate(INSTANCE_STOP_TYPE, &existing.Resource, updates, resp)
return resp, err
}
func (c *InstanceStopClient) List(opts *ListOpts) (*InstanceStopCollection, error) {
resp := &InstanceStopCollection{}
err := c.rancherClient.doList(INSTANCE_STOP_TYPE, opts, resp)
return resp, err
}
func (c *InstanceStopClient) ById(id string) (*InstanceStop, error) {
resp := &InstanceStop{}
err := c.rancherClient.doById(INSTANCE_STOP_TYPE, id, resp)
if apiError, ok := err.(*ApiError); ok {
if apiError.StatusCode == 404 {
return nil, nil
}
}
return resp, err
}
func (c *InstanceStopClient) Delete(container *InstanceStop) error {
return c.rancherClient.doResourceDelete(INSTANCE_STOP_TYPE, &container.Resource)
}

183
vendor/github.com/rancher/go-rancher/client/generated_ip_address.go generated vendored Normal file
View File

@ -0,0 +1,183 @@
package client
const (
IP_ADDRESS_TYPE = "ipAddress"
)
type IpAddress struct {
Resource
AccountId string `json:"accountId,omitempty" yaml:"account_id,omitempty"`
Address string `json:"address,omitempty" yaml:"address,omitempty"`
Created string `json:"created,omitempty" yaml:"created,omitempty"`
Data map[string]interface{} `json:"data,omitempty" yaml:"data,omitempty"`
Description string `json:"description,omitempty" yaml:"description,omitempty"`
Kind string `json:"kind,omitempty" yaml:"kind,omitempty"`
Name string `json:"name,omitempty" yaml:"name,omitempty"`
NetworkId string `json:"networkId,omitempty" yaml:"network_id,omitempty"`
RemoveTime string `json:"removeTime,omitempty" yaml:"remove_time,omitempty"`
Removed string `json:"removed,omitempty" yaml:"removed,omitempty"`
State string `json:"state,omitempty" yaml:"state,omitempty"`
Transitioning string `json:"transitioning,omitempty" yaml:"transitioning,omitempty"`
TransitioningMessage string `json:"transitioningMessage,omitempty" yaml:"transitioning_message,omitempty"`
TransitioningProgress int64 `json:"transitioningProgress,omitempty" yaml:"transitioning_progress,omitempty"`
Uuid string `json:"uuid,omitempty" yaml:"uuid,omitempty"`
}
type IpAddressCollection struct {
Collection
Data []IpAddress `json:"data,omitempty"`
}
type IpAddressClient struct {
rancherClient *RancherClient
}
type IpAddressOperations interface {
List(opts *ListOpts) (*IpAddressCollection, error)
Create(opts *IpAddress) (*IpAddress, error)
Update(existing *IpAddress, updates interface{}) (*IpAddress, error)
ById(id string) (*IpAddress, error)
Delete(container *IpAddress) error
ActionActivate(*IpAddress) (*IpAddress, error)
ActionCreate(*IpAddress) (*IpAddress, error)
ActionDeactivate(*IpAddress) (*IpAddress, error)
ActionDisassociate(*IpAddress) (*IpAddress, error)
ActionPurge(*IpAddress) (*IpAddress, error)
ActionRemove(*IpAddress) (*IpAddress, error)
ActionRestore(*IpAddress) (*IpAddress, error)
ActionUpdate(*IpAddress) (*IpAddress, error)
}
func newIpAddressClient(rancherClient *RancherClient) *IpAddressClient {
return &IpAddressClient{
rancherClient: rancherClient,
}
}
func (c *IpAddressClient) Create(container *IpAddress) (*IpAddress, error) {
resp := &IpAddress{}
err := c.rancherClient.doCreate(IP_ADDRESS_TYPE, container, resp)
return resp, err
}
func (c *IpAddressClient) Update(existing *IpAddress, updates interface{}) (*IpAddress, error) {
resp := &IpAddress{}
err := c.rancherClient.doUpdate(IP_ADDRESS_TYPE, &existing.Resource, updates, resp)
return resp, err
}
func (c *IpAddressClient) List(opts *ListOpts) (*IpAddressCollection, error) {
resp := &IpAddressCollection{}
err := c.rancherClient.doList(IP_ADDRESS_TYPE, opts, resp)
return resp, err
}
func (c *IpAddressClient) ById(id string) (*IpAddress, error) {
resp := &IpAddress{}
err := c.rancherClient.doById(IP_ADDRESS_TYPE, id, resp)
if apiError, ok := err.(*ApiError); ok {
if apiError.StatusCode == 404 {
return nil, nil
}
}
return resp, err
}
func (c *IpAddressClient) Delete(container *IpAddress) error {
return c.rancherClient.doResourceDelete(IP_ADDRESS_TYPE, &container.Resource)
}
func (c *IpAddressClient) ActionActivate(resource *IpAddress) (*IpAddress, error) {
resp := &IpAddress{}
err := c.rancherClient.doAction(IP_ADDRESS_TYPE, "activate", &resource.Resource, nil, resp)
return resp, err
}
func (c *IpAddressClient) ActionCreate(resource *IpAddress) (*IpAddress, error) {
resp := &IpAddress{}
err := c.rancherClient.doAction(IP_ADDRESS_TYPE, "create", &resource.Resource, nil, resp)
return resp, err
}
func (c *IpAddressClient) ActionDeactivate(resource *IpAddress) (*IpAddress, error) {
resp := &IpAddress{}
err := c.rancherClient.doAction(IP_ADDRESS_TYPE, "deactivate", &resource.Resource, nil, resp)
return resp, err
}
func (c *IpAddressClient) ActionDisassociate(resource *IpAddress) (*IpAddress, error) {
resp := &IpAddress{}
err := c.rancherClient.doAction(IP_ADDRESS_TYPE, "disassociate", &resource.Resource, nil, resp)
return resp, err
}
func (c *IpAddressClient) ActionPurge(resource *IpAddress) (*IpAddress, error) {
resp := &IpAddress{}
err := c.rancherClient.doAction(IP_ADDRESS_TYPE, "purge", &resource.Resource, nil, resp)
return resp, err
}
func (c *IpAddressClient) ActionRemove(resource *IpAddress) (*IpAddress, error) {
resp := &IpAddress{}
err := c.rancherClient.doAction(IP_ADDRESS_TYPE, "remove", &resource.Resource, nil, resp)
return resp, err
}
func (c *IpAddressClient) ActionRestore(resource *IpAddress) (*IpAddress, error) {
resp := &IpAddress{}
err := c.rancherClient.doAction(IP_ADDRESS_TYPE, "restore", &resource.Resource, nil, resp)
return resp, err
}
func (c *IpAddressClient) ActionUpdate(resource *IpAddress) (*IpAddress, error) {
resp := &IpAddress{}
err := c.rancherClient.doAction(IP_ADDRESS_TYPE, "update", &resource.Resource, nil, resp)
return resp, err
}

67
vendor/github.com/rancher/go-rancher/client/generated_ip_address_associate_input.go generated vendored Normal file
View File

@ -0,0 +1,67 @@
package client
const (
IP_ADDRESS_ASSOCIATE_INPUT_TYPE = "ipAddressAssociateInput"
)
type IpAddressAssociateInput struct {
Resource
IpAddressId string `json:"ipAddressId,omitempty" yaml:"ip_address_id,omitempty"`
}
type IpAddressAssociateInputCollection struct {
Collection
Data []IpAddressAssociateInput `json:"data,omitempty"`
}
type IpAddressAssociateInputClient struct {
rancherClient *RancherClient
}
type IpAddressAssociateInputOperations interface {
List(opts *ListOpts) (*IpAddressAssociateInputCollection, error)
Create(opts *IpAddressAssociateInput) (*IpAddressAssociateInput, error)
Update(existing *IpAddressAssociateInput, updates interface{}) (*IpAddressAssociateInput, error)
ById(id string) (*IpAddressAssociateInput, error)
Delete(container *IpAddressAssociateInput) error
}
func newIpAddressAssociateInputClient(rancherClient *RancherClient) *IpAddressAssociateInputClient {
return &IpAddressAssociateInputClient{
rancherClient: rancherClient,
}
}
func (c *IpAddressAssociateInputClient) Create(container *IpAddressAssociateInput) (*IpAddressAssociateInput, error) {
resp := &IpAddressAssociateInput{}
err := c.rancherClient.doCreate(IP_ADDRESS_ASSOCIATE_INPUT_TYPE, container, resp)
return resp, err
}
func (c *IpAddressAssociateInputClient) Update(existing *IpAddressAssociateInput, updates interface{}) (*IpAddressAssociateInput, error) {
resp := &IpAddressAssociateInput{}
err := c.rancherClient.doUpdate(IP_ADDRESS_ASSOCIATE_INPUT_TYPE, &existing.Resource, updates, resp)
return resp, err
}
func (c *IpAddressAssociateInputClient) List(opts *ListOpts) (*IpAddressAssociateInputCollection, error) {
resp := &IpAddressAssociateInputCollection{}
err := c.rancherClient.doList(IP_ADDRESS_ASSOCIATE_INPUT_TYPE, opts, resp)
return resp, err
}
func (c *IpAddressAssociateInputClient) ById(id string) (*IpAddressAssociateInput, error) {
resp := &IpAddressAssociateInput{}
err := c.rancherClient.doById(IP_ADDRESS_ASSOCIATE_INPUT_TYPE, id, resp)
if apiError, ok := err.(*ApiError); ok {
if apiError.StatusCode == 404 {
return nil, nil
}
}
return resp, err
}
func (c *IpAddressAssociateInputClient) Delete(container *IpAddressAssociateInput) error {
return c.rancherClient.doResourceDelete(IP_ADDRESS_ASSOCIATE_INPUT_TYPE, &container.Resource)
}

257
vendor/github.com/rancher/go-rancher/client/generated_kubernetes_service.go generated vendored Normal file
View File

@ -0,0 +1,257 @@
package client
const (
KUBERNETES_SERVICE_TYPE = "kubernetesService"
)
type KubernetesService struct {
Resource
AccountId string `json:"accountId,omitempty" yaml:"account_id,omitempty"`
Created string `json:"created,omitempty" yaml:"created,omitempty"`
Data map[string]interface{} `json:"data,omitempty" yaml:"data,omitempty"`
Description string `json:"description,omitempty" yaml:"description,omitempty"`
EnvironmentId string `json:"environmentId,omitempty" yaml:"environment_id,omitempty"`
ExternalId string `json:"externalId,omitempty" yaml:"external_id,omitempty"`
HealthState string `json:"healthState,omitempty" yaml:"health_state,omitempty"`
Kind string `json:"kind,omitempty" yaml:"kind,omitempty"`
Name string `json:"name,omitempty" yaml:"name,omitempty"`
RemoveTime string `json:"removeTime,omitempty" yaml:"remove_time,omitempty"`
Removed string `json:"removed,omitempty" yaml:"removed,omitempty"`
SelectorContainer string `json:"selectorContainer,omitempty" yaml:"selector_container,omitempty"`
State string `json:"state,omitempty" yaml:"state,omitempty"`
Template interface{} `json:"template,omitempty" yaml:"template,omitempty"`
Transitioning string `json:"transitioning,omitempty" yaml:"transitioning,omitempty"`
TransitioningMessage string `json:"transitioningMessage,omitempty" yaml:"transitioning_message,omitempty"`
TransitioningProgress int64 `json:"transitioningProgress,omitempty" yaml:"transitioning_progress,omitempty"`
Uuid string `json:"uuid,omitempty" yaml:"uuid,omitempty"`
Vip string `json:"vip,omitempty" yaml:"vip,omitempty"`
}
type KubernetesServiceCollection struct {
Collection
Data []KubernetesService `json:"data,omitempty"`
}
type KubernetesServiceClient struct {
rancherClient *RancherClient
}
type KubernetesServiceOperations interface {
List(opts *ListOpts) (*KubernetesServiceCollection, error)
Create(opts *KubernetesService) (*KubernetesService, error)
Update(existing *KubernetesService, updates interface{}) (*KubernetesService, error)
ById(id string) (*KubernetesService, error)
Delete(container *KubernetesService) error
ActionActivate(*KubernetesService) (*Service, error)
ActionAddservicelink(*KubernetesService, *AddRemoveServiceLinkInput) (*Service, error)
ActionCancelrollback(*KubernetesService) (*Service, error)
ActionCancelupgrade(*KubernetesService) (*Service, error)
ActionCreate(*KubernetesService) (*Service, error)
ActionDeactivate(*KubernetesService) (*Service, error)
ActionFinishupgrade(*KubernetesService) (*Service, error)
ActionRemove(*KubernetesService) (*Service, error)
ActionRemoveservicelink(*KubernetesService, *AddRemoveServiceLinkInput) (*Service, error)
ActionRestart(*KubernetesService, *ServiceRestart) (*Service, error)
ActionRollback(*KubernetesService) (*Service, error)
ActionSetservicelinks(*KubernetesService, *SetServiceLinksInput) (*Service, error)
ActionUpdate(*KubernetesService) (*Service, error)
ActionUpgrade(*KubernetesService, *ServiceUpgrade) (*Service, error)
}
func newKubernetesServiceClient(rancherClient *RancherClient) *KubernetesServiceClient {
return &KubernetesServiceClient{
rancherClient: rancherClient,
}
}
func (c *KubernetesServiceClient) Create(container *KubernetesService) (*KubernetesService, error) {
resp := &KubernetesService{}
err := c.rancherClient.doCreate(KUBERNETES_SERVICE_TYPE, container, resp)
return resp, err
}
func (c *KubernetesServiceClient) Update(existing *KubernetesService, updates interface{}) (*KubernetesService, error) {
resp := &KubernetesService{}
err := c.rancherClient.doUpdate(KUBERNETES_SERVICE_TYPE, &existing.Resource, updates, resp)
return resp, err
}
func (c *KubernetesServiceClient) List(opts *ListOpts) (*KubernetesServiceCollection, error) {
resp := &KubernetesServiceCollection{}
err := c.rancherClient.doList(KUBERNETES_SERVICE_TYPE, opts, resp)
return resp, err
}
func (c *KubernetesServiceClient) ById(id string) (*KubernetesService, error) {
resp := &KubernetesService{}
err := c.rancherClient.doById(KUBERNETES_SERVICE_TYPE, id, resp)
if apiError, ok := err.(*ApiError); ok {
if apiError.StatusCode == 404 {
return nil, nil
}
}
return resp, err
}
func (c *KubernetesServiceClient) Delete(container *KubernetesService) error {
return c.rancherClient.doResourceDelete(KUBERNETES_SERVICE_TYPE, &container.Resource)
}
func (c *KubernetesServiceClient) ActionActivate(resource *KubernetesService) (*Service, error) {
resp := &Service{}
err := c.rancherClient.doAction(KUBERNETES_SERVICE_TYPE, "activate", &resource.Resource, nil, resp)
return resp, err
}
func (c *KubernetesServiceClient) ActionAddservicelink(resource *KubernetesService, input *AddRemoveServiceLinkInput) (*Service, error) {
resp := &Service{}
err := c.rancherClient.doAction(KUBERNETES_SERVICE_TYPE, "addservicelink", &resource.Resource, input, resp)
return resp, err
}
func (c *KubernetesServiceClient) ActionCancelrollback(resource *KubernetesService) (*Service, error) {
resp := &Service{}
err := c.rancherClient.doAction(KUBERNETES_SERVICE_TYPE, "cancelrollback", &resource.Resource, nil, resp)
return resp, err
}
func (c *KubernetesServiceClient) ActionCancelupgrade(resource *KubernetesService) (*Service, error) {
resp := &Service{}
err := c.rancherClient.doAction(KUBERNETES_SERVICE_TYPE, "cancelupgrade", &resource.Resource, nil, resp)
return resp, err
}
func (c *KubernetesServiceClient) ActionCreate(resource *KubernetesService) (*Service, error) {
resp := &Service{}
err := c.rancherClient.doAction(KUBERNETES_SERVICE_TYPE, "create", &resource.Resource, nil, resp)
return resp, err
}
func (c *KubernetesServiceClient) ActionDeactivate(resource *KubernetesService) (*Service, error) {
resp := &Service{}
err := c.rancherClient.doAction(KUBERNETES_SERVICE_TYPE, "deactivate", &resource.Resource, nil, resp)
return resp, err
}
func (c *KubernetesServiceClient) ActionFinishupgrade(resource *KubernetesService) (*Service, error) {
resp := &Service{}
err := c.rancherClient.doAction(KUBERNETES_SERVICE_TYPE, "finishupgrade", &resource.Resource, nil, resp)
return resp, err
}
func (c *KubernetesServiceClient) ActionRemove(resource *KubernetesService) (*Service, error) {
resp := &Service{}
err := c.rancherClient.doAction(KUBERNETES_SERVICE_TYPE, "remove", &resource.Resource, nil, resp)
return resp, err
}
func (c *KubernetesServiceClient) ActionRemoveservicelink(resource *KubernetesService, input *AddRemoveServiceLinkInput) (*Service, error) {
resp := &Service{}
err := c.rancherClient.doAction(KUBERNETES_SERVICE_TYPE, "removeservicelink", &resource.Resource, input, resp)
return resp, err
}
func (c *KubernetesServiceClient) ActionRestart(resource *KubernetesService, input *ServiceRestart) (*Service, error) {
resp := &Service{}
err := c.rancherClient.doAction(KUBERNETES_SERVICE_TYPE, "restart", &resource.Resource, input, resp)
return resp, err
}
func (c *KubernetesServiceClient) ActionRollback(resource *KubernetesService) (*Service, error) {
resp := &Service{}
err := c.rancherClient.doAction(KUBERNETES_SERVICE_TYPE, "rollback", &resource.Resource, nil, resp)
return resp, err
}
func (c *KubernetesServiceClient) ActionSetservicelinks(resource *KubernetesService, input *SetServiceLinksInput) (*Service, error) {
resp := &Service{}
err := c.rancherClient.doAction(KUBERNETES_SERVICE_TYPE, "setservicelinks", &resource.Resource, input, resp)
return resp, err
}
func (c *KubernetesServiceClient) ActionUpdate(resource *KubernetesService) (*Service, error) {
resp := &Service{}
err := c.rancherClient.doAction(KUBERNETES_SERVICE_TYPE, "update", &resource.Resource, nil, resp)
return resp, err
}
func (c *KubernetesServiceClient) ActionUpgrade(resource *KubernetesService, input *ServiceUpgrade) (*Service, error) {
resp := &Service{}
err := c.rancherClient.doAction(KUBERNETES_SERVICE_TYPE, "upgrade", &resource.Resource, input, resp)
return resp, err
}

193
vendor/github.com/rancher/go-rancher/client/generated_kubernetes_stack.go generated vendored Normal file
View File

@ -0,0 +1,193 @@
package client
const (
KUBERNETES_STACK_TYPE = "kubernetesStack"
)
type KubernetesStack struct {
Resource
AccountId string `json:"accountId,omitempty" yaml:"account_id,omitempty"`
Created string `json:"created,omitempty" yaml:"created,omitempty"`
Data map[string]interface{} `json:"data,omitempty" yaml:"data,omitempty"`
Description string `json:"description,omitempty" yaml:"description,omitempty"`
Environment map[string]interface{} `json:"environment,omitempty" yaml:"environment,omitempty"`
ExternalId string `json:"externalId,omitempty" yaml:"external_id,omitempty"`
HealthState string `json:"healthState,omitempty" yaml:"health_state,omitempty"`
Kind string `json:"kind,omitempty" yaml:"kind,omitempty"`
Name string `json:"name,omitempty" yaml:"name,omitempty"`
Namespace string `json:"namespace,omitempty" yaml:"namespace,omitempty"`
PreviousEnvironment map[string]interface{} `json:"previousEnvironment,omitempty" yaml:"previous_environment,omitempty"`
PreviousExternalId string `json:"previousExternalId,omitempty" yaml:"previous_external_id,omitempty"`
RemoveTime string `json:"removeTime,omitempty" yaml:"remove_time,omitempty"`
Removed string `json:"removed,omitempty" yaml:"removed,omitempty"`
State string `json:"state,omitempty" yaml:"state,omitempty"`
Templates map[string]interface{} `json:"templates,omitempty" yaml:"templates,omitempty"`
Transitioning string `json:"transitioning,omitempty" yaml:"transitioning,omitempty"`
TransitioningMessage string `json:"transitioningMessage,omitempty" yaml:"transitioning_message,omitempty"`
TransitioningProgress int64 `json:"transitioningProgress,omitempty" yaml:"transitioning_progress,omitempty"`
Uuid string `json:"uuid,omitempty" yaml:"uuid,omitempty"`
}
type KubernetesStackCollection struct {
Collection
Data []KubernetesStack `json:"data,omitempty"`
}
type KubernetesStackClient struct {
rancherClient *RancherClient
}
type KubernetesStackOperations interface {
List(opts *ListOpts) (*KubernetesStackCollection, error)
Create(opts *KubernetesStack) (*KubernetesStack, error)
Update(existing *KubernetesStack, updates interface{}) (*KubernetesStack, error)
ById(id string) (*KubernetesStack, error)
Delete(container *KubernetesStack) error
ActionCancelrollback(*KubernetesStack) (*Environment, error)
ActionCancelupgrade(*KubernetesStack) (*Environment, error)
ActionCreate(*KubernetesStack) (*Environment, error)
ActionError(*KubernetesStack) (*Environment, error)
ActionFinishupgrade(*KubernetesStack) (*Environment, error)
ActionRemove(*KubernetesStack) (*Environment, error)
ActionRollback(*KubernetesStack) (*Environment, error)
ActionUpgrade(*KubernetesStack, *KubernetesStackUpgrade) (*KubernetesStack, error)
}
func newKubernetesStackClient(rancherClient *RancherClient) *KubernetesStackClient {
return &KubernetesStackClient{
rancherClient: rancherClient,
}
}
func (c *KubernetesStackClient) Create(container *KubernetesStack) (*KubernetesStack, error) {
resp := &KubernetesStack{}
err := c.rancherClient.doCreate(KUBERNETES_STACK_TYPE, container, resp)
return resp, err
}
func (c *KubernetesStackClient) Update(existing *KubernetesStack, updates interface{}) (*KubernetesStack, error) {
resp := &KubernetesStack{}
err := c.rancherClient.doUpdate(KUBERNETES_STACK_TYPE, &existing.Resource, updates, resp)
return resp, err
}
func (c *KubernetesStackClient) List(opts *ListOpts) (*KubernetesStackCollection, error) {
resp := &KubernetesStackCollection{}
err := c.rancherClient.doList(KUBERNETES_STACK_TYPE, opts, resp)
return resp, err
}
func (c *KubernetesStackClient) ById(id string) (*KubernetesStack, error) {
resp := &KubernetesStack{}
err := c.rancherClient.doById(KUBERNETES_STACK_TYPE, id, resp)
if apiError, ok := err.(*ApiError); ok {
if apiError.StatusCode == 404 {
return nil, nil
}
}
return resp, err
}
func (c *KubernetesStackClient) Delete(container *KubernetesStack) error {
return c.rancherClient.doResourceDelete(KUBERNETES_STACK_TYPE, &container.Resource)
}
func (c *KubernetesStackClient) ActionCancelrollback(resource *KubernetesStack) (*Environment, error) {
resp := &Environment{}
err := c.rancherClient.doAction(KUBERNETES_STACK_TYPE, "cancelrollback", &resource.Resource, nil, resp)
return resp, err
}
func (c *KubernetesStackClient) ActionCancelupgrade(resource *KubernetesStack) (*Environment, error) {
resp := &Environment{}
err := c.rancherClient.doAction(KUBERNETES_STACK_TYPE, "cancelupgrade", &resource.Resource, nil, resp)
return resp, err
}
func (c *KubernetesStackClient) ActionCreate(resource *KubernetesStack) (*Environment, error) {
resp := &Environment{}
err := c.rancherClient.doAction(KUBERNETES_STACK_TYPE, "create", &resource.Resource, nil, resp)
return resp, err
}
func (c *KubernetesStackClient) ActionError(resource *KubernetesStack) (*Environment, error) {
resp := &Environment{}
err := c.rancherClient.doAction(KUBERNETES_STACK_TYPE, "error", &resource.Resource, nil, resp)
return resp, err
}
func (c *KubernetesStackClient) ActionFinishupgrade(resource *KubernetesStack) (*Environment, error) {
resp := &Environment{}
err := c.rancherClient.doAction(KUBERNETES_STACK_TYPE, "finishupgrade", &resource.Resource, nil, resp)
return resp, err
}
func (c *KubernetesStackClient) ActionRemove(resource *KubernetesStack) (*Environment, error) {
resp := &Environment{}
err := c.rancherClient.doAction(KUBERNETES_STACK_TYPE, "remove", &resource.Resource, nil, resp)
return resp, err
}
func (c *KubernetesStackClient) ActionRollback(resource *KubernetesStack) (*Environment, error) {
resp := &Environment{}
err := c.rancherClient.doAction(KUBERNETES_STACK_TYPE, "rollback", &resource.Resource, nil, resp)
return resp, err
}
func (c *KubernetesStackClient) ActionUpgrade(resource *KubernetesStack, input *KubernetesStackUpgrade) (*KubernetesStack, error) {
resp := &KubernetesStack{}
err := c.rancherClient.doAction(KUBERNETES_STACK_TYPE, "upgrade", &resource.Resource, input, resp)
return resp, err
}

71
vendor/github.com/rancher/go-rancher/client/generated_kubernetes_stack_upgrade.go generated vendored Normal file
View File

@ -0,0 +1,71 @@
package client
const (
KUBERNETES_STACK_UPGRADE_TYPE = "kubernetesStackUpgrade"
)
type KubernetesStackUpgrade struct {
Resource
Environment map[string]interface{} `json:"environment,omitempty" yaml:"environment,omitempty"`
ExternalId string `json:"externalId,omitempty" yaml:"external_id,omitempty"`
Templates map[string]interface{} `json:"templates,omitempty" yaml:"templates,omitempty"`
}
type KubernetesStackUpgradeCollection struct {
Collection
Data []KubernetesStackUpgrade `json:"data,omitempty"`
}
type KubernetesStackUpgradeClient struct {
rancherClient *RancherClient
}
type KubernetesStackUpgradeOperations interface {
List(opts *ListOpts) (*KubernetesStackUpgradeCollection, error)
Create(opts *KubernetesStackUpgrade) (*KubernetesStackUpgrade, error)
Update(existing *KubernetesStackUpgrade, updates interface{}) (*KubernetesStackUpgrade, error)
ById(id string) (*KubernetesStackUpgrade, error)
Delete(container *KubernetesStackUpgrade) error
}
func newKubernetesStackUpgradeClient(rancherClient *RancherClient) *KubernetesStackUpgradeClient {
return &KubernetesStackUpgradeClient{
rancherClient: rancherClient,
}
}
func (c *KubernetesStackUpgradeClient) Create(container *KubernetesStackUpgrade) (*KubernetesStackUpgrade, error) {
resp := &KubernetesStackUpgrade{}
err := c.rancherClient.doCreate(KUBERNETES_STACK_UPGRADE_TYPE, container, resp)
return resp, err
}
func (c *KubernetesStackUpgradeClient) Update(existing *KubernetesStackUpgrade, updates interface{}) (*KubernetesStackUpgrade, error) {
resp := &KubernetesStackUpgrade{}
err := c.rancherClient.doUpdate(KUBERNETES_STACK_UPGRADE_TYPE, &existing.Resource, updates, resp)
return resp, err
}
func (c *KubernetesStackUpgradeClient) List(opts *ListOpts) (*KubernetesStackUpgradeCollection, error) {
resp := &KubernetesStackUpgradeCollection{}
err := c.rancherClient.doList(KUBERNETES_STACK_UPGRADE_TYPE, opts, resp)
return resp, err
}
func (c *KubernetesStackUpgradeClient) ById(id string) (*KubernetesStackUpgrade, error) {
resp := &KubernetesStackUpgrade{}
err := c.rancherClient.doById(KUBERNETES_STACK_UPGRADE_TYPE, id, resp)
if apiError, ok := err.(*ApiError); ok {
if apiError.StatusCode == 404 {
return nil, nil
}
}
return resp, err
}
func (c *KubernetesStackUpgradeClient) Delete(container *KubernetesStackUpgrade) error {
return c.rancherClient.doResourceDelete(KUBERNETES_STACK_UPGRADE_TYPE, &container.Resource)
}

117
vendor/github.com/rancher/go-rancher/client/generated_label.go generated vendored Normal file
View File

@ -0,0 +1,117 @@
package client
const (
LABEL_TYPE = "label"
)
type Label struct {
Resource
AccountId string `json:"accountId,omitempty" yaml:"account_id,omitempty"`
Created string `json:"created,omitempty" yaml:"created,omitempty"`
Data map[string]interface{} `json:"data,omitempty" yaml:"data,omitempty"`
Description string `json:"description,omitempty" yaml:"description,omitempty"`
Key string `json:"key,omitempty" yaml:"key,omitempty"`
Kind string `json:"kind,omitempty" yaml:"kind,omitempty"`
Name string `json:"name,omitempty" yaml:"name,omitempty"`
RemoveTime string `json:"removeTime,omitempty" yaml:"remove_time,omitempty"`
Removed string `json:"removed,omitempty" yaml:"removed,omitempty"`
State string `json:"state,omitempty" yaml:"state,omitempty"`
Transitioning string `json:"transitioning,omitempty" yaml:"transitioning,omitempty"`
TransitioningMessage string `json:"transitioningMessage,omitempty" yaml:"transitioning_message,omitempty"`
TransitioningProgress int64 `json:"transitioningProgress,omitempty" yaml:"transitioning_progress,omitempty"`
Uuid string `json:"uuid,omitempty" yaml:"uuid,omitempty"`
Value string `json:"value,omitempty" yaml:"value,omitempty"`
}
type LabelCollection struct {
Collection
Data []Label `json:"data,omitempty"`
}
type LabelClient struct {
rancherClient *RancherClient
}
type LabelOperations interface {
List(opts *ListOpts) (*LabelCollection, error)
Create(opts *Label) (*Label, error)
Update(existing *Label, updates interface{}) (*Label, error)
ById(id string) (*Label, error)
Delete(container *Label) error
ActionCreate(*Label) (*Label, error)
ActionRemove(*Label) (*Label, error)
}
func newLabelClient(rancherClient *RancherClient) *LabelClient {
return &LabelClient{
rancherClient: rancherClient,
}
}
func (c *LabelClient) Create(container *Label) (*Label, error) {
resp := &Label{}
err := c.rancherClient.doCreate(LABEL_TYPE, container, resp)
return resp, err
}
func (c *LabelClient) Update(existing *Label, updates interface{}) (*Label, error) {
resp := &Label{}
err := c.rancherClient.doUpdate(LABEL_TYPE, &existing.Resource, updates, resp)
return resp, err
}
func (c *LabelClient) List(opts *ListOpts) (*LabelCollection, error) {
resp := &LabelCollection{}
err := c.rancherClient.doList(LABEL_TYPE, opts, resp)
return resp, err
}
func (c *LabelClient) ById(id string) (*Label, error) {
resp := &Label{}
err := c.rancherClient.doById(LABEL_TYPE, id, resp)
if apiError, ok := err.(*ApiError); ok {
if apiError.StatusCode == 404 {
return nil, nil
}
}
return resp, err
}
func (c *LabelClient) Delete(container *Label) error {
return c.rancherClient.doResourceDelete(LABEL_TYPE, &container.Resource)
}
func (c *LabelClient) ActionCreate(resource *Label) (*Label, error) {
resp := &Label{}
err := c.rancherClient.doAction(LABEL_TYPE, "create", &resource.Resource, nil, resp)
return resp, err
}
func (c *LabelClient) ActionRemove(resource *Label) (*Label, error) {
resp := &Label{}
err := c.rancherClient.doAction(LABEL_TYPE, "remove", &resource.Resource, nil, resp)
return resp, err
}

430
vendor/github.com/rancher/go-rancher/client/generated_launch_config.go generated vendored Normal file
View File

@ -0,0 +1,430 @@
package client
const (
LAUNCH_CONFIG_TYPE = "launchConfig"
)
type LaunchConfig struct {
Resource
AccountId string `json:"accountId,omitempty" yaml:"account_id,omitempty"`
AgentId string `json:"agentId,omitempty" yaml:"agent_id,omitempty"`
AllocationState string `json:"allocationState,omitempty" yaml:"allocation_state,omitempty"`
BlkioDeviceOptions map[string]interface{} `json:"blkioDeviceOptions,omitempty" yaml:"blkio_device_options,omitempty"`
Build *DockerBuild `json:"build,omitempty" yaml:"build,omitempty"`
CapAdd []string `json:"capAdd,omitempty" yaml:"cap_add,omitempty"`
CapDrop []string `json:"capDrop,omitempty" yaml:"cap_drop,omitempty"`
Command []string `json:"command,omitempty" yaml:"command,omitempty"`
Count int64 `json:"count,omitempty" yaml:"count,omitempty"`
CpuSet string `json:"cpuSet,omitempty" yaml:"cpu_set,omitempty"`
CpuShares int64 `json:"cpuShares,omitempty" yaml:"cpu_shares,omitempty"`
CreateIndex int64 `json:"createIndex,omitempty" yaml:"create_index,omitempty"`
Created string `json:"created,omitempty" yaml:"created,omitempty"`
Data map[string]interface{} `json:"data,omitempty" yaml:"data,omitempty"`
DataVolumeMounts map[string]interface{} `json:"dataVolumeMounts,omitempty" yaml:"data_volume_mounts,omitempty"`
DataVolumes []string `json:"dataVolumes,omitempty" yaml:"data_volumes,omitempty"`
DataVolumesFrom []string `json:"dataVolumesFrom,omitempty" yaml:"data_volumes_from,omitempty"`
DataVolumesFromLaunchConfigs []string `json:"dataVolumesFromLaunchConfigs,omitempty" yaml:"data_volumes_from_launch_configs,omitempty"`
DeploymentUnitUuid string `json:"deploymentUnitUuid,omitempty" yaml:"deployment_unit_uuid,omitempty"`
Description string `json:"description,omitempty" yaml:"description,omitempty"`
Devices []string `json:"devices,omitempty" yaml:"devices,omitempty"`
Disks []interface{} `json:"disks,omitempty" yaml:"disks,omitempty"`
Dns []string `json:"dns,omitempty" yaml:"dns,omitempty"`
DnsSearch []string `json:"dnsSearch,omitempty" yaml:"dns_search,omitempty"`
DomainName string `json:"domainName,omitempty" yaml:"domain_name,omitempty"`
EntryPoint []string `json:"entryPoint,omitempty" yaml:"entry_point,omitempty"`
Environment map[string]interface{} `json:"environment,omitempty" yaml:"environment,omitempty"`
Expose []string `json:"expose,omitempty" yaml:"expose,omitempty"`
ExternalId string `json:"externalId,omitempty" yaml:"external_id,omitempty"`
ExtraHosts []string `json:"extraHosts,omitempty" yaml:"extra_hosts,omitempty"`
FirstRunning string `json:"firstRunning,omitempty" yaml:"first_running,omitempty"`
HealthCheck *InstanceHealthCheck `json:"healthCheck,omitempty" yaml:"health_check,omitempty"`
HealthState string `json:"healthState,omitempty" yaml:"health_state,omitempty"`
HostId string `json:"hostId,omitempty" yaml:"host_id,omitempty"`
Hostname string `json:"hostname,omitempty" yaml:"hostname,omitempty"`
ImageUuid string `json:"imageUuid,omitempty" yaml:"image_uuid,omitempty"`
InstanceLinks map[string]interface{} `json:"instanceLinks,omitempty" yaml:"instance_links,omitempty"`
Kind string `json:"kind,omitempty" yaml:"kind,omitempty"`
Labels map[string]interface{} `json:"labels,omitempty" yaml:"labels,omitempty"`
LogConfig *LogConfig `json:"logConfig,omitempty" yaml:"log_config,omitempty"`
LxcConf map[string]interface{} `json:"lxcConf,omitempty" yaml:"lxc_conf,omitempty"`
Memory int64 `json:"memory,omitempty" yaml:"memory,omitempty"`
MemoryMb int64 `json:"memoryMb,omitempty" yaml:"memory_mb,omitempty"`
MemorySwap int64 `json:"memorySwap,omitempty" yaml:"memory_swap,omitempty"`
NativeContainer bool `json:"nativeContainer,omitempty" yaml:"native_container,omitempty"`
NetworkContainerId string `json:"networkContainerId,omitempty" yaml:"network_container_id,omitempty"`
NetworkIds []string `json:"networkIds,omitempty" yaml:"network_ids,omitempty"`
NetworkLaunchConfig string `json:"networkLaunchConfig,omitempty" yaml:"network_launch_config,omitempty"`
NetworkMode string `json:"networkMode,omitempty" yaml:"network_mode,omitempty"`
PidMode string `json:"pidMode,omitempty" yaml:"pid_mode,omitempty"`
Ports []string `json:"ports,omitempty" yaml:"ports,omitempty"`
PrimaryIpAddress string `json:"primaryIpAddress,omitempty" yaml:"primary_ip_address,omitempty"`
Privileged bool `json:"privileged,omitempty" yaml:"privileged,omitempty"`
PublishAllPorts bool `json:"publishAllPorts,omitempty" yaml:"publish_all_ports,omitempty"`
ReadOnly bool `json:"readOnly,omitempty" yaml:"read_only,omitempty"`
RegistryCredentialId string `json:"registryCredentialId,omitempty" yaml:"registry_credential_id,omitempty"`
RemoveTime string `json:"removeTime,omitempty" yaml:"remove_time,omitempty"`
Removed string `json:"removed,omitempty" yaml:"removed,omitempty"`
RequestedHostId string `json:"requestedHostId,omitempty" yaml:"requested_host_id,omitempty"`
RequestedIpAddress string `json:"requestedIpAddress,omitempty" yaml:"requested_ip_address,omitempty"`
SecurityOpt []string `json:"securityOpt,omitempty" yaml:"security_opt,omitempty"`
StartCount int64 `json:"startCount,omitempty" yaml:"start_count,omitempty"`
StartOnCreate bool `json:"startOnCreate,omitempty" yaml:"start_on_create,omitempty"`
State string `json:"state,omitempty" yaml:"state,omitempty"`
StdinOpen bool `json:"stdinOpen,omitempty" yaml:"stdin_open,omitempty"`
SystemContainer string `json:"systemContainer,omitempty" yaml:"system_container,omitempty"`
Token string `json:"token,omitempty" yaml:"token,omitempty"`
Transitioning string `json:"transitioning,omitempty" yaml:"transitioning,omitempty"`
TransitioningMessage string `json:"transitioningMessage,omitempty" yaml:"transitioning_message,omitempty"`
TransitioningProgress int64 `json:"transitioningProgress,omitempty" yaml:"transitioning_progress,omitempty"`
Tty bool `json:"tty,omitempty" yaml:"tty,omitempty"`
User string `json:"user,omitempty" yaml:"user,omitempty"`
Userdata string `json:"userdata,omitempty" yaml:"userdata,omitempty"`
Uuid string `json:"uuid,omitempty" yaml:"uuid,omitempty"`
Vcpu int64 `json:"vcpu,omitempty" yaml:"vcpu,omitempty"`
Version string `json:"version,omitempty" yaml:"version,omitempty"`
VolumeDriver string `json:"volumeDriver,omitempty" yaml:"volume_driver,omitempty"`
WorkingDir string `json:"workingDir,omitempty" yaml:"working_dir,omitempty"`
}
type LaunchConfigCollection struct {
Collection
Data []LaunchConfig `json:"data,omitempty"`
}
type LaunchConfigClient struct {
rancherClient *RancherClient
}
type LaunchConfigOperations interface {
List(opts *ListOpts) (*LaunchConfigCollection, error)
Create(opts *LaunchConfig) (*LaunchConfig, error)
Update(existing *LaunchConfig, updates interface{}) (*LaunchConfig, error)
ById(id string) (*LaunchConfig, error)
Delete(container *LaunchConfig) error
ActionAllocate(*LaunchConfig) (*Instance, error)
ActionConsole(*LaunchConfig, *InstanceConsoleInput) (*InstanceConsole, error)
ActionCreate(*LaunchConfig) (*Instance, error)
ActionDeallocate(*LaunchConfig) (*Instance, error)
ActionError(*LaunchConfig) (*Instance, error)
ActionExecute(*LaunchConfig, *ContainerExec) (*HostAccess, error)
ActionMigrate(*LaunchConfig) (*Instance, error)
ActionProxy(*LaunchConfig, *ContainerProxy) (*HostAccess, error)
ActionPurge(*LaunchConfig) (*Instance, error)
ActionRemove(*LaunchConfig) (*Instance, error)
ActionRestart(*LaunchConfig) (*Instance, error)
ActionRestore(*LaunchConfig) (*Instance, error)
ActionSetlabels(*LaunchConfig, *SetLabelsInput) (*Container, error)
ActionStart(*LaunchConfig) (*Instance, error)
ActionStop(*LaunchConfig, *InstanceStop) (*Instance, error)
ActionUpdate(*LaunchConfig) (*Instance, error)
ActionUpdatehealthy(*LaunchConfig) (*Instance, error)
ActionUpdatereinitializing(*LaunchConfig) (*Instance, error)
ActionUpdateunhealthy(*LaunchConfig) (*Instance, error)
}
func newLaunchConfigClient(rancherClient *RancherClient) *LaunchConfigClient {
return &LaunchConfigClient{
rancherClient: rancherClient,
}
}
func (c *LaunchConfigClient) Create(container *LaunchConfig) (*LaunchConfig, error) {
resp := &LaunchConfig{}
err := c.rancherClient.doCreate(LAUNCH_CONFIG_TYPE, container, resp)
return resp, err
}
func (c *LaunchConfigClient) Update(existing *LaunchConfig, updates interface{}) (*LaunchConfig, error) {
resp := &LaunchConfig{}
err := c.rancherClient.doUpdate(LAUNCH_CONFIG_TYPE, &existing.Resource, updates, resp)
return resp, err
}
func (c *LaunchConfigClient) List(opts *ListOpts) (*LaunchConfigCollection, error) {
resp := &LaunchConfigCollection{}
err := c.rancherClient.doList(LAUNCH_CONFIG_TYPE, opts, resp)
return resp, err
}
func (c *LaunchConfigClient) ById(id string) (*LaunchConfig, error) {
resp := &LaunchConfig{}
err := c.rancherClient.doById(LAUNCH_CONFIG_TYPE, id, resp)
if apiError, ok := err.(*ApiError); ok {
if apiError.StatusCode == 404 {
return nil, nil
}
}
return resp, err
}
func (c *LaunchConfigClient) Delete(container *LaunchConfig) error {
return c.rancherClient.doResourceDelete(LAUNCH_CONFIG_TYPE, &container.Resource)
}
func (c *LaunchConfigClient) ActionAllocate(resource *LaunchConfig) (*Instance, error) {
resp := &Instance{}
err := c.rancherClient.doAction(LAUNCH_CONFIG_TYPE, "allocate", &resource.Resource, nil, resp)
return resp, err
}
func (c *LaunchConfigClient) ActionConsole(resource *LaunchConfig, input *InstanceConsoleInput) (*InstanceConsole, error) {
resp := &InstanceConsole{}
err := c.rancherClient.doAction(LAUNCH_CONFIG_TYPE, "console", &resource.Resource, input, resp)
return resp, err
}
func (c *LaunchConfigClient) ActionCreate(resource *LaunchConfig) (*Instance, error) {
resp := &Instance{}
err := c.rancherClient.doAction(LAUNCH_CONFIG_TYPE, "create", &resource.Resource, nil, resp)
return resp, err
}
func (c *LaunchConfigClient) ActionDeallocate(resource *LaunchConfig) (*Instance, error) {
resp := &Instance{}
err := c.rancherClient.doAction(LAUNCH_CONFIG_TYPE, "deallocate", &resource.Resource, nil, resp)
return resp, err
}
func (c *LaunchConfigClient) ActionError(resource *LaunchConfig) (*Instance, error) {
resp := &Instance{}
err := c.rancherClient.doAction(LAUNCH_CONFIG_TYPE, "error", &resource.Resource, nil, resp)
return resp, err
}
func (c *LaunchConfigClient) ActionExecute(resource *LaunchConfig, input *ContainerExec) (*HostAccess, error) {
resp := &HostAccess{}
err := c.rancherClient.doAction(LAUNCH_CONFIG_TYPE, "execute", &resource.Resource, input, resp)
return resp, err
}
func (c *LaunchConfigClient) ActionMigrate(resource *LaunchConfig) (*Instance, error) {
resp := &Instance{}
err := c.rancherClient.doAction(LAUNCH_CONFIG_TYPE, "migrate", &resource.Resource, nil, resp)
return resp, err
}
func (c *LaunchConfigClient) ActionProxy(resource *LaunchConfig, input *ContainerProxy) (*HostAccess, error) {
resp := &HostAccess{}
err := c.rancherClient.doAction(LAUNCH_CONFIG_TYPE, "proxy", &resource.Resource, input, resp)
return resp, err
}
func (c *LaunchConfigClient) ActionPurge(resource *LaunchConfig) (*Instance, error) {
resp := &Instance{}
err := c.rancherClient.doAction(LAUNCH_CONFIG_TYPE, "purge", &resource.Resource, nil, resp)
return resp, err
}
func (c *LaunchConfigClient) ActionRemove(resource *LaunchConfig) (*Instance, error) {
resp := &Instance{}
err := c.rancherClient.doAction(LAUNCH_CONFIG_TYPE, "remove", &resource.Resource, nil, resp)
return resp, err
}
func (c *LaunchConfigClient) ActionRestart(resource *LaunchConfig) (*Instance, error) {
resp := &Instance{}
err := c.rancherClient.doAction(LAUNCH_CONFIG_TYPE, "restart", &resource.Resource, nil, resp)
return resp, err
}
func (c *LaunchConfigClient) ActionRestore(resource *LaunchConfig) (*Instance, error) {
resp := &Instance{}
err := c.rancherClient.doAction(LAUNCH_CONFIG_TYPE, "restore", &resource.Resource, nil, resp)
return resp, err
}
func (c *LaunchConfigClient) ActionSetlabels(resource *LaunchConfig, input *SetLabelsInput) (*Container, error) {
resp := &Container{}
err := c.rancherClient.doAction(LAUNCH_CONFIG_TYPE, "setlabels", &resource.Resource, input, resp)
return resp, err
}
func (c *LaunchConfigClient) ActionStart(resource *LaunchConfig) (*Instance, error) {
resp := &Instance{}
err := c.rancherClient.doAction(LAUNCH_CONFIG_TYPE, "start", &resource.Resource, nil, resp)
return resp, err
}
func (c *LaunchConfigClient) ActionStop(resource *LaunchConfig, input *InstanceStop) (*Instance, error) {
resp := &Instance{}
err := c.rancherClient.doAction(LAUNCH_CONFIG_TYPE, "stop", &resource.Resource, input, resp)
return resp, err
}
func (c *LaunchConfigClient) ActionUpdate(resource *LaunchConfig) (*Instance, error) {
resp := &Instance{}
err := c.rancherClient.doAction(LAUNCH_CONFIG_TYPE, "update", &resource.Resource, nil, resp)
return resp, err
}
func (c *LaunchConfigClient) ActionUpdatehealthy(resource *LaunchConfig) (*Instance, error) {
resp := &Instance{}
err := c.rancherClient.doAction(LAUNCH_CONFIG_TYPE, "updatehealthy", &resource.Resource, nil, resp)
return resp, err
}
func (c *LaunchConfigClient) ActionUpdatereinitializing(resource *LaunchConfig) (*Instance, error) {
resp := &Instance{}
err := c.rancherClient.doAction(LAUNCH_CONFIG_TYPE, "updatereinitializing", &resource.Resource, nil, resp)
return resp, err
}
func (c *LaunchConfigClient) ActionUpdateunhealthy(resource *LaunchConfig) (*Instance, error) {
resp := &Instance{}
err := c.rancherClient.doAction(LAUNCH_CONFIG_TYPE, "updateunhealthy", &resource.Resource, nil, resp)
return resp, err
}

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