google-cloud-bigtable 0.1.0

data/lib/google/cloud/bigtable/v2/doc/google/protobuf/any.rb

@@ -0,0 +1,124 @@
+# 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 Protobuf
+    # +Any+ contains an arbitrary serialized protocol buffer message along with a
+    # URL that describes the type of the serialized message.
+    #
+    # Protobuf library provides support to pack/unpack Any values in the form
+    # of utility functions or additional generated methods of the Any type.
+    #
+    # Example 1: Pack and unpack a message in C++.
+    #
+    #     Foo foo = ...;
+    #     Any any;
+    #     any.PackFrom(foo);
+    #     ...
+    #     if (any.UnpackTo(&foo)) {
+    #       ...
+    #     }
+    #
+    # Example 2: Pack and unpack a message in Java.
+    #
+    #     Foo foo = ...;
+    #     Any any = Any.pack(foo);
+    #     ...
+    #     if (any.is(Foo.class)) {
+    #       foo = any.unpack(Foo.class);
+    #     }
+    #
+    #  Example 3: Pack and unpack a message in Python.
+    #
+    #     foo = Foo(...)
+    #     any = Any()
+    #     any.Pack(foo)
+    #     ...
+    #     if any.Is(Foo.DESCRIPTOR):
+    #       any.Unpack(foo)
+    #       ...
+    #
+    #  Example 4: Pack and unpack a message in Go
+    #
+    #      foo := &pb.Foo{...}
+    #      any, err := ptypes.MarshalAny(foo)
+    #      ...
+    #      foo := &pb.Foo{}
+    #      if err := ptypes.UnmarshalAny(any, foo); err != nil {
+    #        ...
+    #      }
+    #
+    # The pack methods provided by protobuf library will by default use
+    # 'type.googleapis.com/full.type.name' as the type URL and the unpack
+    # methods only use the fully qualified type name after the last '/'
+    # in the type URL, for example "foo.bar.com/x/y.z" will yield type
+    # name "y.z".
+    #
+    #
+    # = JSON
+    #
+    # The JSON representation of an +Any+ value uses the regular
+    # representation of the deserialized, embedded message, with an
+    # additional field +@type+ which contains the type URL. Example:
+    #
+    #     package google.profile;
+    #     message Person {
+    #       string first_name = 1;
+    #       string last_name = 2;
+    #     }
+    #
+    #     {
+    #       "@type": "type.googleapis.com/google.profile.Person",
+    #       "firstName": <string>,
+    #       "lastName": <string>
+    #     }
+    #
+    # If the embedded message type is well-known and has a custom JSON
+    # representation, that representation will be embedded adding a field
+    # +value+ which holds the custom JSON in addition to the +@type+
+    # field. Example (for message {Google::Protobuf::Duration}):
+    #
+    #     {
+    #       "@type": "type.googleapis.com/google.protobuf.Duration",
+    #       "value": "1.212s"
+    #     }
+    # @!attribute [rw] type_url
+    #   @return [String]
+    #     A URL/resource name whose content describes the type of the
+    #     serialized protocol buffer message.
+    #
+    #     For URLs which use the scheme +http+, +https+, or no scheme, the
+    #     following restrictions and interpretations apply:
+    #
+    #     * If no scheme is provided, +https+ is assumed.
+    #     * The last segment of the URL's path must represent the fully
+    #       qualified name of the type (as in +path/google.protobuf.Duration+).
+    #       The name should be in a canonical form (e.g., leading "." is
+    #       not accepted).
+    #     * An HTTP GET on the URL must yield a {Google::Protobuf::Type}
+    #       value in binary format, or produce an error.
+    #     * Applications are allowed to cache lookup results based on the
+    #       URL, or have them precompiled into a binary to avoid any
+    #       lookup. Therefore, binary compatibility needs to be preserved
+    #       on changes to types. (Use versioned type names to manage
+    #       breaking changes.)
+    #
+    #     Schemes other than +http+, +https+ (or the empty scheme) might be
+    #     used with implementation specific semantics.
+    # @!attribute [rw] value
+    #   @return [String]
+    #     Must be a valid serialized protocol buffer of the above specified type.
+    class Any; end
+  end
+end

