google-cloud-security-private_ca-v1 1.0.1 → 1.1.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- checksums.yaml +4 -4
- data/.yardopts +1 -1
- data/README.md +32 -22
- data/lib/google/cloud/security/private_ca/v1/certificate_authority_service/client.rb +48 -30
- data/lib/google/cloud/security/private_ca/v1/certificate_authority_service/operations.rb +12 -15
- data/lib/google/cloud/security/private_ca/v1/certificate_authority_service/rest/client.rb +43 -30
- data/lib/google/cloud/security/private_ca/v1/certificate_authority_service/rest/operations.rb +43 -38
- data/lib/google/cloud/security/private_ca/v1/certificate_authority_service/rest/service_stub.rb +246 -176
- data/lib/google/cloud/security/private_ca/v1/version.rb +1 -1
- data/proto_docs/README.md +1 -1
- data/proto_docs/google/api/client.rb +39 -0
- data/proto_docs/google/longrunning/operations.rb +19 -14
- metadata +5 -5
    
        data/lib/google/cloud/security/private_ca/v1/certificate_authority_service/rest/service_stub.rb
    CHANGED
    
    | @@ -31,7 +31,8 @@ module Google | |
| 31 31 | 
             
                          # including transcoding, making the REST call, and deserialing the response.
         | 
| 32 32 | 
             
                          #
         | 
| 33 33 | 
             
                          class ServiceStub
         | 
| 34 | 
            -
                             | 
| 34 | 
            +
                            # @private
         | 
| 35 | 
            +
                            def initialize endpoint:, endpoint_template:, universe_domain:, credentials:, logger:
         | 
| 35 36 | 
             
                              # These require statements are intentionally placed here to initialize
         | 
| 36 37 | 
             
                              # the REST modules only when it's required.
         | 
| 37 38 | 
             
                              require "gapic/rest"
         | 
| @@ -41,7 +42,9 @@ module Google | |
| 41 42 | 
             
                                                                           universe_domain: universe_domain,
         | 
| 42 43 | 
             
                                                                           credentials: credentials,
         | 
| 43 44 | 
             
                                                                           numeric_enums: true,
         | 
| 44 | 
            -
                                                                            | 
| 45 | 
            +
                                                                           service_name: self.class,
         | 
| 46 | 
            +
                                                                           raise_faraday_errors: false,
         | 
| 47 | 
            +
                                                                           logger: logger
         | 
| 45 48 | 
             
                            end
         | 
| 46 49 |  | 
| 47 50 | 
             
                            ##
         | 
| @@ -62,6 +65,15 @@ module Google | |
| 62 65 | 
             
                              @client_stub.endpoint
         | 
| 63 66 | 
             
                            end
         | 
| 64 67 |  | 
| 68 | 
            +
                            ##
         | 
| 69 | 
            +
                            # The logger used for request/response debug logging.
         | 
| 70 | 
            +
                            #
         | 
| 71 | 
            +
                            # @return [Logger]
         | 
| 72 | 
            +
                            #
         | 
| 73 | 
            +
                            def logger stub: false
         | 
| 74 | 
            +
                              stub ? @client_stub.stub_logger : @client_stub.logger
         | 
| 75 | 
            +
                            end
         | 
| 76 | 
            +
             | 
| 65 77 | 
             
                            ##
         | 
| 66 78 | 
             
                            # Baseline implementation for the create_certificate REST call
         | 
| 67 79 | 
             
                            #
         | 
| @@ -88,16 +100,18 @@ module Google | |
| 88 100 |  | 
| 89 101 | 
             
                              response = @client_stub.make_http_request(
         | 
| 90 102 | 
             
                                verb,
         | 
| 91 | 
            -
                                uri: | 
| 92 | 
            -
                                body: | 
| 93 | 
            -
                                params: | 
| 103 | 
            +
                                uri: uri,
         | 
| 104 | 
            +
                                body: body || "",
         | 
| 105 | 
            +
                                params: query_string_params,
         | 
| 106 | 
            +
                                method_name: "create_certificate",
         | 
| 94 107 | 
             
                                options: options
         | 
| 95 108 | 
             
                              )
         | 
| 96 109 | 
             
                              operation = ::Gapic::Rest::TransportOperation.new response
         | 
| 97 110 | 
             
                              result = ::Google::Cloud::Security::PrivateCA::V1::Certificate.decode_json response.body, ignore_unknown_fields: true
         | 
| 98 | 
            -
             | 
| 99 | 
            -
             | 
| 100 | 
            -
             | 
| 111 | 
            +
                              catch :response do
         | 
| 112 | 
            +
                                yield result, operation if block_given?
         | 
| 113 | 
            +
                                result
         | 
| 114 | 
            +
                              end
         | 
| 101 115 | 
             
                            end
         | 
| 102 116 |  | 
| 103 117 | 
             
                            ##
         | 
| @@ -126,16 +140,18 @@ module Google | |
| 126 140 |  | 
| 127 141 | 
             
                              response = @client_stub.make_http_request(
         | 
| 128 142 | 
             
                                verb,
         | 
| 129 | 
            -
                                uri: | 
| 130 | 
            -
                                body: | 
| 131 | 
            -
                                params: | 
| 143 | 
            +
                                uri: uri,
         | 
| 144 | 
            +
                                body: body || "",
         | 
| 145 | 
            +
                                params: query_string_params,
         | 
| 146 | 
            +
                                method_name: "get_certificate",
         | 
| 132 147 | 
             
                                options: options
         | 
| 133 148 | 
             
                              )
         | 
| 134 149 | 
             
                              operation = ::Gapic::Rest::TransportOperation.new response
         | 
