google-cloud-bigtable 1.3.0

data/lib/google/cloud/bigtable/table/cluster_state.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+# Copyright 2018 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+module Google
+  module Cloud
+    module Bigtable
+      class Table
+        ##
+        # Table::ClusterState is the state of a table's data in a particular cluster.
+        #
+        # @attr [String] cluster_name The name of the cluster.
+        class ClusterState
+          attr_reader :cluster_name
+
+          # @private
+          # Creates a new Table::ClusterState
+          #
+          def initialize grpc, cluster_name
+            @grpc = grpc
+            @cluster_name = cluster_name
+          end
+
+          ##
+          # The state of replication for the table in this cluster.
+          #   Valid values are:
+          #   * `:INITIALIZING` - The cluster was recently created.
+          #   * `:PLANNED_MAINTENANCE` - The table is temporarily unable to serve.
+          #   * `:UNPLANNED_MAINTENANCE` - The table is temporarily unable to serve.
+          #   * `:READY` - The table can serve.
+          #   * `:READY_OPTIMIZING` - The table is fully created and ready for use
+          #     after a restore, and is being optimized for performance. When
+          #     optimizations are complete, the table will transition to `READY`
+          #     state.
+          #
+          # @return [Symbol] The state of replication.
+          #
+          def replication_state
+            @grpc.replication_state
+          end
+
+          ##
+          # The cluster was recently created, and the table must finish copying
+          # over pre-existing data from other clusters before it can begin
+          # receiving live replication updates and serving.
+          #
+          # @return [Boolean] `true` if the table in this cluster is initializing.
+          #
+          def initializing?
+            replication_state == :INITIALIZING
+          end
+
+          ##
+          # The table is temporarily unable to serve
+          # requests from this cluster due to planned internal maintenance.
+          #
+          # @return [Boolean] `true` if the table in this cluster is in planned
+          #   maintenance.
+          #
+          def planned_maintenance?
+            replication_state == :PLANNED_MAINTENANCE
+          end
+
+          ##
+          # The table is temporarily unable to serve requests from this
+          # cluster due to unplanned or emergency maintenance.
+          #
+          # @return [Boolean] `true` if the table in this cluster is in unplanned
+          #   maintenance.
+          #
+          def unplanned_maintenance?
+            replication_state == :UNPLANNED_MAINTENANCE
+          end
+
+          ##
+          # The table can serve requests from this cluster.
+          # Depending on replication delay, reads may not immediately
+          # reflect the state of the table in other clusters.
+          #
+          # @return [Boolean] `true` if the table in this cluster is ready.
+          #
+          def ready?
+            replication_state == :READY
+          end
+
+          ##
+          # The table is fully created and ready for use after a
+          # restore, and is being optimized for performance. When
+          # optimizations are complete, the table will transition to `READY`
+          # state.
+          #
+          # @return [Boolean] `true` if the table in this cluster is being
+          #   optimized.
+          #
+          def ready_optimizing?
+            replication_state == :READY_OPTIMIZING
+          end
+
+          # @private
+          # New Table::ClusterState from a Google::Bigtable::Admin::V2::Table::ClusterState object.
+          # @param grpc [Google::Bigtable::Admin::V2::Table::ClusterState]
+          # @param cluster_name [String]
+          # @return [Google::Cloud::Bigtable::Table::ClusterState]
+          #
+          def self.from_grpc grpc, cluster_name
+            new grpc, cluster_name
+          end
+        end
+      end
+    end
+  end
+end

data/lib/google/cloud/bigtable/table/list.rb

