google-cloud-bigtable 0.1.0

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

@@ -0,0 +1,75 @@
+# 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.
+
+
+require "time"
+require "date"
+
+module Google
+  module Cloud
+    module Bigtable
+      # @private
+      # Helper module for converting Bigtable values.
+      module Convert
+        module_function
+
+        # Convert number to protobuf duration.
+        #
+        # @param number [Float] Seconds with nano seconds
+        # @return [Google::Protobuf::Duration, nil]
+        def number_to_duration number
+          return unless number
+
+          Google::Protobuf::Duration.new(
+            seconds: number.to_i,
+            nanos: (number.remainder(1) * 1000000000).round
+          )
+        end
+
+        # Convert protobuf durations to float.
+        #
+        # @param duration [Google::Protobuf::Duration, nil]
+        # @return [Float, Integer, nil] Seconds with nano seconds
+        def duration_to_number duration
+          return unless duration
+          return duration.seconds if duration.nanos.zero?
+
+          duration.seconds + (duration.nanos / 1000000000.0)
+        end
+
+        # Convert protobuf timestamp to Time object.
+        #
+        # @param timestamp [Google::Protobuf::Timestamp]
+        # @return [Time, nil]
+        def timestamp_to_time timestamp
+          return unless timestamp
+
+          Time.at(timestamp.seconds, timestamp.nanos / 1000.0)
+        end
+
+        # Convert time to timestamp protobuf object.
+        #
+        # @param time [Time]
+        # @return [Google::Protobuf::Timestamp, nil]
+        def time_to_timestamp time
+          return unless time
+
+          Google::Protobuf::Timestamp.new(seconds: time.to_i, nanos: time.nsec)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+# 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/credentials"
+
+module Google
+  module Cloud
+    module Bigtable
+      class Credentials < Google::Cloud::Bigtable::V2::Credentials
+      end
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+# 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
+      # Invalid read row state error
+      class InvalidRowStateError < Google::Cloud::Error
+        # Invalid row chunk data
+        attr_reader :data
+
+        def initialize message, data = nil
+          super(message)
+          @data = data if data
+        end
+      end
+
+      # Row filter error.
+      class RowFilterError < Google::Cloud::Error
+      end
+    end
+  end
+end

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