data/lib/google/cloud/bigtable/v2/doc/google/protobuf/wrappers.rb

@@ -0,0 +1,89 @@
+# 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 Protobuf
+    # Wrapper message for +double+.
+    #
+    # The JSON representation for +DoubleValue+ is JSON number.
+    # @!attribute [rw] value
+    #   @return [Float]
+    #     The double value.
+    class DoubleValue; end
+
+    # Wrapper message for +float+.
+    #
+    # The JSON representation for +FloatValue+ is JSON number.
+    # @!attribute [rw] value
+    #   @return [Float]
+    #     The float value.
+    class FloatValue; end
+
+    # Wrapper message for +int64+.
+    #
+    # The JSON representation for +Int64Value+ is JSON string.
+    # @!attribute [rw] value
+    #   @return [Integer]
+    #     The int64 value.
+    class Int64Value; end
+
+    # Wrapper message for +uint64+.
+    #
+    # The JSON representation for +UInt64Value+ is JSON string.
+    # @!attribute [rw] value
+    #   @return [Integer]
+    #     The uint64 value.
+    class UInt64Value; end
+
+    # Wrapper message for +int32+.
+    #
+    # The JSON representation for +Int32Value+ is JSON number.
+    # @!attribute [rw] value
+    #   @return [Integer]
+    #     The int32 value.
+    class Int32Value; end
+
+    # Wrapper message for +uint32+.
+    #
+    # The JSON representation for +UInt32Value+ is JSON number.
+    # @!attribute [rw] value
+    #   @return [Integer]
+    #     The uint32 value.
+    class UInt32Value; end
+
+    # Wrapper message for +bool+.
+    #
+    # The JSON representation for +BoolValue+ is JSON +true+ and +false+.
+    # @!attribute [rw] value
+    #   @return [true, false]
+    #     The bool value.
+    class BoolValue; end
+
+    # Wrapper message for +string+.
+    #
+    # The JSON representation for +StringValue+ is JSON string.
+    # @!attribute [rw] value
+    #   @return [String]
+    #     The string value.
+    class StringValue; end
+
+    # Wrapper message for +bytes+.
+    #
+    # The JSON representation for +BytesValue+ is JSON string.
+    # @!attribute [rw] value
+    #   @return [String]
+    #     The bytes value.
+    class BytesValue; end
+  end
+end

data/lib/google/cloud/bigtable/v2/doc/google/rpc/status.rb

