Class: PEROBS::Store

Inherits:
Object
  • Object
show all
Defined in:
lib/perobs/Store.rb

Overview

PEROBS::Store is a persistent storage system for Ruby objects. Regular Ruby objects are transparently stored in a back-end storage and retrieved when needed. It features a garbage collector that removes all objects that are no longer in use. A build-in cache keeps access latencies to recently used objects low and lazily flushes modified objects into the persistend back-end. The default back-end is a filesystem based database. Alternatively, an Amazon DynamoDB can be used as well. Adding support for other key/value stores is fairly trivial to do. See PEROBS::DynamoDB for an example

Persistent objects must be defined by deriving your class from PEROBS::Object, PERBOS::Array or PEROBS::Hash. Only instance variables that are declared via po_attr will be persistent. It is recommended that references to other objects are all going to persistent objects again. TO create a new persistent object you must call Store.new(). Don’t use the constructors of persistent classes directly. Store.new() will return a proxy or delegator object that can be used like the actual object. By using delegators we can disconnect the actual object from the delegator handle.

require ‘perobs’

class Person < PEROBS::Object

po_attr :name, :mother, :father, :kids

def initialize(cf, name)
  super(cf)
  attr_init(:name, name)
  attr_init(:kids, @store.new(PEROBS::Array))
end

def to_s
  "#{@name} is the child of #{self.mother ? self.mother.name : 'unknown'} " +
  "and #{self.father ? self.father.name : 'unknown'}.
end

end

store = PEROBS::Store.new(‘family’) store = joe = store.new(Person, ‘Joe’) store = jane = store.new(Person, ‘Jane’) jim = store.new(Person, ‘Jim’) jim.father = joe joe.kids << jim jim.mother = jane jane.kids << jim store.sync

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(data_base, options = {}) ⇒ Store

Create a new Store.

Parameters:

  • data_base (String) —

    the name of the database

  • options (Hash) (defaults to: {}) —

    various options to affect the operation of the database. Currently the following options are supported: :engine : The class that provides the back-end storage

    engine. By default FlatFileDB is used. A user
can provide it's own storage engine that must
conform to the same API exposed by FlatFileDB.

    :cache_bits : the number of bits used for cache indexing. The

    cache will hold 2 to the power of bits number of
objects. We have separate caches for reading and
writing. The default value is 16. It probably makes
little sense to use much larger numbers than that.

    :serializer : select the format used to serialize the data. There

    are 3 different options:
:marshal : Native Ruby serializer. Fastest option
that can handle most Ruby data types. Big
disadvantate is the stability of the format. Data
written with one Ruby version may not be readable
with another version.
:json : About half as fast as marshal, but the
format is rock solid and portable between
languages. It only supports basic Ruby data types
like String, Fixnum, Float, Array, Hash. This is
the default option.
:yaml : Can also handle most Ruby data types and is
portable between Ruby versions (1.9 and later).
Unfortunately, it is 10x slower than marshal.



128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
 
# File 'lib/perobs/Store.rb', line 128

def initialize(data_base, options = {})
  # Create a backing store handler
  @db = (options[:engine] || BTreeDB).new(data_base, options)
  @db.open
  # Create a map that can translate classes to numerical IDs and vice
  # versa.
  @class_map = ClassMap.new(@db)

  # List of PEROBS objects that are currently available as Ruby objects
  # hashed by their ID.
  @in_memory_objects = {}

  # This objects keeps some counters of interest.
  @stats = Statistics.new

  # The Cache reduces read and write latencies by keeping a subset of the
  # objects in memory.
  @cache = Cache.new(options[:cache_bits] || 16)

  # The named (global) objects IDs hashed by their name
  unless (@root_objects = object_by_id(0))
    PEROBS.log.debug "Initializing the PEROBS store"
    # The root object hash always has the object ID 0.
    @root_objects = _construct_po(Hash, 0)
    # Mark the root_objects object as modified.
    @cache.cache_write(@root_objects)
  end
  unless @root_objects.is_a?(Hash)
    PEROBS.log.fatal "Database corrupted: Root objects must be a Hash " +
      "but is a #{@root_objects.class}"
  end
