google-cloud-workstations-v1 0.1.3 → 0.2.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/README.md +30 -20
- data/lib/google/cloud/workstations/v1/version.rb +1 -1
- data/lib/google/cloud/workstations/v1/workstations/client.rb +45 -21
- data/lib/google/cloud/workstations/v1/workstations/operations.rb +9 -5
- data/lib/google/cloud/workstations/v1/workstations/rest/client.rb +40 -21
- data/lib/google/cloud/workstations/v1/workstations/rest/operations.rb +40 -28
- data/lib/google/cloud/workstations/v1/workstations/rest/service_stub.rb +174 -122
- metadata +4 -4
| @@ -196,7 +196,7 @@ module Google | |
| 196 196 | 
             
                            @operations_stub.list_operations request, options do |result, operation|
         | 
| 197 197 | 
             
                              result = ::Gapic::Rest::PagedEnumerable.new @operations_stub, :list_operations, "operations", request, result, options
         | 
| 198 198 | 
             
                              yield result, operation if block_given?
         | 
| 199 | 
            -
                               | 
| 199 | 
            +
                              throw :response, result
         | 
| 200 200 | 
             
                            end
         | 
| 201 201 | 
             
                          rescue ::Gapic::Rest::Error => e
         | 
| 202 202 | 
             
                            raise ::Google::Cloud::Error.from_error(e)
         | 
| @@ -285,7 +285,7 @@ module Google | |
| 285 285 | 
             
                            @operations_stub.get_operation request, options do |result, operation|
         | 
| 286 286 | 
             
                              result = ::Gapic::Operation.new result, @operations_client, options: options
         | 
| 287 287 | 
             
                              yield result, operation if block_given?
         | 
| 288 | 
            -
                               | 
| 288 | 
            +
                              throw :response, result
         | 
| 289 289 | 
             
                            end
         | 
| 290 290 | 
             
                          rescue ::Gapic::Rest::Error => e
         | 
| 291 291 | 
             
                            raise ::Google::Cloud::Error.from_error(e)
         | 
| @@ -367,7 +367,6 @@ module Google | |
| 367 367 |  | 
| 368 368 | 
             
                            @operations_stub.delete_operation request, options do |result, operation|
         | 
| 369 369 | 
             
                              yield result, operation if block_given?
         | 
| 370 | 
            -
                              return result
         | 
| 371 370 | 
             
                            end
         | 
| 372 371 | 
             
                          rescue ::Gapic::Rest::Error => e
         | 
| 373 372 | 
             
                            raise ::Google::Cloud::Error.from_error(e)
         | 
| @@ -456,7 +455,6 @@ module Google | |
| 456 455 |  | 
| 457 456 | 
             
                            @operations_stub.cancel_operation request, options do |result, operation|
         | 
| 458 457 | 
             
                              yield result, operation if block_given?
         | 
| 459 | 
            -
                              return result
         | 
| 460 458 | 
             
                            end
         | 
| 461 459 | 
             
                          rescue ::Gapic::Rest::Error => e
         | 
| 462 460 | 
             
                            raise ::Google::Cloud::Error.from_error(e)
         | 
| @@ -536,6 +534,11 @@ module Google | |
| 536 534 | 
             
                          #   default endpoint URL. The default value of nil uses the environment
         | 
| 537 535 | 
             
                          #   universe (usually the default "googleapis.com" universe).
         | 
| 538 536 | 
             
                          #   @return [::String,nil]
         | 
| 537 | 
            +
                          # @!attribute [rw] logger
         | 
| 538 | 
            +
                          #   A custom logger to use for request/response debug logging, or the value
         | 
| 539 | 
            +
                          #   `:default` (the default) to construct a default logger, or `nil` to
         | 
| 540 | 
            +
                          #   explicitly disable logging.
         | 
| 541 | 
            +
                          #   @return [::Logger,:default,nil]
         | 
| 539 542 | 
             
                          #
         | 
| 540 543 | 
             
                          class Configuration
         | 
| 541 544 | 
             
                            extend ::Gapic::Config
         | 
| @@ -557,6 +560,7 @@ module Google | |
| 557 560 | 
             
                            config_attr :retry_policy,  nil, ::Hash, ::Proc, nil
         | 
| 558 561 | 
             
                            config_attr :quota_project, nil, ::String, nil
         | 
| 559 562 | 
             
                            config_attr :universe_domain, nil, ::String, nil
         | 
| 563 | 
            +
                            config_attr :logger, :default, ::Logger, nil, :default
         | 
| 560 564 |  | 
| 561 565 | 
             
                            # @private
         | 
| 562 566 | 
             
                            def initialize parent_config = nil
         | 
| @@ -676,16 +680,18 @@ module Google | |
| 676 680 |  | 
| 677 681 | 
             
                            response = @client_stub.make_http_request(
         | 
| 678 682 | 
             
                              verb,
         | 
| 679 | 
            -
                              uri: | 
| 680 | 
            -
                              body: | 
| 681 | 
            -
                              params: | 
| 683 | 
            +
                              uri: uri,
         | 
| 684 | 
            +
                              body: body || "",
         | 
| 685 | 
            +
                              params: query_string_params,
         | 
| 686 | 
            +
                              method_name: "list_operations",
         | 
| 682 687 | 
             
                              options: options
         | 
| 683 688 | 
             
                            )
         | 
