riak-client 2.4.1 → 2.5.0

data/lib/riak/locale/en.yml

@@ -102,6 +102,7 @@ en:
       serialize_big_integer: "%{bignum} is out of range for sint64 field"
       serialize_complex_number: "Cannot serialize Complex numbers"
       serialize_rational_number: "Cannot serialize Rational numbers without losing precision"
+    tombstone_object: "The object is a tombstone (has vclock but no values) and cannot be treated singly or saved: %{robject}"
     too_few_arguments: "too few arguments: %{params}"
     walk_spec_invalid_unless_link: "WalkSpec is only valid for a function when the type is :link"
     wrong_argument_count_walk_spec: "wrong number of arguments (one Hash or bucket,tag,keep required)"

data/lib/riak/locale/fr.yml

@@ -1,51 +1,51 @@
-fr:
-  riak:
-    backwards_clock: "L'horloge système a reculé. La génération des ID échouera pour les %{delay} millisecondes à venir."
-    bucket_link_conversion: "Ne peut convertir un lien de bucket vers un walk spec"
-    client_type: "argument invalide : %{client} n'est pas un Riak::Client"
-    conflict_resolver_invalid: "Le résolveur (%{resolver}) n'a pas répondu à :call"
-    content_type_undefined: "content_type n'est pas défini !"
-    deprecated:
-      port: "DEPRECATION: Riak::Client#port ne doit plus être utilisé (deprecated), utilisez #http_port ou #pb_port pour spécifier le protocol.\n%{backtrace}"
-      search: "DEPRECATION: Les fonctionnalités Riak Search sont désormais inclues dans le client principal. Vous n'avez plus besoin d'inclure 'riak/search'.\n%{backtrace}"
-    empty_map_reduce_query: "Spécifiez une ou plusieurs requêtes pour MapReduce."
-    failed_request: "La requête client a échouée."
-    filter_needs_block: "Le filtre %{filter} nécessite un bloc."
-    filter_arity_mismatch: "Le filtre %{filter} nécessite %{expected} arguments. Seulement %{received} ont été fournis."
-    full_bucket_mapred: "Les MapReduce sur un bucket complet, y compris les filtres de clé, invoque 'list-keys' qui est une opération coûteuse et ne doit pas être utilisée en production.\n    %{backtrace}"
-    hash_type: "argument invalide : %{hash} n'est pas un Hash"
-    http_configuration: "Le moteur HTTP %{backend} ne peut être utilisé. Merci de vérifier ses dépendances et/ou sa configuration."
-    http_failed_request: "%{expected} attendu depuis Riak mais %{code} reçu. %{body}"
-    hostname_invalid: "host doit être un nom d'hôte valide"
-    protocol_invalid: "'%{invalid}' n'est pas un protocole valide. Les valeurs possibles sont %{valid}"
-    invalid_basic_auth: "L'authentification basique doit être utilisée comme ceci : 'user:pass'"
-    invalid_client_id: "ID client invalide, doit être une chaîne ou un entier entre 0 et %{max_id}"
-    invalid_io_object: "Object de type IO invalide assigné à RObject#data. Il devrait plutôt être assigné à raw_data"
-    invalid_function_value: "Valeur invalide pour la fonction : %{value}"
-    invalid_options: "Options de configuration invalides."
-    invalid_phase_type: "type doit être :map, :reduce, ou :link"
-    invalid_ssl_verify_mode: "%{invalid} n'est pas une option :verify_mode valide pour SSL. Les options valides sont 'peer' and 'none'."
-    invalid_index_query: "%{value} n'est pas un term de requête valide. Seules les String, Integer et Range de ces types sont autorisés"
-    indexes_unsupported: "Le serveur Riak ne supporte pas les index secondaires."
-    loading_bucket: "pendant le chargement du bucket '%{name}'"
-    list_buckets: "Riak::Client#buckets est une opération coûteuse et ne doit pas être utilisée en production.\n    %{backtrace}"
-    list_keys: "Riak::Bucket#keys est une opération coûteuse et ne doit pas être utilisée en production.\n    %{backtrace}"
-    missing_block: "Un bloc doit être fourni."
-    missing_host_and_port: "Vous devez spécifier un hôte et un port, utiliser la valeur par défaut : 127.0.0.1:8098"
-    module_function_pair_required: "la fonction doit avoir deux élément lorsqu'elle est définie par un tableau"
-    not_found: "L'objet demandé n'a pas été trouvé."
-    no_pipes: "Ne peut trouver ou ne peut ouvrir un pipe pour la console Riak dans %{path}."
-    port_invalid: "le port doit être un entier entre 0 et 65535"
-    protobuffs_failed_request: "Riak a retourné le code d'erreur %{code} au lieu d'une réponse réussie. %{body}"
-    request_body_type: "Le corps de la requête doit être une chaine ou répondre à :read."
-    search_unsupported: "Le serveur Riak ne supporte pas la recherche."
-    search_docs_require_id: "Search index documents must include the 'id' field."
-    search_remove_requires_id_or_query: "Les documents d'index de recherche doivent avoir des clés 'id' ou 'query'"
-    serializer_not_implemented: "Aucun sérialiseur n'a été défini pour le type de contenu %{content_type}"
-    source_and_root_required: "La configuration de Riak::Node configuration doit inclure les clés :source and :root."
-    stale_write_prevented: "Le client a empêché une écriture périmée."
-    stored_function_invalid: "Une fonction définie par un hash doit avoir :bucket et :key"
-    string_type: "invalid_argument %{string} n'est pas une String"
-    too_few_arguments: "pas assez d'arguments : %{params}"
-    walk_spec_invalid_unless_link: "Le WalkSpec n'est valide pour une fonction que lorsque le type est :link"
-    wrong_argument_count_walk_spec: "nombre d'argument invalide (un Hash ou bucket,tag,keep requis)"
+fr:
+  riak:
+    backwards_clock: "L'horloge système a reculé. La génération des ID échouera pour les %{delay} millisecondes à venir."
+    bucket_link_conversion: "Ne peut convertir un lien de bucket vers un walk spec"
+    client_type: "argument invalide : %{client} n'est pas un Riak::Client"
+    conflict_resolver_invalid: "Le résolveur (%{resolver}) n'a pas répondu à :call"
+    content_type_undefined: "content_type n'est pas défini !"
+    deprecated:
+      port: "DEPRECATION: Riak::Client#port ne doit plus être utilisé (deprecated), utilisez #http_port ou #pb_port pour spécifier le protocol.\n%{backtrace}"
+      search: "DEPRECATION: Les fonctionnalités Riak Search sont désormais inclues dans le client principal. Vous n'avez plus besoin d'inclure 'riak/search'.\n%{backtrace}"
+    empty_map_reduce_query: "Spécifiez une ou plusieurs requêtes pour MapReduce."
+    failed_request: "La requête client a échouée."
+    filter_needs_block: "Le filtre %{filter} nécessite un bloc."
+    filter_arity_mismatch: "Le filtre %{filter} nécessite %{expected} arguments. Seulement %{received} ont été fournis."
+    full_bucket_mapred: "Les MapReduce sur un bucket complet, y compris les filtres de clé, invoque 'list-keys' qui est une opération coûteuse et ne doit pas être utilisée en production.\n    %{backtrace}"
+    hash_type: "argument invalide : %{hash} n'est pas un Hash"
+    http_configuration: "Le moteur HTTP %{backend} ne peut être utilisé. Merci de vérifier ses dépendances et/ou sa configuration."
+    http_failed_request: "%{expected} attendu depuis Riak mais %{code} reçu. %{body}"
+    hostname_invalid: "host doit être un nom d'hôte valide"
+    protocol_invalid: "'%{invalid}' n'est pas un protocole valide. Les valeurs possibles sont %{valid}"
+    invalid_basic_auth: "L'authentification basique doit être utilisée comme ceci : 'user:pass'"
+    invalid_client_id: "ID client invalide, doit être une chaîne ou un entier entre 0 et %{max_id}"
+    invalid_io_object: "Object de type IO invalide assigné à RObject#data. Il devrait plutôt être assigné à raw_data"
+    invalid_function_value: "Valeur invalide pour la fonction : %{value}"
+    invalid_options: "Options de configuration invalides."
+    invalid_phase_type: "type doit être :map, :reduce, ou :link"
+    invalid_ssl_verify_mode: "%{invalid} n'est pas une option :verify_mode valide pour SSL. Les options valides sont 'peer' and 'none'."
+    invalid_index_query: "%{value} n'est pas un term de requête valide. Seules les String, Integer et Range de ces types sont autorisés"
+    indexes_unsupported: "Le serveur Riak ne supporte pas les index secondaires."
+    loading_bucket: "pendant le chargement du bucket '%{name}'"
+    list_buckets: "Riak::Client#buckets est une opération coûteuse et ne doit pas être utilisée en production.\n    %{backtrace}"
+    list_keys: "Riak::Bucket#keys est une opération coûteuse et ne doit pas être utilisée en production.\n    %{backtrace}"
+    missing_block: "Un bloc doit être fourni."
+    missing_host_and_port: "Vous devez spécifier un hôte et un port, utiliser la valeur par défaut : 127.0.0.1:8098"
+    module_function_pair_required: "la fonction doit avoir deux élément lorsqu'elle est définie par un tableau"
+    not_found: "L'objet demandé n'a pas été trouvé."
+    no_pipes: "Ne peut trouver ou ne peut ouvrir un pipe pour la console Riak dans %{path}."
+    port_invalid: "le port doit être un entier entre 0 et 65535"
+    protobuffs_failed_request: "Riak a retourné le code d'erreur %{code} au lieu d'une réponse réussie. %{body}"
+    request_body_type: "Le corps de la requête doit être une chaine ou répondre à :read."
+    search_unsupported: "Le serveur Riak ne supporte pas la recherche."
+    search_docs_require_id: "Search index documents must include the 'id' field."
+    search_remove_requires_id_or_query: "Les documents d'index de recherche doivent avoir des clés 'id' ou 'query'"
+    serializer_not_implemented: "Aucun sérialiseur n'a été défini pour le type de contenu %{content_type}"
+    source_and_root_required: "La configuration de Riak::Node configuration doit inclure les clés :source and :root."
+    stale_write_prevented: "Le client a empêché une écriture périmée."
+    stored_function_invalid: "Une fonction définie par un hash doit avoir :bucket et :key"
+    string_type: "invalid_argument %{string} n'est pas une String"
+    too_few_arguments: "pas assez d'arguments : %{params}"
+    walk_spec_invalid_unless_link: "Le WalkSpec n'est valide pour une fonction que lorsque le type est :link"
+    wrong_argument_count_walk_spec: "nombre d'argument invalide (un Hash ou bucket,tag,keep requis)"