| 135 150 | 
             
                              result = ::Google::Cloud::Security::PrivateCA::V1::Certificate.decode_json response.body, ignore_unknown_fields: true
         | 
| 136 | 
            -
             | 
| 137 | 
            -
             | 
| 138 | 
            -
             | 
| 151 | 
            +
                              catch :response do
         | 
| 152 | 
            +
                                yield result, operation if block_given?
         | 
| 153 | 
            +
                                result
         | 
| 154 | 
            +
                              end
         | 
| 139 155 | 
             
                            end
         | 
| 140 156 |  | 
| 141 157 | 
             
                            ##
         | 
| @@ -164,16 +180,18 @@ module Google | |
| 164 180 |  | 
| 165 181 | 
             
                              response = @client_stub.make_http_request(
         | 
| 166 182 | 
             
                                verb,
         | 
| 167 | 
            -
                                uri: | 
| 168 | 
            -
                                body: | 
| 169 | 
            -
                                params: | 
| 183 | 
            +
                                uri: uri,
         | 
| 184 | 
            +
                                body: body || "",
         | 
| 185 | 
            +
                                params: query_string_params,
         | 
| 186 | 
            +
                                method_name: "list_certificates",
         | 
| 170 187 | 
             
                                options: options
         | 
| 171 188 | 
             
                              )
         | 
| 172 189 | 
             
                              operation = ::Gapic::Rest::TransportOperation.new response
         | 
| 173 190 | 
             
                              result = ::Google::Cloud::Security::PrivateCA::V1::ListCertificatesResponse.decode_json response.body, ignore_unknown_fields: true
         | 
| 174 | 
            -
             | 
| 175 | 
            -
             | 
| 176 | 
            -
             | 
| 191 | 
            +
                              catch :response do
         | 
| 192 | 
            +
                                yield result, operation if block_given?
         | 
| 193 | 
            +
                                result
         | 
| 194 | 
            +
                              end
         | 
| 177 195 | 
             
                            end
         | 
| 178 196 |  | 
| 179 197 | 
             
                            ##
         | 
| @@ -202,16 +220,18 @@ module Google | |
| 202 220 |  | 
| 203 221 | 
             
                              response = @client_stub.make_http_request(
         | 
| 204 222 | 
             
                                verb,
         | 
| 205 | 
            -
                                uri: | 
| 206 | 
            -
                                body: | 
| 207 | 
            -
                                params: | 
| 223 | 
            +
                                uri: uri,
         | 
| 224 | 
            +
                                body: body || "",
         | 
| 225 | 
            +
                                params: query_string_params,
         | 
| 226 | 
            +
                                method_name: "revoke_certificate",
         | 
| 208 227 | 
             
                                options: options
         | 
| 209 228 | 
             
                              )
         | 
| 210 229 | 
             
                              operation = ::Gapic::Rest::TransportOperation.new response
         | 
| 211 230 | 
             
                              result = ::Google::Cloud::Security::PrivateCA::V1::Certificate.decode_json response.body, ignore_unknown_fields: true
         | 
| 212 | 
            -
             | 
| 213 | 
            -
             | 
| 214 | 
            -
             | 
| 231 | 
            +
                              catch :response do
         | 
| 232 | 
            +
                                yield result, operation if block_given?
         | 
| 233 | 
            +
                                result
         | 
| 234 | 
            +
                              end
         | 
| 215 235 | 
             
                            end
         | 
| 216 236 |  | 
| 217 237 | 
             
                            ##
         | 
| @@ -240,16 +260,18 @@ module Google | |
| 240 260 |  | 
| 241 261 | 
             
                              response = @client_stub.make_http_request(
         | 
| 242 262 | 
             
                                verb,
         | 
| 243 | 
            -
                                uri: | 
| 244 | 
            -
                                body: | 
| 245 | 
            -
                                params: | 
| 263 | 
            +
                                uri: uri,
         | 
| 264 | 
            +
                                body: body || "",
         | 
| 265 | 
            +
                                params: query_string_params,
         | 
| 266 | 
            +
                                method_name: "update_certificate",
         | 
| 246 267 | 
             
                                options: options
         | 
| 247 268 | 
             
                              )
         | 
| 248 269 | 
             
                              operation = ::Gapic::Rest::TransportOperation.new response
         | 
| 249 270 | 
             
                              result = ::Google::Cloud::Security::PrivateCA::V1::Certificate.decode_json response.body, ignore_unknown_fields: true
         | 
| 250 | 
            -
             | 
| 251 | 
            -
             | 
| 252 | 
            -
             | 
| 271 | 
            +
                              catch :response do
         | 
| 272 | 
            +
                                yield result, operation if block_given?
         | 
| 273 | 
            +
                                result
         | 
| 274 | 
            +
                              end
         | 
| 253 275 | 
             
                            end
         | 
| 254 276 |  | 
| 255 277 | 
             
                            ##
         | 
| @@ -278,16 +300,18 @@ module Google | |
| 278 300 |  | 
| 279 301 | 
             
                              response = @client_stub.make_http_request(
         | 
| 280 302 | 
             
                                verb,
         | 
| 281 | 
            -
                                uri: | 
| 282 | 
            -
                                body: | 
| 283 | 
            -
                                params: | 
| 303 | 
            +
                                uri: uri,
         | 
| 304 | 
            +
                                body: body || "",
         | 
| 305 | 
            +
                                params: query_string_params,
         | 
| 306 | 
            +
                                method_name: "activate_certificate_authority",
         | 
| 284 307 | 
             
                                options: options
         | 
| 285 308 | 
             
                              )
         | 
