# NB this function is called _early_ in init(), pretty much all you have to
# work with is @bot.botclass.
def upgrade_data
- if File.exist?("#{@bot.botclass}/registry.db")
+ oldreg = @bot.path 'registry.db'
+ newreg = @bot.path 'plugin_registry.db'
+ if File.exist?(oldreg)
log _("upgrading old-style (rbot 0.9.5 or earlier) plugin registry to new format")
- old = BDB::Hash.open("#{@bot.botclass}/registry.db", nil,
- "r+", 0600)
- new = BDB::CIBtree.open("#{@bot.botclass}/plugin_registry.db", nil,
- BDB::CREATE | BDB::EXCL,
- 0600)
+ old = BDB::Hash.open(oldreg, nil, "r+", 0600)
+ new = BDB::CIBtree.open(newreg, nil, BDB::CREATE | BDB::EXCL, 0600)
old.each {|k,v|
new[k] = v
}
old.close
new.close
- File.rename("#{@bot.botclass}/registry.db", "#{@bot.botclass}/registry.db.old")
+ File.rename(oldreg, oldreg + ".old")
end
end
def upgrade_data2
- if File.exist?("#{@bot.botclass}/plugin_registry.db")
- Dir.mkdir("#{@bot.botclass}/registry") unless File.exist?("#{@bot.botclass}/registry")
- env = BDB::Env.open("#{@bot.botclass}", BDB::INIT_TRANSACTION | BDB::CREATE | BDB::RECOVER)# | BDB::TXN_NOSYNC)
+ oldreg = @bot.path 'plugin_registry.db'
+ newdir = @bot.path 'registry'
+ if File.exist?(oldreg)
+ Dir.mkdir(newdir) unless File.exist?(newdir)
+ env = BDB::Env.open(@bot.botclass, BDB::INIT_TRANSACTION | BDB::CREATE | BDB::RECOVER)# | BDB::TXN_NOSYNC)
dbs = Hash.new
log _("upgrading previous (rbot 0.9.9 or earlier) plugin registry to new split format")
- old = BDB::CIBtree.open("#{@bot.botclass}/plugin_registry.db", nil,
- "r+", 0600, "env" => env)
+ old = BDB::CIBtree.open(oldreg, nil, "r+", 0600, "env" => env)
old.each {|k,v|
prefix,key = k.split("/", 2)
prefix.downcase!
dbs[prefix][key] = v
}
old.close
- File.rename("#{@bot.botclass}/plugin_registry.db", "#{@bot.botclass}/plugin_registry.db.old")
+ File.rename(oldreg, oldreg + ".old")
dbs.each {|k,v|
log _("closing db #{k}")
v.close
# blah = @registry[:blah]
# blah[:foo] = "flump"
# @registry[:blah] = blah
-
+ #
# If you don't need to store objects, and strictly want a persistant hash of
# strings, you can override the store/restore methods to suit your needs, for
# example (in your plugin):
def initialize(bot, name)
@bot = bot
@name = name.downcase
- dirs = File.dirname("#{@bot.botclass}/registry/#{@name}").split("/")
+ @filename = @bot.path 'registry', @name
+ dirs = File.dirname(@filename).split("/")
dirs.length.times { |i|
dir = dirs[0,i+1].join("/")+"/"
unless File.exist?(dir)
Dir.mkdir(dir)
end
}
+ @filename << ".db"
@registry = nil
@default = nil
@recovery = nil
debug ee
end
end
- unless @default.nil?
- begin
- return Marshal.restore(@default)
- rescue
- return nil
- end
- else
- return nil
- end
+ return default
end
end
# lookup a key in the registry
def [](key)
- if registry.has_key?(key)
+ if File.exist?(@filename) && registry.has_key?(key)
return restore(registry[key])
- elsif @default != nil
- return restore(@default)
else
- return nil
+ return default
end
end
# set the default value for registry lookups, if the key sought is not
# found, the default will be returned. The default default (har) is nil.
def set_default (default)
- @default = store(default)
+ @default = default
+ end
+
+ def default
+ @default && (@default.dup rescue @default)
end
# just like Hash#each
- def each(&block)
- registry.each {|key,value|
+ def each(set=nil, bulk=0, &block)
+ return nil unless File.exist?(@filename)
+ registry.each(set, bulk) {|key,value|
block.call(key, restore(value))
}
end
# just like Hash#each_key
- def each_key(&block)
- registry.each {|key, value|
+ def each_key(set=nil, bulk=0, &block)
+ return nil unless File.exist?(@filename)
+ registry.each_key(set, bulk) {|key|
block.call(key)
}
end
# just like Hash#each_value
- def each_value(&block)
- registry.each {|key, value|
+ def each_value(set=nil, bulk=0, &block)
+ return nil unless File.exist?(@filename)
+ registry.each_value(set, bulk) { |value|
block.call(restore(value))
}
end
# just like Hash#has_key?
def has_key?(key)
+ return false unless File.exist?(@filename)
return registry.has_key?(key)
end
alias include? has_key?
alias member? has_key?
+ alias key? has_key?
# just like Hash#has_both?
def has_both?(key, value)
+ return false unless File.exist?(@filename)
return registry.has_both?(key, store(value))
end
# just like Hash#has_value?
def has_value?(value)
+ return false unless File.exist?(@filename)
return registry.has_value?(store(value))
end
# just like Hash#index?
def index(value)
+ return nil unless File.exist?(@filename)
ind = registry.index(store(value))
if ind
return ind
# delete a key from the registry
def delete(key)
+ return default unless File.exist?(@filename)
return registry.delete(key)
end
# returns a list of your keys
def keys
+ return [] unless File.exist?(@filename)
return registry.keys
end
# Return an array of all associations [key, value] in your namespace
def to_a
+ return [] unless File.exist?(@filename)
ret = Array.new
registry.each {|key, value|
ret << [key, restore(value)]
# Return an hash of all associations {key => value} in your namespace
def to_hash
+ return {} unless File.exist?(@filename)
ret = Hash.new
registry.each {|key, value|
ret[key] = restore(value)
# empties the registry (restricted to your namespace)
def clear
+ return true unless File.exist?(@filename)
registry.clear
end
alias truncate clear
# returns an array of the values in your namespace of the registry
def values
+ return [] unless File.exist?(@filename)
ret = Array.new
self.each {|k,v|
ret << restore(v)
projects / user / henk / code / ruby / rbot.git / blobdiff