| 684 689 | 
             
                            operation = ::Gapic::Rest::TransportOperation.new response
         | 
| 685 690 | 
             
                            result = ::Google::Longrunning::ListOperationsResponse.decode_json response.body, ignore_unknown_fields: true
         | 
| 686 | 
            -
             | 
| 687 | 
            -
             | 
| 688 | 
            -
             | 
| 691 | 
            +
                            catch :response do
         | 
| 692 | 
            +
                              yield result, operation if block_given?
         | 
| 693 | 
            +
                              result
         | 
| 694 | 
            +
                            end
         | 
| 689 695 | 
             
                          end
         | 
| 690 696 |  | 
| 691 697 | 
             
                          ##
         | 
| @@ -714,16 +720,18 @@ module Google | |
| 714 720 |  | 
| 715 721 | 
             
                            response = @client_stub.make_http_request(
         | 
| 716 722 | 
             
                              verb,
         | 
| 717 | 
            -
                              uri: | 
| 718 | 
            -
                              body: | 
| 719 | 
            -
                              params: | 
| 723 | 
            +
                              uri: uri,
         | 
| 724 | 
            +
                              body: body || "",
         | 
| 725 | 
            +
                              params: query_string_params,
         | 
| 726 | 
            +
                              method_name: "get_operation",
         | 
| 720 727 | 
             
                              options: options
         | 
| 721 728 | 
             
                            )
         | 
| 722 729 | 
             
                            operation = ::Gapic::Rest::TransportOperation.new response
         | 
| 723 730 | 
             
                            result = ::Google::Longrunning::Operation.decode_json response.body, ignore_unknown_fields: true
         | 
| 724 | 
            -
             | 
| 725 | 
            -
             | 
| 726 | 
            -
             | 
| 731 | 
            +
                            catch :response do
         | 
| 732 | 
            +
                              yield result, operation if block_given?
         | 
| 733 | 
            +
                              result
         | 
| 734 | 
            +
                            end
         | 
| 727 735 | 
             
                          end
         | 
| 728 736 |  | 
| 729 737 | 
             
                          ##
         | 
| @@ -752,16 +760,18 @@ module Google | |
| 752 760 |  | 
| 753 761 | 
             
                            response = @client_stub.make_http_request(
         | 
| 754 762 | 
             
                              verb,
         | 
| 755 | 
            -
                              uri: | 
| 756 | 
            -
                              body: | 
| 757 | 
            -
                              params: | 
| 763 | 
            +
                              uri: uri,
         | 
| 764 | 
            +
                              body: body || "",
         | 
| 765 | 
            +
                              params: query_string_params,
         | 
| 766 | 
            +
                              method_name: "delete_operation",
         | 
| 758 767 | 
             
                              options: options
         | 
| 759 768 | 
             
                            )
         | 
| 760 769 | 
             
                            operation = ::Gapic::Rest::TransportOperation.new response
         | 
| 761 770 | 
             
                            result = ::Google::Protobuf::Empty.decode_json response.body, ignore_unknown_fields: true
         | 
| 762 | 
            -
             | 
| 763 | 
            -
             | 
| 764 | 
            -
             | 
| 771 | 
            +
                            catch :response do
         | 
| 772 | 
            +
                              yield result, operation if block_given?
         | 
| 773 | 
            +
                              result
         | 
| 774 | 
            +
                            end
         | 
| 765 775 | 
             
                          end
         | 
| 766 776 |  | 
| 767 777 | 
             
                          ##
         | 
| @@ -790,16 +800,18 @@ module Google | |
| 790 800 |  | 
| 791 801 | 
             
                            response = @client_stub.make_http_request(
         | 
| 792 802 | 
             
                              verb,
         | 
| 793 | 
            -
                              uri: | 
| 794 | 
            -
                              body: | 
| 795 | 
            -
                              params: | 
| 803 | 
            +
                              uri: uri,
         | 
| 804 | 
            +
                              body: body || "",
         | 
| 805 | 
            +
                              params: query_string_params,
         | 
| 806 | 
            +
                              method_name: "cancel_operation",
         | 
| 796 807 | 
             
                              options: options
         | 
| 797 808 | 
             
                            )
         | 
| 798 809 | 
             
                            operation = ::Gapic::Rest::TransportOperation.new response
         | 
| 799 810 | 
             
                            result = ::Google::Protobuf::Empty.decode_json response.body, ignore_unknown_fields: true
         | 
| 800 | 
            -
             | 
| 801 | 
            -
             | 
| 802 | 
            -
             | 
| 811 | 
            +
                            catch :response do
         | 
| 812 | 
            +
                              yield result, operation if block_given?
         | 
| 813 | 
            +
                              result
         | 
| 814 | 
            +
                            end
         | 
| 803 815 | 
             
                          end
         | 
| 804 816 |  | 
| 805 817 | 
             
                          ##
         | 