@@ -0,0 +1,154 @@
+# frozen_string_literal: true
+
+# Copyright 2018 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+module Google
+  module Cloud
+    module Bigtable
+      class Table
+        ##
+        # Table::List is a special-case array with additional
+        # values.
+        #
+        class List < DelegateClass(::Array)
+          # @private
+          # The gRPC Service object.
+          attr_accessor :service
+
+          # @private
+          # The gRPC page enumerable object.
+          attr_accessor :grpc
+
+          # @private
+          # Creates a new Table::List with an array of table instances.
+          def initialize arr = []
+            super arr
+          end
+
+          ##
+          # Whether there is a next page of tables.
+          #
+          # @return [Boolean]
+          #
+          # @example
+          #   require "google/cloud/bigtable"
+          #
+          #   bigtable = Google::Cloud::Bigtable.new
+          #
+          #   tables = bigtable.tables("my-instance")
+          #   if tables.next?
+          #     next_tables = tables.next
+          #   end
+          #
+          def next?
+            grpc.next_page?
+          end
+
+          ##
+          # Retrieves the next page of tables.
+          #
+          # @return [Table::List] The list of table instances.
+          #
+          # @example
+          #   require "google/cloud/bigtable"
+          #
+          #   bigtable = Google::Cloud::Bigtable.new
+          #
+          #   tables = bigtable.tables("my-instance")
+          #   if tables.next?
+          #     next_tables = tables.next
+          #   end
+          #
+          def next
+            ensure_grpc!
+
+            return nil unless next?
+            grpc.next_page
+            self.class.from_grpc grpc, service
+          end
+
+          ##
+          # Retrieves remaining results by repeatedly invoking {#next} until
+          # {#next?} returns `false`. Calls the given block once for each
+          # result, which is passed as the argument to the block.
+          #
+          # An enumerator is returned if no block is given.
+          #
+          # This method will make repeated API calls until all remaining results
+          # are retrieved (unlike `#each`, for example, which merely iterates
+          # over the results returned by a single API call). Use with caution.
+          #
+          # @yield [table] The block for accessing each table instance.
+          # @yieldparam [Table] table The table instance object.
+          #
+          # @return [Enumerator,nil] An enumerator is returned if no block is given, otherwise `nil`.
+          #
+          # @example Iterating each table by passing a block:
+          #   require "google/cloud/bigtable"
+          #
+          #   bigtable = Google::Cloud::Bigtable.new
+          #
+          #   bigtable.tables("my-instance").all do |table|
+          #     puts table.table_id
+          #   end
+          #
+          # @example Using the enumerator by not passing a block:
+          #   require "google/cloud/bigtable"
+          #
+          #   bigtable = Google::Cloud::Bigtable.new
+          #
+          #   all_table_ids = bigtable.tables("my-instance").all.map do |table|
+          #     puts table.table_id
+          #   end
+          #
+          def all
+            return enum_for :all unless block_given?
+
+            results = self
+            loop do
+              results.each { |r| yield r }
+              break unless next?
+              grpc.next_page
+              results = self.class.from_grpc grpc, service
+            end
+          end
+
+          # @private
+          # New Table::List from a Google::Gax::PagedEnumerable<Google::Bigtable::Admin::V2::Table> object.
+          #
+          def self.from_grpc grpc, service
+            tables = List.new(Array(grpc.response.tables).map do |table|
+              Table.from_grpc table, service, view: :NAME_ONLY
+            end)
+            tables.grpc = grpc
+            tables.service = service
+            tables
+          end
+
+          protected
+
+          # @private
+          #
+          # Raises an error unless an active grpc call is available.
+          #
+          def ensure_grpc!
+            raise "Must have grpc call" unless grpc
+          end
+        end
+      end
+    end
+  end
+end

data/lib/google/cloud/bigtable/table/restore_job.rb

