google-api-client 0.52.0 → 0.53.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4cf9aed2e7ad1e0d517672ac8c80aef43afca0178bdb548f01f4ccf6dc438700
-  data.tar.gz: c884e7459a1fe60d844ce835c5996c0f630eb72bee4eb7090202535d255d16cf
+  metadata.gz: 7731c684db7d4a0731ccc0bb8c3e716505536f2d3ce140bf9976e8da90ba27f2
+  data.tar.gz: 2a2711d7c31ed7049b9a9fa92ef8f62c4bb93c1c63151bbeff7d27ac3dcc7944
 SHA512:
-  metadata.gz: 689d97934acb44994f2ec76b69e6b5d8ac139fbeba821a62ad3c13474686f08799bdf4d86872efbf989e054ad997f34d512716c3de2e54351f8fb145035eb884
-  data.tar.gz: ade510d661a01da090c2e0c8a703bbbcbb3caaf0af94642199c95c1b79443566eba40e7ce6d0146c19d5766471b42c1a1221217ddca076b5b8f297a865e0f528
+  metadata.gz: a9c3603aa094ca3be4f126d657f79ca5144cb1e7e42d8dc3da82fc38feb0c76f4fa07fda94e69b5170c7052ca5fa891a9445d83b532159eea1b2206cc786d033
+  data.tar.gz: 165d53b6017f25365cddb12397d6251619cd22e62834c1ed517d3ed00c1f6cb80060273e18bc9c9f26c69a517b4a3453932c95d4c46f8f7bff00cca93fae6524

data/.yardopts

@@ -9,18 +9,4 @@ lib/**/*.rb
 generated/**/*.rb
 -
 OVERVIEW.md
-docs/getting-started.md
-docs/installation.md
-docs/auth.md
-docs/api-keys.md
-docs/oauth.md
-docs/oauth-web.md
-docs/oauth-installed.md
-docs/oauth-server.md
-docs/client-secrets.md
-docs/logging.md
-docs/media-upload.md
-docs/pagination.md
-docs/performance.md
-MIGRATING.md
 LICENSE

data/CHANGELOG.md

@@ -1,5 +1,11 @@
 # Release History
 