| 286 309 | 
             
                              operation = ::Gapic::Rest::TransportOperation.new response
         | 
| 287 310 | 
             
                              result = ::Google::Longrunning::Operation.decode_json response.body, ignore_unknown_fields: true
         | 
| 288 | 
            -
             | 
| 289 | 
            -
             | 
| 290 | 
            -
             | 
| 311 | 
            +
                              catch :response do
         | 
| 312 | 
            +
                                yield result, operation if block_given?
         | 
| 313 | 
            +
                                result
         | 
| 314 | 
            +
                              end
         | 
| 291 315 | 
             
                            end
         | 
| 292 316 |  | 
| 293 317 | 
             
                            ##
         | 
| @@ -316,16 +340,18 @@ module Google | |
| 316 340 |  | 
| 317 341 | 
             
                              response = @client_stub.make_http_request(
         | 
| 318 342 | 
             
                                verb,
         | 
| 319 | 
            -
                                uri: | 
| 320 | 
            -
                                body: | 
| 321 | 
            -
                                params: | 
| 343 | 
            +
                                uri: uri,
         | 
| 344 | 
            +
                                body: body || "",
         | 
| 345 | 
            +
                                params: query_string_params,
         | 
| 346 | 
            +
                                method_name: "create_certificate_authority",
         | 
| 322 347 | 
             
                                options: options
         | 
| 323 348 | 
             
                              )
         | 
| 324 349 | 
             
                              operation = ::Gapic::Rest::TransportOperation.new response
         | 
| 325 350 | 
             
                              result = ::Google::Longrunning::Operation.decode_json response.body, ignore_unknown_fields: true
         | 
| 326 | 
            -
             | 
| 327 | 
            -
             | 
| 328 | 
            -
             | 
| 351 | 
            +
                              catch :response do
         | 
| 352 | 
            +
                                yield result, operation if block_given?
         | 
| 353 | 
            +
                                result
         | 
| 354 | 
            +
                              end
         | 
| 329 355 | 
             
                            end
         | 
| 330 356 |  | 
| 331 357 | 
             
                            ##
         | 
| @@ -354,16 +380,18 @@ module Google | |
| 354 380 |  | 
| 355 381 | 
             
                              response = @client_stub.make_http_request(
         | 
| 356 382 | 
             
                                verb,
         | 
| 357 | 
            -
                                uri: | 
| 358 | 
            -
                                body: | 
| 359 | 
            -
                                params: | 
| 383 | 
            +
                                uri: uri,
         | 
| 384 | 
            +
                                body: body || "",
         | 
| 385 | 
            +
                                params: query_string_params,
         | 
| 386 | 
            +
                                method_name: "disable_certificate_authority",
         | 
| 360 387 | 
             
                                options: options
         | 
| 361 388 | 
             
                              )
         | 
| 362 389 | 
             
                              operation = ::Gapic::Rest::TransportOperation.new response
         | 
| 363 390 | 
             
                              result = ::Google::Longrunning::Operation.decode_json response.body, ignore_unknown_fields: true
         | 
| 364 | 
            -
             | 
| 365 | 
            -
             | 
| 366 | 
            -
             | 
| 391 | 
            +
                              catch :response do
         | 
| 392 | 
            +
                                yield result, operation if block_given?
         | 
| 393 | 
            +
                                result
         | 
| 394 | 
            +
                              end
         | 
| 367 395 | 
             
                            end
         | 
| 368 396 |  | 
| 369 397 | 
             
                            ##
         | 
| @@ -392,16 +420,18 @@ module Google | |
| 392 420 |  | 
| 393 421 | 
             
                              response = @client_stub.make_http_request(
         | 
| 394 422 | 
             
                                verb,
         | 
| 395 | 
            -
                                uri: | 
| 396 | 
            -
                                body: | 
| 397 | 
            -
                                params: | 
| 423 | 
            +
                                uri: uri,
         | 
| 424 | 
            +
                                body: body || "",
         | 
| 425 | 
            +
                                params: query_string_params,
         | 
| 426 | 
            +
                                method_name: "enable_certificate_authority",
         | 
| 398 427 | 
             
                                options: options
         | 
| 399 428 | 
             
                              )
         | 
| 400 429 | 
             
                              operation = ::Gapic::Rest::TransportOperation.new response
         | 
| 401 430 | 
             
                              result = ::Google::Longrunning::Operation.decode_json response.body, ignore_unknown_fields: true
         | 
| 402 | 
            -
             | 
| 403 | 
            -
             | 
| 404 | 
            -
             | 
| 431 | 
            +
                              catch :response do
         | 
| 432 | 
            +
                                yield result, operation if block_given?
         | 
| 433 | 
            +
                                result
         | 
| 434 | 
            +
                              end
         | 
| 405 435 | 
             
                            end
         | 
| 406 436 |  | 
| 407 437 | 
             
                            ##
         | 
| @@ -430,16 +460,18 @@ module Google | |
| 430 460 |  | 
| 431 461 | 
             
                              response = @client_stub.make_http_request(
         | 
| 432 462 | 
             
                                verb,
         | 
| 433 | 
            -
                                uri: | 
| 434 | 
            -
                                body: | 
| 435 | 
            -
                                params: | 
| 463 | 
            +
                                uri: uri,
         | 
| 464 | 
            +
                                body: body || "",
         | 
| 465 | 
            +
                                params: query_string_params,
         | 
| 466 | 
            +
                                method_name: "fetch_certificate_authority_csr",
         | 
| 436 467 | 
             
                                options: options
         | 
| 437 468 | 
             
                              )
         | 