data/lib/riak/map_reduce/results.rb

@@ -1,49 +1,49 @@
-module Riak
-  class MapReduce
-    # @api private
-    # Collects and normalizes results from MapReduce requests
-    class Results
-      # Creates a new result collector
-      # @param [MapReduce] mr the MapReduce query
-      def initialize(mr)
-        @keep_count = mr.query.select {|p| p.keep }.size
-        @hash = create_results_hash(mr.query)
-      end
-
-      # Adds a new result to the collector
-      # @param [Fixnum] phase the phase index
-      # @param [Array] result the phase result
-      def add(phase, result)
-        @hash[phase] += result
-      end
-
-      # Coalesces the query results
-      # @return [Array] the query results, coalesced according to the
-      #   phase configuration
-      def report
-        if @keep_count > 1
-          @hash.to_a.sort.map {|(num, results)| results }
-        else
-          @hash[@hash.keys.first]
-        end
-      end
-
-      private
-      def create_results_hash(query)
-        # When the query is empty, only bucket/key pairs are returned,
-        # but implicitly in phase 0.
-        return { 0 => [] } if query.empty?
-
-        # Pre-populate the hash with empty results for kept phases.
-        # Additionally, the last phase is always implictly kept, even
-        # when keep is false.
-        query.inject({}) do |hash, phase|
-          if phase.keep || query[-1] == phase
-            hash[query.index(phase)] = []
-          end
-          hash
-        end
-      end
-    end
-  end
-end
+module Riak
+  class MapReduce
+    # @api private
+    # Collects and normalizes results from MapReduce requests
+    class Results
+      # Creates a new result collector
+      # @param [MapReduce] mr the MapReduce query
+      def initialize(mr)
+        @keep_count = mr.query.select {|p| p.keep }.size
+        @hash = create_results_hash(mr.query)
+      end
+
+      # Adds a new result to the collector
+      # @param [Fixnum] phase the phase index
+      # @param [Array] result the phase result
+      def add(phase, result)
+        @hash[phase] += result
+      end
+
+      # Coalesces the query results
+      # @return [Array] the query results, coalesced according to the
+      #   phase configuration
+      def report
+        if @keep_count > 1
+          @hash.to_a.sort.map {|(num, results)| results }
+        else
+          @hash[@hash.keys.first]
+        end
+      end
+
+      private
+      def create_results_hash(query)
+        # When the query is empty, only bucket/key pairs are returned,
+        # but implicitly in phase 0.
+        return { 0 => [] } if query.empty?
+
+        # Pre-populate the hash with empty results for kept phases.
+        # Additionally, the last phase is always implictly kept, even
+        # when keep is false.
+        query.inject({}) do |hash, phase|
+          if phase.keep || query[-1] == phase
+            hash[query.index(phase)] = []
+          end
+          hash
+        end
+      end
+    end
+  end
+end