+## [0.53.0](https://www.github.com/googleapis/google-api-ruby-client/compare/google-api-client/v0.52.0...v0.53.0) (2021-01-18)
+
+** google-api-client is now deprecated **
+
+This gem includes API client classes for >300 Google APIs (updated as of December 2020). At the end of 2020, it was split into separate gems for each API. Instead of google-api-client, please install the separate gem corresponding to the specific service to be used. For example, to use the Google Drive V3 client, install `google-apis-drive_v3`. For more information, please see the [FAQ](https://github.com/googleapis/google-api-ruby-client/blob/master/google-api-client/OVERVIEW.md). The google-api-client gem will no longer be updated from this point.
+
 ## [0.52.0](https://www.github.com/googleapis/google-api-ruby-client/compare/v0.51.0...v0.52.0) (2020-12-14)
 
 

data/OVERVIEW.md

@@ -1,36 +1,45 @@
-# Google API Client Library for Ruby Docs
+# Monolithic Client for Google APIs (DEPRECATED)
 
-The Google API Client Library for Ruby is designed for Ruby
-client-application developers. It offers simple, flexible
-access to many Google APIs.
+This library includes REST clients for all public [Discovery]((https://developers.google.com/discovery))-based Google APIs as of December 2020.
 
-## Features
+This library is **deprecated** and will likely not be updated further. Instead, please install the gem corresponding to the specific service you want to use. For example, to use the Google Drive V3 client, install the `google-apis-drive_v3` gem. To use the code generator, install the `google-apis-generator` gem.
 
-- Call Google APIs simply
-- Handle Auth with fewer lines of code
-- Use standard tooling for installation
+## FAQ
 
-## Documentation
+### Why is this gem deprecated?
 
-Learn how to use the Google API Client Library for Ruby with these guides:
+The `google-api-client` gem is a 75 megabyte installation including client classes for more than 300 services. Although the library is designed so that only the classes being used are loaded into memory, it still takes a nontrivial amount of space on disk (and in deployments), and can take a while to install. Additionally, the class reference documentation is so large that rubydoc.info often fails to build it.
 
-### Usage Guides
+Because few applications would use more than one or two of the included clients at a time, it was decided to release a separate gem for each client.
 
-- {file:docs/getting-started.md Getting Started}
-- {file:docs/installation.md Installation}
-- {file:docs/auth.md Auth}
-  - {file:docs/api-keys.md API Keys}
-  - {file:docs/oauth.md OAuth 2.0}
-  - {file:docs/oauth-web.md OAuth 2.0 for Web Server Applications}
-  - {file:docs/oauth-installed.md OAuth 2.0 for Installed Applications}
-  - {file:docs/oauth-server.md OAuth 2.0 for Server to Server Applications}
-  - {file:docs/client-secrets.md Client Secrets}
-- How to...
-  - {file:docs/logging.md Use Logging}
-  - {file:docs/media-upload.md Upload Media}
-  - {file:docs/pagination.md Use Pagination}
-  - {file:docs/performance.md Improve Performance}
+### How do I find the service-specific gem to use instead?
 
-### Reference Documentation
+The service-specific gems are all named according to the pattern: `google-apis-<servicename>_<serviceversion>`. For example, `google-apis-drive_v3` or `google-apis-billingbudgets_v1beta1`. If you already have code that uses a client class, it's very straightforward: Look for the `require 'google/apis/servicenameandversion'` statement in your code, and replace slashes with dashes in the path, and you'll have the gem name.
 
-- Reference documentation for [google-api-client](https://googleapis.dev/ruby/google-api-client/latest/index.html).
+### Are the service-specific gems drop-in compatible?
+
+Yes, the client code has been copied as-is into the separate clients. The common code has been extracted as-is into a separate gem `google-apis-core` which is a dependency. So all existing usage should remain the same. You can simply replace `google-api-client` with the appropriate individual client libraries in your Gemfile, and your existing code should work as before (just with a much smaller dependency).
+
+### I still need to use the code generator. What should I do?
+
+The code generator has been extracted into the `google-apis-generator` gem, and you should use that gem from now on to build custom clients for private, partner, and early-access APIs. Note that the generator has been modified to build an entire client gem as opposed to just client classes (although you can simply copy the relevant Ruby files into your own code if you do not want a separate gem.)
+
+### This library is a dependency of a library I use. What should I do?
+
+Some third-party libraries take a dependency on `google-api-client` to communicate with Google APIs. These libraries should be updated to depend instead on the individual service gems they need. Please contact the library maintainer.
+
+### A documentation page or tutorial is directing me to install this library. Should I?
+
+You should instead install the individual gems corresponding to the specific service and service version. (For example, to use the Google Drive V3 client, install the `google-apis-drive_v3` gem.)
+
+Please contact the owners of the documentation or tutorial that is referencing the old `google-api-client` gem and ask them to update their content. For documentation on the developers.google.com or cloud.google.com sites, look for a "Send Feedback" button toward the upper right of the page.
+
+### Can I still use google-api-client anyway?
+
+Yes, the gem will continue to be available, _but_ it will likely not be updated any further. So it will not reflect any future updates to the API surface, and if you report issues, we will likely direct you to use the appropriate service-specific gem instead.
+
+### Where is the documentation?
+
+Reference documentation is now available separately for each service-specific gem. Reference documentation for common classes (such as `RequestOptions`) is connected to the common gem `google-apis-core`.
+
+Basic usage documentaiton is provided with each service-specific gem. Some more detailed documentation including how to implement OAuth flows, is available in the [docs directory of the repo](https://github.com/googleapis/google-api-ruby-client/tree/master/docs).

data/generated/google/apis/accesscontextmanager_v1.rb

@@ -25,7 +25,7 @@ module Google
     # @see https://cloud.google.com/access-context-manager/docs/reference/rest/
     module AccesscontextmanagerV1
       VERSION = 'V1'
-      REVISION = '20200927'
+      REVISION = '20201210'
 
       # View and manage your data across Google Cloud Platform services
       AUTH_CLOUD_PLATFORM = 'https://www.googleapis.com/auth/cloud-platform'

data/generated/google/apis/accesscontextmanager_v1/classes.rb

@@ -118,6 +118,36 @@ module Google
         end
       end
       
+      # Identification for an API Operation.
+      class ApiOperation
+        include Google::Apis::Core::Hashable
+      
+        # API methods or permissions to allow. Method or permission must belong to the
+        # service specified by `service_name` field. A single MethodSelector entry with `
+        # *` specified for the `method` field will allow all methods AND permissions for
+        # the service specified in `service_name`.
+        # Corresponds to the JSON property `methodSelectors`
+        # @return [Array<Google::Apis::AccesscontextmanagerV1::MethodSelector>]
+        attr_accessor :method_selectors
+      
+        # The name of the API whose methods or permissions the IngressPolicy or
+        # EgressPolicy want to allow. A single ApiOperation with `service_name` field
+        # set to `*` will allow all methods AND permissions for all services.
+        # Corresponds to the JSON property `serviceName`
+        # @return [String]
+        attr_accessor :service_name
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @method_selectors = args[:method_selectors] if args.key?(:method_selectors)
+          @service_name = args[:service_name] if args.key?(:service_name)
+        end
+      end
+      
       # `BasicLevel` is an `AccessLevel` using a set of recommended features.
       class BasicLevel
         include Google::Apis::Core::Hashable
@@ -375,6 +405,116 @@ module Google
         end
       end
       
+      # Defines the conditions under which an EgressPolicy matches a request.
+      # Conditions based on information about the source of the request. Note that if
+      # the destination of the request is protected by a ServicePerimeter, then that
+      # ServicePerimeter must have an IngressPolicy which allows access in order for
+      # this request to succeed.
+      class EgressFrom
+        include Google::Apis::Core::Hashable
+      
+        # A list of identities that are allowed access through this [EgressPolicy].
+        # Should be in the format of email address. The email address should represent
+        # individual user or service account only.
+        # Corresponds to the JSON property `identities`
+        # @return [Array<String>]
+        attr_accessor :identities
+      
+        # Specifies the type of identities that are allowed access to outside the
+        # perimeter. If left unspecified, then members of `identities` field will be
+        # allowed access.
+        # Corresponds to the JSON property `identityType`
+        # @return [String]
+        attr_accessor :identity_type
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @identities = args[:identities] if args.key?(:identities)
+          @identity_type = args[:identity_type] if args.key?(:identity_type)
+        end
+      end
+      
+      # Policy for egress from perimeter. EgressPolicies match requests based on `
+      # egress_from` and `egress_to` stanzas. For an EgressPolicy to match, both `
+      # egress_from` and `egress_to` stanzas must be matched. If an EgressPolicy
+      # matches a request, the request is allowed to span the ServicePerimeter
+      # boundary. For example, an EgressPolicy can be used to allow VMs on networks
+      # within the ServicePerimeter to access a defined set of projects outside the
+      # perimeter in certain contexts (e.g. to read data from a Cloud Storage bucket
+      # or query against a BigQuery dataset). EgressPolicies are concerned with the *
+      # resources* that a request relates as well as the API services and API actions
+      # being used. They do not related to the direction of data movement. More
+      # detailed documentation for this concept can be found in the descriptions of
+      # EgressFrom and EgressTo.
+      class EgressPolicy
+        include Google::Apis::Core::Hashable
+      
+        # Defines the conditions under which an EgressPolicy matches a request.
+        # Conditions based on information about the source of the request. Note that if
+        # the destination of the request is protected by a ServicePerimeter, then that
+        # ServicePerimeter must have an IngressPolicy which allows access in order for
+        # this request to succeed.
+        # Corresponds to the JSON property `egressFrom`
+        # @return [Google::Apis::AccesscontextmanagerV1::EgressFrom]
+        attr_accessor :egress_from
+      
+        # Defines the conditions under which an EgressPolicy matches a request.
+        # Conditions are based on information about the ApiOperation intended to be
+        # performed on the `resources` specified. Note that if the destination of the
+        # request is protected by a ServicePerimeter, then that ServicePerimeter must
+        # have an IngressPolicy which allows access in order for this request to succeed.
+        # Corresponds to the JSON property `egressTo`
+        # @return [Google::Apis::AccesscontextmanagerV1::EgressTo]
+        attr_accessor :egress_to
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @egress_from = args[:egress_from] if args.key?(:egress_from)
+          @egress_to = args[:egress_to] if args.key?(:egress_to)
+        end
+      end
+      
+      # Defines the conditions under which an EgressPolicy matches a request.
+      # Conditions are based on information about the ApiOperation intended to be
+      # performed on the `resources` specified. Note that if the destination of the
+      # request is protected by a ServicePerimeter, then that ServicePerimeter must
+      # have an IngressPolicy which allows access in order for this request to succeed.
+      class EgressTo
+        include Google::Apis::Core::Hashable
+      
+        # A list of ApiOperations that this egress rule applies to. A request matches if
+        # it contains an operation/service in this list.
+        # Corresponds to the JSON property `operations`
+        # @return [Array<Google::Apis::AccesscontextmanagerV1::ApiOperation>]
+        attr_accessor :operations
+      
+        # A list of resources, currently only projects in the form `projects/`, that
+        # match this to stanza. A request matches if it contains a resource in this list.
+        # If `*` is specified for resources, then this EgressTo rule will authorize
+        # access to all resources outside the perimeter.
+        # Corresponds to the JSON property `resources`
+        # @return [Array<String>]
+        attr_accessor :resources
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @operations = args[:operations] if args.key?(:operations)
+          @resources = args[:resources] if args.key?(:resources)
+        end
+      end
+      
       # A generic empty message that you can re-use to avoid defining duplicated empty
       # messages in your APIs. A typical example is to use it as the request or the
       # response type of an API method. For instance: service Foo ` rpc Bar(google.
@@ -489,6 +629,148 @@ module Google
         end
       end
       
+      # Defines the conditions under which an IngressPolicy matches a request.
+      # Conditions are based on information about the source of the request.
+      class IngressFrom
+        include Google::Apis::Core::Hashable
+      
+        # A list of identities that are allowed access through this ingress policy.
+        # Should be in the format of email address. The email address should represent
+        # individual user or service account only.
+        # Corresponds to the JSON property `identities`
+        # @return [Array<String>]
+        attr_accessor :identities
+      
+        # Specifies the type of identities that are allowed access from outside the
+        # perimeter. If left unspecified, then members of `identities` field will be
+        # allowed access.
+        # Corresponds to the JSON property `identityType`
+        # @return [String]
+        attr_accessor :identity_type
+      
+        # Sources that this IngressPolicy authorizes access from.
+        # Corresponds to the JSON property `sources`
+        # @return [Array<Google::Apis::AccesscontextmanagerV1::IngressSource>]
+        attr_accessor :sources
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @identities = args[:identities] if args.key?(:identities)
+          @identity_type = args[:identity_type] if args.key?(:identity_type)
+          @sources = args[:sources] if args.key?(:sources)
+        end
+      end
+      
+      # Policy for ingress into ServicePerimeter. IngressPolicies match requests based
+      # on `ingress_from` and `ingress_to` stanzas. For an ingress policy to match,
+      # both the `ingress_from` and `ingress_to` stanzas must be matched. If an
+      # IngressPolicy matches a request, the request is allowed through the perimeter
+      # boundary from outside the perimeter. For example, access from the internet can
+      # be allowed either based on an AccessLevel or, for traffic hosted on Google
+      # Cloud, the project of the source network. For access from private networks,
+      # using the project of the hosting network is required. Individual ingress
+      # policies can be limited by restricting which services and/or actions they
+      # match using the `ingress_to` field.
+      class IngressPolicy
+        include Google::Apis::Core::Hashable
+      
+        # Defines the conditions under which an IngressPolicy matches a request.
+        # Conditions are based on information about the source of the request.
+        # Corresponds to the JSON property `ingressFrom`
+        # @return [Google::Apis::AccesscontextmanagerV1::IngressFrom]
+        attr_accessor :ingress_from
+      
+        # Defines the conditions under which an IngressPolicy matches a request.
+        # Conditions are based on information about the ApiOperation intended to be
+        # performed on the destination of the request.
+        # Corresponds to the JSON property `ingressTo`
+        # @return [Google::Apis::AccesscontextmanagerV1::IngressTo]
+        attr_accessor :ingress_to
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @ingress_from = args[:ingress_from] if args.key?(:ingress_from)
+          @ingress_to = args[:ingress_to] if args.key?(:ingress_to)
+        end
+      end
+      
+      # The source that IngressPolicy authorizes access from.
+      class IngressSource
+        include Google::Apis::Core::Hashable
+      
+        # An AccessLevel resource name that allow resources within the ServicePerimeters
+        # to be accessed from the internet. AccessLevels listed must be in the same
+        # policy as this ServicePerimeter. Referencing a nonexistent AccessLevel will
+        # cause an error. If no AccessLevel names are listed, resources within the
+        # perimeter can only be accessed via Google Cloud calls with request origins
+        # within the perimeter. Example: `accessPolicies/MY_POLICY/accessLevels/MY_LEVEL`
+        # . If `*` is specified, then all IngressSources will be allowed.
+        # Corresponds to the JSON property `accessLevel`
+        # @return [String]
+        attr_accessor :access_level
+      
+        # A Google Cloud resource that is allowed to ingress the perimeter. Requests
+        # from these resources will be allowed to access perimeter data. Currently only
+        # projects are allowed. Format: `projects/`project_number`` The project may be
+        # in any Google Cloud organization, not just the organization that the perimeter
+        # is defined in. `*` is not allowed, the case of allowing all Google Cloud
+        # resources only is not supported.
+        # Corresponds to the JSON property `resource`
+        # @return [String]
+        attr_accessor :resource
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @access_level = args[:access_level] if args.key?(:access_level)
+          @resource = args[:resource] if args.key?(:resource)
+        end
+      end
+      
+      # Defines the conditions under which an IngressPolicy matches a request.
+      # Conditions are based on information about the ApiOperation intended to be
+      # performed on the destination of the request.
+      class IngressTo
+        include Google::Apis::Core::Hashable
+      
+        # A list of ApiOperations the sources specified in corresponding IngressFrom are
+        # allowed to perform in this ServicePerimeter.
+        # Corresponds to the JSON property `operations`
+        # @return [Array<Google::Apis::AccesscontextmanagerV1::ApiOperation>]
+        attr_accessor :operations
+      
+        # A list of resources, currently only projects in the form `projects/`,
+        # protected by this ServicePerimeter that are allowed to be accessed by sources
+        # defined in the corresponding IngressFrom. A request matches if it contains a
+        # resource in this list. If `*` is specified for resources, then this IngressTo
+        # rule will authorize access to all resources inside the perimeter, provided
+        # that the request also matches the `operations` field.
+        # Corresponds to the JSON property `resources`
+        # @return [Array<String>]
+        attr_accessor :resources
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @operations = args[:operations] if args.key?(:operations)
+          @resources = args[:resources] if args.key?(:resources)
+        end
+      end
+      
       # A response to `ListAccessLevelsRequest`.
       class ListAccessLevelsResponse
         include Google::Apis::Core::Hashable
@@ -617,6 +899,34 @@ module Google
         end
       end
       
+      # An allowed method or permission of a service specified in ApiOperation.
+      class MethodSelector
+        include Google::Apis::Core::Hashable
+      
+        # Value for `method` should be a valid method name for the corresponding `
+        # service_name` in ApiOperation. If `*` used as value for `method`, then ALL
+        # methods and permissions are allowed.
+        # Corresponds to the JSON property `method`
+        # @return [String]
+        attr_accessor :method_prop
+      
+        # Value for `permission` should be a valid Cloud IAM permission for the
+        # corresponding `service_name` in ApiOperation.
+        # Corresponds to the JSON property `permission`
+        # @return [String]
+        attr_accessor :permission
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @method_prop = args[:method_prop] if args.key?(:method_prop)
+          @permission = args[:permission] if args.key?(:permission)
+        end
+      end
+      
       # This resource represents a long-running operation that is the result of a
       # network API call.
       class Operation
@@ -916,6 +1226,20 @@ module Google
         # @return [Array<String>]
         attr_accessor :access_levels
       
+        # List of EgressPolicies to apply to the perimeter. A perimeter may have
+        # multiple EgressPolicies, each of which is evaluated separately. Access is
+        # granted if any EgressPolicy grants it. Must be empty for a perimeter bridge.
+        # Corresponds to the JSON property `egressPolicies`
+        # @return [Array<Google::Apis::AccesscontextmanagerV1::EgressPolicy>]
+        attr_accessor :egress_policies
+      
+        # List of IngressPolicies to apply to the perimeter. A perimeter may have
+        # multiple IngressPolicies, each of which is evaluated separately. Access is
+        # granted if any Ingress Policy grants it. Must be empty for a perimeter bridge.
+        # Corresponds to the JSON property `ingressPolicies`
+        # @return [Array<Google::Apis::AccesscontextmanagerV1::IngressPolicy>]
+        attr_accessor :ingress_policies
+      
         # A list of Google Cloud resources that are inside of the service perimeter.
         # Currently only projects are allowed. Format: `projects/`project_number``
         # Corresponds to the JSON property `resources`
@@ -941,6 +1265,8 @@ module Google
         # Update properties of this object
         def update!(**args)
           @access_levels = args[:access_levels] if args.key?(:access_levels)
+          @egress_policies = args[:egress_policies] if args.key?(:egress_policies)
+          @ingress_policies = args[:ingress_policies] if args.key?(:ingress_policies)
           @resources = args[:resources] if args.key?(:resources)
           @restricted_services = args[:restricted_services] if args.key?(:restricted_services)
           @vpc_accessible_services = args[:vpc_accessible_services] if args.key?(:vpc_accessible_services)