Class: Riak::RObject

Inherits:

Object

• Object
• Riak::RObject

show all

Extended by:

Util::Escape, Util::Translation

Includes:

Util::Escape, Util::Translation

Defined in:

lib/riak/robject.rb

Overview

Instance Attribute Summary (collapse)

• - (Bucket) bucket

  The bucket in which this object is contained.

• - (Object) conflict writeonly

  Sets the attribute conflict.

• - (String) content_type

  The MIME content type of the object.

• - (String) etag

  The ETag header from the most recent HTTP response, useful for caching and reloading.

• - (Hash<Set>) indexes

  A hash of secondary indexes, where the key is the index name and the value is a Set of index entries for that index.

• - (String) key

  The key of this object within its bucket.

• - (Time) last_modified

  The Last-Modified header from the most recent HTTP response, useful for caching and reloading.

• - (Set<Link>) links

  A Set of Link objects for relationships between this object and other resources.

• - (Hash) meta

  A hash of any X-Riak-Meta-* headers that were in the HTTP response, keyed on the trailing portion.

• - (Boolean) prevent_stale_writes

  Whether to attempt to prevent stale writes using conditional PUT semantics, If-None-Match: * or If-Match: #etag.

• - (Array<RObject>, Array<self>) siblings

  Returns sibling objects when in conflict.