| @@ -30,7 +30,8 @@ module Google | |
| 30 30 | 
             
                        # including transcoding, making the REST call, and deserialing the response.
         | 
| 31 31 | 
             
                        #
         | 
| 32 32 | 
             
                        class ServiceStub
         | 
| 33 | 
            -
                           | 
| 33 | 
            +
                          # @private
         | 
| 34 | 
            +
                          def initialize endpoint:, endpoint_template:, universe_domain:, credentials:, logger:
         | 
| 34 35 | 
             
                            # These require statements are intentionally placed here to initialize
         | 
| 35 36 | 
             
                            # the REST modules only when it's required.
         | 
| 36 37 | 
             
                            require "gapic/rest"
         | 
| @@ -40,7 +41,9 @@ module Google | |
| 40 41 | 
             
                                                                         universe_domain: universe_domain,
         | 
| 41 42 | 
             
                                                                         credentials: credentials,
         | 
| 42 43 | 
             
                                                                         numeric_enums: true,
         | 
| 43 | 
            -
                                                                          | 
| 44 | 
            +
                                                                         service_name: self.class,
         | 
| 45 | 
            +
                                                                         raise_faraday_errors: false,
         | 
| 46 | 
            +
                                                                         logger: logger
         | 
| 44 47 | 
             
                          end
         | 
| 45 48 |  | 
| 46 49 | 
             
                          ##
         | 
| @@ -61,6 +64,15 @@ module Google | |
| 61 64 | 
             
                            @client_stub.endpoint
         | 
| 62 65 | 
             
                          end
         | 
| 63 66 |  | 
| 67 | 
            +
                          ##
         | 
| 68 | 
            +
                          # The logger used for request/response debug logging.
         | 
| 69 | 
            +
                          #
         | 
| 70 | 
            +
                          # @return [Logger]
         | 
| 71 | 
            +
                          #
         | 
| 72 | 
            +
                          def logger stub: false
         | 
| 73 | 
            +
                            stub ? @client_stub.stub_logger : @client_stub.logger
         | 
| 74 | 
            +
                          end
         | 
| 75 | 
            +
             | 
| 64 76 | 
             
                          ##
         | 
| 65 77 | 
             
                          # Baseline implementation for the get_workstation_cluster REST call
         | 
| 66 78 | 
             
                          #
         | 
| @@ -87,16 +99,18 @@ module Google | |
| 87 99 |  | 
| 88 100 | 
             
                            response = @client_stub.make_http_request(
         | 
| 89 101 | 
             
                              verb,
         | 
| 90 | 
            -
                              uri: | 
| 91 | 
            -
                              body: | 
| 92 | 
            -
                              params: | 
| 102 | 
            +
                              uri: uri,
         | 
| 103 | 
            +
                              body: body || "",
         | 
| 104 | 
            +
                              params: query_string_params,
         | 
| 105 | 
            +
                              method_name: "get_workstation_cluster",
         | 
| 93 106 | 
             
                              options: options
         | 
| 94 107 | 
             
                            )
         | 
| 95 108 | 
             
                            operation = ::Gapic::Rest::TransportOperation.new response
         | 
| 96 109 | 
             
                            result = ::Google::Cloud::Workstations::V1::WorkstationCluster.decode_json response.body, ignore_unknown_fields: true
         | 
| 97 | 
            -
             | 
| 98 | 
            -
             | 
| 99 | 
            -
             | 
| 110 | 
            +
                            catch :response do
         | 
| 111 | 
            +
                              yield result, operation if block_given?
         | 
| 112 | 
            +
                              result
         | 
| 113 | 
            +
                            end
         | 
| 100 114 | 
             
                          end
         | 
| 101 115 |  | 
| 102 116 | 
             
                          ##
         | 
| @@ -125,16 +139,18 @@ module Google | |
| 125 139 |  | 
| 126 140 | 
             
                            response = @client_stub.make_http_request(
         | 
| 127 141 | 
             
                              verb,
         | 
| 128 | 
            -
                              uri: | 
| 129 | 
            -
                              body: | 
| 130 | 
            -
                              params: | 
| 142 | 
            +
                              uri: uri,
         | 
| 143 | 
            +
                              body: body || "",
         | 
| 144 | 
            +
                              params: query_string_params,
         | 
| 145 | 
            +
                              method_name: "list_workstation_clusters",
         | 
| 131 146 | 
             
                              options: options
         | 
| 132 147 | 
             
                            )
         | 
| 133 148 | 
             
                            operation = ::Gapic::Rest::TransportOperation.new response
         | 
| 134 149 | 
             
                            result = ::Google::Cloud::Workstations::V1::ListWorkstationClustersResponse.decode_json response.body, ignore_unknown_fields: true
         | 
| 135 | 
            -
             | 
| 136 | 
            -
             | 
| 137 | 
            -
             | 
| 150 | 
            +
                            catch :response do
         | 
| 151 | 
            +
                              yield result, operation if block_given?
         | 
| 152 | 
            +
                              result
         | 
| 153 | 
            +
                            end
         | 