end

Instance Attribute Details

#cache ⇒ Object (readonly)

Returns the value of attribute cache.



98
99
100
 
# File 'lib/perobs/Store.rb', line 98

def cache
  @cache
end

#class_map ⇒ Object (readonly)

Returns the value of attribute class_map.



98
99
100
 
# File 'lib/perobs/Store.rb', line 98

def class_map
  @class_map
end

#db ⇒ Object (readonly)

Returns the value of attribute db.



98
99
100
 
# File 'lib/perobs/Store.rb', line 98

def db
  @db
end

Instance Method Details

#[](name) ⇒ Object

Return the object with the provided name.

Parameters:

  • name (Symbol) —

    A Symbol specifies the name of the object to be returned.

Returns:

  • The requested object or nil if it doesn’t exist.



274
275
276
277
278
279
 
# File 'lib/perobs/Store.rb', line 274

def [](name)
  # Return nil if there is no object with that name.
  return nil unless (id = @root_objects[name])

  POXReference.new(self, id)
end

#[]=(name, obj) ⇒ PEROBS::Object

Store the provided object under the given name. Use this to make the object a root or top-level object (think global variable). Each store should have at least one root object. Objects that are not directly or indirectly reachable via any of the root objects are no longer accessible and will be garbage collected.

Parameters:

  • name (Symbol) —

    The name to use.

  • obj (PEROBS::Object) —

    The object to store

Returns:



246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
 
# File 'lib/perobs/Store.rb', line 246

def []=(name, obj)
  # If the passed object is nil, we delete the entry if it exists.
  if obj.nil?
    @root_objects.delete(name)
    return nil
  end

  # We only allow derivatives of PEROBS::Object to be stored in the
  # store.
  unless obj.is_a?(ObjectBase)
    PEROBS.log.fatal 'Object must be of class PEROBS::Object but ' +
      "is of class #{obj.class}"
  end

  unless obj.store == self
    PEROBS.log.fatal 'The object does not belong to this store.'
  end

  # Store the name and mark the name list as modified.
  @root_objects[name] = obj._id

  obj
end

#_collect(id, ignore_errors = false) ⇒ Object

Remove the object from the in-memory list. This is an internal method and should never be called from user code. It will be called from a finalizer, so many restrictions apply!

Parameters:

  • id (Fixnum or Bignum) —

    Object ID of object to remove from the list



452
453
454
 
# File 'lib/perobs/Store.rb', line 452

def _collect(id, ignore_errors = false)
  @in_memory_objects.delete(id)
end

#_construct_po(klass, id, *args) ⇒ BasicObject

For library internal use only! This method will create a new PEROBS object.

Parameters:

  • klass (BasicObject) —

    Class of the object to create

  • id (Fixnum, Bignum) —

    Requested object ID

  • args (Array) —

    Arguments to pass to the object constructor.

Returns:

  • (BasicObject) —

    Newly constructed PEROBS object



227
228
229
 
# File 'lib/perobs/Store.rb', line 227

def _construct_po(klass, id, *args)
  klass.new(Handle.new(self, id), *args)
end

#_new_id ⇒ Fixnum or Bignum

Internal method. Don’t use this outside of this library! Generate a new unique ID that is not used by any other object. It uses random numbers between 0 and 2**64 - 1.

Returns:

  • (Fixnum or Bignum) 


426
427
428
429
430
431
432
433
434
435
 
# File 'lib/perobs/Store.rb', line 426

def _new_id
  begin
    # Generate a random number. It's recommended to not store more than
    # 2**62 objects in the same store.
    id = rand(2**64)
    # Ensure that we don't have already another object with this ID.
  end while @in_memory_objects.include?(id) || @db.include?(id)

  id
end

#_register_in_memory(obj, id) ⇒ Object

Internal method. Don’t use this outside of this library! Add the new object to the in-memory list. We only store a weak reference to the object so it can be garbage collected. When this happens the object finalizer is triggered and calls _forget() to remove the object from this hash again.