• - (String) vclock (also: #vector_clock)

  The Riak vector clock for the object.

Class Method Summary (collapse)

• + (Array<RObject>) load_from_mapreduce(client, response)

  Loads a list of RObjects that were emitted from a MapReduce query.

• + (Object) on_conflict {|robject| ... }

  Defines a callback to be invoked when there is conflict.

• + (Array<Proc>) on_conflict_hooks

  The list of registered conflict callbacks.

Instance Method Summary (collapse)

• - (RObject) attempt_conflict_resolution

  Attempts to resolve conflict using the registered conflict callbacks.

• - (true, false) conflict?

  Whether this object has conflicting sibling objects (divergent vclocks).

• - (Object) data

  The unmarshaled form of #raw_data stored in riak at this object's key.

• - (Object) data=(new_data)

  The object stored.

• - (Object) delete(options = {})

  Delete the object from Riak and freeze this instance.

• - (Object) deserialize(body)

  Deserializes the internal object data from a Riak response.

• - (RObject) initialize(bucket, key = nil) { ... } constructor

  Create a new object manually.

• - (String) inspect

  A representation suitable for IRB and debugging output.

• - (RObject) load_from_mapreduce(response)

  Load object data from a map/reduce response item.

• - (String) raw_data

  Raw data stored in riak for this object's key.

• - (String) raw_data=(new_raw_data)

  The data stored.

• - (Riak::RObject) reload(options = {}) (also: #fetch)

  Reload the object from Riak.

• - (Object) serialize(payload)

  Serializes the internal object data for sending to Riak.

• - (Riak::RObject) store(options = {})

  Store the object in Riak.

• - (Object) to_link(tag)

  Converts the object to a link suitable for linking other objects to it.

• - (Object) url

  Generates a URL representing the object according to the client, bucket and key.

• - (Object) walk(*params)

  Walks links from this object to other objects in Riak.

Methods included from Util::Escape

escape, maybe_escape, maybe_unescape, unescape

Methods included from Util::Translation

i18n_scope, t

103
104
105
106
107
108

# File 'lib/riak/robject.rb', line 103

def initialize(bucket, key=nil)
  @bucket, @key = bucket, key
  @links, @meta = Set.new, {}
  @indexes = Hash.new {|h,k| h[k] = Set.new }
  yield self if block_given?
end

21
22
23

# File 'lib/riak/robject.rb', line 21

def bucket
  @bucket
end

209
210
211

# File 'lib/riak/robject.rb', line 209

def conflict=(value)
  @conflict = value
end

27
28
29

# File 'lib/riak/robject.rb', line 27

def content_type
  @content_type
end

36
37
38

# File 'lib/riak/robject.rb', line 36

def etag
  @etag
end

47
48
49

# File 'lib/riak/robject.rb', line 47

def indexes
  @indexes
end

24
25
26

# File 'lib/riak/robject.rb', line 24

def key
  @key
end

39
40
41

# File 'lib/riak/robject.rb', line 39

def last_modified
  @last_modified
end

33
34
35

# File 'lib/riak/robject.rb', line 33

def links
  @links
end

42
43
44

# File 'lib/riak/robject.rb', line 42

def meta
  @meta
end

51
52
53

# File 'lib/riak/robject.rb', line 51

def prevent_stale_writes
  @prevent_stale_writes
end

215
216
217
218

# File 'lib/riak/robject.rb', line 215

def siblings
  return [self] unless conflict?
  @siblings
end

30
31
32

# File 'lib/riak/robject.rb', line 30

def vclock
  @vclock
end

92
93
94
95
96

# File 'lib/riak/robject.rb', line 92

def self.load_from_mapreduce(client, response)
  response.map do |item|
    RObject.new(client[unescape(item['bucket'])], unescape(item['key'])).load_from_mapreduce(item)
  end
end

63
64
65

# File 'lib/riak/robject.rb', line 63

def self.on_conflict(&conflict_hook)
  on_conflict_hooks << conflict_hook
end

68
69
70

# File 'lib/riak/robject.rb', line 68

def self.on_conflict_hooks
  @on_conflict_hooks ||= []
end

76
77
78
79
80
81
82
83
84
85

# File 'lib/riak/robject.rb', line 76

def attempt_conflict_resolution
  return self unless conflict?

  self.class.on_conflict_hooks.each do |hook|
    result = hook.call(self)
    return result if result.is_a?(RObject)
  end

  self
end

221
222
223

# File 'lib/riak/robject.rb', line 221

def conflict?
  @conflict.present?
end

133
134
135
136
137
138
139
140

# File 'lib/riak/robject.rb', line 133

def data
  if @raw_data && !@data
    raw = @raw_data.respond_to?(:read) ? @raw_data.read : @raw_data
    @data = deserialize(raw)
    @raw_data = nil
  end
  @data
end

144
145
146
147
148
149
150
151

# File 'lib/riak/robject.rb', line 144

def data=(new_data)
  if new_data.respond_to?(:read)
    raise ArgumentError.new(t("invalid_io_object"))
  end

  @raw_data = nil
  @data = new_data
end

202
203
204
205
206
207

# File 'lib/riak/robject.rb', line 202

def delete(options={})
  return if key.blank?
  options[:vclock] = vclock if vclock
  @bucket.delete(key, options)
  freeze
end

245
246
247

# File 'lib/riak/robject.rb', line 245

def deserialize(body)
  Serializers.deserialize(@content_type, body)
end

250
251
252
253
254
255
256
257

# File 'lib/riak/robject.rb', line 250

def inspect
  body = if @data || Serializers[content_type]
           data.inspect
         else
           @raw_data && "(#{@raw_data.size} bytes)"
         end
  "#<#{self.class.name} {#{bucket.name}#{"," + @key if @key}} [#{@content_type}]:#{body}>"
end

115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130

# File 'lib/riak/robject.rb', line 115

def load_from_mapreduce(response)
  self.vclock = response['vclock']
  if response['values'].size == 1
    value = response['values'].first
    load_map_reduce_value(value)
  else
    @conflict = true
    @siblings = response['values'].map do |v|
      RObject.new(self.bucket, self.key) do |robj|
        robj.vclock = self.vclock
        robj.load_map_reduce_value(v)
      end
    end
  end
  self
end

154
155
156
157
158
159
160

# File 'lib/riak/robject.rb', line 154

def raw_data
  if @data && !@raw_data
    @raw_data = serialize(@data)
    @data = nil
  end
  @raw_data
end

164
165
166
167

# File 'lib/riak/robject.rb', line 164

def raw_data=(new_raw_data)
  @data = nil
  @raw_data = new_raw_data
end

190
191
192
193
194
195

# File 'lib/riak/robject.rb', line 190

def reload(options={})
  force = options.delete(:force)
  return self unless @key && (@vclock || force)
  self.etag = self.last_modified = nil if force
  bucket.client.reload_object(self, options)
end

234
235
236

# File 'lib/riak/robject.rb', line 234

def serialize(payload)
  Serializers.serialize(@content_type, payload)
end

177
178
179
180
181

# File 'lib/riak/robject.rb', line 177

def store(options={})
  raise ArgumentError, t("content_type_undefined") unless @content_type.present?
  @bucket.client.store_object(self, options)
  self
end

269
270
271

# File 'lib/riak/robject.rb', line 269

def to_link(tag)
  Link.new(@bucket.name, @key, tag)
end

276
277
278
279
280

# File 'lib/riak/robject.rb', line 276

def url
  segments = [ @bucket.client.http_paths[:prefix], escape(@bucket.name)]
  segments << escape(@key) if @key
  @bucket.client.http.path(*segments).to_s
end

261
262
263
264

# File 'lib/riak/robject.rb', line 261

def walk(*params)
  specs = WalkSpec.normalize(*params)
  @bucket.client.link_walk(self, specs)
end