| 138 154 | 
             
                          end
         | 
| 139 155 |  | 
| 140 156 | 
             
                          ##
         | 
| @@ -163,16 +179,18 @@ module Google | |
| 163 179 |  | 
| 164 180 | 
             
                            response = @client_stub.make_http_request(
         | 
| 165 181 | 
             
                              verb,
         | 
| 166 | 
            -
                              uri: | 
| 167 | 
            -
                              body: | 
| 168 | 
            -
                              params: | 
| 182 | 
            +
                              uri: uri,
         | 
| 183 | 
            +
                              body: body || "",
         | 
| 184 | 
            +
                              params: query_string_params,
         | 
| 185 | 
            +
                              method_name: "create_workstation_cluster",
         | 
| 169 186 | 
             
                              options: options
         | 
| 170 187 | 
             
                            )
         | 
| 171 188 | 
             
                            operation = ::Gapic::Rest::TransportOperation.new response
         | 
| 172 189 | 
             
                            result = ::Google::Longrunning::Operation.decode_json response.body, ignore_unknown_fields: true
         | 
| 173 | 
            -
             | 
| 174 | 
            -
             | 
| 175 | 
            -
             | 
| 190 | 
            +
                            catch :response do
         | 
| 191 | 
            +
                              yield result, operation if block_given?
         | 
| 192 | 
            +
                              result
         | 
| 193 | 
            +
                            end
         | 
| 176 194 | 
             
                          end
         | 
| 177 195 |  | 
| 178 196 | 
             
                          ##
         | 
| @@ -201,16 +219,18 @@ module Google | |
| 201 219 |  | 
| 202 220 | 
             
                            response = @client_stub.make_http_request(
         | 
| 203 221 | 
             
                              verb,
         | 
| 204 | 
            -
                              uri: | 
| 205 | 
            -
                              body: | 
| 206 | 
            -
                              params: | 
| 222 | 
            +
                              uri: uri,
         | 
| 223 | 
            +
                              body: body || "",
         | 
| 224 | 
            +
                              params: query_string_params,
         | 
| 225 | 
            +
                              method_name: "update_workstation_cluster",
         | 
| 207 226 | 
             
                              options: options
         | 
| 208 227 | 
             
                            )
         | 
| 209 228 | 
             
                            operation = ::Gapic::Rest::TransportOperation.new response
         | 
| 210 229 | 
             
                            result = ::Google::Longrunning::Operation.decode_json response.body, ignore_unknown_fields: true
         | 
| 211 | 
            -
             | 
| 212 | 
            -
             | 
| 213 | 
            -
             | 
| 230 | 
            +
                            catch :response do
         | 
| 231 | 
            +
                              yield result, operation if block_given?
         | 
| 232 | 
            +
                              result
         | 
| 233 | 
            +
                            end
         | 
| 214 234 | 
             
                          end
         | 
| 215 235 |  | 
| 216 236 | 
             
                          ##
         | 
| @@ -239,16 +259,18 @@ module Google | |
| 239 259 |  | 
| 240 260 | 
             
                            response = @client_stub.make_http_request(
         | 
| 241 261 | 
             
                              verb,
         | 
| 242 | 
            -
                              uri: | 
| 243 | 
            -
                              body: | 
| 244 | 
            -
                              params: | 
| 262 | 
            +
                              uri: uri,
         | 
| 263 | 
            +
                              body: body || "",
         | 
| 264 | 
            +
                              params: query_string_params,
         | 
| 265 | 
            +
                              method_name: "delete_workstation_cluster",
         | 
| 245 266 | 
             
                              options: options
         | 
| 246 267 | 
             
                            )
         | 
| 247 268 | 
             
                            operation = ::Gapic::Rest::TransportOperation.new response
         | 
| 248 269 | 
             
                            result = ::Google::Longrunning::Operation.decode_json response.body, ignore_unknown_fields: true
         | 
| 249 | 
            -
             | 
| 250 | 
            -
             | 
| 251 | 
            -
             | 
| 270 | 
            +
                            catch :response do
         | 
| 271 | 
            +
                              yield result, operation if block_given?
         | 
| 272 | 
            +
                              result
         | 
| 273 | 
            +
                            end
         | 
| 252 274 | 
             
                          end
         | 
| 253 275 |  | 
| 254 276 | 
             
                          ##
         | 
| @@ -277,16 +299,18 @@ module Google | |
| 277 299 |  | 
| 278 300 | 
             
                            response = @client_stub.make_http_request(
         | 
| 279 301 | 
             
                              verb,
         | 
| 280 | 
            -
                              uri: | 
| 281 | 
            -
                              body: | 
| 282 | 
            -
                              params: | 
| 302 | 
            +
                              uri: uri,
         | 
| 303 | 
            +
                              body: body || "",
         | 
| 304 | 
            +
                              params: query_string_params,
         | 
| 305 | 
            +
                              method_name: "get_workstation_config",
         | 
| 283 306 | 
             
                              options: options
         | 
| 284 307 | 
             
                            )
         | 
| 285 308 | 
             
                            operation = ::Gapic::Rest::TransportOperation.new response
         | 