data/lib/riak/map_reduce_error.rb

@@ -1,7 +1,7 @@
-require 'riak/util/translation'
-
-module Riak
-  # Raised when an error occurred in the Javascript map-reduce chain.
-  # The message will be the body of the JSON error response.
-  class MapReduceError < StandardError; end
-end
+require 'riak/util/translation'
+
+module Riak
+  # Raised when an error occurred in the Javascript map-reduce chain.
+  # The message will be the body of the JSON error response.
+  class MapReduceError < StandardError; end
+end

data/lib/riak/multiget.rb

@@ -1,122 +1,122 @@
-require 'riak/client'
-require 'riak/bucket'
-
-module Riak
-  # Coordinates a parallel fetch operation for multiple values.
-  class Multiget
-    include Util::Translation
-
-    # @return [Riak::Client] the associated client
-    attr_reader :client
-
-    # @return [Array<Bucket, String>] fetch_list an {Array} of {Bucket} and {String} keys to fetch
-    attr_reader :fetch_list
-
-    # @return [Hash<fetch_list_entry, RObject] result_hash a {Hash} of {Bucket} and {String} key pairs to {RObject} instances
-    attr_accessor :result_hash
-
-    # @return [Boolean] finished if the fetch operation has completed
-    attr_reader :finished
-
-    # @return [Integer] The number of threads to use
-    attr_accessor :thread_count
-
-    # Perform a Riak Multiget operation.
-    # @param [Client] client the {Riak::Client} that will perform the multiget
-    # @param [Array<Bucket, String>] fetch_list an {Array} of {Bucket} and {String} keys to fetch
-    # @return [Hash<fetch_list_entry, RObject] result_hash a {Hash} of {Bucket} and {String} key pairs to {RObject} instances
-    def self.get_all(client, fetch_list)
-      multi = new client, fetch_list
-      multi.fetch
-      multi.results
-    end
-
-    # Create a Riak Multiget operation.
-    # @param [Client] client the {Riak::Client} that will perform the multiget
-    # @param [Array<Bucket, String>] fetch_list an {Array} of {Bucket} and {String} keys to fetch
-    def initialize(client, fetch_list)
-      raise ArgumentError, t('client_type', :client => client.inspect) unless client.is_a? Riak::Client
-      raise ArgumentError, t('array_type', :array => fetch_list.inspect) unless fetch_list.is_a? Array
-
-      validate_fetch_list fetch_list
-      @client, @fetch_list = client, fetch_list.uniq
-      self.result_hash = Hash.new
-      @finished = false
-      self.thread_count = client.multiget_threads
-    end
-
-    # Starts the parallelized fetch operation
-    # @raise [ArgumentError] when a non-positive-Integer count is given
-    def fetch
-      queue = fetch_list.dup
-      queue_mutex = Mutex.new
-      result_mutex = Mutex.new
-
-      unless thread_count.is_a?(Integer) && thread_count > 0
-        raise ArgumentError, t("invalid_multiget_thread_count")
-      end
-
-      @threads = 1.upto(thread_count).map do |_node|
-        Thread.new do
-          loop do
-            pair = queue_mutex.synchronize do
-              queue.shift
-            end
-
-            break if pair.nil?
-
-            found = attempt_fetch(*pair)
-            result_mutex.synchronize do
-              result_hash[pair] = found
-            end
-          end
-        end
-      end
-    end
-
-    def results
-      wait_for_finish
-      result_hash
-    end
-
-    def finished?
-      set_finished_for_thread_liveness
-      finished
-    end
-
-    def wait_for_finish
-      return if finished?
-      @threads.each {|t| t.join }
-      @finished = true
-    end
-
-    private
-
-    def attempt_fetch(bucket, key)
-      bucket[key]
-    rescue Riak::FailedRequest => e
-      raise e unless e.not_found?
-      nil
-    end
-
-    def set_finished_for_thread_liveness
-      return if @finished # already done
-
-      all_dead = @threads.none? {|t| t.alive? }
-      return unless all_dead # still working
-
-      @finished = true
-      return
-    end
-
-    def validate_fetch_list(fetch_list)
-      return unless erroneous = fetch_list.detect do |e|
-        bucket, key = e
-        next true unless bucket.is_a? Bucket
-        next true unless key.is_a? String
-      end
-
-      raise ArgumentError, t('fetch_list_type', :problem => erroneous)
-    end
-  end
-end
+require 'riak/client'
+require 'riak/bucket'
+
+module Riak
+  # Coordinates a parallel fetch operation for multiple values.
+  class Multiget
+    include Util::Translation
+
+    # @return [Riak::Client] the associated client
+    attr_reader :client
+
+    # @return [Array<Bucket, String>] fetch_list an {Array} of {Bucket} and {String} keys to fetch
+    attr_reader :fetch_list
+
+    # @return [Hash<fetch_list_entry, RObject] result_hash a {Hash} of {Bucket} and {String} key pairs to {RObject} instances
+    attr_accessor :result_hash
+
+    # @return [Boolean] finished if the fetch operation has completed
+    attr_reader :finished
+
+    # @return [Integer] The number of threads to use
+    attr_accessor :thread_count
+
+    # Perform a Riak Multiget operation.
+    # @param [Client] client the {Riak::Client} that will perform the multiget
+    # @param [Array<Bucket, String>] fetch_list an {Array} of {Bucket} and {String} keys to fetch
+    # @return [Hash<fetch_list_entry, RObject] result_hash a {Hash} of {Bucket} and {String} key pairs to {RObject} instances
+    def self.get_all(client, fetch_list)
+      multi = new client, fetch_list
+      multi.fetch
+      multi.results
+    end
+
+    # Create a Riak Multiget operation.
+    # @param [Client] client the {Riak::Client} that will perform the multiget
+    # @param [Array<Bucket, String>] fetch_list an {Array} of {Bucket} and {String} keys to fetch
+    def initialize(client, fetch_list)
+      raise ArgumentError, t('client_type', :client => client.inspect) unless client.is_a? Riak::Client
+      raise ArgumentError, t('array_type', :array => fetch_list.inspect) unless fetch_list.is_a? Array
+
+      validate_fetch_list fetch_list
+      @client, @fetch_list = client, fetch_list.uniq
+      self.result_hash = Hash.new
+      @finished = false
+      self.thread_count = client.multiget_threads
+    end
+
+    # Starts the parallelized fetch operation
+    # @raise [ArgumentError] when a non-positive-Integer count is given
+    def fetch
+      queue = fetch_list.dup
+      queue_mutex = Mutex.new
+      result_mutex = Mutex.new
+
+      unless thread_count.is_a?(Integer) && thread_count > 0
+        raise ArgumentError, t("invalid_multiget_thread_count")
+      end
+
+      @threads = 1.upto(thread_count).map do |_node|
+        Thread.new do
+          loop do
+            pair = queue_mutex.synchronize do
+              queue.shift
+            end
+
+            break if pair.nil?
+
+            found = attempt_fetch(*pair)
+            result_mutex.synchronize do
+              result_hash[pair] = found
+            end
+          end
+        end
+      end
+    end
+
+    def results
+      wait_for_finish
+      result_hash
+    end
+
+    def finished?
+      set_finished_for_thread_liveness
+      finished
+    end
+
+    def wait_for_finish
+      return if finished?
+      @threads.each {|t| t.join }
+      @finished = true
+    end
+
+    private
+
+    def attempt_fetch(bucket, key)
+      bucket[key]
+    rescue Riak::FailedRequest => e
+      raise e unless e.not_found?
+      nil
+    end
+
+    def set_finished_for_thread_liveness
+      return if @finished # already done
+
+      all_dead = @threads.none? {|t| t.alive? }
+      return unless all_dead # still working
+
+      @finished = true
+      return
+    end
+
+    def validate_fetch_list(fetch_list)
+      return unless erroneous = fetch_list.detect do |e|
+        bucket, key = e
+        next true unless bucket.is_a? Bucket
+        next true unless key.is_a? String
+      end
+
+      raise ArgumentError, t('fetch_list_type', :problem => erroneous)
+    end
+  end
+end