@@ -0,0 +1,83 @@
+# 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 Rpc
+    # The +Status+ type defines a logical error model that is suitable for different
+    # programming environments, including REST APIs and RPC APIs. It is used by
+    # [gRPC](https://github.com/grpc). The error model is designed to be:
+    #
+    # * Simple to use and understand for most users
+    # * Flexible enough to meet unexpected needs
+    #
+    # = Overview
+    #
+    # The +Status+ message contains three pieces of data: error code, error message,
+    # and error details. The error code should be an enum value of
+    # {Google::Rpc::Code}, but it may accept additional error codes if needed.  The
+    # error message should be a developer-facing English message that helps
+    # developers *understand* and *resolve* the error. If a localized user-facing
+    # error message is needed, put the localized message in the error details or
+    # localize it in the client. The optional error details may contain arbitrary
+    # information about the error. There is a predefined set of error detail types
+    # in the package +google.rpc+ that can be used for common error conditions.
+    #
+    # = Language mapping
+    #
+    # The +Status+ message is the logical representation of the error model, but it
+    # is not necessarily the actual wire format. When the +Status+ message is
+    # exposed in different client libraries and different wire protocols, it can be
+    # mapped differently. For example, it will likely be mapped to some exceptions
+    # in Java, but more likely mapped to some error codes in C.
+    #
+    # = Other uses
+    #
+    # The error model and the +Status+ message can be used in a variety of
+    # environments, either with or without APIs, to provide a
+    # consistent developer experience across different environments.
+    #
+    # Example uses of this error model include:
+    #
+    # * Partial errors. If a service needs to return partial errors to the client,
+    #   it may embed the +Status+ in the normal response to indicate the partial
+    #   errors.
+    #
+    # * Workflow errors. A typical workflow has multiple steps. Each step may
+    #   have a +Status+ message for error reporting.
+    #
+    # * Batch operations. If a client uses batch request and batch response, the
+    #   +Status+ message should be used directly inside batch response, one for
+    #   each error sub-response.
+    #
+    # * Asynchronous operations. If an API call embeds asynchronous operation
+    #   results in its response, the status of those operations should be
+    #   represented directly using the +Status+ message.
+    #
+    # * Logging. If some API errors are stored in logs, the message +Status+ could
+    #   be used directly after any stripping needed for security/privacy reasons.
+    # @!attribute [rw] code
+    #   @return [Integer]
+    #     The status code, which should be an enum value of {Google::Rpc::Code}.
+    # @!attribute [rw] message
+    #   @return [String]
+    #     A developer-facing error message, which should be in English. Any
+    #     user-facing error message should be localized and sent in the
+    #     {Google::Rpc::Status#details} field, or localized by the client.
+    # @!attribute [rw] details
+    #   @return [Array<Google::Protobuf::Any>]
+    #     A list of messages that carry the error details.  There is a common set of
+    #     message types for APIs to use.
+    class Status; end
+  end
+end

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

