435c0d9fc8
This PR switches the Nomad repository from using govendor to Go modules for managing dependencies. Aspects of the Nomad workflow remain pretty much the same. The usual Makefile targets should continue to work as they always did. The API submodule simply defers to the parent Nomad version on the repository, keeping the semantics of API versioning that currently exists.
457 lines
18 KiB
Go
457 lines
18 KiB
Go
/**
|
|
* Copyright 2016 IBM Corp.
|
|
*
|
|
* 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.
|
|
*/
|
|
|
|
/**
|
|
* AUTOMATICALLY GENERATED CODE - DO NOT MODIFY
|
|
*/
|
|
|
|
package services
|
|
|
|
import (
|
|
"fmt"
|
|
"strings"
|
|
|
|
"github.com/softlayer/softlayer-go/datatypes"
|
|
"github.com/softlayer/softlayer-go/session"
|
|
"github.com/softlayer/softlayer-go/sl"
|
|
)
|
|
|
|
// no documentation yet
|
|
type Security_Certificate struct {
|
|
Session *session.Session
|
|
Options sl.Options
|
|
}
|
|
|
|
// GetSecurityCertificateService returns an instance of the Security_Certificate SoftLayer service
|
|
func GetSecurityCertificateService(sess *session.Session) Security_Certificate {
|
|
return Security_Certificate{Session: sess}
|
|
}
|
|
|
|
func (r Security_Certificate) Id(id int) Security_Certificate {
|
|
r.Options.Id = &id
|
|
return r
|
|
}
|
|
|
|
func (r Security_Certificate) Mask(mask string) Security_Certificate {
|
|
if !strings.HasPrefix(mask, "mask[") && (strings.Contains(mask, "[") || strings.Contains(mask, ",")) {
|
|
mask = fmt.Sprintf("mask[%s]", mask)
|
|
}
|
|
|
|
r.Options.Mask = mask
|
|
return r
|
|
}
|
|
|
|
func (r Security_Certificate) Filter(filter string) Security_Certificate {
|
|
r.Options.Filter = filter
|
|
return r
|
|
}
|
|
|
|
func (r Security_Certificate) Limit(limit int) Security_Certificate {
|
|
r.Options.Limit = &limit
|
|
return r
|
|
}
|
|
|
|
func (r Security_Certificate) Offset(offset int) Security_Certificate {
|
|
r.Options.Offset = &offset
|
|
return r
|
|
}
|
|
|
|
// Add a certificate to your account for your records, or for use with various services. Only the certificate and private key are usually required. If your issuer provided an intermediate certificate, you must also provide that certificate. Details will be extracted from the certificate. Validation will be performed between the certificate and the private key as well as the certificate and the intermediate certificate, if provided.
|
|
//
|
|
// The certificate signing request is not required, but can be provided for your records.
|
|
func (r Security_Certificate) CreateObject(templateObject *datatypes.Security_Certificate) (resp datatypes.Security_Certificate, err error) {
|
|
params := []interface{}{
|
|
templateObject,
|
|
}
|
|
err = r.Session.DoRequest("SoftLayer_Security_Certificate", "createObject", params, &r.Options, &resp)
|
|
return
|
|
}
|
|
|
|
// Remove a certificate from your account. You may not remove a certificate with associated services.
|
|
func (r Security_Certificate) DeleteObject() (resp bool, err error) {
|
|
err = r.Session.DoRequest("SoftLayer_Security_Certificate", "deleteObject", nil, &r.Options, &resp)
|
|
return
|
|
}
|
|
|
|
// Update a certificate. Modifications are restricted to the note and CSR if the are any services associated with the certificate. There are no modification restrictions for a certificate with no associated services.
|
|
func (r Security_Certificate) EditObject(templateObject *datatypes.Security_Certificate) (resp bool, err error) {
|
|
params := []interface{}{
|
|
templateObject,
|
|
}
|
|
err = r.Session.DoRequest("SoftLayer_Security_Certificate", "editObject", params, &r.Options, &resp)
|
|
return
|
|
}
|
|
|
|
// Locate certificates by their common name, traditionally a domain name.
|
|
func (r Security_Certificate) FindByCommonName(commonName *string) (resp []datatypes.Security_Certificate, err error) {
|
|
params := []interface{}{
|
|
commonName,
|
|
}
|
|
err = r.Session.DoRequest("SoftLayer_Security_Certificate", "findByCommonName", params, &r.Options, &resp)
|
|
return
|
|
}
|
|
|
|
// Retrieve The number of services currently associated with the certificate.
|
|
func (r Security_Certificate) GetAssociatedServiceCount() (resp int, err error) {
|
|
err = r.Session.DoRequest("SoftLayer_Security_Certificate", "getAssociatedServiceCount", nil, &r.Options, &resp)
|
|
return
|
|
}
|
|
|
|
// Retrieve The load balancers virtual IP addresses currently associated with the certificate.
|
|
func (r Security_Certificate) GetLoadBalancerVirtualIpAddresses() (resp []datatypes.Network_Application_Delivery_Controller_LoadBalancer_VirtualIpAddress, err error) {
|
|
err = r.Session.DoRequest("SoftLayer_Security_Certificate", "getLoadBalancerVirtualIpAddresses", nil, &r.Options, &resp)
|
|
return
|
|
}
|
|
|
|
// no documentation yet
|
|
func (r Security_Certificate) GetObject() (resp datatypes.Security_Certificate, err error) {
|
|
err = r.Session.DoRequest("SoftLayer_Security_Certificate", "getObject", nil, &r.Options, &resp)
|
|
return
|
|
}
|
|
|
|
// Retrieve the certificate in PEM (Privacy Enhanced Mail) format, which is a string containing all base64 encoded (DER) certificates delimited by -----BEGIN/END *----- clauses.
|
|
func (r Security_Certificate) GetPemFormat() (resp string, err error) {
|
|
err = r.Session.DoRequest("SoftLayer_Security_Certificate", "getPemFormat", nil, &r.Options, &resp)
|
|
return
|
|
}
|
|
|
|
// SoftLayer_Security_Certificate_Request data type is used to harness your SSL certificate order to a Certificate Authority. This contains data that is required by a Certificate Authority to place an SSL certificate order.
|
|
type Security_Certificate_Request struct {
|
|
Session *session.Session
|
|
Options sl.Options
|
|
}
|
|
|
|
// GetSecurityCertificateRequestService returns an instance of the Security_Certificate_Request SoftLayer service
|
|
func GetSecurityCertificateRequestService(sess *session.Session) Security_Certificate_Request {
|
|
return Security_Certificate_Request{Session: sess}
|
|
}
|
|
|
|
func (r Security_Certificate_Request) Id(id int) Security_Certificate_Request {
|
|
r.Options.Id = &id
|
|
return r
|
|
}
|
|
|
|
func (r Security_Certificate_Request) Mask(mask string) Security_Certificate_Request {
|
|
if !strings.HasPrefix(mask, "mask[") && (strings.Contains(mask, "[") || strings.Contains(mask, ",")) {
|
|
mask = fmt.Sprintf("mask[%s]", mask)
|
|
}
|
|
|
|
r.Options.Mask = mask
|
|
return r
|
|
}
|
|
|
|
func (r Security_Certificate_Request) Filter(filter string) Security_Certificate_Request {
|
|
r.Options.Filter = filter
|
|
return r
|
|
}
|
|
|
|
func (r Security_Certificate_Request) Limit(limit int) Security_Certificate_Request {
|
|
r.Options.Limit = &limit
|
|
return r
|
|
}
|
|
|
|
func (r Security_Certificate_Request) Offset(offset int) Security_Certificate_Request {
|
|
r.Options.Offset = &offset
|
|
return r
|
|
}
|
|
|
|
// Cancels a pending SSL certificate order at the Certificate Authority
|
|
func (r Security_Certificate_Request) CancelSslOrder() (resp bool, err error) {
|
|
err = r.Session.DoRequest("SoftLayer_Security_Certificate_Request", "cancelSslOrder", nil, &r.Options, &resp)
|
|
return
|
|
}
|
|
|
|
// Retrieve The account to which a SSL certificate request belongs.
|
|
func (r Security_Certificate_Request) GetAccount() (resp datatypes.Account, err error) {
|
|
err = r.Session.DoRequest("SoftLayer_Security_Certificate_Request", "getAccount", nil, &r.Options, &resp)
|
|
return
|
|
}
|
|
|
|
// Gets the email domains that can be used to validate a certificate to a domain.
|
|
func (r Security_Certificate_Request) GetAdministratorEmailDomains(commonName *string) (resp []string, err error) {
|
|
params := []interface{}{
|
|
commonName,
|
|
}
|
|
err = r.Session.DoRequest("SoftLayer_Security_Certificate_Request", "getAdministratorEmailDomains", params, &r.Options, &resp)
|
|
return
|
|
}
|
|
|
|
// Gets the email accounts that can be used to validate a certificate to a domain.
|
|
func (r Security_Certificate_Request) GetAdministratorEmailPrefixes() (resp []string, err error) {
|
|
err = r.Session.DoRequest("SoftLayer_Security_Certificate_Request", "getAdministratorEmailPrefixes", nil, &r.Options, &resp)
|
|
return
|
|
}
|
|
|
|
// Retrieve The Certificate Authority name
|
|
func (r Security_Certificate_Request) GetCertificateAuthorityName() (resp string, err error) {
|
|
err = r.Session.DoRequest("SoftLayer_Security_Certificate_Request", "getCertificateAuthorityName", nil, &r.Options, &resp)
|
|
return
|
|
}
|
|
|
|
// no documentation yet
|
|
func (r Security_Certificate_Request) GetObject() (resp datatypes.Security_Certificate_Request, err error) {
|
|
err = r.Session.DoRequest("SoftLayer_Security_Certificate_Request", "getObject", nil, &r.Options, &resp)
|
|
return
|
|
}
|
|
|
|
// Retrieve The order contains the information related to a SSL certificate request.
|
|
func (r Security_Certificate_Request) GetOrder() (resp datatypes.Billing_Order, err error) {
|
|
err = r.Session.DoRequest("SoftLayer_Security_Certificate_Request", "getOrder", nil, &r.Options, &resp)
|
|
return
|
|
}
|
|
|
|
// Retrieve The associated order item for this SSL certificate request.
|
|
func (r Security_Certificate_Request) GetOrderItem() (resp datatypes.Billing_Order_Item, err error) {
|
|
err = r.Session.DoRequest("SoftLayer_Security_Certificate_Request", "getOrderItem", nil, &r.Options, &resp)
|
|
return
|
|
}
|
|
|
|
// Returns previous SSL certificate order data. You can use this data for to place a renewal order for a completed SSL certificate.
|
|
func (r Security_Certificate_Request) GetPreviousOrderData() (resp datatypes.Container_Product_Order_Security_Certificate, err error) {
|
|
err = r.Session.DoRequest("SoftLayer_Security_Certificate_Request", "getPreviousOrderData", nil, &r.Options, &resp)
|
|
return
|
|
}
|
|
|
|
// Returns all the SSL certificate requests.
|
|
func (r Security_Certificate_Request) GetSslCertificateRequests(accountId *int) (resp []datatypes.Security_Certificate_Request, err error) {
|
|
params := []interface{}{
|
|
accountId,
|
|
}
|
|
err = r.Session.DoRequest("SoftLayer_Security_Certificate_Request", "getSslCertificateRequests", params, &r.Options, &resp)
|
|
return
|
|
}
|
|
|
|
// Retrieve The status of a SSL certificate request.
|
|
func (r Security_Certificate_Request) GetStatus() (resp datatypes.Security_Certificate_Request_Status, err error) {
|
|
err = r.Session.DoRequest("SoftLayer_Security_Certificate_Request", "getStatus", nil, &r.Options, &resp)
|
|
return
|
|
}
|
|
|
|
// A Certificate Authority sends out various emails to your domain administrator or your technical contact. Use this service to have these emails re-sent.
|
|
func (r Security_Certificate_Request) ResendEmail(emailType *string) (resp bool, err error) {
|
|
params := []interface{}{
|
|
emailType,
|
|
}
|
|
err = r.Session.DoRequest("SoftLayer_Security_Certificate_Request", "resendEmail", params, &r.Options, &resp)
|
|
return
|
|
}
|
|
|
|
// Allows you to validate a Certificate Signing Request (CSR) required for an SSL certificate with the certificate authority (CA). This method sends the CSR, the length of the subscription in months, the certificate type, and the server type for validation against requirements of the CA. Returns true if valid.
|
|
//
|
|
// More information on CSR generation can be found at: [http://en.wikipedia.org/wiki/Certificate_signing_request Wikipedia] [https://knowledge.verisign.com/support/ssl-certificates-support/index?page=content&id=AR235&actp=LIST&viewlocale=en_US VeriSign]
|
|
func (r Security_Certificate_Request) ValidateCsr(csr *string, validityMonths *int, itemId *int, serverType *string) (resp bool, err error) {
|
|
params := []interface{}{
|
|
csr,
|
|
validityMonths,
|
|
itemId,
|
|
serverType,
|
|
}
|
|
err = r.Session.DoRequest("SoftLayer_Security_Certificate_Request", "validateCsr", params, &r.Options, &resp)
|
|
return
|
|
}
|
|
|
|
// Represents a server type that can be specified when ordering an SSL certificate.
|
|
type Security_Certificate_Request_ServerType struct {
|
|
Session *session.Session
|
|
Options sl.Options
|
|
}
|
|
|
|
// GetSecurityCertificateRequestServerTypeService returns an instance of the Security_Certificate_Request_ServerType SoftLayer service
|
|
func GetSecurityCertificateRequestServerTypeService(sess *session.Session) Security_Certificate_Request_ServerType {
|
|
return Security_Certificate_Request_ServerType{Session: sess}
|
|
}
|
|
|
|
func (r Security_Certificate_Request_ServerType) Id(id int) Security_Certificate_Request_ServerType {
|
|
r.Options.Id = &id
|
|
return r
|
|
}
|
|
|
|
func (r Security_Certificate_Request_ServerType) Mask(mask string) Security_Certificate_Request_ServerType {
|
|
if !strings.HasPrefix(mask, "mask[") && (strings.Contains(mask, "[") || strings.Contains(mask, ",")) {
|
|
mask = fmt.Sprintf("mask[%s]", mask)
|
|
}
|
|
|
|
r.Options.Mask = mask
|
|
return r
|
|
}
|
|
|
|
func (r Security_Certificate_Request_ServerType) Filter(filter string) Security_Certificate_Request_ServerType {
|
|
r.Options.Filter = filter
|
|
return r
|
|
}
|
|
|
|
func (r Security_Certificate_Request_ServerType) Limit(limit int) Security_Certificate_Request_ServerType {
|
|
r.Options.Limit = &limit
|
|
return r
|
|
}
|
|
|
|
func (r Security_Certificate_Request_ServerType) Offset(offset int) Security_Certificate_Request_ServerType {
|
|
r.Options.Offset = &offset
|
|
return r
|
|
}
|
|
|
|
// Returns all SSL certificate server types, which are passed in on a [[SoftLayer_Container_Product_Order_Security_Certificate|certificate order]].
|
|
func (r Security_Certificate_Request_ServerType) GetAllObjects() (resp []datatypes.Security_Certificate_Request_ServerType, err error) {
|
|
err = r.Session.DoRequest("SoftLayer_Security_Certificate_Request_ServerType", "getAllObjects", nil, &r.Options, &resp)
|
|
return
|
|
}
|
|
|
|
// no documentation yet
|
|
func (r Security_Certificate_Request_ServerType) GetObject() (resp datatypes.Security_Certificate_Request_ServerType, err error) {
|
|
err = r.Session.DoRequest("SoftLayer_Security_Certificate_Request_ServerType", "getObject", nil, &r.Options, &resp)
|
|
return
|
|
}
|
|
|
|
// Represents the status of an SSL certificate request.
|
|
type Security_Certificate_Request_Status struct {
|
|
Session *session.Session
|
|
Options sl.Options
|
|
}
|
|
|
|
// GetSecurityCertificateRequestStatusService returns an instance of the Security_Certificate_Request_Status SoftLayer service
|
|
func GetSecurityCertificateRequestStatusService(sess *session.Session) Security_Certificate_Request_Status {
|
|
return Security_Certificate_Request_Status{Session: sess}
|
|
}
|
|
|
|
func (r Security_Certificate_Request_Status) Id(id int) Security_Certificate_Request_Status {
|
|
r.Options.Id = &id
|
|
return r
|
|
}
|
|
|
|
func (r Security_Certificate_Request_Status) Mask(mask string) Security_Certificate_Request_Status {
|
|
if !strings.HasPrefix(mask, "mask[") && (strings.Contains(mask, "[") || strings.Contains(mask, ",")) {
|
|
mask = fmt.Sprintf("mask[%s]", mask)
|
|
}
|
|
|
|
r.Options.Mask = mask
|
|
return r
|
|
}
|
|
|
|
func (r Security_Certificate_Request_Status) Filter(filter string) Security_Certificate_Request_Status {
|
|
r.Options.Filter = filter
|
|
return r
|
|
}
|
|
|
|
func (r Security_Certificate_Request_Status) Limit(limit int) Security_Certificate_Request_Status {
|
|
r.Options.Limit = &limit
|
|
return r
|
|
}
|
|
|
|
func (r Security_Certificate_Request_Status) Offset(offset int) Security_Certificate_Request_Status {
|
|
r.Options.Offset = &offset
|
|
return r
|
|
}
|
|
|
|
// no documentation yet
|
|
func (r Security_Certificate_Request_Status) GetObject() (resp datatypes.Security_Certificate_Request_Status, err error) {
|
|
err = r.Session.DoRequest("SoftLayer_Security_Certificate_Request_Status", "getObject", nil, &r.Options, &resp)
|
|
return
|
|
}
|
|
|
|
// Returns all SSL certificate request status objects
|
|
func (r Security_Certificate_Request_Status) GetSslRequestStatuses() (resp []datatypes.Security_Certificate_Request_Status, err error) {
|
|
err = r.Session.DoRequest("SoftLayer_Security_Certificate_Request_Status", "getSslRequestStatuses", nil, &r.Options, &resp)
|
|
return
|
|
}
|
|
|
|
// no documentation yet
|
|
type Security_Ssh_Key struct {
|
|
Session *session.Session
|
|
Options sl.Options
|
|
}
|
|
|
|
// GetSecuritySshKeyService returns an instance of the Security_Ssh_Key SoftLayer service
|
|
func GetSecuritySshKeyService(sess *session.Session) Security_Ssh_Key {
|
|
return Security_Ssh_Key{Session: sess}
|
|
}
|
|
|
|
func (r Security_Ssh_Key) Id(id int) Security_Ssh_Key {
|
|
r.Options.Id = &id
|
|
return r
|
|
}
|
|
|
|
func (r Security_Ssh_Key) Mask(mask string) Security_Ssh_Key {
|
|
if !strings.HasPrefix(mask, "mask[") && (strings.Contains(mask, "[") || strings.Contains(mask, ",")) {
|
|
mask = fmt.Sprintf("mask[%s]", mask)
|
|
}
|
|
|
|
r.Options.Mask = mask
|
|
return r
|
|
}
|
|
|
|
func (r Security_Ssh_Key) Filter(filter string) Security_Ssh_Key {
|
|
r.Options.Filter = filter
|
|
return r
|
|
}
|
|
|
|
func (r Security_Ssh_Key) Limit(limit int) Security_Ssh_Key {
|
|
r.Options.Limit = &limit
|
|
return r
|
|
}
|
|
|
|
func (r Security_Ssh_Key) Offset(offset int) Security_Ssh_Key {
|
|
r.Options.Offset = &offset
|
|
return r
|
|
}
|
|
|
|
// Add a ssh key to your account for use during server provisioning and os reloads.
|
|
func (r Security_Ssh_Key) CreateObject(templateObject *datatypes.Security_Ssh_Key) (resp datatypes.Security_Ssh_Key, err error) {
|
|
params := []interface{}{
|
|
templateObject,
|
|
}
|
|
err = r.Session.DoRequest("SoftLayer_Security_Ssh_Key", "createObject", params, &r.Options, &resp)
|
|
return
|
|
}
|
|
|
|
// Remove a ssh key from your account.
|
|
func (r Security_Ssh_Key) DeleteObject() (resp bool, err error) {
|
|
err = r.Session.DoRequest("SoftLayer_Security_Ssh_Key", "deleteObject", nil, &r.Options, &resp)
|
|
return
|
|
}
|
|
|
|
// Update a ssh key.
|
|
func (r Security_Ssh_Key) EditObject(templateObject *datatypes.Security_Ssh_Key) (resp bool, err error) {
|
|
params := []interface{}{
|
|
templateObject,
|
|
}
|
|
err = r.Session.DoRequest("SoftLayer_Security_Ssh_Key", "editObject", params, &r.Options, &resp)
|
|
return
|
|
}
|
|
|
|
// Retrieve
|
|
func (r Security_Ssh_Key) GetAccount() (resp datatypes.Account, err error) {
|
|
err = r.Session.DoRequest("SoftLayer_Security_Ssh_Key", "getAccount", nil, &r.Options, &resp)
|
|
return
|
|
}
|
|
|
|
// Retrieve The image template groups that are linked to an SSH key.
|
|
func (r Security_Ssh_Key) GetBlockDeviceTemplateGroups() (resp []datatypes.Virtual_Guest_Block_Device_Template_Group, err error) {
|
|
err = r.Session.DoRequest("SoftLayer_Security_Ssh_Key", "getBlockDeviceTemplateGroups", nil, &r.Options, &resp)
|
|
return
|
|
}
|
|
|
|
// no documentation yet
|
|
func (r Security_Ssh_Key) GetObject() (resp datatypes.Security_Ssh_Key, err error) {
|
|
err = r.Session.DoRequest("SoftLayer_Security_Ssh_Key", "getObject", nil, &r.Options, &resp)
|
|
return
|
|
}
|
|
|
|
// Retrieve The OS root users that are linked to an SSH key.
|
|
func (r Security_Ssh_Key) GetSoftwarePasswords() (resp []datatypes.Software_Component_Password, err error) {
|
|
err = r.Session.DoRequest("SoftLayer_Security_Ssh_Key", "getSoftwarePasswords", nil, &r.Options, &resp)
|
|
return
|
|
}
|