1// Copyright (c) 2016, 2018, 2019, Oracle and/or its affiliates. All rights reserved. 2// Code generated. DO NOT EDIT. 3 4// Core Services API 5// 6// API covering the Networking (https://docs.cloud.oracle.com/iaas/Content/Network/Concepts/overview.htm), 7// Compute (https://docs.cloud.oracle.com/iaas/Content/Compute/Concepts/computeoverview.htm), and 8// Block Volume (https://docs.cloud.oracle.com/iaas/Content/Block/Concepts/overview.htm) services. Use this API 9// to manage resources such as virtual cloud networks (VCNs), compute instances, and 10// block storage volumes. 11// 12 13package core 14 15import ( 16 "context" 17 "fmt" 18 "github.com/oracle/oci-go-sdk/common" 19 "net/http" 20) 21 22//VirtualNetworkClient a client for VirtualNetwork 23type VirtualNetworkClient struct { 24 common.BaseClient 25 config *common.ConfigurationProvider 26} 27 28// NewVirtualNetworkClientWithConfigurationProvider Creates a new default VirtualNetwork client with the given configuration provider. 29// the configuration provider will be used for the default signer as well as reading the region 30func NewVirtualNetworkClientWithConfigurationProvider(configProvider common.ConfigurationProvider) (client VirtualNetworkClient, err error) { 31 baseClient, err := common.NewClientWithConfig(configProvider) 32 if err != nil { 33 return 34 } 35 36 client = VirtualNetworkClient{BaseClient: baseClient} 37 client.BasePath = "20160918" 38 err = client.setConfigurationProvider(configProvider) 39 return 40} 41 42// SetRegion overrides the region of this client. 43func (client *VirtualNetworkClient) SetRegion(region string) { 44 client.Host = common.StringToRegion(region).EndpointForTemplate("iaas", "https://iaas.{region}.{secondLevelDomain}") 45} 46 47// SetConfigurationProvider sets the configuration provider including the region, returns an error if is not valid 48func (client *VirtualNetworkClient) setConfigurationProvider(configProvider common.ConfigurationProvider) error { 49 if ok, err := common.IsConfigurationProviderValid(configProvider); !ok { 50 return err 51 } 52 53 // Error has been checked already 54 region, _ := configProvider.Region() 55 client.SetRegion(region) 56 client.config = &configProvider 57 return nil 58} 59 60// ConfigurationProvider the ConfigurationProvider used in this client, or null if none set 61func (client *VirtualNetworkClient) ConfigurationProvider() *common.ConfigurationProvider { 62 return client.config 63} 64 65// AddNetworkSecurityGroupSecurityRules Adds one or more security rules to the specified network security group. 66func (client VirtualNetworkClient) AddNetworkSecurityGroupSecurityRules(ctx context.Context, request AddNetworkSecurityGroupSecurityRulesRequest) (response AddNetworkSecurityGroupSecurityRulesResponse, err error) { 67 var ociResponse common.OCIResponse 68 policy := common.NoRetryPolicy() 69 if request.RetryPolicy() != nil { 70 policy = *request.RetryPolicy() 71 } 72 ociResponse, err = common.Retry(ctx, request, client.addNetworkSecurityGroupSecurityRules, policy) 73 if err != nil { 74 if ociResponse != nil { 75 response = AddNetworkSecurityGroupSecurityRulesResponse{RawResponse: ociResponse.HTTPResponse()} 76 } 77 return 78 } 79 if convertedResponse, ok := ociResponse.(AddNetworkSecurityGroupSecurityRulesResponse); ok { 80 response = convertedResponse 81 } else { 82 err = fmt.Errorf("failed to convert OCIResponse into AddNetworkSecurityGroupSecurityRulesResponse") 83 } 84 return 85} 86 87// addNetworkSecurityGroupSecurityRules implements the OCIOperation interface (enables retrying operations) 88func (client VirtualNetworkClient) addNetworkSecurityGroupSecurityRules(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 89 httpRequest, err := request.HTTPRequest(http.MethodPost, "/networkSecurityGroups/{networkSecurityGroupId}/actions/addSecurityRules") 90 if err != nil { 91 return nil, err 92 } 93 94 var response AddNetworkSecurityGroupSecurityRulesResponse 95 var httpResponse *http.Response 96 httpResponse, err = client.Call(ctx, &httpRequest) 97 defer common.CloseBodyIfValid(httpResponse) 98 response.RawResponse = httpResponse 99 if err != nil { 100 return response, err 101 } 102 103 err = common.UnmarshalResponse(httpResponse, &response) 104 return response, err 105} 106 107// AttachServiceId Adds the specified Service to the list of enabled 108// `Service` objects for the specified gateway. You must also set up a route rule with the 109// `cidrBlock` of the `Service` as the rule's destination and the service gateway as the rule's 110// target. See RouteTable. 111// **Note:** The `AttachServiceId` operation is an easy way to add an individual `Service` to 112// the service gateway. Compare it with 113// UpdateServiceGateway, which replaces 114// the entire existing list of enabled `Service` objects with the list that you provide in the 115// `Update` call. 116func (client VirtualNetworkClient) AttachServiceId(ctx context.Context, request AttachServiceIdRequest) (response AttachServiceIdResponse, err error) { 117 var ociResponse common.OCIResponse 118 policy := common.NoRetryPolicy() 119 if request.RetryPolicy() != nil { 120 policy = *request.RetryPolicy() 121 } 122 ociResponse, err = common.Retry(ctx, request, client.attachServiceId, policy) 123 if err != nil { 124 if ociResponse != nil { 125 response = AttachServiceIdResponse{RawResponse: ociResponse.HTTPResponse()} 126 } 127 return 128 } 129 if convertedResponse, ok := ociResponse.(AttachServiceIdResponse); ok { 130 response = convertedResponse 131 } else { 132 err = fmt.Errorf("failed to convert OCIResponse into AttachServiceIdResponse") 133 } 134 return 135} 136 137// attachServiceId implements the OCIOperation interface (enables retrying operations) 138func (client VirtualNetworkClient) attachServiceId(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 139 httpRequest, err := request.HTTPRequest(http.MethodPost, "/serviceGateways/{serviceGatewayId}/actions/attachService") 140 if err != nil { 141 return nil, err 142 } 143 144 var response AttachServiceIdResponse 145 var httpResponse *http.Response 146 httpResponse, err = client.Call(ctx, &httpRequest) 147 defer common.CloseBodyIfValid(httpResponse) 148 response.RawResponse = httpResponse 149 if err != nil { 150 return response, err 151 } 152 153 err = common.UnmarshalResponse(httpResponse, &response) 154 return response, err 155} 156 157// BulkAddVirtualCircuitPublicPrefixes Adds one or more customer public IP prefixes to the specified public virtual circuit. 158// Use this operation (and not UpdateVirtualCircuit) 159// to add prefixes to the virtual circuit. Oracle must verify the customer's ownership 160// of each prefix before traffic for that prefix will flow across the virtual circuit. 161func (client VirtualNetworkClient) BulkAddVirtualCircuitPublicPrefixes(ctx context.Context, request BulkAddVirtualCircuitPublicPrefixesRequest) (err error) { 162 policy := common.NoRetryPolicy() 163 if request.RetryPolicy() != nil { 164 policy = *request.RetryPolicy() 165 } 166 _, err = common.Retry(ctx, request, client.bulkAddVirtualCircuitPublicPrefixes, policy) 167 return 168} 169 170// bulkAddVirtualCircuitPublicPrefixes implements the OCIOperation interface (enables retrying operations) 171func (client VirtualNetworkClient) bulkAddVirtualCircuitPublicPrefixes(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 172 httpRequest, err := request.HTTPRequest(http.MethodPost, "/virtualCircuits/{virtualCircuitId}/actions/bulkAddPublicPrefixes") 173 if err != nil { 174 return nil, err 175 } 176 177 var response BulkAddVirtualCircuitPublicPrefixesResponse 178 var httpResponse *http.Response 179 httpResponse, err = client.Call(ctx, &httpRequest) 180 defer common.CloseBodyIfValid(httpResponse) 181 response.RawResponse = httpResponse 182 if err != nil { 183 return response, err 184 } 185 186 err = common.UnmarshalResponse(httpResponse, &response) 187 return response, err 188} 189 190// BulkDeleteVirtualCircuitPublicPrefixes Removes one or more customer public IP prefixes from the specified public virtual circuit. 191// Use this operation (and not UpdateVirtualCircuit) 192// to remove prefixes from the virtual circuit. When the virtual circuit's state switches 193// back to PROVISIONED, Oracle stops advertising the specified prefixes across the connection. 194func (client VirtualNetworkClient) BulkDeleteVirtualCircuitPublicPrefixes(ctx context.Context, request BulkDeleteVirtualCircuitPublicPrefixesRequest) (err error) { 195 policy := common.NoRetryPolicy() 196 if request.RetryPolicy() != nil { 197 policy = *request.RetryPolicy() 198 } 199 _, err = common.Retry(ctx, request, client.bulkDeleteVirtualCircuitPublicPrefixes, policy) 200 return 201} 202 203// bulkDeleteVirtualCircuitPublicPrefixes implements the OCIOperation interface (enables retrying operations) 204func (client VirtualNetworkClient) bulkDeleteVirtualCircuitPublicPrefixes(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 205 httpRequest, err := request.HTTPRequest(http.MethodPost, "/virtualCircuits/{virtualCircuitId}/actions/bulkDeletePublicPrefixes") 206 if err != nil { 207 return nil, err 208 } 209 210 var response BulkDeleteVirtualCircuitPublicPrefixesResponse 211 var httpResponse *http.Response 212 httpResponse, err = client.Call(ctx, &httpRequest) 213 defer common.CloseBodyIfValid(httpResponse) 214 response.RawResponse = httpResponse 215 if err != nil { 216 return response, err 217 } 218 219 err = common.UnmarshalResponse(httpResponse, &response) 220 return response, err 221} 222 223// ChangeCpeCompartment Moves a CPE object into a different compartment within the same tenancy. For information 224// about moving resources between compartments, see 225// Moving Resources to a Different Compartment (https://docs.cloud.oracle.com/iaas/Content/Identity/Tasks/managingcompartments.htm#moveRes). 226func (client VirtualNetworkClient) ChangeCpeCompartment(ctx context.Context, request ChangeCpeCompartmentRequest) (response ChangeCpeCompartmentResponse, err error) { 227 var ociResponse common.OCIResponse 228 policy := common.NoRetryPolicy() 229 if request.RetryPolicy() != nil { 230 policy = *request.RetryPolicy() 231 } 232 233 if !(request.OpcRetryToken != nil && *request.OpcRetryToken != "") { 234 request.OpcRetryToken = common.String(common.RetryToken()) 235 } 236 237 ociResponse, err = common.Retry(ctx, request, client.changeCpeCompartment, policy) 238 if err != nil { 239 if ociResponse != nil { 240 response = ChangeCpeCompartmentResponse{RawResponse: ociResponse.HTTPResponse()} 241 } 242 return 243 } 244 if convertedResponse, ok := ociResponse.(ChangeCpeCompartmentResponse); ok { 245 response = convertedResponse 246 } else { 247 err = fmt.Errorf("failed to convert OCIResponse into ChangeCpeCompartmentResponse") 248 } 249 return 250} 251 252// changeCpeCompartment implements the OCIOperation interface (enables retrying operations) 253func (client VirtualNetworkClient) changeCpeCompartment(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 254 httpRequest, err := request.HTTPRequest(http.MethodPost, "/cpes/{cpeId}/actions/changeCompartment") 255 if err != nil { 256 return nil, err 257 } 258 259 var response ChangeCpeCompartmentResponse 260 var httpResponse *http.Response 261 httpResponse, err = client.Call(ctx, &httpRequest) 262 defer common.CloseBodyIfValid(httpResponse) 263 response.RawResponse = httpResponse 264 if err != nil { 265 return response, err 266 } 267 268 err = common.UnmarshalResponse(httpResponse, &response) 269 return response, err 270} 271 272// ChangeCrossConnectCompartment Moves a cross-connect into a different compartment within the same tenancy. For information 273// about moving resources between compartments, see 274// Moving Resources to a Different Compartment (https://docs.cloud.oracle.com/iaas/Content/Identity/Tasks/managingcompartments.htm#moveRes). 275func (client VirtualNetworkClient) ChangeCrossConnectCompartment(ctx context.Context, request ChangeCrossConnectCompartmentRequest) (response ChangeCrossConnectCompartmentResponse, err error) { 276 var ociResponse common.OCIResponse 277 policy := common.NoRetryPolicy() 278 if request.RetryPolicy() != nil { 279 policy = *request.RetryPolicy() 280 } 281 282 if !(request.OpcRetryToken != nil && *request.OpcRetryToken != "") { 283 request.OpcRetryToken = common.String(common.RetryToken()) 284 } 285 286 ociResponse, err = common.Retry(ctx, request, client.changeCrossConnectCompartment, policy) 287 if err != nil { 288 if ociResponse != nil { 289 response = ChangeCrossConnectCompartmentResponse{RawResponse: ociResponse.HTTPResponse()} 290 } 291 return 292 } 293 if convertedResponse, ok := ociResponse.(ChangeCrossConnectCompartmentResponse); ok { 294 response = convertedResponse 295 } else { 296 err = fmt.Errorf("failed to convert OCIResponse into ChangeCrossConnectCompartmentResponse") 297 } 298 return 299} 300 301// changeCrossConnectCompartment implements the OCIOperation interface (enables retrying operations) 302func (client VirtualNetworkClient) changeCrossConnectCompartment(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 303 httpRequest, err := request.HTTPRequest(http.MethodPost, "/crossConnects/{crossConnectId}/actions/changeCompartment") 304 if err != nil { 305 return nil, err 306 } 307 308 var response ChangeCrossConnectCompartmentResponse 309 var httpResponse *http.Response 310 httpResponse, err = client.Call(ctx, &httpRequest) 311 defer common.CloseBodyIfValid(httpResponse) 312 response.RawResponse = httpResponse 313 if err != nil { 314 return response, err 315 } 316 317 err = common.UnmarshalResponse(httpResponse, &response) 318 return response, err 319} 320 321// ChangeCrossConnectGroupCompartment Moves a cross-connect group into a different compartment within the same tenancy. For information 322// about moving resources between compartments, see 323// Moving Resources to a Different Compartment (https://docs.cloud.oracle.com/iaas/Content/Identity/Tasks/managingcompartments.htm#moveRes). 324func (client VirtualNetworkClient) ChangeCrossConnectGroupCompartment(ctx context.Context, request ChangeCrossConnectGroupCompartmentRequest) (response ChangeCrossConnectGroupCompartmentResponse, err error) { 325 var ociResponse common.OCIResponse 326 policy := common.NoRetryPolicy() 327 if request.RetryPolicy() != nil { 328 policy = *request.RetryPolicy() 329 } 330 331 if !(request.OpcRetryToken != nil && *request.OpcRetryToken != "") { 332 request.OpcRetryToken = common.String(common.RetryToken()) 333 } 334 335 ociResponse, err = common.Retry(ctx, request, client.changeCrossConnectGroupCompartment, policy) 336 if err != nil { 337 if ociResponse != nil { 338 response = ChangeCrossConnectGroupCompartmentResponse{RawResponse: ociResponse.HTTPResponse()} 339 } 340 return 341 } 342 if convertedResponse, ok := ociResponse.(ChangeCrossConnectGroupCompartmentResponse); ok { 343 response = convertedResponse 344 } else { 345 err = fmt.Errorf("failed to convert OCIResponse into ChangeCrossConnectGroupCompartmentResponse") 346 } 347 return 348} 349 350// changeCrossConnectGroupCompartment implements the OCIOperation interface (enables retrying operations) 351func (client VirtualNetworkClient) changeCrossConnectGroupCompartment(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 352 httpRequest, err := request.HTTPRequest(http.MethodPost, "/crossConnectGroups/{crossConnectGroupId}/actions/changeCompartment") 353 if err != nil { 354 return nil, err 355 } 356 357 var response ChangeCrossConnectGroupCompartmentResponse 358 var httpResponse *http.Response 359 httpResponse, err = client.Call(ctx, &httpRequest) 360 defer common.CloseBodyIfValid(httpResponse) 361 response.RawResponse = httpResponse 362 if err != nil { 363 return response, err 364 } 365 366 err = common.UnmarshalResponse(httpResponse, &response) 367 return response, err 368} 369 370// ChangeDhcpOptionsCompartment Moves a set of DHCP options into a different compartment within the same tenancy. For information 371// about moving resources between compartments, see 372// Moving Resources to a Different Compartment (https://docs.cloud.oracle.com/iaas/Content/Identity/Tasks/managingcompartments.htm#moveRes). 373func (client VirtualNetworkClient) ChangeDhcpOptionsCompartment(ctx context.Context, request ChangeDhcpOptionsCompartmentRequest) (response ChangeDhcpOptionsCompartmentResponse, err error) { 374 var ociResponse common.OCIResponse 375 policy := common.NoRetryPolicy() 376 if request.RetryPolicy() != nil { 377 policy = *request.RetryPolicy() 378 } 379 380 if !(request.OpcRetryToken != nil && *request.OpcRetryToken != "") { 381 request.OpcRetryToken = common.String(common.RetryToken()) 382 } 383 384 ociResponse, err = common.Retry(ctx, request, client.changeDhcpOptionsCompartment, policy) 385 if err != nil { 386 if ociResponse != nil { 387 response = ChangeDhcpOptionsCompartmentResponse{RawResponse: ociResponse.HTTPResponse()} 388 } 389 return 390 } 391 if convertedResponse, ok := ociResponse.(ChangeDhcpOptionsCompartmentResponse); ok { 392 response = convertedResponse 393 } else { 394 err = fmt.Errorf("failed to convert OCIResponse into ChangeDhcpOptionsCompartmentResponse") 395 } 396 return 397} 398 399// changeDhcpOptionsCompartment implements the OCIOperation interface (enables retrying operations) 400func (client VirtualNetworkClient) changeDhcpOptionsCompartment(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 401 httpRequest, err := request.HTTPRequest(http.MethodPost, "/dhcps/{dhcpId}/actions/changeCompartment") 402 if err != nil { 403 return nil, err 404 } 405 406 var response ChangeDhcpOptionsCompartmentResponse 407 var httpResponse *http.Response 408 httpResponse, err = client.Call(ctx, &httpRequest) 409 defer common.CloseBodyIfValid(httpResponse) 410 response.RawResponse = httpResponse 411 if err != nil { 412 return response, err 413 } 414 415 err = common.UnmarshalResponse(httpResponse, &response) 416 return response, err 417} 418 419// ChangeDrgCompartment Moves a DRG into a different compartment within the same tenancy. For information 420// about moving resources between compartments, see 421// Moving Resources to a Different Compartment (https://docs.cloud.oracle.com/iaas/Content/Identity/Tasks/managingcompartments.htm#moveRes). 422func (client VirtualNetworkClient) ChangeDrgCompartment(ctx context.Context, request ChangeDrgCompartmentRequest) (response ChangeDrgCompartmentResponse, err error) { 423 var ociResponse common.OCIResponse 424 policy := common.NoRetryPolicy() 425 if request.RetryPolicy() != nil { 426 policy = *request.RetryPolicy() 427 } 428 429 if !(request.OpcRetryToken != nil && *request.OpcRetryToken != "") { 430 request.OpcRetryToken = common.String(common.RetryToken()) 431 } 432 433 ociResponse, err = common.Retry(ctx, request, client.changeDrgCompartment, policy) 434 if err != nil { 435 if ociResponse != nil { 436 response = ChangeDrgCompartmentResponse{RawResponse: ociResponse.HTTPResponse()} 437 } 438 return 439 } 440 if convertedResponse, ok := ociResponse.(ChangeDrgCompartmentResponse); ok { 441 response = convertedResponse 442 } else { 443 err = fmt.Errorf("failed to convert OCIResponse into ChangeDrgCompartmentResponse") 444 } 445 return 446} 447 448// changeDrgCompartment implements the OCIOperation interface (enables retrying operations) 449func (client VirtualNetworkClient) changeDrgCompartment(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 450 httpRequest, err := request.HTTPRequest(http.MethodPost, "/drgs/{drgId}/actions/changeCompartment") 451 if err != nil { 452 return nil, err 453 } 454 455 var response ChangeDrgCompartmentResponse 456 var httpResponse *http.Response 457 httpResponse, err = client.Call(ctx, &httpRequest) 458 defer common.CloseBodyIfValid(httpResponse) 459 response.RawResponse = httpResponse 460 if err != nil { 461 return response, err 462 } 463 464 err = common.UnmarshalResponse(httpResponse, &response) 465 return response, err 466} 467 468// ChangeIPSecConnectionCompartment Moves an IPSec connection into a different compartment within the same tenancy. For information 469// about moving resources between compartments, see 470// Moving Resources to a Different Compartment (https://docs.cloud.oracle.com/iaas/Content/Identity/Tasks/managingcompartments.htm#moveRes). 471func (client VirtualNetworkClient) ChangeIPSecConnectionCompartment(ctx context.Context, request ChangeIPSecConnectionCompartmentRequest) (response ChangeIPSecConnectionCompartmentResponse, err error) { 472 var ociResponse common.OCIResponse 473 policy := common.NoRetryPolicy() 474 if request.RetryPolicy() != nil { 475 policy = *request.RetryPolicy() 476 } 477 478 if !(request.OpcRetryToken != nil && *request.OpcRetryToken != "") { 479 request.OpcRetryToken = common.String(common.RetryToken()) 480 } 481 482 ociResponse, err = common.Retry(ctx, request, client.changeIPSecConnectionCompartment, policy) 483 if err != nil { 484 if ociResponse != nil { 485 response = ChangeIPSecConnectionCompartmentResponse{RawResponse: ociResponse.HTTPResponse()} 486 } 487 return 488 } 489 if convertedResponse, ok := ociResponse.(ChangeIPSecConnectionCompartmentResponse); ok { 490 response = convertedResponse 491 } else { 492 err = fmt.Errorf("failed to convert OCIResponse into ChangeIPSecConnectionCompartmentResponse") 493 } 494 return 495} 496 497// changeIPSecConnectionCompartment implements the OCIOperation interface (enables retrying operations) 498func (client VirtualNetworkClient) changeIPSecConnectionCompartment(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 499 httpRequest, err := request.HTTPRequest(http.MethodPost, "/ipsecConnections/{ipscId}/actions/changeCompartment") 500 if err != nil { 501 return nil, err 502 } 503 504 var response ChangeIPSecConnectionCompartmentResponse 505 var httpResponse *http.Response 506 httpResponse, err = client.Call(ctx, &httpRequest) 507 defer common.CloseBodyIfValid(httpResponse) 508 response.RawResponse = httpResponse 509 if err != nil { 510 return response, err 511 } 512 513 err = common.UnmarshalResponse(httpResponse, &response) 514 return response, err 515} 516 517// ChangeInternetGatewayCompartment Moves an internet gateway into a different compartment within the same tenancy. For information 518// about moving resources between compartments, see 519// Moving Resources to a Different Compartment (https://docs.cloud.oracle.com/iaas/Content/Identity/Tasks/managingcompartments.htm#moveRes). 520func (client VirtualNetworkClient) ChangeInternetGatewayCompartment(ctx context.Context, request ChangeInternetGatewayCompartmentRequest) (response ChangeInternetGatewayCompartmentResponse, err error) { 521 var ociResponse common.OCIResponse 522 policy := common.NoRetryPolicy() 523 if request.RetryPolicy() != nil { 524 policy = *request.RetryPolicy() 525 } 526 527 if !(request.OpcRetryToken != nil && *request.OpcRetryToken != "") { 528 request.OpcRetryToken = common.String(common.RetryToken()) 529 } 530 531 ociResponse, err = common.Retry(ctx, request, client.changeInternetGatewayCompartment, policy) 532 if err != nil { 533 if ociResponse != nil { 534 response = ChangeInternetGatewayCompartmentResponse{RawResponse: ociResponse.HTTPResponse()} 535 } 536 return 537 } 538 if convertedResponse, ok := ociResponse.(ChangeInternetGatewayCompartmentResponse); ok { 539 response = convertedResponse 540 } else { 541 err = fmt.Errorf("failed to convert OCIResponse into ChangeInternetGatewayCompartmentResponse") 542 } 543 return 544} 545 546// changeInternetGatewayCompartment implements the OCIOperation interface (enables retrying operations) 547func (client VirtualNetworkClient) changeInternetGatewayCompartment(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 548 httpRequest, err := request.HTTPRequest(http.MethodPost, "/internetGateways/{igId}/actions/changeCompartment") 549 if err != nil { 550 return nil, err 551 } 552 553 var response ChangeInternetGatewayCompartmentResponse 554 var httpResponse *http.Response 555 httpResponse, err = client.Call(ctx, &httpRequest) 556 defer common.CloseBodyIfValid(httpResponse) 557 response.RawResponse = httpResponse 558 if err != nil { 559 return response, err 560 } 561 562 err = common.UnmarshalResponse(httpResponse, &response) 563 return response, err 564} 565 566// ChangeLocalPeeringGatewayCompartment Moves a local peering gateway into a different compartment within the same tenancy. For information 567// about moving resources between compartments, see 568// Moving Resources to a Different Compartment (https://docs.cloud.oracle.com/iaas/Content/Identity/Tasks/managingcompartments.htm#moveRes). 569func (client VirtualNetworkClient) ChangeLocalPeeringGatewayCompartment(ctx context.Context, request ChangeLocalPeeringGatewayCompartmentRequest) (response ChangeLocalPeeringGatewayCompartmentResponse, err error) { 570 var ociResponse common.OCIResponse 571 policy := common.NoRetryPolicy() 572 if request.RetryPolicy() != nil { 573 policy = *request.RetryPolicy() 574 } 575 576 if !(request.OpcRetryToken != nil && *request.OpcRetryToken != "") { 577 request.OpcRetryToken = common.String(common.RetryToken()) 578 } 579 580 ociResponse, err = common.Retry(ctx, request, client.changeLocalPeeringGatewayCompartment, policy) 581 if err != nil { 582 if ociResponse != nil { 583 response = ChangeLocalPeeringGatewayCompartmentResponse{RawResponse: ociResponse.HTTPResponse()} 584 } 585 return 586 } 587 if convertedResponse, ok := ociResponse.(ChangeLocalPeeringGatewayCompartmentResponse); ok { 588 response = convertedResponse 589 } else { 590 err = fmt.Errorf("failed to convert OCIResponse into ChangeLocalPeeringGatewayCompartmentResponse") 591 } 592 return 593} 594 595// changeLocalPeeringGatewayCompartment implements the OCIOperation interface (enables retrying operations) 596func (client VirtualNetworkClient) changeLocalPeeringGatewayCompartment(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 597 httpRequest, err := request.HTTPRequest(http.MethodPost, "/localPeeringGateways/{localPeeringGatewayId}/actions/changeCompartment") 598 if err != nil { 599 return nil, err 600 } 601 602 var response ChangeLocalPeeringGatewayCompartmentResponse 603 var httpResponse *http.Response 604 httpResponse, err = client.Call(ctx, &httpRequest) 605 defer common.CloseBodyIfValid(httpResponse) 606 response.RawResponse = httpResponse 607 if err != nil { 608 return response, err 609 } 610 611 err = common.UnmarshalResponse(httpResponse, &response) 612 return response, err 613} 614 615// ChangeNatGatewayCompartment Moves a NAT gateway into a different compartment within the same tenancy. For information 616// about moving resources between compartments, see 617// Moving Resources to a Different Compartment (https://docs.cloud.oracle.com/iaas/Content/Identity/Tasks/managingcompartments.htm#moveRes). 618func (client VirtualNetworkClient) ChangeNatGatewayCompartment(ctx context.Context, request ChangeNatGatewayCompartmentRequest) (response ChangeNatGatewayCompartmentResponse, err error) { 619 var ociResponse common.OCIResponse 620 policy := common.NoRetryPolicy() 621 if request.RetryPolicy() != nil { 622 policy = *request.RetryPolicy() 623 } 624 625 if !(request.OpcRetryToken != nil && *request.OpcRetryToken != "") { 626 request.OpcRetryToken = common.String(common.RetryToken()) 627 } 628 629 ociResponse, err = common.Retry(ctx, request, client.changeNatGatewayCompartment, policy) 630 if err != nil { 631 if ociResponse != nil { 632 response = ChangeNatGatewayCompartmentResponse{RawResponse: ociResponse.HTTPResponse()} 633 } 634 return 635 } 636 if convertedResponse, ok := ociResponse.(ChangeNatGatewayCompartmentResponse); ok { 637 response = convertedResponse 638 } else { 639 err = fmt.Errorf("failed to convert OCIResponse into ChangeNatGatewayCompartmentResponse") 640 } 641 return 642} 643 644// changeNatGatewayCompartment implements the OCIOperation interface (enables retrying operations) 645func (client VirtualNetworkClient) changeNatGatewayCompartment(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 646 httpRequest, err := request.HTTPRequest(http.MethodPost, "/natGateways/{natGatewayId}/actions/changeCompartment") 647 if err != nil { 648 return nil, err 649 } 650 651 var response ChangeNatGatewayCompartmentResponse 652 var httpResponse *http.Response 653 httpResponse, err = client.Call(ctx, &httpRequest) 654 defer common.CloseBodyIfValid(httpResponse) 655 response.RawResponse = httpResponse 656 if err != nil { 657 return response, err 658 } 659 660 err = common.UnmarshalResponse(httpResponse, &response) 661 return response, err 662} 663 664// ChangeNetworkSecurityGroupCompartment Moves a network security group into a different compartment within the same tenancy. For 665// information about moving resources between compartments, see Moving Resources to a Different Compartment (https://docs.cloud.oracle.com/iaas/Content/Identity/Tasks/managingcompartments.htm#moveRes). 666func (client VirtualNetworkClient) ChangeNetworkSecurityGroupCompartment(ctx context.Context, request ChangeNetworkSecurityGroupCompartmentRequest) (response ChangeNetworkSecurityGroupCompartmentResponse, err error) { 667 var ociResponse common.OCIResponse 668 policy := common.NoRetryPolicy() 669 if request.RetryPolicy() != nil { 670 policy = *request.RetryPolicy() 671 } 672 673 if !(request.OpcRetryToken != nil && *request.OpcRetryToken != "") { 674 request.OpcRetryToken = common.String(common.RetryToken()) 675 } 676 677 ociResponse, err = common.Retry(ctx, request, client.changeNetworkSecurityGroupCompartment, policy) 678 if err != nil { 679 if ociResponse != nil { 680 response = ChangeNetworkSecurityGroupCompartmentResponse{RawResponse: ociResponse.HTTPResponse()} 681 } 682 return 683 } 684 if convertedResponse, ok := ociResponse.(ChangeNetworkSecurityGroupCompartmentResponse); ok { 685 response = convertedResponse 686 } else { 687 err = fmt.Errorf("failed to convert OCIResponse into ChangeNetworkSecurityGroupCompartmentResponse") 688 } 689 return 690} 691 692// changeNetworkSecurityGroupCompartment implements the OCIOperation interface (enables retrying operations) 693func (client VirtualNetworkClient) changeNetworkSecurityGroupCompartment(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 694 httpRequest, err := request.HTTPRequest(http.MethodPost, "/networkSecurityGroups/{networkSecurityGroupId}/actions/changeCompartment") 695 if err != nil { 696 return nil, err 697 } 698 699 var response ChangeNetworkSecurityGroupCompartmentResponse 700 var httpResponse *http.Response 701 httpResponse, err = client.Call(ctx, &httpRequest) 702 defer common.CloseBodyIfValid(httpResponse) 703 response.RawResponse = httpResponse 704 if err != nil { 705 return response, err 706 } 707 708 err = common.UnmarshalResponse(httpResponse, &response) 709 return response, err 710} 711 712// ChangePublicIpCompartment Moves a public IP into a different compartment within the same tenancy. For information 713// about moving resources between compartments, see 714// Moving Resources to a Different Compartment (https://docs.cloud.oracle.com/iaas/Content/Identity/Tasks/managingcompartments.htm#moveRes). 715// This operation applies only to reserved public IPs. Ephemeral public IPs always belong to the 716// same compartment as their VNIC and move accordingly. 717func (client VirtualNetworkClient) ChangePublicIpCompartment(ctx context.Context, request ChangePublicIpCompartmentRequest) (response ChangePublicIpCompartmentResponse, err error) { 718 var ociResponse common.OCIResponse 719 policy := common.NoRetryPolicy() 720 if request.RetryPolicy() != nil { 721 policy = *request.RetryPolicy() 722 } 723 724 if !(request.OpcRetryToken != nil && *request.OpcRetryToken != "") { 725 request.OpcRetryToken = common.String(common.RetryToken()) 726 } 727 728 ociResponse, err = common.Retry(ctx, request, client.changePublicIpCompartment, policy) 729 if err != nil { 730 if ociResponse != nil { 731 response = ChangePublicIpCompartmentResponse{RawResponse: ociResponse.HTTPResponse()} 732 } 733 return 734 } 735 if convertedResponse, ok := ociResponse.(ChangePublicIpCompartmentResponse); ok { 736 response = convertedResponse 737 } else { 738 err = fmt.Errorf("failed to convert OCIResponse into ChangePublicIpCompartmentResponse") 739 } 740 return 741} 742 743// changePublicIpCompartment implements the OCIOperation interface (enables retrying operations) 744func (client VirtualNetworkClient) changePublicIpCompartment(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 745 httpRequest, err := request.HTTPRequest(http.MethodPost, "/publicIps/{publicIpId}/actions/changeCompartment") 746 if err != nil { 747 return nil, err 748 } 749 750 var response ChangePublicIpCompartmentResponse 751 var httpResponse *http.Response 752 httpResponse, err = client.Call(ctx, &httpRequest) 753 defer common.CloseBodyIfValid(httpResponse) 754 response.RawResponse = httpResponse 755 if err != nil { 756 return response, err 757 } 758 759 err = common.UnmarshalResponse(httpResponse, &response) 760 return response, err 761} 762 763// ChangeRemotePeeringConnectionCompartment Moves a remote peering connection (RPC) into a different compartment within the same tenancy. For information 764// about moving resources between compartments, see 765// Moving Resources to a Different Compartment (https://docs.cloud.oracle.com/iaas/Content/Identity/Tasks/managingcompartments.htm#moveRes). 766func (client VirtualNetworkClient) ChangeRemotePeeringConnectionCompartment(ctx context.Context, request ChangeRemotePeeringConnectionCompartmentRequest) (response ChangeRemotePeeringConnectionCompartmentResponse, err error) { 767 var ociResponse common.OCIResponse 768 policy := common.NoRetryPolicy() 769 if request.RetryPolicy() != nil { 770 policy = *request.RetryPolicy() 771 } 772 773 if !(request.OpcRetryToken != nil && *request.OpcRetryToken != "") { 774 request.OpcRetryToken = common.String(common.RetryToken()) 775 } 776 777 ociResponse, err = common.Retry(ctx, request, client.changeRemotePeeringConnectionCompartment, policy) 778 if err != nil { 779 if ociResponse != nil { 780 response = ChangeRemotePeeringConnectionCompartmentResponse{RawResponse: ociResponse.HTTPResponse()} 781 } 782 return 783 } 784 if convertedResponse, ok := ociResponse.(ChangeRemotePeeringConnectionCompartmentResponse); ok { 785 response = convertedResponse 786 } else { 787 err = fmt.Errorf("failed to convert OCIResponse into ChangeRemotePeeringConnectionCompartmentResponse") 788 } 789 return 790} 791 792// changeRemotePeeringConnectionCompartment implements the OCIOperation interface (enables retrying operations) 793func (client VirtualNetworkClient) changeRemotePeeringConnectionCompartment(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 794 httpRequest, err := request.HTTPRequest(http.MethodPost, "/remotePeeringConnections/{remotePeeringConnectionId}/actions/changeCompartment") 795 if err != nil { 796 return nil, err 797 } 798 799 var response ChangeRemotePeeringConnectionCompartmentResponse 800 var httpResponse *http.Response 801 httpResponse, err = client.Call(ctx, &httpRequest) 802 defer common.CloseBodyIfValid(httpResponse) 803 response.RawResponse = httpResponse 804 if err != nil { 805 return response, err 806 } 807 808 err = common.UnmarshalResponse(httpResponse, &response) 809 return response, err 810} 811 812// ChangeRouteTableCompartment Moves a route table into a different compartment within the same tenancy. For information 813// about moving resources between compartments, see 814// Moving Resources to a Different Compartment (https://docs.cloud.oracle.com/iaas/Content/Identity/Tasks/managingcompartments.htm#moveRes). 815func (client VirtualNetworkClient) ChangeRouteTableCompartment(ctx context.Context, request ChangeRouteTableCompartmentRequest) (response ChangeRouteTableCompartmentResponse, err error) { 816 var ociResponse common.OCIResponse 817 policy := common.NoRetryPolicy() 818 if request.RetryPolicy() != nil { 819 policy = *request.RetryPolicy() 820 } 821 822 if !(request.OpcRetryToken != nil && *request.OpcRetryToken != "") { 823 request.OpcRetryToken = common.String(common.RetryToken()) 824 } 825 826 ociResponse, err = common.Retry(ctx, request, client.changeRouteTableCompartment, policy) 827 if err != nil { 828 if ociResponse != nil { 829 response = ChangeRouteTableCompartmentResponse{RawResponse: ociResponse.HTTPResponse()} 830 } 831 return 832 } 833 if convertedResponse, ok := ociResponse.(ChangeRouteTableCompartmentResponse); ok { 834 response = convertedResponse 835 } else { 836 err = fmt.Errorf("failed to convert OCIResponse into ChangeRouteTableCompartmentResponse") 837 } 838 return 839} 840 841// changeRouteTableCompartment implements the OCIOperation interface (enables retrying operations) 842func (client VirtualNetworkClient) changeRouteTableCompartment(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 843 httpRequest, err := request.HTTPRequest(http.MethodPost, "/routeTables/{rtId}/actions/changeCompartment") 844 if err != nil { 845 return nil, err 846 } 847 848 var response ChangeRouteTableCompartmentResponse 849 var httpResponse *http.Response 850 httpResponse, err = client.Call(ctx, &httpRequest) 851 defer common.CloseBodyIfValid(httpResponse) 852 response.RawResponse = httpResponse 853 if err != nil { 854 return response, err 855 } 856 857 err = common.UnmarshalResponse(httpResponse, &response) 858 return response, err 859} 860 861// ChangeSecurityListCompartment Moves a security list into a different compartment within the same tenancy. For information 862// about moving resources between compartments, see 863// Moving Resources to a Different Compartment (https://docs.cloud.oracle.com/iaas/Content/Identity/Tasks/managingcompartments.htm#moveRes). 864func (client VirtualNetworkClient) ChangeSecurityListCompartment(ctx context.Context, request ChangeSecurityListCompartmentRequest) (response ChangeSecurityListCompartmentResponse, err error) { 865 var ociResponse common.OCIResponse 866 policy := common.NoRetryPolicy() 867 if request.RetryPolicy() != nil { 868 policy = *request.RetryPolicy() 869 } 870 871 if !(request.OpcRetryToken != nil && *request.OpcRetryToken != "") { 872 request.OpcRetryToken = common.String(common.RetryToken()) 873 } 874 875 ociResponse, err = common.Retry(ctx, request, client.changeSecurityListCompartment, policy) 876 if err != nil { 877 if ociResponse != nil { 878 response = ChangeSecurityListCompartmentResponse{RawResponse: ociResponse.HTTPResponse()} 879 } 880 return 881 } 882 if convertedResponse, ok := ociResponse.(ChangeSecurityListCompartmentResponse); ok { 883 response = convertedResponse 884 } else { 885 err = fmt.Errorf("failed to convert OCIResponse into ChangeSecurityListCompartmentResponse") 886 } 887 return 888} 889 890// changeSecurityListCompartment implements the OCIOperation interface (enables retrying operations) 891func (client VirtualNetworkClient) changeSecurityListCompartment(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 892 httpRequest, err := request.HTTPRequest(http.MethodPost, "/securityLists/{securityListId}/actions/changeCompartment") 893 if err != nil { 894 return nil, err 895 } 896 897 var response ChangeSecurityListCompartmentResponse 898 var httpResponse *http.Response 899 httpResponse, err = client.Call(ctx, &httpRequest) 900 defer common.CloseBodyIfValid(httpResponse) 901 response.RawResponse = httpResponse 902 if err != nil { 903 return response, err 904 } 905 906 err = common.UnmarshalResponse(httpResponse, &response) 907 return response, err 908} 909 910// ChangeServiceGatewayCompartment Moves a service gateway into a different compartment within the same tenancy. For information 911// about moving resources between compartments, see 912// Moving Resources to a Different Compartment (https://docs.cloud.oracle.com/iaas/Content/Identity/Tasks/managingcompartments.htm#moveRes). 913func (client VirtualNetworkClient) ChangeServiceGatewayCompartment(ctx context.Context, request ChangeServiceGatewayCompartmentRequest) (response ChangeServiceGatewayCompartmentResponse, err error) { 914 var ociResponse common.OCIResponse 915 policy := common.NoRetryPolicy() 916 if request.RetryPolicy() != nil { 917 policy = *request.RetryPolicy() 918 } 919 920 if !(request.OpcRetryToken != nil && *request.OpcRetryToken != "") { 921 request.OpcRetryToken = common.String(common.RetryToken()) 922 } 923 924 ociResponse, err = common.Retry(ctx, request, client.changeServiceGatewayCompartment, policy) 925 if err != nil { 926 if ociResponse != nil { 927 response = ChangeServiceGatewayCompartmentResponse{RawResponse: ociResponse.HTTPResponse()} 928 } 929 return 930 } 931 if convertedResponse, ok := ociResponse.(ChangeServiceGatewayCompartmentResponse); ok { 932 response = convertedResponse 933 } else { 934 err = fmt.Errorf("failed to convert OCIResponse into ChangeServiceGatewayCompartmentResponse") 935 } 936 return 937} 938 939// changeServiceGatewayCompartment implements the OCIOperation interface (enables retrying operations) 940func (client VirtualNetworkClient) changeServiceGatewayCompartment(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 941 httpRequest, err := request.HTTPRequest(http.MethodPost, "/serviceGateways/{serviceGatewayId}/actions/changeCompartment") 942 if err != nil { 943 return nil, err 944 } 945 946 var response ChangeServiceGatewayCompartmentResponse 947 var httpResponse *http.Response 948 httpResponse, err = client.Call(ctx, &httpRequest) 949 defer common.CloseBodyIfValid(httpResponse) 950 response.RawResponse = httpResponse 951 if err != nil { 952 return response, err 953 } 954 955 err = common.UnmarshalResponse(httpResponse, &response) 956 return response, err 957} 958 959// ChangeSubnetCompartment Moves a subnet into a different compartment within the same tenancy. For information 960// about moving resources between compartments, see 961// Moving Resources to a Different Compartment (https://docs.cloud.oracle.com/iaas/Content/Identity/Tasks/managingcompartments.htm#moveRes). 962func (client VirtualNetworkClient) ChangeSubnetCompartment(ctx context.Context, request ChangeSubnetCompartmentRequest) (response ChangeSubnetCompartmentResponse, err error) { 963 var ociResponse common.OCIResponse 964 policy := common.NoRetryPolicy() 965 if request.RetryPolicy() != nil { 966 policy = *request.RetryPolicy() 967 } 968 969 if !(request.OpcRetryToken != nil && *request.OpcRetryToken != "") { 970 request.OpcRetryToken = common.String(common.RetryToken()) 971 } 972 973 ociResponse, err = common.Retry(ctx, request, client.changeSubnetCompartment, policy) 974 if err != nil { 975 if ociResponse != nil { 976 response = ChangeSubnetCompartmentResponse{RawResponse: ociResponse.HTTPResponse()} 977 } 978 return 979 } 980 if convertedResponse, ok := ociResponse.(ChangeSubnetCompartmentResponse); ok { 981 response = convertedResponse 982 } else { 983 err = fmt.Errorf("failed to convert OCIResponse into ChangeSubnetCompartmentResponse") 984 } 985 return 986} 987 988// changeSubnetCompartment implements the OCIOperation interface (enables retrying operations) 989func (client VirtualNetworkClient) changeSubnetCompartment(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 990 httpRequest, err := request.HTTPRequest(http.MethodPost, "/subnets/{subnetId}/actions/changeCompartment") 991 if err != nil { 992 return nil, err 993 } 994 995 var response ChangeSubnetCompartmentResponse 996 var httpResponse *http.Response 997 httpResponse, err = client.Call(ctx, &httpRequest) 998 defer common.CloseBodyIfValid(httpResponse) 999 response.RawResponse = httpResponse 1000 if err != nil { 1001 return response, err 1002 } 1003 1004 err = common.UnmarshalResponse(httpResponse, &response) 1005 return response, err 1006} 1007 1008// ChangeVcnCompartment Moves a VCN into a different compartment within the same tenancy. For information 1009// about moving resources between compartments, see 1010// Moving Resources to a Different Compartment (https://docs.cloud.oracle.com/iaas/Content/Identity/Tasks/managingcompartments.htm#moveRes). 1011func (client VirtualNetworkClient) ChangeVcnCompartment(ctx context.Context, request ChangeVcnCompartmentRequest) (response ChangeVcnCompartmentResponse, err error) { 1012 var ociResponse common.OCIResponse 1013 policy := common.NoRetryPolicy() 1014 if request.RetryPolicy() != nil { 1015 policy = *request.RetryPolicy() 1016 } 1017 1018 if !(request.OpcRetryToken != nil && *request.OpcRetryToken != "") { 1019 request.OpcRetryToken = common.String(common.RetryToken()) 1020 } 1021 1022 ociResponse, err = common.Retry(ctx, request, client.changeVcnCompartment, policy) 1023 if err != nil { 1024 if ociResponse != nil { 1025 response = ChangeVcnCompartmentResponse{RawResponse: ociResponse.HTTPResponse()} 1026 } 1027 return 1028 } 1029 if convertedResponse, ok := ociResponse.(ChangeVcnCompartmentResponse); ok { 1030 response = convertedResponse 1031 } else { 1032 err = fmt.Errorf("failed to convert OCIResponse into ChangeVcnCompartmentResponse") 1033 } 1034 return 1035} 1036 1037// changeVcnCompartment implements the OCIOperation interface (enables retrying operations) 1038func (client VirtualNetworkClient) changeVcnCompartment(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 1039 httpRequest, err := request.HTTPRequest(http.MethodPost, "/vcns/{vcnId}/actions/changeCompartment") 1040 if err != nil { 1041 return nil, err 1042 } 1043 1044 var response ChangeVcnCompartmentResponse 1045 var httpResponse *http.Response 1046 httpResponse, err = client.Call(ctx, &httpRequest) 1047 defer common.CloseBodyIfValid(httpResponse) 1048 response.RawResponse = httpResponse 1049 if err != nil { 1050 return response, err 1051 } 1052 1053 err = common.UnmarshalResponse(httpResponse, &response) 1054 return response, err 1055} 1056 1057// ChangeVirtualCircuitCompartment Moves a virtual circuit into a different compartment within the same tenancy. For information 1058// about moving resources between compartments, see 1059// Moving Resources to a Different Compartment (https://docs.cloud.oracle.com/iaas/Content/Identity/Tasks/managingcompartments.htm#moveRes). 1060func (client VirtualNetworkClient) ChangeVirtualCircuitCompartment(ctx context.Context, request ChangeVirtualCircuitCompartmentRequest) (response ChangeVirtualCircuitCompartmentResponse, err error) { 1061 var ociResponse common.OCIResponse 1062 policy := common.NoRetryPolicy() 1063 if request.RetryPolicy() != nil { 1064 policy = *request.RetryPolicy() 1065 } 1066 1067 if !(request.OpcRetryToken != nil && *request.OpcRetryToken != "") { 1068 request.OpcRetryToken = common.String(common.RetryToken()) 1069 } 1070 1071 ociResponse, err = common.Retry(ctx, request, client.changeVirtualCircuitCompartment, policy) 1072 if err != nil { 1073 if ociResponse != nil { 1074 response = ChangeVirtualCircuitCompartmentResponse{RawResponse: ociResponse.HTTPResponse()} 1075 } 1076 return 1077 } 1078 if convertedResponse, ok := ociResponse.(ChangeVirtualCircuitCompartmentResponse); ok { 1079 response = convertedResponse 1080 } else { 1081 err = fmt.Errorf("failed to convert OCIResponse into ChangeVirtualCircuitCompartmentResponse") 1082 } 1083 return 1084} 1085 1086// changeVirtualCircuitCompartment implements the OCIOperation interface (enables retrying operations) 1087func (client VirtualNetworkClient) changeVirtualCircuitCompartment(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 1088 httpRequest, err := request.HTTPRequest(http.MethodPost, "/virtualCircuits/{virtualCircuitId}/actions/changeCompartment") 1089 if err != nil { 1090 return nil, err 1091 } 1092 1093 var response ChangeVirtualCircuitCompartmentResponse 1094 var httpResponse *http.Response 1095 httpResponse, err = client.Call(ctx, &httpRequest) 1096 defer common.CloseBodyIfValid(httpResponse) 1097 response.RawResponse = httpResponse 1098 if err != nil { 1099 return response, err 1100 } 1101 1102 err = common.UnmarshalResponse(httpResponse, &response) 1103 return response, err 1104} 1105 1106// ConnectLocalPeeringGateways Connects this local peering gateway (LPG) to another one in the same region. 1107// This operation must be called by the VCN administrator who is designated as 1108// the *requestor* in the peering relationship. The *acceptor* must implement 1109// an Identity and Access Management (IAM) policy that gives the requestor permission 1110// to connect to LPGs in the acceptor's compartment. Without that permission, this 1111// operation will fail. For more information, see 1112// VCN Peering (https://docs.cloud.oracle.com/Content/Network/Tasks/VCNpeering.htm). 1113func (client VirtualNetworkClient) ConnectLocalPeeringGateways(ctx context.Context, request ConnectLocalPeeringGatewaysRequest) (response ConnectLocalPeeringGatewaysResponse, err error) { 1114 var ociResponse common.OCIResponse 1115 policy := common.NoRetryPolicy() 1116 if request.RetryPolicy() != nil { 1117 policy = *request.RetryPolicy() 1118 } 1119 ociResponse, err = common.Retry(ctx, request, client.connectLocalPeeringGateways, policy) 1120 if err != nil { 1121 if ociResponse != nil { 1122 response = ConnectLocalPeeringGatewaysResponse{RawResponse: ociResponse.HTTPResponse()} 1123 } 1124 return 1125 } 1126 if convertedResponse, ok := ociResponse.(ConnectLocalPeeringGatewaysResponse); ok { 1127 response = convertedResponse 1128 } else { 1129 err = fmt.Errorf("failed to convert OCIResponse into ConnectLocalPeeringGatewaysResponse") 1130 } 1131 return 1132} 1133 1134// connectLocalPeeringGateways implements the OCIOperation interface (enables retrying operations) 1135func (client VirtualNetworkClient) connectLocalPeeringGateways(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 1136 httpRequest, err := request.HTTPRequest(http.MethodPost, "/localPeeringGateways/{localPeeringGatewayId}/actions/connect") 1137 if err != nil { 1138 return nil, err 1139 } 1140 1141 var response ConnectLocalPeeringGatewaysResponse 1142 var httpResponse *http.Response 1143 httpResponse, err = client.Call(ctx, &httpRequest) 1144 defer common.CloseBodyIfValid(httpResponse) 1145 response.RawResponse = httpResponse 1146 if err != nil { 1147 return response, err 1148 } 1149 1150 err = common.UnmarshalResponse(httpResponse, &response) 1151 return response, err 1152} 1153 1154// ConnectRemotePeeringConnections Connects this RPC to another one in a different region. 1155// This operation must be called by the VCN administrator who is designated as 1156// the *requestor* in the peering relationship. The *acceptor* must implement 1157// an Identity and Access Management (IAM) policy that gives the requestor permission 1158// to connect to RPCs in the acceptor's compartment. Without that permission, this 1159// operation will fail. For more information, see 1160// VCN Peering (https://docs.cloud.oracle.com/Content/Network/Tasks/VCNpeering.htm). 1161func (client VirtualNetworkClient) ConnectRemotePeeringConnections(ctx context.Context, request ConnectRemotePeeringConnectionsRequest) (response ConnectRemotePeeringConnectionsResponse, err error) { 1162 var ociResponse common.OCIResponse 1163 policy := common.NoRetryPolicy() 1164 if request.RetryPolicy() != nil { 1165 policy = *request.RetryPolicy() 1166 } 1167 ociResponse, err = common.Retry(ctx, request, client.connectRemotePeeringConnections, policy) 1168 if err != nil { 1169 if ociResponse != nil { 1170 response = ConnectRemotePeeringConnectionsResponse{RawResponse: ociResponse.HTTPResponse()} 1171 } 1172 return 1173 } 1174 if convertedResponse, ok := ociResponse.(ConnectRemotePeeringConnectionsResponse); ok { 1175 response = convertedResponse 1176 } else { 1177 err = fmt.Errorf("failed to convert OCIResponse into ConnectRemotePeeringConnectionsResponse") 1178 } 1179 return 1180} 1181 1182// connectRemotePeeringConnections implements the OCIOperation interface (enables retrying operations) 1183func (client VirtualNetworkClient) connectRemotePeeringConnections(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 1184 httpRequest, err := request.HTTPRequest(http.MethodPost, "/remotePeeringConnections/{remotePeeringConnectionId}/actions/connect") 1185 if err != nil { 1186 return nil, err 1187 } 1188 1189 var response ConnectRemotePeeringConnectionsResponse 1190 var httpResponse *http.Response 1191 httpResponse, err = client.Call(ctx, &httpRequest) 1192 defer common.CloseBodyIfValid(httpResponse) 1193 response.RawResponse = httpResponse 1194 if err != nil { 1195 return response, err 1196 } 1197 1198 err = common.UnmarshalResponse(httpResponse, &response) 1199 return response, err 1200} 1201 1202// CreateCpe Creates a new virtual customer-premises equipment (CPE) object in the specified compartment. For 1203// more information, see IPSec VPNs (https://docs.cloud.oracle.com/Content/Network/Tasks/managingIPsec.htm). 1204// For the purposes of access control, you must provide the OCID of the compartment where you want 1205// the CPE to reside. Notice that the CPE doesn't have to be in the same compartment as the IPSec 1206// connection or other Networking Service components. If you're not sure which compartment to 1207// use, put the CPE in the same compartment as the DRG. For more information about 1208// compartments and access control, see Overview of the IAM Service (https://docs.cloud.oracle.com/Content/Identity/Concepts/overview.htm). 1209// For information about OCIDs, see Resource Identifiers (https://docs.cloud.oracle.com/Content/General/Concepts/identifiers.htm). 1210// You must provide the public IP address of your on-premises router. See 1211// Configuring Your On-Premises Router for an IPSec VPN (https://docs.cloud.oracle.com/Content/Network/Tasks/configuringCPE.htm). 1212// You may optionally specify a *display name* for the CPE, otherwise a default is provided. It does not have to 1213// be unique, and you can change it. Avoid entering confidential information. 1214func (client VirtualNetworkClient) CreateCpe(ctx context.Context, request CreateCpeRequest) (response CreateCpeResponse, err error) { 1215 var ociResponse common.OCIResponse 1216 policy := common.NoRetryPolicy() 1217 if request.RetryPolicy() != nil { 1218 policy = *request.RetryPolicy() 1219 } 1220 1221 if !(request.OpcRetryToken != nil && *request.OpcRetryToken != "") { 1222 request.OpcRetryToken = common.String(common.RetryToken()) 1223 } 1224 1225 ociResponse, err = common.Retry(ctx, request, client.createCpe, policy) 1226 if err != nil { 1227 if ociResponse != nil { 1228 response = CreateCpeResponse{RawResponse: ociResponse.HTTPResponse()} 1229 } 1230 return 1231 } 1232 if convertedResponse, ok := ociResponse.(CreateCpeResponse); ok { 1233 response = convertedResponse 1234 } else { 1235 err = fmt.Errorf("failed to convert OCIResponse into CreateCpeResponse") 1236 } 1237 return 1238} 1239 1240// createCpe implements the OCIOperation interface (enables retrying operations) 1241func (client VirtualNetworkClient) createCpe(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 1242 httpRequest, err := request.HTTPRequest(http.MethodPost, "/cpes") 1243 if err != nil { 1244 return nil, err 1245 } 1246 1247 var response CreateCpeResponse 1248 var httpResponse *http.Response 1249 httpResponse, err = client.Call(ctx, &httpRequest) 1250 defer common.CloseBodyIfValid(httpResponse) 1251 response.RawResponse = httpResponse 1252 if err != nil { 1253 return response, err 1254 } 1255 1256 err = common.UnmarshalResponse(httpResponse, &response) 1257 return response, err 1258} 1259 1260// CreateCrossConnect Creates a new cross-connect. Oracle recommends you create each cross-connect in a 1261// CrossConnectGroup so you can use link aggregation 1262// with the connection. 1263// After creating the `CrossConnect` object, you need to go the FastConnect location 1264// and request to have the physical cable installed. For more information, see 1265// FastConnect Overview (https://docs.cloud.oracle.com/Content/Network/Concepts/fastconnect.htm). 1266// For the purposes of access control, you must provide the OCID of the 1267// compartment where you want the cross-connect to reside. If you're 1268// not sure which compartment to use, put the cross-connect in the 1269// same compartment with your VCN. For more information about 1270// compartments and access control, see 1271// Overview of the IAM Service (https://docs.cloud.oracle.com/Content/Identity/Concepts/overview.htm). 1272// For information about OCIDs, see 1273// Resource Identifiers (https://docs.cloud.oracle.com/Content/General/Concepts/identifiers.htm). 1274// You may optionally specify a *display name* for the cross-connect. 1275// It does not have to be unique, and you can change it. Avoid entering confidential information. 1276func (client VirtualNetworkClient) CreateCrossConnect(ctx context.Context, request CreateCrossConnectRequest) (response CreateCrossConnectResponse, err error) { 1277 var ociResponse common.OCIResponse 1278 policy := common.NoRetryPolicy() 1279 if request.RetryPolicy() != nil { 1280 policy = *request.RetryPolicy() 1281 } 1282 1283 if !(request.OpcRetryToken != nil && *request.OpcRetryToken != "") { 1284 request.OpcRetryToken = common.String(common.RetryToken()) 1285 } 1286 1287 ociResponse, err = common.Retry(ctx, request, client.createCrossConnect, policy) 1288 if err != nil { 1289 if ociResponse != nil { 1290 response = CreateCrossConnectResponse{RawResponse: ociResponse.HTTPResponse()} 1291 } 1292 return 1293 } 1294 if convertedResponse, ok := ociResponse.(CreateCrossConnectResponse); ok { 1295 response = convertedResponse 1296 } else { 1297 err = fmt.Errorf("failed to convert OCIResponse into CreateCrossConnectResponse") 1298 } 1299 return 1300} 1301 1302// createCrossConnect implements the OCIOperation interface (enables retrying operations) 1303func (client VirtualNetworkClient) createCrossConnect(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 1304 httpRequest, err := request.HTTPRequest(http.MethodPost, "/crossConnects") 1305 if err != nil { 1306 return nil, err 1307 } 1308 1309 var response CreateCrossConnectResponse 1310 var httpResponse *http.Response 1311 httpResponse, err = client.Call(ctx, &httpRequest) 1312 defer common.CloseBodyIfValid(httpResponse) 1313 response.RawResponse = httpResponse 1314 if err != nil { 1315 return response, err 1316 } 1317 1318 err = common.UnmarshalResponse(httpResponse, &response) 1319 return response, err 1320} 1321 1322// CreateCrossConnectGroup Creates a new cross-connect group to use with Oracle Cloud Infrastructure 1323// FastConnect. For more information, see 1324// FastConnect Overview (https://docs.cloud.oracle.com/Content/Network/Concepts/fastconnect.htm). 1325// For the purposes of access control, you must provide the OCID of the 1326// compartment where you want the cross-connect group to reside. If you're 1327// not sure which compartment to use, put the cross-connect group in the 1328// same compartment with your VCN. For more information about 1329// compartments and access control, see 1330// Overview of the IAM Service (https://docs.cloud.oracle.com/Content/Identity/Concepts/overview.htm). 1331// For information about OCIDs, see 1332// Resource Identifiers (https://docs.cloud.oracle.com/Content/General/Concepts/identifiers.htm). 1333// You may optionally specify a *display name* for the cross-connect group. 1334// It does not have to be unique, and you can change it. Avoid entering confidential information. 1335func (client VirtualNetworkClient) CreateCrossConnectGroup(ctx context.Context, request CreateCrossConnectGroupRequest) (response CreateCrossConnectGroupResponse, err error) { 1336 var ociResponse common.OCIResponse 1337 policy := common.NoRetryPolicy() 1338 if request.RetryPolicy() != nil { 1339 policy = *request.RetryPolicy() 1340 } 1341 1342 if !(request.OpcRetryToken != nil && *request.OpcRetryToken != "") { 1343 request.OpcRetryToken = common.String(common.RetryToken()) 1344 } 1345 1346 ociResponse, err = common.Retry(ctx, request, client.createCrossConnectGroup, policy) 1347 if err != nil { 1348 if ociResponse != nil { 1349 response = CreateCrossConnectGroupResponse{RawResponse: ociResponse.HTTPResponse()} 1350 } 1351 return 1352 } 1353 if convertedResponse, ok := ociResponse.(CreateCrossConnectGroupResponse); ok { 1354 response = convertedResponse 1355 } else { 1356 err = fmt.Errorf("failed to convert OCIResponse into CreateCrossConnectGroupResponse") 1357 } 1358 return 1359} 1360 1361// createCrossConnectGroup implements the OCIOperation interface (enables retrying operations) 1362func (client VirtualNetworkClient) createCrossConnectGroup(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 1363 httpRequest, err := request.HTTPRequest(http.MethodPost, "/crossConnectGroups") 1364 if err != nil { 1365 return nil, err 1366 } 1367 1368 var response CreateCrossConnectGroupResponse 1369 var httpResponse *http.Response 1370 httpResponse, err = client.Call(ctx, &httpRequest) 1371 defer common.CloseBodyIfValid(httpResponse) 1372 response.RawResponse = httpResponse 1373 if err != nil { 1374 return response, err 1375 } 1376 1377 err = common.UnmarshalResponse(httpResponse, &response) 1378 return response, err 1379} 1380 1381// CreateDhcpOptions Creates a new set of DHCP options for the specified VCN. For more information, see 1382// DhcpOptions. 1383// For the purposes of access control, you must provide the OCID of the compartment where you want the set of 1384// DHCP options to reside. Notice that the set of options doesn't have to be in the same compartment as the VCN, 1385// subnets, or other Networking Service components. If you're not sure which compartment to use, put the set 1386// of DHCP options in the same compartment as the VCN. For more information about compartments and access control, see 1387// Overview of the IAM Service (https://docs.cloud.oracle.com/Content/Identity/Concepts/overview.htm). For information about OCIDs, see 1388// Resource Identifiers (https://docs.cloud.oracle.com/Content/General/Concepts/identifiers.htm). 1389// You may optionally specify a *display name* for the set of DHCP options, otherwise a default is provided. 1390// It does not have to be unique, and you can change it. Avoid entering confidential information. 1391func (client VirtualNetworkClient) CreateDhcpOptions(ctx context.Context, request CreateDhcpOptionsRequest) (response CreateDhcpOptionsResponse, err error) { 1392 var ociResponse common.OCIResponse 1393 policy := common.NoRetryPolicy() 1394 if request.RetryPolicy() != nil { 1395 policy = *request.RetryPolicy() 1396 } 1397 1398 if !(request.OpcRetryToken != nil && *request.OpcRetryToken != "") { 1399 request.OpcRetryToken = common.String(common.RetryToken()) 1400 } 1401 1402 ociResponse, err = common.Retry(ctx, request, client.createDhcpOptions, policy) 1403 if err != nil { 1404 if ociResponse != nil { 1405 response = CreateDhcpOptionsResponse{RawResponse: ociResponse.HTTPResponse()} 1406 } 1407 return 1408 } 1409 if convertedResponse, ok := ociResponse.(CreateDhcpOptionsResponse); ok { 1410 response = convertedResponse 1411 } else { 1412 err = fmt.Errorf("failed to convert OCIResponse into CreateDhcpOptionsResponse") 1413 } 1414 return 1415} 1416 1417// createDhcpOptions implements the OCIOperation interface (enables retrying operations) 1418func (client VirtualNetworkClient) createDhcpOptions(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 1419 httpRequest, err := request.HTTPRequest(http.MethodPost, "/dhcps") 1420 if err != nil { 1421 return nil, err 1422 } 1423 1424 var response CreateDhcpOptionsResponse 1425 var httpResponse *http.Response 1426 httpResponse, err = client.Call(ctx, &httpRequest) 1427 defer common.CloseBodyIfValid(httpResponse) 1428 response.RawResponse = httpResponse 1429 if err != nil { 1430 return response, err 1431 } 1432 1433 err = common.UnmarshalResponse(httpResponse, &response) 1434 return response, err 1435} 1436 1437// CreateDrg Creates a new dynamic routing gateway (DRG) in the specified compartment. For more information, 1438// see Dynamic Routing Gateways (DRGs) (https://docs.cloud.oracle.com/Content/Network/Tasks/managingDRGs.htm). 1439// For the purposes of access control, you must provide the OCID of the compartment where you want 1440// the DRG to reside. Notice that the DRG doesn't have to be in the same compartment as the VCN, 1441// the DRG attachment, or other Networking Service components. If you're not sure which compartment 1442// to use, put the DRG in the same compartment as the VCN. For more information about compartments 1443// and access control, see Overview of the IAM Service (https://docs.cloud.oracle.com/Content/Identity/Concepts/overview.htm). 1444// For information about OCIDs, see Resource Identifiers (https://docs.cloud.oracle.com/Content/General/Concepts/identifiers.htm). 1445// You may optionally specify a *display name* for the DRG, otherwise a default is provided. 1446// It does not have to be unique, and you can change it. Avoid entering confidential information. 1447func (client VirtualNetworkClient) CreateDrg(ctx context.Context, request CreateDrgRequest) (response CreateDrgResponse, err error) { 1448 var ociResponse common.OCIResponse 1449 policy := common.NoRetryPolicy() 1450 if request.RetryPolicy() != nil { 1451 policy = *request.RetryPolicy() 1452 } 1453 1454 if !(request.OpcRetryToken != nil && *request.OpcRetryToken != "") { 1455 request.OpcRetryToken = common.String(common.RetryToken()) 1456 } 1457 1458 ociResponse, err = common.Retry(ctx, request, client.createDrg, policy) 1459 if err != nil { 1460 if ociResponse != nil { 1461 response = CreateDrgResponse{RawResponse: ociResponse.HTTPResponse()} 1462 } 1463 return 1464 } 1465 if convertedResponse, ok := ociResponse.(CreateDrgResponse); ok { 1466 response = convertedResponse 1467 } else { 1468 err = fmt.Errorf("failed to convert OCIResponse into CreateDrgResponse") 1469 } 1470 return 1471} 1472 1473// createDrg implements the OCIOperation interface (enables retrying operations) 1474func (client VirtualNetworkClient) createDrg(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 1475 httpRequest, err := request.HTTPRequest(http.MethodPost, "/drgs") 1476 if err != nil { 1477 return nil, err 1478 } 1479 1480 var response CreateDrgResponse 1481 var httpResponse *http.Response 1482 httpResponse, err = client.Call(ctx, &httpRequest) 1483 defer common.CloseBodyIfValid(httpResponse) 1484 response.RawResponse = httpResponse 1485 if err != nil { 1486 return response, err 1487 } 1488 1489 err = common.UnmarshalResponse(httpResponse, &response) 1490 return response, err 1491} 1492 1493// CreateDrgAttachment Attaches the specified DRG to the specified VCN. A VCN can be attached to only one DRG at a time, 1494// and vice versa. The response includes a `DrgAttachment` object with its own OCID. For more 1495// information about DRGs, see 1496// Dynamic Routing Gateways (DRGs) (https://docs.cloud.oracle.com/Content/Network/Tasks/managingDRGs.htm). 1497// You may optionally specify a *display name* for the attachment, otherwise a default is provided. 1498// It does not have to be unique, and you can change it. Avoid entering confidential information. 1499// For the purposes of access control, the DRG attachment is automatically placed into the same compartment 1500// as the VCN. For more information about compartments and access control, see 1501// Overview of the IAM Service (https://docs.cloud.oracle.com/Content/Identity/Concepts/overview.htm). 1502func (client VirtualNetworkClient) CreateDrgAttachment(ctx context.Context, request CreateDrgAttachmentRequest) (response CreateDrgAttachmentResponse, err error) { 1503 var ociResponse common.OCIResponse 1504 policy := common.NoRetryPolicy() 1505 if request.RetryPolicy() != nil { 1506 policy = *request.RetryPolicy() 1507 } 1508 1509 if !(request.OpcRetryToken != nil && *request.OpcRetryToken != "") { 1510 request.OpcRetryToken = common.String(common.RetryToken()) 1511 } 1512 1513 ociResponse, err = common.Retry(ctx, request, client.createDrgAttachment, policy) 1514 if err != nil { 1515 if ociResponse != nil { 1516 response = CreateDrgAttachmentResponse{RawResponse: ociResponse.HTTPResponse()} 1517 } 1518 return 1519 } 1520 if convertedResponse, ok := ociResponse.(CreateDrgAttachmentResponse); ok { 1521 response = convertedResponse 1522 } else { 1523 err = fmt.Errorf("failed to convert OCIResponse into CreateDrgAttachmentResponse") 1524 } 1525 return 1526} 1527 1528// createDrgAttachment implements the OCIOperation interface (enables retrying operations) 1529func (client VirtualNetworkClient) createDrgAttachment(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 1530 httpRequest, err := request.HTTPRequest(http.MethodPost, "/drgAttachments") 1531 if err != nil { 1532 return nil, err 1533 } 1534 1535 var response CreateDrgAttachmentResponse 1536 var httpResponse *http.Response 1537 httpResponse, err = client.Call(ctx, &httpRequest) 1538 defer common.CloseBodyIfValid(httpResponse) 1539 response.RawResponse = httpResponse 1540 if err != nil { 1541 return response, err 1542 } 1543 1544 err = common.UnmarshalResponse(httpResponse, &response) 1545 return response, err 1546} 1547 1548// CreateIPSecConnection Creates a new IPSec connection between the specified DRG and CPE. For more information, see 1549// IPSec VPNs (https://docs.cloud.oracle.com/Content/Network/Tasks/managingIPsec.htm). 1550// If you configure at least one tunnel to use static routing, then in the request you must provide 1551// at least one valid static route (you're allowed a maximum of 10). For example: 10.0.0.0/16. 1552// If you configure both tunnels to use BGP dynamic routing, you can provide an empty list for 1553// the static routes. For more information, see the important note in 1554// IPSecConnection. 1555// For the purposes of access control, you must provide the OCID of the compartment where you want the 1556// IPSec connection to reside. Notice that the IPSec connection doesn't have to be in the same compartment 1557// as the DRG, CPE, or other Networking Service components. If you're not sure which compartment to 1558// use, put the IPSec connection in the same compartment as the DRG. For more information about 1559// compartments and access control, see 1560// Overview of the IAM Service (https://docs.cloud.oracle.com/Content/Identity/Concepts/overview.htm). 1561// For information about OCIDs, see Resource Identifiers (https://docs.cloud.oracle.com/Content/General/Concepts/identifiers.htm). 1562// You may optionally specify a *display name* for the IPSec connection, otherwise a default is provided. 1563// It does not have to be unique, and you can change it. Avoid entering confidential information. 1564// After creating the IPSec connection, you need to configure your on-premises router 1565// with tunnel-specific information. For tunnel status and the required configuration information, see: 1566// * IPSecConnectionTunnel 1567// * IPSecConnectionTunnelSharedSecret 1568// For each tunnel, you need the IP address of Oracle's VPN headend and the shared secret 1569// (that is, the pre-shared key). For more information, see 1570// Configuring Your On-Premises Router for an IPSec VPN (https://docs.cloud.oracle.com/Content/Network/Tasks/configuringCPE.htm). 1571func (client VirtualNetworkClient) CreateIPSecConnection(ctx context.Context, request CreateIPSecConnectionRequest) (response CreateIPSecConnectionResponse, err error) { 1572 var ociResponse common.OCIResponse 1573 policy := common.NoRetryPolicy() 1574 if request.RetryPolicy() != nil { 1575 policy = *request.RetryPolicy() 1576 } 1577 1578 if !(request.OpcRetryToken != nil && *request.OpcRetryToken != "") { 1579 request.OpcRetryToken = common.String(common.RetryToken()) 1580 } 1581 1582 ociResponse, err = common.Retry(ctx, request, client.createIPSecConnection, policy) 1583 if err != nil { 1584 if ociResponse != nil { 1585 response = CreateIPSecConnectionResponse{RawResponse: ociResponse.HTTPResponse()} 1586 } 1587 return 1588 } 1589 if convertedResponse, ok := ociResponse.(CreateIPSecConnectionResponse); ok { 1590 response = convertedResponse 1591 } else { 1592 err = fmt.Errorf("failed to convert OCIResponse into CreateIPSecConnectionResponse") 1593 } 1594 return 1595} 1596 1597// createIPSecConnection implements the OCIOperation interface (enables retrying operations) 1598func (client VirtualNetworkClient) createIPSecConnection(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 1599 httpRequest, err := request.HTTPRequest(http.MethodPost, "/ipsecConnections") 1600 if err != nil { 1601 return nil, err 1602 } 1603 1604 var response CreateIPSecConnectionResponse 1605 var httpResponse *http.Response 1606 httpResponse, err = client.Call(ctx, &httpRequest) 1607 defer common.CloseBodyIfValid(httpResponse) 1608 response.RawResponse = httpResponse 1609 if err != nil { 1610 return response, err 1611 } 1612 1613 err = common.UnmarshalResponse(httpResponse, &response) 1614 return response, err 1615} 1616 1617// CreateInternetGateway Creates a new internet gateway for the specified VCN. For more information, see 1618// Access to the Internet (https://docs.cloud.oracle.com/Content/Network/Tasks/managingIGs.htm). 1619// For the purposes of access control, you must provide the OCID of the compartment where you want the Internet 1620// Gateway to reside. Notice that the internet gateway doesn't have to be in the same compartment as the VCN or 1621// other Networking Service components. If you're not sure which compartment to use, put the Internet 1622// Gateway in the same compartment with the VCN. For more information about compartments and access control, see 1623// Overview of the IAM Service (https://docs.cloud.oracle.com/Content/Identity/Concepts/overview.htm). For information about OCIDs, see 1624// Resource Identifiers (https://docs.cloud.oracle.com/Content/General/Concepts/identifiers.htm). 1625// You may optionally specify a *display name* for the internet gateway, otherwise a default is provided. It 1626// does not have to be unique, and you can change it. Avoid entering confidential information. 1627// For traffic to flow between a subnet and an internet gateway, you must create a route rule accordingly in 1628// the subnet's route table (for example, 0.0.0.0/0 > internet gateway). See 1629// UpdateRouteTable. 1630// You must specify whether the internet gateway is enabled when you create it. If it's disabled, that means no 1631// traffic will flow to/from the internet even if there's a route rule that enables that traffic. You can later 1632// use UpdateInternetGateway to easily disable/enable 1633// the gateway without changing the route rule. 1634func (client VirtualNetworkClient) CreateInternetGateway(ctx context.Context, request CreateInternetGatewayRequest) (response CreateInternetGatewayResponse, err error) { 1635 var ociResponse common.OCIResponse 1636 policy := common.NoRetryPolicy() 1637 if request.RetryPolicy() != nil { 1638 policy = *request.RetryPolicy() 1639 } 1640 1641 if !(request.OpcRetryToken != nil && *request.OpcRetryToken != "") { 1642 request.OpcRetryToken = common.String(common.RetryToken()) 1643 } 1644 1645 ociResponse, err = common.Retry(ctx, request, client.createInternetGateway, policy) 1646 if err != nil { 1647 if ociResponse != nil { 1648 response = CreateInternetGatewayResponse{RawResponse: ociResponse.HTTPResponse()} 1649 } 1650 return 1651 } 1652 if convertedResponse, ok := ociResponse.(CreateInternetGatewayResponse); ok { 1653 response = convertedResponse 1654 } else { 1655 err = fmt.Errorf("failed to convert OCIResponse into CreateInternetGatewayResponse") 1656 } 1657 return 1658} 1659 1660// createInternetGateway implements the OCIOperation interface (enables retrying operations) 1661func (client VirtualNetworkClient) createInternetGateway(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 1662 httpRequest, err := request.HTTPRequest(http.MethodPost, "/internetGateways") 1663 if err != nil { 1664 return nil, err 1665 } 1666 1667 var response CreateInternetGatewayResponse 1668 var httpResponse *http.Response 1669 httpResponse, err = client.Call(ctx, &httpRequest) 1670 defer common.CloseBodyIfValid(httpResponse) 1671 response.RawResponse = httpResponse 1672 if err != nil { 1673 return response, err 1674 } 1675 1676 err = common.UnmarshalResponse(httpResponse, &response) 1677 return response, err 1678} 1679 1680// CreateIpv6 Creates an IPv6 for the specified VNIC. 1681func (client VirtualNetworkClient) CreateIpv6(ctx context.Context, request CreateIpv6Request) (response CreateIpv6Response, err error) { 1682 var ociResponse common.OCIResponse 1683 policy := common.NoRetryPolicy() 1684 if request.RetryPolicy() != nil { 1685 policy = *request.RetryPolicy() 1686 } 1687 1688 if !(request.OpcRetryToken != nil && *request.OpcRetryToken != "") { 1689 request.OpcRetryToken = common.String(common.RetryToken()) 1690 } 1691 1692 ociResponse, err = common.Retry(ctx, request, client.createIpv6, policy) 1693 if err != nil { 1694 if ociResponse != nil { 1695 response = CreateIpv6Response{RawResponse: ociResponse.HTTPResponse()} 1696 } 1697 return 1698 } 1699 if convertedResponse, ok := ociResponse.(CreateIpv6Response); ok { 1700 response = convertedResponse 1701 } else { 1702 err = fmt.Errorf("failed to convert OCIResponse into CreateIpv6Response") 1703 } 1704 return 1705} 1706 1707// createIpv6 implements the OCIOperation interface (enables retrying operations) 1708func (client VirtualNetworkClient) createIpv6(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 1709 httpRequest, err := request.HTTPRequest(http.MethodPost, "/ipv6") 1710 if err != nil { 1711 return nil, err 1712 } 1713 1714 var response CreateIpv6Response 1715 var httpResponse *http.Response 1716 httpResponse, err = client.Call(ctx, &httpRequest) 1717 defer common.CloseBodyIfValid(httpResponse) 1718 response.RawResponse = httpResponse 1719 if err != nil { 1720 return response, err 1721 } 1722 1723 err = common.UnmarshalResponse(httpResponse, &response) 1724 return response, err 1725} 1726 1727// CreateLocalPeeringGateway Creates a new local peering gateway (LPG) for the specified VCN. 1728func (client VirtualNetworkClient) CreateLocalPeeringGateway(ctx context.Context, request CreateLocalPeeringGatewayRequest) (response CreateLocalPeeringGatewayResponse, err error) { 1729 var ociResponse common.OCIResponse 1730 policy := common.NoRetryPolicy() 1731 if request.RetryPolicy() != nil { 1732 policy = *request.RetryPolicy() 1733 } 1734 1735 if !(request.OpcRetryToken != nil && *request.OpcRetryToken != "") { 1736 request.OpcRetryToken = common.String(common.RetryToken()) 1737 } 1738 1739 ociResponse, err = common.Retry(ctx, request, client.createLocalPeeringGateway, policy) 1740 if err != nil { 1741 if ociResponse != nil { 1742 response = CreateLocalPeeringGatewayResponse{RawResponse: ociResponse.HTTPResponse()} 1743 } 1744 return 1745 } 1746 if convertedResponse, ok := ociResponse.(CreateLocalPeeringGatewayResponse); ok { 1747 response = convertedResponse 1748 } else { 1749 err = fmt.Errorf("failed to convert OCIResponse into CreateLocalPeeringGatewayResponse") 1750 } 1751 return 1752} 1753 1754// createLocalPeeringGateway implements the OCIOperation interface (enables retrying operations) 1755func (client VirtualNetworkClient) createLocalPeeringGateway(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 1756 httpRequest, err := request.HTTPRequest(http.MethodPost, "/localPeeringGateways") 1757 if err != nil { 1758 return nil, err 1759 } 1760 1761 var response CreateLocalPeeringGatewayResponse 1762 var httpResponse *http.Response 1763 httpResponse, err = client.Call(ctx, &httpRequest) 1764 defer common.CloseBodyIfValid(httpResponse) 1765 response.RawResponse = httpResponse 1766 if err != nil { 1767 return response, err 1768 } 1769 1770 err = common.UnmarshalResponse(httpResponse, &response) 1771 return response, err 1772} 1773 1774// CreateNatGateway Creates a new NAT gateway for the specified VCN. You must also set up a route rule with the 1775// NAT gateway as the rule's target. See RouteTable. 1776func (client VirtualNetworkClient) CreateNatGateway(ctx context.Context, request CreateNatGatewayRequest) (response CreateNatGatewayResponse, err error) { 1777 var ociResponse common.OCIResponse 1778 policy := common.NoRetryPolicy() 1779 if request.RetryPolicy() != nil { 1780 policy = *request.RetryPolicy() 1781 } 1782 1783 if !(request.OpcRetryToken != nil && *request.OpcRetryToken != "") { 1784 request.OpcRetryToken = common.String(common.RetryToken()) 1785 } 1786 1787 ociResponse, err = common.Retry(ctx, request, client.createNatGateway, policy) 1788 if err != nil { 1789 if ociResponse != nil { 1790 response = CreateNatGatewayResponse{RawResponse: ociResponse.HTTPResponse()} 1791 } 1792 return 1793 } 1794 if convertedResponse, ok := ociResponse.(CreateNatGatewayResponse); ok { 1795 response = convertedResponse 1796 } else { 1797 err = fmt.Errorf("failed to convert OCIResponse into CreateNatGatewayResponse") 1798 } 1799 return 1800} 1801 1802// createNatGateway implements the OCIOperation interface (enables retrying operations) 1803func (client VirtualNetworkClient) createNatGateway(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 1804 httpRequest, err := request.HTTPRequest(http.MethodPost, "/natGateways") 1805 if err != nil { 1806 return nil, err 1807 } 1808 1809 var response CreateNatGatewayResponse 1810 var httpResponse *http.Response 1811 httpResponse, err = client.Call(ctx, &httpRequest) 1812 defer common.CloseBodyIfValid(httpResponse) 1813 response.RawResponse = httpResponse 1814 if err != nil { 1815 return response, err 1816 } 1817 1818 err = common.UnmarshalResponse(httpResponse, &response) 1819 return response, err 1820} 1821 1822// CreateNetworkSecurityGroup Creates a new network security group for the specified VCN. 1823func (client VirtualNetworkClient) CreateNetworkSecurityGroup(ctx context.Context, request CreateNetworkSecurityGroupRequest) (response CreateNetworkSecurityGroupResponse, err error) { 1824 var ociResponse common.OCIResponse 1825 policy := common.NoRetryPolicy() 1826 if request.RetryPolicy() != nil { 1827 policy = *request.RetryPolicy() 1828 } 1829 1830 if !(request.OpcRetryToken != nil && *request.OpcRetryToken != "") { 1831 request.OpcRetryToken = common.String(common.RetryToken()) 1832 } 1833 1834 ociResponse, err = common.Retry(ctx, request, client.createNetworkSecurityGroup, policy) 1835 if err != nil { 1836 if ociResponse != nil { 1837 response = CreateNetworkSecurityGroupResponse{RawResponse: ociResponse.HTTPResponse()} 1838 } 1839 return 1840 } 1841 if convertedResponse, ok := ociResponse.(CreateNetworkSecurityGroupResponse); ok { 1842 response = convertedResponse 1843 } else { 1844 err = fmt.Errorf("failed to convert OCIResponse into CreateNetworkSecurityGroupResponse") 1845 } 1846 return 1847} 1848 1849// createNetworkSecurityGroup implements the OCIOperation interface (enables retrying operations) 1850func (client VirtualNetworkClient) createNetworkSecurityGroup(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 1851 httpRequest, err := request.HTTPRequest(http.MethodPost, "/networkSecurityGroups") 1852 if err != nil { 1853 return nil, err 1854 } 1855 1856 var response CreateNetworkSecurityGroupResponse 1857 var httpResponse *http.Response 1858 httpResponse, err = client.Call(ctx, &httpRequest) 1859 defer common.CloseBodyIfValid(httpResponse) 1860 response.RawResponse = httpResponse 1861 if err != nil { 1862 return response, err 1863 } 1864 1865 err = common.UnmarshalResponse(httpResponse, &response) 1866 return response, err 1867} 1868 1869// CreatePrivateIp Creates a secondary private IP for the specified VNIC. 1870// For more information about secondary private IPs, see 1871// IP Addresses (https://docs.cloud.oracle.com/Content/Network/Tasks/managingIPaddresses.htm). 1872func (client VirtualNetworkClient) CreatePrivateIp(ctx context.Context, request CreatePrivateIpRequest) (response CreatePrivateIpResponse, err error) { 1873 var ociResponse common.OCIResponse 1874 policy := common.NoRetryPolicy() 1875 if request.RetryPolicy() != nil { 1876 policy = *request.RetryPolicy() 1877 } 1878 1879 if !(request.OpcRetryToken != nil && *request.OpcRetryToken != "") { 1880 request.OpcRetryToken = common.String(common.RetryToken()) 1881 } 1882 1883 ociResponse, err = common.Retry(ctx, request, client.createPrivateIp, policy) 1884 if err != nil { 1885 if ociResponse != nil { 1886 response = CreatePrivateIpResponse{RawResponse: ociResponse.HTTPResponse()} 1887 } 1888 return 1889 } 1890 if convertedResponse, ok := ociResponse.(CreatePrivateIpResponse); ok { 1891 response = convertedResponse 1892 } else { 1893 err = fmt.Errorf("failed to convert OCIResponse into CreatePrivateIpResponse") 1894 } 1895 return 1896} 1897 1898// createPrivateIp implements the OCIOperation interface (enables retrying operations) 1899func (client VirtualNetworkClient) createPrivateIp(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 1900 httpRequest, err := request.HTTPRequest(http.MethodPost, "/privateIps") 1901 if err != nil { 1902 return nil, err 1903 } 1904 1905 var response CreatePrivateIpResponse 1906 var httpResponse *http.Response 1907 httpResponse, err = client.Call(ctx, &httpRequest) 1908 defer common.CloseBodyIfValid(httpResponse) 1909 response.RawResponse = httpResponse 1910 if err != nil { 1911 return response, err 1912 } 1913 1914 err = common.UnmarshalResponse(httpResponse, &response) 1915 return response, err 1916} 1917 1918// CreatePublicIp Creates a public IP. Use the `lifetime` property to specify whether it's an ephemeral or 1919// reserved public IP. For information about limits on how many you can create, see 1920// Public IP Addresses (https://docs.cloud.oracle.com/Content/Network/Tasks/managingpublicIPs.htm). 1921// * **For an ephemeral public IP assigned to a private IP:** You must also specify a `privateIpId` 1922// with the OCID of the primary private IP you want to assign the public IP to. The public IP is 1923// created in the same availability domain as the private IP. An ephemeral public IP must always be 1924// assigned to a private IP, and only to the *primary* private IP on a VNIC, not a secondary 1925// private IP. Exception: If you create a NatGateway, Oracle 1926// automatically assigns the NAT gateway a regional ephemeral public IP that you cannot remove. 1927// * **For a reserved public IP:** You may also optionally assign the public IP to a private 1928// IP by specifying `privateIpId`. Or you can later assign the public IP with 1929// UpdatePublicIp. 1930// **Note:** When assigning a public IP to a private IP, the private IP must not already have 1931// a public IP with `lifecycleState` = ASSIGNING or ASSIGNED. If it does, an error is returned. 1932// Also, for reserved public IPs, the optional assignment part of this operation is 1933// asynchronous. Poll the public IP's `lifecycleState` to determine if the assignment 1934// succeeded. 1935func (client VirtualNetworkClient) CreatePublicIp(ctx context.Context, request CreatePublicIpRequest) (response CreatePublicIpResponse, err error) { 1936 var ociResponse common.OCIResponse 1937 policy := common.NoRetryPolicy() 1938 if request.RetryPolicy() != nil { 1939 policy = *request.RetryPolicy() 1940 } 1941 1942 if !(request.OpcRetryToken != nil && *request.OpcRetryToken != "") { 1943 request.OpcRetryToken = common.String(common.RetryToken()) 1944 } 1945 1946 ociResponse, err = common.Retry(ctx, request, client.createPublicIp, policy) 1947 if err != nil { 1948 if ociResponse != nil { 1949 response = CreatePublicIpResponse{RawResponse: ociResponse.HTTPResponse()} 1950 } 1951 return 1952 } 1953 if convertedResponse, ok := ociResponse.(CreatePublicIpResponse); ok { 1954 response = convertedResponse 1955 } else { 1956 err = fmt.Errorf("failed to convert OCIResponse into CreatePublicIpResponse") 1957 } 1958 return 1959} 1960 1961// createPublicIp implements the OCIOperation interface (enables retrying operations) 1962func (client VirtualNetworkClient) createPublicIp(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 1963 httpRequest, err := request.HTTPRequest(http.MethodPost, "/publicIps") 1964 if err != nil { 1965 return nil, err 1966 } 1967 1968 var response CreatePublicIpResponse 1969 var httpResponse *http.Response 1970 httpResponse, err = client.Call(ctx, &httpRequest) 1971 defer common.CloseBodyIfValid(httpResponse) 1972 response.RawResponse = httpResponse 1973 if err != nil { 1974 return response, err 1975 } 1976 1977 err = common.UnmarshalResponse(httpResponse, &response) 1978 return response, err 1979} 1980 1981// CreateRemotePeeringConnection Creates a new remote peering connection (RPC) for the specified DRG. 1982func (client VirtualNetworkClient) CreateRemotePeeringConnection(ctx context.Context, request CreateRemotePeeringConnectionRequest) (response CreateRemotePeeringConnectionResponse, err error) { 1983 var ociResponse common.OCIResponse 1984 policy := common.NoRetryPolicy() 1985 if request.RetryPolicy() != nil { 1986 policy = *request.RetryPolicy() 1987 } 1988 1989 if !(request.OpcRetryToken != nil && *request.OpcRetryToken != "") { 1990 request.OpcRetryToken = common.String(common.RetryToken()) 1991 } 1992 1993 ociResponse, err = common.Retry(ctx, request, client.createRemotePeeringConnection, policy) 1994 if err != nil { 1995 if ociResponse != nil { 1996 response = CreateRemotePeeringConnectionResponse{RawResponse: ociResponse.HTTPResponse()} 1997 } 1998 return 1999 } 2000 if convertedResponse, ok := ociResponse.(CreateRemotePeeringConnectionResponse); ok { 2001 response = convertedResponse 2002 } else { 2003 err = fmt.Errorf("failed to convert OCIResponse into CreateRemotePeeringConnectionResponse") 2004 } 2005 return 2006} 2007 2008// createRemotePeeringConnection implements the OCIOperation interface (enables retrying operations) 2009func (client VirtualNetworkClient) createRemotePeeringConnection(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 2010 httpRequest, err := request.HTTPRequest(http.MethodPost, "/remotePeeringConnections") 2011 if err != nil { 2012 return nil, err 2013 } 2014 2015 var response CreateRemotePeeringConnectionResponse 2016 var httpResponse *http.Response 2017 httpResponse, err = client.Call(ctx, &httpRequest) 2018 defer common.CloseBodyIfValid(httpResponse) 2019 response.RawResponse = httpResponse 2020 if err != nil { 2021 return response, err 2022 } 2023 2024 err = common.UnmarshalResponse(httpResponse, &response) 2025 return response, err 2026} 2027 2028// CreateRouteTable Creates a new route table for the specified VCN. In the request you must also include at least one route 2029// rule for the new route table. For information on the number of rules you can have in a route table, see 2030// Service Limits (https://docs.cloud.oracle.com/Content/General/Concepts/servicelimits.htm). For general information about route 2031// tables in your VCN and the types of targets you can use in route rules, 2032// see Route Tables (https://docs.cloud.oracle.com/Content/Network/Tasks/managingroutetables.htm). 2033// For the purposes of access control, you must provide the OCID of the compartment where you want the route 2034// table to reside. Notice that the route table doesn't have to be in the same compartment as the VCN, subnets, 2035// or other Networking Service components. If you're not sure which compartment to use, put the route 2036// table in the same compartment as the VCN. For more information about compartments and access control, see 2037// Overview of the IAM Service (https://docs.cloud.oracle.com/Content/Identity/Concepts/overview.htm). For information about OCIDs, see 2038// Resource Identifiers (https://docs.cloud.oracle.com/Content/General/Concepts/identifiers.htm). 2039// You may optionally specify a *display name* for the route table, otherwise a default is provided. 2040// It does not have to be unique, and you can change it. Avoid entering confidential information. 2041func (client VirtualNetworkClient) CreateRouteTable(ctx context.Context, request CreateRouteTableRequest) (response CreateRouteTableResponse, err error) { 2042 var ociResponse common.OCIResponse 2043 policy := common.NoRetryPolicy() 2044 if request.RetryPolicy() != nil { 2045 policy = *request.RetryPolicy() 2046 } 2047 2048 if !(request.OpcRetryToken != nil && *request.OpcRetryToken != "") { 2049 request.OpcRetryToken = common.String(common.RetryToken()) 2050 } 2051 2052 ociResponse, err = common.Retry(ctx, request, client.createRouteTable, policy) 2053 if err != nil { 2054 if ociResponse != nil { 2055 response = CreateRouteTableResponse{RawResponse: ociResponse.HTTPResponse()} 2056 } 2057 return 2058 } 2059 if convertedResponse, ok := ociResponse.(CreateRouteTableResponse); ok { 2060 response = convertedResponse 2061 } else { 2062 err = fmt.Errorf("failed to convert OCIResponse into CreateRouteTableResponse") 2063 } 2064 return 2065} 2066 2067// createRouteTable implements the OCIOperation interface (enables retrying operations) 2068func (client VirtualNetworkClient) createRouteTable(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 2069 httpRequest, err := request.HTTPRequest(http.MethodPost, "/routeTables") 2070 if err != nil { 2071 return nil, err 2072 } 2073 2074 var response CreateRouteTableResponse 2075 var httpResponse *http.Response 2076 httpResponse, err = client.Call(ctx, &httpRequest) 2077 defer common.CloseBodyIfValid(httpResponse) 2078 response.RawResponse = httpResponse 2079 if err != nil { 2080 return response, err 2081 } 2082 2083 err = common.UnmarshalResponse(httpResponse, &response) 2084 return response, err 2085} 2086 2087// CreateSecurityList Creates a new security list for the specified VCN. For more information 2088// about security lists, see Security Lists (https://docs.cloud.oracle.com/Content/Network/Concepts/securitylists.htm). 2089// For information on the number of rules you can have in a security list, see 2090// Service Limits (https://docs.cloud.oracle.com/Content/General/Concepts/servicelimits.htm). 2091// For the purposes of access control, you must provide the OCID of the compartment where you want the security 2092// list to reside. Notice that the security list doesn't have to be in the same compartment as the VCN, subnets, 2093// or other Networking Service components. If you're not sure which compartment to use, put the security 2094// list in the same compartment as the VCN. For more information about compartments and access control, see 2095// Overview of the IAM Service (https://docs.cloud.oracle.com/Content/Identity/Concepts/overview.htm). For information about OCIDs, see 2096// Resource Identifiers (https://docs.cloud.oracle.com/Content/General/Concepts/identifiers.htm). 2097// You may optionally specify a *display name* for the security list, otherwise a default is provided. 2098// It does not have to be unique, and you can change it. Avoid entering confidential information. 2099func (client VirtualNetworkClient) CreateSecurityList(ctx context.Context, request CreateSecurityListRequest) (response CreateSecurityListResponse, err error) { 2100 var ociResponse common.OCIResponse 2101 policy := common.NoRetryPolicy() 2102 if request.RetryPolicy() != nil { 2103 policy = *request.RetryPolicy() 2104 } 2105 2106 if !(request.OpcRetryToken != nil && *request.OpcRetryToken != "") { 2107 request.OpcRetryToken = common.String(common.RetryToken()) 2108 } 2109 2110 ociResponse, err = common.Retry(ctx, request, client.createSecurityList, policy) 2111 if err != nil { 2112 if ociResponse != nil { 2113 response = CreateSecurityListResponse{RawResponse: ociResponse.HTTPResponse()} 2114 } 2115 return 2116 } 2117 if convertedResponse, ok := ociResponse.(CreateSecurityListResponse); ok { 2118 response = convertedResponse 2119 } else { 2120 err = fmt.Errorf("failed to convert OCIResponse into CreateSecurityListResponse") 2121 } 2122 return 2123} 2124 2125// createSecurityList implements the OCIOperation interface (enables retrying operations) 2126func (client VirtualNetworkClient) createSecurityList(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 2127 httpRequest, err := request.HTTPRequest(http.MethodPost, "/securityLists") 2128 if err != nil { 2129 return nil, err 2130 } 2131 2132 var response CreateSecurityListResponse 2133 var httpResponse *http.Response 2134 httpResponse, err = client.Call(ctx, &httpRequest) 2135 defer common.CloseBodyIfValid(httpResponse) 2136 response.RawResponse = httpResponse 2137 if err != nil { 2138 return response, err 2139 } 2140 2141 err = common.UnmarshalResponse(httpResponse, &response) 2142 return response, err 2143} 2144 2145// CreateServiceGateway Creates a new service gateway in the specified compartment. 2146// For the purposes of access control, you must provide the OCID of the compartment where you want 2147// the service gateway to reside. For more information about compartments and access control, see 2148// Overview of the IAM Service (https://docs.cloud.oracle.com/Content/Identity/Concepts/overview.htm). 2149// For information about OCIDs, see Resource Identifiers (https://docs.cloud.oracle.com/Content/General/Concepts/identifiers.htm). 2150// You may optionally specify a *display name* for the service gateway, otherwise a default is provided. 2151// It does not have to be unique, and you can change it. Avoid entering confidential information. 2152func (client VirtualNetworkClient) CreateServiceGateway(ctx context.Context, request CreateServiceGatewayRequest) (response CreateServiceGatewayResponse, err error) { 2153 var ociResponse common.OCIResponse 2154 policy := common.NoRetryPolicy() 2155 if request.RetryPolicy() != nil { 2156 policy = *request.RetryPolicy() 2157 } 2158 2159 if !(request.OpcRetryToken != nil && *request.OpcRetryToken != "") { 2160 request.OpcRetryToken = common.String(common.RetryToken()) 2161 } 2162 2163 ociResponse, err = common.Retry(ctx, request, client.createServiceGateway, policy) 2164 if err != nil { 2165 if ociResponse != nil { 2166 response = CreateServiceGatewayResponse{RawResponse: ociResponse.HTTPResponse()} 2167 } 2168 return 2169 } 2170 if convertedResponse, ok := ociResponse.(CreateServiceGatewayResponse); ok { 2171 response = convertedResponse 2172 } else { 2173 err = fmt.Errorf("failed to convert OCIResponse into CreateServiceGatewayResponse") 2174 } 2175 return 2176} 2177 2178// createServiceGateway implements the OCIOperation interface (enables retrying operations) 2179func (client VirtualNetworkClient) createServiceGateway(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 2180 httpRequest, err := request.HTTPRequest(http.MethodPost, "/serviceGateways") 2181 if err != nil { 2182 return nil, err 2183 } 2184 2185 var response CreateServiceGatewayResponse 2186 var httpResponse *http.Response 2187 httpResponse, err = client.Call(ctx, &httpRequest) 2188 defer common.CloseBodyIfValid(httpResponse) 2189 response.RawResponse = httpResponse 2190 if err != nil { 2191 return response, err 2192 } 2193 2194 err = common.UnmarshalResponse(httpResponse, &response) 2195 return response, err 2196} 2197 2198// CreateSubnet Creates a new subnet in the specified VCN. You can't change the size of the subnet after creation, 2199// so it's important to think about the size of subnets you need before creating them. 2200// For more information, see VCNs and Subnets (https://docs.cloud.oracle.com/Content/Network/Tasks/managingVCNs.htm). 2201// For information on the number of subnets you can have in a VCN, see 2202// Service Limits (https://docs.cloud.oracle.com/Content/General/Concepts/servicelimits.htm). 2203// For the purposes of access control, you must provide the OCID of the compartment where you want the subnet 2204// to reside. Notice that the subnet doesn't have to be in the same compartment as the VCN, route tables, or 2205// other Networking Service components. If you're not sure which compartment to use, put the subnet in 2206// the same compartment as the VCN. For more information about compartments and access control, see 2207// Overview of the IAM Service (https://docs.cloud.oracle.com/Content/Identity/Concepts/overview.htm). For information about OCIDs, 2208// see Resource Identifiers (https://docs.cloud.oracle.com/Content/General/Concepts/identifiers.htm). 2209// You may optionally associate a route table with the subnet. If you don't, the subnet will use the 2210// VCN's default route table. For more information about route tables, see 2211// Route Tables (https://docs.cloud.oracle.com/Content/Network/Tasks/managingroutetables.htm). 2212// You may optionally associate a security list with the subnet. If you don't, the subnet will use the 2213// VCN's default security list. For more information about security lists, see 2214// Security Lists (https://docs.cloud.oracle.com/Content/Network/Concepts/securitylists.htm). 2215// You may optionally associate a set of DHCP options with the subnet. If you don't, the subnet will use the 2216// VCN's default set. For more information about DHCP options, see 2217// DHCP Options (https://docs.cloud.oracle.com/Content/Network/Tasks/managingDHCP.htm). 2218// You may optionally specify a *display name* for the subnet, otherwise a default is provided. 2219// It does not have to be unique, and you can change it. Avoid entering confidential information. 2220// You can also add a DNS label for the subnet, which is required if you want the Internet and 2221// VCN Resolver to resolve hostnames for instances in the subnet. For more information, see 2222// DNS in Your Virtual Cloud Network (https://docs.cloud.oracle.com/Content/Network/Concepts/dns.htm). 2223func (client VirtualNetworkClient) CreateSubnet(ctx context.Context, request CreateSubnetRequest) (response CreateSubnetResponse, err error) { 2224 var ociResponse common.OCIResponse 2225 policy := common.NoRetryPolicy() 2226 if request.RetryPolicy() != nil { 2227 policy = *request.RetryPolicy() 2228 } 2229 2230 if !(request.OpcRetryToken != nil && *request.OpcRetryToken != "") { 2231 request.OpcRetryToken = common.String(common.RetryToken()) 2232 } 2233 2234 ociResponse, err = common.Retry(ctx, request, client.createSubnet, policy) 2235 if err != nil { 2236 if ociResponse != nil { 2237 response = CreateSubnetResponse{RawResponse: ociResponse.HTTPResponse()} 2238 } 2239 return 2240 } 2241 if convertedResponse, ok := ociResponse.(CreateSubnetResponse); ok { 2242 response = convertedResponse 2243 } else { 2244 err = fmt.Errorf("failed to convert OCIResponse into CreateSubnetResponse") 2245 } 2246 return 2247} 2248 2249// createSubnet implements the OCIOperation interface (enables retrying operations) 2250func (client VirtualNetworkClient) createSubnet(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 2251 httpRequest, err := request.HTTPRequest(http.MethodPost, "/subnets") 2252 if err != nil { 2253 return nil, err 2254 } 2255 2256 var response CreateSubnetResponse 2257 var httpResponse *http.Response 2258 httpResponse, err = client.Call(ctx, &httpRequest) 2259 defer common.CloseBodyIfValid(httpResponse) 2260 response.RawResponse = httpResponse 2261 if err != nil { 2262 return response, err 2263 } 2264 2265 err = common.UnmarshalResponse(httpResponse, &response) 2266 return response, err 2267} 2268 2269// CreateVcn Creates a new virtual cloud network (VCN). For more information, see 2270// VCNs and Subnets (https://docs.cloud.oracle.com/Content/Network/Tasks/managingVCNs.htm). 2271// For the VCN you must specify a single, contiguous IPv4 CIDR block. Oracle recommends using one of the 2272// private IP address ranges specified in RFC 1918 (https://tools.ietf.org/html/rfc1918) (10.0.0.0/8, 2273// 172.16/12, and 192.168/16). Example: 172.16.0.0/16. The CIDR block can range from /16 to /30, and it 2274// must not overlap with your on-premises network. You can't change the size of the VCN after creation. 2275// For the purposes of access control, you must provide the OCID of the compartment where you want the VCN to 2276// reside. Consult an Oracle Cloud Infrastructure administrator in your organization if you're not sure which 2277// compartment to use. Notice that the VCN doesn't have to be in the same compartment as the subnets or other 2278// Networking Service components. For more information about compartments and access control, see 2279// Overview of the IAM Service (https://docs.cloud.oracle.com/Content/Identity/Concepts/overview.htm). For information about OCIDs, see 2280// Resource Identifiers (https://docs.cloud.oracle.com/Content/General/Concepts/identifiers.htm). 2281// You may optionally specify a *display name* for the VCN, otherwise a default is provided. It does not have to 2282// be unique, and you can change it. Avoid entering confidential information. 2283// You can also add a DNS label for the VCN, which is required if you want the instances to use the 2284// Interent and VCN Resolver option for DNS in the VCN. For more information, see 2285// DNS in Your Virtual Cloud Network (https://docs.cloud.oracle.com/Content/Network/Concepts/dns.htm). 2286// The VCN automatically comes with a default route table, default security list, and default set of DHCP options. 2287// The OCID for each is returned in the response. You can't delete these default objects, but you can change their 2288// contents (that is, change the route rules, security list rules, and so on). 2289// The VCN and subnets you create are not accessible until you attach an internet gateway or set up an IPSec VPN 2290// or FastConnect. For more information, see 2291// Overview of the Networking Service (https://docs.cloud.oracle.com/Content/Network/Concepts/overview.htm). 2292func (client VirtualNetworkClient) CreateVcn(ctx context.Context, request CreateVcnRequest) (response CreateVcnResponse, err error) { 2293 var ociResponse common.OCIResponse 2294 policy := common.NoRetryPolicy() 2295 if request.RetryPolicy() != nil { 2296 policy = *request.RetryPolicy() 2297 } 2298 2299 if !(request.OpcRetryToken != nil && *request.OpcRetryToken != "") { 2300 request.OpcRetryToken = common.String(common.RetryToken()) 2301 } 2302 2303 ociResponse, err = common.Retry(ctx, request, client.createVcn, policy) 2304 if err != nil { 2305 if ociResponse != nil { 2306 response = CreateVcnResponse{RawResponse: ociResponse.HTTPResponse()} 2307 } 2308 return 2309 } 2310 if convertedResponse, ok := ociResponse.(CreateVcnResponse); ok { 2311 response = convertedResponse 2312 } else { 2313 err = fmt.Errorf("failed to convert OCIResponse into CreateVcnResponse") 2314 } 2315 return 2316} 2317 2318// createVcn implements the OCIOperation interface (enables retrying operations) 2319func (client VirtualNetworkClient) createVcn(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 2320 httpRequest, err := request.HTTPRequest(http.MethodPost, "/vcns") 2321 if err != nil { 2322 return nil, err 2323 } 2324 2325 var response CreateVcnResponse 2326 var httpResponse *http.Response 2327 httpResponse, err = client.Call(ctx, &httpRequest) 2328 defer common.CloseBodyIfValid(httpResponse) 2329 response.RawResponse = httpResponse 2330 if err != nil { 2331 return response, err 2332 } 2333 2334 err = common.UnmarshalResponse(httpResponse, &response) 2335 return response, err 2336} 2337 2338// CreateVirtualCircuit Creates a new virtual circuit to use with Oracle Cloud 2339// Infrastructure FastConnect. For more information, see 2340// FastConnect Overview (https://docs.cloud.oracle.com/Content/Network/Concepts/fastconnect.htm). 2341// For the purposes of access control, you must provide the OCID of the 2342// compartment where you want the virtual circuit to reside. If you're 2343// not sure which compartment to use, put the virtual circuit in the 2344// same compartment with the DRG it's using. For more information about 2345// compartments and access control, see 2346// Overview of the IAM Service (https://docs.cloud.oracle.com/Content/Identity/Concepts/overview.htm). 2347// For information about OCIDs, see 2348// Resource Identifiers (https://docs.cloud.oracle.com/Content/General/Concepts/identifiers.htm). 2349// You may optionally specify a *display name* for the virtual circuit. 2350// It does not have to be unique, and you can change it. Avoid entering confidential information. 2351// **Important:** When creating a virtual circuit, you specify a DRG for 2352// the traffic to flow through. Make sure you attach the DRG to your 2353// VCN and confirm the VCN's routing sends traffic to the DRG. Otherwise 2354// traffic will not flow. For more information, see 2355// Route Tables (https://docs.cloud.oracle.com/Content/Network/Tasks/managingroutetables.htm). 2356func (client VirtualNetworkClient) CreateVirtualCircuit(ctx context.Context, request CreateVirtualCircuitRequest) (response CreateVirtualCircuitResponse, err error) { 2357 var ociResponse common.OCIResponse 2358 policy := common.NoRetryPolicy() 2359 if request.RetryPolicy() != nil { 2360 policy = *request.RetryPolicy() 2361 } 2362 2363 if !(request.OpcRetryToken != nil && *request.OpcRetryToken != "") { 2364 request.OpcRetryToken = common.String(common.RetryToken()) 2365 } 2366 2367 ociResponse, err = common.Retry(ctx, request, client.createVirtualCircuit, policy) 2368 if err != nil { 2369 if ociResponse != nil { 2370 response = CreateVirtualCircuitResponse{RawResponse: ociResponse.HTTPResponse()} 2371 } 2372 return 2373 } 2374 if convertedResponse, ok := ociResponse.(CreateVirtualCircuitResponse); ok { 2375 response = convertedResponse 2376 } else { 2377 err = fmt.Errorf("failed to convert OCIResponse into CreateVirtualCircuitResponse") 2378 } 2379 return 2380} 2381 2382// createVirtualCircuit implements the OCIOperation interface (enables retrying operations) 2383func (client VirtualNetworkClient) createVirtualCircuit(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 2384 httpRequest, err := request.HTTPRequest(http.MethodPost, "/virtualCircuits") 2385 if err != nil { 2386 return nil, err 2387 } 2388 2389 var response CreateVirtualCircuitResponse 2390 var httpResponse *http.Response 2391 httpResponse, err = client.Call(ctx, &httpRequest) 2392 defer common.CloseBodyIfValid(httpResponse) 2393 response.RawResponse = httpResponse 2394 if err != nil { 2395 return response, err 2396 } 2397 2398 err = common.UnmarshalResponse(httpResponse, &response) 2399 return response, err 2400} 2401 2402// DeleteCpe Deletes the specified CPE object. The CPE must not be connected to a DRG. This is an asynchronous 2403// operation. The CPE's `lifecycleState` will change to TERMINATING temporarily until the CPE is completely 2404// removed. 2405func (client VirtualNetworkClient) DeleteCpe(ctx context.Context, request DeleteCpeRequest) (response DeleteCpeResponse, err error) { 2406 var ociResponse common.OCIResponse 2407 policy := common.NoRetryPolicy() 2408 if request.RetryPolicy() != nil { 2409 policy = *request.RetryPolicy() 2410 } 2411 ociResponse, err = common.Retry(ctx, request, client.deleteCpe, policy) 2412 if err != nil { 2413 if ociResponse != nil { 2414 response = DeleteCpeResponse{RawResponse: ociResponse.HTTPResponse()} 2415 } 2416 return 2417 } 2418 if convertedResponse, ok := ociResponse.(DeleteCpeResponse); ok { 2419 response = convertedResponse 2420 } else { 2421 err = fmt.Errorf("failed to convert OCIResponse into DeleteCpeResponse") 2422 } 2423 return 2424} 2425 2426// deleteCpe implements the OCIOperation interface (enables retrying operations) 2427func (client VirtualNetworkClient) deleteCpe(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 2428 httpRequest, err := request.HTTPRequest(http.MethodDelete, "/cpes/{cpeId}") 2429 if err != nil { 2430 return nil, err 2431 } 2432 2433 var response DeleteCpeResponse 2434 var httpResponse *http.Response 2435 httpResponse, err = client.Call(ctx, &httpRequest) 2436 defer common.CloseBodyIfValid(httpResponse) 2437 response.RawResponse = httpResponse 2438 if err != nil { 2439 return response, err 2440 } 2441 2442 err = common.UnmarshalResponse(httpResponse, &response) 2443 return response, err 2444} 2445 2446// DeleteCrossConnect Deletes the specified cross-connect. It must not be mapped to a 2447// VirtualCircuit. 2448func (client VirtualNetworkClient) DeleteCrossConnect(ctx context.Context, request DeleteCrossConnectRequest) (response DeleteCrossConnectResponse, err error) { 2449 var ociResponse common.OCIResponse 2450 policy := common.NoRetryPolicy() 2451 if request.RetryPolicy() != nil { 2452 policy = *request.RetryPolicy() 2453 } 2454 ociResponse, err = common.Retry(ctx, request, client.deleteCrossConnect, policy) 2455 if err != nil { 2456 if ociResponse != nil { 2457 response = DeleteCrossConnectResponse{RawResponse: ociResponse.HTTPResponse()} 2458 } 2459 return 2460 } 2461 if convertedResponse, ok := ociResponse.(DeleteCrossConnectResponse); ok { 2462 response = convertedResponse 2463 } else { 2464 err = fmt.Errorf("failed to convert OCIResponse into DeleteCrossConnectResponse") 2465 } 2466 return 2467} 2468 2469// deleteCrossConnect implements the OCIOperation interface (enables retrying operations) 2470func (client VirtualNetworkClient) deleteCrossConnect(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 2471 httpRequest, err := request.HTTPRequest(http.MethodDelete, "/crossConnects/{crossConnectId}") 2472 if err != nil { 2473 return nil, err 2474 } 2475 2476 var response DeleteCrossConnectResponse 2477 var httpResponse *http.Response 2478 httpResponse, err = client.Call(ctx, &httpRequest) 2479 defer common.CloseBodyIfValid(httpResponse) 2480 response.RawResponse = httpResponse 2481 if err != nil { 2482 return response, err 2483 } 2484 2485 err = common.UnmarshalResponse(httpResponse, &response) 2486 return response, err 2487} 2488 2489// DeleteCrossConnectGroup Deletes the specified cross-connect group. It must not contain any 2490// cross-connects, and it cannot be mapped to a 2491// VirtualCircuit. 2492func (client VirtualNetworkClient) DeleteCrossConnectGroup(ctx context.Context, request DeleteCrossConnectGroupRequest) (response DeleteCrossConnectGroupResponse, err error) { 2493 var ociResponse common.OCIResponse 2494 policy := common.NoRetryPolicy() 2495 if request.RetryPolicy() != nil { 2496 policy = *request.RetryPolicy() 2497 } 2498 ociResponse, err = common.Retry(ctx, request, client.deleteCrossConnectGroup, policy) 2499 if err != nil { 2500 if ociResponse != nil { 2501 response = DeleteCrossConnectGroupResponse{RawResponse: ociResponse.HTTPResponse()} 2502 } 2503 return 2504 } 2505 if convertedResponse, ok := ociResponse.(DeleteCrossConnectGroupResponse); ok { 2506 response = convertedResponse 2507 } else { 2508 err = fmt.Errorf("failed to convert OCIResponse into DeleteCrossConnectGroupResponse") 2509 } 2510 return 2511} 2512 2513// deleteCrossConnectGroup implements the OCIOperation interface (enables retrying operations) 2514func (client VirtualNetworkClient) deleteCrossConnectGroup(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 2515 httpRequest, err := request.HTTPRequest(http.MethodDelete, "/crossConnectGroups/{crossConnectGroupId}") 2516 if err != nil { 2517 return nil, err 2518 } 2519 2520 var response DeleteCrossConnectGroupResponse 2521 var httpResponse *http.Response 2522 httpResponse, err = client.Call(ctx, &httpRequest) 2523 defer common.CloseBodyIfValid(httpResponse) 2524 response.RawResponse = httpResponse 2525 if err != nil { 2526 return response, err 2527 } 2528 2529 err = common.UnmarshalResponse(httpResponse, &response) 2530 return response, err 2531} 2532 2533// DeleteDhcpOptions Deletes the specified set of DHCP options, but only if it's not associated with a subnet. You can't delete a 2534// VCN's default set of DHCP options. 2535// This is an asynchronous operation. The state of the set of options will switch to TERMINATING temporarily 2536// until the set is completely removed. 2537func (client VirtualNetworkClient) DeleteDhcpOptions(ctx context.Context, request DeleteDhcpOptionsRequest) (response DeleteDhcpOptionsResponse, err error) { 2538 var ociResponse common.OCIResponse 2539 policy := common.NoRetryPolicy() 2540 if request.RetryPolicy() != nil { 2541 policy = *request.RetryPolicy() 2542 } 2543 ociResponse, err = common.Retry(ctx, request, client.deleteDhcpOptions, policy) 2544 if err != nil { 2545 if ociResponse != nil { 2546 response = DeleteDhcpOptionsResponse{RawResponse: ociResponse.HTTPResponse()} 2547 } 2548 return 2549 } 2550 if convertedResponse, ok := ociResponse.(DeleteDhcpOptionsResponse); ok { 2551 response = convertedResponse 2552 } else { 2553 err = fmt.Errorf("failed to convert OCIResponse into DeleteDhcpOptionsResponse") 2554 } 2555 return 2556} 2557 2558// deleteDhcpOptions implements the OCIOperation interface (enables retrying operations) 2559func (client VirtualNetworkClient) deleteDhcpOptions(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 2560 httpRequest, err := request.HTTPRequest(http.MethodDelete, "/dhcps/{dhcpId}") 2561 if err != nil { 2562 return nil, err 2563 } 2564 2565 var response DeleteDhcpOptionsResponse 2566 var httpResponse *http.Response 2567 httpResponse, err = client.Call(ctx, &httpRequest) 2568 defer common.CloseBodyIfValid(httpResponse) 2569 response.RawResponse = httpResponse 2570 if err != nil { 2571 return response, err 2572 } 2573 2574 err = common.UnmarshalResponse(httpResponse, &response) 2575 return response, err 2576} 2577 2578// DeleteDrg Deletes the specified DRG. The DRG must not be attached to a VCN or be connected to your on-premise 2579// network. Also, there must not be a route table that lists the DRG as a target. This is an asynchronous 2580// operation. The DRG's `lifecycleState` will change to TERMINATING temporarily until the DRG is completely 2581// removed. 2582func (client VirtualNetworkClient) DeleteDrg(ctx context.Context, request DeleteDrgRequest) (response DeleteDrgResponse, err error) { 2583 var ociResponse common.OCIResponse 2584 policy := common.NoRetryPolicy() 2585 if request.RetryPolicy() != nil { 2586 policy = *request.RetryPolicy() 2587 } 2588 ociResponse, err = common.Retry(ctx, request, client.deleteDrg, policy) 2589 if err != nil { 2590 if ociResponse != nil { 2591 response = DeleteDrgResponse{RawResponse: ociResponse.HTTPResponse()} 2592 } 2593 return 2594 } 2595 if convertedResponse, ok := ociResponse.(DeleteDrgResponse); ok { 2596 response = convertedResponse 2597 } else { 2598 err = fmt.Errorf("failed to convert OCIResponse into DeleteDrgResponse") 2599 } 2600 return 2601} 2602 2603// deleteDrg implements the OCIOperation interface (enables retrying operations) 2604func (client VirtualNetworkClient) deleteDrg(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 2605 httpRequest, err := request.HTTPRequest(http.MethodDelete, "/drgs/{drgId}") 2606 if err != nil { 2607 return nil, err 2608 } 2609 2610 var response DeleteDrgResponse 2611 var httpResponse *http.Response 2612 httpResponse, err = client.Call(ctx, &httpRequest) 2613 defer common.CloseBodyIfValid(httpResponse) 2614 response.RawResponse = httpResponse 2615 if err != nil { 2616 return response, err 2617 } 2618 2619 err = common.UnmarshalResponse(httpResponse, &response) 2620 return response, err 2621} 2622 2623// DeleteDrgAttachment Detaches a DRG from a VCN by deleting the corresponding `DrgAttachment`. This is an asynchronous 2624// operation. The attachment's `lifecycleState` will change to DETACHING temporarily until the attachment 2625// is completely removed. 2626func (client VirtualNetworkClient) DeleteDrgAttachment(ctx context.Context, request DeleteDrgAttachmentRequest) (response DeleteDrgAttachmentResponse, err error) { 2627 var ociResponse common.OCIResponse 2628 policy := common.NoRetryPolicy() 2629 if request.RetryPolicy() != nil { 2630 policy = *request.RetryPolicy() 2631 } 2632 ociResponse, err = common.Retry(ctx, request, client.deleteDrgAttachment, policy) 2633 if err != nil { 2634 if ociResponse != nil { 2635 response = DeleteDrgAttachmentResponse{RawResponse: ociResponse.HTTPResponse()} 2636 } 2637 return 2638 } 2639 if convertedResponse, ok := ociResponse.(DeleteDrgAttachmentResponse); ok { 2640 response = convertedResponse 2641 } else { 2642 err = fmt.Errorf("failed to convert OCIResponse into DeleteDrgAttachmentResponse") 2643 } 2644 return 2645} 2646 2647// deleteDrgAttachment implements the OCIOperation interface (enables retrying operations) 2648func (client VirtualNetworkClient) deleteDrgAttachment(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 2649 httpRequest, err := request.HTTPRequest(http.MethodDelete, "/drgAttachments/{drgAttachmentId}") 2650 if err != nil { 2651 return nil, err 2652 } 2653 2654 var response DeleteDrgAttachmentResponse 2655 var httpResponse *http.Response 2656 httpResponse, err = client.Call(ctx, &httpRequest) 2657 defer common.CloseBodyIfValid(httpResponse) 2658 response.RawResponse = httpResponse 2659 if err != nil { 2660 return response, err 2661 } 2662 2663 err = common.UnmarshalResponse(httpResponse, &response) 2664 return response, err 2665} 2666 2667// DeleteIPSecConnection Deletes the specified IPSec connection. If your goal is to disable the IPSec VPN between your VCN and 2668// on-premises network, it's easiest to simply detach the DRG but keep all the IPSec VPN components intact. 2669// If you were to delete all the components and then later need to create an IPSec VPN again, you would 2670// need to configure your on-premises router again with the new information returned from 2671// CreateIPSecConnection. 2672// This is an asynchronous operation. The connection's `lifecycleState` will change to TERMINATING temporarily 2673// until the connection is completely removed. 2674func (client VirtualNetworkClient) DeleteIPSecConnection(ctx context.Context, request DeleteIPSecConnectionRequest) (response DeleteIPSecConnectionResponse, err error) { 2675 var ociResponse common.OCIResponse 2676 policy := common.NoRetryPolicy() 2677 if request.RetryPolicy() != nil { 2678 policy = *request.RetryPolicy() 2679 } 2680 ociResponse, err = common.Retry(ctx, request, client.deleteIPSecConnection, policy) 2681 if err != nil { 2682 if ociResponse != nil { 2683 response = DeleteIPSecConnectionResponse{RawResponse: ociResponse.HTTPResponse()} 2684 } 2685 return 2686 } 2687 if convertedResponse, ok := ociResponse.(DeleteIPSecConnectionResponse); ok { 2688 response = convertedResponse 2689 } else { 2690 err = fmt.Errorf("failed to convert OCIResponse into DeleteIPSecConnectionResponse") 2691 } 2692 return 2693} 2694 2695// deleteIPSecConnection implements the OCIOperation interface (enables retrying operations) 2696func (client VirtualNetworkClient) deleteIPSecConnection(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 2697 httpRequest, err := request.HTTPRequest(http.MethodDelete, "/ipsecConnections/{ipscId}") 2698 if err != nil { 2699 return nil, err 2700 } 2701 2702 var response DeleteIPSecConnectionResponse 2703 var httpResponse *http.Response 2704 httpResponse, err = client.Call(ctx, &httpRequest) 2705 defer common.CloseBodyIfValid(httpResponse) 2706 response.RawResponse = httpResponse 2707 if err != nil { 2708 return response, err 2709 } 2710 2711 err = common.UnmarshalResponse(httpResponse, &response) 2712 return response, err 2713} 2714 2715// DeleteInternetGateway Deletes the specified internet gateway. The internet gateway does not have to be disabled, but 2716// there must not be a route table that lists it as a target. 2717// This is an asynchronous operation. The gateway's `lifecycleState` will change to TERMINATING temporarily 2718// until the gateway is completely removed. 2719func (client VirtualNetworkClient) DeleteInternetGateway(ctx context.Context, request DeleteInternetGatewayRequest) (response DeleteInternetGatewayResponse, err error) { 2720 var ociResponse common.OCIResponse 2721 policy := common.NoRetryPolicy() 2722 if request.RetryPolicy() != nil { 2723 policy = *request.RetryPolicy() 2724 } 2725 ociResponse, err = common.Retry(ctx, request, client.deleteInternetGateway, policy) 2726 if err != nil { 2727 if ociResponse != nil { 2728 response = DeleteInternetGatewayResponse{RawResponse: ociResponse.HTTPResponse()} 2729 } 2730 return 2731 } 2732 if convertedResponse, ok := ociResponse.(DeleteInternetGatewayResponse); ok { 2733 response = convertedResponse 2734 } else { 2735 err = fmt.Errorf("failed to convert OCIResponse into DeleteInternetGatewayResponse") 2736 } 2737 return 2738} 2739 2740// deleteInternetGateway implements the OCIOperation interface (enables retrying operations) 2741func (client VirtualNetworkClient) deleteInternetGateway(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 2742 httpRequest, err := request.HTTPRequest(http.MethodDelete, "/internetGateways/{igId}") 2743 if err != nil { 2744 return nil, err 2745 } 2746 2747 var response DeleteInternetGatewayResponse 2748 var httpResponse *http.Response 2749 httpResponse, err = client.Call(ctx, &httpRequest) 2750 defer common.CloseBodyIfValid(httpResponse) 2751 response.RawResponse = httpResponse 2752 if err != nil { 2753 return response, err 2754 } 2755 2756 err = common.UnmarshalResponse(httpResponse, &response) 2757 return response, err 2758} 2759 2760// DeleteIpv6 Unassigns and deletes the specified IPv6. You must specify the object's OCID. 2761// The IPv6 address is returned to the subnet's pool of available addresses. 2762func (client VirtualNetworkClient) DeleteIpv6(ctx context.Context, request DeleteIpv6Request) (response DeleteIpv6Response, err error) { 2763 var ociResponse common.OCIResponse 2764 policy := common.NoRetryPolicy() 2765 if request.RetryPolicy() != nil { 2766 policy = *request.RetryPolicy() 2767 } 2768 ociResponse, err = common.Retry(ctx, request, client.deleteIpv6, policy) 2769 if err != nil { 2770 if ociResponse != nil { 2771 response = DeleteIpv6Response{RawResponse: ociResponse.HTTPResponse()} 2772 } 2773 return 2774 } 2775 if convertedResponse, ok := ociResponse.(DeleteIpv6Response); ok { 2776 response = convertedResponse 2777 } else { 2778 err = fmt.Errorf("failed to convert OCIResponse into DeleteIpv6Response") 2779 } 2780 return 2781} 2782 2783// deleteIpv6 implements the OCIOperation interface (enables retrying operations) 2784func (client VirtualNetworkClient) deleteIpv6(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 2785 httpRequest, err := request.HTTPRequest(http.MethodDelete, "/ipv6/{ipv6Id}") 2786 if err != nil { 2787 return nil, err 2788 } 2789 2790 var response DeleteIpv6Response 2791 var httpResponse *http.Response 2792 httpResponse, err = client.Call(ctx, &httpRequest) 2793 defer common.CloseBodyIfValid(httpResponse) 2794 response.RawResponse = httpResponse 2795 if err != nil { 2796 return response, err 2797 } 2798 2799 err = common.UnmarshalResponse(httpResponse, &response) 2800 return response, err 2801} 2802 2803// DeleteLocalPeeringGateway Deletes the specified local peering gateway (LPG). 2804// This is an asynchronous operation; the local peering gateway's `lifecycleState` changes to TERMINATING temporarily 2805// until the local peering gateway is completely removed. 2806func (client VirtualNetworkClient) DeleteLocalPeeringGateway(ctx context.Context, request DeleteLocalPeeringGatewayRequest) (response DeleteLocalPeeringGatewayResponse, err error) { 2807 var ociResponse common.OCIResponse 2808 policy := common.NoRetryPolicy() 2809 if request.RetryPolicy() != nil { 2810 policy = *request.RetryPolicy() 2811 } 2812 ociResponse, err = common.Retry(ctx, request, client.deleteLocalPeeringGateway, policy) 2813 if err != nil { 2814 if ociResponse != nil { 2815 response = DeleteLocalPeeringGatewayResponse{RawResponse: ociResponse.HTTPResponse()} 2816 } 2817 return 2818 } 2819 if convertedResponse, ok := ociResponse.(DeleteLocalPeeringGatewayResponse); ok { 2820 response = convertedResponse 2821 } else { 2822 err = fmt.Errorf("failed to convert OCIResponse into DeleteLocalPeeringGatewayResponse") 2823 } 2824 return 2825} 2826 2827// deleteLocalPeeringGateway implements the OCIOperation interface (enables retrying operations) 2828func (client VirtualNetworkClient) deleteLocalPeeringGateway(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 2829 httpRequest, err := request.HTTPRequest(http.MethodDelete, "/localPeeringGateways/{localPeeringGatewayId}") 2830 if err != nil { 2831 return nil, err 2832 } 2833 2834 var response DeleteLocalPeeringGatewayResponse 2835 var httpResponse *http.Response 2836 httpResponse, err = client.Call(ctx, &httpRequest) 2837 defer common.CloseBodyIfValid(httpResponse) 2838 response.RawResponse = httpResponse 2839 if err != nil { 2840 return response, err 2841 } 2842 2843 err = common.UnmarshalResponse(httpResponse, &response) 2844 return response, err 2845} 2846 2847// DeleteNatGateway Deletes the specified NAT gateway. The NAT gateway does not have to be disabled, but there 2848// must not be a route rule that lists the NAT gateway as a target. 2849// This is an asynchronous operation. The NAT gateway's `lifecycleState` will change to 2850// TERMINATING temporarily until the NAT gateway is completely removed. 2851func (client VirtualNetworkClient) DeleteNatGateway(ctx context.Context, request DeleteNatGatewayRequest) (response DeleteNatGatewayResponse, err error) { 2852 var ociResponse common.OCIResponse 2853 policy := common.NoRetryPolicy() 2854 if request.RetryPolicy() != nil { 2855 policy = *request.RetryPolicy() 2856 } 2857 ociResponse, err = common.Retry(ctx, request, client.deleteNatGateway, policy) 2858 if err != nil { 2859 if ociResponse != nil { 2860 response = DeleteNatGatewayResponse{RawResponse: ociResponse.HTTPResponse()} 2861 } 2862 return 2863 } 2864 if convertedResponse, ok := ociResponse.(DeleteNatGatewayResponse); ok { 2865 response = convertedResponse 2866 } else { 2867 err = fmt.Errorf("failed to convert OCIResponse into DeleteNatGatewayResponse") 2868 } 2869 return 2870} 2871 2872// deleteNatGateway implements the OCIOperation interface (enables retrying operations) 2873func (client VirtualNetworkClient) deleteNatGateway(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 2874 httpRequest, err := request.HTTPRequest(http.MethodDelete, "/natGateways/{natGatewayId}") 2875 if err != nil { 2876 return nil, err 2877 } 2878 2879 var response DeleteNatGatewayResponse 2880 var httpResponse *http.Response 2881 httpResponse, err = client.Call(ctx, &httpRequest) 2882 defer common.CloseBodyIfValid(httpResponse) 2883 response.RawResponse = httpResponse 2884 if err != nil { 2885 return response, err 2886 } 2887 2888 err = common.UnmarshalResponse(httpResponse, &response) 2889 return response, err 2890} 2891 2892// DeleteNetworkSecurityGroup Deletes the specified network security group. The group must not contain any VNICs. 2893// To get a list of the VNICs in a network security group, use 2894// ListNetworkSecurityGroupVnics. 2895// Each returned NetworkSecurityGroupVnic object 2896// contains both the OCID of the VNIC and the OCID of the VNIC's parent resource (for example, 2897// the Compute instance that the VNIC is attached to). 2898func (client VirtualNetworkClient) DeleteNetworkSecurityGroup(ctx context.Context, request DeleteNetworkSecurityGroupRequest) (response DeleteNetworkSecurityGroupResponse, err error) { 2899 var ociResponse common.OCIResponse 2900 policy := common.NoRetryPolicy() 2901 if request.RetryPolicy() != nil { 2902 policy = *request.RetryPolicy() 2903 } 2904 ociResponse, err = common.Retry(ctx, request, client.deleteNetworkSecurityGroup, policy) 2905 if err != nil { 2906 if ociResponse != nil { 2907 response = DeleteNetworkSecurityGroupResponse{RawResponse: ociResponse.HTTPResponse()} 2908 } 2909 return 2910 } 2911 if convertedResponse, ok := ociResponse.(DeleteNetworkSecurityGroupResponse); ok { 2912 response = convertedResponse 2913 } else { 2914 err = fmt.Errorf("failed to convert OCIResponse into DeleteNetworkSecurityGroupResponse") 2915 } 2916 return 2917} 2918 2919// deleteNetworkSecurityGroup implements the OCIOperation interface (enables retrying operations) 2920func (client VirtualNetworkClient) deleteNetworkSecurityGroup(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 2921 httpRequest, err := request.HTTPRequest(http.MethodDelete, "/networkSecurityGroups/{networkSecurityGroupId}") 2922 if err != nil { 2923 return nil, err 2924 } 2925 2926 var response DeleteNetworkSecurityGroupResponse 2927 var httpResponse *http.Response 2928 httpResponse, err = client.Call(ctx, &httpRequest) 2929 defer common.CloseBodyIfValid(httpResponse) 2930 response.RawResponse = httpResponse 2931 if err != nil { 2932 return response, err 2933 } 2934 2935 err = common.UnmarshalResponse(httpResponse, &response) 2936 return response, err 2937} 2938 2939// DeletePrivateIp Unassigns and deletes the specified private IP. You must 2940// specify the object's OCID. The private IP address is returned to 2941// the subnet's pool of available addresses. 2942// This operation cannot be used with primary private IPs, which are 2943// automatically unassigned and deleted when the VNIC is terminated. 2944// **Important:** If a secondary private IP is the 2945// target of a route rule (https://docs.cloud.oracle.com/Content/Network/Tasks/managingroutetables.htm#privateip), 2946// unassigning it from the VNIC causes that route rule to blackhole and the traffic 2947// will be dropped. 2948func (client VirtualNetworkClient) DeletePrivateIp(ctx context.Context, request DeletePrivateIpRequest) (response DeletePrivateIpResponse, err error) { 2949 var ociResponse common.OCIResponse 2950 policy := common.NoRetryPolicy() 2951 if request.RetryPolicy() != nil { 2952 policy = *request.RetryPolicy() 2953 } 2954 ociResponse, err = common.Retry(ctx, request, client.deletePrivateIp, policy) 2955 if err != nil { 2956 if ociResponse != nil { 2957 response = DeletePrivateIpResponse{RawResponse: ociResponse.HTTPResponse()} 2958 } 2959 return 2960 } 2961 if convertedResponse, ok := ociResponse.(DeletePrivateIpResponse); ok { 2962 response = convertedResponse 2963 } else { 2964 err = fmt.Errorf("failed to convert OCIResponse into DeletePrivateIpResponse") 2965 } 2966 return 2967} 2968 2969// deletePrivateIp implements the OCIOperation interface (enables retrying operations) 2970func (client VirtualNetworkClient) deletePrivateIp(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 2971 httpRequest, err := request.HTTPRequest(http.MethodDelete, "/privateIps/{privateIpId}") 2972 if err != nil { 2973 return nil, err 2974 } 2975 2976 var response DeletePrivateIpResponse 2977 var httpResponse *http.Response 2978 httpResponse, err = client.Call(ctx, &httpRequest) 2979 defer common.CloseBodyIfValid(httpResponse) 2980 response.RawResponse = httpResponse 2981 if err != nil { 2982 return response, err 2983 } 2984 2985 err = common.UnmarshalResponse(httpResponse, &response) 2986 return response, err 2987} 2988 2989// DeletePublicIp Unassigns and deletes the specified public IP (either ephemeral or reserved). 2990// You must specify the object's OCID. The public IP address is returned to the 2991// Oracle Cloud Infrastructure public IP pool. 2992// **Note:** You cannot update, unassign, or delete the public IP that Oracle automatically 2993// assigned to an entity for you (such as a load balancer or NAT gateway). The public IP is 2994// automatically deleted if the assigned entity is terminated. 2995// For an assigned reserved public IP, the initial unassignment portion of this operation 2996// is asynchronous. Poll the public IP's `lifecycleState` to determine 2997// if the operation succeeded. 2998// If you want to simply unassign a reserved public IP and return it to your pool 2999// of reserved public IPs, instead use 3000// UpdatePublicIp. 3001func (client VirtualNetworkClient) DeletePublicIp(ctx context.Context, request DeletePublicIpRequest) (response DeletePublicIpResponse, err error) { 3002 var ociResponse common.OCIResponse 3003 policy := common.NoRetryPolicy() 3004 if request.RetryPolicy() != nil { 3005 policy = *request.RetryPolicy() 3006 } 3007 ociResponse, err = common.Retry(ctx, request, client.deletePublicIp, policy) 3008 if err != nil { 3009 if ociResponse != nil { 3010 response = DeletePublicIpResponse{RawResponse: ociResponse.HTTPResponse()} 3011 } 3012 return 3013 } 3014 if convertedResponse, ok := ociResponse.(DeletePublicIpResponse); ok { 3015 response = convertedResponse 3016 } else { 3017 err = fmt.Errorf("failed to convert OCIResponse into DeletePublicIpResponse") 3018 } 3019 return 3020} 3021 3022// deletePublicIp implements the OCIOperation interface (enables retrying operations) 3023func (client VirtualNetworkClient) deletePublicIp(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 3024 httpRequest, err := request.HTTPRequest(http.MethodDelete, "/publicIps/{publicIpId}") 3025 if err != nil { 3026 return nil, err 3027 } 3028 3029 var response DeletePublicIpResponse 3030 var httpResponse *http.Response 3031 httpResponse, err = client.Call(ctx, &httpRequest) 3032 defer common.CloseBodyIfValid(httpResponse) 3033 response.RawResponse = httpResponse 3034 if err != nil { 3035 return response, err 3036 } 3037 3038 err = common.UnmarshalResponse(httpResponse, &response) 3039 return response, err 3040} 3041 3042// DeleteRemotePeeringConnection Deletes the remote peering connection (RPC). 3043// This is an asynchronous operation; the RPC's `lifecycleState` changes to TERMINATING temporarily 3044// until the RPC is completely removed. 3045func (client VirtualNetworkClient) DeleteRemotePeeringConnection(ctx context.Context, request DeleteRemotePeeringConnectionRequest) (response DeleteRemotePeeringConnectionResponse, err error) { 3046 var ociResponse common.OCIResponse 3047 policy := common.NoRetryPolicy() 3048 if request.RetryPolicy() != nil { 3049 policy = *request.RetryPolicy() 3050 } 3051 ociResponse, err = common.Retry(ctx, request, client.deleteRemotePeeringConnection, policy) 3052 if err != nil { 3053 if ociResponse != nil { 3054 response = DeleteRemotePeeringConnectionResponse{RawResponse: ociResponse.HTTPResponse()} 3055 } 3056 return 3057 } 3058 if convertedResponse, ok := ociResponse.(DeleteRemotePeeringConnectionResponse); ok { 3059 response = convertedResponse 3060 } else { 3061 err = fmt.Errorf("failed to convert OCIResponse into DeleteRemotePeeringConnectionResponse") 3062 } 3063 return 3064} 3065 3066// deleteRemotePeeringConnection implements the OCIOperation interface (enables retrying operations) 3067func (client VirtualNetworkClient) deleteRemotePeeringConnection(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 3068 httpRequest, err := request.HTTPRequest(http.MethodDelete, "/remotePeeringConnections/{remotePeeringConnectionId}") 3069 if err != nil { 3070 return nil, err 3071 } 3072 3073 var response DeleteRemotePeeringConnectionResponse 3074 var httpResponse *http.Response 3075 httpResponse, err = client.Call(ctx, &httpRequest) 3076 defer common.CloseBodyIfValid(httpResponse) 3077 response.RawResponse = httpResponse 3078 if err != nil { 3079 return response, err 3080 } 3081 3082 err = common.UnmarshalResponse(httpResponse, &response) 3083 return response, err 3084} 3085 3086// DeleteRouteTable Deletes the specified route table, but only if it's not associated with a subnet. You can't delete a 3087// VCN's default route table. 3088// This is an asynchronous operation. The route table's `lifecycleState` will change to TERMINATING temporarily 3089// until the route table is completely removed. 3090func (client VirtualNetworkClient) DeleteRouteTable(ctx context.Context, request DeleteRouteTableRequest) (response DeleteRouteTableResponse, err error) { 3091 var ociResponse common.OCIResponse 3092 policy := common.NoRetryPolicy() 3093 if request.RetryPolicy() != nil { 3094 policy = *request.RetryPolicy() 3095 } 3096 ociResponse, err = common.Retry(ctx, request, client.deleteRouteTable, policy) 3097 if err != nil { 3098 if ociResponse != nil { 3099 response = DeleteRouteTableResponse{RawResponse: ociResponse.HTTPResponse()} 3100 } 3101 return 3102 } 3103 if convertedResponse, ok := ociResponse.(DeleteRouteTableResponse); ok { 3104 response = convertedResponse 3105 } else { 3106 err = fmt.Errorf("failed to convert OCIResponse into DeleteRouteTableResponse") 3107 } 3108 return 3109} 3110 3111// deleteRouteTable implements the OCIOperation interface (enables retrying operations) 3112func (client VirtualNetworkClient) deleteRouteTable(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 3113 httpRequest, err := request.HTTPRequest(http.MethodDelete, "/routeTables/{rtId}") 3114 if err != nil { 3115 return nil, err 3116 } 3117 3118 var response DeleteRouteTableResponse 3119 var httpResponse *http.Response 3120 httpResponse, err = client.Call(ctx, &httpRequest) 3121 defer common.CloseBodyIfValid(httpResponse) 3122 response.RawResponse = httpResponse 3123 if err != nil { 3124 return response, err 3125 } 3126 3127 err = common.UnmarshalResponse(httpResponse, &response) 3128 return response, err 3129} 3130 3131// DeleteSecurityList Deletes the specified security list, but only if it's not associated with a subnet. You can't delete 3132// a VCN's default security list. 3133// This is an asynchronous operation. The security list's `lifecycleState` will change to TERMINATING temporarily 3134// until the security list is completely removed. 3135func (client VirtualNetworkClient) DeleteSecurityList(ctx context.Context, request DeleteSecurityListRequest) (response DeleteSecurityListResponse, err error) { 3136 var ociResponse common.OCIResponse 3137 policy := common.NoRetryPolicy() 3138 if request.RetryPolicy() != nil { 3139 policy = *request.RetryPolicy() 3140 } 3141 ociResponse, err = common.Retry(ctx, request, client.deleteSecurityList, policy) 3142 if err != nil { 3143 if ociResponse != nil { 3144 response = DeleteSecurityListResponse{RawResponse: ociResponse.HTTPResponse()} 3145 } 3146 return 3147 } 3148 if convertedResponse, ok := ociResponse.(DeleteSecurityListResponse); ok { 3149 response = convertedResponse 3150 } else { 3151 err = fmt.Errorf("failed to convert OCIResponse into DeleteSecurityListResponse") 3152 } 3153 return 3154} 3155 3156// deleteSecurityList implements the OCIOperation interface (enables retrying operations) 3157func (client VirtualNetworkClient) deleteSecurityList(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 3158 httpRequest, err := request.HTTPRequest(http.MethodDelete, "/securityLists/{securityListId}") 3159 if err != nil { 3160 return nil, err 3161 } 3162 3163 var response DeleteSecurityListResponse 3164 var httpResponse *http.Response 3165 httpResponse, err = client.Call(ctx, &httpRequest) 3166 defer common.CloseBodyIfValid(httpResponse) 3167 response.RawResponse = httpResponse 3168 if err != nil { 3169 return response, err 3170 } 3171 3172 err = common.UnmarshalResponse(httpResponse, &response) 3173 return response, err 3174} 3175 3176// DeleteServiceGateway Deletes the specified service gateway. There must not be a route table that lists the service 3177// gateway as a target. 3178func (client VirtualNetworkClient) DeleteServiceGateway(ctx context.Context, request DeleteServiceGatewayRequest) (response DeleteServiceGatewayResponse, err error) { 3179 var ociResponse common.OCIResponse 3180 policy := common.NoRetryPolicy() 3181 if request.RetryPolicy() != nil { 3182 policy = *request.RetryPolicy() 3183 } 3184 ociResponse, err = common.Retry(ctx, request, client.deleteServiceGateway, policy) 3185 if err != nil { 3186 if ociResponse != nil { 3187 response = DeleteServiceGatewayResponse{RawResponse: ociResponse.HTTPResponse()} 3188 } 3189 return 3190 } 3191 if convertedResponse, ok := ociResponse.(DeleteServiceGatewayResponse); ok { 3192 response = convertedResponse 3193 } else { 3194 err = fmt.Errorf("failed to convert OCIResponse into DeleteServiceGatewayResponse") 3195 } 3196 return 3197} 3198 3199// deleteServiceGateway implements the OCIOperation interface (enables retrying operations) 3200func (client VirtualNetworkClient) deleteServiceGateway(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 3201 httpRequest, err := request.HTTPRequest(http.MethodDelete, "/serviceGateways/{serviceGatewayId}") 3202 if err != nil { 3203 return nil, err 3204 } 3205 3206 var response DeleteServiceGatewayResponse 3207 var httpResponse *http.Response 3208 httpResponse, err = client.Call(ctx, &httpRequest) 3209 defer common.CloseBodyIfValid(httpResponse) 3210 response.RawResponse = httpResponse 3211 if err != nil { 3212 return response, err 3213 } 3214 3215 err = common.UnmarshalResponse(httpResponse, &response) 3216 return response, err 3217} 3218 3219// DeleteSubnet Deletes the specified subnet, but only if there are no instances in the subnet. This is an asynchronous 3220// operation. The subnet's `lifecycleState` will change to TERMINATING temporarily. If there are any 3221// instances in the subnet, the state will instead change back to AVAILABLE. 3222func (client VirtualNetworkClient) DeleteSubnet(ctx context.Context, request DeleteSubnetRequest) (response DeleteSubnetResponse, err error) { 3223 var ociResponse common.OCIResponse 3224 policy := common.NoRetryPolicy() 3225 if request.RetryPolicy() != nil { 3226 policy = *request.RetryPolicy() 3227 } 3228 ociResponse, err = common.Retry(ctx, request, client.deleteSubnet, policy) 3229 if err != nil { 3230 if ociResponse != nil { 3231 response = DeleteSubnetResponse{RawResponse: ociResponse.HTTPResponse()} 3232 } 3233 return 3234 } 3235 if convertedResponse, ok := ociResponse.(DeleteSubnetResponse); ok { 3236 response = convertedResponse 3237 } else { 3238 err = fmt.Errorf("failed to convert OCIResponse into DeleteSubnetResponse") 3239 } 3240 return 3241} 3242 3243// deleteSubnet implements the OCIOperation interface (enables retrying operations) 3244func (client VirtualNetworkClient) deleteSubnet(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 3245 httpRequest, err := request.HTTPRequest(http.MethodDelete, "/subnets/{subnetId}") 3246 if err != nil { 3247 return nil, err 3248 } 3249 3250 var response DeleteSubnetResponse 3251 var httpResponse *http.Response 3252 httpResponse, err = client.Call(ctx, &httpRequest) 3253 defer common.CloseBodyIfValid(httpResponse) 3254 response.RawResponse = httpResponse 3255 if err != nil { 3256 return response, err 3257 } 3258 3259 err = common.UnmarshalResponse(httpResponse, &response) 3260 return response, err 3261} 3262 3263// DeleteVcn Deletes the specified VCN. The VCN must be empty and have no attached gateways. This is an asynchronous 3264// operation. The VCN's `lifecycleState` will change to TERMINATING temporarily until the VCN is completely 3265// removed. 3266func (client VirtualNetworkClient) DeleteVcn(ctx context.Context, request DeleteVcnRequest) (response DeleteVcnResponse, err error) { 3267 var ociResponse common.OCIResponse 3268 policy := common.NoRetryPolicy() 3269 if request.RetryPolicy() != nil { 3270 policy = *request.RetryPolicy() 3271 } 3272 ociResponse, err = common.Retry(ctx, request, client.deleteVcn, policy) 3273 if err != nil { 3274 if ociResponse != nil { 3275 response = DeleteVcnResponse{RawResponse: ociResponse.HTTPResponse()} 3276 } 3277 return 3278 } 3279 if convertedResponse, ok := ociResponse.(DeleteVcnResponse); ok { 3280 response = convertedResponse 3281 } else { 3282 err = fmt.Errorf("failed to convert OCIResponse into DeleteVcnResponse") 3283 } 3284 return 3285} 3286 3287// deleteVcn implements the OCIOperation interface (enables retrying operations) 3288func (client VirtualNetworkClient) deleteVcn(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 3289 httpRequest, err := request.HTTPRequest(http.MethodDelete, "/vcns/{vcnId}") 3290 if err != nil { 3291 return nil, err 3292 } 3293 3294 var response DeleteVcnResponse 3295 var httpResponse *http.Response 3296 httpResponse, err = client.Call(ctx, &httpRequest) 3297 defer common.CloseBodyIfValid(httpResponse) 3298 response.RawResponse = httpResponse 3299 if err != nil { 3300 return response, err 3301 } 3302 3303 err = common.UnmarshalResponse(httpResponse, &response) 3304 return response, err 3305} 3306 3307// DeleteVirtualCircuit Deletes the specified virtual circuit. 3308// **Important:** If you're using FastConnect via a provider, 3309// make sure to also terminate the connection with 3310// the provider, or else the provider may continue to bill you. 3311func (client VirtualNetworkClient) DeleteVirtualCircuit(ctx context.Context, request DeleteVirtualCircuitRequest) (response DeleteVirtualCircuitResponse, err error) { 3312 var ociResponse common.OCIResponse 3313 policy := common.NoRetryPolicy() 3314 if request.RetryPolicy() != nil { 3315 policy = *request.RetryPolicy() 3316 } 3317 ociResponse, err = common.Retry(ctx, request, client.deleteVirtualCircuit, policy) 3318 if err != nil { 3319 if ociResponse != nil { 3320 response = DeleteVirtualCircuitResponse{RawResponse: ociResponse.HTTPResponse()} 3321 } 3322 return 3323 } 3324 if convertedResponse, ok := ociResponse.(DeleteVirtualCircuitResponse); ok { 3325 response = convertedResponse 3326 } else { 3327 err = fmt.Errorf("failed to convert OCIResponse into DeleteVirtualCircuitResponse") 3328 } 3329 return 3330} 3331 3332// deleteVirtualCircuit implements the OCIOperation interface (enables retrying operations) 3333func (client VirtualNetworkClient) deleteVirtualCircuit(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 3334 httpRequest, err := request.HTTPRequest(http.MethodDelete, "/virtualCircuits/{virtualCircuitId}") 3335 if err != nil { 3336 return nil, err 3337 } 3338 3339 var response DeleteVirtualCircuitResponse 3340 var httpResponse *http.Response 3341 httpResponse, err = client.Call(ctx, &httpRequest) 3342 defer common.CloseBodyIfValid(httpResponse) 3343 response.RawResponse = httpResponse 3344 if err != nil { 3345 return response, err 3346 } 3347 3348 err = common.UnmarshalResponse(httpResponse, &response) 3349 return response, err 3350} 3351 3352// DetachServiceId Removes the specified Service from the list of enabled 3353// `Service` objects for the specified gateway. You do not need to remove any route 3354// rules that specify this `Service` object's `cidrBlock` as the destination CIDR. However, consider 3355// removing the rules if your intent is to permanently disable use of the `Service` through this 3356// service gateway. 3357// **Note:** The `DetachServiceId` operation is an easy way to remove an individual `Service` from 3358// the service gateway. Compare it with 3359// UpdateServiceGateway, which replaces 3360// the entire existing list of enabled `Service` objects with the list that you provide in the 3361// `Update` call. `UpdateServiceGateway` also lets you block all traffic through the service 3362// gateway without having to remove each of the individual `Service` objects. 3363func (client VirtualNetworkClient) DetachServiceId(ctx context.Context, request DetachServiceIdRequest) (response DetachServiceIdResponse, err error) { 3364 var ociResponse common.OCIResponse 3365 policy := common.NoRetryPolicy() 3366 if request.RetryPolicy() != nil { 3367 policy = *request.RetryPolicy() 3368 } 3369 ociResponse, err = common.Retry(ctx, request, client.detachServiceId, policy) 3370 if err != nil { 3371 if ociResponse != nil { 3372 response = DetachServiceIdResponse{RawResponse: ociResponse.HTTPResponse()} 3373 } 3374 return 3375 } 3376 if convertedResponse, ok := ociResponse.(DetachServiceIdResponse); ok { 3377 response = convertedResponse 3378 } else { 3379 err = fmt.Errorf("failed to convert OCIResponse into DetachServiceIdResponse") 3380 } 3381 return 3382} 3383 3384// detachServiceId implements the OCIOperation interface (enables retrying operations) 3385func (client VirtualNetworkClient) detachServiceId(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 3386 httpRequest, err := request.HTTPRequest(http.MethodPost, "/serviceGateways/{serviceGatewayId}/actions/detachService") 3387 if err != nil { 3388 return nil, err 3389 } 3390 3391 var response DetachServiceIdResponse 3392 var httpResponse *http.Response 3393 httpResponse, err = client.Call(ctx, &httpRequest) 3394 defer common.CloseBodyIfValid(httpResponse) 3395 response.RawResponse = httpResponse 3396 if err != nil { 3397 return response, err 3398 } 3399 3400 err = common.UnmarshalResponse(httpResponse, &response) 3401 return response, err 3402} 3403 3404// GetCpe Gets the specified CPE's information. 3405func (client VirtualNetworkClient) GetCpe(ctx context.Context, request GetCpeRequest) (response GetCpeResponse, err error) { 3406 var ociResponse common.OCIResponse 3407 policy := common.NoRetryPolicy() 3408 if request.RetryPolicy() != nil { 3409 policy = *request.RetryPolicy() 3410 } 3411 ociResponse, err = common.Retry(ctx, request, client.getCpe, policy) 3412 if err != nil { 3413 if ociResponse != nil { 3414 response = GetCpeResponse{RawResponse: ociResponse.HTTPResponse()} 3415 } 3416 return 3417 } 3418 if convertedResponse, ok := ociResponse.(GetCpeResponse); ok { 3419 response = convertedResponse 3420 } else { 3421 err = fmt.Errorf("failed to convert OCIResponse into GetCpeResponse") 3422 } 3423 return 3424} 3425 3426// getCpe implements the OCIOperation interface (enables retrying operations) 3427func (client VirtualNetworkClient) getCpe(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 3428 httpRequest, err := request.HTTPRequest(http.MethodGet, "/cpes/{cpeId}") 3429 if err != nil { 3430 return nil, err 3431 } 3432 3433 var response GetCpeResponse 3434 var httpResponse *http.Response 3435 httpResponse, err = client.Call(ctx, &httpRequest) 3436 defer common.CloseBodyIfValid(httpResponse) 3437 response.RawResponse = httpResponse 3438 if err != nil { 3439 return response, err 3440 } 3441 3442 err = common.UnmarshalResponse(httpResponse, &response) 3443 return response, err 3444} 3445 3446// GetCrossConnect Gets the specified cross-connect's information. 3447func (client VirtualNetworkClient) GetCrossConnect(ctx context.Context, request GetCrossConnectRequest) (response GetCrossConnectResponse, err error) { 3448 var ociResponse common.OCIResponse 3449 policy := common.NoRetryPolicy() 3450 if request.RetryPolicy() != nil { 3451 policy = *request.RetryPolicy() 3452 } 3453 ociResponse, err = common.Retry(ctx, request, client.getCrossConnect, policy) 3454 if err != nil { 3455 if ociResponse != nil { 3456 response = GetCrossConnectResponse{RawResponse: ociResponse.HTTPResponse()} 3457 } 3458 return 3459 } 3460 if convertedResponse, ok := ociResponse.(GetCrossConnectResponse); ok { 3461 response = convertedResponse 3462 } else { 3463 err = fmt.Errorf("failed to convert OCIResponse into GetCrossConnectResponse") 3464 } 3465 return 3466} 3467 3468// getCrossConnect implements the OCIOperation interface (enables retrying operations) 3469func (client VirtualNetworkClient) getCrossConnect(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 3470 httpRequest, err := request.HTTPRequest(http.MethodGet, "/crossConnects/{crossConnectId}") 3471 if err != nil { 3472 return nil, err 3473 } 3474 3475 var response GetCrossConnectResponse 3476 var httpResponse *http.Response 3477 httpResponse, err = client.Call(ctx, &httpRequest) 3478 defer common.CloseBodyIfValid(httpResponse) 3479 response.RawResponse = httpResponse 3480 if err != nil { 3481 return response, err 3482 } 3483 3484 err = common.UnmarshalResponse(httpResponse, &response) 3485 return response, err 3486} 3487 3488// GetCrossConnectGroup Gets the specified cross-connect group's information. 3489func (client VirtualNetworkClient) GetCrossConnectGroup(ctx context.Context, request GetCrossConnectGroupRequest) (response GetCrossConnectGroupResponse, err error) { 3490 var ociResponse common.OCIResponse 3491 policy := common.NoRetryPolicy() 3492 if request.RetryPolicy() != nil { 3493 policy = *request.RetryPolicy() 3494 } 3495 ociResponse, err = common.Retry(ctx, request, client.getCrossConnectGroup, policy) 3496 if err != nil { 3497 if ociResponse != nil { 3498 response = GetCrossConnectGroupResponse{RawResponse: ociResponse.HTTPResponse()} 3499 } 3500 return 3501 } 3502 if convertedResponse, ok := ociResponse.(GetCrossConnectGroupResponse); ok { 3503 response = convertedResponse 3504 } else { 3505 err = fmt.Errorf("failed to convert OCIResponse into GetCrossConnectGroupResponse") 3506 } 3507 return 3508} 3509 3510// getCrossConnectGroup implements the OCIOperation interface (enables retrying operations) 3511func (client VirtualNetworkClient) getCrossConnectGroup(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 3512 httpRequest, err := request.HTTPRequest(http.MethodGet, "/crossConnectGroups/{crossConnectGroupId}") 3513 if err != nil { 3514 return nil, err 3515 } 3516 3517 var response GetCrossConnectGroupResponse 3518 var httpResponse *http.Response 3519 httpResponse, err = client.Call(ctx, &httpRequest) 3520 defer common.CloseBodyIfValid(httpResponse) 3521 response.RawResponse = httpResponse 3522 if err != nil { 3523 return response, err 3524 } 3525 3526 err = common.UnmarshalResponse(httpResponse, &response) 3527 return response, err 3528} 3529 3530// GetCrossConnectLetterOfAuthority Gets the Letter of Authority for the specified cross-connect. 3531func (client VirtualNetworkClient) GetCrossConnectLetterOfAuthority(ctx context.Context, request GetCrossConnectLetterOfAuthorityRequest) (response GetCrossConnectLetterOfAuthorityResponse, err error) { 3532 var ociResponse common.OCIResponse 3533 policy := common.NoRetryPolicy() 3534 if request.RetryPolicy() != nil { 3535 policy = *request.RetryPolicy() 3536 } 3537 ociResponse, err = common.Retry(ctx, request, client.getCrossConnectLetterOfAuthority, policy) 3538 if err != nil { 3539 if ociResponse != nil { 3540 response = GetCrossConnectLetterOfAuthorityResponse{RawResponse: ociResponse.HTTPResponse()} 3541 } 3542 return 3543 } 3544 if convertedResponse, ok := ociResponse.(GetCrossConnectLetterOfAuthorityResponse); ok { 3545 response = convertedResponse 3546 } else { 3547 err = fmt.Errorf("failed to convert OCIResponse into GetCrossConnectLetterOfAuthorityResponse") 3548 } 3549 return 3550} 3551 3552// getCrossConnectLetterOfAuthority implements the OCIOperation interface (enables retrying operations) 3553func (client VirtualNetworkClient) getCrossConnectLetterOfAuthority(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 3554 httpRequest, err := request.HTTPRequest(http.MethodGet, "/crossConnects/{crossConnectId}/letterOfAuthority") 3555 if err != nil { 3556 return nil, err 3557 } 3558 3559 var response GetCrossConnectLetterOfAuthorityResponse 3560 var httpResponse *http.Response 3561 httpResponse, err = client.Call(ctx, &httpRequest) 3562 defer common.CloseBodyIfValid(httpResponse) 3563 response.RawResponse = httpResponse 3564 if err != nil { 3565 return response, err 3566 } 3567 3568 err = common.UnmarshalResponse(httpResponse, &response) 3569 return response, err 3570} 3571 3572// GetCrossConnectStatus Gets the status of the specified cross-connect. 3573func (client VirtualNetworkClient) GetCrossConnectStatus(ctx context.Context, request GetCrossConnectStatusRequest) (response GetCrossConnectStatusResponse, err error) { 3574 var ociResponse common.OCIResponse 3575 policy := common.NoRetryPolicy() 3576 if request.RetryPolicy() != nil { 3577 policy = *request.RetryPolicy() 3578 } 3579 ociResponse, err = common.Retry(ctx, request, client.getCrossConnectStatus, policy) 3580 if err != nil { 3581 if ociResponse != nil { 3582 response = GetCrossConnectStatusResponse{RawResponse: ociResponse.HTTPResponse()} 3583 } 3584 return 3585 } 3586 if convertedResponse, ok := ociResponse.(GetCrossConnectStatusResponse); ok { 3587 response = convertedResponse 3588 } else { 3589 err = fmt.Errorf("failed to convert OCIResponse into GetCrossConnectStatusResponse") 3590 } 3591 return 3592} 3593 3594// getCrossConnectStatus implements the OCIOperation interface (enables retrying operations) 3595func (client VirtualNetworkClient) getCrossConnectStatus(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 3596 httpRequest, err := request.HTTPRequest(http.MethodGet, "/crossConnects/{crossConnectId}/status") 3597 if err != nil { 3598 return nil, err 3599 } 3600 3601 var response GetCrossConnectStatusResponse 3602 var httpResponse *http.Response 3603 httpResponse, err = client.Call(ctx, &httpRequest) 3604 defer common.CloseBodyIfValid(httpResponse) 3605 response.RawResponse = httpResponse 3606 if err != nil { 3607 return response, err 3608 } 3609 3610 err = common.UnmarshalResponse(httpResponse, &response) 3611 return response, err 3612} 3613 3614// GetDhcpOptions Gets the specified set of DHCP options. 3615func (client VirtualNetworkClient) GetDhcpOptions(ctx context.Context, request GetDhcpOptionsRequest) (response GetDhcpOptionsResponse, err error) { 3616 var ociResponse common.OCIResponse 3617 policy := common.NoRetryPolicy() 3618 if request.RetryPolicy() != nil { 3619 policy = *request.RetryPolicy() 3620 } 3621 ociResponse, err = common.Retry(ctx, request, client.getDhcpOptions, policy) 3622 if err != nil { 3623 if ociResponse != nil { 3624 response = GetDhcpOptionsResponse{RawResponse: ociResponse.HTTPResponse()} 3625 } 3626 return 3627 } 3628 if convertedResponse, ok := ociResponse.(GetDhcpOptionsResponse); ok { 3629 response = convertedResponse 3630 } else { 3631 err = fmt.Errorf("failed to convert OCIResponse into GetDhcpOptionsResponse") 3632 } 3633 return 3634} 3635 3636// getDhcpOptions implements the OCIOperation interface (enables retrying operations) 3637func (client VirtualNetworkClient) getDhcpOptions(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 3638 httpRequest, err := request.HTTPRequest(http.MethodGet, "/dhcps/{dhcpId}") 3639 if err != nil { 3640 return nil, err 3641 } 3642 3643 var response GetDhcpOptionsResponse 3644 var httpResponse *http.Response 3645 httpResponse, err = client.Call(ctx, &httpRequest) 3646 defer common.CloseBodyIfValid(httpResponse) 3647 response.RawResponse = httpResponse 3648 if err != nil { 3649 return response, err 3650 } 3651 3652 err = common.UnmarshalResponse(httpResponse, &response) 3653 return response, err 3654} 3655 3656// GetDrg Gets the specified DRG's information. 3657func (client VirtualNetworkClient) GetDrg(ctx context.Context, request GetDrgRequest) (response GetDrgResponse, err error) { 3658 var ociResponse common.OCIResponse 3659 policy := common.NoRetryPolicy() 3660 if request.RetryPolicy() != nil { 3661 policy = *request.RetryPolicy() 3662 } 3663 ociResponse, err = common.Retry(ctx, request, client.getDrg, policy) 3664 if err != nil { 3665 if ociResponse != nil { 3666 response = GetDrgResponse{RawResponse: ociResponse.HTTPResponse()} 3667 } 3668 return 3669 } 3670 if convertedResponse, ok := ociResponse.(GetDrgResponse); ok { 3671 response = convertedResponse 3672 } else { 3673 err = fmt.Errorf("failed to convert OCIResponse into GetDrgResponse") 3674 } 3675 return 3676} 3677 3678// getDrg implements the OCIOperation interface (enables retrying operations) 3679func (client VirtualNetworkClient) getDrg(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 3680 httpRequest, err := request.HTTPRequest(http.MethodGet, "/drgs/{drgId}") 3681 if err != nil { 3682 return nil, err 3683 } 3684 3685 var response GetDrgResponse 3686 var httpResponse *http.Response 3687 httpResponse, err = client.Call(ctx, &httpRequest) 3688 defer common.CloseBodyIfValid(httpResponse) 3689 response.RawResponse = httpResponse 3690 if err != nil { 3691 return response, err 3692 } 3693 3694 err = common.UnmarshalResponse(httpResponse, &response) 3695 return response, err 3696} 3697 3698// GetDrgAttachment Gets the information for the specified `DrgAttachment`. 3699func (client VirtualNetworkClient) GetDrgAttachment(ctx context.Context, request GetDrgAttachmentRequest) (response GetDrgAttachmentResponse, err error) { 3700 var ociResponse common.OCIResponse 3701 policy := common.NoRetryPolicy() 3702 if request.RetryPolicy() != nil { 3703 policy = *request.RetryPolicy() 3704 } 3705 ociResponse, err = common.Retry(ctx, request, client.getDrgAttachment, policy) 3706 if err != nil { 3707 if ociResponse != nil { 3708 response = GetDrgAttachmentResponse{RawResponse: ociResponse.HTTPResponse()} 3709 } 3710 return 3711 } 3712 if convertedResponse, ok := ociResponse.(GetDrgAttachmentResponse); ok { 3713 response = convertedResponse 3714 } else { 3715 err = fmt.Errorf("failed to convert OCIResponse into GetDrgAttachmentResponse") 3716 } 3717 return 3718} 3719 3720// getDrgAttachment implements the OCIOperation interface (enables retrying operations) 3721func (client VirtualNetworkClient) getDrgAttachment(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 3722 httpRequest, err := request.HTTPRequest(http.MethodGet, "/drgAttachments/{drgAttachmentId}") 3723 if err != nil { 3724 return nil, err 3725 } 3726 3727 var response GetDrgAttachmentResponse 3728 var httpResponse *http.Response 3729 httpResponse, err = client.Call(ctx, &httpRequest) 3730 defer common.CloseBodyIfValid(httpResponse) 3731 response.RawResponse = httpResponse 3732 if err != nil { 3733 return response, err 3734 } 3735 3736 err = common.UnmarshalResponse(httpResponse, &response) 3737 return response, err 3738} 3739 3740// GetFastConnectProviderService Gets the specified provider service. 3741// For more information, see FastConnect Overview (https://docs.cloud.oracle.com/Content/Network/Concepts/fastconnect.htm). 3742func (client VirtualNetworkClient) GetFastConnectProviderService(ctx context.Context, request GetFastConnectProviderServiceRequest) (response GetFastConnectProviderServiceResponse, err error) { 3743 var ociResponse common.OCIResponse 3744 policy := common.NoRetryPolicy() 3745 if request.RetryPolicy() != nil { 3746 policy = *request.RetryPolicy() 3747 } 3748 ociResponse, err = common.Retry(ctx, request, client.getFastConnectProviderService, policy) 3749 if err != nil { 3750 if ociResponse != nil { 3751 response = GetFastConnectProviderServiceResponse{RawResponse: ociResponse.HTTPResponse()} 3752 } 3753 return 3754 } 3755 if convertedResponse, ok := ociResponse.(GetFastConnectProviderServiceResponse); ok { 3756 response = convertedResponse 3757 } else { 3758 err = fmt.Errorf("failed to convert OCIResponse into GetFastConnectProviderServiceResponse") 3759 } 3760 return 3761} 3762 3763// getFastConnectProviderService implements the OCIOperation interface (enables retrying operations) 3764func (client VirtualNetworkClient) getFastConnectProviderService(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 3765 httpRequest, err := request.HTTPRequest(http.MethodGet, "/fastConnectProviderServices/{providerServiceId}") 3766 if err != nil { 3767 return nil, err 3768 } 3769 3770 var response GetFastConnectProviderServiceResponse 3771 var httpResponse *http.Response 3772 httpResponse, err = client.Call(ctx, &httpRequest) 3773 defer common.CloseBodyIfValid(httpResponse) 3774 response.RawResponse = httpResponse 3775 if err != nil { 3776 return response, err 3777 } 3778 3779 err = common.UnmarshalResponse(httpResponse, &response) 3780 return response, err 3781} 3782 3783// GetFastConnectProviderServiceKey Gets the specified provider service key's information. Use this operation to validate a 3784// provider service key. An invalid key returns a 404 error. 3785func (client VirtualNetworkClient) GetFastConnectProviderServiceKey(ctx context.Context, request GetFastConnectProviderServiceKeyRequest) (response GetFastConnectProviderServiceKeyResponse, err error) { 3786 var ociResponse common.OCIResponse 3787 policy := common.NoRetryPolicy() 3788 if request.RetryPolicy() != nil { 3789 policy = *request.RetryPolicy() 3790 } 3791 ociResponse, err = common.Retry(ctx, request, client.getFastConnectProviderServiceKey, policy) 3792 if err != nil { 3793 if ociResponse != nil { 3794 response = GetFastConnectProviderServiceKeyResponse{RawResponse: ociResponse.HTTPResponse()} 3795 } 3796 return 3797 } 3798 if convertedResponse, ok := ociResponse.(GetFastConnectProviderServiceKeyResponse); ok { 3799 response = convertedResponse 3800 } else { 3801 err = fmt.Errorf("failed to convert OCIResponse into GetFastConnectProviderServiceKeyResponse") 3802 } 3803 return 3804} 3805 3806// getFastConnectProviderServiceKey implements the OCIOperation interface (enables retrying operations) 3807func (client VirtualNetworkClient) getFastConnectProviderServiceKey(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 3808 httpRequest, err := request.HTTPRequest(http.MethodGet, "/fastConnectProviderServices/{providerServiceId}/providerServiceKeys/{providerServiceKeyName}") 3809 if err != nil { 3810 return nil, err 3811 } 3812 3813 var response GetFastConnectProviderServiceKeyResponse 3814 var httpResponse *http.Response 3815 httpResponse, err = client.Call(ctx, &httpRequest) 3816 defer common.CloseBodyIfValid(httpResponse) 3817 response.RawResponse = httpResponse 3818 if err != nil { 3819 return response, err 3820 } 3821 3822 err = common.UnmarshalResponse(httpResponse, &response) 3823 return response, err 3824} 3825 3826// GetIPSecConnection Gets the specified IPSec connection's basic information, including the static routes for the 3827// on-premises router. If you want the status of the connection (whether it's up or down), use 3828// GetIPSecConnectionTunnel. 3829func (client VirtualNetworkClient) GetIPSecConnection(ctx context.Context, request GetIPSecConnectionRequest) (response GetIPSecConnectionResponse, err error) { 3830 var ociResponse common.OCIResponse 3831 policy := common.NoRetryPolicy() 3832 if request.RetryPolicy() != nil { 3833 policy = *request.RetryPolicy() 3834 } 3835 ociResponse, err = common.Retry(ctx, request, client.getIPSecConnection, policy) 3836 if err != nil { 3837 if ociResponse != nil { 3838 response = GetIPSecConnectionResponse{RawResponse: ociResponse.HTTPResponse()} 3839 } 3840 return 3841 } 3842 if convertedResponse, ok := ociResponse.(GetIPSecConnectionResponse); ok { 3843 response = convertedResponse 3844 } else { 3845 err = fmt.Errorf("failed to convert OCIResponse into GetIPSecConnectionResponse") 3846 } 3847 return 3848} 3849 3850// getIPSecConnection implements the OCIOperation interface (enables retrying operations) 3851func (client VirtualNetworkClient) getIPSecConnection(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 3852 httpRequest, err := request.HTTPRequest(http.MethodGet, "/ipsecConnections/{ipscId}") 3853 if err != nil { 3854 return nil, err 3855 } 3856 3857 var response GetIPSecConnectionResponse 3858 var httpResponse *http.Response 3859 httpResponse, err = client.Call(ctx, &httpRequest) 3860 defer common.CloseBodyIfValid(httpResponse) 3861 response.RawResponse = httpResponse 3862 if err != nil { 3863 return response, err 3864 } 3865 3866 err = common.UnmarshalResponse(httpResponse, &response) 3867 return response, err 3868} 3869 3870// GetIPSecConnectionDeviceConfig Deprecated. To get tunnel information, instead use: 3871// * GetIPSecConnectionTunnel 3872// * GetIPSecConnectionTunnelSharedSecret 3873func (client VirtualNetworkClient) GetIPSecConnectionDeviceConfig(ctx context.Context, request GetIPSecConnectionDeviceConfigRequest) (response GetIPSecConnectionDeviceConfigResponse, err error) { 3874 var ociResponse common.OCIResponse 3875 policy := common.NoRetryPolicy() 3876 if request.RetryPolicy() != nil { 3877 policy = *request.RetryPolicy() 3878 } 3879 ociResponse, err = common.Retry(ctx, request, client.getIPSecConnectionDeviceConfig, policy) 3880 if err != nil { 3881 if ociResponse != nil { 3882 response = GetIPSecConnectionDeviceConfigResponse{RawResponse: ociResponse.HTTPResponse()} 3883 } 3884 return 3885 } 3886 if convertedResponse, ok := ociResponse.(GetIPSecConnectionDeviceConfigResponse); ok { 3887 response = convertedResponse 3888 } else { 3889 err = fmt.Errorf("failed to convert OCIResponse into GetIPSecConnectionDeviceConfigResponse") 3890 } 3891 return 3892} 3893 3894// getIPSecConnectionDeviceConfig implements the OCIOperation interface (enables retrying operations) 3895func (client VirtualNetworkClient) getIPSecConnectionDeviceConfig(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 3896 httpRequest, err := request.HTTPRequest(http.MethodGet, "/ipsecConnections/{ipscId}/deviceConfig") 3897 if err != nil { 3898 return nil, err 3899 } 3900 3901 var response GetIPSecConnectionDeviceConfigResponse 3902 var httpResponse *http.Response 3903 httpResponse, err = client.Call(ctx, &httpRequest) 3904 defer common.CloseBodyIfValid(httpResponse) 3905 response.RawResponse = httpResponse 3906 if err != nil { 3907 return response, err 3908 } 3909 3910 err = common.UnmarshalResponse(httpResponse, &response) 3911 return response, err 3912} 3913 3914// GetIPSecConnectionDeviceStatus Deprecated. To get the tunnel status, instead use 3915// GetIPSecConnectionTunnel. 3916func (client VirtualNetworkClient) GetIPSecConnectionDeviceStatus(ctx context.Context, request GetIPSecConnectionDeviceStatusRequest) (response GetIPSecConnectionDeviceStatusResponse, err error) { 3917 var ociResponse common.OCIResponse 3918 policy := common.NoRetryPolicy() 3919 if request.RetryPolicy() != nil { 3920 policy = *request.RetryPolicy() 3921 } 3922 ociResponse, err = common.Retry(ctx, request, client.getIPSecConnectionDeviceStatus, policy) 3923 if err != nil { 3924 if ociResponse != nil { 3925 response = GetIPSecConnectionDeviceStatusResponse{RawResponse: ociResponse.HTTPResponse()} 3926 } 3927 return 3928 } 3929 if convertedResponse, ok := ociResponse.(GetIPSecConnectionDeviceStatusResponse); ok { 3930 response = convertedResponse 3931 } else { 3932 err = fmt.Errorf("failed to convert OCIResponse into GetIPSecConnectionDeviceStatusResponse") 3933 } 3934 return 3935} 3936 3937// getIPSecConnectionDeviceStatus implements the OCIOperation interface (enables retrying operations) 3938func (client VirtualNetworkClient) getIPSecConnectionDeviceStatus(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 3939 httpRequest, err := request.HTTPRequest(http.MethodGet, "/ipsecConnections/{ipscId}/deviceStatus") 3940 if err != nil { 3941 return nil, err 3942 } 3943 3944 var response GetIPSecConnectionDeviceStatusResponse 3945 var httpResponse *http.Response 3946 httpResponse, err = client.Call(ctx, &httpRequest) 3947 defer common.CloseBodyIfValid(httpResponse) 3948 response.RawResponse = httpResponse 3949 if err != nil { 3950 return response, err 3951 } 3952 3953 err = common.UnmarshalResponse(httpResponse, &response) 3954 return response, err 3955} 3956 3957// GetIPSecConnectionTunnel Gets the specified tunnel's information. The resulting object does not include the tunnel's 3958// shared secret (pre-shared key). To retrieve that, use 3959// GetIPSecConnectionTunnelSharedSecret. 3960func (client VirtualNetworkClient) GetIPSecConnectionTunnel(ctx context.Context, request GetIPSecConnectionTunnelRequest) (response GetIPSecConnectionTunnelResponse, err error) { 3961 var ociResponse common.OCIResponse 3962 policy := common.NoRetryPolicy() 3963 if request.RetryPolicy() != nil { 3964 policy = *request.RetryPolicy() 3965 } 3966 ociResponse, err = common.Retry(ctx, request, client.getIPSecConnectionTunnel, policy) 3967 if err != nil { 3968 if ociResponse != nil { 3969 response = GetIPSecConnectionTunnelResponse{RawResponse: ociResponse.HTTPResponse()} 3970 } 3971 return 3972 } 3973 if convertedResponse, ok := ociResponse.(GetIPSecConnectionTunnelResponse); ok { 3974 response = convertedResponse 3975 } else { 3976 err = fmt.Errorf("failed to convert OCIResponse into GetIPSecConnectionTunnelResponse") 3977 } 3978 return 3979} 3980 3981// getIPSecConnectionTunnel implements the OCIOperation interface (enables retrying operations) 3982func (client VirtualNetworkClient) getIPSecConnectionTunnel(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 3983 httpRequest, err := request.HTTPRequest(http.MethodGet, "/ipsecConnections/{ipscId}/tunnels/{tunnelId}") 3984 if err != nil { 3985 return nil, err 3986 } 3987 3988 var response GetIPSecConnectionTunnelResponse 3989 var httpResponse *http.Response 3990 httpResponse, err = client.Call(ctx, &httpRequest) 3991 defer common.CloseBodyIfValid(httpResponse) 3992 response.RawResponse = httpResponse 3993 if err != nil { 3994 return response, err 3995 } 3996 3997 err = common.UnmarshalResponse(httpResponse, &response) 3998 return response, err 3999} 4000 4001// GetIPSecConnectionTunnelSharedSecret Gets the specified tunnel's shared secret (pre-shared key). To get other information 4002// about the tunnel, use GetIPSecConnectionTunnel. 4003func (client VirtualNetworkClient) GetIPSecConnectionTunnelSharedSecret(ctx context.Context, request GetIPSecConnectionTunnelSharedSecretRequest) (response GetIPSecConnectionTunnelSharedSecretResponse, err error) { 4004 var ociResponse common.OCIResponse 4005 policy := common.NoRetryPolicy() 4006 if request.RetryPolicy() != nil { 4007 policy = *request.RetryPolicy() 4008 } 4009 ociResponse, err = common.Retry(ctx, request, client.getIPSecConnectionTunnelSharedSecret, policy) 4010 if err != nil { 4011 if ociResponse != nil { 4012 response = GetIPSecConnectionTunnelSharedSecretResponse{RawResponse: ociResponse.HTTPResponse()} 4013 } 4014 return 4015 } 4016 if convertedResponse, ok := ociResponse.(GetIPSecConnectionTunnelSharedSecretResponse); ok { 4017 response = convertedResponse 4018 } else { 4019 err = fmt.Errorf("failed to convert OCIResponse into GetIPSecConnectionTunnelSharedSecretResponse") 4020 } 4021 return 4022} 4023 4024// getIPSecConnectionTunnelSharedSecret implements the OCIOperation interface (enables retrying operations) 4025func (client VirtualNetworkClient) getIPSecConnectionTunnelSharedSecret(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 4026 httpRequest, err := request.HTTPRequest(http.MethodGet, "/ipsecConnections/{ipscId}/tunnels/{tunnelId}/sharedSecret") 4027 if err != nil { 4028 return nil, err 4029 } 4030 4031 var response GetIPSecConnectionTunnelSharedSecretResponse 4032 var httpResponse *http.Response 4033 httpResponse, err = client.Call(ctx, &httpRequest) 4034 defer common.CloseBodyIfValid(httpResponse) 4035 response.RawResponse = httpResponse 4036 if err != nil { 4037 return response, err 4038 } 4039 4040 err = common.UnmarshalResponse(httpResponse, &response) 4041 return response, err 4042} 4043 4044// GetInternetGateway Gets the specified internet gateway's information. 4045func (client VirtualNetworkClient) GetInternetGateway(ctx context.Context, request GetInternetGatewayRequest) (response GetInternetGatewayResponse, err error) { 4046 var ociResponse common.OCIResponse 4047 policy := common.NoRetryPolicy() 4048 if request.RetryPolicy() != nil { 4049 policy = *request.RetryPolicy() 4050 } 4051 ociResponse, err = common.Retry(ctx, request, client.getInternetGateway, policy) 4052 if err != nil { 4053 if ociResponse != nil { 4054 response = GetInternetGatewayResponse{RawResponse: ociResponse.HTTPResponse()} 4055 } 4056 return 4057 } 4058 if convertedResponse, ok := ociResponse.(GetInternetGatewayResponse); ok { 4059 response = convertedResponse 4060 } else { 4061 err = fmt.Errorf("failed to convert OCIResponse into GetInternetGatewayResponse") 4062 } 4063 return 4064} 4065 4066// getInternetGateway implements the OCIOperation interface (enables retrying operations) 4067func (client VirtualNetworkClient) getInternetGateway(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 4068 httpRequest, err := request.HTTPRequest(http.MethodGet, "/internetGateways/{igId}") 4069 if err != nil { 4070 return nil, err 4071 } 4072 4073 var response GetInternetGatewayResponse 4074 var httpResponse *http.Response 4075 httpResponse, err = client.Call(ctx, &httpRequest) 4076 defer common.CloseBodyIfValid(httpResponse) 4077 response.RawResponse = httpResponse 4078 if err != nil { 4079 return response, err 4080 } 4081 4082 err = common.UnmarshalResponse(httpResponse, &response) 4083 return response, err 4084} 4085 4086// GetIpv6 Gets the specified IPv6. You must specify the object's OCID. 4087// Alternatively, you can get the object by using 4088// ListIpv6s 4089// with the IPv6 address (for example, 2001:0db8:0123:1111:98fe:dcba:9876:4321) and subnet OCID. 4090func (client VirtualNetworkClient) GetIpv6(ctx context.Context, request GetIpv6Request) (response GetIpv6Response, err error) { 4091 var ociResponse common.OCIResponse 4092 policy := common.NoRetryPolicy() 4093 if request.RetryPolicy() != nil { 4094 policy = *request.RetryPolicy() 4095 } 4096 ociResponse, err = common.Retry(ctx, request, client.getIpv6, policy) 4097 if err != nil { 4098 if ociResponse != nil { 4099 response = GetIpv6Response{RawResponse: ociResponse.HTTPResponse()} 4100 } 4101 return 4102 } 4103 if convertedResponse, ok := ociResponse.(GetIpv6Response); ok { 4104 response = convertedResponse 4105 } else { 4106 err = fmt.Errorf("failed to convert OCIResponse into GetIpv6Response") 4107 } 4108 return 4109} 4110 4111// getIpv6 implements the OCIOperation interface (enables retrying operations) 4112func (client VirtualNetworkClient) getIpv6(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 4113 httpRequest, err := request.HTTPRequest(http.MethodGet, "/ipv6/{ipv6Id}") 4114 if err != nil { 4115 return nil, err 4116 } 4117 4118 var response GetIpv6Response 4119 var httpResponse *http.Response 4120 httpResponse, err = client.Call(ctx, &httpRequest) 4121 defer common.CloseBodyIfValid(httpResponse) 4122 response.RawResponse = httpResponse 4123 if err != nil { 4124 return response, err 4125 } 4126 4127 err = common.UnmarshalResponse(httpResponse, &response) 4128 return response, err 4129} 4130 4131// GetLocalPeeringGateway Gets the specified local peering gateway's information. 4132func (client VirtualNetworkClient) GetLocalPeeringGateway(ctx context.Context, request GetLocalPeeringGatewayRequest) (response GetLocalPeeringGatewayResponse, err error) { 4133 var ociResponse common.OCIResponse 4134 policy := common.NoRetryPolicy() 4135 if request.RetryPolicy() != nil { 4136 policy = *request.RetryPolicy() 4137 } 4138 ociResponse, err = common.Retry(ctx, request, client.getLocalPeeringGateway, policy) 4139 if err != nil { 4140 if ociResponse != nil { 4141 response = GetLocalPeeringGatewayResponse{RawResponse: ociResponse.HTTPResponse()} 4142 } 4143 return 4144 } 4145 if convertedResponse, ok := ociResponse.(GetLocalPeeringGatewayResponse); ok { 4146 response = convertedResponse 4147 } else { 4148 err = fmt.Errorf("failed to convert OCIResponse into GetLocalPeeringGatewayResponse") 4149 } 4150 return 4151} 4152 4153// getLocalPeeringGateway implements the OCIOperation interface (enables retrying operations) 4154func (client VirtualNetworkClient) getLocalPeeringGateway(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 4155 httpRequest, err := request.HTTPRequest(http.MethodGet, "/localPeeringGateways/{localPeeringGatewayId}") 4156 if err != nil { 4157 return nil, err 4158 } 4159 4160 var response GetLocalPeeringGatewayResponse 4161 var httpResponse *http.Response 4162 httpResponse, err = client.Call(ctx, &httpRequest) 4163 defer common.CloseBodyIfValid(httpResponse) 4164 response.RawResponse = httpResponse 4165 if err != nil { 4166 return response, err 4167 } 4168 4169 err = common.UnmarshalResponse(httpResponse, &response) 4170 return response, err 4171} 4172 4173// GetNatGateway Gets the specified NAT gateway's information. 4174func (client VirtualNetworkClient) GetNatGateway(ctx context.Context, request GetNatGatewayRequest) (response GetNatGatewayResponse, err error) { 4175 var ociResponse common.OCIResponse 4176 policy := common.NoRetryPolicy() 4177 if request.RetryPolicy() != nil { 4178 policy = *request.RetryPolicy() 4179 } 4180 ociResponse, err = common.Retry(ctx, request, client.getNatGateway, policy) 4181 if err != nil { 4182 if ociResponse != nil { 4183 response = GetNatGatewayResponse{RawResponse: ociResponse.HTTPResponse()} 4184 } 4185 return 4186 } 4187 if convertedResponse, ok := ociResponse.(GetNatGatewayResponse); ok { 4188 response = convertedResponse 4189 } else { 4190 err = fmt.Errorf("failed to convert OCIResponse into GetNatGatewayResponse") 4191 } 4192 return 4193} 4194 4195// getNatGateway implements the OCIOperation interface (enables retrying operations) 4196func (client VirtualNetworkClient) getNatGateway(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 4197 httpRequest, err := request.HTTPRequest(http.MethodGet, "/natGateways/{natGatewayId}") 4198 if err != nil { 4199 return nil, err 4200 } 4201 4202 var response GetNatGatewayResponse 4203 var httpResponse *http.Response 4204 httpResponse, err = client.Call(ctx, &httpRequest) 4205 defer common.CloseBodyIfValid(httpResponse) 4206 response.RawResponse = httpResponse 4207 if err != nil { 4208 return response, err 4209 } 4210 4211 err = common.UnmarshalResponse(httpResponse, &response) 4212 return response, err 4213} 4214 4215// GetNetworkSecurityGroup Gets the specified network security group's information. 4216// To list the VNICs in an NSG, see 4217// ListNetworkSecurityGroupVnics. 4218// To list the security rules in an NSG, see 4219// ListNetworkSecurityGroupSecurityRules. 4220func (client VirtualNetworkClient) GetNetworkSecurityGroup(ctx context.Context, request GetNetworkSecurityGroupRequest) (response GetNetworkSecurityGroupResponse, err error) { 4221 var ociResponse common.OCIResponse 4222 policy := common.NoRetryPolicy() 4223 if request.RetryPolicy() != nil { 4224 policy = *request.RetryPolicy() 4225 } 4226 ociResponse, err = common.Retry(ctx, request, client.getNetworkSecurityGroup, policy) 4227 if err != nil { 4228 if ociResponse != nil { 4229 response = GetNetworkSecurityGroupResponse{RawResponse: ociResponse.HTTPResponse()} 4230 } 4231 return 4232 } 4233 if convertedResponse, ok := ociResponse.(GetNetworkSecurityGroupResponse); ok { 4234 response = convertedResponse 4235 } else { 4236 err = fmt.Errorf("failed to convert OCIResponse into GetNetworkSecurityGroupResponse") 4237 } 4238 return 4239} 4240 4241// getNetworkSecurityGroup implements the OCIOperation interface (enables retrying operations) 4242func (client VirtualNetworkClient) getNetworkSecurityGroup(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 4243 httpRequest, err := request.HTTPRequest(http.MethodGet, "/networkSecurityGroups/{networkSecurityGroupId}") 4244 if err != nil { 4245 return nil, err 4246 } 4247 4248 var response GetNetworkSecurityGroupResponse 4249 var httpResponse *http.Response 4250 httpResponse, err = client.Call(ctx, &httpRequest) 4251 defer common.CloseBodyIfValid(httpResponse) 4252 response.RawResponse = httpResponse 4253 if err != nil { 4254 return response, err 4255 } 4256 4257 err = common.UnmarshalResponse(httpResponse, &response) 4258 return response, err 4259} 4260 4261// GetPrivateIp Gets the specified private IP. You must specify the object's OCID. 4262// Alternatively, you can get the object by using 4263// ListPrivateIps 4264// with the private IP address (for example, 10.0.3.3) and subnet OCID. 4265func (client VirtualNetworkClient) GetPrivateIp(ctx context.Context, request GetPrivateIpRequest) (response GetPrivateIpResponse, err error) { 4266 var ociResponse common.OCIResponse 4267 policy := common.NoRetryPolicy() 4268 if request.RetryPolicy() != nil { 4269 policy = *request.RetryPolicy() 4270 } 4271 ociResponse, err = common.Retry(ctx, request, client.getPrivateIp, policy) 4272 if err != nil { 4273 if ociResponse != nil { 4274 response = GetPrivateIpResponse{RawResponse: ociResponse.HTTPResponse()} 4275 } 4276 return 4277 } 4278 if convertedResponse, ok := ociResponse.(GetPrivateIpResponse); ok { 4279 response = convertedResponse 4280 } else { 4281 err = fmt.Errorf("failed to convert OCIResponse into GetPrivateIpResponse") 4282 } 4283 return 4284} 4285 4286// getPrivateIp implements the OCIOperation interface (enables retrying operations) 4287func (client VirtualNetworkClient) getPrivateIp(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 4288 httpRequest, err := request.HTTPRequest(http.MethodGet, "/privateIps/{privateIpId}") 4289 if err != nil { 4290 return nil, err 4291 } 4292 4293 var response GetPrivateIpResponse 4294 var httpResponse *http.Response 4295 httpResponse, err = client.Call(ctx, &httpRequest) 4296 defer common.CloseBodyIfValid(httpResponse) 4297 response.RawResponse = httpResponse 4298 if err != nil { 4299 return response, err 4300 } 4301 4302 err = common.UnmarshalResponse(httpResponse, &response) 4303 return response, err 4304} 4305 4306// GetPublicIp Gets the specified public IP. You must specify the object's OCID. 4307// Alternatively, you can get the object by using GetPublicIpByIpAddress 4308// with the public IP address (for example, 129.146.2.1). 4309// Or you can use GetPublicIpByPrivateIpId 4310// with the OCID of the private IP that the public IP is assigned to. 4311// **Note:** If you're fetching a reserved public IP that is in the process of being 4312// moved to a different private IP, the service returns the public IP object with 4313// `lifecycleState` = ASSIGNING and `assignedEntityId` = OCID of the target private IP. 4314func (client VirtualNetworkClient) GetPublicIp(ctx context.Context, request GetPublicIpRequest) (response GetPublicIpResponse, err error) { 4315 var ociResponse common.OCIResponse 4316 policy := common.NoRetryPolicy() 4317 if request.RetryPolicy() != nil { 4318 policy = *request.RetryPolicy() 4319 } 4320 ociResponse, err = common.Retry(ctx, request, client.getPublicIp, policy) 4321 if err != nil { 4322 if ociResponse != nil { 4323 response = GetPublicIpResponse{RawResponse: ociResponse.HTTPResponse()} 4324 } 4325 return 4326 } 4327 if convertedResponse, ok := ociResponse.(GetPublicIpResponse); ok { 4328 response = convertedResponse 4329 } else { 4330 err = fmt.Errorf("failed to convert OCIResponse into GetPublicIpResponse") 4331 } 4332 return 4333} 4334 4335// getPublicIp implements the OCIOperation interface (enables retrying operations) 4336func (client VirtualNetworkClient) getPublicIp(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 4337 httpRequest, err := request.HTTPRequest(http.MethodGet, "/publicIps/{publicIpId}") 4338 if err != nil { 4339 return nil, err 4340 } 4341 4342 var response GetPublicIpResponse 4343 var httpResponse *http.Response 4344 httpResponse, err = client.Call(ctx, &httpRequest) 4345 defer common.CloseBodyIfValid(httpResponse) 4346 response.RawResponse = httpResponse 4347 if err != nil { 4348 return response, err 4349 } 4350 4351 err = common.UnmarshalResponse(httpResponse, &response) 4352 return response, err 4353} 4354 4355// GetPublicIpByIpAddress Gets the public IP based on the public IP address (for example, 129.146.2.1). 4356// **Note:** If you're fetching a reserved public IP that is in the process of being 4357// moved to a different private IP, the service returns the public IP object with 4358// `lifecycleState` = ASSIGNING and `assignedEntityId` = OCID of the target private IP. 4359func (client VirtualNetworkClient) GetPublicIpByIpAddress(ctx context.Context, request GetPublicIpByIpAddressRequest) (response GetPublicIpByIpAddressResponse, err error) { 4360 var ociResponse common.OCIResponse 4361 policy := common.NoRetryPolicy() 4362 if request.RetryPolicy() != nil { 4363 policy = *request.RetryPolicy() 4364 } 4365 ociResponse, err = common.Retry(ctx, request, client.getPublicIpByIpAddress, policy) 4366 if err != nil { 4367 if ociResponse != nil { 4368 response = GetPublicIpByIpAddressResponse{RawResponse: ociResponse.HTTPResponse()} 4369 } 4370 return 4371 } 4372 if convertedResponse, ok := ociResponse.(GetPublicIpByIpAddressResponse); ok { 4373 response = convertedResponse 4374 } else { 4375 err = fmt.Errorf("failed to convert OCIResponse into GetPublicIpByIpAddressResponse") 4376 } 4377 return 4378} 4379 4380// getPublicIpByIpAddress implements the OCIOperation interface (enables retrying operations) 4381func (client VirtualNetworkClient) getPublicIpByIpAddress(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 4382 httpRequest, err := request.HTTPRequest(http.MethodPost, "/publicIps/actions/getByIpAddress") 4383 if err != nil { 4384 return nil, err 4385 } 4386 4387 var response GetPublicIpByIpAddressResponse 4388 var httpResponse *http.Response 4389 httpResponse, err = client.Call(ctx, &httpRequest) 4390 defer common.CloseBodyIfValid(httpResponse) 4391 response.RawResponse = httpResponse 4392 if err != nil { 4393 return response, err 4394 } 4395 4396 err = common.UnmarshalResponse(httpResponse, &response) 4397 return response, err 4398} 4399 4400// GetPublicIpByPrivateIpId Gets the public IP assigned to the specified private IP. You must specify the OCID 4401// of the private IP. If no public IP is assigned, a 404 is returned. 4402// **Note:** If you're fetching a reserved public IP that is in the process of being 4403// moved to a different private IP, and you provide the OCID of the original private 4404// IP, this operation returns a 404. If you instead provide the OCID of the target 4405// private IP, or if you instead call 4406// GetPublicIp or 4407// GetPublicIpByIpAddress, the 4408// service returns the public IP object with `lifecycleState` = ASSIGNING and 4409// `assignedEntityId` = OCID of the target private IP. 4410func (client VirtualNetworkClient) GetPublicIpByPrivateIpId(ctx context.Context, request GetPublicIpByPrivateIpIdRequest) (response GetPublicIpByPrivateIpIdResponse, err error) { 4411 var ociResponse common.OCIResponse 4412 policy := common.NoRetryPolicy() 4413 if request.RetryPolicy() != nil { 4414 policy = *request.RetryPolicy() 4415 } 4416 ociResponse, err = common.Retry(ctx, request, client.getPublicIpByPrivateIpId, policy) 4417 if err != nil { 4418 if ociResponse != nil { 4419 response = GetPublicIpByPrivateIpIdResponse{RawResponse: ociResponse.HTTPResponse()} 4420 } 4421 return 4422 } 4423 if convertedResponse, ok := ociResponse.(GetPublicIpByPrivateIpIdResponse); ok { 4424 response = convertedResponse 4425 } else { 4426 err = fmt.Errorf("failed to convert OCIResponse into GetPublicIpByPrivateIpIdResponse") 4427 } 4428 return 4429} 4430 4431// getPublicIpByPrivateIpId implements the OCIOperation interface (enables retrying operations) 4432func (client VirtualNetworkClient) getPublicIpByPrivateIpId(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 4433 httpRequest, err := request.HTTPRequest(http.MethodPost, "/publicIps/actions/getByPrivateIpId") 4434 if err != nil { 4435 return nil, err 4436 } 4437 4438 var response GetPublicIpByPrivateIpIdResponse 4439 var httpResponse *http.Response 4440 httpResponse, err = client.Call(ctx, &httpRequest) 4441 defer common.CloseBodyIfValid(httpResponse) 4442 response.RawResponse = httpResponse 4443 if err != nil { 4444 return response, err 4445 } 4446 4447 err = common.UnmarshalResponse(httpResponse, &response) 4448 return response, err 4449} 4450 4451// GetRemotePeeringConnection Get the specified remote peering connection's information. 4452func (client VirtualNetworkClient) GetRemotePeeringConnection(ctx context.Context, request GetRemotePeeringConnectionRequest) (response GetRemotePeeringConnectionResponse, err error) { 4453 var ociResponse common.OCIResponse 4454 policy := common.NoRetryPolicy() 4455 if request.RetryPolicy() != nil { 4456 policy = *request.RetryPolicy() 4457 } 4458 ociResponse, err = common.Retry(ctx, request, client.getRemotePeeringConnection, policy) 4459 if err != nil { 4460 if ociResponse != nil { 4461 response = GetRemotePeeringConnectionResponse{RawResponse: ociResponse.HTTPResponse()} 4462 } 4463 return 4464 } 4465 if convertedResponse, ok := ociResponse.(GetRemotePeeringConnectionResponse); ok { 4466 response = convertedResponse 4467 } else { 4468 err = fmt.Errorf("failed to convert OCIResponse into GetRemotePeeringConnectionResponse") 4469 } 4470 return 4471} 4472 4473// getRemotePeeringConnection implements the OCIOperation interface (enables retrying operations) 4474func (client VirtualNetworkClient) getRemotePeeringConnection(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 4475 httpRequest, err := request.HTTPRequest(http.MethodGet, "/remotePeeringConnections/{remotePeeringConnectionId}") 4476 if err != nil { 4477 return nil, err 4478 } 4479 4480 var response GetRemotePeeringConnectionResponse 4481 var httpResponse *http.Response 4482 httpResponse, err = client.Call(ctx, &httpRequest) 4483 defer common.CloseBodyIfValid(httpResponse) 4484 response.RawResponse = httpResponse 4485 if err != nil { 4486 return response, err 4487 } 4488 4489 err = common.UnmarshalResponse(httpResponse, &response) 4490 return response, err 4491} 4492 4493// GetRouteTable Gets the specified route table's information. 4494func (client VirtualNetworkClient) GetRouteTable(ctx context.Context, request GetRouteTableRequest) (response GetRouteTableResponse, err error) { 4495 var ociResponse common.OCIResponse 4496 policy := common.NoRetryPolicy() 4497 if request.RetryPolicy() != nil { 4498 policy = *request.RetryPolicy() 4499 } 4500 ociResponse, err = common.Retry(ctx, request, client.getRouteTable, policy) 4501 if err != nil { 4502 if ociResponse != nil { 4503 response = GetRouteTableResponse{RawResponse: ociResponse.HTTPResponse()} 4504 } 4505 return 4506 } 4507 if convertedResponse, ok := ociResponse.(GetRouteTableResponse); ok { 4508 response = convertedResponse 4509 } else { 4510 err = fmt.Errorf("failed to convert OCIResponse into GetRouteTableResponse") 4511 } 4512 return 4513} 4514 4515// getRouteTable implements the OCIOperation interface (enables retrying operations) 4516func (client VirtualNetworkClient) getRouteTable(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 4517 httpRequest, err := request.HTTPRequest(http.MethodGet, "/routeTables/{rtId}") 4518 if err != nil { 4519 return nil, err 4520 } 4521 4522 var response GetRouteTableResponse 4523 var httpResponse *http.Response 4524 httpResponse, err = client.Call(ctx, &httpRequest) 4525 defer common.CloseBodyIfValid(httpResponse) 4526 response.RawResponse = httpResponse 4527 if err != nil { 4528 return response, err 4529 } 4530 4531 err = common.UnmarshalResponse(httpResponse, &response) 4532 return response, err 4533} 4534 4535// GetSecurityList Gets the specified security list's information. 4536func (client VirtualNetworkClient) GetSecurityList(ctx context.Context, request GetSecurityListRequest) (response GetSecurityListResponse, err error) { 4537 var ociResponse common.OCIResponse 4538 policy := common.NoRetryPolicy() 4539 if request.RetryPolicy() != nil { 4540 policy = *request.RetryPolicy() 4541 } 4542 ociResponse, err = common.Retry(ctx, request, client.getSecurityList, policy) 4543 if err != nil { 4544 if ociResponse != nil { 4545 response = GetSecurityListResponse{RawResponse: ociResponse.HTTPResponse()} 4546 } 4547 return 4548 } 4549 if convertedResponse, ok := ociResponse.(GetSecurityListResponse); ok { 4550 response = convertedResponse 4551 } else { 4552 err = fmt.Errorf("failed to convert OCIResponse into GetSecurityListResponse") 4553 } 4554 return 4555} 4556 4557// getSecurityList implements the OCIOperation interface (enables retrying operations) 4558func (client VirtualNetworkClient) getSecurityList(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 4559 httpRequest, err := request.HTTPRequest(http.MethodGet, "/securityLists/{securityListId}") 4560 if err != nil { 4561 return nil, err 4562 } 4563 4564 var response GetSecurityListResponse 4565 var httpResponse *http.Response 4566 httpResponse, err = client.Call(ctx, &httpRequest) 4567 defer common.CloseBodyIfValid(httpResponse) 4568 response.RawResponse = httpResponse 4569 if err != nil { 4570 return response, err 4571 } 4572 4573 err = common.UnmarshalResponse(httpResponse, &response) 4574 return response, err 4575} 4576 4577// GetService Gets the specified Service object. 4578func (client VirtualNetworkClient) GetService(ctx context.Context, request GetServiceRequest) (response GetServiceResponse, err error) { 4579 var ociResponse common.OCIResponse 4580 policy := common.NoRetryPolicy() 4581 if request.RetryPolicy() != nil { 4582 policy = *request.RetryPolicy() 4583 } 4584 ociResponse, err = common.Retry(ctx, request, client.getService, policy) 4585 if err != nil { 4586 if ociResponse != nil { 4587 response = GetServiceResponse{RawResponse: ociResponse.HTTPResponse()} 4588 } 4589 return 4590 } 4591 if convertedResponse, ok := ociResponse.(GetServiceResponse); ok { 4592 response = convertedResponse 4593 } else { 4594 err = fmt.Errorf("failed to convert OCIResponse into GetServiceResponse") 4595 } 4596 return 4597} 4598 4599// getService implements the OCIOperation interface (enables retrying operations) 4600func (client VirtualNetworkClient) getService(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 4601 httpRequest, err := request.HTTPRequest(http.MethodGet, "/services/{serviceId}") 4602 if err != nil { 4603 return nil, err 4604 } 4605 4606 var response GetServiceResponse 4607 var httpResponse *http.Response 4608 httpResponse, err = client.Call(ctx, &httpRequest) 4609 defer common.CloseBodyIfValid(httpResponse) 4610 response.RawResponse = httpResponse 4611 if err != nil { 4612 return response, err 4613 } 4614 4615 err = common.UnmarshalResponse(httpResponse, &response) 4616 return response, err 4617} 4618 4619// GetServiceGateway Gets the specified service gateway's information. 4620func (client VirtualNetworkClient) GetServiceGateway(ctx context.Context, request GetServiceGatewayRequest) (response GetServiceGatewayResponse, err error) { 4621 var ociResponse common.OCIResponse 4622 policy := common.NoRetryPolicy() 4623 if request.RetryPolicy() != nil { 4624 policy = *request.RetryPolicy() 4625 } 4626 ociResponse, err = common.Retry(ctx, request, client.getServiceGateway, policy) 4627 if err != nil { 4628 if ociResponse != nil { 4629 response = GetServiceGatewayResponse{RawResponse: ociResponse.HTTPResponse()} 4630 } 4631 return 4632 } 4633 if convertedResponse, ok := ociResponse.(GetServiceGatewayResponse); ok { 4634 response = convertedResponse 4635 } else { 4636 err = fmt.Errorf("failed to convert OCIResponse into GetServiceGatewayResponse") 4637 } 4638 return 4639} 4640 4641// getServiceGateway implements the OCIOperation interface (enables retrying operations) 4642func (client VirtualNetworkClient) getServiceGateway(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 4643 httpRequest, err := request.HTTPRequest(http.MethodGet, "/serviceGateways/{serviceGatewayId}") 4644 if err != nil { 4645 return nil, err 4646 } 4647 4648 var response GetServiceGatewayResponse 4649 var httpResponse *http.Response 4650 httpResponse, err = client.Call(ctx, &httpRequest) 4651 defer common.CloseBodyIfValid(httpResponse) 4652 response.RawResponse = httpResponse 4653 if err != nil { 4654 return response, err 4655 } 4656 4657 err = common.UnmarshalResponse(httpResponse, &response) 4658 return response, err 4659} 4660 4661// GetSubnet Gets the specified subnet's information. 4662func (client VirtualNetworkClient) GetSubnet(ctx context.Context, request GetSubnetRequest) (response GetSubnetResponse, err error) { 4663 var ociResponse common.OCIResponse 4664 policy := common.NoRetryPolicy() 4665 if request.RetryPolicy() != nil { 4666 policy = *request.RetryPolicy() 4667 } 4668 ociResponse, err = common.Retry(ctx, request, client.getSubnet, policy) 4669 if err != nil { 4670 if ociResponse != nil { 4671 response = GetSubnetResponse{RawResponse: ociResponse.HTTPResponse()} 4672 } 4673 return 4674 } 4675 if convertedResponse, ok := ociResponse.(GetSubnetResponse); ok { 4676 response = convertedResponse 4677 } else { 4678 err = fmt.Errorf("failed to convert OCIResponse into GetSubnetResponse") 4679 } 4680 return 4681} 4682 4683// getSubnet implements the OCIOperation interface (enables retrying operations) 4684func (client VirtualNetworkClient) getSubnet(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 4685 httpRequest, err := request.HTTPRequest(http.MethodGet, "/subnets/{subnetId}") 4686 if err != nil { 4687 return nil, err 4688 } 4689 4690 var response GetSubnetResponse 4691 var httpResponse *http.Response 4692 httpResponse, err = client.Call(ctx, &httpRequest) 4693 defer common.CloseBodyIfValid(httpResponse) 4694 response.RawResponse = httpResponse 4695 if err != nil { 4696 return response, err 4697 } 4698 4699 err = common.UnmarshalResponse(httpResponse, &response) 4700 return response, err 4701} 4702 4703// GetVcn Gets the specified VCN's information. 4704func (client VirtualNetworkClient) GetVcn(ctx context.Context, request GetVcnRequest) (response GetVcnResponse, err error) { 4705 var ociResponse common.OCIResponse 4706 policy := common.NoRetryPolicy() 4707 if request.RetryPolicy() != nil { 4708 policy = *request.RetryPolicy() 4709 } 4710 ociResponse, err = common.Retry(ctx, request, client.getVcn, policy) 4711 if err != nil { 4712 if ociResponse != nil { 4713 response = GetVcnResponse{RawResponse: ociResponse.HTTPResponse()} 4714 } 4715 return 4716 } 4717 if convertedResponse, ok := ociResponse.(GetVcnResponse); ok { 4718 response = convertedResponse 4719 } else { 4720 err = fmt.Errorf("failed to convert OCIResponse into GetVcnResponse") 4721 } 4722 return 4723} 4724 4725// getVcn implements the OCIOperation interface (enables retrying operations) 4726func (client VirtualNetworkClient) getVcn(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 4727 httpRequest, err := request.HTTPRequest(http.MethodGet, "/vcns/{vcnId}") 4728 if err != nil { 4729 return nil, err 4730 } 4731 4732 var response GetVcnResponse 4733 var httpResponse *http.Response 4734 httpResponse, err = client.Call(ctx, &httpRequest) 4735 defer common.CloseBodyIfValid(httpResponse) 4736 response.RawResponse = httpResponse 4737 if err != nil { 4738 return response, err 4739 } 4740 4741 err = common.UnmarshalResponse(httpResponse, &response) 4742 return response, err 4743} 4744 4745// GetVirtualCircuit Gets the specified virtual circuit's information. 4746func (client VirtualNetworkClient) GetVirtualCircuit(ctx context.Context, request GetVirtualCircuitRequest) (response GetVirtualCircuitResponse, err error) { 4747 var ociResponse common.OCIResponse 4748 policy := common.NoRetryPolicy() 4749 if request.RetryPolicy() != nil { 4750 policy = *request.RetryPolicy() 4751 } 4752 ociResponse, err = common.Retry(ctx, request, client.getVirtualCircuit, policy) 4753 if err != nil { 4754 if ociResponse != nil { 4755 response = GetVirtualCircuitResponse{RawResponse: ociResponse.HTTPResponse()} 4756 } 4757 return 4758 } 4759 if convertedResponse, ok := ociResponse.(GetVirtualCircuitResponse); ok { 4760 response = convertedResponse 4761 } else { 4762 err = fmt.Errorf("failed to convert OCIResponse into GetVirtualCircuitResponse") 4763 } 4764 return 4765} 4766 4767// getVirtualCircuit implements the OCIOperation interface (enables retrying operations) 4768func (client VirtualNetworkClient) getVirtualCircuit(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 4769 httpRequest, err := request.HTTPRequest(http.MethodGet, "/virtualCircuits/{virtualCircuitId}") 4770 if err != nil { 4771 return nil, err 4772 } 4773 4774 var response GetVirtualCircuitResponse 4775 var httpResponse *http.Response 4776 httpResponse, err = client.Call(ctx, &httpRequest) 4777 defer common.CloseBodyIfValid(httpResponse) 4778 response.RawResponse = httpResponse 4779 if err != nil { 4780 return response, err 4781 } 4782 4783 err = common.UnmarshalResponse(httpResponse, &response) 4784 return response, err 4785} 4786 4787// GetVnic Gets the information for the specified virtual network interface card (VNIC). 4788// You can get the VNIC OCID from the 4789// ListVnicAttachments 4790// operation. 4791func (client VirtualNetworkClient) GetVnic(ctx context.Context, request GetVnicRequest) (response GetVnicResponse, err error) { 4792 var ociResponse common.OCIResponse 4793 policy := common.NoRetryPolicy() 4794 if request.RetryPolicy() != nil { 4795 policy = *request.RetryPolicy() 4796 } 4797 ociResponse, err = common.Retry(ctx, request, client.getVnic, policy) 4798 if err != nil { 4799 if ociResponse != nil { 4800 response = GetVnicResponse{RawResponse: ociResponse.HTTPResponse()} 4801 } 4802 return 4803 } 4804 if convertedResponse, ok := ociResponse.(GetVnicResponse); ok { 4805 response = convertedResponse 4806 } else { 4807 err = fmt.Errorf("failed to convert OCIResponse into GetVnicResponse") 4808 } 4809 return 4810} 4811 4812// getVnic implements the OCIOperation interface (enables retrying operations) 4813func (client VirtualNetworkClient) getVnic(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 4814 httpRequest, err := request.HTTPRequest(http.MethodGet, "/vnics/{vnicId}") 4815 if err != nil { 4816 return nil, err 4817 } 4818 4819 var response GetVnicResponse 4820 var httpResponse *http.Response 4821 httpResponse, err = client.Call(ctx, &httpRequest) 4822 defer common.CloseBodyIfValid(httpResponse) 4823 response.RawResponse = httpResponse 4824 if err != nil { 4825 return response, err 4826 } 4827 4828 err = common.UnmarshalResponse(httpResponse, &response) 4829 return response, err 4830} 4831 4832// ListAllowedPeerRegionsForRemotePeering Lists the regions that support remote VCN peering (which is peering across regions). 4833// For more information, see VCN Peering (https://docs.cloud.oracle.com/Content/Network/Tasks/VCNpeering.htm). 4834func (client VirtualNetworkClient) ListAllowedPeerRegionsForRemotePeering(ctx context.Context, request ListAllowedPeerRegionsForRemotePeeringRequest) (response ListAllowedPeerRegionsForRemotePeeringResponse, err error) { 4835 var ociResponse common.OCIResponse 4836 policy := common.NoRetryPolicy() 4837 if request.RetryPolicy() != nil { 4838 policy = *request.RetryPolicy() 4839 } 4840 ociResponse, err = common.Retry(ctx, request, client.listAllowedPeerRegionsForRemotePeering, policy) 4841 if err != nil { 4842 if ociResponse != nil { 4843 response = ListAllowedPeerRegionsForRemotePeeringResponse{RawResponse: ociResponse.HTTPResponse()} 4844 } 4845 return 4846 } 4847 if convertedResponse, ok := ociResponse.(ListAllowedPeerRegionsForRemotePeeringResponse); ok { 4848 response = convertedResponse 4849 } else { 4850 err = fmt.Errorf("failed to convert OCIResponse into ListAllowedPeerRegionsForRemotePeeringResponse") 4851 } 4852 return 4853} 4854 4855// listAllowedPeerRegionsForRemotePeering implements the OCIOperation interface (enables retrying operations) 4856func (client VirtualNetworkClient) listAllowedPeerRegionsForRemotePeering(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 4857 httpRequest, err := request.HTTPRequest(http.MethodGet, "/allowedPeerRegionsForRemotePeering") 4858 if err != nil { 4859 return nil, err 4860 } 4861 4862 var response ListAllowedPeerRegionsForRemotePeeringResponse 4863 var httpResponse *http.Response 4864 httpResponse, err = client.Call(ctx, &httpRequest) 4865 defer common.CloseBodyIfValid(httpResponse) 4866 response.RawResponse = httpResponse 4867 if err != nil { 4868 return response, err 4869 } 4870 4871 err = common.UnmarshalResponse(httpResponse, &response) 4872 return response, err 4873} 4874 4875// ListCpes Lists the customer-premises equipment objects (CPEs) in the specified compartment. 4876func (client VirtualNetworkClient) ListCpes(ctx context.Context, request ListCpesRequest) (response ListCpesResponse, err error) { 4877 var ociResponse common.OCIResponse 4878 policy := common.NoRetryPolicy() 4879 if request.RetryPolicy() != nil { 4880 policy = *request.RetryPolicy() 4881 } 4882 ociResponse, err = common.Retry(ctx, request, client.listCpes, policy) 4883 if err != nil { 4884 if ociResponse != nil { 4885 response = ListCpesResponse{RawResponse: ociResponse.HTTPResponse()} 4886 } 4887 return 4888 } 4889 if convertedResponse, ok := ociResponse.(ListCpesResponse); ok { 4890 response = convertedResponse 4891 } else { 4892 err = fmt.Errorf("failed to convert OCIResponse into ListCpesResponse") 4893 } 4894 return 4895} 4896 4897// listCpes implements the OCIOperation interface (enables retrying operations) 4898func (client VirtualNetworkClient) listCpes(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 4899 httpRequest, err := request.HTTPRequest(http.MethodGet, "/cpes") 4900 if err != nil { 4901 return nil, err 4902 } 4903 4904 var response ListCpesResponse 4905 var httpResponse *http.Response 4906 httpResponse, err = client.Call(ctx, &httpRequest) 4907 defer common.CloseBodyIfValid(httpResponse) 4908 response.RawResponse = httpResponse 4909 if err != nil { 4910 return response, err 4911 } 4912 4913 err = common.UnmarshalResponse(httpResponse, &response) 4914 return response, err 4915} 4916 4917// ListCrossConnectGroups Lists the cross-connect groups in the specified compartment. 4918func (client VirtualNetworkClient) ListCrossConnectGroups(ctx context.Context, request ListCrossConnectGroupsRequest) (response ListCrossConnectGroupsResponse, err error) { 4919 var ociResponse common.OCIResponse 4920 policy := common.NoRetryPolicy() 4921 if request.RetryPolicy() != nil { 4922 policy = *request.RetryPolicy() 4923 } 4924 ociResponse, err = common.Retry(ctx, request, client.listCrossConnectGroups, policy) 4925 if err != nil { 4926 if ociResponse != nil { 4927 response = ListCrossConnectGroupsResponse{RawResponse: ociResponse.HTTPResponse()} 4928 } 4929 return 4930 } 4931 if convertedResponse, ok := ociResponse.(ListCrossConnectGroupsResponse); ok { 4932 response = convertedResponse 4933 } else { 4934 err = fmt.Errorf("failed to convert OCIResponse into ListCrossConnectGroupsResponse") 4935 } 4936 return 4937} 4938 4939// listCrossConnectGroups implements the OCIOperation interface (enables retrying operations) 4940func (client VirtualNetworkClient) listCrossConnectGroups(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 4941 httpRequest, err := request.HTTPRequest(http.MethodGet, "/crossConnectGroups") 4942 if err != nil { 4943 return nil, err 4944 } 4945 4946 var response ListCrossConnectGroupsResponse 4947 var httpResponse *http.Response 4948 httpResponse, err = client.Call(ctx, &httpRequest) 4949 defer common.CloseBodyIfValid(httpResponse) 4950 response.RawResponse = httpResponse 4951 if err != nil { 4952 return response, err 4953 } 4954 4955 err = common.UnmarshalResponse(httpResponse, &response) 4956 return response, err 4957} 4958 4959// ListCrossConnectLocations Lists the available FastConnect locations for cross-connect installation. You need 4960// this information so you can specify your desired location when you create a cross-connect. 4961func (client VirtualNetworkClient) ListCrossConnectLocations(ctx context.Context, request ListCrossConnectLocationsRequest) (response ListCrossConnectLocationsResponse, err error) { 4962 var ociResponse common.OCIResponse 4963 policy := common.NoRetryPolicy() 4964 if request.RetryPolicy() != nil { 4965 policy = *request.RetryPolicy() 4966 } 4967 ociResponse, err = common.Retry(ctx, request, client.listCrossConnectLocations, policy) 4968 if err != nil { 4969 if ociResponse != nil { 4970 response = ListCrossConnectLocationsResponse{RawResponse: ociResponse.HTTPResponse()} 4971 } 4972 return 4973 } 4974 if convertedResponse, ok := ociResponse.(ListCrossConnectLocationsResponse); ok { 4975 response = convertedResponse 4976 } else { 4977 err = fmt.Errorf("failed to convert OCIResponse into ListCrossConnectLocationsResponse") 4978 } 4979 return 4980} 4981 4982// listCrossConnectLocations implements the OCIOperation interface (enables retrying operations) 4983func (client VirtualNetworkClient) listCrossConnectLocations(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 4984 httpRequest, err := request.HTTPRequest(http.MethodGet, "/crossConnectLocations") 4985 if err != nil { 4986 return nil, err 4987 } 4988 4989 var response ListCrossConnectLocationsResponse 4990 var httpResponse *http.Response 4991 httpResponse, err = client.Call(ctx, &httpRequest) 4992 defer common.CloseBodyIfValid(httpResponse) 4993 response.RawResponse = httpResponse 4994 if err != nil { 4995 return response, err 4996 } 4997 4998 err = common.UnmarshalResponse(httpResponse, &response) 4999 return response, err 5000} 5001 5002// ListCrossConnects Lists the cross-connects in the specified compartment. You can filter the list 5003// by specifying the OCID of a cross-connect group. 5004func (client VirtualNetworkClient) ListCrossConnects(ctx context.Context, request ListCrossConnectsRequest) (response ListCrossConnectsResponse, err error) { 5005 var ociResponse common.OCIResponse 5006 policy := common.NoRetryPolicy() 5007 if request.RetryPolicy() != nil { 5008 policy = *request.RetryPolicy() 5009 } 5010 ociResponse, err = common.Retry(ctx, request, client.listCrossConnects, policy) 5011 if err != nil { 5012 if ociResponse != nil { 5013 response = ListCrossConnectsResponse{RawResponse: ociResponse.HTTPResponse()} 5014 } 5015 return 5016 } 5017 if convertedResponse, ok := ociResponse.(ListCrossConnectsResponse); ok { 5018 response = convertedResponse 5019 } else { 5020 err = fmt.Errorf("failed to convert OCIResponse into ListCrossConnectsResponse") 5021 } 5022 return 5023} 5024 5025// listCrossConnects implements the OCIOperation interface (enables retrying operations) 5026func (client VirtualNetworkClient) listCrossConnects(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 5027 httpRequest, err := request.HTTPRequest(http.MethodGet, "/crossConnects") 5028 if err != nil { 5029 return nil, err 5030 } 5031 5032 var response ListCrossConnectsResponse 5033 var httpResponse *http.Response 5034 httpResponse, err = client.Call(ctx, &httpRequest) 5035 defer common.CloseBodyIfValid(httpResponse) 5036 response.RawResponse = httpResponse 5037 if err != nil { 5038 return response, err 5039 } 5040 5041 err = common.UnmarshalResponse(httpResponse, &response) 5042 return response, err 5043} 5044 5045// ListCrossconnectPortSpeedShapes Lists the available port speeds for cross-connects. You need this information 5046// so you can specify your desired port speed (that is, shape) when you create a 5047// cross-connect. 5048func (client VirtualNetworkClient) ListCrossconnectPortSpeedShapes(ctx context.Context, request ListCrossconnectPortSpeedShapesRequest) (response ListCrossconnectPortSpeedShapesResponse, err error) { 5049 var ociResponse common.OCIResponse 5050 policy := common.NoRetryPolicy() 5051 if request.RetryPolicy() != nil { 5052 policy = *request.RetryPolicy() 5053 } 5054 ociResponse, err = common.Retry(ctx, request, client.listCrossconnectPortSpeedShapes, policy) 5055 if err != nil { 5056 if ociResponse != nil { 5057 response = ListCrossconnectPortSpeedShapesResponse{RawResponse: ociResponse.HTTPResponse()} 5058 } 5059 return 5060 } 5061 if convertedResponse, ok := ociResponse.(ListCrossconnectPortSpeedShapesResponse); ok { 5062 response = convertedResponse 5063 } else { 5064 err = fmt.Errorf("failed to convert OCIResponse into ListCrossconnectPortSpeedShapesResponse") 5065 } 5066 return 5067} 5068 5069// listCrossconnectPortSpeedShapes implements the OCIOperation interface (enables retrying operations) 5070func (client VirtualNetworkClient) listCrossconnectPortSpeedShapes(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 5071 httpRequest, err := request.HTTPRequest(http.MethodGet, "/crossConnectPortSpeedShapes") 5072 if err != nil { 5073 return nil, err 5074 } 5075 5076 var response ListCrossconnectPortSpeedShapesResponse 5077 var httpResponse *http.Response 5078 httpResponse, err = client.Call(ctx, &httpRequest) 5079 defer common.CloseBodyIfValid(httpResponse) 5080 response.RawResponse = httpResponse 5081 if err != nil { 5082 return response, err 5083 } 5084 5085 err = common.UnmarshalResponse(httpResponse, &response) 5086 return response, err 5087} 5088 5089// ListDhcpOptions Lists the sets of DHCP options in the specified VCN and specified compartment. 5090// The response includes the default set of options that automatically comes with each VCN, 5091// plus any other sets you've created. 5092func (client VirtualNetworkClient) ListDhcpOptions(ctx context.Context, request ListDhcpOptionsRequest) (response ListDhcpOptionsResponse, err error) { 5093 var ociResponse common.OCIResponse 5094 policy := common.NoRetryPolicy() 5095 if request.RetryPolicy() != nil { 5096 policy = *request.RetryPolicy() 5097 } 5098 ociResponse, err = common.Retry(ctx, request, client.listDhcpOptions, policy) 5099 if err != nil { 5100 if ociResponse != nil { 5101 response = ListDhcpOptionsResponse{RawResponse: ociResponse.HTTPResponse()} 5102 } 5103 return 5104 } 5105 if convertedResponse, ok := ociResponse.(ListDhcpOptionsResponse); ok { 5106 response = convertedResponse 5107 } else { 5108 err = fmt.Errorf("failed to convert OCIResponse into ListDhcpOptionsResponse") 5109 } 5110 return 5111} 5112 5113// listDhcpOptions implements the OCIOperation interface (enables retrying operations) 5114func (client VirtualNetworkClient) listDhcpOptions(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 5115 httpRequest, err := request.HTTPRequest(http.MethodGet, "/dhcps") 5116 if err != nil { 5117 return nil, err 5118 } 5119 5120 var response ListDhcpOptionsResponse 5121 var httpResponse *http.Response 5122 httpResponse, err = client.Call(ctx, &httpRequest) 5123 defer common.CloseBodyIfValid(httpResponse) 5124 response.RawResponse = httpResponse 5125 if err != nil { 5126 return response, err 5127 } 5128 5129 err = common.UnmarshalResponse(httpResponse, &response) 5130 return response, err 5131} 5132 5133// ListDrgAttachments Lists the `DrgAttachment` objects for the specified compartment. You can filter the 5134// results by VCN or DRG. 5135func (client VirtualNetworkClient) ListDrgAttachments(ctx context.Context, request ListDrgAttachmentsRequest) (response ListDrgAttachmentsResponse, err error) { 5136 var ociResponse common.OCIResponse 5137 policy := common.NoRetryPolicy() 5138 if request.RetryPolicy() != nil { 5139 policy = *request.RetryPolicy() 5140 } 5141 ociResponse, err = common.Retry(ctx, request, client.listDrgAttachments, policy) 5142 if err != nil { 5143 if ociResponse != nil { 5144 response = ListDrgAttachmentsResponse{RawResponse: ociResponse.HTTPResponse()} 5145 } 5146 return 5147 } 5148 if convertedResponse, ok := ociResponse.(ListDrgAttachmentsResponse); ok { 5149 response = convertedResponse 5150 } else { 5151 err = fmt.Errorf("failed to convert OCIResponse into ListDrgAttachmentsResponse") 5152 } 5153 return 5154} 5155 5156// listDrgAttachments implements the OCIOperation interface (enables retrying operations) 5157func (client VirtualNetworkClient) listDrgAttachments(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 5158 httpRequest, err := request.HTTPRequest(http.MethodGet, "/drgAttachments") 5159 if err != nil { 5160 return nil, err 5161 } 5162 5163 var response ListDrgAttachmentsResponse 5164 var httpResponse *http.Response 5165 httpResponse, err = client.Call(ctx, &httpRequest) 5166 defer common.CloseBodyIfValid(httpResponse) 5167 response.RawResponse = httpResponse 5168 if err != nil { 5169 return response, err 5170 } 5171 5172 err = common.UnmarshalResponse(httpResponse, &response) 5173 return response, err 5174} 5175 5176// ListDrgs Lists the DRGs in the specified compartment. 5177func (client VirtualNetworkClient) ListDrgs(ctx context.Context, request ListDrgsRequest) (response ListDrgsResponse, err error) { 5178 var ociResponse common.OCIResponse 5179 policy := common.NoRetryPolicy() 5180 if request.RetryPolicy() != nil { 5181 policy = *request.RetryPolicy() 5182 } 5183 ociResponse, err = common.Retry(ctx, request, client.listDrgs, policy) 5184 if err != nil { 5185 if ociResponse != nil { 5186 response = ListDrgsResponse{RawResponse: ociResponse.HTTPResponse()} 5187 } 5188 return 5189 } 5190 if convertedResponse, ok := ociResponse.(ListDrgsResponse); ok { 5191 response = convertedResponse 5192 } else { 5193 err = fmt.Errorf("failed to convert OCIResponse into ListDrgsResponse") 5194 } 5195 return 5196} 5197 5198// listDrgs implements the OCIOperation interface (enables retrying operations) 5199func (client VirtualNetworkClient) listDrgs(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 5200 httpRequest, err := request.HTTPRequest(http.MethodGet, "/drgs") 5201 if err != nil { 5202 return nil, err 5203 } 5204 5205 var response ListDrgsResponse 5206 var httpResponse *http.Response 5207 httpResponse, err = client.Call(ctx, &httpRequest) 5208 defer common.CloseBodyIfValid(httpResponse) 5209 response.RawResponse = httpResponse 5210 if err != nil { 5211 return response, err 5212 } 5213 5214 err = common.UnmarshalResponse(httpResponse, &response) 5215 return response, err 5216} 5217 5218// ListFastConnectProviderServices Lists the service offerings from supported providers. You need this 5219// information so you can specify your desired provider and service 5220// offering when you create a virtual circuit. 5221// For the compartment ID, provide the OCID of your tenancy (the root compartment). 5222// For more information, see FastConnect Overview (https://docs.cloud.oracle.com/Content/Network/Concepts/fastconnect.htm). 5223func (client VirtualNetworkClient) ListFastConnectProviderServices(ctx context.Context, request ListFastConnectProviderServicesRequest) (response ListFastConnectProviderServicesResponse, err error) { 5224 var ociResponse common.OCIResponse 5225 policy := common.NoRetryPolicy() 5226 if request.RetryPolicy() != nil { 5227 policy = *request.RetryPolicy() 5228 } 5229 ociResponse, err = common.Retry(ctx, request, client.listFastConnectProviderServices, policy) 5230 if err != nil { 5231 if ociResponse != nil { 5232 response = ListFastConnectProviderServicesResponse{RawResponse: ociResponse.HTTPResponse()} 5233 } 5234 return 5235 } 5236 if convertedResponse, ok := ociResponse.(ListFastConnectProviderServicesResponse); ok { 5237 response = convertedResponse 5238 } else { 5239 err = fmt.Errorf("failed to convert OCIResponse into ListFastConnectProviderServicesResponse") 5240 } 5241 return 5242} 5243 5244// listFastConnectProviderServices implements the OCIOperation interface (enables retrying operations) 5245func (client VirtualNetworkClient) listFastConnectProviderServices(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 5246 httpRequest, err := request.HTTPRequest(http.MethodGet, "/fastConnectProviderServices") 5247 if err != nil { 5248 return nil, err 5249 } 5250 5251 var response ListFastConnectProviderServicesResponse 5252 var httpResponse *http.Response 5253 httpResponse, err = client.Call(ctx, &httpRequest) 5254 defer common.CloseBodyIfValid(httpResponse) 5255 response.RawResponse = httpResponse 5256 if err != nil { 5257 return response, err 5258 } 5259 5260 err = common.UnmarshalResponse(httpResponse, &response) 5261 return response, err 5262} 5263 5264// ListFastConnectProviderVirtualCircuitBandwidthShapes Gets the list of available virtual circuit bandwidth levels for a provider. 5265// You need this information so you can specify your desired bandwidth level (shape) when you create a virtual circuit. 5266// For more information about virtual circuits, see FastConnect Overview (https://docs.cloud.oracle.com/Content/Network/Concepts/fastconnect.htm). 5267func (client VirtualNetworkClient) ListFastConnectProviderVirtualCircuitBandwidthShapes(ctx context.Context, request ListFastConnectProviderVirtualCircuitBandwidthShapesRequest) (response ListFastConnectProviderVirtualCircuitBandwidthShapesResponse, err error) { 5268 var ociResponse common.OCIResponse 5269 policy := common.NoRetryPolicy() 5270 if request.RetryPolicy() != nil { 5271 policy = *request.RetryPolicy() 5272 } 5273 ociResponse, err = common.Retry(ctx, request, client.listFastConnectProviderVirtualCircuitBandwidthShapes, policy) 5274 if err != nil { 5275 if ociResponse != nil { 5276 response = ListFastConnectProviderVirtualCircuitBandwidthShapesResponse{RawResponse: ociResponse.HTTPResponse()} 5277 } 5278 return 5279 } 5280 if convertedResponse, ok := ociResponse.(ListFastConnectProviderVirtualCircuitBandwidthShapesResponse); ok { 5281 response = convertedResponse 5282 } else { 5283 err = fmt.Errorf("failed to convert OCIResponse into ListFastConnectProviderVirtualCircuitBandwidthShapesResponse") 5284 } 5285 return 5286} 5287 5288// listFastConnectProviderVirtualCircuitBandwidthShapes implements the OCIOperation interface (enables retrying operations) 5289func (client VirtualNetworkClient) listFastConnectProviderVirtualCircuitBandwidthShapes(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 5290 httpRequest, err := request.HTTPRequest(http.MethodGet, "/fastConnectProviderServices/{providerServiceId}/virtualCircuitBandwidthShapes") 5291 if err != nil { 5292 return nil, err 5293 } 5294 5295 var response ListFastConnectProviderVirtualCircuitBandwidthShapesResponse 5296 var httpResponse *http.Response 5297 httpResponse, err = client.Call(ctx, &httpRequest) 5298 defer common.CloseBodyIfValid(httpResponse) 5299 response.RawResponse = httpResponse 5300 if err != nil { 5301 return response, err 5302 } 5303 5304 err = common.UnmarshalResponse(httpResponse, &response) 5305 return response, err 5306} 5307 5308// ListIPSecConnectionTunnels Lists the tunnel information for the specified IPSec connection. 5309func (client VirtualNetworkClient) ListIPSecConnectionTunnels(ctx context.Context, request ListIPSecConnectionTunnelsRequest) (response ListIPSecConnectionTunnelsResponse, err error) { 5310 var ociResponse common.OCIResponse 5311 policy := common.NoRetryPolicy() 5312 if request.RetryPolicy() != nil { 5313 policy = *request.RetryPolicy() 5314 } 5315 ociResponse, err = common.Retry(ctx, request, client.listIPSecConnectionTunnels, policy) 5316 if err != nil { 5317 if ociResponse != nil { 5318 response = ListIPSecConnectionTunnelsResponse{RawResponse: ociResponse.HTTPResponse()} 5319 } 5320 return 5321 } 5322 if convertedResponse, ok := ociResponse.(ListIPSecConnectionTunnelsResponse); ok { 5323 response = convertedResponse 5324 } else { 5325 err = fmt.Errorf("failed to convert OCIResponse into ListIPSecConnectionTunnelsResponse") 5326 } 5327 return 5328} 5329 5330// listIPSecConnectionTunnels implements the OCIOperation interface (enables retrying operations) 5331func (client VirtualNetworkClient) listIPSecConnectionTunnels(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 5332 httpRequest, err := request.HTTPRequest(http.MethodGet, "/ipsecConnections/{ipscId}/tunnels") 5333 if err != nil { 5334 return nil, err 5335 } 5336 5337 var response ListIPSecConnectionTunnelsResponse 5338 var httpResponse *http.Response 5339 httpResponse, err = client.Call(ctx, &httpRequest) 5340 defer common.CloseBodyIfValid(httpResponse) 5341 response.RawResponse = httpResponse 5342 if err != nil { 5343 return response, err 5344 } 5345 5346 err = common.UnmarshalResponse(httpResponse, &response) 5347 return response, err 5348} 5349 5350// ListIPSecConnections Lists the IPSec connections for the specified compartment. You can filter the 5351// results by DRG or CPE. 5352func (client VirtualNetworkClient) ListIPSecConnections(ctx context.Context, request ListIPSecConnectionsRequest) (response ListIPSecConnectionsResponse, err error) { 5353 var ociResponse common.OCIResponse 5354 policy := common.NoRetryPolicy() 5355 if request.RetryPolicy() != nil { 5356 policy = *request.RetryPolicy() 5357 } 5358 ociResponse, err = common.Retry(ctx, request, client.listIPSecConnections, policy) 5359 if err != nil { 5360 if ociResponse != nil { 5361 response = ListIPSecConnectionsResponse{RawResponse: ociResponse.HTTPResponse()} 5362 } 5363 return 5364 } 5365 if convertedResponse, ok := ociResponse.(ListIPSecConnectionsResponse); ok { 5366 response = convertedResponse 5367 } else { 5368 err = fmt.Errorf("failed to convert OCIResponse into ListIPSecConnectionsResponse") 5369 } 5370 return 5371} 5372 5373// listIPSecConnections implements the OCIOperation interface (enables retrying operations) 5374func (client VirtualNetworkClient) listIPSecConnections(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 5375 httpRequest, err := request.HTTPRequest(http.MethodGet, "/ipsecConnections") 5376 if err != nil { 5377 return nil, err 5378 } 5379 5380 var response ListIPSecConnectionsResponse 5381 var httpResponse *http.Response 5382 httpResponse, err = client.Call(ctx, &httpRequest) 5383 defer common.CloseBodyIfValid(httpResponse) 5384 response.RawResponse = httpResponse 5385 if err != nil { 5386 return response, err 5387 } 5388 5389 err = common.UnmarshalResponse(httpResponse, &response) 5390 return response, err 5391} 5392 5393// ListInternetGateways Lists the internet gateways in the specified VCN and the specified compartment. 5394func (client VirtualNetworkClient) ListInternetGateways(ctx context.Context, request ListInternetGatewaysRequest) (response ListInternetGatewaysResponse, err error) { 5395 var ociResponse common.OCIResponse 5396 policy := common.NoRetryPolicy() 5397 if request.RetryPolicy() != nil { 5398 policy = *request.RetryPolicy() 5399 } 5400 ociResponse, err = common.Retry(ctx, request, client.listInternetGateways, policy) 5401 if err != nil { 5402 if ociResponse != nil { 5403 response = ListInternetGatewaysResponse{RawResponse: ociResponse.HTTPResponse()} 5404 } 5405 return 5406 } 5407 if convertedResponse, ok := ociResponse.(ListInternetGatewaysResponse); ok { 5408 response = convertedResponse 5409 } else { 5410 err = fmt.Errorf("failed to convert OCIResponse into ListInternetGatewaysResponse") 5411 } 5412 return 5413} 5414 5415// listInternetGateways implements the OCIOperation interface (enables retrying operations) 5416func (client VirtualNetworkClient) listInternetGateways(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 5417 httpRequest, err := request.HTTPRequest(http.MethodGet, "/internetGateways") 5418 if err != nil { 5419 return nil, err 5420 } 5421 5422 var response ListInternetGatewaysResponse 5423 var httpResponse *http.Response 5424 httpResponse, err = client.Call(ctx, &httpRequest) 5425 defer common.CloseBodyIfValid(httpResponse) 5426 response.RawResponse = httpResponse 5427 if err != nil { 5428 return response, err 5429 } 5430 5431 err = common.UnmarshalResponse(httpResponse, &response) 5432 return response, err 5433} 5434 5435// ListIpv6s Lists the Ipv6 objects based 5436// on one of these filters: 5437// * Subnet OCID. 5438// * VNIC OCID. 5439// * Both IPv6 address and subnet OCID: This lets you get an `Ipv6` object based on its private 5440// IPv6 address (for example, 2001:0db8:0123:1111:abcd:ef01:2345:6789) and not its OCID. For comparison, 5441// GetIpv6 requires the OCID. 5442func (client VirtualNetworkClient) ListIpv6s(ctx context.Context, request ListIpv6sRequest) (response ListIpv6sResponse, err error) { 5443 var ociResponse common.OCIResponse 5444 policy := common.NoRetryPolicy() 5445 if request.RetryPolicy() != nil { 5446 policy = *request.RetryPolicy() 5447 } 5448 ociResponse, err = common.Retry(ctx, request, client.listIpv6s, policy) 5449 if err != nil { 5450 if ociResponse != nil { 5451 response = ListIpv6sResponse{RawResponse: ociResponse.HTTPResponse()} 5452 } 5453 return 5454 } 5455 if convertedResponse, ok := ociResponse.(ListIpv6sResponse); ok { 5456 response = convertedResponse 5457 } else { 5458 err = fmt.Errorf("failed to convert OCIResponse into ListIpv6sResponse") 5459 } 5460 return 5461} 5462 5463// listIpv6s implements the OCIOperation interface (enables retrying operations) 5464func (client VirtualNetworkClient) listIpv6s(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 5465 httpRequest, err := request.HTTPRequest(http.MethodGet, "/ipv6") 5466 if err != nil { 5467 return nil, err 5468 } 5469 5470 var response ListIpv6sResponse 5471 var httpResponse *http.Response 5472 httpResponse, err = client.Call(ctx, &httpRequest) 5473 defer common.CloseBodyIfValid(httpResponse) 5474 response.RawResponse = httpResponse 5475 if err != nil { 5476 return response, err 5477 } 5478 5479 err = common.UnmarshalResponse(httpResponse, &response) 5480 return response, err 5481} 5482 5483// ListLocalPeeringGateways Lists the local peering gateways (LPGs) for the specified VCN and compartment 5484// (the LPG's compartment). 5485func (client VirtualNetworkClient) ListLocalPeeringGateways(ctx context.Context, request ListLocalPeeringGatewaysRequest) (response ListLocalPeeringGatewaysResponse, err error) { 5486 var ociResponse common.OCIResponse 5487 policy := common.NoRetryPolicy() 5488 if request.RetryPolicy() != nil { 5489 policy = *request.RetryPolicy() 5490 } 5491 ociResponse, err = common.Retry(ctx, request, client.listLocalPeeringGateways, policy) 5492 if err != nil { 5493 if ociResponse != nil { 5494 response = ListLocalPeeringGatewaysResponse{RawResponse: ociResponse.HTTPResponse()} 5495 } 5496 return 5497 } 5498 if convertedResponse, ok := ociResponse.(ListLocalPeeringGatewaysResponse); ok { 5499 response = convertedResponse 5500 } else { 5501 err = fmt.Errorf("failed to convert OCIResponse into ListLocalPeeringGatewaysResponse") 5502 } 5503 return 5504} 5505 5506// listLocalPeeringGateways implements the OCIOperation interface (enables retrying operations) 5507func (client VirtualNetworkClient) listLocalPeeringGateways(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 5508 httpRequest, err := request.HTTPRequest(http.MethodGet, "/localPeeringGateways") 5509 if err != nil { 5510 return nil, err 5511 } 5512 5513 var response ListLocalPeeringGatewaysResponse 5514 var httpResponse *http.Response 5515 httpResponse, err = client.Call(ctx, &httpRequest) 5516 defer common.CloseBodyIfValid(httpResponse) 5517 response.RawResponse = httpResponse 5518 if err != nil { 5519 return response, err 5520 } 5521 5522 err = common.UnmarshalResponse(httpResponse, &response) 5523 return response, err 5524} 5525 5526// ListNatGateways Lists the NAT gateways in the specified compartment. You may optionally specify a VCN OCID 5527// to filter the results by VCN. 5528func (client VirtualNetworkClient) ListNatGateways(ctx context.Context, request ListNatGatewaysRequest) (response ListNatGatewaysResponse, err error) { 5529 var ociResponse common.OCIResponse 5530 policy := common.NoRetryPolicy() 5531 if request.RetryPolicy() != nil { 5532 policy = *request.RetryPolicy() 5533 } 5534 ociResponse, err = common.Retry(ctx, request, client.listNatGateways, policy) 5535 if err != nil { 5536 if ociResponse != nil { 5537 response = ListNatGatewaysResponse{RawResponse: ociResponse.HTTPResponse()} 5538 } 5539 return 5540 } 5541 if convertedResponse, ok := ociResponse.(ListNatGatewaysResponse); ok { 5542 response = convertedResponse 5543 } else { 5544 err = fmt.Errorf("failed to convert OCIResponse into ListNatGatewaysResponse") 5545 } 5546 return 5547} 5548 5549// listNatGateways implements the OCIOperation interface (enables retrying operations) 5550func (client VirtualNetworkClient) listNatGateways(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 5551 httpRequest, err := request.HTTPRequest(http.MethodGet, "/natGateways") 5552 if err != nil { 5553 return nil, err 5554 } 5555 5556 var response ListNatGatewaysResponse 5557 var httpResponse *http.Response 5558 httpResponse, err = client.Call(ctx, &httpRequest) 5559 defer common.CloseBodyIfValid(httpResponse) 5560 response.RawResponse = httpResponse 5561 if err != nil { 5562 return response, err 5563 } 5564 5565 err = common.UnmarshalResponse(httpResponse, &response) 5566 return response, err 5567} 5568 5569// ListNetworkSecurityGroupSecurityRules Lists the security rules in the specified network security group. 5570func (client VirtualNetworkClient) ListNetworkSecurityGroupSecurityRules(ctx context.Context, request ListNetworkSecurityGroupSecurityRulesRequest) (response ListNetworkSecurityGroupSecurityRulesResponse, err error) { 5571 var ociResponse common.OCIResponse 5572 policy := common.NoRetryPolicy() 5573 if request.RetryPolicy() != nil { 5574 policy = *request.RetryPolicy() 5575 } 5576 ociResponse, err = common.Retry(ctx, request, client.listNetworkSecurityGroupSecurityRules, policy) 5577 if err != nil { 5578 if ociResponse != nil { 5579 response = ListNetworkSecurityGroupSecurityRulesResponse{RawResponse: ociResponse.HTTPResponse()} 5580 } 5581 return 5582 } 5583 if convertedResponse, ok := ociResponse.(ListNetworkSecurityGroupSecurityRulesResponse); ok { 5584 response = convertedResponse 5585 } else { 5586 err = fmt.Errorf("failed to convert OCIResponse into ListNetworkSecurityGroupSecurityRulesResponse") 5587 } 5588 return 5589} 5590 5591// listNetworkSecurityGroupSecurityRules implements the OCIOperation interface (enables retrying operations) 5592func (client VirtualNetworkClient) listNetworkSecurityGroupSecurityRules(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 5593 httpRequest, err := request.HTTPRequest(http.MethodGet, "/networkSecurityGroups/{networkSecurityGroupId}/securityRules") 5594 if err != nil { 5595 return nil, err 5596 } 5597 5598 var response ListNetworkSecurityGroupSecurityRulesResponse 5599 var httpResponse *http.Response 5600 httpResponse, err = client.Call(ctx, &httpRequest) 5601 defer common.CloseBodyIfValid(httpResponse) 5602 response.RawResponse = httpResponse 5603 if err != nil { 5604 return response, err 5605 } 5606 5607 err = common.UnmarshalResponse(httpResponse, &response) 5608 return response, err 5609} 5610 5611// ListNetworkSecurityGroupVnics Lists the VNICs in the specified network security group. 5612func (client VirtualNetworkClient) ListNetworkSecurityGroupVnics(ctx context.Context, request ListNetworkSecurityGroupVnicsRequest) (response ListNetworkSecurityGroupVnicsResponse, err error) { 5613 var ociResponse common.OCIResponse 5614 policy := common.NoRetryPolicy() 5615 if request.RetryPolicy() != nil { 5616 policy = *request.RetryPolicy() 5617 } 5618 ociResponse, err = common.Retry(ctx, request, client.listNetworkSecurityGroupVnics, policy) 5619 if err != nil { 5620 if ociResponse != nil { 5621 response = ListNetworkSecurityGroupVnicsResponse{RawResponse: ociResponse.HTTPResponse()} 5622 } 5623 return 5624 } 5625 if convertedResponse, ok := ociResponse.(ListNetworkSecurityGroupVnicsResponse); ok { 5626 response = convertedResponse 5627 } else { 5628 err = fmt.Errorf("failed to convert OCIResponse into ListNetworkSecurityGroupVnicsResponse") 5629 } 5630 return 5631} 5632 5633// listNetworkSecurityGroupVnics implements the OCIOperation interface (enables retrying operations) 5634func (client VirtualNetworkClient) listNetworkSecurityGroupVnics(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 5635 httpRequest, err := request.HTTPRequest(http.MethodGet, "/networkSecurityGroups/{networkSecurityGroupId}/vnics") 5636 if err != nil { 5637 return nil, err 5638 } 5639 5640 var response ListNetworkSecurityGroupVnicsResponse 5641 var httpResponse *http.Response 5642 httpResponse, err = client.Call(ctx, &httpRequest) 5643 defer common.CloseBodyIfValid(httpResponse) 5644 response.RawResponse = httpResponse 5645 if err != nil { 5646 return response, err 5647 } 5648 5649 err = common.UnmarshalResponse(httpResponse, &response) 5650 return response, err 5651} 5652 5653// ListNetworkSecurityGroups Lists the network security groups in the specified compartment. 5654func (client VirtualNetworkClient) ListNetworkSecurityGroups(ctx context.Context, request ListNetworkSecurityGroupsRequest) (response ListNetworkSecurityGroupsResponse, err error) { 5655 var ociResponse common.OCIResponse 5656 policy := common.NoRetryPolicy() 5657 if request.RetryPolicy() != nil { 5658 policy = *request.RetryPolicy() 5659 } 5660 ociResponse, err = common.Retry(ctx, request, client.listNetworkSecurityGroups, policy) 5661 if err != nil { 5662 if ociResponse != nil { 5663 response = ListNetworkSecurityGroupsResponse{RawResponse: ociResponse.HTTPResponse()} 5664 } 5665 return 5666 } 5667 if convertedResponse, ok := ociResponse.(ListNetworkSecurityGroupsResponse); ok { 5668 response = convertedResponse 5669 } else { 5670 err = fmt.Errorf("failed to convert OCIResponse into ListNetworkSecurityGroupsResponse") 5671 } 5672 return 5673} 5674 5675// listNetworkSecurityGroups implements the OCIOperation interface (enables retrying operations) 5676func (client VirtualNetworkClient) listNetworkSecurityGroups(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 5677 httpRequest, err := request.HTTPRequest(http.MethodGet, "/networkSecurityGroups") 5678 if err != nil { 5679 return nil, err 5680 } 5681 5682 var response ListNetworkSecurityGroupsResponse 5683 var httpResponse *http.Response 5684 httpResponse, err = client.Call(ctx, &httpRequest) 5685 defer common.CloseBodyIfValid(httpResponse) 5686 response.RawResponse = httpResponse 5687 if err != nil { 5688 return response, err 5689 } 5690 5691 err = common.UnmarshalResponse(httpResponse, &response) 5692 return response, err 5693} 5694 5695// ListPrivateIps Lists the PrivateIp objects based 5696// on one of these filters: 5697// - Subnet OCID. 5698// - VNIC OCID. 5699// - Both private IP address and subnet OCID: This lets 5700// you get a `privateIP` object based on its private IP 5701// address (for example, 10.0.3.3) and not its OCID. For comparison, 5702// GetPrivateIp 5703// requires the OCID. 5704// If you're listing all the private IPs associated with a given subnet 5705// or VNIC, the response includes both primary and secondary private IPs. 5706func (client VirtualNetworkClient) ListPrivateIps(ctx context.Context, request ListPrivateIpsRequest) (response ListPrivateIpsResponse, err error) { 5707 var ociResponse common.OCIResponse 5708 policy := common.NoRetryPolicy() 5709 if request.RetryPolicy() != nil { 5710 policy = *request.RetryPolicy() 5711 } 5712 ociResponse, err = common.Retry(ctx, request, client.listPrivateIps, policy) 5713 if err != nil { 5714 if ociResponse != nil { 5715 response = ListPrivateIpsResponse{RawResponse: ociResponse.HTTPResponse()} 5716 } 5717 return 5718 } 5719 if convertedResponse, ok := ociResponse.(ListPrivateIpsResponse); ok { 5720 response = convertedResponse 5721 } else { 5722 err = fmt.Errorf("failed to convert OCIResponse into ListPrivateIpsResponse") 5723 } 5724 return 5725} 5726 5727// listPrivateIps implements the OCIOperation interface (enables retrying operations) 5728func (client VirtualNetworkClient) listPrivateIps(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 5729 httpRequest, err := request.HTTPRequest(http.MethodGet, "/privateIps") 5730 if err != nil { 5731 return nil, err 5732 } 5733 5734 var response ListPrivateIpsResponse 5735 var httpResponse *http.Response 5736 httpResponse, err = client.Call(ctx, &httpRequest) 5737 defer common.CloseBodyIfValid(httpResponse) 5738 response.RawResponse = httpResponse 5739 if err != nil { 5740 return response, err 5741 } 5742 5743 err = common.UnmarshalResponse(httpResponse, &response) 5744 return response, err 5745} 5746 5747// ListPublicIps Lists the PublicIp objects 5748// in the specified compartment. You can filter the list by using query parameters. 5749// To list your reserved public IPs: 5750// * Set `scope` = `REGION` (required) 5751// * Leave the `availabilityDomain` parameter empty 5752// * Set `lifetime` = `RESERVED` 5753// To list the ephemeral public IPs assigned to a regional entity such as a NAT gateway: 5754// * Set `scope` = `REGION` (required) 5755// * Leave the `availabilityDomain` parameter empty 5756// * Set `lifetime` = `EPHEMERAL` 5757// To list the ephemeral public IPs assigned to private IPs: 5758// * Set `scope` = `AVAILABILITY_DOMAIN` (required) 5759// * Set the `availabilityDomain` parameter to the desired availability domain (required) 5760// * Set `lifetime` = `EPHEMERAL` 5761// **Note:** An ephemeral public IP assigned to a private IP 5762// is always in the same availability domain and compartment as the private IP. 5763func (client VirtualNetworkClient) ListPublicIps(ctx context.Context, request ListPublicIpsRequest) (response ListPublicIpsResponse, err error) { 5764 var ociResponse common.OCIResponse 5765 policy := common.NoRetryPolicy() 5766 if request.RetryPolicy() != nil { 5767 policy = *request.RetryPolicy() 5768 } 5769 ociResponse, err = common.Retry(ctx, request, client.listPublicIps, policy) 5770 if err != nil { 5771 if ociResponse != nil { 5772 response = ListPublicIpsResponse{RawResponse: ociResponse.HTTPResponse()} 5773 } 5774 return 5775 } 5776 if convertedResponse, ok := ociResponse.(ListPublicIpsResponse); ok { 5777 response = convertedResponse 5778 } else { 5779 err = fmt.Errorf("failed to convert OCIResponse into ListPublicIpsResponse") 5780 } 5781 return 5782} 5783 5784// listPublicIps implements the OCIOperation interface (enables retrying operations) 5785func (client VirtualNetworkClient) listPublicIps(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 5786 httpRequest, err := request.HTTPRequest(http.MethodGet, "/publicIps") 5787 if err != nil { 5788 return nil, err 5789 } 5790 5791 var response ListPublicIpsResponse 5792 var httpResponse *http.Response 5793 httpResponse, err = client.Call(ctx, &httpRequest) 5794 defer common.CloseBodyIfValid(httpResponse) 5795 response.RawResponse = httpResponse 5796 if err != nil { 5797 return response, err 5798 } 5799 5800 err = common.UnmarshalResponse(httpResponse, &response) 5801 return response, err 5802} 5803 5804// ListRemotePeeringConnections Lists the remote peering connections (RPCs) for the specified DRG and compartment 5805// (the RPC's compartment). 5806func (client VirtualNetworkClient) ListRemotePeeringConnections(ctx context.Context, request ListRemotePeeringConnectionsRequest) (response ListRemotePeeringConnectionsResponse, err error) { 5807 var ociResponse common.OCIResponse 5808 policy := common.NoRetryPolicy() 5809 if request.RetryPolicy() != nil { 5810 policy = *request.RetryPolicy() 5811 } 5812 ociResponse, err = common.Retry(ctx, request, client.listRemotePeeringConnections, policy) 5813 if err != nil { 5814 if ociResponse != nil { 5815 response = ListRemotePeeringConnectionsResponse{RawResponse: ociResponse.HTTPResponse()} 5816 } 5817 return 5818 } 5819 if convertedResponse, ok := ociResponse.(ListRemotePeeringConnectionsResponse); ok { 5820 response = convertedResponse 5821 } else { 5822 err = fmt.Errorf("failed to convert OCIResponse into ListRemotePeeringConnectionsResponse") 5823 } 5824 return 5825} 5826 5827// listRemotePeeringConnections implements the OCIOperation interface (enables retrying operations) 5828func (client VirtualNetworkClient) listRemotePeeringConnections(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 5829 httpRequest, err := request.HTTPRequest(http.MethodGet, "/remotePeeringConnections") 5830 if err != nil { 5831 return nil, err 5832 } 5833 5834 var response ListRemotePeeringConnectionsResponse 5835 var httpResponse *http.Response 5836 httpResponse, err = client.Call(ctx, &httpRequest) 5837 defer common.CloseBodyIfValid(httpResponse) 5838 response.RawResponse = httpResponse 5839 if err != nil { 5840 return response, err 5841 } 5842 5843 err = common.UnmarshalResponse(httpResponse, &response) 5844 return response, err 5845} 5846 5847// ListRouteTables Lists the route tables in the specified VCN and specified compartment. The response 5848// includes the default route table that automatically comes with each VCN, plus any route tables 5849// you've created. 5850func (client VirtualNetworkClient) ListRouteTables(ctx context.Context, request ListRouteTablesRequest) (response ListRouteTablesResponse, err error) { 5851 var ociResponse common.OCIResponse 5852 policy := common.NoRetryPolicy() 5853 if request.RetryPolicy() != nil { 5854 policy = *request.RetryPolicy() 5855 } 5856 ociResponse, err = common.Retry(ctx, request, client.listRouteTables, policy) 5857 if err != nil { 5858 if ociResponse != nil { 5859 response = ListRouteTablesResponse{RawResponse: ociResponse.HTTPResponse()} 5860 } 5861 return 5862 } 5863 if convertedResponse, ok := ociResponse.(ListRouteTablesResponse); ok { 5864 response = convertedResponse 5865 } else { 5866 err = fmt.Errorf("failed to convert OCIResponse into ListRouteTablesResponse") 5867 } 5868 return 5869} 5870 5871// listRouteTables implements the OCIOperation interface (enables retrying operations) 5872func (client VirtualNetworkClient) listRouteTables(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 5873 httpRequest, err := request.HTTPRequest(http.MethodGet, "/routeTables") 5874 if err != nil { 5875 return nil, err 5876 } 5877 5878 var response ListRouteTablesResponse 5879 var httpResponse *http.Response 5880 httpResponse, err = client.Call(ctx, &httpRequest) 5881 defer common.CloseBodyIfValid(httpResponse) 5882 response.RawResponse = httpResponse 5883 if err != nil { 5884 return response, err 5885 } 5886 5887 err = common.UnmarshalResponse(httpResponse, &response) 5888 return response, err 5889} 5890 5891// ListSecurityLists Lists the security lists in the specified VCN and compartment. 5892func (client VirtualNetworkClient) ListSecurityLists(ctx context.Context, request ListSecurityListsRequest) (response ListSecurityListsResponse, err error) { 5893 var ociResponse common.OCIResponse 5894 policy := common.NoRetryPolicy() 5895 if request.RetryPolicy() != nil { 5896 policy = *request.RetryPolicy() 5897 } 5898 ociResponse, err = common.Retry(ctx, request, client.listSecurityLists, policy) 5899 if err != nil { 5900 if ociResponse != nil { 5901 response = ListSecurityListsResponse{RawResponse: ociResponse.HTTPResponse()} 5902 } 5903 return 5904 } 5905 if convertedResponse, ok := ociResponse.(ListSecurityListsResponse); ok { 5906 response = convertedResponse 5907 } else { 5908 err = fmt.Errorf("failed to convert OCIResponse into ListSecurityListsResponse") 5909 } 5910 return 5911} 5912 5913// listSecurityLists implements the OCIOperation interface (enables retrying operations) 5914func (client VirtualNetworkClient) listSecurityLists(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 5915 httpRequest, err := request.HTTPRequest(http.MethodGet, "/securityLists") 5916 if err != nil { 5917 return nil, err 5918 } 5919 5920 var response ListSecurityListsResponse 5921 var httpResponse *http.Response 5922 httpResponse, err = client.Call(ctx, &httpRequest) 5923 defer common.CloseBodyIfValid(httpResponse) 5924 response.RawResponse = httpResponse 5925 if err != nil { 5926 return response, err 5927 } 5928 5929 err = common.UnmarshalResponse(httpResponse, &response) 5930 return response, err 5931} 5932 5933// ListServiceGateways Lists the service gateways in the specified compartment. You may optionally specify a VCN OCID 5934// to filter the results by VCN. 5935func (client VirtualNetworkClient) ListServiceGateways(ctx context.Context, request ListServiceGatewaysRequest) (response ListServiceGatewaysResponse, err error) { 5936 var ociResponse common.OCIResponse 5937 policy := common.NoRetryPolicy() 5938 if request.RetryPolicy() != nil { 5939 policy = *request.RetryPolicy() 5940 } 5941 ociResponse, err = common.Retry(ctx, request, client.listServiceGateways, policy) 5942 if err != nil { 5943 if ociResponse != nil { 5944 response = ListServiceGatewaysResponse{RawResponse: ociResponse.HTTPResponse()} 5945 } 5946 return 5947 } 5948 if convertedResponse, ok := ociResponse.(ListServiceGatewaysResponse); ok { 5949 response = convertedResponse 5950 } else { 5951 err = fmt.Errorf("failed to convert OCIResponse into ListServiceGatewaysResponse") 5952 } 5953 return 5954} 5955 5956// listServiceGateways implements the OCIOperation interface (enables retrying operations) 5957func (client VirtualNetworkClient) listServiceGateways(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 5958 httpRequest, err := request.HTTPRequest(http.MethodGet, "/serviceGateways") 5959 if err != nil { 5960 return nil, err 5961 } 5962 5963 var response ListServiceGatewaysResponse 5964 var httpResponse *http.Response 5965 httpResponse, err = client.Call(ctx, &httpRequest) 5966 defer common.CloseBodyIfValid(httpResponse) 5967 response.RawResponse = httpResponse 5968 if err != nil { 5969 return response, err 5970 } 5971 5972 err = common.UnmarshalResponse(httpResponse, &response) 5973 return response, err 5974} 5975 5976// ListServices Lists the available Service objects that you can enable for a 5977// service gateway in this region. 5978func (client VirtualNetworkClient) ListServices(ctx context.Context, request ListServicesRequest) (response ListServicesResponse, err error) { 5979 var ociResponse common.OCIResponse 5980 policy := common.NoRetryPolicy() 5981 if request.RetryPolicy() != nil { 5982 policy = *request.RetryPolicy() 5983 } 5984 ociResponse, err = common.Retry(ctx, request, client.listServices, policy) 5985 if err != nil { 5986 if ociResponse != nil { 5987 response = ListServicesResponse{RawResponse: ociResponse.HTTPResponse()} 5988 } 5989 return 5990 } 5991 if convertedResponse, ok := ociResponse.(ListServicesResponse); ok { 5992 response = convertedResponse 5993 } else { 5994 err = fmt.Errorf("failed to convert OCIResponse into ListServicesResponse") 5995 } 5996 return 5997} 5998 5999// listServices implements the OCIOperation interface (enables retrying operations) 6000func (client VirtualNetworkClient) listServices(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 6001 httpRequest, err := request.HTTPRequest(http.MethodGet, "/services") 6002 if err != nil { 6003 return nil, err 6004 } 6005 6006 var response ListServicesResponse 6007 var httpResponse *http.Response 6008 httpResponse, err = client.Call(ctx, &httpRequest) 6009 defer common.CloseBodyIfValid(httpResponse) 6010 response.RawResponse = httpResponse 6011 if err != nil { 6012 return response, err 6013 } 6014 6015 err = common.UnmarshalResponse(httpResponse, &response) 6016 return response, err 6017} 6018 6019// ListSubnets Lists the subnets in the specified VCN and the specified compartment. 6020func (client VirtualNetworkClient) ListSubnets(ctx context.Context, request ListSubnetsRequest) (response ListSubnetsResponse, err error) { 6021 var ociResponse common.OCIResponse 6022 policy := common.NoRetryPolicy() 6023 if request.RetryPolicy() != nil { 6024 policy = *request.RetryPolicy() 6025 } 6026 ociResponse, err = common.Retry(ctx, request, client.listSubnets, policy) 6027 if err != nil { 6028 if ociResponse != nil { 6029 response = ListSubnetsResponse{RawResponse: ociResponse.HTTPResponse()} 6030 } 6031 return 6032 } 6033 if convertedResponse, ok := ociResponse.(ListSubnetsResponse); ok { 6034 response = convertedResponse 6035 } else { 6036 err = fmt.Errorf("failed to convert OCIResponse into ListSubnetsResponse") 6037 } 6038 return 6039} 6040 6041// listSubnets implements the OCIOperation interface (enables retrying operations) 6042func (client VirtualNetworkClient) listSubnets(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 6043 httpRequest, err := request.HTTPRequest(http.MethodGet, "/subnets") 6044 if err != nil { 6045 return nil, err 6046 } 6047 6048 var response ListSubnetsResponse 6049 var httpResponse *http.Response 6050 httpResponse, err = client.Call(ctx, &httpRequest) 6051 defer common.CloseBodyIfValid(httpResponse) 6052 response.RawResponse = httpResponse 6053 if err != nil { 6054 return response, err 6055 } 6056 6057 err = common.UnmarshalResponse(httpResponse, &response) 6058 return response, err 6059} 6060 6061// ListVcns Lists the virtual cloud networks (VCNs) in the specified compartment. 6062func (client VirtualNetworkClient) ListVcns(ctx context.Context, request ListVcnsRequest) (response ListVcnsResponse, err error) { 6063 var ociResponse common.OCIResponse 6064 policy := common.NoRetryPolicy() 6065 if request.RetryPolicy() != nil { 6066 policy = *request.RetryPolicy() 6067 } 6068 ociResponse, err = common.Retry(ctx, request, client.listVcns, policy) 6069 if err != nil { 6070 if ociResponse != nil { 6071 response = ListVcnsResponse{RawResponse: ociResponse.HTTPResponse()} 6072 } 6073 return 6074 } 6075 if convertedResponse, ok := ociResponse.(ListVcnsResponse); ok { 6076 response = convertedResponse 6077 } else { 6078 err = fmt.Errorf("failed to convert OCIResponse into ListVcnsResponse") 6079 } 6080 return 6081} 6082 6083// listVcns implements the OCIOperation interface (enables retrying operations) 6084func (client VirtualNetworkClient) listVcns(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 6085 httpRequest, err := request.HTTPRequest(http.MethodGet, "/vcns") 6086 if err != nil { 6087 return nil, err 6088 } 6089 6090 var response ListVcnsResponse 6091 var httpResponse *http.Response 6092 httpResponse, err = client.Call(ctx, &httpRequest) 6093 defer common.CloseBodyIfValid(httpResponse) 6094 response.RawResponse = httpResponse 6095 if err != nil { 6096 return response, err 6097 } 6098 6099 err = common.UnmarshalResponse(httpResponse, &response) 6100 return response, err 6101} 6102 6103// ListVirtualCircuitBandwidthShapes The deprecated operation lists available bandwidth levels for virtual circuits. For the compartment ID, provide the OCID of your tenancy (the root compartment). 6104func (client VirtualNetworkClient) ListVirtualCircuitBandwidthShapes(ctx context.Context, request ListVirtualCircuitBandwidthShapesRequest) (response ListVirtualCircuitBandwidthShapesResponse, err error) { 6105 var ociResponse common.OCIResponse 6106 policy := common.NoRetryPolicy() 6107 if request.RetryPolicy() != nil { 6108 policy = *request.RetryPolicy() 6109 } 6110 ociResponse, err = common.Retry(ctx, request, client.listVirtualCircuitBandwidthShapes, policy) 6111 if err != nil { 6112 if ociResponse != nil { 6113 response = ListVirtualCircuitBandwidthShapesResponse{RawResponse: ociResponse.HTTPResponse()} 6114 } 6115 return 6116 } 6117 if convertedResponse, ok := ociResponse.(ListVirtualCircuitBandwidthShapesResponse); ok { 6118 response = convertedResponse 6119 } else { 6120 err = fmt.Errorf("failed to convert OCIResponse into ListVirtualCircuitBandwidthShapesResponse") 6121 } 6122 return 6123} 6124 6125// listVirtualCircuitBandwidthShapes implements the OCIOperation interface (enables retrying operations) 6126func (client VirtualNetworkClient) listVirtualCircuitBandwidthShapes(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 6127 httpRequest, err := request.HTTPRequest(http.MethodGet, "/virtualCircuitBandwidthShapes") 6128 if err != nil { 6129 return nil, err 6130 } 6131 6132 var response ListVirtualCircuitBandwidthShapesResponse 6133 var httpResponse *http.Response 6134 httpResponse, err = client.Call(ctx, &httpRequest) 6135 defer common.CloseBodyIfValid(httpResponse) 6136 response.RawResponse = httpResponse 6137 if err != nil { 6138 return response, err 6139 } 6140 6141 err = common.UnmarshalResponse(httpResponse, &response) 6142 return response, err 6143} 6144 6145// ListVirtualCircuitPublicPrefixes Lists the public IP prefixes and their details for the specified 6146// public virtual circuit. 6147func (client VirtualNetworkClient) ListVirtualCircuitPublicPrefixes(ctx context.Context, request ListVirtualCircuitPublicPrefixesRequest) (response ListVirtualCircuitPublicPrefixesResponse, err error) { 6148 var ociResponse common.OCIResponse 6149 policy := common.NoRetryPolicy() 6150 if request.RetryPolicy() != nil { 6151 policy = *request.RetryPolicy() 6152 } 6153 ociResponse, err = common.Retry(ctx, request, client.listVirtualCircuitPublicPrefixes, policy) 6154 if err != nil { 6155 if ociResponse != nil { 6156 response = ListVirtualCircuitPublicPrefixesResponse{RawResponse: ociResponse.HTTPResponse()} 6157 } 6158 return 6159 } 6160 if convertedResponse, ok := ociResponse.(ListVirtualCircuitPublicPrefixesResponse); ok { 6161 response = convertedResponse 6162 } else { 6163 err = fmt.Errorf("failed to convert OCIResponse into ListVirtualCircuitPublicPrefixesResponse") 6164 } 6165 return 6166} 6167 6168// listVirtualCircuitPublicPrefixes implements the OCIOperation interface (enables retrying operations) 6169func (client VirtualNetworkClient) listVirtualCircuitPublicPrefixes(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 6170 httpRequest, err := request.HTTPRequest(http.MethodGet, "/virtualCircuits/{virtualCircuitId}/publicPrefixes") 6171 if err != nil { 6172 return nil, err 6173 } 6174 6175 var response ListVirtualCircuitPublicPrefixesResponse 6176 var httpResponse *http.Response 6177 httpResponse, err = client.Call(ctx, &httpRequest) 6178 defer common.CloseBodyIfValid(httpResponse) 6179 response.RawResponse = httpResponse 6180 if err != nil { 6181 return response, err 6182 } 6183 6184 err = common.UnmarshalResponse(httpResponse, &response) 6185 return response, err 6186} 6187 6188// ListVirtualCircuits Lists the virtual circuits in the specified compartment. 6189func (client VirtualNetworkClient) ListVirtualCircuits(ctx context.Context, request ListVirtualCircuitsRequest) (response ListVirtualCircuitsResponse, err error) { 6190 var ociResponse common.OCIResponse 6191 policy := common.NoRetryPolicy() 6192 if request.RetryPolicy() != nil { 6193 policy = *request.RetryPolicy() 6194 } 6195 ociResponse, err = common.Retry(ctx, request, client.listVirtualCircuits, policy) 6196 if err != nil { 6197 if ociResponse != nil { 6198 response = ListVirtualCircuitsResponse{RawResponse: ociResponse.HTTPResponse()} 6199 } 6200 return 6201 } 6202 if convertedResponse, ok := ociResponse.(ListVirtualCircuitsResponse); ok { 6203 response = convertedResponse 6204 } else { 6205 err = fmt.Errorf("failed to convert OCIResponse into ListVirtualCircuitsResponse") 6206 } 6207 return 6208} 6209 6210// listVirtualCircuits implements the OCIOperation interface (enables retrying operations) 6211func (client VirtualNetworkClient) listVirtualCircuits(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 6212 httpRequest, err := request.HTTPRequest(http.MethodGet, "/virtualCircuits") 6213 if err != nil { 6214 return nil, err 6215 } 6216 6217 var response ListVirtualCircuitsResponse 6218 var httpResponse *http.Response 6219 httpResponse, err = client.Call(ctx, &httpRequest) 6220 defer common.CloseBodyIfValid(httpResponse) 6221 response.RawResponse = httpResponse 6222 if err != nil { 6223 return response, err 6224 } 6225 6226 err = common.UnmarshalResponse(httpResponse, &response) 6227 return response, err 6228} 6229 6230// RemoveNetworkSecurityGroupSecurityRules Removes one or more security rules from the specified network security group. 6231func (client VirtualNetworkClient) RemoveNetworkSecurityGroupSecurityRules(ctx context.Context, request RemoveNetworkSecurityGroupSecurityRulesRequest) (response RemoveNetworkSecurityGroupSecurityRulesResponse, err error) { 6232 var ociResponse common.OCIResponse 6233 policy := common.NoRetryPolicy() 6234 if request.RetryPolicy() != nil { 6235 policy = *request.RetryPolicy() 6236 } 6237 ociResponse, err = common.Retry(ctx, request, client.removeNetworkSecurityGroupSecurityRules, policy) 6238 if err != nil { 6239 if ociResponse != nil { 6240 response = RemoveNetworkSecurityGroupSecurityRulesResponse{RawResponse: ociResponse.HTTPResponse()} 6241 } 6242 return 6243 } 6244 if convertedResponse, ok := ociResponse.(RemoveNetworkSecurityGroupSecurityRulesResponse); ok { 6245 response = convertedResponse 6246 } else { 6247 err = fmt.Errorf("failed to convert OCIResponse into RemoveNetworkSecurityGroupSecurityRulesResponse") 6248 } 6249 return 6250} 6251 6252// removeNetworkSecurityGroupSecurityRules implements the OCIOperation interface (enables retrying operations) 6253func (client VirtualNetworkClient) removeNetworkSecurityGroupSecurityRules(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 6254 httpRequest, err := request.HTTPRequest(http.MethodPost, "/networkSecurityGroups/{networkSecurityGroupId}/actions/removeSecurityRules") 6255 if err != nil { 6256 return nil, err 6257 } 6258 6259 var response RemoveNetworkSecurityGroupSecurityRulesResponse 6260 var httpResponse *http.Response 6261 httpResponse, err = client.Call(ctx, &httpRequest) 6262 defer common.CloseBodyIfValid(httpResponse) 6263 response.RawResponse = httpResponse 6264 if err != nil { 6265 return response, err 6266 } 6267 6268 err = common.UnmarshalResponse(httpResponse, &response) 6269 return response, err 6270} 6271 6272// UpdateCpe Updates the specified CPE's display name or tags. 6273// Avoid entering confidential information. 6274func (client VirtualNetworkClient) UpdateCpe(ctx context.Context, request UpdateCpeRequest) (response UpdateCpeResponse, err error) { 6275 var ociResponse common.OCIResponse 6276 policy := common.NoRetryPolicy() 6277 if request.RetryPolicy() != nil { 6278 policy = *request.RetryPolicy() 6279 } 6280 ociResponse, err = common.Retry(ctx, request, client.updateCpe, policy) 6281 if err != nil { 6282 if ociResponse != nil { 6283 response = UpdateCpeResponse{RawResponse: ociResponse.HTTPResponse()} 6284 } 6285 return 6286 } 6287 if convertedResponse, ok := ociResponse.(UpdateCpeResponse); ok { 6288 response = convertedResponse 6289 } else { 6290 err = fmt.Errorf("failed to convert OCIResponse into UpdateCpeResponse") 6291 } 6292 return 6293} 6294 6295// updateCpe implements the OCIOperation interface (enables retrying operations) 6296func (client VirtualNetworkClient) updateCpe(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 6297 httpRequest, err := request.HTTPRequest(http.MethodPut, "/cpes/{cpeId}") 6298 if err != nil { 6299 return nil, err 6300 } 6301 6302 var response UpdateCpeResponse 6303 var httpResponse *http.Response 6304 httpResponse, err = client.Call(ctx, &httpRequest) 6305 defer common.CloseBodyIfValid(httpResponse) 6306 response.RawResponse = httpResponse 6307 if err != nil { 6308 return response, err 6309 } 6310 6311 err = common.UnmarshalResponse(httpResponse, &response) 6312 return response, err 6313} 6314 6315// UpdateCrossConnect Updates the specified cross-connect. 6316func (client VirtualNetworkClient) UpdateCrossConnect(ctx context.Context, request UpdateCrossConnectRequest) (response UpdateCrossConnectResponse, err error) { 6317 var ociResponse common.OCIResponse 6318 policy := common.NoRetryPolicy() 6319 if request.RetryPolicy() != nil { 6320 policy = *request.RetryPolicy() 6321 } 6322 ociResponse, err = common.Retry(ctx, request, client.updateCrossConnect, policy) 6323 if err != nil { 6324 if ociResponse != nil { 6325 response = UpdateCrossConnectResponse{RawResponse: ociResponse.HTTPResponse()} 6326 } 6327 return 6328 } 6329 if convertedResponse, ok := ociResponse.(UpdateCrossConnectResponse); ok { 6330 response = convertedResponse 6331 } else { 6332 err = fmt.Errorf("failed to convert OCIResponse into UpdateCrossConnectResponse") 6333 } 6334 return 6335} 6336 6337// updateCrossConnect implements the OCIOperation interface (enables retrying operations) 6338func (client VirtualNetworkClient) updateCrossConnect(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 6339 httpRequest, err := request.HTTPRequest(http.MethodPut, "/crossConnects/{crossConnectId}") 6340 if err != nil { 6341 return nil, err 6342 } 6343 6344 var response UpdateCrossConnectResponse 6345 var httpResponse *http.Response 6346 httpResponse, err = client.Call(ctx, &httpRequest) 6347 defer common.CloseBodyIfValid(httpResponse) 6348 response.RawResponse = httpResponse 6349 if err != nil { 6350 return response, err 6351 } 6352 6353 err = common.UnmarshalResponse(httpResponse, &response) 6354 return response, err 6355} 6356 6357// UpdateCrossConnectGroup Updates the specified cross-connect group's display name. 6358// Avoid entering confidential information. 6359func (client VirtualNetworkClient) UpdateCrossConnectGroup(ctx context.Context, request UpdateCrossConnectGroupRequest) (response UpdateCrossConnectGroupResponse, err error) { 6360 var ociResponse common.OCIResponse 6361 policy := common.NoRetryPolicy() 6362 if request.RetryPolicy() != nil { 6363 policy = *request.RetryPolicy() 6364 } 6365 ociResponse, err = common.Retry(ctx, request, client.updateCrossConnectGroup, policy) 6366 if err != nil { 6367 if ociResponse != nil { 6368 response = UpdateCrossConnectGroupResponse{RawResponse: ociResponse.HTTPResponse()} 6369 } 6370 return 6371 } 6372 if convertedResponse, ok := ociResponse.(UpdateCrossConnectGroupResponse); ok { 6373 response = convertedResponse 6374 } else { 6375 err = fmt.Errorf("failed to convert OCIResponse into UpdateCrossConnectGroupResponse") 6376 } 6377 return 6378} 6379 6380// updateCrossConnectGroup implements the OCIOperation interface (enables retrying operations) 6381func (client VirtualNetworkClient) updateCrossConnectGroup(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 6382 httpRequest, err := request.HTTPRequest(http.MethodPut, "/crossConnectGroups/{crossConnectGroupId}") 6383 if err != nil { 6384 return nil, err 6385 } 6386 6387 var response UpdateCrossConnectGroupResponse 6388 var httpResponse *http.Response 6389 httpResponse, err = client.Call(ctx, &httpRequest) 6390 defer common.CloseBodyIfValid(httpResponse) 6391 response.RawResponse = httpResponse 6392 if err != nil { 6393 return response, err 6394 } 6395 6396 err = common.UnmarshalResponse(httpResponse, &response) 6397 return response, err 6398} 6399 6400// UpdateDhcpOptions Updates the specified set of DHCP options. You can update the display name or the options 6401// themselves. Avoid entering confidential information. 6402// Note that the `options` object you provide replaces the entire existing set of options. 6403func (client VirtualNetworkClient) UpdateDhcpOptions(ctx context.Context, request UpdateDhcpOptionsRequest) (response UpdateDhcpOptionsResponse, err error) { 6404 var ociResponse common.OCIResponse 6405 policy := common.NoRetryPolicy() 6406 if request.RetryPolicy() != nil { 6407 policy = *request.RetryPolicy() 6408 } 6409 ociResponse, err = common.Retry(ctx, request, client.updateDhcpOptions, policy) 6410 if err != nil { 6411 if ociResponse != nil { 6412 response = UpdateDhcpOptionsResponse{RawResponse: ociResponse.HTTPResponse()} 6413 } 6414 return 6415 } 6416 if convertedResponse, ok := ociResponse.(UpdateDhcpOptionsResponse); ok { 6417 response = convertedResponse 6418 } else { 6419 err = fmt.Errorf("failed to convert OCIResponse into UpdateDhcpOptionsResponse") 6420 } 6421 return 6422} 6423 6424// updateDhcpOptions implements the OCIOperation interface (enables retrying operations) 6425func (client VirtualNetworkClient) updateDhcpOptions(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 6426 httpRequest, err := request.HTTPRequest(http.MethodPut, "/dhcps/{dhcpId}") 6427 if err != nil { 6428 return nil, err 6429 } 6430 6431 var response UpdateDhcpOptionsResponse 6432 var httpResponse *http.Response 6433 httpResponse, err = client.Call(ctx, &httpRequest) 6434 defer common.CloseBodyIfValid(httpResponse) 6435 response.RawResponse = httpResponse 6436 if err != nil { 6437 return response, err 6438 } 6439 6440 err = common.UnmarshalResponse(httpResponse, &response) 6441 return response, err 6442} 6443 6444// UpdateDrg Updates the specified DRG's display name or tags. Avoid entering confidential information. 6445func (client VirtualNetworkClient) UpdateDrg(ctx context.Context, request UpdateDrgRequest) (response UpdateDrgResponse, err error) { 6446 var ociResponse common.OCIResponse 6447 policy := common.NoRetryPolicy() 6448 if request.RetryPolicy() != nil { 6449 policy = *request.RetryPolicy() 6450 } 6451 ociResponse, err = common.Retry(ctx, request, client.updateDrg, policy) 6452 if err != nil { 6453 if ociResponse != nil { 6454 response = UpdateDrgResponse{RawResponse: ociResponse.HTTPResponse()} 6455 } 6456 return 6457 } 6458 if convertedResponse, ok := ociResponse.(UpdateDrgResponse); ok { 6459 response = convertedResponse 6460 } else { 6461 err = fmt.Errorf("failed to convert OCIResponse into UpdateDrgResponse") 6462 } 6463 return 6464} 6465 6466// updateDrg implements the OCIOperation interface (enables retrying operations) 6467func (client VirtualNetworkClient) updateDrg(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 6468 httpRequest, err := request.HTTPRequest(http.MethodPut, "/drgs/{drgId}") 6469 if err != nil { 6470 return nil, err 6471 } 6472 6473 var response UpdateDrgResponse 6474 var httpResponse *http.Response 6475 httpResponse, err = client.Call(ctx, &httpRequest) 6476 defer common.CloseBodyIfValid(httpResponse) 6477 response.RawResponse = httpResponse 6478 if err != nil { 6479 return response, err 6480 } 6481 6482 err = common.UnmarshalResponse(httpResponse, &response) 6483 return response, err 6484} 6485 6486// UpdateDrgAttachment Updates the display name for the specified `DrgAttachment`. 6487// Avoid entering confidential information. 6488func (client VirtualNetworkClient) UpdateDrgAttachment(ctx context.Context, request UpdateDrgAttachmentRequest) (response UpdateDrgAttachmentResponse, err error) { 6489 var ociResponse common.OCIResponse 6490 policy := common.NoRetryPolicy() 6491 if request.RetryPolicy() != nil { 6492 policy = *request.RetryPolicy() 6493 } 6494 ociResponse, err = common.Retry(ctx, request, client.updateDrgAttachment, policy) 6495 if err != nil { 6496 if ociResponse != nil { 6497 response = UpdateDrgAttachmentResponse{RawResponse: ociResponse.HTTPResponse()} 6498 } 6499 return 6500 } 6501 if convertedResponse, ok := ociResponse.(UpdateDrgAttachmentResponse); ok { 6502 response = convertedResponse 6503 } else { 6504 err = fmt.Errorf("failed to convert OCIResponse into UpdateDrgAttachmentResponse") 6505 } 6506 return 6507} 6508 6509// updateDrgAttachment implements the OCIOperation interface (enables retrying operations) 6510func (client VirtualNetworkClient) updateDrgAttachment(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 6511 httpRequest, err := request.HTTPRequest(http.MethodPut, "/drgAttachments/{drgAttachmentId}") 6512 if err != nil { 6513 return nil, err 6514 } 6515 6516 var response UpdateDrgAttachmentResponse 6517 var httpResponse *http.Response 6518 httpResponse, err = client.Call(ctx, &httpRequest) 6519 defer common.CloseBodyIfValid(httpResponse) 6520 response.RawResponse = httpResponse 6521 if err != nil { 6522 return response, err 6523 } 6524 6525 err = common.UnmarshalResponse(httpResponse, &response) 6526 return response, err 6527} 6528 6529// UpdateIPSecConnection Updates the specified IPSec connection. 6530// To update an individual IPSec tunnel's attributes, use 6531// UpdateIPSecConnectionTunnel. 6532func (client VirtualNetworkClient) UpdateIPSecConnection(ctx context.Context, request UpdateIPSecConnectionRequest) (response UpdateIPSecConnectionResponse, err error) { 6533 var ociResponse common.OCIResponse 6534 policy := common.NoRetryPolicy() 6535 if request.RetryPolicy() != nil { 6536 policy = *request.RetryPolicy() 6537 } 6538 ociResponse, err = common.Retry(ctx, request, client.updateIPSecConnection, policy) 6539 if err != nil { 6540 if ociResponse != nil { 6541 response = UpdateIPSecConnectionResponse{RawResponse: ociResponse.HTTPResponse()} 6542 } 6543 return 6544 } 6545 if convertedResponse, ok := ociResponse.(UpdateIPSecConnectionResponse); ok { 6546 response = convertedResponse 6547 } else { 6548 err = fmt.Errorf("failed to convert OCIResponse into UpdateIPSecConnectionResponse") 6549 } 6550 return 6551} 6552 6553// updateIPSecConnection implements the OCIOperation interface (enables retrying operations) 6554func (client VirtualNetworkClient) updateIPSecConnection(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 6555 httpRequest, err := request.HTTPRequest(http.MethodPut, "/ipsecConnections/{ipscId}") 6556 if err != nil { 6557 return nil, err 6558 } 6559 6560 var response UpdateIPSecConnectionResponse 6561 var httpResponse *http.Response 6562 httpResponse, err = client.Call(ctx, &httpRequest) 6563 defer common.CloseBodyIfValid(httpResponse) 6564 response.RawResponse = httpResponse 6565 if err != nil { 6566 return response, err 6567 } 6568 6569 err = common.UnmarshalResponse(httpResponse, &response) 6570 return response, err 6571} 6572 6573// UpdateIPSecConnectionTunnel Updates the specified tunnel. This operation lets you change tunnel attributes such as the 6574// routing type (BGP dynamic routing or static routing). Here are some important notes: 6575// * If you change the tunnel's routing type or BGP session configuration, the tunnel will go 6576// down while it's reprovisioned. 6577// * If you want to switch the tunnel's `routing` from `STATIC` to `BGP`, make sure the tunnel's 6578// BGP session configuration attributes have been set (BgpSessionInfo). 6579// * If you want to switch the tunnel's `routing` from `BGP` to `STATIC`, make sure the 6580// IPSecConnection already has at least one valid CIDR 6581// static route. 6582func (client VirtualNetworkClient) UpdateIPSecConnectionTunnel(ctx context.Context, request UpdateIPSecConnectionTunnelRequest) (response UpdateIPSecConnectionTunnelResponse, err error) { 6583 var ociResponse common.OCIResponse 6584 policy := common.NoRetryPolicy() 6585 if request.RetryPolicy() != nil { 6586 policy = *request.RetryPolicy() 6587 } 6588 ociResponse, err = common.Retry(ctx, request, client.updateIPSecConnectionTunnel, policy) 6589 if err != nil { 6590 if ociResponse != nil { 6591 response = UpdateIPSecConnectionTunnelResponse{RawResponse: ociResponse.HTTPResponse()} 6592 } 6593 return 6594 } 6595 if convertedResponse, ok := ociResponse.(UpdateIPSecConnectionTunnelResponse); ok { 6596 response = convertedResponse 6597 } else { 6598 err = fmt.Errorf("failed to convert OCIResponse into UpdateIPSecConnectionTunnelResponse") 6599 } 6600 return 6601} 6602 6603// updateIPSecConnectionTunnel implements the OCIOperation interface (enables retrying operations) 6604func (client VirtualNetworkClient) updateIPSecConnectionTunnel(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 6605 httpRequest, err := request.HTTPRequest(http.MethodPut, "/ipsecConnections/{ipscId}/tunnels/{tunnelId}") 6606 if err != nil { 6607 return nil, err 6608 } 6609 6610 var response UpdateIPSecConnectionTunnelResponse 6611 var httpResponse *http.Response 6612 httpResponse, err = client.Call(ctx, &httpRequest) 6613 defer common.CloseBodyIfValid(httpResponse) 6614 response.RawResponse = httpResponse 6615 if err != nil { 6616 return response, err 6617 } 6618 6619 err = common.UnmarshalResponse(httpResponse, &response) 6620 return response, err 6621} 6622 6623// UpdateIPSecConnectionTunnelSharedSecret Updates the shared secret (pre-shared key) for the specified tunnel. 6624// **Important:** If you change the shared secret, the tunnel will go down while it's reprovisioned. 6625func (client VirtualNetworkClient) UpdateIPSecConnectionTunnelSharedSecret(ctx context.Context, request UpdateIPSecConnectionTunnelSharedSecretRequest) (response UpdateIPSecConnectionTunnelSharedSecretResponse, err error) { 6626 var ociResponse common.OCIResponse 6627 policy := common.NoRetryPolicy() 6628 if request.RetryPolicy() != nil { 6629 policy = *request.RetryPolicy() 6630 } 6631 ociResponse, err = common.Retry(ctx, request, client.updateIPSecConnectionTunnelSharedSecret, policy) 6632 if err != nil { 6633 if ociResponse != nil { 6634 response = UpdateIPSecConnectionTunnelSharedSecretResponse{RawResponse: ociResponse.HTTPResponse()} 6635 } 6636 return 6637 } 6638 if convertedResponse, ok := ociResponse.(UpdateIPSecConnectionTunnelSharedSecretResponse); ok { 6639 response = convertedResponse 6640 } else { 6641 err = fmt.Errorf("failed to convert OCIResponse into UpdateIPSecConnectionTunnelSharedSecretResponse") 6642 } 6643 return 6644} 6645 6646// updateIPSecConnectionTunnelSharedSecret implements the OCIOperation interface (enables retrying operations) 6647func (client VirtualNetworkClient) updateIPSecConnectionTunnelSharedSecret(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 6648 httpRequest, err := request.HTTPRequest(http.MethodPut, "/ipsecConnections/{ipscId}/tunnels/{tunnelId}/sharedSecret") 6649 if err != nil { 6650 return nil, err 6651 } 6652 6653 var response UpdateIPSecConnectionTunnelSharedSecretResponse 6654 var httpResponse *http.Response 6655 httpResponse, err = client.Call(ctx, &httpRequest) 6656 defer common.CloseBodyIfValid(httpResponse) 6657 response.RawResponse = httpResponse 6658 if err != nil { 6659 return response, err 6660 } 6661 6662 err = common.UnmarshalResponse(httpResponse, &response) 6663 return response, err 6664} 6665 6666// UpdateInternetGateway Updates the specified internet gateway. You can disable/enable it, or change its display name 6667// or tags. Avoid entering confidential information. 6668// If the gateway is disabled, that means no traffic will flow to/from the internet even if there's 6669// a route rule that enables that traffic. 6670func (client VirtualNetworkClient) UpdateInternetGateway(ctx context.Context, request UpdateInternetGatewayRequest) (response UpdateInternetGatewayResponse, err error) { 6671 var ociResponse common.OCIResponse 6672 policy := common.NoRetryPolicy() 6673 if request.RetryPolicy() != nil { 6674 policy = *request.RetryPolicy() 6675 } 6676 ociResponse, err = common.Retry(ctx, request, client.updateInternetGateway, policy) 6677 if err != nil { 6678 if ociResponse != nil { 6679 response = UpdateInternetGatewayResponse{RawResponse: ociResponse.HTTPResponse()} 6680 } 6681 return 6682 } 6683 if convertedResponse, ok := ociResponse.(UpdateInternetGatewayResponse); ok { 6684 response = convertedResponse 6685 } else { 6686 err = fmt.Errorf("failed to convert OCIResponse into UpdateInternetGatewayResponse") 6687 } 6688 return 6689} 6690 6691// updateInternetGateway implements the OCIOperation interface (enables retrying operations) 6692func (client VirtualNetworkClient) updateInternetGateway(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 6693 httpRequest, err := request.HTTPRequest(http.MethodPut, "/internetGateways/{igId}") 6694 if err != nil { 6695 return nil, err 6696 } 6697 6698 var response UpdateInternetGatewayResponse 6699 var httpResponse *http.Response 6700 httpResponse, err = client.Call(ctx, &httpRequest) 6701 defer common.CloseBodyIfValid(httpResponse) 6702 response.RawResponse = httpResponse 6703 if err != nil { 6704 return response, err 6705 } 6706 6707 err = common.UnmarshalResponse(httpResponse, &response) 6708 return response, err 6709} 6710 6711// UpdateIpv6 Updates the specified IPv6. You must specify the object's OCID. 6712// Use this operation if you want to: 6713// * Move an IPv6 to a different VNIC in the same subnet. 6714// * Enable/disable internet access for an IPv6. 6715// * Change the display name for an IPv6. 6716// * Update resource tags for an IPv6. 6717func (client VirtualNetworkClient) UpdateIpv6(ctx context.Context, request UpdateIpv6Request) (response UpdateIpv6Response, err error) { 6718 var ociResponse common.OCIResponse 6719 policy := common.NoRetryPolicy() 6720 if request.RetryPolicy() != nil { 6721 policy = *request.RetryPolicy() 6722 } 6723 ociResponse, err = common.Retry(ctx, request, client.updateIpv6, policy) 6724 if err != nil { 6725 if ociResponse != nil { 6726 response = UpdateIpv6Response{RawResponse: ociResponse.HTTPResponse()} 6727 } 6728 return 6729 } 6730 if convertedResponse, ok := ociResponse.(UpdateIpv6Response); ok { 6731 response = convertedResponse 6732 } else { 6733 err = fmt.Errorf("failed to convert OCIResponse into UpdateIpv6Response") 6734 } 6735 return 6736} 6737 6738// updateIpv6 implements the OCIOperation interface (enables retrying operations) 6739func (client VirtualNetworkClient) updateIpv6(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 6740 httpRequest, err := request.HTTPRequest(http.MethodPut, "/ipv6/{ipv6Id}") 6741 if err != nil { 6742 return nil, err 6743 } 6744 6745 var response UpdateIpv6Response 6746 var httpResponse *http.Response 6747 httpResponse, err = client.Call(ctx, &httpRequest) 6748 defer common.CloseBodyIfValid(httpResponse) 6749 response.RawResponse = httpResponse 6750 if err != nil { 6751 return response, err 6752 } 6753 6754 err = common.UnmarshalResponse(httpResponse, &response) 6755 return response, err 6756} 6757 6758// UpdateLocalPeeringGateway Updates the specified local peering gateway (LPG). 6759func (client VirtualNetworkClient) UpdateLocalPeeringGateway(ctx context.Context, request UpdateLocalPeeringGatewayRequest) (response UpdateLocalPeeringGatewayResponse, err error) { 6760 var ociResponse common.OCIResponse 6761 policy := common.NoRetryPolicy() 6762 if request.RetryPolicy() != nil { 6763 policy = *request.RetryPolicy() 6764 } 6765 ociResponse, err = common.Retry(ctx, request, client.updateLocalPeeringGateway, policy) 6766 if err != nil { 6767 if ociResponse != nil { 6768 response = UpdateLocalPeeringGatewayResponse{RawResponse: ociResponse.HTTPResponse()} 6769 } 6770 return 6771 } 6772 if convertedResponse, ok := ociResponse.(UpdateLocalPeeringGatewayResponse); ok { 6773 response = convertedResponse 6774 } else { 6775 err = fmt.Errorf("failed to convert OCIResponse into UpdateLocalPeeringGatewayResponse") 6776 } 6777 return 6778} 6779 6780// updateLocalPeeringGateway implements the OCIOperation interface (enables retrying operations) 6781func (client VirtualNetworkClient) updateLocalPeeringGateway(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 6782 httpRequest, err := request.HTTPRequest(http.MethodPut, "/localPeeringGateways/{localPeeringGatewayId}") 6783 if err != nil { 6784 return nil, err 6785 } 6786 6787 var response UpdateLocalPeeringGatewayResponse 6788 var httpResponse *http.Response 6789 httpResponse, err = client.Call(ctx, &httpRequest) 6790 defer common.CloseBodyIfValid(httpResponse) 6791 response.RawResponse = httpResponse 6792 if err != nil { 6793 return response, err 6794 } 6795 6796 err = common.UnmarshalResponse(httpResponse, &response) 6797 return response, err 6798} 6799 6800// UpdateNatGateway Updates the specified NAT gateway. 6801func (client VirtualNetworkClient) UpdateNatGateway(ctx context.Context, request UpdateNatGatewayRequest) (response UpdateNatGatewayResponse, err error) { 6802 var ociResponse common.OCIResponse 6803 policy := common.NoRetryPolicy() 6804 if request.RetryPolicy() != nil { 6805 policy = *request.RetryPolicy() 6806 } 6807 ociResponse, err = common.Retry(ctx, request, client.updateNatGateway, policy) 6808 if err != nil { 6809 if ociResponse != nil { 6810 response = UpdateNatGatewayResponse{RawResponse: ociResponse.HTTPResponse()} 6811 } 6812 return 6813 } 6814 if convertedResponse, ok := ociResponse.(UpdateNatGatewayResponse); ok { 6815 response = convertedResponse 6816 } else { 6817 err = fmt.Errorf("failed to convert OCIResponse into UpdateNatGatewayResponse") 6818 } 6819 return 6820} 6821 6822// updateNatGateway implements the OCIOperation interface (enables retrying operations) 6823func (client VirtualNetworkClient) updateNatGateway(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 6824 httpRequest, err := request.HTTPRequest(http.MethodPut, "/natGateways/{natGatewayId}") 6825 if err != nil { 6826 return nil, err 6827 } 6828 6829 var response UpdateNatGatewayResponse 6830 var httpResponse *http.Response 6831 httpResponse, err = client.Call(ctx, &httpRequest) 6832 defer common.CloseBodyIfValid(httpResponse) 6833 response.RawResponse = httpResponse 6834 if err != nil { 6835 return response, err 6836 } 6837 6838 err = common.UnmarshalResponse(httpResponse, &response) 6839 return response, err 6840} 6841 6842// UpdateNetworkSecurityGroup Updates the specified network security group. 6843// To add or remove an existing VNIC from the group, use 6844// UpdateVnic. 6845// To add a VNIC to the group *when you create the VNIC*, specify the NSG's OCID during creation. 6846// For example, see the `nsgIds` attribute in CreateVnicDetails. 6847// To add or remove security rules from the group, use 6848// AddNetworkSecurityGroupSecurityRules 6849// or 6850// RemoveNetworkSecurityGroupSecurityRules. 6851// To edit the contents of existing security rules in the group, use 6852// UpdateNetworkSecurityGroupSecurityRules. 6853func (client VirtualNetworkClient) UpdateNetworkSecurityGroup(ctx context.Context, request UpdateNetworkSecurityGroupRequest) (response UpdateNetworkSecurityGroupResponse, err error) { 6854 var ociResponse common.OCIResponse 6855 policy := common.NoRetryPolicy() 6856 if request.RetryPolicy() != nil { 6857 policy = *request.RetryPolicy() 6858 } 6859 ociResponse, err = common.Retry(ctx, request, client.updateNetworkSecurityGroup, policy) 6860 if err != nil { 6861 if ociResponse != nil { 6862 response = UpdateNetworkSecurityGroupResponse{RawResponse: ociResponse.HTTPResponse()} 6863 } 6864 return 6865 } 6866 if convertedResponse, ok := ociResponse.(UpdateNetworkSecurityGroupResponse); ok { 6867 response = convertedResponse 6868 } else { 6869 err = fmt.Errorf("failed to convert OCIResponse into UpdateNetworkSecurityGroupResponse") 6870 } 6871 return 6872} 6873 6874// updateNetworkSecurityGroup implements the OCIOperation interface (enables retrying operations) 6875func (client VirtualNetworkClient) updateNetworkSecurityGroup(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 6876 httpRequest, err := request.HTTPRequest(http.MethodPut, "/networkSecurityGroups/{networkSecurityGroupId}") 6877 if err != nil { 6878 return nil, err 6879 } 6880 6881 var response UpdateNetworkSecurityGroupResponse 6882 var httpResponse *http.Response 6883 httpResponse, err = client.Call(ctx, &httpRequest) 6884 defer common.CloseBodyIfValid(httpResponse) 6885 response.RawResponse = httpResponse 6886 if err != nil { 6887 return response, err 6888 } 6889 6890 err = common.UnmarshalResponse(httpResponse, &response) 6891 return response, err 6892} 6893 6894// UpdateNetworkSecurityGroupSecurityRules Updates one or more security rules in the specified network security group. 6895func (client VirtualNetworkClient) UpdateNetworkSecurityGroupSecurityRules(ctx context.Context, request UpdateNetworkSecurityGroupSecurityRulesRequest) (response UpdateNetworkSecurityGroupSecurityRulesResponse, err error) { 6896 var ociResponse common.OCIResponse 6897 policy := common.NoRetryPolicy() 6898 if request.RetryPolicy() != nil { 6899 policy = *request.RetryPolicy() 6900 } 6901 ociResponse, err = common.Retry(ctx, request, client.updateNetworkSecurityGroupSecurityRules, policy) 6902 if err != nil { 6903 if ociResponse != nil { 6904 response = UpdateNetworkSecurityGroupSecurityRulesResponse{RawResponse: ociResponse.HTTPResponse()} 6905 } 6906 return 6907 } 6908 if convertedResponse, ok := ociResponse.(UpdateNetworkSecurityGroupSecurityRulesResponse); ok { 6909 response = convertedResponse 6910 } else { 6911 err = fmt.Errorf("failed to convert OCIResponse into UpdateNetworkSecurityGroupSecurityRulesResponse") 6912 } 6913 return 6914} 6915 6916// updateNetworkSecurityGroupSecurityRules implements the OCIOperation interface (enables retrying operations) 6917func (client VirtualNetworkClient) updateNetworkSecurityGroupSecurityRules(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 6918 httpRequest, err := request.HTTPRequest(http.MethodPost, "/networkSecurityGroups/{networkSecurityGroupId}/actions/updateSecurityRules") 6919 if err != nil { 6920 return nil, err 6921 } 6922 6923 var response UpdateNetworkSecurityGroupSecurityRulesResponse 6924 var httpResponse *http.Response 6925 httpResponse, err = client.Call(ctx, &httpRequest) 6926 defer common.CloseBodyIfValid(httpResponse) 6927 response.RawResponse = httpResponse 6928 if err != nil { 6929 return response, err 6930 } 6931 6932 err = common.UnmarshalResponse(httpResponse, &response) 6933 return response, err 6934} 6935 6936// UpdatePrivateIp Updates the specified private IP. You must specify the object's OCID. 6937// Use this operation if you want to: 6938// - Move a secondary private IP to a different VNIC in the same subnet. 6939// - Change the display name for a secondary private IP. 6940// - Change the hostname for a secondary private IP. 6941// This operation cannot be used with primary private IPs. 6942// To update the hostname for the primary IP on a VNIC, use 6943// UpdateVnic. 6944func (client VirtualNetworkClient) UpdatePrivateIp(ctx context.Context, request UpdatePrivateIpRequest) (response UpdatePrivateIpResponse, err error) { 6945 var ociResponse common.OCIResponse 6946 policy := common.NoRetryPolicy() 6947 if request.RetryPolicy() != nil { 6948 policy = *request.RetryPolicy() 6949 } 6950 ociResponse, err = common.Retry(ctx, request, client.updatePrivateIp, policy) 6951 if err != nil { 6952 if ociResponse != nil { 6953 response = UpdatePrivateIpResponse{RawResponse: ociResponse.HTTPResponse()} 6954 } 6955 return 6956 } 6957 if convertedResponse, ok := ociResponse.(UpdatePrivateIpResponse); ok { 6958 response = convertedResponse 6959 } else { 6960 err = fmt.Errorf("failed to convert OCIResponse into UpdatePrivateIpResponse") 6961 } 6962 return 6963} 6964 6965// updatePrivateIp implements the OCIOperation interface (enables retrying operations) 6966func (client VirtualNetworkClient) updatePrivateIp(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 6967 httpRequest, err := request.HTTPRequest(http.MethodPut, "/privateIps/{privateIpId}") 6968 if err != nil { 6969 return nil, err 6970 } 6971 6972 var response UpdatePrivateIpResponse 6973 var httpResponse *http.Response 6974 httpResponse, err = client.Call(ctx, &httpRequest) 6975 defer common.CloseBodyIfValid(httpResponse) 6976 response.RawResponse = httpResponse 6977 if err != nil { 6978 return response, err 6979 } 6980 6981 err = common.UnmarshalResponse(httpResponse, &response) 6982 return response, err 6983} 6984 6985// UpdatePublicIp Updates the specified public IP. You must specify the object's OCID. Use this operation if you want to: 6986// * Assign a reserved public IP in your pool to a private IP. 6987// * Move a reserved public IP to a different private IP. 6988// * Unassign a reserved public IP from a private IP (which returns it to your pool 6989// of reserved public IPs). 6990// * Change the display name or tags for a public IP. 6991// Assigning, moving, and unassigning a reserved public IP are asynchronous 6992// operations. Poll the public IP's `lifecycleState` to determine if the operation 6993// succeeded. 6994// **Note:** When moving a reserved public IP, the target private IP 6995// must not already have a public IP with `lifecycleState` = ASSIGNING or ASSIGNED. If it 6996// does, an error is returned. Also, the initial unassignment from the original 6997// private IP always succeeds, but the assignment to the target private IP is asynchronous and 6998// could fail silently (for example, if the target private IP is deleted or has a different public IP 6999// assigned to it in the interim). If that occurs, the public IP remains unassigned and its 7000// `lifecycleState` switches to AVAILABLE (it is not reassigned to its original private IP). 7001// You must poll the public IP's `lifecycleState` to determine if the move succeeded. 7002// Regarding ephemeral public IPs: 7003// * If you want to assign an ephemeral public IP to a primary private IP, use 7004// CreatePublicIp. 7005// * You can't move an ephemeral public IP to a different private IP. 7006// * If you want to unassign an ephemeral public IP from its private IP, use 7007// DeletePublicIp, which 7008// unassigns and deletes the ephemeral public IP. 7009// **Note:** If a public IP is assigned to a secondary private 7010// IP (see PrivateIp), and you move that secondary 7011// private IP to another VNIC, the public IP moves with it. 7012// **Note:** There's a limit to the number of PublicIp 7013// a VNIC or instance can have. If you try to move a reserved public IP 7014// to a VNIC or instance that has already reached its public IP limit, an error is 7015// returned. For information about the public IP limits, see 7016// Public IP Addresses (https://docs.cloud.oracle.com/Content/Network/Tasks/managingpublicIPs.htm). 7017func (client VirtualNetworkClient) UpdatePublicIp(ctx context.Context, request UpdatePublicIpRequest) (response UpdatePublicIpResponse, err error) { 7018 var ociResponse common.OCIResponse 7019 policy := common.NoRetryPolicy() 7020 if request.RetryPolicy() != nil { 7021 policy = *request.RetryPolicy() 7022 } 7023 ociResponse, err = common.Retry(ctx, request, client.updatePublicIp, policy) 7024 if err != nil { 7025 if ociResponse != nil { 7026 response = UpdatePublicIpResponse{RawResponse: ociResponse.HTTPResponse()} 7027 } 7028 return 7029 } 7030 if convertedResponse, ok := ociResponse.(UpdatePublicIpResponse); ok { 7031 response = convertedResponse 7032 } else { 7033 err = fmt.Errorf("failed to convert OCIResponse into UpdatePublicIpResponse") 7034 } 7035 return 7036} 7037 7038// updatePublicIp implements the OCIOperation interface (enables retrying operations) 7039func (client VirtualNetworkClient) updatePublicIp(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 7040 httpRequest, err := request.HTTPRequest(http.MethodPut, "/publicIps/{publicIpId}") 7041 if err != nil { 7042 return nil, err 7043 } 7044 7045 var response UpdatePublicIpResponse 7046 var httpResponse *http.Response 7047 httpResponse, err = client.Call(ctx, &httpRequest) 7048 defer common.CloseBodyIfValid(httpResponse) 7049 response.RawResponse = httpResponse 7050 if err != nil { 7051 return response, err 7052 } 7053 7054 err = common.UnmarshalResponse(httpResponse, &response) 7055 return response, err 7056} 7057 7058// UpdateRemotePeeringConnection Updates the specified remote peering connection (RPC). 7059func (client VirtualNetworkClient) UpdateRemotePeeringConnection(ctx context.Context, request UpdateRemotePeeringConnectionRequest) (response UpdateRemotePeeringConnectionResponse, err error) { 7060 var ociResponse common.OCIResponse 7061 policy := common.NoRetryPolicy() 7062 if request.RetryPolicy() != nil { 7063 policy = *request.RetryPolicy() 7064 } 7065 ociResponse, err = common.Retry(ctx, request, client.updateRemotePeeringConnection, policy) 7066 if err != nil { 7067 if ociResponse != nil { 7068 response = UpdateRemotePeeringConnectionResponse{RawResponse: ociResponse.HTTPResponse()} 7069 } 7070 return 7071 } 7072 if convertedResponse, ok := ociResponse.(UpdateRemotePeeringConnectionResponse); ok { 7073 response = convertedResponse 7074 } else { 7075 err = fmt.Errorf("failed to convert OCIResponse into UpdateRemotePeeringConnectionResponse") 7076 } 7077 return 7078} 7079 7080// updateRemotePeeringConnection implements the OCIOperation interface (enables retrying operations) 7081func (client VirtualNetworkClient) updateRemotePeeringConnection(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 7082 httpRequest, err := request.HTTPRequest(http.MethodPut, "/remotePeeringConnections/{remotePeeringConnectionId}") 7083 if err != nil { 7084 return nil, err 7085 } 7086 7087 var response UpdateRemotePeeringConnectionResponse 7088 var httpResponse *http.Response 7089 httpResponse, err = client.Call(ctx, &httpRequest) 7090 defer common.CloseBodyIfValid(httpResponse) 7091 response.RawResponse = httpResponse 7092 if err != nil { 7093 return response, err 7094 } 7095 7096 err = common.UnmarshalResponse(httpResponse, &response) 7097 return response, err 7098} 7099 7100// UpdateRouteTable Updates the specified route table's display name or route rules. 7101// Avoid entering confidential information. 7102// Note that the `routeRules` object you provide replaces the entire existing set of rules. 7103func (client VirtualNetworkClient) UpdateRouteTable(ctx context.Context, request UpdateRouteTableRequest) (response UpdateRouteTableResponse, err error) { 7104 var ociResponse common.OCIResponse 7105 policy := common.NoRetryPolicy() 7106 if request.RetryPolicy() != nil { 7107 policy = *request.RetryPolicy() 7108 } 7109 ociResponse, err = common.Retry(ctx, request, client.updateRouteTable, policy) 7110 if err != nil { 7111 if ociResponse != nil { 7112 response = UpdateRouteTableResponse{RawResponse: ociResponse.HTTPResponse()} 7113 } 7114 return 7115 } 7116 if convertedResponse, ok := ociResponse.(UpdateRouteTableResponse); ok { 7117 response = convertedResponse 7118 } else { 7119 err = fmt.Errorf("failed to convert OCIResponse into UpdateRouteTableResponse") 7120 } 7121 return 7122} 7123 7124// updateRouteTable implements the OCIOperation interface (enables retrying operations) 7125func (client VirtualNetworkClient) updateRouteTable(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 7126 httpRequest, err := request.HTTPRequest(http.MethodPut, "/routeTables/{rtId}") 7127 if err != nil { 7128 return nil, err 7129 } 7130 7131 var response UpdateRouteTableResponse 7132 var httpResponse *http.Response 7133 httpResponse, err = client.Call(ctx, &httpRequest) 7134 defer common.CloseBodyIfValid(httpResponse) 7135 response.RawResponse = httpResponse 7136 if err != nil { 7137 return response, err 7138 } 7139 7140 err = common.UnmarshalResponse(httpResponse, &response) 7141 return response, err 7142} 7143 7144// UpdateSecurityList Updates the specified security list's display name or rules. 7145// Avoid entering confidential information. 7146// Note that the `egressSecurityRules` or `ingressSecurityRules` objects you provide replace the entire 7147// existing objects. 7148func (client VirtualNetworkClient) UpdateSecurityList(ctx context.Context, request UpdateSecurityListRequest) (response UpdateSecurityListResponse, err error) { 7149 var ociResponse common.OCIResponse 7150 policy := common.NoRetryPolicy() 7151 if request.RetryPolicy() != nil { 7152 policy = *request.RetryPolicy() 7153 } 7154 ociResponse, err = common.Retry(ctx, request, client.updateSecurityList, policy) 7155 if err != nil { 7156 if ociResponse != nil { 7157 response = UpdateSecurityListResponse{RawResponse: ociResponse.HTTPResponse()} 7158 } 7159 return 7160 } 7161 if convertedResponse, ok := ociResponse.(UpdateSecurityListResponse); ok { 7162 response = convertedResponse 7163 } else { 7164 err = fmt.Errorf("failed to convert OCIResponse into UpdateSecurityListResponse") 7165 } 7166 return 7167} 7168 7169// updateSecurityList implements the OCIOperation interface (enables retrying operations) 7170func (client VirtualNetworkClient) updateSecurityList(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 7171 httpRequest, err := request.HTTPRequest(http.MethodPut, "/securityLists/{securityListId}") 7172 if err != nil { 7173 return nil, err 7174 } 7175 7176 var response UpdateSecurityListResponse 7177 var httpResponse *http.Response 7178 httpResponse, err = client.Call(ctx, &httpRequest) 7179 defer common.CloseBodyIfValid(httpResponse) 7180 response.RawResponse = httpResponse 7181 if err != nil { 7182 return response, err 7183 } 7184 7185 err = common.UnmarshalResponse(httpResponse, &response) 7186 return response, err 7187} 7188 7189// UpdateServiceGateway Updates the specified service gateway. The information you provide overwrites the existing 7190// attributes of the gateway. 7191func (client VirtualNetworkClient) UpdateServiceGateway(ctx context.Context, request UpdateServiceGatewayRequest) (response UpdateServiceGatewayResponse, err error) { 7192 var ociResponse common.OCIResponse 7193 policy := common.NoRetryPolicy() 7194 if request.RetryPolicy() != nil { 7195 policy = *request.RetryPolicy() 7196 } 7197 ociResponse, err = common.Retry(ctx, request, client.updateServiceGateway, policy) 7198 if err != nil { 7199 if ociResponse != nil { 7200 response = UpdateServiceGatewayResponse{RawResponse: ociResponse.HTTPResponse()} 7201 } 7202 return 7203 } 7204 if convertedResponse, ok := ociResponse.(UpdateServiceGatewayResponse); ok { 7205 response = convertedResponse 7206 } else { 7207 err = fmt.Errorf("failed to convert OCIResponse into UpdateServiceGatewayResponse") 7208 } 7209 return 7210} 7211 7212// updateServiceGateway implements the OCIOperation interface (enables retrying operations) 7213func (client VirtualNetworkClient) updateServiceGateway(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 7214 httpRequest, err := request.HTTPRequest(http.MethodPut, "/serviceGateways/{serviceGatewayId}") 7215 if err != nil { 7216 return nil, err 7217 } 7218 7219 var response UpdateServiceGatewayResponse 7220 var httpResponse *http.Response 7221 httpResponse, err = client.Call(ctx, &httpRequest) 7222 defer common.CloseBodyIfValid(httpResponse) 7223 response.RawResponse = httpResponse 7224 if err != nil { 7225 return response, err 7226 } 7227 7228 err = common.UnmarshalResponse(httpResponse, &response) 7229 return response, err 7230} 7231 7232// UpdateSubnet Updates the specified subnet. 7233func (client VirtualNetworkClient) UpdateSubnet(ctx context.Context, request UpdateSubnetRequest) (response UpdateSubnetResponse, err error) { 7234 var ociResponse common.OCIResponse 7235 policy := common.NoRetryPolicy() 7236 if request.RetryPolicy() != nil { 7237 policy = *request.RetryPolicy() 7238 } 7239 ociResponse, err = common.Retry(ctx, request, client.updateSubnet, policy) 7240 if err != nil { 7241 if ociResponse != nil { 7242 response = UpdateSubnetResponse{RawResponse: ociResponse.HTTPResponse()} 7243 } 7244 return 7245 } 7246 if convertedResponse, ok := ociResponse.(UpdateSubnetResponse); ok { 7247 response = convertedResponse 7248 } else { 7249 err = fmt.Errorf("failed to convert OCIResponse into UpdateSubnetResponse") 7250 } 7251 return 7252} 7253 7254// updateSubnet implements the OCIOperation interface (enables retrying operations) 7255func (client VirtualNetworkClient) updateSubnet(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 7256 httpRequest, err := request.HTTPRequest(http.MethodPut, "/subnets/{subnetId}") 7257 if err != nil { 7258 return nil, err 7259 } 7260 7261 var response UpdateSubnetResponse 7262 var httpResponse *http.Response 7263 httpResponse, err = client.Call(ctx, &httpRequest) 7264 defer common.CloseBodyIfValid(httpResponse) 7265 response.RawResponse = httpResponse 7266 if err != nil { 7267 return response, err 7268 } 7269 7270 err = common.UnmarshalResponse(httpResponse, &response) 7271 return response, err 7272} 7273 7274// UpdateVcn Updates the specified VCN. 7275func (client VirtualNetworkClient) UpdateVcn(ctx context.Context, request UpdateVcnRequest) (response UpdateVcnResponse, err error) { 7276 var ociResponse common.OCIResponse 7277 policy := common.NoRetryPolicy() 7278 if request.RetryPolicy() != nil { 7279 policy = *request.RetryPolicy() 7280 } 7281 ociResponse, err = common.Retry(ctx, request, client.updateVcn, policy) 7282 if err != nil { 7283 if ociResponse != nil { 7284 response = UpdateVcnResponse{RawResponse: ociResponse.HTTPResponse()} 7285 } 7286 return 7287 } 7288 if convertedResponse, ok := ociResponse.(UpdateVcnResponse); ok { 7289 response = convertedResponse 7290 } else { 7291 err = fmt.Errorf("failed to convert OCIResponse into UpdateVcnResponse") 7292 } 7293 return 7294} 7295 7296// updateVcn implements the OCIOperation interface (enables retrying operations) 7297func (client VirtualNetworkClient) updateVcn(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 7298 httpRequest, err := request.HTTPRequest(http.MethodPut, "/vcns/{vcnId}") 7299 if err != nil { 7300 return nil, err 7301 } 7302 7303 var response UpdateVcnResponse 7304 var httpResponse *http.Response 7305 httpResponse, err = client.Call(ctx, &httpRequest) 7306 defer common.CloseBodyIfValid(httpResponse) 7307 response.RawResponse = httpResponse 7308 if err != nil { 7309 return response, err 7310 } 7311 7312 err = common.UnmarshalResponse(httpResponse, &response) 7313 return response, err 7314} 7315 7316// UpdateVirtualCircuit Updates the specified virtual circuit. This can be called by 7317// either the customer who owns the virtual circuit, or the 7318// provider (when provisioning or de-provisioning the virtual 7319// circuit from their end). The documentation for 7320// UpdateVirtualCircuitDetails 7321// indicates who can update each property of the virtual circuit. 7322// **Important:** If the virtual circuit is working and in the 7323// PROVISIONED state, updating any of the network-related properties 7324// (such as the DRG being used, the BGP ASN, and so on) will cause the virtual 7325// circuit's state to switch to PROVISIONING and the related BGP 7326// session to go down. After Oracle re-provisions the virtual circuit, 7327// its state will return to PROVISIONED. Make sure you confirm that 7328// the associated BGP session is back up. For more information 7329// about the various states and how to test connectivity, see 7330// FastConnect Overview (https://docs.cloud.oracle.com/Content/Network/Concepts/fastconnect.htm). 7331// To change the list of public IP prefixes for a public virtual circuit, 7332// use BulkAddVirtualCircuitPublicPrefixes 7333// and 7334// BulkDeleteVirtualCircuitPublicPrefixes. 7335// Updating the list of prefixes does NOT cause the BGP session to go down. However, 7336// Oracle must verify the customer's ownership of each added prefix before 7337// traffic for that prefix will flow across the virtual circuit. 7338func (client VirtualNetworkClient) UpdateVirtualCircuit(ctx context.Context, request UpdateVirtualCircuitRequest) (response UpdateVirtualCircuitResponse, err error) { 7339 var ociResponse common.OCIResponse 7340 policy := common.NoRetryPolicy() 7341 if request.RetryPolicy() != nil { 7342 policy = *request.RetryPolicy() 7343 } 7344 ociResponse, err = common.Retry(ctx, request, client.updateVirtualCircuit, policy) 7345 if err != nil { 7346 if ociResponse != nil { 7347 response = UpdateVirtualCircuitResponse{RawResponse: ociResponse.HTTPResponse()} 7348 } 7349 return 7350 } 7351 if convertedResponse, ok := ociResponse.(UpdateVirtualCircuitResponse); ok { 7352 response = convertedResponse 7353 } else { 7354 err = fmt.Errorf("failed to convert OCIResponse into UpdateVirtualCircuitResponse") 7355 } 7356 return 7357} 7358 7359// updateVirtualCircuit implements the OCIOperation interface (enables retrying operations) 7360func (client VirtualNetworkClient) updateVirtualCircuit(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 7361 httpRequest, err := request.HTTPRequest(http.MethodPut, "/virtualCircuits/{virtualCircuitId}") 7362 if err != nil { 7363 return nil, err 7364 } 7365 7366 var response UpdateVirtualCircuitResponse 7367 var httpResponse *http.Response 7368 httpResponse, err = client.Call(ctx, &httpRequest) 7369 defer common.CloseBodyIfValid(httpResponse) 7370 response.RawResponse = httpResponse 7371 if err != nil { 7372 return response, err 7373 } 7374 7375 err = common.UnmarshalResponse(httpResponse, &response) 7376 return response, err 7377} 7378 7379// UpdateVnic Updates the specified VNIC. 7380func (client VirtualNetworkClient) UpdateVnic(ctx context.Context, request UpdateVnicRequest) (response UpdateVnicResponse, err error) { 7381 var ociResponse common.OCIResponse 7382 policy := common.NoRetryPolicy() 7383 if request.RetryPolicy() != nil { 7384 policy = *request.RetryPolicy() 7385 } 7386 ociResponse, err = common.Retry(ctx, request, client.updateVnic, policy) 7387 if err != nil { 7388 if ociResponse != nil { 7389 response = UpdateVnicResponse{RawResponse: ociResponse.HTTPResponse()} 7390 } 7391 return 7392 } 7393 if convertedResponse, ok := ociResponse.(UpdateVnicResponse); ok { 7394 response = convertedResponse 7395 } else { 7396 err = fmt.Errorf("failed to convert OCIResponse into UpdateVnicResponse") 7397 } 7398 return 7399} 7400 7401// updateVnic implements the OCIOperation interface (enables retrying operations) 7402func (client VirtualNetworkClient) updateVnic(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 7403 httpRequest, err := request.HTTPRequest(http.MethodPut, "/vnics/{vnicId}") 7404 if err != nil { 7405 return nil, err 7406 } 7407 7408 var response UpdateVnicResponse 7409 var httpResponse *http.Response 7410 httpResponse, err = client.Call(ctx, &httpRequest) 7411 defer common.CloseBodyIfValid(httpResponse) 7412 response.RawResponse = httpResponse 7413 if err != nil { 7414 return response, err 7415 } 7416 7417 err = common.UnmarshalResponse(httpResponse, &response) 7418 return response, err 7419} 7420