| 438 469 | 
             
                              operation = ::Gapic::Rest::TransportOperation.new response
         | 
| 439 470 | 
             
                              result = ::Google::Cloud::Security::PrivateCA::V1::FetchCertificateAuthorityCsrResponse.decode_json response.body, ignore_unknown_fields: true
         | 
| 440 | 
            -
             | 
| 441 | 
            -
             | 
| 442 | 
            -
             | 
| 471 | 
            +
                              catch :response do
         | 
| 472 | 
            +
                                yield result, operation if block_given?
         | 
| 473 | 
            +
                                result
         | 
| 474 | 
            +
                              end
         | 
| 443 475 | 
             
                            end
         | 
| 444 476 |  | 
| 445 477 | 
             
                            ##
         | 
| @@ -468,16 +500,18 @@ module Google | |
| 468 500 |  | 
| 469 501 | 
             
                              response = @client_stub.make_http_request(
         | 
| 470 502 | 
             
                                verb,
         | 
| 471 | 
            -
                                uri: | 
| 472 | 
            -
                                body: | 
| 473 | 
            -
                                params: | 
| 503 | 
            +
                                uri: uri,
         | 
| 504 | 
            +
                                body: body || "",
         | 
| 505 | 
            +
                                params: query_string_params,
         | 
| 506 | 
            +
                                method_name: "get_certificate_authority",
         | 
| 474 507 | 
             
                                options: options
         | 
| 475 508 | 
             
                              )
         | 
| 476 509 | 
             
                              operation = ::Gapic::Rest::TransportOperation.new response
         | 
| 477 510 | 
             
                              result = ::Google::Cloud::Security::PrivateCA::V1::CertificateAuthority.decode_json response.body, ignore_unknown_fields: true
         | 
| 478 | 
            -
             | 
| 479 | 
            -
             | 
| 480 | 
            -
             | 
| 511 | 
            +
                              catch :response do
         | 
| 512 | 
            +
                                yield result, operation if block_given?
         | 
| 513 | 
            +
                                result
         | 
| 514 | 
            +
                              end
         | 
| 481 515 | 
             
                            end
         | 
| 482 516 |  | 
| 483 517 | 
             
                            ##
         | 
| @@ -506,16 +540,18 @@ module Google | |
| 506 540 |  | 
| 507 541 | 
             
                              response = @client_stub.make_http_request(
         | 
| 508 542 | 
             
                                verb,
         | 
| 509 | 
            -
                                uri: | 
| 510 | 
            -
                                body: | 
| 511 | 
            -
                                params: | 
| 543 | 
            +
                                uri: uri,
         | 
| 544 | 
            +
                                body: body || "",
         | 
| 545 | 
            +
                                params: query_string_params,
         | 
| 546 | 
            +
                                method_name: "list_certificate_authorities",
         | 
| 512 547 | 
             
                                options: options
         | 
| 513 548 | 
             
                              )
         | 
| 514 549 | 
             
                              operation = ::Gapic::Rest::TransportOperation.new response
         | 
| 515 550 | 
             
                              result = ::Google::Cloud::Security::PrivateCA::V1::ListCertificateAuthoritiesResponse.decode_json response.body, ignore_unknown_fields: true
         | 
| 516 | 
            -
             | 
| 517 | 
            -
             | 
| 518 | 
            -
             | 
| 551 | 
            +
                              catch :response do
         | 
| 552 | 
            +
                                yield result, operation if block_given?
         | 
| 553 | 
            +
                                result
         | 
| 554 | 
            +
                              end
         | 
| 519 555 | 
             
                            end
         | 
| 520 556 |  | 
| 521 557 | 
             
                            ##
         | 
| @@ -544,16 +580,18 @@ module Google | |
| 544 580 |  | 
| 545 581 | 
             
                              response = @client_stub.make_http_request(
         | 
| 546 582 | 
             
                                verb,
         | 
| 547 | 
            -
                                uri: | 
| 548 | 
            -
                                body: | 
| 549 | 
            -
                                params: | 
| 583 | 
            +
                                uri: uri,
         | 
| 584 | 
            +
                                body: body || "",
         | 
| 585 | 
            +
                                params: query_string_params,
         | 
| 586 | 
            +
                                method_name: "undelete_certificate_authority",
         | 
| 550 587 | 
             
                                options: options
         | 
| 551 588 | 
             
                              )
         | 
| 552 589 | 
             
                              operation = ::Gapic::Rest::TransportOperation.new response
         | 
| 553 590 | 
             
                              result = ::Google::Longrunning::Operation.decode_json response.body, ignore_unknown_fields: true
         | 
| 554 | 
            -
             | 
| 555 | 
            -
             | 
| 556 | 
            -
             | 
| 591 | 
            +
                              catch :response do
         | 
| 592 | 
            +
                                yield result, operation if block_given?
         | 
| 593 | 
            +
                                result
         | 
| 594 | 
            +
                              end
         | 
| 557 595 | 
             
                            end
         | 
| 558 596 |  | 
| 559 597 | 
             
                            ##
         | 
| @@ -582,16 +620,18 @@ module Google | |
| 582 620 |  | 
| 583 621 | 
             
                              response = @client_stub.make_http_request(
         | 
| 584 622 | 
             
                                verb,
         | 
| 585 | 
            -
                                uri: | 
| 586 | 
            -
                                body: | 
| 587 | 
            -
                                params: | 
| 623 | 
            +
                                uri: uri,
         | 
| 624 | 
            +
                                body: body || "",
         | 
| 625 | 
            +
                                params: query_string_params,
         | 
| 626 | 
            +
                                method_name: "delete_certificate_authority",
         | 
| 588 627 | 
             
                                options: options
         | 
| 589 628 | 
             
                              )
         | 