@@ -0,0 +1,117 @@
+# Copyright 2020 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+module Google
+  module Cloud
+    module Bigtable
+      class Table
+        ##
+        # # RestoreJob
+        #
+        # A resource representing the long-running, asynchronous processing of a backup restore operation. The
+        # job can be refreshed to retrieve the table object once the operation has been completed.
+        #
+        # See {Backup#restore}.
+        #
+        # @see https://cloud.google.com/bigtable/docs/reference/admin/rpc/google.longrunning#google.longrunning.Operation
+        #   Long-running Operation
+        #
+        # @example
+        #   require "google/cloud/bigtable"
+        #
+        #   bigtable = Google::Cloud::Bigtable.new
+        #   instance = bigtable.instance("my-instance")
+        #   cluster = instance.cluster("my-cluster")
+        #
+        #   backup = cluster.backup("my-backup")
+        #
+        #   job = backup.restore("my-new-table")
+        #
+        #   job.wait_until_done!
+        #   job.done? #=> true
+        #
+        #   if job.error?
+        #     status = job.error
+        #   else
+        #     table = job.table
+        #     optimized = job.optimize_table_operation_name
+        #   end
+        #
+        class RestoreJob < LongrunningJob
+          ##
+          # The optimize table operation name from operation metadata.
+          #
+          # @return [String, nil] The optimize table operation name, or `nil` if the optimize table operation is not
+          #   complete.
+          #
+          # @example
+          #   require "google/cloud/bigtable"
+          #
+          #   bigtable = Google::Cloud::Bigtable.new
+          #   instance = bigtable.instance("my-instance")
+          #   cluster = instance.cluster("my-cluster")
+          #
+          #   backup = cluster.backup("my-backup")
+          #
+          #   job = backup.restore("my-new-table")
+          #
+          #   job.wait_until_done!
+          #   job.done? #=> true
+          #
+          #   if job.error?
+          #     status = job.error
+          #   else
+          #     table = job.table
+          #     optimized = job.optimize_table_operation_name
+          #   end
+          #
+          def optimize_table_operation_name
+            metadata.optimize_table_operation_name
+          end
+
+          ##
+          # Gets the table object from operation results.
+          #
+          # @return [Google::Cloud::Bigtable::Table, nil] The table instance, or `nil` if the operation is not complete.
+          #
+          # @example
+          #   require "google/cloud/bigtable"
+          #
+          #   bigtable = Google::Cloud::Bigtable.new
+          #   instance = bigtable.instance("my-instance")
+          #   cluster = instance.cluster("my-cluster")
+          #
+          #   backup = cluster.backup("my-backup")
+          #
+          #   job = backup.restore("my-new-table")
+          #
+          #   job.wait_until_done!
+          #   job.done? #=> true
+          #
+          #   if job.error?
+          #     status = job.error
+          #   else
+          #     table = job.table
+          #     optimized = job.optimize_table_operation_name
+          #   end
+          #
+          def table
+            Table.from_grpc results, service if results
+          end
+        end
+      end
+    end
+  end
+end

data/lib/google/cloud/bigtable/v2.rb

