Class: Moneta::Adapters::Couch
- Inherits:
-
Object
- Object
- Moneta::Adapters::Couch
- Includes:
- Defaults
- Defined in:
- lib/moneta/adapters/couch.rb
Overview
CouchDB backend
You can store hashes directly using this adapter.
Defined Under Namespace
Classes: HTTPError
Instance Attribute Summary collapse
- #backend ⇒ Object readonly
Instance Method Summary collapse
-
#clear(options = {}) ⇒ void
Clear all keys in this store.
-
#create(key, value, options = {}) ⇒ Boolean
Atomically sets a key to value if it’s not set.
-
#delete(key, options = {}) ⇒ Object
Delete the key from the store and return the current value.
-
#each_key ⇒ Object
Calls block once for each key in store, passing the key as a parameter.
-
#initialize(options = {}) ⇒ Couch
constructor
A new instance of Couch.
-
#key?(key, options = {}) ⇒ Boolean
Exists the value with key.
-
#load(key, options = {}) ⇒ Object
Fetch value with key.
-
#merge!(pairs, options = {}) ⇒ Object
Stores the pairs in the key-value store, and returns itself.
-
#slice(*keys, **options) ⇒ <(Object, Object)>
Returns a collection of key-value pairs corresponding to those supplied keys which are present in the key-value store, and their associated values.
-
#store(key, value, options = {}) ⇒ Object
Store value with key.
-
#values_at(*keys, **options) ⇒ Array<Object, nil>
Returns an array containing the values associated with the given keys, in the same order as the supplied keys.
Methods included from Defaults
#[], #[]=, #close, #decrement, #features, #fetch, #fetch_values, included, #increment, #supports?, #update
Methods included from OptionSupport
#expires, #prefix, #raw, #with
Constructor Details
#initialize(options = {}) ⇒ Couch
Returns a new instance of Couch.
46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 |
# File 'lib/moneta/adapters/couch.rb', line 46 def initialize( = {}) @value_field = .delete(:value_field) || 'value' @type_field = .delete(:type_field) || 'type' @backend = .delete(:backend) || begin host = .delete(:host) || '127.0.0.1' port = .delete(:port) || 5984 db = .delete(:db) || 'moneta' scheme = .delete(:scheme) || 'http' block = if faraday_adapter = .delete(:adapter) proc { |faraday| faraday.adapter(faraday_adapter) } end ::Faraday.new("#{scheme}://#{host}:#{port}/#{db}", , &block) end @rev_cache = Moneta.build do use :Lock adapter :LRUHash end create_db end |
Instance Attribute Details
#backend ⇒ Object (readonly)
31 32 33 |
# File 'lib/moneta/adapters/couch.rb', line 31 def backend @backend end |
Instance Method Details
#clear(options = {}) ⇒ void
This method returns an undefined value.
Clear all keys in this store
138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 |
# File 'lib/moneta/adapters/couch.rb', line 138 def clear( = {}) loop do docs = all_docs(limit: 10_000) break if docs['rows'].empty? deletions = docs['rows'].map do |row| { _id: row['id'], _rev: row['value']['rev'], _deleted: true } end bulk_docs(deletions, full_commit: [:full_commit]) end # Compact the database unless told not to if [:compact] post('_compact', expect: 202) # Performance won't be great while compaction is happening, so by default we wait for it if [:await_compact] loop do db_info = get('', expect: 200) break unless db_info['compact_running'] # wait before checking again sleep 1 end end end self end |
#create(key, value, options = {}) ⇒ Boolean
Not every Moneta store implements this method, a NotImplementedError is raised if it is not supported.
Atomically sets a key to value if it’s not set.
169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 |
# File 'lib/moneta/adapters/couch.rb', line 169 def create(key, value, = {}) cache_rev = [:cache_rev] != false doc = value_to_doc(value, nil) response = put(key, doc, cache_rev: cache_rev, returns: :response) case response.status when 201 true when 409 false else raise HTTPError.new(response.status, :put, @backend.create_url(key)) end rescue HTTPError tries ||= 0 (tries += 1) < 10 ? retry : raise end |
#delete(key, options = {}) ⇒ Object
Delete the key from the store and return the current value
111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 |
# File 'lib/moneta/adapters/couch.rb', line 111 def delete(key, = {}) get_response = get(key, returns: :response) if get_response.success? value = body_to_value(get_response.body) existing_rev = parse_rev(get_response) query = { rev: existing_rev } query[:batch] = 'ok' if [:batch] request(:delete, key, headers: full_commit_header([:full_commit]), query: query, expect: [:batch] ? 202 : 200) delete_cached_rev(key) value end rescue HTTPError tries ||= 0 (tries += 1) < 10 ? retry : raise end |
#each_key ⇒ Enumerator #each_key {|key| ... } ⇒ self
Not every Moneta store implements this method, a NotImplementedError is raised if it is not supported.
Calls block once for each key in store, passing the key as a parameter. If no block is given, an enumerator is returned instead.
187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 |
# File 'lib/moneta/adapters/couch.rb', line 187 def each_key return enum_for(:each_key) unless block_given? skip = 0 limit = 1000 loop do docs = all_docs(limit: limit, skip: skip) break if docs['rows'].empty? skip += docs['rows'].length docs['rows'].each do |row| key = row['id'] @rev_cache[key] = row['value']['rev'] yield key end end self end |
#key?(key, options = {}) ⇒ Boolean
Exists the value with key
69 70 71 72 |
# File 'lib/moneta/adapters/couch.rb', line 69 def key?(key, = {}) cache_rev = [:cache_rev] != false head(key, cache_rev: cache_rev) end |
#load(key, options = {}) ⇒ Object
Fetch value with key. Return nil if the key doesn’t exist
76 77 78 79 80 |
# File 'lib/moneta/adapters/couch.rb', line 76 def load(key, = {}) cache_rev = [:cache_rev] != false doc = get(key, cache_rev: cache_rev) doc ? doc_to_value(doc) : nil end |
#merge!(pairs, options = {}) ⇒ self #merge!(pairs, options = {}) {|key, old_value, new_value| ... } ⇒ self
Stores the pairs in the key-value store, and returns itself. When a block is provided, it will be called before overwriting any existing values with the key, old value and supplied value, and the return value of the block will be used in place of the supplied value.
225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 |
# File 'lib/moneta/adapters/couch.rb', line 225 def merge!(pairs, = {}) keys = pairs.map { |key, _| key }.to_a cache_revs(*keys.reject { |key| @rev_cache[key] }) if block_given? existing = Hash[slice(*keys, **)] pairs = pairs.map do |key, new_value| [ key, if existing.key?(key) yield(key, existing[key], new_value) else new_value end ] end end docs = pairs.map { |key, value| value_to_doc(value, @rev_cache[key], key) }.to_a results = bulk_docs(docs, full_commit: [:full_commit], returns: :doc) retries = results.each_with_object([]) do |row, retries| ok, id = row.values_at('ok', 'id') if ok @rev_cache[id] = row['rev'] elsif row['error'] == 'conflict' delete_cached_rev(id) retries << pairs.find { |key,| key == id } else raise "Unrecognised response: #{row}" end end # Recursive call with all conflicts if retries.empty? self else merge!(retries, ) end end |
#slice(*keys, **options) ⇒ <(Object, Object)>
The keys in the return value may be the same objects that were supplied (i.e. Object#equal?), or may simply be equal (i.e. Object#==).
Some adapters may implement this method atomically. The default implmentation uses #values_at.
Returns a collection of key-value pairs corresponding to those supplied keys which are present in the key-value store, and their associated values. Only those keys present in the store will have pairs in the return value. The return value can be any enumerable object that yields pairs, so it could be a hash, but needn’t be.
212 213 214 215 216 217 218 |
# File 'lib/moneta/adapters/couch.rb', line 212 def slice(*keys, **) docs = all_docs(keys: keys, include_docs: true) docs["rows"].map do |row| next unless doc = row['doc'] [row['id'], doc_to_value(doc)] end.compact end |
#store(key, value, options = {}) ⇒ Object
Store value with key
91 92 93 94 95 96 97 98 99 100 101 |
# File 'lib/moneta/adapters/couch.rb', line 91 def store(key, value, = {}) put(key, value_to_doc(value, rev(key)), headers: full_commit_header([:full_commit]), query: [:batch] ? { batch: 'ok' } : {}, cache_rev: [:cache_rev] != false, expect: [:batch] ? 202 : 201) value rescue HTTPError tries ||= 0 (tries += 1) < 10 ? retry : raise end |
#values_at(*keys, **options) ⇒ Array<Object, nil>
Some adapters may implement this method atomically, but the default implementation simply makes repeated calls to #load.
Returns an array containing the values associated with the given keys, in the same order as the supplied keys. If a key is not present in the key-value-store, nil is returned in its place.
206 207 208 209 |
# File 'lib/moneta/adapters/couch.rb', line 206 def values_at(*keys, **) hash = Hash[slice(*keys, **)] keys.map { |key| hash[key] } end |