| 590 629 | 
             
                              operation = ::Gapic::Rest::TransportOperation.new response
         | 
| 591 630 | 
             
                              result = ::Google::Longrunning::Operation.decode_json response.body, ignore_unknown_fields: true
         | 
| 592 | 
            -
             | 
| 593 | 
            -
             | 
| 594 | 
            -
             | 
| 631 | 
            +
                              catch :response do
         | 
| 632 | 
            +
                                yield result, operation if block_given?
         | 
| 633 | 
            +
                                result
         | 
| 634 | 
            +
                              end
         | 
| 595 635 | 
             
                            end
         | 
| 596 636 |  | 
| 597 637 | 
             
                            ##
         | 
| @@ -620,16 +660,18 @@ module Google | |
| 620 660 |  | 
| 621 661 | 
             
                              response = @client_stub.make_http_request(
         | 
| 622 662 | 
             
                                verb,
         | 
| 623 | 
            -
                                uri: | 
| 624 | 
            -
                                body: | 
| 625 | 
            -
                                params: | 
| 663 | 
            +
                                uri: uri,
         | 
| 664 | 
            +
                                body: body || "",
         | 
| 665 | 
            +
                                params: query_string_params,
         | 
| 666 | 
            +
                                method_name: "update_certificate_authority",
         | 
| 626 667 | 
             
                                options: options
         | 
| 627 668 | 
             
                              )
         | 
| 628 669 | 
             
                              operation = ::Gapic::Rest::TransportOperation.new response
         | 
| 629 670 | 
             
                              result = ::Google::Longrunning::Operation.decode_json response.body, ignore_unknown_fields: true
         | 
| 630 | 
            -
             | 
| 631 | 
            -
             | 
| 632 | 
            -
             | 
| 671 | 
            +
                              catch :response do
         | 
| 672 | 
            +
                                yield result, operation if block_given?
         | 
| 673 | 
            +
                                result
         | 
| 674 | 
            +
                              end
         | 
| 633 675 | 
             
                            end
         | 
| 634 676 |  | 
| 635 677 | 
             
                            ##
         | 
| @@ -658,16 +700,18 @@ module Google | |
| 658 700 |  | 
| 659 701 | 
             
                              response = @client_stub.make_http_request(
         | 
| 660 702 | 
             
                                verb,
         | 
| 661 | 
            -
                                uri: | 
| 662 | 
            -
                                body: | 
| 663 | 
            -
                                params: | 
| 703 | 
            +
                                uri: uri,
         | 
| 704 | 
            +
                                body: body || "",
         | 
| 705 | 
            +
                                params: query_string_params,
         | 
| 706 | 
            +
                                method_name: "create_ca_pool",
         | 
| 664 707 | 
             
                                options: options
         | 
| 665 708 | 
             
                              )
         | 
| 666 709 | 
             
                              operation = ::Gapic::Rest::TransportOperation.new response
         | 
| 667 710 | 
             
                              result = ::Google::Longrunning::Operation.decode_json response.body, ignore_unknown_fields: true
         | 
| 668 | 
            -
             | 
| 669 | 
            -
             | 
| 670 | 
            -
             | 
| 711 | 
            +
                              catch :response do
         | 
| 712 | 
            +
                                yield result, operation if block_given?
         | 
| 713 | 
            +
                                result
         | 
| 714 | 
            +
                              end
         | 
| 671 715 | 
             
                            end
         | 
| 672 716 |  | 
| 673 717 | 
             
                            ##
         | 
| @@ -696,16 +740,18 @@ module Google | |
| 696 740 |  | 
| 697 741 | 
             
                              response = @client_stub.make_http_request(
         | 
| 698 742 | 
             
                                verb,
         | 
| 699 | 
            -
                                uri: | 
| 700 | 
            -
                                body: | 
| 701 | 
            -
                                params: | 
| 743 | 
            +
                                uri: uri,
         | 
| 744 | 
            +
                                body: body || "",
         | 
| 745 | 
            +
                                params: query_string_params,
         | 
| 746 | 
            +
                                method_name: "update_ca_pool",
         | 
| 702 747 | 
             
                                options: options
         | 
| 703 748 | 
             
                              )
         | 
| 704 749 | 
             
                              operation = ::Gapic::Rest::TransportOperation.new response
         | 
| 705 750 | 
             
                              result = ::Google::Longrunning::Operation.decode_json response.body, ignore_unknown_fields: true
         | 
| 706 | 
            -
             | 
| 707 | 
            -
             | 
| 708 | 
            -
             | 
| 751 | 
            +
                              catch :response do
         | 
| 752 | 
            +
                                yield result, operation if block_given?
         | 
| 753 | 
            +
                                result
         | 
| 754 | 
            +
                              end
         | 
| 709 755 | 
             
                            end
         | 
| 710 756 |  | 
| 711 757 | 
             
                            ##
         | 
| @@ -734,16 +780,18 @@ module Google | |
| 734 780 |  | 
| 735 781 | 
             
                              response = @client_stub.make_http_request(
         | 
| 736 782 | 
             
                                verb,
         | 
| 737 | 
            -
                                uri: | 
| 738 | 
            -
                                body: | 
| 739 | 
            -
                                params: | 
| 783 | 
            +
                                uri: uri,
         | 
| 784 | 
            +
                                body: body || "",
         | 
| 785 | 
            +
                                params: query_string_params,
         | 
| 786 | 
            +
                                method_name: "get_ca_pool",
         | 
| 740 787 | 
             
                                options: options
         | 
| 741 788 | 
             
                              )
         | 
