statelydb 0.1.1 → 0.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5716a868b12a20de48e33bddf16396bac216172edc29ee5302eb3477380c7943
-  data.tar.gz: 98ca1b24cd5bdaa79409de8bf36e10bc573bc6c0b80bf8194bb08eeddc91cf0a
+  metadata.gz: d085f703fae0e0d968fe62788d74409d67b487025c76eca89589ded2b985794f
+  data.tar.gz: 3f9a0a0e029cb375f970eb2acfea662aced22501302758eedd5c7938ae6ebe26
 SHA512:
-  metadata.gz: 13a52d97a5ac5c309a3249dcbd1f5cb15392edc40c87a65a34064be54dfc44e5d6dd5ed6bff63fd4793f6e85297dbff92660fdc50a490d994c4af41e4ed9159c
-  data.tar.gz: cb8ce77af551b2c015c06ab75114517fe05376c26f1d8b228dde017b25da3685d7d8ee551bc140b50dc15fe06982618d485aab43dc88e7f63ebd47bdbd04769c
+  metadata.gz: fac13f5e528c452d3a69f305cfef78e34374f58913125a2ac9291656427ff8895ff303baa29c4244150b1e69dadf8bbadc13520bb02297de34c8e38801da35bc
+  data.tar.gz: 2c2f9ee717d50aef99d135c1316e7c3947617592246122461888b2bbb111c3f3204f9677fbef3cf8f33c1e5d04cecb1a4fecbfa99aaa44a772138e79b1663257

data/lib/common/net/conn.rb

@@ -19,7 +19,15 @@ module StatelyDB
                 else
                   creds.compose(call_creds)
                 end
-        GRPC::Core::Channel.new(endpoint_uri.authority, {}, creds)
+        GRPC::Core::Channel.new(endpoint_uri.authority, {
+                                  # 2x the default of 8kb = 16kb
+                                  # Set max and absolute max to the same value
+                                  # to stop the grpc lib changing the error code to ResourceExhausted
+                                  # while still successfully reading the metadata because only the soft
+                                  # limit was exceeded.
+                                  "grpc.max_metadata_size" => 8192 * 2,
+                                  "grpc.absolute_max_metadata_size" => 8192 * 2
+                                }, creds)
       end
     end
   end

data/lib/error.rb

@@ -22,14 +22,7 @@ module StatelyDB
     # @param [String] stately_code
     # @param [Exception] cause
     def initialize(message, code: nil, stately_code: nil, cause: nil)
-      # Turn a gRPC status code into a human-readable string. e.g. 3 -> "InvalidArgument"
-      code_str = if code > 0
-                   GRPC::Core::StatusCodes.constants.find do |c|
-                     GRPC::Core::StatusCodes.const_get(c) === code
-                   end.to_s.split("_").collect(&:capitalize).join
-                 else
-                   "Unknown"
-                 end
+      code_str = self.class.grpc_code_to_string(code)
 
       super("(#{code_str}/#{stately_code}): #{message}")
       @code = code
@@ -50,13 +43,31 @@ module StatelyDB
           raw_detail = status.details[0]
           if raw_detail.type_url == "type.googleapis.com/stately.errors.StatelyErrorDetails"
             error_details = Stately::Errors::StatelyErrorDetails.decode(raw_detail.value)
+            upstream_cause = error_details.upstream_cause.empty? ? nil : StandardError.new(error_details.upstream_cause) # rubocop:disable Metrics/BlockNesting
             return new(error_details.message, code: error.code, stately_code: error_details.stately_code,
-                                              cause: error_details.upstream_cause)
+                                              cause: upstream_cause)
           end
         end
       end
 
