9 warning "rbot couldn't load the bdb module. Old registries won't be upgraded"
11 warning "rbot couldn't load the bdb module: #{e.pretty_inspect}"
15 if BDB::VERSION_MAJOR < 4
16 fatal "Your bdb (Berkeley DB) version #{BDB::VERSION} is too old!"
17 fatal "rbot will only run with bdb version 4 or higher, please upgrade."
18 fatal "For maximum reliability, upgrade to version 4.2 or higher."
19 raise BDB::Fatal, BDB::VERSION + " is too old"
22 if BDB::VERSION_MAJOR == 4 and BDB::VERSION_MINOR < 2
23 warning "Your bdb (Berkeley DB) version #{BDB::VERSION} may not be reliable."
24 warning "If possible, try upgrade version 4.2 or later."
27 require 'tokyocabinet'
32 # DBHash is for tying a hash to disk (using bdb).
33 # Call it with an identifier, for example "mydata". It'll look for
34 # mydata.db, if it exists, it will load and reference that db.
35 # Otherwise it'll create and empty db called mydata.db
38 # absfilename:: use +key+ as an actual filename, don't prepend the bot's
39 # config path and don't append ".db"
40 def initialize(bot, key, absfilename=false)
43 relfilename = @bot.path key
45 if absfilename && File.exist?(key)
46 # db already exists, use it
47 @db = DBHash.open_db(key)
50 @db = DBHash.create_db(key)
51 elsif File.exist? relfilename
52 # db already exists, use it
53 @db = DBHash.open_db relfilename
56 @db = DBHash.create_db relfilename
60 def method_missing(method, *args, &block)
61 return @db.send(method, *args, &block)
64 def DBHash.create_db(name)
65 debug "DBHash: creating empty db #{name}"
66 return BDB::Hash.open(name, nil,
67 BDB::CREATE | BDB::EXCL, 0600)
70 def DBHash.open_db(name)
71 debug "DBHash: opening existing db #{name}"
72 return BDB::Hash.open(name, nil, "r+", 0600)
76 # make BTree lookups case insensitive
79 def bdb_bt_compare(a, b)
80 if a == nil || b == nil
81 warning "CIBTree: comparing #{a.inspect} (#{self[a].inspect}) with #{b.inspect} (#{self[b].inspect})"
83 (a||'').downcase <=> (b||'').downcase
90 class CIBDB < TokyoCabinet::BDB
94 self.setcmpfunc(Proc.new do |a, b|
95 a.downcase <=> b.downcase
103 # DBTree is a BTree equivalent of DBHash, with case insensitive lookups.
105 # absfilename:: use +key+ as an actual filename, don't prepend the bot's
106 # config path and don't append ".db"
107 def initialize(bot, key, absfilename=false)
111 relfilename = @bot.path key
112 relfilename << '.tdb'
114 if absfilename && File.exist?(key)
115 # db already exists, use it
116 @db = DBTree.open_db(key)
119 @db = DBTree.create_db(key)
120 elsif File.exist? relfilename
121 # db already exists, use it
122 @db = DBTree.open_db relfilename
125 @db = DBTree.create_db relfilename
127 oldbasename = (absfilename ? key : relfilename).gsub(/\.tdb$/, ".db")
128 if File.exists? oldbasename and defined? BDB
130 warning "Upgrading old database #{oldbasename}..."
131 oldb = ::BDB::Btree.open(oldbasename, nil, "r", 0600)
134 @db.putlist k, (oldb.duplicates(k, false))
137 File.rename oldbasename, oldbasename+".bak"
142 def method_missing(method, *args, &block)
143 return @db.send(method, *args, &block)
146 def DBTree.create_db(name)
147 debug "DBTree: creating empty db #{name}"
148 db = TokyoCabinet::CIBDB.new
149 res = db.open(name, TokyoCabinet::CIBDB::OREADER | TokyoCabinet::CIBDB::OCREAT | TokyoCabinet::CIBDB::OWRITER)
150 warning "DBTree: creating empty db #{name}: #{db.errmsg(db.ecode) unless res}"
154 def DBTree.open_db(name)
155 debug "DBTree: opening existing db #{name}"
156 db = TokyoCabinet::CIBDB.new
157 res = db.open(name, TokyoCabinet::CIBDB::OREADER | TokyoCabinet::CIBDB::OWRITER)
158 warning "DBTree:opening db #{name}: #{db.errmsg(db.ecode) unless res}"
162 def DBTree.cleanup_logs()
170 def DBTree.cleanup_env()
181 # This class is now used purely for upgrading from prior versions of rbot
182 # the new registry is split into multiple DBHash objects, one per plugin
190 # check for older versions of rbot with data formats that require updating
191 # NB this function is called _early_ in init(), pretty much all you have to
192 # work with is @bot.botclass.
195 oldreg = @bot.path 'registry.db'
196 newreg = @bot.path 'plugin_registry.db'
197 if File.exist?(oldreg)
198 log _("upgrading old-style (rbot 0.9.5 or earlier) plugin registry to new format")
199 old = ::BDB::Hash.open(oldreg, nil, "r+", 0600)
200 new = TokyoCabinet::CIBDB.new
201 new.open(name, TokyoCabinet::CIBDB::OREADER | TokyoCabinet::CIBDB::OCREAT | TokyoCabinet::CIBDB::OWRITER)
204 new.putlist k, (old.duplicates(k, false))
208 File.rename(oldreg, oldreg + ".old")
211 warning "Won't upgrade data: BDB not installed"
216 oldreg = @bot.path 'plugin_registry.db'
217 newdir = @bot.path 'registry'
218 if File.exist?(oldreg)
219 Dir.mkdir(newdir) unless File.exist?(newdir)
220 env = BDB::Env.open(@bot.botclass, BDB::INIT_TRANSACTION | BDB::CREATE | BDB::RECOVER)# | BDB::TXN_NOSYNC)
222 log _("upgrading previous (rbot 0.9.9 or earlier) plugin registry to new split format")
223 old = BDB::CIBtree.open(oldreg, nil, "r+", 0600, "env" => env)
225 prefix,key = k.split("/", 2)
227 # subregistries were split with a +, now they are in separate folders
228 if prefix.gsub!(/\+/, "/")
229 # Ok, this code needs to be put in the db opening routines
230 dirs = File.dirname("#{@bot.botclass}/registry/#{prefix}.db").split("/")
231 dirs.length.times { |i|
232 dir = dirs[0,i+1].join("/")+"/"
233 unless File.exist?(dir)
234 log _("creating subregistry directory #{dir}")
239 unless dbs.has_key?(prefix)
240 log _("creating db #{@bot.botclass}/registry/#{prefix}.db")
241 dbs[prefix] = TokyoCabinet::CIBDB.open("#{@bot.botclass}/registry/#{prefix}.db",
242 TokyoCabinet::CIBDB::OREADER | TokyoCabinet::CIBDB::OCREAT | TokyoCabinet::CIBDB::OWRITER)
247 File.rename(oldreg, oldreg + ".old")
249 log _("closing db #{k}")
256 # This class provides persistent storage for plugins via a hash interface.
257 # The default mode is an object store, so you can store ruby objects and
258 # reference them with hash keys. This is because the default store/restore
259 # methods of the plugins' RegistryAccessor are calls to Marshal.dump and
264 # @registry[:blah] = blah
265 # then, even after the bot is shut down and disconnected, on the next run you
266 # can access the blah object as it was, with:
267 # blah = @registry[:blah]
268 # The registry can of course be used to store simple strings, fixnums, etc as
269 # well, and should be useful to store or cache plugin data or dynamic plugin
273 # in object store mode, don't make the mistake of treating it like a live
274 # object, e.g. (using the example above)
275 # @registry[:blah][:foo] = "flump"
276 # will NOT modify the object in the registry - remember that Registry#[]
277 # returns a Marshal.restore'd object, the object you just modified in place
278 # will disappear. You would need to:
279 # blah = @registry[:blah]
280 # blah[:foo] = "flump"
281 # @registry[:blah] = blah
283 # If you don't need to store objects, and strictly want a persistant hash of
284 # strings, you can override the store/restore methods to suit your needs, for
285 # example (in your plugin):
296 # Your plugins section of the registry is private, it has its own namespace
297 # (derived from the plugin's class name, so change it and lose your data).
298 # Calls to registry.each etc, will only iterate over your namespace.
301 attr_accessor :recovery
303 # plugins don't call this - a Registry::Accessor is created for them and
304 # is accessible via @registry.
305 def initialize(bot, name)
307 @name = name.downcase
308 @filename = @bot.path 'registry', @name
309 dirs = File.dirname(@filename).split("/")
310 dirs.length.times { |i|
311 dir = dirs[0,i+1].join("/")+"/"
312 unless File.exist?(dir)
313 debug "creating subregistry directory #{dir}"
321 # debug "initializing registry accessor with name #{@name}"
325 @registry ||= DBTree.new @bot, "registry/#{@name}"
329 # debug "fushing registry #{registry}"
335 # debug "closing registry #{registry}"
340 # convert value to string form for storing in the registry
341 # defaults to Marshal.dump(val) but you can override this in your module's
342 # registry object to use any method you like.
343 # For example, if you always just handle strings use:
351 # restores object from string form, restore(store(val)) must return val.
352 # If you override store, you should override restore to reverse the
354 # For example, if you always just handle strings use:
361 rescue Exception => e
362 error _("failed to restore marshal data for #{val.inspect}, attempting recovery or fallback to default")
364 if defined? @recovery and @recovery
366 return @recovery.call(val)
367 rescue Exception => ee
368 error _("marshal recovery failed, trying default")
376 # lookup a key in the registry
378 if File.exist?(@filename) and registry.has_key?(key.to_s)
379 return restore(registry[key.to_s])
385 # set a key in the registry
387 registry[key.to_s] = store(value)
390 # set the default value for registry lookups, if the key sought is not
391 # found, the default will be returned. The default default (har) is nil.
392 def set_default (default)
397 @default && (@default.dup rescue @default)
400 # just like Hash#each
401 def each(set=nil, bulk=0, &block)
402 return nil unless File.exist?(@filename)
403 registry.fwmkeys(set).each {|key|
404 block.call(key, restore(registry[key]))
408 # just like Hash#each_key
409 def each_key(set=nil, bulk=0, &block)
410 return nil unless File.exist?(@filename)
411 registry.fwmkeys(set).each do |key|
416 # just like Hash#each_value
417 def each_value(set=nil, bulk=0, &block)
418 return nil unless File.exist?(@filename)
419 registry.fwmkeys(set).each do |key|
420 block.call(restore(registry[key]))
424 # just like Hash#has_key?
426 return false unless File.exist?(@filename)
427 return registry.has_key?(key.to_s)
430 alias include? has_key?
431 alias member? has_key?
434 # just like Hash#has_both?
435 def has_both?(key, value)
436 return false unless File.exist?(@filename)
437 registry.has_key?(key.to_s) and registry.has_value?(store(value))
440 # just like Hash#has_value?
441 def has_value?(value)
442 return false unless File.exist?(@filename)
443 return registry.has_value?(store(value))
446 # just like Hash#index?
449 return k if v == value
454 # delete a key from the registry
456 return default unless File.exist?(@filename)
457 return registry.delete(key.to_s)
460 # returns a list of your keys
462 return [] unless File.exist?(@filename)
466 # Return an array of all associations [key, value] in your namespace
468 return [] unless File.exist?(@filename)
470 registry.each {|key, value|
471 ret << [key, restore(value)]
476 # Return an hash of all associations {key => value} in your namespace
478 return {} unless File.exist?(@filename)
480 registry.each {|key, value|
481 ret[key] = restore(value)
486 # empties the registry (restricted to your namespace)
488 return true unless File.exist?(@filename)
493 # returns an array of the values in your namespace of the registry
495 return [] unless File.exist?(@filename)
503 def sub_registry(prefix)
504 return Accessor.new(@bot, @name + "/" + prefix.to_s)
507 # returns the number of keys in your registry namespace
509 return 0 unless File.exist?(@filename)
515 def putdup(key, value)
516 registry.putdup(key.to_s, store(value))
519 def putlist(key, values)
520 registry.putlist(key.to_s, value.map {|v| store(v)})
524 return [] unless File.exist?(@filename)
525 (registry.getlist(key.to_s) || []).map {|v| restore(v)}