security.go raw
1 /**
2 * Copyright 2016-2024 IBM Corp.
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
5 * the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
6 *
7 * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed
8 * on an "AS IS" BASIS,WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
9 * See the License for the specific language governing permissions and limitations under the License.
10 */
11
12 // AUTOMATICALLY GENERATED CODE - DO NOT MODIFY
13
14 package services
15
16 import (
17 "fmt"
18 "strings"
19
20 "github.com/softlayer/softlayer-go/datatypes"
21 "github.com/softlayer/softlayer-go/session"
22 "github.com/softlayer/softlayer-go/sl"
23 )
24
25 // no documentation yet
26 type Security_Certificate struct {
27 Session session.SLSession
28 Options sl.Options
29 }
30
31 // GetSecurityCertificateService returns an instance of the Security_Certificate SoftLayer service
32 func GetSecurityCertificateService(sess session.SLSession) Security_Certificate {
33 return Security_Certificate{Session: sess}
34 }
35
36 func (r Security_Certificate) Id(id int) Security_Certificate {
37 r.Options.Id = &id
38 return r
39 }
40
41 func (r Security_Certificate) Mask(mask string) Security_Certificate {
42 if !strings.HasPrefix(mask, "mask[") && (strings.Contains(mask, "[") || strings.Contains(mask, ",")) {
43 mask = fmt.Sprintf("mask[%s]", mask)
44 }
45
46 r.Options.Mask = mask
47 return r
48 }
49
50 func (r Security_Certificate) Filter(filter string) Security_Certificate {
51 r.Options.Filter = filter
52 return r
53 }
54
55 func (r Security_Certificate) Limit(limit int) Security_Certificate {
56 r.Options.Limit = &limit
57 return r
58 }
59
60 func (r Security_Certificate) Offset(offset int) Security_Certificate {
61 r.Options.Offset = &offset
62 return r
63 }
64
65 // 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.
66 //
67 // The certificate signing request is not required, but can be provided for your records.
68 func (r Security_Certificate) CreateObject(templateObject *datatypes.Security_Certificate) (resp datatypes.Security_Certificate, err error) {
69 params := []interface{}{
70 templateObject,
71 }
72 err = r.Session.DoRequest("SoftLayer_Security_Certificate", "createObject", params, &r.Options, &resp)
73 return
74 }
75
76 // Remove a certificate from your account. You may not remove a certificate with associated services.
77 func (r Security_Certificate) DeleteObject() (resp bool, err error) {
78 err = r.Session.DoRequest("SoftLayer_Security_Certificate", "deleteObject", nil, &r.Options, &resp)
79 return
80 }
81
82 // 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.
83 func (r Security_Certificate) EditObject(templateObject *datatypes.Security_Certificate) (resp bool, err error) {
84 params := []interface{}{
85 templateObject,
86 }
87 err = r.Session.DoRequest("SoftLayer_Security_Certificate", "editObject", params, &r.Options, &resp)
88 return
89 }
90
91 // Locate certificates by their common name, traditionally a domain name.
92 func (r Security_Certificate) FindByCommonName(commonName *string) (resp []datatypes.Security_Certificate, err error) {
93 params := []interface{}{
94 commonName,
95 }
96 err = r.Session.DoRequest("SoftLayer_Security_Certificate", "findByCommonName", params, &r.Options, &resp)
97 return
98 }
99
100 // Retrieve The number of services currently associated with the certificate.
101 func (r Security_Certificate) GetAssociatedServiceCount() (resp int, err error) {
102 err = r.Session.DoRequest("SoftLayer_Security_Certificate", "getAssociatedServiceCount", nil, &r.Options, &resp)
103 return
104 }
105
106 // Retrieve Cloud Load Balancer [LBaaS] listeners currently associated with the certificate.
107 func (r Security_Certificate) GetLbaasListeners() (resp []datatypes.Network_LBaaS_Listener, err error) {
108 err = r.Session.DoRequest("SoftLayer_Security_Certificate", "getLbaasListeners", nil, &r.Options, &resp)
109 return
110 }
111
112 // Retrieve The load balancers virtual IP addresses currently associated with the certificate.
113 func (r Security_Certificate) GetLoadBalancerVirtualIpAddresses() (resp []datatypes.Network_Application_Delivery_Controller_LoadBalancer_VirtualIpAddress, err error) {
114 err = r.Session.DoRequest("SoftLayer_Security_Certificate", "getLoadBalancerVirtualIpAddresses", nil, &r.Options, &resp)
115 return
116 }
117
118 // no documentation yet
119 func (r Security_Certificate) GetObject() (resp datatypes.Security_Certificate, err error) {
120 err = r.Session.DoRequest("SoftLayer_Security_Certificate", "getObject", nil, &r.Options, &resp)
121 return
122 }
123
124 // Retrieve the certificate in PEM (Privacy Enhanced Mail) format, which is a string containing all base64 encoded (DER) certificates delimited by -----BEGIN/END *----- clauses.
125 func (r Security_Certificate) GetPemFormat() (resp string, err error) {
126 err = r.Session.DoRequest("SoftLayer_Security_Certificate", "getPemFormat", nil, &r.Options, &resp)
127 return
128 }
129
130 // The SoftLayer_Security_Certificate_Request data type is used to view details about your SSL certificate order. This contains data that is required by a Certificate Authority to place an SSL certificate order.
131 type Security_Certificate_Request struct {
132 Session session.SLSession
133 Options sl.Options
134 }
135
136 // GetSecurityCertificateRequestService returns an instance of the Security_Certificate_Request SoftLayer service
137 func GetSecurityCertificateRequestService(sess session.SLSession) Security_Certificate_Request {
138 return Security_Certificate_Request{Session: sess}
139 }
140
141 func (r Security_Certificate_Request) Id(id int) Security_Certificate_Request {
142 r.Options.Id = &id
143 return r
144 }
145
146 func (r Security_Certificate_Request) Mask(mask string) Security_Certificate_Request {
147 if !strings.HasPrefix(mask, "mask[") && (strings.Contains(mask, "[") || strings.Contains(mask, ",")) {
148 mask = fmt.Sprintf("mask[%s]", mask)
149 }
150
151 r.Options.Mask = mask
152 return r
153 }
154
155 func (r Security_Certificate_Request) Filter(filter string) Security_Certificate_Request {
156 r.Options.Filter = filter
157 return r
158 }
159
160 func (r Security_Certificate_Request) Limit(limit int) Security_Certificate_Request {
161 r.Options.Limit = &limit
162 return r
163 }
164
165 func (r Security_Certificate_Request) Offset(offset int) Security_Certificate_Request {
166 r.Options.Offset = &offset
167 return r
168 }
169
170 // Cancels a pending SSL certificate order at the Certificate Authority
171 func (r Security_Certificate_Request) CancelSslOrder() (resp bool, err error) {
172 err = r.Session.DoRequest("SoftLayer_Security_Certificate_Request", "cancelSslOrder", nil, &r.Options, &resp)
173 return
174 }
175
176 // Retrieve The account to which a SSL certificate request belongs.
177 func (r Security_Certificate_Request) GetAccount() (resp datatypes.Account, err error) {
178 err = r.Session.DoRequest("SoftLayer_Security_Certificate_Request", "getAccount", nil, &r.Options, &resp)
179 return
180 }
181
182 // Gets the email domains that can be used to validate a certificate to a domain.
183 func (r Security_Certificate_Request) GetAdministratorEmailDomains(commonName *string) (resp []string, err error) {
184 params := []interface{}{
185 commonName,
186 }
187 err = r.Session.DoRequest("SoftLayer_Security_Certificate_Request", "getAdministratorEmailDomains", params, &r.Options, &resp)
188 return
189 }
190
191 // Gets the email accounts that can be used to validate a certificate to a domain.
192 func (r Security_Certificate_Request) GetAdministratorEmailPrefixes() (resp []string, err error) {
193 err = r.Session.DoRequest("SoftLayer_Security_Certificate_Request", "getAdministratorEmailPrefixes", nil, &r.Options, &resp)
194 return
195 }
196
197 // no documentation yet
198 func (r Security_Certificate_Request) GetObject() (resp datatypes.Security_Certificate_Request, err error) {
199 err = r.Session.DoRequest("SoftLayer_Security_Certificate_Request", "getObject", nil, &r.Options, &resp)
200 return
201 }
202
203 // Retrieve The order contains the information related to a SSL certificate request.
204 func (r Security_Certificate_Request) GetOrder() (resp datatypes.Billing_Order, err error) {
205 err = r.Session.DoRequest("SoftLayer_Security_Certificate_Request", "getOrder", nil, &r.Options, &resp)
206 return
207 }
208
209 // Retrieve The associated order item for this SSL certificate request.
210 func (r Security_Certificate_Request) GetOrderItem() (resp datatypes.Billing_Order_Item, err error) {
211 err = r.Session.DoRequest("SoftLayer_Security_Certificate_Request", "getOrderItem", nil, &r.Options, &resp)
212 return
213 }
214
215 // Returns previous SSL certificate order data. You can use this data for to place a renewal order for a completed SSL certificate.
216 func (r Security_Certificate_Request) GetPreviousOrderData() (resp datatypes.Container_Product_Order_Security_Certificate, err error) {
217 err = r.Session.DoRequest("SoftLayer_Security_Certificate_Request", "getPreviousOrderData", nil, &r.Options, &resp)
218 return
219 }
220
221 // Returns all the SSL certificate requests.
222 func (r Security_Certificate_Request) GetSslCertificateRequests(accountId *int) (resp []datatypes.Security_Certificate_Request, err error) {
223 params := []interface{}{
224 accountId,
225 }
226 err = r.Session.DoRequest("SoftLayer_Security_Certificate_Request", "getSslCertificateRequests", params, &r.Options, &resp)
227 return
228 }
229
230 // Retrieve The status of a SSL certificate request.
231 func (r Security_Certificate_Request) GetStatus() (resp datatypes.Security_Certificate_Request_Status, err error) {
232 err = r.Session.DoRequest("SoftLayer_Security_Certificate_Request", "getStatus", nil, &r.Options, &resp)
233 return
234 }
235
236 // A Certificate Authority sends out various emails to your domain administrator or your technical contact. Use this service to have these emails re-sent.
237 func (r Security_Certificate_Request) ResendEmail(emailType *string) (resp bool, err error) {
238 params := []interface{}{
239 emailType,
240 }
241 err = r.Session.DoRequest("SoftLayer_Security_Certificate_Request", "resendEmail", params, &r.Options, &resp)
242 return
243 }
244
245 // 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.
246 //
247 // More information on CSR generation can be found at: [http://en.wikipedia.org/wiki/Certificate_signing_request Wikipedia] [https://www.digicert.com/csr-creation.htm DigiCert]
248 func (r Security_Certificate_Request) ValidateCsr(csr *string, validityMonths *int, itemId *int, serverType *string) (resp bool, err error) {
249 params := []interface{}{
250 csr,
251 validityMonths,
252 itemId,
253 serverType,
254 }
255 err = r.Session.DoRequest("SoftLayer_Security_Certificate_Request", "validateCsr", params, &r.Options, &resp)
256 return
257 }
258
259 // Represents a server type that can be specified when ordering an SSL certificate.
260 type Security_Certificate_Request_ServerType struct {
261 Session session.SLSession
262 Options sl.Options
263 }
264
265 // GetSecurityCertificateRequestServerTypeService returns an instance of the Security_Certificate_Request_ServerType SoftLayer service
266 func GetSecurityCertificateRequestServerTypeService(sess session.SLSession) Security_Certificate_Request_ServerType {
267 return Security_Certificate_Request_ServerType{Session: sess}
268 }
269
270 func (r Security_Certificate_Request_ServerType) Id(id int) Security_Certificate_Request_ServerType {
271 r.Options.Id = &id
272 return r
273 }
274
275 func (r Security_Certificate_Request_ServerType) Mask(mask string) Security_Certificate_Request_ServerType {
276 if !strings.HasPrefix(mask, "mask[") && (strings.Contains(mask, "[") || strings.Contains(mask, ",")) {
277 mask = fmt.Sprintf("mask[%s]", mask)
278 }
279
280 r.Options.Mask = mask
281 return r
282 }
283
284 func (r Security_Certificate_Request_ServerType) Filter(filter string) Security_Certificate_Request_ServerType {
285 r.Options.Filter = filter
286 return r
287 }
288
289 func (r Security_Certificate_Request_ServerType) Limit(limit int) Security_Certificate_Request_ServerType {
290 r.Options.Limit = &limit
291 return r
292 }
293
294 func (r Security_Certificate_Request_ServerType) Offset(offset int) Security_Certificate_Request_ServerType {
295 r.Options.Offset = &offset
296 return r
297 }
298
299 // Returns all SSL certificate server types, which are passed in on a [[SoftLayer_Container_Product_Order_Security_Certificate|certificate order]].
300 func (r Security_Certificate_Request_ServerType) GetAllObjects() (resp []datatypes.Security_Certificate_Request_ServerType, err error) {
301 err = r.Session.DoRequest("SoftLayer_Security_Certificate_Request_ServerType", "getAllObjects", nil, &r.Options, &resp)
302 return
303 }
304
305 // no documentation yet
306 func (r Security_Certificate_Request_ServerType) GetObject() (resp datatypes.Security_Certificate_Request_ServerType, err error) {
307 err = r.Session.DoRequest("SoftLayer_Security_Certificate_Request_ServerType", "getObject", nil, &r.Options, &resp)
308 return
309 }
310
311 // Represents the status of an SSL certificate request.
312 type Security_Certificate_Request_Status struct {
313 Session session.SLSession
314 Options sl.Options
315 }
316
317 // GetSecurityCertificateRequestStatusService returns an instance of the Security_Certificate_Request_Status SoftLayer service
318 func GetSecurityCertificateRequestStatusService(sess session.SLSession) Security_Certificate_Request_Status {
319 return Security_Certificate_Request_Status{Session: sess}
320 }
321
322 func (r Security_Certificate_Request_Status) Id(id int) Security_Certificate_Request_Status {
323 r.Options.Id = &id
324 return r
325 }
326
327 func (r Security_Certificate_Request_Status) Mask(mask string) Security_Certificate_Request_Status {
328 if !strings.HasPrefix(mask, "mask[") && (strings.Contains(mask, "[") || strings.Contains(mask, ",")) {
329 mask = fmt.Sprintf("mask[%s]", mask)
330 }
331
332 r.Options.Mask = mask
333 return r
334 }
335
336 func (r Security_Certificate_Request_Status) Filter(filter string) Security_Certificate_Request_Status {
337 r.Options.Filter = filter
338 return r
339 }
340
341 func (r Security_Certificate_Request_Status) Limit(limit int) Security_Certificate_Request_Status {
342 r.Options.Limit = &limit
343 return r
344 }
345
346 func (r Security_Certificate_Request_Status) Offset(offset int) Security_Certificate_Request_Status {
347 r.Options.Offset = &offset
348 return r
349 }
350
351 // no documentation yet
352 func (r Security_Certificate_Request_Status) GetObject() (resp datatypes.Security_Certificate_Request_Status, err error) {
353 err = r.Session.DoRequest("SoftLayer_Security_Certificate_Request_Status", "getObject", nil, &r.Options, &resp)
354 return
355 }
356
357 // Returns all SSL certificate request status objects
358 func (r Security_Certificate_Request_Status) GetSslRequestStatuses() (resp []datatypes.Security_Certificate_Request_Status, err error) {
359 err = r.Session.DoRequest("SoftLayer_Security_Certificate_Request_Status", "getSslRequestStatuses", nil, &r.Options, &resp)
360 return
361 }
362
363 // no documentation yet
364 type Security_Ssh_Key struct {
365 Session session.SLSession
366 Options sl.Options
367 }
368
369 // GetSecuritySshKeyService returns an instance of the Security_Ssh_Key SoftLayer service
370 func GetSecuritySshKeyService(sess session.SLSession) Security_Ssh_Key {
371 return Security_Ssh_Key{Session: sess}
372 }
373
374 func (r Security_Ssh_Key) Id(id int) Security_Ssh_Key {
375 r.Options.Id = &id
376 return r
377 }
378
379 func (r Security_Ssh_Key) Mask(mask string) Security_Ssh_Key {
380 if !strings.HasPrefix(mask, "mask[") && (strings.Contains(mask, "[") || strings.Contains(mask, ",")) {
381 mask = fmt.Sprintf("mask[%s]", mask)
382 }
383
384 r.Options.Mask = mask
385 return r
386 }
387
388 func (r Security_Ssh_Key) Filter(filter string) Security_Ssh_Key {
389 r.Options.Filter = filter
390 return r
391 }
392
393 func (r Security_Ssh_Key) Limit(limit int) Security_Ssh_Key {
394 r.Options.Limit = &limit
395 return r
396 }
397
398 func (r Security_Ssh_Key) Offset(offset int) Security_Ssh_Key {
399 r.Options.Offset = &offset
400 return r
401 }
402
403 // Add a ssh key to your account for use during server provisioning and os reloads.
404 func (r Security_Ssh_Key) CreateObject(templateObject *datatypes.Security_Ssh_Key) (resp datatypes.Security_Ssh_Key, err error) {
405 params := []interface{}{
406 templateObject,
407 }
408 err = r.Session.DoRequest("SoftLayer_Security_Ssh_Key", "createObject", params, &r.Options, &resp)
409 return
410 }
411
412 // Remove a ssh key from your account.
413 func (r Security_Ssh_Key) DeleteObject() (resp bool, err error) {
414 err = r.Session.DoRequest("SoftLayer_Security_Ssh_Key", "deleteObject", nil, &r.Options, &resp)
415 return
416 }
417
418 // Update a ssh key.
419 func (r Security_Ssh_Key) EditObject(templateObject *datatypes.Security_Ssh_Key) (resp bool, err error) {
420 params := []interface{}{
421 templateObject,
422 }
423 err = r.Session.DoRequest("SoftLayer_Security_Ssh_Key", "editObject", params, &r.Options, &resp)
424 return
425 }
426
427 // Retrieve
428 func (r Security_Ssh_Key) GetAccount() (resp datatypes.Account, err error) {
429 err = r.Session.DoRequest("SoftLayer_Security_Ssh_Key", "getAccount", nil, &r.Options, &resp)
430 return
431 }
432
433 // Retrieve The image template groups that are linked to an SSH key.
434 func (r Security_Ssh_Key) GetBlockDeviceTemplateGroups() (resp []datatypes.Virtual_Guest_Block_Device_Template_Group, err error) {
435 err = r.Session.DoRequest("SoftLayer_Security_Ssh_Key", "getBlockDeviceTemplateGroups", nil, &r.Options, &resp)
436 return
437 }
438
439 // no documentation yet
440 func (r Security_Ssh_Key) GetObject() (resp datatypes.Security_Ssh_Key, err error) {
441 err = r.Session.DoRequest("SoftLayer_Security_Ssh_Key", "getObject", nil, &r.Options, &resp)
442 return
443 }
444
445 // Retrieve The OS root users that are linked to an SSH key.
446 func (r Security_Ssh_Key) GetSoftwarePasswords() (resp []datatypes.Software_Component_Password, err error) {
447 err = r.Session.DoRequest("SoftLayer_Security_Ssh_Key", "getSoftwarePasswords", nil, &r.Options, &resp)
448 return
449 }
450