-      new(error.message, code: GRPC::Codes::StatusCodes::Unknown, stately_code: "Unknown", cause: error)
+      new(error.message, code: GRPC::Core::StatusCodes::UNKNOWN, stately_code: "Unknown", cause: error)
+    end
+
+    def code_string
+      self.class.grpc_code_to_string(@code)
+    end
+
+    # Turn a gRPC status code into a human-readable string. e.g. 3 -> "InvalidArgument"
+    # @param [Integer] code
+    # @return [String]
+    def self.grpc_code_to_string(code)
+      if code > 0
+        GRPC::Core::StatusCodes.constants.find do |c|
+          GRPC::Core::StatusCodes.const_get(c) === code
+        end.to_s.split("_").collect(&:capitalize).join
+      else
+        "Unknown"
+      end
     end
   end
 end

data/lib/stately_codes.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module StatelyCode
+  # StoreRequestLimitExceeded indicates that an attempt to modify a Store has
+  # been temporarily rejected due to exceeding global modification limits.
+  # StatelyDB has been notified about this error and will take necessary
+  # actions to correct it. In the event that the issue has not been resolved,
+  # please contact support.
+  #
+  # - Retryable? Yes.
+  STORE_REQUEST_LIMIT_EXCEEDED = "StoreRequestLimitExceeded"
+
+  # StoreThroughputExceeded indicates that the underlying Store does not have
+  # resources to complete the request. This may indicate a request rate is too
+  # high to a specific Group or that a sudden burst of traffic has exceeded a
+  # Store's provisioned capacity.
+  #
+  # - Retryable? Yes.
+  #     With an exponential backoff.
+  STORE_THROUGHPUT_EXCEEDED = "StoreThroughputExceeded"
+
+  # ConditionalCheckFailed indicates that conditions provided to perform an
+  # operation were not met. For example, a condition to write an item only if
+  # it does not already exist. In the future StatelyDB may provide more
+  # information about the failed condition; if this feature is a blocker,
+  # please contact support.
+  #
+  # - Retryable? No.
+  #     Typically a conditional check failure is not retryable
+  #     unless the conditions for the operation are changed.
+  CONDITIONAL_CHECK_FAILED = "ConditionalCheckFailed"
+
+  # NonRecoverableTransaction indicates that conditions required for the
+  # transaction to succeed are not possible to meet with the current state of
+  # the system. This can occur when an Item has more than one key-path, and is
+  # written with a "must not exist" condition (e.g. with ID Generation on one
+  # of the keys) but another keys already maps to an existing item in the
+  # store. Permitting such a write would result in conflicting state; two
+  # independent records with aliases pointing to the same item.
+  #
+  # - Retryable? No.
+  NON_RECOVERABLE_TRANSACTION = "NonRecoverableTransaction"
+
+  # ConcurrentModification indicates the current transaction was aborted
+  # because of a non-serializable interaction with another transaction was
+  # detected, a stale read was detected, or because attempts to resolve an
+  # otherwise serializable interaction have exceeded the maximum number of
+  # internal resolution retries. Examples:
+  #
+  # 1. TransactionA and TransactionB are opened concurrently. TransactionA
+  # reads ItemX, puts ItemY. Before transactionA can commit, transactionB
+  # writes ItemX and commits. When transactionA tries to commit, it will fail
+  # with ConcurrentModification because the read of ItemX in transactionA is
+  # no longer valid. That is, the data in ItemX which leads to the decision to
+  # put ItemY may have changed, and thus a conflict is detected.
+  #
+  # 2. TransactionA is opened which writes ItemA with an initialValue field (a
+  # field used for ID assignment) -- the generated ID is returned to the
+  # client. transactionB also performs a on an item which resolves to the same
+  # initialValue, transactionB is committed first. Since transactionA may have
+  # acted on the generatedID (e.g. written in a different record), it will be
+  # aborted because the ID is no longer valid for the item it was intended
+  # for.
+  #
+  # 3. A read or list operation detected that underlying data has changed
+  # since the transaction began.
+  #
+  # - Retryable? Yes.
+  #     This error is immediately retryable.
+  CONCURRENT_MODIFICATION = "ConcurrentModification"
+
+  # StoreInUse indicates that the underlying Store is currently in being
+  # updated and cannot be modified until the operation in progress has
+  # completed.
+  #
+  # - Retryable? Yes.
+  #     This can be retried with backoff.
+  STORE_IN_USE = "StoreInUse"
+end