| 742 789 | 
             
                              operation = ::Gapic::Rest::TransportOperation.new response
         | 
| 743 790 | 
             
                              result = ::Google::Cloud::Security::PrivateCA::V1::CaPool.decode_json response.body, ignore_unknown_fields: true
         | 
| 744 | 
            -
             | 
| 745 | 
            -
             | 
| 746 | 
            -
             | 
| 791 | 
            +
                              catch :response do
         | 
| 792 | 
            +
                                yield result, operation if block_given?
         | 
| 793 | 
            +
                                result
         | 
| 794 | 
            +
                              end
         | 
| 747 795 | 
             
                            end
         | 
| 748 796 |  | 
| 749 797 | 
             
                            ##
         | 
| @@ -772,16 +820,18 @@ module Google | |
| 772 820 |  | 
| 773 821 | 
             
                              response = @client_stub.make_http_request(
         | 
| 774 822 | 
             
                                verb,
         | 
| 775 | 
            -
                                uri: | 
| 776 | 
            -
                                body: | 
| 777 | 
            -
                                params: | 
| 823 | 
            +
                                uri: uri,
         | 
| 824 | 
            +
                                body: body || "",
         | 
| 825 | 
            +
                                params: query_string_params,
         | 
| 826 | 
            +
                                method_name: "list_ca_pools",
         | 
| 778 827 | 
             
                                options: options
         | 
| 779 828 | 
             
                              )
         | 
| 780 829 | 
             
                              operation = ::Gapic::Rest::TransportOperation.new response
         | 
| 781 830 | 
             
                              result = ::Google::Cloud::Security::PrivateCA::V1::ListCaPoolsResponse.decode_json response.body, ignore_unknown_fields: true
         | 
| 782 | 
            -
             | 
| 783 | 
            -
             | 
| 784 | 
            -
             | 
| 831 | 
            +
                              catch :response do
         | 
| 832 | 
            +
                                yield result, operation if block_given?
         | 
| 833 | 
            +
                                result
         | 
| 834 | 
            +
                              end
         | 
| 785 835 | 
             
                            end
         | 
| 786 836 |  | 
| 787 837 | 
             
                            ##
         | 
| @@ -810,16 +860,18 @@ module Google | |
| 810 860 |  | 
| 811 861 | 
             
                              response = @client_stub.make_http_request(
         | 
| 812 862 | 
             
                                verb,
         | 
| 813 | 
            -
                                uri: | 
| 814 | 
            -
                                body: | 
| 815 | 
            -
                                params: | 
| 863 | 
            +
                                uri: uri,
         | 
| 864 | 
            +
                                body: body || "",
         | 
| 865 | 
            +
                                params: query_string_params,
         | 
| 866 | 
            +
                                method_name: "delete_ca_pool",
         | 
| 816 867 | 
             
                                options: options
         | 
| 817 868 | 
             
                              )
         | 
| 818 869 | 
             
                              operation = ::Gapic::Rest::TransportOperation.new response
         | 
| 819 870 | 
             
                              result = ::Google::Longrunning::Operation.decode_json response.body, ignore_unknown_fields: true
         | 
| 820 | 
            -
             | 
| 821 | 
            -
             | 
| 822 | 
            -
             | 
| 871 | 
            +
                              catch :response do
         | 
| 872 | 
            +
                                yield result, operation if block_given?
         | 
| 873 | 
            +
                                result
         | 
| 874 | 
            +
                              end
         | 
| 823 875 | 
             
                            end
         | 
| 824 876 |  | 
| 825 877 | 
             
                            ##
         | 
| @@ -848,16 +900,18 @@ module Google | |
| 848 900 |  | 
| 849 901 | 
             
                              response = @client_stub.make_http_request(
         | 
| 850 902 | 
             
                                verb,
         | 
| 851 | 
            -
                                uri: | 
| 852 | 
            -
                                body: | 
| 853 | 
            -
                                params: | 
| 903 | 
            +
                                uri: uri,
         | 
| 904 | 
            +
                                body: body || "",
         | 
| 905 | 
            +
                                params: query_string_params,
         | 
| 906 | 
            +
                                method_name: "fetch_ca_certs",
         | 
| 854 907 | 
             
                                options: options
         | 
| 855 908 | 
             
                              )
         | 
| 856 909 | 
             
                              operation = ::Gapic::Rest::TransportOperation.new response
         | 
| 857 910 | 
             
                              result = ::Google::Cloud::Security::PrivateCA::V1::FetchCaCertsResponse.decode_json response.body, ignore_unknown_fields: true
         | 
| 858 | 
            -
             | 
| 859 | 
            -
             | 
| 860 | 
            -
             | 
| 911 | 
            +
                              catch :response do
         | 
| 912 | 
            +
                                yield result, operation if block_given?
         | 
| 913 | 
            +
                                result
         | 
| 914 | 
            +
                              end
         | 
| 861 915 | 
             
                            end
         | 
| 862 916 |  | 
| 863 917 | 
             
                            ##
         | 
| @@ -886,16 +940,18 @@ module Google | |
| 886 940 |  | 
| 887 941 | 
             
                              response = @client_stub.make_http_request(
         | 
| 888 942 | 
             
                                verb,
         | 
| 889 | 
            -
                                uri: | 
| 890 | 
            -
                                body: | 
| 891 | 
            -
                                params: | 
| 943 | 
            +
                                uri: uri,
         | 
| 944 | 
            +
                                body: body || "",
         | 
| 945 | 
            +
                                params: query_string_params,
         | 
| 946 | 
            +
                                method_name: "get_certificate_revocation_list",
         | 
| 892 947 | 
             
                                options: options
         | 
| 893 948 | 
             
                              )
         | 