Parameters:

  • obj (BasicObject) —

    Object to register

  • id (Fixnum or Bignum) —

    object ID



444
445
446
 
# File 'lib/perobs/Store.rb', line 444

def _register_in_memory(obj, id)
  @in_memory_objects[id] = WeakRef.new(obj)
end

#check(repair = false) ⇒ Fixnum

This method can be used to check the database and optionally repair it. The repair is a pure structural repair. It cannot ensure that the stored data is still correct. E. g. if a reference to a non-existing or unreadable object is found, the reference will simply be deleted.

Parameters:

  • repair (TrueClass/FalseClass) (defaults to: false) —

    true if a repair attempt should be made.

Returns:

  • (Fixnum) —

    The number of references to bad objects found.



346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
 
# File 'lib/perobs/Store.rb', line 346

def check(repair = false)
  # All objects must have in-db version.
  sync
  # Run basic consistency checks first.
  @db.check_db(repair)

  # We will use the mark to mark all objects that we have checked already.
  # Before we start, we need to clear all marks.
  @db.clear_marks

  errors = 0
  objects = 0
  @root_objects.each do |name, id|
    objects += 1
    errors += check_object(id, repair)
  end
  if errors > 0
    PEROBS.log.warn "#{errors} errors found in #{objects} objects"
  else
    PEROBS.log.debug "No errors found"
  end
  # Delete all broken root objects.
  @root_objects.delete_if { |name, id| !@db.check(id, repair) }

  # Ensure that any fixes are written into the DB.
  sync

  errors
end

#copy(dir, options = {}) ⇒ Object

Copy the store content into a new Store. The arguments are identical to Store.new().

Parameters:

  • options (Hash) (defaults to: {}) —

    various options to affect the operation of the



164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
 
# File 'lib/perobs/Store.rb', line 164

def copy(dir, options = {})
  # Make sure all objects are persisted.
  sync

  # Create a new store with the specified directory and options.
  new_db = Store.new(dir, options)
  # Clear the cache.
  new_db.sync
  # Copy all objects of the existing store to the new store.
  i = 0
  each do |ref_obj|
    obj = ref_obj._referenced_object
    obj._transfer(new_db)
    obj._sync
    i += 1
  end
  PEROBS.log.debug "Copied #{i} objects into new database at #{dir}"
  # Flush the new store and close it.
  new_db.exit

  true
end

#delete_store ⇒ Object

Delete the entire store. The store is no longer usable after this method was called.



233
234
235
236
 
# File 'lib/perobs/Store.rb', line 233

def delete_store
  @db.delete_database
  @db = @class_map = @cache = @root_objects = nil
end

#each ⇒ Object

Calls the given block once for each object, passing that object as a parameter.



395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
 
# File 'lib/perobs/Store.rb', line 395

def each
  @db.clear_marks
  # Start with the object 0 and the indexes of the root objects. Push them
  # onto the work stack.
  stack = [ 0 ] + @root_objects.values
  while !stack.empty?
    # Get an object index from the stack.
    unless (obj = object_by_id(id = stack.pop))
      PEROBS.log.fatal "Database is corrupted. Object with ID #{id} " +
        "not found."
    end
    # Mark the object so it will never be pushed to the stack again.
    @db.mark(id)
    yield(obj.myself) if block_given?
    # Push the IDs of all unmarked referenced objects onto the stack
    obj._referenced_object_ids.each do |r_id|
      stack << r_id unless @db.is_marked?(r_id)
    end
  end
end

#exit ⇒ Object

Close the store and ensure that all in-memory objects are written out to the storage backend. The Store object is no longer usable after this method was called.



191
192
193
194
195
196
197
198
199
 
# File 'lib/perobs/Store.rb', line 191

def exit
  if @cache.in_transaction?
    PEROBS.log.fatal 'You cannot call exit() during a transaction'
  end
  @cache.flush
  @db.close
  @db = @class_map = @in_memory_objects = @stats = @cache = @root_objects =
    nil
end