data/lib/statelydb.rb

@@ -240,8 +240,11 @@ module StatelyDB
     rescue Exception => e
       txn.abort
 
+      # All gRPC errors inherit from GRPC::BadStatus. We wrap these in a StatelyDB::Error.
+      raise StatelyDB::Error.from(e) if e.is_a? GRPC::BadStatus
+
       # Calling raise with no parameters re-raises the original exception
-      raise StatelyDB::Error.from(e)
+      raise
     end
 
     private

data/lib/transaction/transaction.rb

@@ -239,7 +239,7 @@ module StatelyDB
       # for the items will be returned while inside the transaction block.
       #
       # @param items [StatelyDB::Item, Array<StatelyDB::Item>] the items to store
-      # @return [Array<String>] the key paths of the items
+      # @return [Array<StatelyDB::UUID, String, Integer, nil>] the ids of the items
       #
       # @example
       #   results = client.data.transaction do |txn|
@@ -261,7 +261,17 @@ module StatelyDB
         )
 
         resp = request_response(req).put_ack
-        resp.generated_ids.map(&:value)
+        resp.generated_ids.map do |generated_id|
+          case generated_id.value
+          when :bytes
+            StatelyDB::UUID.valid_uuid?(generated_id.bytes) ? StatelyDB::UUID.parse(generated_id.bytes) : generated_id.bytes
+          when :uint
+            generated_id.uint
+          else # rubocop:disable Style/EmptyElse
+            # An empty identifier is sent in the transaction Put response if an initialValue is not set
+            nil
+          end
+        end
       end
 
       # Delete one or more Items from a StatelyDB Store at the given key_paths. Results are not returned until the transaction is

data/lib/uuid.rb

@@ -48,6 +48,12 @@ module StatelyDB
       to_s <=> other.to_s
     end
 
+    # Returns true if the UUID is empty.
+    # @return [Boolean]
+    def empty?
+      @byte_string.empty?
+    end
+
     # Parses a base16 string (eg: "f4a8a24a-129d-411f-91d2-6d19d0eaa096") into a UUID object.
     # The string can be the following:
     # 1. Encoded as Encoding::ASCII_8BIT (also aliased as Encoding::BINARY) and be 16 bytes long.
@@ -56,7 +62,9 @@ module StatelyDB
     #                             base16-formatted UUID string.
     # @return [StatelyDB::UUID]
     def self.parse(byte_string)
-      if byte_string.encoding == Encoding::BINARY && byte_string.bytesize == 16
+      return byte_string if byte_string.is_a?(StatelyDB::UUID)
+
+      if valid_uuid?(byte_string)
         return new(byte_string)
       elsif byte_string.match(/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i)
         return new([byte_string.delete("-")].pack("H*"))
@@ -64,5 +72,12 @@ module StatelyDB
 
       raise "Invalid UUID"
     end
+
+    # Not all bytes values in StatelyDB are UUIDs. This method checks if a byte string is a valid UUID.
+    # @param [String] byte_string A binary-encoded string (eg: Encoding::ASCII_8BIT encoding)
+    # @return [Boolean]
+    def self.valid_uuid?(byte_string)
+      byte_string.encoding == Encoding::BINARY && byte_string.bytesize == 16
+    end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: statelydb
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.3
 platform: ruby
 authors:
 - Stately Cloud, Inc.
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-08-28 00:00:00.000000000 Z
+date: 2024-09-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: async
@@ -79,6 +79,7 @@ files:
 - lib/common/net/conn.rb
 - lib/error.rb
 - lib/key_path.rb
+- lib/stately_codes.rb
 - lib/statelydb.rb
 - lib/token.rb
 - lib/transaction/queue.rb