| 894 949 | 
             
                              operation = ::Gapic::Rest::TransportOperation.new response
         | 
| 895 950 | 
             
                              result = ::Google::Cloud::Security::PrivateCA::V1::CertificateRevocationList.decode_json response.body, ignore_unknown_fields: true
         | 
| 896 | 
            -
             | 
| 897 | 
            -
             | 
| 898 | 
            -
             | 
| 951 | 
            +
                              catch :response do
         | 
| 952 | 
            +
                                yield result, operation if block_given?
         | 
| 953 | 
            +
                                result
         | 
| 954 | 
            +
                              end
         | 
| 899 955 | 
             
                            end
         | 
| 900 956 |  | 
| 901 957 | 
             
                            ##
         | 
| @@ -924,16 +980,18 @@ module Google | |
| 924 980 |  | 
| 925 981 | 
             
                              response = @client_stub.make_http_request(
         | 
| 926 982 | 
             
                                verb,
         | 
| 927 | 
            -
                                uri: | 
| 928 | 
            -
                                body: | 
| 929 | 
            -
                                params: | 
| 983 | 
            +
                                uri: uri,
         | 
| 984 | 
            +
                                body: body || "",
         | 
| 985 | 
            +
                                params: query_string_params,
         | 
| 986 | 
            +
                                method_name: "list_certificate_revocation_lists",
         | 
| 930 987 | 
             
                                options: options
         | 
| 931 988 | 
             
                              )
         | 
| 932 989 | 
             
                              operation = ::Gapic::Rest::TransportOperation.new response
         | 
| 933 990 | 
             
                              result = ::Google::Cloud::Security::PrivateCA::V1::ListCertificateRevocationListsResponse.decode_json response.body, ignore_unknown_fields: true
         | 
| 934 | 
            -
             | 
| 935 | 
            -
             | 
| 936 | 
            -
             | 
| 991 | 
            +
                              catch :response do
         | 
| 992 | 
            +
                                yield result, operation if block_given?
         | 
| 993 | 
            +
                                result
         | 
| 994 | 
            +
                              end
         | 
| 937 995 | 
             
                            end
         | 
| 938 996 |  | 
| 939 997 | 
             
                            ##
         | 
| @@ -962,16 +1020,18 @@ module Google | |
| 962 1020 |  | 
| 963 1021 | 
             
                              response = @client_stub.make_http_request(
         | 
| 964 1022 | 
             
                                verb,
         | 
| 965 | 
            -
                                uri: | 
| 966 | 
            -
                                body: | 
| 967 | 
            -
                                params: | 
| 1023 | 
            +
                                uri: uri,
         | 
| 1024 | 
            +
                                body: body || "",
         | 
| 1025 | 
            +
                                params: query_string_params,
         | 
| 1026 | 
            +
                                method_name: "update_certificate_revocation_list",
         | 
| 968 1027 | 
             
                                options: options
         | 
| 969 1028 | 
             
                              )
         | 
| 970 1029 | 
             
                              operation = ::Gapic::Rest::TransportOperation.new response
         | 
| 971 1030 | 
             
                              result = ::Google::Longrunning::Operation.decode_json response.body, ignore_unknown_fields: true
         | 
| 972 | 
            -
             | 
| 973 | 
            -
             | 
| 974 | 
            -
             | 
| 1031 | 
            +
                              catch :response do
         | 
| 1032 | 
            +
                                yield result, operation if block_given?
         | 
| 1033 | 
            +
                                result
         | 
| 1034 | 
            +
                              end
         | 
| 975 1035 | 
             
                            end
         | 
| 976 1036 |  | 
| 977 1037 | 
             
                            ##
         | 
| @@ -1000,16 +1060,18 @@ module Google | |
| 1000 1060 |  | 
| 1001 1061 | 
             
                              response = @client_stub.make_http_request(
         | 
| 1002 1062 | 
             
                                verb,
         | 
| 1003 | 
            -
                                uri: | 
| 1004 | 
            -
                                body: | 
| 1005 | 
            -
                                params: | 
| 1063 | 
            +
                                uri: uri,
         | 
| 1064 | 
            +
                                body: body || "",
         | 
| 1065 | 
            +
                                params: query_string_params,
         | 
| 1066 | 
            +
                                method_name: "create_certificate_template",
         | 
| 1006 1067 | 
             
                                options: options
         | 
| 1007 1068 | 
             
                              )
         | 
| 1008 1069 | 
             
                              operation = ::Gapic::Rest::TransportOperation.new response
         | 
| 1009 1070 | 
             
                              result = ::Google::Longrunning::Operation.decode_json response.body, ignore_unknown_fields: true
         | 
| 1010 | 
            -
             | 
| 1011 | 
            -
             | 
| 1012 | 
            -
             | 
| 1071 | 
            +
                              catch :response do
         | 
| 1072 | 
            +
                                yield result, operation if block_given?
         | 
| 1073 | 
            +
                                result
         | 
| 1074 | 
            +
                              end
         | 
| 1013 1075 | 
             
                            end
         | 
| 1014 1076 |  | 
| 1015 1077 | 
             
                            ##
         | 
| @@ -1038,16 +1100,18 @@ module Google | |
| 1038 1100 |  | 
| 1039 1101 | 
             
                              response = @client_stub.make_http_request(
         | 
| 1040 1102 | 
             
                                verb,
         | 
| 1041 | 
            -
                                uri: | 
| 1042 | 
            -
                                body: | 
| 1043 | 
            -
                                params: | 
| 1103 | 
            +
                                uri: uri,
         | 
| 1104 | 
            +
                                body: body || "",
         | 
| 1105 | 
            +
                                params: query_string_params,
         | 
| 1106 | 
            +
                                method_name: "delete_certificate_template",
         | 
| 1044 1107 | 
             
                                options: options
         | 
| 1045 1108 | 
             
                              )
         | 