| 286 309 | 
             
                            result = ::Google::Cloud::Workstations::V1::WorkstationConfig.decode_json response.body, ignore_unknown_fields: true
         | 
| 287 | 
            -
             | 
| 288 | 
            -
             | 
| 289 | 
            -
             | 
| 310 | 
            +
                            catch :response do
         | 
| 311 | 
            +
                              yield result, operation if block_given?
         | 
| 312 | 
            +
                              result
         | 
| 313 | 
            +
                            end
         | 
| 290 314 | 
             
                          end
         | 
| 291 315 |  | 
| 292 316 | 
             
                          ##
         | 
| @@ -315,16 +339,18 @@ module Google | |
| 315 339 |  | 
| 316 340 | 
             
                            response = @client_stub.make_http_request(
         | 
| 317 341 | 
             
                              verb,
         | 
| 318 | 
            -
                              uri: | 
| 319 | 
            -
                              body: | 
| 320 | 
            -
                              params: | 
| 342 | 
            +
                              uri: uri,
         | 
| 343 | 
            +
                              body: body || "",
         | 
| 344 | 
            +
                              params: query_string_params,
         | 
| 345 | 
            +
                              method_name: "list_workstation_configs",
         | 
| 321 346 | 
             
                              options: options
         | 
| 322 347 | 
             
                            )
         | 
| 323 348 | 
             
                            operation = ::Gapic::Rest::TransportOperation.new response
         | 
| 324 349 | 
             
                            result = ::Google::Cloud::Workstations::V1::ListWorkstationConfigsResponse.decode_json response.body, ignore_unknown_fields: true
         | 
| 325 | 
            -
             | 
| 326 | 
            -
             | 
| 327 | 
            -
             | 
| 350 | 
            +
                            catch :response do
         | 
| 351 | 
            +
                              yield result, operation if block_given?
         | 
| 352 | 
            +
                              result
         | 
| 353 | 
            +
                            end
         | 
| 328 354 | 
             
                          end
         | 
| 329 355 |  | 
| 330 356 | 
             
                          ##
         | 
| @@ -353,16 +379,18 @@ module Google | |
| 353 379 |  | 
| 354 380 | 
             
                            response = @client_stub.make_http_request(
         | 
| 355 381 | 
             
                              verb,
         | 
| 356 | 
            -
                              uri: | 
| 357 | 
            -
                              body: | 
| 358 | 
            -
                              params: | 
| 382 | 
            +
                              uri: uri,
         | 
| 383 | 
            +
                              body: body || "",
         | 
| 384 | 
            +
                              params: query_string_params,
         | 
| 385 | 
            +
                              method_name: "list_usable_workstation_configs",
         | 
| 359 386 | 
             
                              options: options
         | 
| 360 387 | 
             
                            )
         | 
| 361 388 | 
             
                            operation = ::Gapic::Rest::TransportOperation.new response
         | 
| 362 389 | 
             
                            result = ::Google::Cloud::Workstations::V1::ListUsableWorkstationConfigsResponse.decode_json response.body, ignore_unknown_fields: true
         | 
| 363 | 
            -
             | 
| 364 | 
            -
             | 
| 365 | 
            -
             | 
| 390 | 
            +
                            catch :response do
         | 
| 391 | 
            +
                              yield result, operation if block_given?
         | 
| 392 | 
            +
                              result
         | 
| 393 | 
            +
                            end
         | 
| 366 394 | 
             
                          end
         | 
| 367 395 |  | 
| 368 396 | 
             
                          ##
         | 
| @@ -391,16 +419,18 @@ module Google | |
| 391 419 |  | 
| 392 420 | 
             
                            response = @client_stub.make_http_request(
         | 
| 393 421 | 
             
                              verb,
         | 
| 394 | 
            -
                              uri: | 
| 395 | 
            -
                              body: | 
| 396 | 
            -
                              params: | 
| 422 | 
            +
                              uri: uri,
         | 
| 423 | 
            +
                              body: body || "",
         | 
| 424 | 
            +
                              params: query_string_params,
         | 
| 425 | 
            +
                              method_name: "create_workstation_config",
         | 
| 397 426 | 
             
                              options: options
         | 
| 398 427 | 
             
                            )
         | 
| 399 428 | 
             
                            operation = ::Gapic::Rest::TransportOperation.new response
         | 
| 400 429 | 
             
                            result = ::Google::Longrunning::Operation.decode_json response.body, ignore_unknown_fields: true
         | 
| 401 | 
            -
             | 
| 402 | 
            -
             | 
| 403 | 
            -
             | 
| 430 | 
            +
                            catch :response do
         | 
| 431 | 
            +
                              yield result, operation if block_given?
         | 
| 432 | 
            +
                              result
         | 
| 433 | 
            +
                            end
         | 
| 404 434 | 
             
                          end
         | 
| 405 435 |  | 
| 406 436 | 
             
                          ##
         | 