@@ -0,0 +1,215 @@
+# 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
+      # # GcRule
+      #
+      # Rule for determining which cells to delete during garbage collection.
+      # Garbage collection executes opportunistically in the background, and
+      # so it's possible for reads to return a cell even if it matches the active
+      # GC expression for its family.
+      #
+      # NOTE: GC Rule can hold only one type at a time.
+      # GC Rule types:
+      #   * `max_num_versions` - Delete all cells in a column except the most recent N
+      #   * `max_age` - Delete cells in a column older than the given age.
+      #   * `union` - Delete cells that would be deleted by every nested rule.
+      #       It can have mutiple chainable GC Rules.
+      #   * `intersection` - Delete cells that would be deleted by any nested rule.
+      #       It can have mutiple chainable GC Rules.
+      #
+      # @example Create GC rule instance with max version.
+      #
+      #  gc_rule = Google::Cloud::Bigtable::GcRule.max_versions(3)
+      #
+      #  # Change max verions
+      #  gc_rule.max_versions = 5
+      #
+      # @example Create GC rule instance with max age.
+      #
+      #  gc_rule = Google::Cloud::Bigtable::GcRule.max_age(3)
+      #
+      #  # Change max age
+      #  gc_rule.max_age = 600 # 10 minutes
+      #
+      # @example Create GC rule instance with union.
+      #
+      #  max_age_gc_rule = Google::Cloud::Bigtable::GcRule.max_age(180)
+      #  union_gc_rule = Google::Cloud::Bigtable::GcRule.union(max_age_gc_rule)
+      #
+      #  # Change union GC rule
+      #  gc_rule.union = Google::Cloud::Bigtable::GcRule.max_age(600)
+      #
+      # @example Create GC rule instance with intersection.
+      #
+      #  max_versions_gc_rule = Google::Cloud::Bigtable::GcRule.max_versions(3)
+      #  gc_rule = Google::Cloud::Bigtable::GcRule.intersection(max_versions_gc_rule)
+      #
+      #  # Change intersection GC rule
+      #  gc_rule.intersection = Google::Cloud::Bigtable::GcRule.max_age(600)
+      #
+      class GcRule
+        # @private
+        # Creates a new GC Rule instance.
+        #
+        # @param grpc [Google::Bigtable::Admin::V2::GcRule | nil]
+        #
+        def initialize grpc = nil
+          @grpc = grpc || Google::Bigtable::Admin::V2::GcRule.new
+        end
+
+        # Delete all cells in a column except the most recent N.
+        #
+        # @param versions [Integer]
+        #
+        def max_versions= versions
+          @grpc.max_num_versions = versions
+        end
+
+        # Get max versions.
+        #
+        # @return [Integer, nil]
+        #
+        def max_versions
+          @grpc.max_num_versions
+        end
+
+        # Delete cells in a column older than the given age.
+        # Values must be at least one millisecond, and will be truncated to
+        # microsecond granularity.
+        #
+        # @param age [Integer] age in seconds
+        #
+        def max_age= age
+          @grpc.max_age = Convert.number_to_duration(age)
+        end
+
+        # Max age in seconds, if max age is set.
+        #
+        # @return [Integer, nil] Max age in seconds.
+        #
+        def max_age
+          @grpc.max_age.seconds if @grpc.max_age
+        end
+
+        # Delete cells that would be deleted by every nested rule.
+        #
+        # @param rules [Array<Google::Cloud::Bigtable::GcRule>]
+        #   List of GcRule with nested rules.
+        #
+        def intersection= rules
+          @grpc.intersection = \
+            Google::Bigtable::Admin::V2::GcRule::Intersection.new(
+              rules: rules.map(&:to_grpc)
+            )
+        end
+
+        # Get intersection GC rules
+        #
+        # @return [Google::Bigtable::Admin::V2::GcRule::Intersection, nil]
+        #
+        def intersection
+          @grpc.intersection
+        end
+
+        # Delete cells that would be deleted by any nested rule.
+        #
+        # @param rules [Array<Google::Cloud::Bigtable::GcRule>]
+        #   List of GcRule with nested rules.
+        #
+        def union= rules
+          @grpc.union = Google::Bigtable::Admin::V2::GcRule::Union.new(
+            rules: rules.map(&:to_grpc)
+          )
+        end
+
+        # Get union GC rules
+        #
+        # @return [Google::Bigtable::Admin::V2::GcRule::Union, nil]
+        #
+        def union
+          @grpc.union
+        end
+
+        # Create GcRule instance with max number of versions.
+        #
+        # @param versions [Integer] Max number of versions
+        # @return [Google::Bigtable::Admin::V2::GcRule]
+        #
+        def self.max_versions versions
+          new.tap do |gc_rule|
+            gc_rule.max_versions = versions
+          end
+        end
+
+        # Create GcRule instance with max age.
+        #
+        # @param age [Integer] Max age in seconds.
+        # @return [Google::Bigtable::Admin::V2::GcRule]
+        #
+        def self.max_age age
+          new.tap do |gc_rule|
+            gc_rule.max_age = age
+          end
+        end
+
+        # Create union GcRule instance.
+        #
+        # @param rules [Google::Cloud::Bigtable::GcRule, Array<Google::Cloud::Bigtable::GcRule>]
+        #   List of GcRule with nested rules.
+        # @return [Google::Bigtable::Admin::V2::GcRule]
+        #
+        def self.union *rules
+          new.tap do |gc_rule|
+            gc_rule.union = rules
+          end
+        end
+
+        # Create intersection GCRule instance.
+        #
+        # @param rules [Google::Cloud::Bigtable::GcRule, Array<Google::Cloud::Bigtable::GcRule>]
+        #   List of GcRule with nested rules.
+        # @return [Google::Bigtable::Admin::V2::GcRule]
+        #
+        def self.intersection *rules
+          new.tap do |gc_rule|
+            gc_rule.intersection = rules
+          end
+        end
+
+        # @private
+        # Get gRPC instance of GC Rule
+        # @return [Google::Bigtable::Admin::V2::GcRule]
+        def to_grpc
+          @grpc
+        end
+
+        # @private
+        #
+        # Creates a new GcRule instance from a
+        # Google::Bigtable::Admin::V2::GcRule.
+        # @param grpc [Google::Bigtable::Admin::V2::GcRule]
+        # @return [Google::Cloud::Bigtable::GcRule]
+        def self.from_grpc grpc
+          new(grpc)
+        end
+      end
+    end
+  end
+end