| 1046 1109 | 
             
                              operation = ::Gapic::Rest::TransportOperation.new response
         | 
| 1047 1110 | 
             
                              result = ::Google::Longrunning::Operation.decode_json response.body, ignore_unknown_fields: true
         | 
| 1048 | 
            -
             | 
| 1049 | 
            -
             | 
| 1050 | 
            -
             | 
| 1111 | 
            +
                              catch :response do
         | 
| 1112 | 
            +
                                yield result, operation if block_given?
         | 
| 1113 | 
            +
                                result
         | 
| 1114 | 
            +
                              end
         | 
| 1051 1115 | 
             
                            end
         | 
| 1052 1116 |  | 
| 1053 1117 | 
             
                            ##
         | 
| @@ -1076,16 +1140,18 @@ module Google | |
| 1076 1140 |  | 
| 1077 1141 | 
             
                              response = @client_stub.make_http_request(
         | 
| 1078 1142 | 
             
                                verb,
         | 
| 1079 | 
            -
                                uri: | 
| 1080 | 
            -
                                body: | 
| 1081 | 
            -
                                params: | 
| 1143 | 
            +
                                uri: uri,
         | 
| 1144 | 
            +
                                body: body || "",
         | 
| 1145 | 
            +
                                params: query_string_params,
         | 
| 1146 | 
            +
                                method_name: "get_certificate_template",
         | 
| 1082 1147 | 
             
                                options: options
         | 
| 1083 1148 | 
             
                              )
         | 
| 1084 1149 | 
             
                              operation = ::Gapic::Rest::TransportOperation.new response
         | 
| 1085 1150 | 
             
                              result = ::Google::Cloud::Security::PrivateCA::V1::CertificateTemplate.decode_json response.body, ignore_unknown_fields: true
         | 
| 1086 | 
            -
             | 
| 1087 | 
            -
             | 
| 1088 | 
            -
             | 
| 1151 | 
            +
                              catch :response do
         | 
| 1152 | 
            +
                                yield result, operation if block_given?
         | 
| 1153 | 
            +
                                result
         | 
| 1154 | 
            +
                              end
         | 
| 1089 1155 | 
             
                            end
         | 
| 1090 1156 |  | 
| 1091 1157 | 
             
                            ##
         | 
| @@ -1114,16 +1180,18 @@ module Google | |
| 1114 1180 |  | 
| 1115 1181 | 
             
                              response = @client_stub.make_http_request(
         | 
| 1116 1182 | 
             
                                verb,
         | 
| 1117 | 
            -
                                uri: | 
| 1118 | 
            -
                                body: | 
| 1119 | 
            -
                                params: | 
| 1183 | 
            +
                                uri: uri,
         | 
| 1184 | 
            +
                                body: body || "",
         | 
| 1185 | 
            +
                                params: query_string_params,
         | 
| 1186 | 
            +
                                method_name: "list_certificate_templates",
         | 
| 1120 1187 | 
             
                                options: options
         | 
| 1121 1188 | 
             
                              )
         | 
| 1122 1189 | 
             
                              operation = ::Gapic::Rest::TransportOperation.new response
         | 
| 1123 1190 | 
             
                              result = ::Google::Cloud::Security::PrivateCA::V1::ListCertificateTemplatesResponse.decode_json response.body, ignore_unknown_fields: true
         | 
| 1124 | 
            -
             | 
| 1125 | 
            -
             | 
| 1126 | 
            -
             | 
| 1191 | 
            +
                              catch :response do
         | 
| 1192 | 
            +
                                yield result, operation if block_given?
         | 
| 1193 | 
            +
                                result
         | 
| 1194 | 
            +
                              end
         | 
| 1127 1195 | 
             
                            end
         | 
| 1128 1196 |  | 
| 1129 1197 | 
             
                            ##
         | 
| @@ -1152,16 +1220,18 @@ module Google | |
| 1152 1220 |  | 
| 1153 1221 | 
             
                              response = @client_stub.make_http_request(
         | 
| 1154 1222 | 
             
                                verb,
         | 
| 1155 | 
            -
                                uri: | 
| 1156 | 
            -
                                body: | 
| 1157 | 
            -
                                params: | 
| 1223 | 
            +
                                uri: uri,
         | 
| 1224 | 
            +
                                body: body || "",
         | 
| 1225 | 
            +
                                params: query_string_params,
         | 
| 1226 | 
            +
                                method_name: "update_certificate_template",
         | 
| 1158 1227 | 
             
                                options: options
         | 
| 1159 1228 | 
             
                              )
         | 
| 1160 1229 | 
             
                              operation = ::Gapic::Rest::TransportOperation.new response
         | 
| 1161 1230 | 
             
                              result = ::Google::Longrunning::Operation.decode_json response.body, ignore_unknown_fields: true
         | 
| 1162 | 
            -
             | 
| 1163 | 
            -
             | 
| 1164 | 
            -
             | 
| 1231 | 
            +
                              catch :response do
         | 
| 1232 | 
            +
                                yield result, operation if block_given?
         | 
| 1233 | 
            +
                                result
         | 
| 1234 | 
            +
                              end
         | 
| 1165 1235 | 
             
                            end
         | 
| 1166 1236 |  | 
| 1167 1237 | 
             
                            ##
         |