@@ -0,0 +1,132 @@
+# 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.
+
+require "google/cloud/bigtable/v2/bigtable_client"
+
+module Google
+  module Cloud
+    module Bigtable
+      # rubocop:disable LineLength
+
+      ##
+      # # Ruby Client for Cloud Bigtable API ([Alpha](https://github.com/GoogleCloudPlatform/google-cloud-ruby#versioning))
+      #
+      # [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://googlecloudplatform.github.io/google-cloud-ruby/#/docs/google-cloud/master/guides/authentication)
+      #
+      # ### 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/GoogleCloudPlatform/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://googlecloudplatform.github.io/google-cloud-ruby/#/docs/google-cloud-logging/latest/google/cloud/logging/logger)
+      # 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 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,
+            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,
+            lib_version: lib_version
+          }.select { |_, v| v != nil }
+          Google::Cloud::Bigtable::V2::BigtableClient.new(**kwargs)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,175 @@
+# 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
+      # # ValueRange
+      #
+      # Specifies a contiguous range of string values.
+      #
+      # * from value bound : The value at which to from the range.
+      #   If neither field is set, interpreted as the empty string, inclusive.
+      # * End value bound: The value at which to end the range.
+      #   If neither field is set, interpreted as the infinite string value, exclusive.
+      #
+      # @example
+      #   require "google/cloud/bigtable"
+      #
+      #   bigtable = Google::Cloud::Bigtable.new
+      #   table = bigtable.table("my-instance", "my-table")
+      #
+      #   # Range that includes all row keys including "value-001" to "value-005" excluding
+      #   table.new_value_range.from("value-001").to("value-005")
+      #
+      #   # Range that includes all row keys including "value-001" up to inclusive "value-010".
+      #   table.new_value_range.from("value-001").to("value-010", inclusive: true)
+      #
+      #   # Range that includes all row keys including "value-001" up until end of the row keys.
+      #   table.new_value_range.from("value-001")
+      #
+      #   # Range that includes all row keys exclusive "value-001" up until end of the row keys.
+      #   table.new_value_range.from("value-001", inclusive: false)
+      #
+      #   # Range with unbounded from and the exclusive end "value-100"
+      #   table.new_value_range.to("value-100")
+      #
+      #   # Range that includes all row keys including from and end row keys "value-001", "value-100"
+      #   table.new_value_range.between("value-001", "value-100")
+      #
+      #   # Range that includes all row keys including "value-001" up until "value-100"
+      #   table.new_value_range.of("value-001", "value-100")
+      #
+      class ValueRange
+        # @private
+        # Create value range instance.
+        def initialize
+          @grpc = Google::Bigtable::V2::ValueRange.new
+        end
+
+        # Ser row range with the lower bound.
+        #
+        # @param value [String] value. Required
+        # @param inclusive [String] Inclusive/Exclusive lower bound.
+        #   Default it is an inclusive lower bound.
+        # @return [Google::Cloud::Bigtable::ValueRange]
+        #
+        # @example Inclusive lower bound.
+        #   require "google/cloud/bigtable"
+        #
+        #   bigtable = Google::Cloud::Bigtable.new
+        #   table = bigtable.table("my-instance", "my-table")
+        #
+        #   range = table.new_value_range.from("value-001")
+        #
+        # @example Exclusive lower bound.
+        #   require "google/cloud/bigtable"
+        #
+        #   bigtable = Google::Cloud::Bigtable.new
+        #   table = bigtable.table("my-instance", "my-table")
+        #
+        #   range = table.new_value_range.from("value-001", inclusive: false)
+        #
+        def from value, inclusive: true
+          if inclusive
+            @grpc.start_value_closed = value
+          else
+            @grpc.start_value_open = value
+          end
+          self
+        end
+
+        # Set value range with upper bound.
+        #
+        # @param value [String] value. Required
+        # @param inclusive [String] Inclusive/Exclusive upper bound.
+        #   Default it is an exclusive upper bound.
+        # @return [Google::Cloud::Bigtable::ValueRange]
+        #
+        # @example Inclusive upper bound.
+        #   require "google/cloud/bigtable"
+        #
+        #   bigtable = Google::Cloud::Bigtable.new
+        #   table = bigtable.table("my-instance", "my-table")
+        #
+        #   range = table.new_value_range.to("value-010", inclusive: true)
+        #
+        # @example Exclusive upper bound.
+        #   require "google/cloud/bigtable"
+        #
+        #   bigtable = Google::Cloud::Bigtable.new
+        #   table = bigtable.table("my-instance", "my-table")
+        #
+        #   range = table.new_value_range.to("value-010")
+        #
+        def to value, inclusive: false
+          if inclusive
+            @grpc.end_value_closed = value
+          else
+            @grpc.end_value_open = value
+          end
+          self
+        end
+
+        # Set value range with the inclusive lower and upper bound.
+        #
+        # @param from_value [String] Inclusive from value. Required
+        # @param to_value [String] Inclusive end value. Required
+        # @return [Google::Cloud::Bigtable::ValueRange]
+        #   Range with inclusive from and end value.
+        #
+        # @example
+        #   require "google/cloud/bigtable"
+        #
+        #   bigtable = Google::Cloud::Bigtable.new
+        #   table = bigtable.table("my-instance", "my-table")
+        #
+        #   range = table.new_value_range.between("value-001", "value-010")
+        #
+        def between from_value, to_value
+          from(from_value).to(to_value, inclusive: true)
+        end
+
+        # Set value range with the inclusive lower and the exclusive upper bound.
+        #
+        # @param from_value [String] Inclusive from value
+        # @param to_value [String] Exclusive to value
+        # @return [Google::Cloud::Bigtable::ValueRange]
+        #
+        # @example
+        #   require "google/cloud/bigtable"
+        #
+        #   bigtable = Google::Cloud::Bigtable.new
+        #   table = bigtable.table("my-instance", "my-table")
+        #
+        #   range = table.new_value_range.of("value-001", "value-010")
+        #
+        def of from_value, to_value
+          from(from_value).to(to_value)
+        end
+
+        # @private
+        #
+        # @return [Google::Bigtable::V2::ValueRange]
+        #
+        def to_grpc
+          @grpc
+        end
+      end
+    end
+  end
+end