| @@ -429,16 +459,18 @@ module Google | |
| 429 459 |  | 
| 430 460 | 
             
                            response = @client_stub.make_http_request(
         | 
| 431 461 | 
             
                              verb,
         | 
| 432 | 
            -
                              uri: | 
| 433 | 
            -
                              body: | 
| 434 | 
            -
                              params: | 
| 462 | 
            +
                              uri: uri,
         | 
| 463 | 
            +
                              body: body || "",
         | 
| 464 | 
            +
                              params: query_string_params,
         | 
| 465 | 
            +
                              method_name: "update_workstation_config",
         | 
| 435 466 | 
             
                              options: options
         | 
| 436 467 | 
             
                            )
         | 
| 437 468 | 
             
                            operation = ::Gapic::Rest::TransportOperation.new response
         | 
| 438 469 | 
             
                            result = ::Google::Longrunning::Operation.decode_json response.body, ignore_unknown_fields: true
         | 
| 439 | 
            -
             | 
| 440 | 
            -
             | 
| 441 | 
            -
             | 
| 470 | 
            +
                            catch :response do
         | 
| 471 | 
            +
                              yield result, operation if block_given?
         | 
| 472 | 
            +
                              result
         | 
| 473 | 
            +
                            end
         | 
| 442 474 | 
             
                          end
         | 
| 443 475 |  | 
| 444 476 | 
             
                          ##
         | 
| @@ -467,16 +499,18 @@ module Google | |
| 467 499 |  | 
| 468 500 | 
             
                            response = @client_stub.make_http_request(
         | 
| 469 501 | 
             
                              verb,
         | 
| 470 | 
            -
                              uri: | 
| 471 | 
            -
                              body: | 
| 472 | 
            -
                              params: | 
| 502 | 
            +
                              uri: uri,
         | 
| 503 | 
            +
                              body: body || "",
         | 
| 504 | 
            +
                              params: query_string_params,
         | 
| 505 | 
            +
                              method_name: "delete_workstation_config",
         | 
| 473 506 | 
             
                              options: options
         | 
| 474 507 | 
             
                            )
         | 
| 475 508 | 
             
                            operation = ::Gapic::Rest::TransportOperation.new response
         | 
| 476 509 | 
             
                            result = ::Google::Longrunning::Operation.decode_json response.body, ignore_unknown_fields: true
         | 
| 477 | 
            -
             | 
| 478 | 
            -
             | 
| 479 | 
            -
             | 
| 510 | 
            +
                            catch :response do
         | 
| 511 | 
            +
                              yield result, operation if block_given?
         | 
| 512 | 
            +
                              result
         | 
| 513 | 
            +
                            end
         | 
| 480 514 | 
             
                          end
         | 
| 481 515 |  | 
| 482 516 | 
             
                          ##
         | 
| @@ -505,16 +539,18 @@ module Google | |
| 505 539 |  | 
| 506 540 | 
             
                            response = @client_stub.make_http_request(
         | 
| 507 541 | 
             
                              verb,
         | 
| 508 | 
            -
                              uri: | 
| 509 | 
            -
                              body: | 
| 510 | 
            -
                              params: | 
| 542 | 
            +
                              uri: uri,
         | 
| 543 | 
            +
                              body: body || "",
         | 
| 544 | 
            +
                              params: query_string_params,
         | 
| 545 | 
            +
                              method_name: "get_workstation",
         | 
| 511 546 | 
             
                              options: options
         | 
| 512 547 | 
             
                            )
         | 
| 513 548 | 
             
                            operation = ::Gapic::Rest::TransportOperation.new response
         | 
| 514 549 | 
             
                            result = ::Google::Cloud::Workstations::V1::Workstation.decode_json response.body, ignore_unknown_fields: true
         | 
| 515 | 
            -
             | 
| 516 | 
            -
             | 
| 517 | 
            -
             | 
| 550 | 
            +
                            catch :response do
         | 
| 551 | 
            +
                              yield result, operation if block_given?
         | 
| 552 | 
            +
                              result
         | 
| 553 | 
            +
                            end
         | 
| 518 554 | 
             
                          end
         | 
| 519 555 |  | 
| 520 556 | 
             
                          ##
         | 
| @@ -543,16 +579,18 @@ module Google | |
| 543 579 |  | 
| 544 580 | 
             
                            response = @client_stub.make_http_request(
         | 
| 545 581 | 
             
                              verb,
         | 
| 546 | 
            -
                              uri: | 
| 547 | 
            -
                              body: | 
| 548 | 
            -
                              params: | 
| 582 | 
            +
                              uri: uri,
         | 
| 583 | 
            +
                              body: body || "",
         | 
| 584 | 
            +
                              params: query_string_params,
         | 
| 585 | 
            +
                              method_name: "list_workstations",
         | 
| 549 586 | 
             
                              options: options
         | 
| 550 587 | 
             
                            )
         | 
| 551 588 | 
             
                            operation = ::Gapic::Rest::TransportOperation.new response
         | 
| 552 589 | 
             
                            result = ::Google::Cloud::Workstations::V1::ListWorkstationsResponse.decode_json response.body, ignore_unknown_fields: true
         | 
| 553 | 
            -
             | 
| 554 | 
            -
             | 