@@ -0,0 +1,146 @@
+# Copyright 2020 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+require "google/cloud/bigtable/v2/bigtable_client"
+
+module Google
+  module Cloud
+    module Bigtable
+      # rubocop:disable LineLength
+
+      ##
+      # # Ruby Client for Cloud Bigtable API
+      #
+      # [Cloud Bigtable API][Product Documentation]:
+      # API for reading and writing the contents of Bigtables associated with a
+      # cloud project.
+      # - [Product Documentation][]
+      #
+      # ## Quick Start
+      # In order to use this library, you first need to go through the following
+      # steps:
+      #
+      # 1. [Select or create a Cloud Platform project.](https://console.cloud.google.com/project)
+      # 2. [Enable billing for your project.](https://cloud.google.com/billing/docs/how-to/modify-project#enable_billing_for_a_project)
+      # 3. [Enable the Cloud Bigtable API.](https://console.cloud.google.com/apis/library/bigtable.googleapis.com)
+      # 4. [Setup Authentication.](https://googleapis.dev/ruby/google-cloud-bigtable/latest/file.AUTHENTICATION.html)
+      #
+      # ### Installation
+      # ```
+      # $ gem install google-cloud-bigtable
+      # ```
+      #
+      # ### Next Steps
+      # - Read the [Cloud Bigtable API Product documentation][Product Documentation]
+      #   to learn more about the product and see How-to Guides.
+      # - View this [repository's main README](https://github.com/googleapis/google-cloud-ruby/blob/master/README.md)
+      #   to see the full list of Cloud APIs that we cover.
+      #
+      # [Product Documentation]: https://cloud.google.com/bigtable
+      #
+      # ## Enabling Logging
+      #
+      # To enable logging for this library, set the logger for the underlying [gRPC](https://github.com/grpc/grpc/tree/master/src/ruby) library.
+      # The logger that you set may be a Ruby stdlib [`Logger`](https://ruby-doc.org/stdlib-2.5.0/libdoc/logger/rdoc/Logger.html) as shown below,
+      # or a [`Google::Cloud::Logging::Logger`](https://googleapis.dev/ruby/google-cloud-logging/latest)
+      # that will write logs to [Stackdriver Logging](https://cloud.google.com/logging/). See [grpc/logconfig.rb](https://github.com/grpc/grpc/blob/master/src/ruby/lib/grpc/logconfig.rb)
+      # and the gRPC [spec_helper.rb](https://github.com/grpc/grpc/blob/master/src/ruby/spec/spec_helper.rb) for additional information.
+      #
+      # Configuring a Ruby stdlib logger:
+      #
+      # ```ruby
+      # require "logger"
+      #
+      # module MyLogger
+      #   LOGGER = Logger.new $stderr, level: Logger::WARN
+      #   def logger
+      #     LOGGER
+      #   end
+      # end
+      #
+      # # Define a gRPC module-level logger method before grpc/logconfig.rb loads.
+      # module GRPC
+      #   extend MyLogger
+      # end
+      # ```
+      #
+      module V2
+        # rubocop:enable LineLength
+
+        ##
+        # Service for reading from and writing to existing Bigtable tables.
+        #
+        # @param credentials [Google::Auth::Credentials, String, Hash, GRPC::Core::Channel, GRPC::Core::ChannelCredentials, Proc]
+        #   Provides the means for authenticating requests made by the client. This parameter can
+        #   be many types.
+        #   A `Google::Auth::Credentials` uses a the properties of its represented keyfile for
+        #   authenticating requests made by this client.
+        #   A `String` will be treated as the path to the keyfile to be used for the construction of
+        #   credentials for this client.
+        #   A `Hash` will be treated as the contents of a keyfile to be used for the construction of
+        #   credentials for this client.
+        #   A `GRPC::Core::Channel` will be used to make calls through.
+        #   A `GRPC::Core::ChannelCredentials` for the setting up the RPC client. The channel credentials
+        #   should already be composed with a `GRPC::Core::CallCredentials` object.
+        #   A `Proc` will be used as an updater_proc for the Grpc channel. The proc transforms the
+        #   metadata for requests, generally, to give OAuth credentials.
+        # @param scopes [Array<String>]
+        #   The OAuth scopes for this service. This parameter is ignored if
+        #   an updater_proc is supplied.
+        # @param client_config [Hash]
+        #   A Hash for call options for each method. See
+        #   Google::Gax#construct_settings for the structure of
+        #   this data. Falls back to the default config if not specified
+        #   or the specified config is missing data points.
+        # @param timeout [Numeric]
+        #   The default timeout, in seconds, for calls made through this client.
+        # @param metadata [Hash]
+        #   Default metadata to be sent with each request. This can be overridden on a per call basis.
+        # @param service_address [String]
+        #   Override for the service hostname, or `nil` to leave as the default.
+        # @param service_port [Integer]
+        #   Override for the service port, or `nil` to leave as the default.
+        # @param exception_transformer [Proc]
+        #   An optional proc that intercepts any exceptions raised during an API call to inject
+        #   custom error handling.
+        def self.new \
+            credentials: nil,
+            scopes: nil,
+            client_config: nil,
+            timeout: nil,
+            metadata: nil,
+            service_address: nil,
+            service_port: nil,
+            exception_transformer: nil,
+            lib_name: nil,
+            lib_version: nil
+          kwargs = {
+            credentials: credentials,
+            scopes: scopes,
+            client_config: client_config,
+            timeout: timeout,
+            metadata: metadata,
+            exception_transformer: exception_transformer,
+            lib_name: lib_name,
+            service_address: service_address,
+            service_port: service_port,
+            lib_version: lib_version
+          }.select { |_, v| v != nil }
+          Google::Cloud::Bigtable::V2::BigtableClient.new(**kwargs)
+        end
+      end
+    end
+  end
+end