#gc ⇒ Fixnum

Discard all objects that are not somehow connected to the root objects from the back-end storage. The garbage collector is not invoked automatically. Depending on your usage pattern, you need to call this method periodically.

Returns:

  • (Fixnum) —

    The number of collected objects



301
302
303
304
305
306
307
308
 
# File 'lib/perobs/Store.rb', line 301

def gc
  if @cache.in_transaction?
    PEROBS.log.fatal 'You cannot call gc() during a transaction'
  end
  sync
  mark
  sweep
end

#names ⇒ Array of Symbols

Return a list with all the names of the root objects.

Returns:



283
284
285
 
# File 'lib/perobs/Store.rb', line 283

def names
  @root_objects.keys
end

#new(klass, *args) ⇒ POXReference

You need to call this method to create new PEROBS objects that belong to this Store.

Parameters:

  • klass (Class) —

    The class of the object you want to create. This must be a derivative of ObjectBase.

  • args —

    Optional list of other arguments that are passed to the constructor of the specified class.

Returns:

  • (POXReference) —

    A reference to the newly created object.



209
210
211
212
213
214
215
216
217
218
219
 
# File 'lib/perobs/Store.rb', line 209

def new(klass, *args)
  unless klass.is_a?(BasicObject)
    PEROBS.log.fatal "#{klass} is not a BasicObject derivative"
  end

  obj = _construct_po(klass, _new_id, *args)
  # Mark the new object as modified so it gets pushed into the database.
  @cache.cache_write(obj)
  # Return a POXReference proxy for the newly created object.
  obj.myself
end

#object_by_id(id) ⇒ Object

Return the object with the provided ID. This method is not part of the public API and should never be called by outside users. It’s purely intended for internal use.



313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
 
# File 'lib/perobs/Store.rb', line 313

def object_by_id(id)
  if (obj = @in_memory_objects[id])
    # We have the object in memory so we can just return it.
    begin
      return obj.__getobj__
    rescue WeakRef::RefError
      # Due to a race condition the object can still be in the
      # @in_memory_objects list but has been collected already by the Ruby
      # GC. In that case we need to load it again.
    end
  end

  # We don't have the object in memory. Let's find it in the storage.
  if @db.include?(id)
    # Great, object found. Read it into memory and return it.
    obj = ObjectBase::read(self, id)
    # Add the object to the in-memory storage list.
    @cache.cache_read(obj)

    return obj
  end

  # The requested object does not exist. Return nil.
  nil
end

#rename_classes(rename_map) ⇒ Object

Rename classes of objects stored in the data base.

Parameters:

  • rename_map (Hash) —

    Hash that maps the old name to the new name



418
419
420
 
# File 'lib/perobs/Store.rb', line 418

def rename_classes(rename_map)
  @class_map.rename(rename_map)
end

#statistics ⇒ Object

This method returns a Hash with some statistics about this store.



457
458
459
460
461
462
 
# File 'lib/perobs/Store.rb', line 457

def statistics
  @stats.in_memory_objects = @in_memory_objects.length
  @stats.root_objects = @root_objects.length

  @stats
end

#sync ⇒ Object

Flush out all modified objects to disk and shrink the in-memory list if needed.



289
290
291
292
293
294
 
# File 'lib/perobs/Store.rb', line 289

def sync
  if @cache.in_transaction?
    PEROBS.log.fatal 'You cannot call sync() during a transaction'
  end
  @cache.flush
end

#transaction ⇒ Object

This method will execute the provided block as an atomic transaction regarding the manipulation of all objects associated with this Store. In case the execution of the block generates an exception, the transaction is aborted and all PEROBS objects are restored to the state at the beginning of the transaction. The exception is passed on to the enclosing scope, so you probably want to handle it accordingly.



382
383
384
385
386
387
388
389
390
391
 
# File 'lib/perobs/Store.rb', line 382

def transaction
  @cache.begin_transaction
  begin
    yield if block_given?
  rescue => e
    @cache.abort_transaction
    raise e
  end
  @cache.end_transaction
end