| 555 | 
            -
             | 
| 590 | 
            +
                            catch :response do
         | 
| 591 | 
            +
                              yield result, operation if block_given?
         | 
| 592 | 
            +
                              result
         | 
| 593 | 
            +
                            end
         | 
| 556 594 | 
             
                          end
         | 
| 557 595 |  | 
| 558 596 | 
             
                          ##
         | 
| @@ -581,16 +619,18 @@ module Google | |
| 581 619 |  | 
| 582 620 | 
             
                            response = @client_stub.make_http_request(
         | 
| 583 621 | 
             
                              verb,
         | 
| 584 | 
            -
                              uri: | 
| 585 | 
            -
                              body: | 
| 586 | 
            -
                              params: | 
| 622 | 
            +
                              uri: uri,
         | 
| 623 | 
            +
                              body: body || "",
         | 
| 624 | 
            +
                              params: query_string_params,
         | 
| 625 | 
            +
                              method_name: "list_usable_workstations",
         | 
| 587 626 | 
             
                              options: options
         | 
| 588 627 | 
             
                            )
         | 
| 589 628 | 
             
                            operation = ::Gapic::Rest::TransportOperation.new response
         | 
| 590 629 | 
             
                            result = ::Google::Cloud::Workstations::V1::ListUsableWorkstationsResponse.decode_json response.body, ignore_unknown_fields: true
         | 
| 591 | 
            -
             | 
| 592 | 
            -
             | 
| 593 | 
            -
             | 
| 630 | 
            +
                            catch :response do
         | 
| 631 | 
            +
                              yield result, operation if block_given?
         | 
| 632 | 
            +
                              result
         | 
| 633 | 
            +
                            end
         | 
| 594 634 | 
             
                          end
         | 
| 595 635 |  | 
| 596 636 | 
             
                          ##
         | 
| @@ -619,16 +659,18 @@ module Google | |
| 619 659 |  | 
| 620 660 | 
             
                            response = @client_stub.make_http_request(
         | 
| 621 661 | 
             
                              verb,
         | 
| 622 | 
            -
                              uri: | 
| 623 | 
            -
                              body: | 
| 624 | 
            -
                              params: | 
| 662 | 
            +
                              uri: uri,
         | 
| 663 | 
            +
                              body: body || "",
         | 
| 664 | 
            +
                              params: query_string_params,
         | 
| 665 | 
            +
                              method_name: "create_workstation",
         | 
| 625 666 | 
             
                              options: options
         | 
| 626 667 | 
             
                            )
         | 
| 627 668 | 
             
                            operation = ::Gapic::Rest::TransportOperation.new response
         | 
| 628 669 | 
             
                            result = ::Google::Longrunning::Operation.decode_json response.body, ignore_unknown_fields: true
         | 
| 629 | 
            -
             | 
| 630 | 
            -
             | 
| 631 | 
            -
             | 
| 670 | 
            +
                            catch :response do
         | 
| 671 | 
            +
                              yield result, operation if block_given?
         | 
| 672 | 
            +
                              result
         | 
| 673 | 
            +
                            end
         | 
| 632 674 | 
             
                          end
         | 
| 633 675 |  | 
| 634 676 | 
             
                          ##
         | 
| @@ -657,16 +699,18 @@ module Google | |
| 657 699 |  | 
| 658 700 | 
             
                            response = @client_stub.make_http_request(
         | 
| 659 701 | 
             
                              verb,
         | 
| 660 | 
            -
                              uri: | 
| 661 | 
            -
                              body: | 
| 662 | 
            -
                              params: | 
| 702 | 
            +
                              uri: uri,
         | 
| 703 | 
            +
                              body: body || "",
         | 
| 704 | 
            +
                              params: query_string_params,
         | 
| 705 | 
            +
                              method_name: "update_workstation",
         | 
| 663 706 | 
             
                              options: options
         | 
| 664 707 | 
             
                            )
         | 
| 665 708 | 
             
                            operation = ::Gapic::Rest::TransportOperation.new response
         | 
| 666 709 | 
             
                            result = ::Google::Longrunning::Operation.decode_json response.body, ignore_unknown_fields: true
         | 
| 667 | 
            -
             | 
| 668 | 
            -
             | 
| 669 | 
            -
             | 
| 710 | 
            +
                            catch :response do
         | 
| 711 | 
            +
                              yield result, operation if block_given?
         | 
| 712 | 
            +
                              result
         | 
| 713 | 
            +
                            end
         | 
| 670 714 | 
             
                          end
         | 
| 671 715 |  | 
| 672 716 | 
             
                          ##
         | 
| @@ -695,16 +739,18 @@ module Google | |
| 695 739 |  | 
| 696 740 | 
             
                            response = @client_stub.make_http_request(
         | 
| 697 741 | 
             
                              verb,
         | 
| 698 | 
            -
                              uri: | 
| 699 | 
            -
                              body: | 
| 700 | 
            -
                              params: | 
| 742 | 
            +
                              uri: uri,
         | 
| 743 | 
            +
                              body: body || "",
         | 
| 744 | 
            +
                              params: query_string_params,
         | 
| 745 | 
            +
                              method_name: "delete_workstation",
         | 
| 701 746 | 
             
                              options: options
         | 
| 702 747 | 
             
                            )
         | 