data/lib/google/cloud/bigtable/instance/cluster_map.rb

@@ -0,0 +1,70 @@
+# 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 Instance
+        # Instance::ClusterMap is a Hash with cluster name and gRPC object.
+        # It is used to create instance.
+        # @example Create
+        #
+        #  clusters = Google::Cloud::Bigtable::Instance::ClusterMap.new
+        #
+        #  clusters.add("cluster-1", 3, location: "us-east1-b", storage_type: :SSD)
+        #
+        #  # Or
+        #  cluster.add("cluster-2", 1)
+        #
+        class ClusterMap < DelegateClass(::Hash)
+          # @private
+          #
+          # Create a new Instance::ClusterMap with an hash of Cluster name and
+          # cluster grpc instances.
+          def initialize value = {}
+            super(value)
+          end
+
+          # Add cluster to map
+          #
+          # @param name [String] Cluster name
+          # @param location [String]
+          #   The location where this cluster's nodes and storage reside. For best
+          #   performance, clients should be located as close as possible to this
+          #   cluster. Currently only zones are supported.
+          # @param nodes [Integer] No of nodes
+          # @param storage_type [Symbol]
+          #   Valid values are:
+          #   * `:SSD`(Flash (SSD) storage should be used),
+          #   *`:HDD`(Magnetic drive (HDD) storage should be used)
+          #
+          #   If not set then default will set to `:STORAGE_TYPE_UNSPECIFIED`
+
+          def add name, location, nodes: nil, storage_type: nil
+            attrs = {
+              serve_nodes: nodes,
+              location: location,
+              default_storage_type: storage_type
+            }.delete_if { |_, v| v.nil? }
+
+            self[name] = Google::Bigtable::Admin::V2::Cluster.new(attrs)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/google/cloud/bigtable/instance/job.rb

@@ -0,0 +1,97 @@
+# 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 Instance
+        # # Job
+        #
+        # A resource representing the long-running, asynchronous processing of
+        # an instance create or update operation. The job can be refreshed to
+        # retrieve the instance object once the operation has been completed.
+        #
+        # See {Project#create_instance} and {Instance#update}.
+        #
+        # @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
+        #
+        #   job = bigtable.create_instance(
+        #     "my-instance",
+        #     display_name: "Instance for user data",
+        #     type: :DEVELOPMENT,
+        #     labels: { "env" => "dev"}
+        #   ) do |clusters|
+        #     clusters.add("test-cluster", "us-east1-b", nodes: 1)
+        #   end
+        #
+        #   # Check and reload.
+        #   job.done? #=> false
+        #   job.reload! # API call
+        #   job.done? #=> true
+        #
+        #   # OR - Wailt until complete
+        #   job.wait_until_done!
+        #   job.done? #=> true
+        #
+        #   if job.error?
+        #     status = job.error
+        #   else
+        #     instance = job.instance
+        #   end
+        #
+        #
+        class Job < LongrunningJob
+          # Get the instance object from operation results.
+          #
+          # @return [Google::Cloud::Bigtable::Instance, nil] The Instance instance, or
+          #   `nil` if the operation is not complete.
+          #
+          # @example
+          #   require "google/cloud/bigtable"
+          #
+          #   bigtable = Google::Cloud::Bigtable.new
+          #
+          #   job = bigtable.create_instance(
+          #     "my-instance",
+          #     "Instance for user data",
+          #     type: :DEVELOPMENT,
+          #     labels: { "env" => "dev"}
+          #   ) do |clusters|
+          #     clusters.add("test-cluster", "us-east1-b", nodes: 1)
+          #   end
+          #
+          #   job.done? #=> false
+          #   job.reload!
+          #   job.done? #=> true
+          #
+          #   # OR
+          #   job.wait_until_done!
+          #
+          #   instance = job.instance
+          #
+          def instance
+            Instance.from_grpc(results, service) if results
+          end
+        end
+      end
+    end
+  end
+end