1// Copyright (c) 2016, 2018, 2020, Oracle and/or its affiliates. All rights reserved. 2// This software is dual-licensed to you under the Universal Permissive License (UPL) 1.0 as shown at https://oss.oracle.com/licenses/upl or Apache License 2.0 as shown at http://www.apache.org/licenses/LICENSE-2.0. You may choose either license. 3// Code generated. DO NOT EDIT. 4 5// Blockchain Platform Control Plane API 6// 7// Blockchain Platform Control Plane API 8// 9 10package blockchain 11 12import ( 13 "context" 14 "fmt" 15 "github.com/oracle/oci-go-sdk/common" 16 "net/http" 17) 18 19//BlockchainPlatformClient a client for BlockchainPlatform 20type BlockchainPlatformClient struct { 21 common.BaseClient 22 config *common.ConfigurationProvider 23} 24 25// NewBlockchainPlatformClientWithConfigurationProvider Creates a new default BlockchainPlatform client with the given configuration provider. 26// the configuration provider will be used for the default signer as well as reading the region 27func NewBlockchainPlatformClientWithConfigurationProvider(configProvider common.ConfigurationProvider) (client BlockchainPlatformClient, err error) { 28 baseClient, err := common.NewClientWithConfig(configProvider) 29 if err != nil { 30 return 31 } 32 33 return newBlockchainPlatformClientFromBaseClient(baseClient, configProvider) 34} 35 36// NewBlockchainPlatformClientWithOboToken Creates a new default BlockchainPlatform client with the given configuration provider. 37// The obotoken will be added to default headers and signed; the configuration provider will be used for the signer 38// as well as reading the region 39func NewBlockchainPlatformClientWithOboToken(configProvider common.ConfigurationProvider, oboToken string) (client BlockchainPlatformClient, err error) { 40 baseClient, err := common.NewClientWithOboToken(configProvider, oboToken) 41 if err != nil { 42 return 43 } 44 45 return newBlockchainPlatformClientFromBaseClient(baseClient, configProvider) 46} 47 48func newBlockchainPlatformClientFromBaseClient(baseClient common.BaseClient, configProvider common.ConfigurationProvider) (client BlockchainPlatformClient, err error) { 49 client = BlockchainPlatformClient{BaseClient: baseClient} 50 client.BasePath = "20191010" 51 err = client.setConfigurationProvider(configProvider) 52 return 53} 54 55// SetRegion overrides the region of this client. 56func (client *BlockchainPlatformClient) SetRegion(region string) { 57 client.Host = common.StringToRegion(region).EndpointForTemplate("blockchain", "https://blockchain.{region}.oci.{secondLevelDomain}") 58} 59 60// SetConfigurationProvider sets the configuration provider including the region, returns an error if is not valid 61func (client *BlockchainPlatformClient) setConfigurationProvider(configProvider common.ConfigurationProvider) error { 62 if ok, err := common.IsConfigurationProviderValid(configProvider); !ok { 63 return err 64 } 65 66 // Error has been checked already 67 region, _ := configProvider.Region() 68 client.SetRegion(region) 69 client.config = &configProvider 70 return nil 71} 72 73// ConfigurationProvider the ConfigurationProvider used in this client, or null if none set 74func (client *BlockchainPlatformClient) ConfigurationProvider() *common.ConfigurationProvider { 75 return client.config 76} 77 78// ChangeBlockchainPlatformCompartment Change Blockchain Platform Compartment 79func (client BlockchainPlatformClient) ChangeBlockchainPlatformCompartment(ctx context.Context, request ChangeBlockchainPlatformCompartmentRequest) (response ChangeBlockchainPlatformCompartmentResponse, err error) { 80 var ociResponse common.OCIResponse 81 policy := common.NoRetryPolicy() 82 if request.RetryPolicy() != nil { 83 policy = *request.RetryPolicy() 84 } 85 86 if !(request.OpcRetryToken != nil && *request.OpcRetryToken != "") { 87 request.OpcRetryToken = common.String(common.RetryToken()) 88 } 89 90 ociResponse, err = common.Retry(ctx, request, client.changeBlockchainPlatformCompartment, policy) 91 if err != nil { 92 if ociResponse != nil { 93 if httpResponse := ociResponse.HTTPResponse(); httpResponse != nil { 94 opcRequestId := httpResponse.Header.Get("opc-request-id") 95 response = ChangeBlockchainPlatformCompartmentResponse{RawResponse: httpResponse, OpcRequestId: &opcRequestId} 96 } else { 97 response = ChangeBlockchainPlatformCompartmentResponse{} 98 } 99 } 100 return 101 } 102 if convertedResponse, ok := ociResponse.(ChangeBlockchainPlatformCompartmentResponse); ok { 103 response = convertedResponse 104 } else { 105 err = fmt.Errorf("failed to convert OCIResponse into ChangeBlockchainPlatformCompartmentResponse") 106 } 107 return 108} 109 110// changeBlockchainPlatformCompartment implements the OCIOperation interface (enables retrying operations) 111func (client BlockchainPlatformClient) changeBlockchainPlatformCompartment(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 112 httpRequest, err := request.HTTPRequest(http.MethodPost, "/blockchainPlatforms/{blockchainPlatformId}/actions/changeCompartment") 113 if err != nil { 114 return nil, err 115 } 116 117 var response ChangeBlockchainPlatformCompartmentResponse 118 var httpResponse *http.Response 119 httpResponse, err = client.Call(ctx, &httpRequest) 120 defer common.CloseBodyIfValid(httpResponse) 121 response.RawResponse = httpResponse 122 if err != nil { 123 return response, err 124 } 125 126 err = common.UnmarshalResponse(httpResponse, &response) 127 return response, err 128} 129 130// CreateBlockchainPlatform Creates a new Blockchain Platform. 131func (client BlockchainPlatformClient) CreateBlockchainPlatform(ctx context.Context, request CreateBlockchainPlatformRequest) (response CreateBlockchainPlatformResponse, err error) { 132 var ociResponse common.OCIResponse 133 policy := common.NoRetryPolicy() 134 if request.RetryPolicy() != nil { 135 policy = *request.RetryPolicy() 136 } 137 138 if !(request.OpcRetryToken != nil && *request.OpcRetryToken != "") { 139 request.OpcRetryToken = common.String(common.RetryToken()) 140 } 141 142 ociResponse, err = common.Retry(ctx, request, client.createBlockchainPlatform, policy) 143 if err != nil { 144 if ociResponse != nil { 145 if httpResponse := ociResponse.HTTPResponse(); httpResponse != nil { 146 opcRequestId := httpResponse.Header.Get("opc-request-id") 147 response = CreateBlockchainPlatformResponse{RawResponse: httpResponse, OpcRequestId: &opcRequestId} 148 } else { 149 response = CreateBlockchainPlatformResponse{} 150 } 151 } 152 return 153 } 154 if convertedResponse, ok := ociResponse.(CreateBlockchainPlatformResponse); ok { 155 response = convertedResponse 156 } else { 157 err = fmt.Errorf("failed to convert OCIResponse into CreateBlockchainPlatformResponse") 158 } 159 return 160} 161 162// createBlockchainPlatform implements the OCIOperation interface (enables retrying operations) 163func (client BlockchainPlatformClient) createBlockchainPlatform(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 164 httpRequest, err := request.HTTPRequest(http.MethodPost, "/blockchainPlatforms") 165 if err != nil { 166 return nil, err 167 } 168 169 var response CreateBlockchainPlatformResponse 170 var httpResponse *http.Response 171 httpResponse, err = client.Call(ctx, &httpRequest) 172 defer common.CloseBodyIfValid(httpResponse) 173 response.RawResponse = httpResponse 174 if err != nil { 175 return response, err 176 } 177 178 err = common.UnmarshalResponse(httpResponse, &response) 179 return response, err 180} 181 182// CreateOsn Create Blockchain Platform Osn 183func (client BlockchainPlatformClient) CreateOsn(ctx context.Context, request CreateOsnRequest) (response CreateOsnResponse, err error) { 184 var ociResponse common.OCIResponse 185 policy := common.NoRetryPolicy() 186 if request.RetryPolicy() != nil { 187 policy = *request.RetryPolicy() 188 } 189 190 if !(request.OpcRetryToken != nil && *request.OpcRetryToken != "") { 191 request.OpcRetryToken = common.String(common.RetryToken()) 192 } 193 194 ociResponse, err = common.Retry(ctx, request, client.createOsn, policy) 195 if err != nil { 196 if ociResponse != nil { 197 if httpResponse := ociResponse.HTTPResponse(); httpResponse != nil { 198 opcRequestId := httpResponse.Header.Get("opc-request-id") 199 response = CreateOsnResponse{RawResponse: httpResponse, OpcRequestId: &opcRequestId} 200 } else { 201 response = CreateOsnResponse{} 202 } 203 } 204 return 205 } 206 if convertedResponse, ok := ociResponse.(CreateOsnResponse); ok { 207 response = convertedResponse 208 } else { 209 err = fmt.Errorf("failed to convert OCIResponse into CreateOsnResponse") 210 } 211 return 212} 213 214// createOsn implements the OCIOperation interface (enables retrying operations) 215func (client BlockchainPlatformClient) createOsn(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 216 httpRequest, err := request.HTTPRequest(http.MethodPost, "/blockchainPlatforms/{blockchainPlatformId}/osns") 217 if err != nil { 218 return nil, err 219 } 220 221 var response CreateOsnResponse 222 var httpResponse *http.Response 223 httpResponse, err = client.Call(ctx, &httpRequest) 224 defer common.CloseBodyIfValid(httpResponse) 225 response.RawResponse = httpResponse 226 if err != nil { 227 return response, err 228 } 229 230 err = common.UnmarshalResponse(httpResponse, &response) 231 return response, err 232} 233 234// CreatePeer Create Blockchain Platform Peer 235func (client BlockchainPlatformClient) CreatePeer(ctx context.Context, request CreatePeerRequest) (response CreatePeerResponse, err error) { 236 var ociResponse common.OCIResponse 237 policy := common.NoRetryPolicy() 238 if request.RetryPolicy() != nil { 239 policy = *request.RetryPolicy() 240 } 241 242 if !(request.OpcRetryToken != nil && *request.OpcRetryToken != "") { 243 request.OpcRetryToken = common.String(common.RetryToken()) 244 } 245 246 ociResponse, err = common.Retry(ctx, request, client.createPeer, policy) 247 if err != nil { 248 if ociResponse != nil { 249 if httpResponse := ociResponse.HTTPResponse(); httpResponse != nil { 250 opcRequestId := httpResponse.Header.Get("opc-request-id") 251 response = CreatePeerResponse{RawResponse: httpResponse, OpcRequestId: &opcRequestId} 252 } else { 253 response = CreatePeerResponse{} 254 } 255 } 256 return 257 } 258 if convertedResponse, ok := ociResponse.(CreatePeerResponse); ok { 259 response = convertedResponse 260 } else { 261 err = fmt.Errorf("failed to convert OCIResponse into CreatePeerResponse") 262 } 263 return 264} 265 266// createPeer implements the OCIOperation interface (enables retrying operations) 267func (client BlockchainPlatformClient) createPeer(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 268 httpRequest, err := request.HTTPRequest(http.MethodPost, "/blockchainPlatforms/{blockchainPlatformId}/peers") 269 if err != nil { 270 return nil, err 271 } 272 273 var response CreatePeerResponse 274 var httpResponse *http.Response 275 httpResponse, err = client.Call(ctx, &httpRequest) 276 defer common.CloseBodyIfValid(httpResponse) 277 response.RawResponse = httpResponse 278 if err != nil { 279 return response, err 280 } 281 282 err = common.UnmarshalResponse(httpResponse, &response) 283 return response, err 284} 285 286// DeleteBlockchainPlatform Delete a particular of a Blockchain Platform 287func (client BlockchainPlatformClient) DeleteBlockchainPlatform(ctx context.Context, request DeleteBlockchainPlatformRequest) (response DeleteBlockchainPlatformResponse, err error) { 288 var ociResponse common.OCIResponse 289 policy := common.NoRetryPolicy() 290 if request.RetryPolicy() != nil { 291 policy = *request.RetryPolicy() 292 } 293 ociResponse, err = common.Retry(ctx, request, client.deleteBlockchainPlatform, policy) 294 if err != nil { 295 if ociResponse != nil { 296 if httpResponse := ociResponse.HTTPResponse(); httpResponse != nil { 297 opcRequestId := httpResponse.Header.Get("opc-request-id") 298 response = DeleteBlockchainPlatformResponse{RawResponse: httpResponse, OpcRequestId: &opcRequestId} 299 } else { 300 response = DeleteBlockchainPlatformResponse{} 301 } 302 } 303 return 304 } 305 if convertedResponse, ok := ociResponse.(DeleteBlockchainPlatformResponse); ok { 306 response = convertedResponse 307 } else { 308 err = fmt.Errorf("failed to convert OCIResponse into DeleteBlockchainPlatformResponse") 309 } 310 return 311} 312 313// deleteBlockchainPlatform implements the OCIOperation interface (enables retrying operations) 314func (client BlockchainPlatformClient) deleteBlockchainPlatform(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 315 httpRequest, err := request.HTTPRequest(http.MethodDelete, "/blockchainPlatforms/{blockchainPlatformId}") 316 if err != nil { 317 return nil, err 318 } 319 320 var response DeleteBlockchainPlatformResponse 321 var httpResponse *http.Response 322 httpResponse, err = client.Call(ctx, &httpRequest) 323 defer common.CloseBodyIfValid(httpResponse) 324 response.RawResponse = httpResponse 325 if err != nil { 326 return response, err 327 } 328 329 err = common.UnmarshalResponse(httpResponse, &response) 330 return response, err 331} 332 333// DeleteOsn Delete a particular OSN of a Blockchain Platform 334func (client BlockchainPlatformClient) DeleteOsn(ctx context.Context, request DeleteOsnRequest) (response DeleteOsnResponse, err error) { 335 var ociResponse common.OCIResponse 336 policy := common.NoRetryPolicy() 337 if request.RetryPolicy() != nil { 338 policy = *request.RetryPolicy() 339 } 340 ociResponse, err = common.Retry(ctx, request, client.deleteOsn, policy) 341 if err != nil { 342 if ociResponse != nil { 343 if httpResponse := ociResponse.HTTPResponse(); httpResponse != nil { 344 opcRequestId := httpResponse.Header.Get("opc-request-id") 345 response = DeleteOsnResponse{RawResponse: httpResponse, OpcRequestId: &opcRequestId} 346 } else { 347 response = DeleteOsnResponse{} 348 } 349 } 350 return 351 } 352 if convertedResponse, ok := ociResponse.(DeleteOsnResponse); ok { 353 response = convertedResponse 354 } else { 355 err = fmt.Errorf("failed to convert OCIResponse into DeleteOsnResponse") 356 } 357 return 358} 359 360// deleteOsn implements the OCIOperation interface (enables retrying operations) 361func (client BlockchainPlatformClient) deleteOsn(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 362 httpRequest, err := request.HTTPRequest(http.MethodDelete, "/blockchainPlatforms/{blockchainPlatformId}/osns/{osnId}") 363 if err != nil { 364 return nil, err 365 } 366 367 var response DeleteOsnResponse 368 var httpResponse *http.Response 369 httpResponse, err = client.Call(ctx, &httpRequest) 370 defer common.CloseBodyIfValid(httpResponse) 371 response.RawResponse = httpResponse 372 if err != nil { 373 return response, err 374 } 375 376 err = common.UnmarshalResponse(httpResponse, &response) 377 return response, err 378} 379 380// DeletePeer Delete a particular peer of a Blockchain Platform 381func (client BlockchainPlatformClient) DeletePeer(ctx context.Context, request DeletePeerRequest) (response DeletePeerResponse, err error) { 382 var ociResponse common.OCIResponse 383 policy := common.NoRetryPolicy() 384 if request.RetryPolicy() != nil { 385 policy = *request.RetryPolicy() 386 } 387 ociResponse, err = common.Retry(ctx, request, client.deletePeer, policy) 388 if err != nil { 389 if ociResponse != nil { 390 if httpResponse := ociResponse.HTTPResponse(); httpResponse != nil { 391 opcRequestId := httpResponse.Header.Get("opc-request-id") 392 response = DeletePeerResponse{RawResponse: httpResponse, OpcRequestId: &opcRequestId} 393 } else { 394 response = DeletePeerResponse{} 395 } 396 } 397 return 398 } 399 if convertedResponse, ok := ociResponse.(DeletePeerResponse); ok { 400 response = convertedResponse 401 } else { 402 err = fmt.Errorf("failed to convert OCIResponse into DeletePeerResponse") 403 } 404 return 405} 406 407// deletePeer implements the OCIOperation interface (enables retrying operations) 408func (client BlockchainPlatformClient) deletePeer(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 409 httpRequest, err := request.HTTPRequest(http.MethodDelete, "/blockchainPlatforms/{blockchainPlatformId}/peers/{peerId}") 410 if err != nil { 411 return nil, err 412 } 413 414 var response DeletePeerResponse 415 var httpResponse *http.Response 416 httpResponse, err = client.Call(ctx, &httpRequest) 417 defer common.CloseBodyIfValid(httpResponse) 418 response.RawResponse = httpResponse 419 if err != nil { 420 return response, err 421 } 422 423 err = common.UnmarshalResponse(httpResponse, &response) 424 return response, err 425} 426 427// DeleteWorkRequest Attempts to cancel the work request with the given ID. 428func (client BlockchainPlatformClient) DeleteWorkRequest(ctx context.Context, request DeleteWorkRequestRequest) (response DeleteWorkRequestResponse, err error) { 429 var ociResponse common.OCIResponse 430 policy := common.NoRetryPolicy() 431 if request.RetryPolicy() != nil { 432 policy = *request.RetryPolicy() 433 } 434 ociResponse, err = common.Retry(ctx, request, client.deleteWorkRequest, policy) 435 if err != nil { 436 if ociResponse != nil { 437 if httpResponse := ociResponse.HTTPResponse(); httpResponse != nil { 438 opcRequestId := httpResponse.Header.Get("opc-request-id") 439 response = DeleteWorkRequestResponse{RawResponse: httpResponse, OpcRequestId: &opcRequestId} 440 } else { 441 response = DeleteWorkRequestResponse{} 442 } 443 } 444 return 445 } 446 if convertedResponse, ok := ociResponse.(DeleteWorkRequestResponse); ok { 447 response = convertedResponse 448 } else { 449 err = fmt.Errorf("failed to convert OCIResponse into DeleteWorkRequestResponse") 450 } 451 return 452} 453 454// deleteWorkRequest implements the OCIOperation interface (enables retrying operations) 455func (client BlockchainPlatformClient) deleteWorkRequest(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 456 httpRequest, err := request.HTTPRequest(http.MethodDelete, "/workRequests/{workRequestId}") 457 if err != nil { 458 return nil, err 459 } 460 461 var response DeleteWorkRequestResponse 462 var httpResponse *http.Response 463 httpResponse, err = client.Call(ctx, &httpRequest) 464 defer common.CloseBodyIfValid(httpResponse) 465 response.RawResponse = httpResponse 466 if err != nil { 467 return response, err 468 } 469 470 err = common.UnmarshalResponse(httpResponse, &response) 471 return response, err 472} 473 474// GetBlockchainPlatform Gets information about a Blockchain Platform identified by the specific id 475func (client BlockchainPlatformClient) GetBlockchainPlatform(ctx context.Context, request GetBlockchainPlatformRequest) (response GetBlockchainPlatformResponse, err error) { 476 var ociResponse common.OCIResponse 477 policy := common.NoRetryPolicy() 478 if request.RetryPolicy() != nil { 479 policy = *request.RetryPolicy() 480 } 481 ociResponse, err = common.Retry(ctx, request, client.getBlockchainPlatform, policy) 482 if err != nil { 483 if ociResponse != nil { 484 if httpResponse := ociResponse.HTTPResponse(); httpResponse != nil { 485 opcRequestId := httpResponse.Header.Get("opc-request-id") 486 response = GetBlockchainPlatformResponse{RawResponse: httpResponse, OpcRequestId: &opcRequestId} 487 } else { 488 response = GetBlockchainPlatformResponse{} 489 } 490 } 491 return 492 } 493 if convertedResponse, ok := ociResponse.(GetBlockchainPlatformResponse); ok { 494 response = convertedResponse 495 } else { 496 err = fmt.Errorf("failed to convert OCIResponse into GetBlockchainPlatformResponse") 497 } 498 return 499} 500 501// getBlockchainPlatform implements the OCIOperation interface (enables retrying operations) 502func (client BlockchainPlatformClient) getBlockchainPlatform(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 503 httpRequest, err := request.HTTPRequest(http.MethodGet, "/blockchainPlatforms/{blockchainPlatformId}") 504 if err != nil { 505 return nil, err 506 } 507 508 var response GetBlockchainPlatformResponse 509 var httpResponse *http.Response 510 httpResponse, err = client.Call(ctx, &httpRequest) 511 defer common.CloseBodyIfValid(httpResponse) 512 response.RawResponse = httpResponse 513 if err != nil { 514 return response, err 515 } 516 517 err = common.UnmarshalResponse(httpResponse, &response) 518 return response, err 519} 520 521// GetOsn Gets information about an OSN identified by the specific id 522func (client BlockchainPlatformClient) GetOsn(ctx context.Context, request GetOsnRequest) (response GetOsnResponse, err error) { 523 var ociResponse common.OCIResponse 524 policy := common.NoRetryPolicy() 525 if request.RetryPolicy() != nil { 526 policy = *request.RetryPolicy() 527 } 528 ociResponse, err = common.Retry(ctx, request, client.getOsn, policy) 529 if err != nil { 530 if ociResponse != nil { 531 if httpResponse := ociResponse.HTTPResponse(); httpResponse != nil { 532 opcRequestId := httpResponse.Header.Get("opc-request-id") 533 response = GetOsnResponse{RawResponse: httpResponse, OpcRequestId: &opcRequestId} 534 } else { 535 response = GetOsnResponse{} 536 } 537 } 538 return 539 } 540 if convertedResponse, ok := ociResponse.(GetOsnResponse); ok { 541 response = convertedResponse 542 } else { 543 err = fmt.Errorf("failed to convert OCIResponse into GetOsnResponse") 544 } 545 return 546} 547 548// getOsn implements the OCIOperation interface (enables retrying operations) 549func (client BlockchainPlatformClient) getOsn(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 550 httpRequest, err := request.HTTPRequest(http.MethodGet, "/blockchainPlatforms/{blockchainPlatformId}/osns/{osnId}") 551 if err != nil { 552 return nil, err 553 } 554 555 var response GetOsnResponse 556 var httpResponse *http.Response 557 httpResponse, err = client.Call(ctx, &httpRequest) 558 defer common.CloseBodyIfValid(httpResponse) 559 response.RawResponse = httpResponse 560 if err != nil { 561 return response, err 562 } 563 564 err = common.UnmarshalResponse(httpResponse, &response) 565 return response, err 566} 567 568// GetPeer Gets information about a peer identified by the specific id 569func (client BlockchainPlatformClient) GetPeer(ctx context.Context, request GetPeerRequest) (response GetPeerResponse, err error) { 570 var ociResponse common.OCIResponse 571 policy := common.NoRetryPolicy() 572 if request.RetryPolicy() != nil { 573 policy = *request.RetryPolicy() 574 } 575 ociResponse, err = common.Retry(ctx, request, client.getPeer, policy) 576 if err != nil { 577 if ociResponse != nil { 578 if httpResponse := ociResponse.HTTPResponse(); httpResponse != nil { 579 opcRequestId := httpResponse.Header.Get("opc-request-id") 580 response = GetPeerResponse{RawResponse: httpResponse, OpcRequestId: &opcRequestId} 581 } else { 582 response = GetPeerResponse{} 583 } 584 } 585 return 586 } 587 if convertedResponse, ok := ociResponse.(GetPeerResponse); ok { 588 response = convertedResponse 589 } else { 590 err = fmt.Errorf("failed to convert OCIResponse into GetPeerResponse") 591 } 592 return 593} 594 595// getPeer implements the OCIOperation interface (enables retrying operations) 596func (client BlockchainPlatformClient) getPeer(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 597 httpRequest, err := request.HTTPRequest(http.MethodGet, "/blockchainPlatforms/{blockchainPlatformId}/peers/{peerId}") 598 if err != nil { 599 return nil, err 600 } 601 602 var response GetPeerResponse 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// GetWorkRequest Gets the status of the work request with the given ID. 616func (client BlockchainPlatformClient) GetWorkRequest(ctx context.Context, request GetWorkRequestRequest) (response GetWorkRequestResponse, err error) { 617 var ociResponse common.OCIResponse 618 policy := common.NoRetryPolicy() 619 if request.RetryPolicy() != nil { 620 policy = *request.RetryPolicy() 621 } 622 ociResponse, err = common.Retry(ctx, request, client.getWorkRequest, policy) 623 if err != nil { 624 if ociResponse != nil { 625 if httpResponse := ociResponse.HTTPResponse(); httpResponse != nil { 626 opcRequestId := httpResponse.Header.Get("opc-request-id") 627 response = GetWorkRequestResponse{RawResponse: httpResponse, OpcRequestId: &opcRequestId} 628 } else { 629 response = GetWorkRequestResponse{} 630 } 631 } 632 return 633 } 634 if convertedResponse, ok := ociResponse.(GetWorkRequestResponse); ok { 635 response = convertedResponse 636 } else { 637 err = fmt.Errorf("failed to convert OCIResponse into GetWorkRequestResponse") 638 } 639 return 640} 641 642// getWorkRequest implements the OCIOperation interface (enables retrying operations) 643func (client BlockchainPlatformClient) getWorkRequest(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 644 httpRequest, err := request.HTTPRequest(http.MethodGet, "/workRequests/{workRequestId}") 645 if err != nil { 646 return nil, err 647 } 648 649 var response GetWorkRequestResponse 650 var httpResponse *http.Response 651 httpResponse, err = client.Call(ctx, &httpRequest) 652 defer common.CloseBodyIfValid(httpResponse) 653 response.RawResponse = httpResponse 654 if err != nil { 655 return response, err 656 } 657 658 err = common.UnmarshalResponse(httpResponse, &response) 659 return response, err 660} 661 662// ListBlockchainPlatforms Returns a list Blockchain Platform Instances in a compartment 663func (client BlockchainPlatformClient) ListBlockchainPlatforms(ctx context.Context, request ListBlockchainPlatformsRequest) (response ListBlockchainPlatformsResponse, err error) { 664 var ociResponse common.OCIResponse 665 policy := common.NoRetryPolicy() 666 if request.RetryPolicy() != nil { 667 policy = *request.RetryPolicy() 668 } 669 ociResponse, err = common.Retry(ctx, request, client.listBlockchainPlatforms, policy) 670 if err != nil { 671 if ociResponse != nil { 672 if httpResponse := ociResponse.HTTPResponse(); httpResponse != nil { 673 opcRequestId := httpResponse.Header.Get("opc-request-id") 674 response = ListBlockchainPlatformsResponse{RawResponse: httpResponse, OpcRequestId: &opcRequestId} 675 } else { 676 response = ListBlockchainPlatformsResponse{} 677 } 678 } 679 return 680 } 681 if convertedResponse, ok := ociResponse.(ListBlockchainPlatformsResponse); ok { 682 response = convertedResponse 683 } else { 684 err = fmt.Errorf("failed to convert OCIResponse into ListBlockchainPlatformsResponse") 685 } 686 return 687} 688 689// listBlockchainPlatforms implements the OCIOperation interface (enables retrying operations) 690func (client BlockchainPlatformClient) listBlockchainPlatforms(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 691 httpRequest, err := request.HTTPRequest(http.MethodGet, "/blockchainPlatforms") 692 if err != nil { 693 return nil, err 694 } 695 696 var response ListBlockchainPlatformsResponse 697 var httpResponse *http.Response 698 httpResponse, err = client.Call(ctx, &httpRequest) 699 defer common.CloseBodyIfValid(httpResponse) 700 response.RawResponse = httpResponse 701 if err != nil { 702 return response, err 703 } 704 705 err = common.UnmarshalResponse(httpResponse, &response) 706 return response, err 707} 708 709// ListOsns List Blockchain Platform OSNs 710func (client BlockchainPlatformClient) ListOsns(ctx context.Context, request ListOsnsRequest) (response ListOsnsResponse, err error) { 711 var ociResponse common.OCIResponse 712 policy := common.NoRetryPolicy() 713 if request.RetryPolicy() != nil { 714 policy = *request.RetryPolicy() 715 } 716 717 if !(request.OpcRetryToken != nil && *request.OpcRetryToken != "") { 718 request.OpcRetryToken = common.String(common.RetryToken()) 719 } 720 721 ociResponse, err = common.Retry(ctx, request, client.listOsns, policy) 722 if err != nil { 723 if ociResponse != nil { 724 if httpResponse := ociResponse.HTTPResponse(); httpResponse != nil { 725 opcRequestId := httpResponse.Header.Get("opc-request-id") 726 response = ListOsnsResponse{RawResponse: httpResponse, OpcRequestId: &opcRequestId} 727 } else { 728 response = ListOsnsResponse{} 729 } 730 } 731 return 732 } 733 if convertedResponse, ok := ociResponse.(ListOsnsResponse); ok { 734 response = convertedResponse 735 } else { 736 err = fmt.Errorf("failed to convert OCIResponse into ListOsnsResponse") 737 } 738 return 739} 740 741// listOsns implements the OCIOperation interface (enables retrying operations) 742func (client BlockchainPlatformClient) listOsns(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 743 httpRequest, err := request.HTTPRequest(http.MethodGet, "/blockchainPlatforms/{blockchainPlatformId}/osns") 744 if err != nil { 745 return nil, err 746 } 747 748 var response ListOsnsResponse 749 var httpResponse *http.Response 750 httpResponse, err = client.Call(ctx, &httpRequest) 751 defer common.CloseBodyIfValid(httpResponse) 752 response.RawResponse = httpResponse 753 if err != nil { 754 return response, err 755 } 756 757 err = common.UnmarshalResponse(httpResponse, &response) 758 return response, err 759} 760 761// ListPeers List Blockchain Platform Peers 762func (client BlockchainPlatformClient) ListPeers(ctx context.Context, request ListPeersRequest) (response ListPeersResponse, err error) { 763 var ociResponse common.OCIResponse 764 policy := common.NoRetryPolicy() 765 if request.RetryPolicy() != nil { 766 policy = *request.RetryPolicy() 767 } 768 769 if !(request.OpcRetryToken != nil && *request.OpcRetryToken != "") { 770 request.OpcRetryToken = common.String(common.RetryToken()) 771 } 772 773 ociResponse, err = common.Retry(ctx, request, client.listPeers, policy) 774 if err != nil { 775 if ociResponse != nil { 776 if httpResponse := ociResponse.HTTPResponse(); httpResponse != nil { 777 opcRequestId := httpResponse.Header.Get("opc-request-id") 778 response = ListPeersResponse{RawResponse: httpResponse, OpcRequestId: &opcRequestId} 779 } else { 780 response = ListPeersResponse{} 781 } 782 } 783 return 784 } 785 if convertedResponse, ok := ociResponse.(ListPeersResponse); ok { 786 response = convertedResponse 787 } else { 788 err = fmt.Errorf("failed to convert OCIResponse into ListPeersResponse") 789 } 790 return 791} 792 793// listPeers implements the OCIOperation interface (enables retrying operations) 794func (client BlockchainPlatformClient) listPeers(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 795 httpRequest, err := request.HTTPRequest(http.MethodGet, "/blockchainPlatforms/{blockchainPlatformId}/peers") 796 if err != nil { 797 return nil, err 798 } 799 800 var response ListPeersResponse 801 var httpResponse *http.Response 802 httpResponse, err = client.Call(ctx, &httpRequest) 803 defer common.CloseBodyIfValid(httpResponse) 804 response.RawResponse = httpResponse 805 if err != nil { 806 return response, err 807 } 808 809 err = common.UnmarshalResponse(httpResponse, &response) 810 return response, err 811} 812 813// ListWorkRequestErrors Return a (paginated) list of errors for a given work request. 814func (client BlockchainPlatformClient) ListWorkRequestErrors(ctx context.Context, request ListWorkRequestErrorsRequest) (response ListWorkRequestErrorsResponse, err error) { 815 var ociResponse common.OCIResponse 816 policy := common.NoRetryPolicy() 817 if request.RetryPolicy() != nil { 818 policy = *request.RetryPolicy() 819 } 820 ociResponse, err = common.Retry(ctx, request, client.listWorkRequestErrors, policy) 821 if err != nil { 822 if ociResponse != nil { 823 if httpResponse := ociResponse.HTTPResponse(); httpResponse != nil { 824 opcRequestId := httpResponse.Header.Get("opc-request-id") 825 response = ListWorkRequestErrorsResponse{RawResponse: httpResponse, OpcRequestId: &opcRequestId} 826 } else { 827 response = ListWorkRequestErrorsResponse{} 828 } 829 } 830 return 831 } 832 if convertedResponse, ok := ociResponse.(ListWorkRequestErrorsResponse); ok { 833 response = convertedResponse 834 } else { 835 err = fmt.Errorf("failed to convert OCIResponse into ListWorkRequestErrorsResponse") 836 } 837 return 838} 839 840// listWorkRequestErrors implements the OCIOperation interface (enables retrying operations) 841func (client BlockchainPlatformClient) listWorkRequestErrors(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 842 httpRequest, err := request.HTTPRequest(http.MethodGet, "/workRequests/{workRequestId}/errors") 843 if err != nil { 844 return nil, err 845 } 846 847 var response ListWorkRequestErrorsResponse 848 var httpResponse *http.Response 849 httpResponse, err = client.Call(ctx, &httpRequest) 850 defer common.CloseBodyIfValid(httpResponse) 851 response.RawResponse = httpResponse 852 if err != nil { 853 return response, err 854 } 855 856 err = common.UnmarshalResponse(httpResponse, &response) 857 return response, err 858} 859 860// ListWorkRequestLogs Return a (paginated) list of logs for a given work request. 861func (client BlockchainPlatformClient) ListWorkRequestLogs(ctx context.Context, request ListWorkRequestLogsRequest) (response ListWorkRequestLogsResponse, err error) { 862 var ociResponse common.OCIResponse 863 policy := common.NoRetryPolicy() 864 if request.RetryPolicy() != nil { 865 policy = *request.RetryPolicy() 866 } 867 ociResponse, err = common.Retry(ctx, request, client.listWorkRequestLogs, policy) 868 if err != nil { 869 if ociResponse != nil { 870 if httpResponse := ociResponse.HTTPResponse(); httpResponse != nil { 871 opcRequestId := httpResponse.Header.Get("opc-request-id") 872 response = ListWorkRequestLogsResponse{RawResponse: httpResponse, OpcRequestId: &opcRequestId} 873 } else { 874 response = ListWorkRequestLogsResponse{} 875 } 876 } 877 return 878 } 879 if convertedResponse, ok := ociResponse.(ListWorkRequestLogsResponse); ok { 880 response = convertedResponse 881 } else { 882 err = fmt.Errorf("failed to convert OCIResponse into ListWorkRequestLogsResponse") 883 } 884 return 885} 886 887// listWorkRequestLogs implements the OCIOperation interface (enables retrying operations) 888func (client BlockchainPlatformClient) listWorkRequestLogs(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 889 httpRequest, err := request.HTTPRequest(http.MethodGet, "/workRequests/{workRequestId}/logs") 890 if err != nil { 891 return nil, err 892 } 893 894 var response ListWorkRequestLogsResponse 895 var httpResponse *http.Response 896 httpResponse, err = client.Call(ctx, &httpRequest) 897 defer common.CloseBodyIfValid(httpResponse) 898 response.RawResponse = httpResponse 899 if err != nil { 900 return response, err 901 } 902 903 err = common.UnmarshalResponse(httpResponse, &response) 904 return response, err 905} 906 907// ListWorkRequests Lists the work requests in a compartment. 908func (client BlockchainPlatformClient) ListWorkRequests(ctx context.Context, request ListWorkRequestsRequest) (response ListWorkRequestsResponse, err error) { 909 var ociResponse common.OCIResponse 910 policy := common.NoRetryPolicy() 911 if request.RetryPolicy() != nil { 912 policy = *request.RetryPolicy() 913 } 914 ociResponse, err = common.Retry(ctx, request, client.listWorkRequests, policy) 915 if err != nil { 916 if ociResponse != nil { 917 if httpResponse := ociResponse.HTTPResponse(); httpResponse != nil { 918 opcRequestId := httpResponse.Header.Get("opc-request-id") 919 response = ListWorkRequestsResponse{RawResponse: httpResponse, OpcRequestId: &opcRequestId} 920 } else { 921 response = ListWorkRequestsResponse{} 922 } 923 } 924 return 925 } 926 if convertedResponse, ok := ociResponse.(ListWorkRequestsResponse); ok { 927 response = convertedResponse 928 } else { 929 err = fmt.Errorf("failed to convert OCIResponse into ListWorkRequestsResponse") 930 } 931 return 932} 933 934// listWorkRequests implements the OCIOperation interface (enables retrying operations) 935func (client BlockchainPlatformClient) listWorkRequests(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 936 httpRequest, err := request.HTTPRequest(http.MethodGet, "/workRequests") 937 if err != nil { 938 return nil, err 939 } 940 941 var response ListWorkRequestsResponse 942 var httpResponse *http.Response 943 httpResponse, err = client.Call(ctx, &httpRequest) 944 defer common.CloseBodyIfValid(httpResponse) 945 response.RawResponse = httpResponse 946 if err != nil { 947 return response, err 948 } 949 950 err = common.UnmarshalResponse(httpResponse, &response) 951 return response, err 952} 953 954// PreviewScaleBlockchainPlatform Preview Scale Blockchain Platform 955func (client BlockchainPlatformClient) PreviewScaleBlockchainPlatform(ctx context.Context, request PreviewScaleBlockchainPlatformRequest) (response PreviewScaleBlockchainPlatformResponse, err error) { 956 var ociResponse common.OCIResponse 957 policy := common.NoRetryPolicy() 958 if request.RetryPolicy() != nil { 959 policy = *request.RetryPolicy() 960 } 961 ociResponse, err = common.Retry(ctx, request, client.previewScaleBlockchainPlatform, policy) 962 if err != nil { 963 if ociResponse != nil { 964 if httpResponse := ociResponse.HTTPResponse(); httpResponse != nil { 965 opcRequestId := httpResponse.Header.Get("opc-request-id") 966 response = PreviewScaleBlockchainPlatformResponse{RawResponse: httpResponse, OpcRequestId: &opcRequestId} 967 } else { 968 response = PreviewScaleBlockchainPlatformResponse{} 969 } 970 } 971 return 972 } 973 if convertedResponse, ok := ociResponse.(PreviewScaleBlockchainPlatformResponse); ok { 974 response = convertedResponse 975 } else { 976 err = fmt.Errorf("failed to convert OCIResponse into PreviewScaleBlockchainPlatformResponse") 977 } 978 return 979} 980 981// previewScaleBlockchainPlatform implements the OCIOperation interface (enables retrying operations) 982func (client BlockchainPlatformClient) previewScaleBlockchainPlatform(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 983 httpRequest, err := request.HTTPRequest(http.MethodPost, "/blockchainPlatforms/{blockchainPlatformId}/actions/scale/preview") 984 if err != nil { 985 return nil, err 986 } 987 988 var response PreviewScaleBlockchainPlatformResponse 989 var httpResponse *http.Response 990 httpResponse, err = client.Call(ctx, &httpRequest) 991 defer common.CloseBodyIfValid(httpResponse) 992 response.RawResponse = httpResponse 993 if err != nil { 994 return response, err 995 } 996 997 err = common.UnmarshalResponse(httpResponse, &response) 998 return response, err 999} 1000 1001// ScaleBlockchainPlatform Scale Blockchain Platform 1002func (client BlockchainPlatformClient) ScaleBlockchainPlatform(ctx context.Context, request ScaleBlockchainPlatformRequest) (response ScaleBlockchainPlatformResponse, err error) { 1003 var ociResponse common.OCIResponse 1004 policy := common.NoRetryPolicy() 1005 if request.RetryPolicy() != nil { 1006 policy = *request.RetryPolicy() 1007 } 1008 1009 if !(request.OpcRetryToken != nil && *request.OpcRetryToken != "") { 1010 request.OpcRetryToken = common.String(common.RetryToken()) 1011 } 1012 1013 ociResponse, err = common.Retry(ctx, request, client.scaleBlockchainPlatform, policy) 1014 if err != nil { 1015 if ociResponse != nil { 1016 if httpResponse := ociResponse.HTTPResponse(); httpResponse != nil { 1017 opcRequestId := httpResponse.Header.Get("opc-request-id") 1018 response = ScaleBlockchainPlatformResponse{RawResponse: httpResponse, OpcRequestId: &opcRequestId} 1019 } else { 1020 response = ScaleBlockchainPlatformResponse{} 1021 } 1022 } 1023 return 1024 } 1025 if convertedResponse, ok := ociResponse.(ScaleBlockchainPlatformResponse); ok { 1026 response = convertedResponse 1027 } else { 1028 err = fmt.Errorf("failed to convert OCIResponse into ScaleBlockchainPlatformResponse") 1029 } 1030 return 1031} 1032 1033// scaleBlockchainPlatform implements the OCIOperation interface (enables retrying operations) 1034func (client BlockchainPlatformClient) scaleBlockchainPlatform(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 1035 httpRequest, err := request.HTTPRequest(http.MethodPost, "/blockchainPlatforms/{blockchainPlatformId}/actions/scale") 1036 if err != nil { 1037 return nil, err 1038 } 1039 1040 var response ScaleBlockchainPlatformResponse 1041 var httpResponse *http.Response 1042 httpResponse, err = client.Call(ctx, &httpRequest) 1043 defer common.CloseBodyIfValid(httpResponse) 1044 response.RawResponse = httpResponse 1045 if err != nil { 1046 return response, err 1047 } 1048 1049 err = common.UnmarshalResponse(httpResponse, &response) 1050 return response, err 1051} 1052 1053// StartBlockchainPlatform Start a Blockchain Platform 1054func (client BlockchainPlatformClient) StartBlockchainPlatform(ctx context.Context, request StartBlockchainPlatformRequest) (response StartBlockchainPlatformResponse, err error) { 1055 var ociResponse common.OCIResponse 1056 policy := common.NoRetryPolicy() 1057 if request.RetryPolicy() != nil { 1058 policy = *request.RetryPolicy() 1059 } 1060 ociResponse, err = common.Retry(ctx, request, client.startBlockchainPlatform, policy) 1061 if err != nil { 1062 if ociResponse != nil { 1063 if httpResponse := ociResponse.HTTPResponse(); httpResponse != nil { 1064 opcRequestId := httpResponse.Header.Get("opc-request-id") 1065 response = StartBlockchainPlatformResponse{RawResponse: httpResponse, OpcRequestId: &opcRequestId} 1066 } else { 1067 response = StartBlockchainPlatformResponse{} 1068 } 1069 } 1070 return 1071 } 1072 if convertedResponse, ok := ociResponse.(StartBlockchainPlatformResponse); ok { 1073 response = convertedResponse 1074 } else { 1075 err = fmt.Errorf("failed to convert OCIResponse into StartBlockchainPlatformResponse") 1076 } 1077 return 1078} 1079 1080// startBlockchainPlatform implements the OCIOperation interface (enables retrying operations) 1081func (client BlockchainPlatformClient) startBlockchainPlatform(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 1082 httpRequest, err := request.HTTPRequest(http.MethodPost, "/blockchainPlatforms/{blockchainPlatformId}/actions/start") 1083 if err != nil { 1084 return nil, err 1085 } 1086 1087 var response StartBlockchainPlatformResponse 1088 var httpResponse *http.Response 1089 httpResponse, err = client.Call(ctx, &httpRequest) 1090 defer common.CloseBodyIfValid(httpResponse) 1091 response.RawResponse = httpResponse 1092 if err != nil { 1093 return response, err 1094 } 1095 1096 err = common.UnmarshalResponse(httpResponse, &response) 1097 return response, err 1098} 1099 1100// StopBlockchainPlatform Stop a Blockchain Platform 1101func (client BlockchainPlatformClient) StopBlockchainPlatform(ctx context.Context, request StopBlockchainPlatformRequest) (response StopBlockchainPlatformResponse, err error) { 1102 var ociResponse common.OCIResponse 1103 policy := common.NoRetryPolicy() 1104 if request.RetryPolicy() != nil { 1105 policy = *request.RetryPolicy() 1106 } 1107 ociResponse, err = common.Retry(ctx, request, client.stopBlockchainPlatform, policy) 1108 if err != nil { 1109 if ociResponse != nil { 1110 if httpResponse := ociResponse.HTTPResponse(); httpResponse != nil { 1111 opcRequestId := httpResponse.Header.Get("opc-request-id") 1112 response = StopBlockchainPlatformResponse{RawResponse: httpResponse, OpcRequestId: &opcRequestId} 1113 } else { 1114 response = StopBlockchainPlatformResponse{} 1115 } 1116 } 1117 return 1118 } 1119 if convertedResponse, ok := ociResponse.(StopBlockchainPlatformResponse); ok { 1120 response = convertedResponse 1121 } else { 1122 err = fmt.Errorf("failed to convert OCIResponse into StopBlockchainPlatformResponse") 1123 } 1124 return 1125} 1126 1127// stopBlockchainPlatform implements the OCIOperation interface (enables retrying operations) 1128func (client BlockchainPlatformClient) stopBlockchainPlatform(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 1129 httpRequest, err := request.HTTPRequest(http.MethodPost, "/blockchainPlatforms/{blockchainPlatformId}/actions/stop") 1130 if err != nil { 1131 return nil, err 1132 } 1133 1134 var response StopBlockchainPlatformResponse 1135 var httpResponse *http.Response 1136 httpResponse, err = client.Call(ctx, &httpRequest) 1137 defer common.CloseBodyIfValid(httpResponse) 1138 response.RawResponse = httpResponse 1139 if err != nil { 1140 return response, err 1141 } 1142 1143 err = common.UnmarshalResponse(httpResponse, &response) 1144 return response, err 1145} 1146 1147// UpdateBlockchainPlatform Update a particular of a Blockchain Platform 1148func (client BlockchainPlatformClient) UpdateBlockchainPlatform(ctx context.Context, request UpdateBlockchainPlatformRequest) (response UpdateBlockchainPlatformResponse, err error) { 1149 var ociResponse common.OCIResponse 1150 policy := common.NoRetryPolicy() 1151 if request.RetryPolicy() != nil { 1152 policy = *request.RetryPolicy() 1153 } 1154 ociResponse, err = common.Retry(ctx, request, client.updateBlockchainPlatform, policy) 1155 if err != nil { 1156 if ociResponse != nil { 1157 if httpResponse := ociResponse.HTTPResponse(); httpResponse != nil { 1158 opcRequestId := httpResponse.Header.Get("opc-request-id") 1159 response = UpdateBlockchainPlatformResponse{RawResponse: httpResponse, OpcRequestId: &opcRequestId} 1160 } else { 1161 response = UpdateBlockchainPlatformResponse{} 1162 } 1163 } 1164 return 1165 } 1166 if convertedResponse, ok := ociResponse.(UpdateBlockchainPlatformResponse); ok { 1167 response = convertedResponse 1168 } else { 1169 err = fmt.Errorf("failed to convert OCIResponse into UpdateBlockchainPlatformResponse") 1170 } 1171 return 1172} 1173 1174// updateBlockchainPlatform implements the OCIOperation interface (enables retrying operations) 1175func (client BlockchainPlatformClient) updateBlockchainPlatform(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 1176 httpRequest, err := request.HTTPRequest(http.MethodPut, "/blockchainPlatforms/{blockchainPlatformId}") 1177 if err != nil { 1178 return nil, err 1179 } 1180 1181 var response UpdateBlockchainPlatformResponse 1182 var httpResponse *http.Response 1183 httpResponse, err = client.Call(ctx, &httpRequest) 1184 defer common.CloseBodyIfValid(httpResponse) 1185 response.RawResponse = httpResponse 1186 if err != nil { 1187 return response, err 1188 } 1189 1190 err = common.UnmarshalResponse(httpResponse, &response) 1191 return response, err 1192} 1193 1194// UpdateOsn Update Blockchain Platform OSN 1195func (client BlockchainPlatformClient) UpdateOsn(ctx context.Context, request UpdateOsnRequest) (response UpdateOsnResponse, err error) { 1196 var ociResponse common.OCIResponse 1197 policy := common.NoRetryPolicy() 1198 if request.RetryPolicy() != nil { 1199 policy = *request.RetryPolicy() 1200 } 1201 1202 if !(request.OpcRetryToken != nil && *request.OpcRetryToken != "") { 1203 request.OpcRetryToken = common.String(common.RetryToken()) 1204 } 1205 1206 ociResponse, err = common.Retry(ctx, request, client.updateOsn, policy) 1207 if err != nil { 1208 if ociResponse != nil { 1209 if httpResponse := ociResponse.HTTPResponse(); httpResponse != nil { 1210 opcRequestId := httpResponse.Header.Get("opc-request-id") 1211 response = UpdateOsnResponse{RawResponse: httpResponse, OpcRequestId: &opcRequestId} 1212 } else { 1213 response = UpdateOsnResponse{} 1214 } 1215 } 1216 return 1217 } 1218 if convertedResponse, ok := ociResponse.(UpdateOsnResponse); ok { 1219 response = convertedResponse 1220 } else { 1221 err = fmt.Errorf("failed to convert OCIResponse into UpdateOsnResponse") 1222 } 1223 return 1224} 1225 1226// updateOsn implements the OCIOperation interface (enables retrying operations) 1227func (client BlockchainPlatformClient) updateOsn(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 1228 httpRequest, err := request.HTTPRequest(http.MethodPut, "/blockchainPlatforms/{blockchainPlatformId}/osns/{osnId}") 1229 if err != nil { 1230 return nil, err 1231 } 1232 1233 var response UpdateOsnResponse 1234 var httpResponse *http.Response 1235 httpResponse, err = client.Call(ctx, &httpRequest) 1236 defer common.CloseBodyIfValid(httpResponse) 1237 response.RawResponse = httpResponse 1238 if err != nil { 1239 return response, err 1240 } 1241 1242 err = common.UnmarshalResponse(httpResponse, &response) 1243 return response, err 1244} 1245 1246// UpdatePeer Update Blockchain Platform Peer 1247func (client BlockchainPlatformClient) UpdatePeer(ctx context.Context, request UpdatePeerRequest) (response UpdatePeerResponse, err error) { 1248 var ociResponse common.OCIResponse 1249 policy := common.NoRetryPolicy() 1250 if request.RetryPolicy() != nil { 1251 policy = *request.RetryPolicy() 1252 } 1253 ociResponse, err = common.Retry(ctx, request, client.updatePeer, policy) 1254 if err != nil { 1255 if ociResponse != nil { 1256 if httpResponse := ociResponse.HTTPResponse(); httpResponse != nil { 1257 opcRequestId := httpResponse.Header.Get("opc-request-id") 1258 response = UpdatePeerResponse{RawResponse: httpResponse, OpcRequestId: &opcRequestId} 1259 } else { 1260 response = UpdatePeerResponse{} 1261 } 1262 } 1263 return 1264 } 1265 if convertedResponse, ok := ociResponse.(UpdatePeerResponse); ok { 1266 response = convertedResponse 1267 } else { 1268 err = fmt.Errorf("failed to convert OCIResponse into UpdatePeerResponse") 1269 } 1270 return 1271} 1272 1273// updatePeer implements the OCIOperation interface (enables retrying operations) 1274func (client BlockchainPlatformClient) updatePeer(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 1275 httpRequest, err := request.HTTPRequest(http.MethodPut, "/blockchainPlatforms/{blockchainPlatformId}/peers/{peerId}") 1276 if err != nil { 1277 return nil, err 1278 } 1279 1280 var response UpdatePeerResponse 1281 var httpResponse *http.Response 1282 httpResponse, err = client.Call(ctx, &httpRequest) 1283 defer common.CloseBodyIfValid(httpResponse) 1284 response.RawResponse = httpResponse 1285 if err != nil { 1286 return response, err 1287 } 1288 1289 err = common.UnmarshalResponse(httpResponse, &response) 1290 return response, err 1291} 1292