| 703 748 | 
             
                            operation = ::Gapic::Rest::TransportOperation.new response
         | 
| 704 749 | 
             
                            result = ::Google::Longrunning::Operation.decode_json response.body, ignore_unknown_fields: true
         | 
| 705 | 
            -
             | 
| 706 | 
            -
             | 
| 707 | 
            -
             | 
| 750 | 
            +
                            catch :response do
         | 
| 751 | 
            +
                              yield result, operation if block_given?
         | 
| 752 | 
            +
                              result
         | 
| 753 | 
            +
                            end
         | 
| 708 754 | 
             
                          end
         | 
| 709 755 |  | 
| 710 756 | 
             
                          ##
         | 
| @@ -733,16 +779,18 @@ module Google | |
| 733 779 |  | 
| 734 780 | 
             
                            response = @client_stub.make_http_request(
         | 
| 735 781 | 
             
                              verb,
         | 
| 736 | 
            -
                              uri: | 
| 737 | 
            -
                              body: | 
| 738 | 
            -
                              params: | 
| 782 | 
            +
                              uri: uri,
         | 
| 783 | 
            +
                              body: body || "",
         | 
| 784 | 
            +
                              params: query_string_params,
         | 
| 785 | 
            +
                              method_name: "start_workstation",
         | 
| 739 786 | 
             
                              options: options
         | 
| 740 787 | 
             
                            )
         | 
| 741 788 | 
             
                            operation = ::Gapic::Rest::TransportOperation.new response
         | 
| 742 789 | 
             
                            result = ::Google::Longrunning::Operation.decode_json response.body, ignore_unknown_fields: true
         | 
| 743 | 
            -
             | 
| 744 | 
            -
             | 
| 745 | 
            -
             | 
| 790 | 
            +
                            catch :response do
         | 
| 791 | 
            +
                              yield result, operation if block_given?
         | 
| 792 | 
            +
                              result
         | 
| 793 | 
            +
                            end
         | 
| 746 794 | 
             
                          end
         | 
| 747 795 |  | 
| 748 796 | 
             
                          ##
         | 
| @@ -771,16 +819,18 @@ module Google | |
| 771 819 |  | 
| 772 820 | 
             
                            response = @client_stub.make_http_request(
         | 
| 773 821 | 
             
                              verb,
         | 
| 774 | 
            -
                              uri: | 
| 775 | 
            -
                              body: | 
| 776 | 
            -
                              params: | 
| 822 | 
            +
                              uri: uri,
         | 
| 823 | 
            +
                              body: body || "",
         | 
| 824 | 
            +
                              params: query_string_params,
         | 
| 825 | 
            +
                              method_name: "stop_workstation",
         | 
| 777 826 | 
             
                              options: options
         | 
| 778 827 | 
             
                            )
         | 
| 779 828 | 
             
                            operation = ::Gapic::Rest::TransportOperation.new response
         | 
| 780 829 | 
             
                            result = ::Google::Longrunning::Operation.decode_json response.body, ignore_unknown_fields: true
         | 
| 781 | 
            -
             | 
| 782 | 
            -
             | 
| 783 | 
            -
             | 
| 830 | 
            +
                            catch :response do
         | 
| 831 | 
            +
                              yield result, operation if block_given?
         | 
| 832 | 
            +
                              result
         | 
| 833 | 
            +
                            end
         | 
| 784 834 | 
             
                          end
         | 
| 785 835 |  | 
| 786 836 | 
             
                          ##
         | 
| @@ -809,16 +859,18 @@ module Google | |
| 809 859 |  | 
| 810 860 | 
             
                            response = @client_stub.make_http_request(
         | 
| 811 861 | 
             
                              verb,
         | 
| 812 | 
            -
                              uri: | 
| 813 | 
            -
                              body: | 
| 814 | 
            -
                              params: | 
| 862 | 
            +
                              uri: uri,
         | 
| 863 | 
            +
                              body: body || "",
         | 
| 864 | 
            +
                              params: query_string_params,
         | 
| 865 | 
            +
                              method_name: "generate_access_token",
         | 
| 815 866 | 
             
                              options: options
         | 
| 816 867 | 
             
                            )
         | 
| 817 868 | 
             
                            operation = ::Gapic::Rest::TransportOperation.new response
         | 
| 818 869 | 
             
                            result = ::Google::Cloud::Workstations::V1::GenerateAccessTokenResponse.decode_json response.body, ignore_unknown_fields: true
         | 
| 819 | 
            -
             | 
| 820 | 
            -
             | 
| 821 | 
            -
             | 
| 870 | 
            +
                            catch :response do
         | 
| 871 | 
            +
                              yield result, operation if block_given?
         | 
| 872 | 
            +
                              result
         | 
| 873 | 
            +
                            end
         | 
| 822 874 | 
             
                          end
         | 
| 823 875 |  | 
| 824 876 | 
             
                          ##
         |