lib/rbot/registry.rb

   1 require 'rbot/dbhash'
   2
   3 module Irc
   4
   5   # this class is now used purely for upgrading from prior versions of rbot
   6   # the new registry is split into multiple DBHash objects, one per plugin
   7   class BotRegistry
   8     def initialize(bot)
   9       @bot = bot
  10       upgrade_data
  11       upgrade_data2
  12     end
  13
  14     # check for older versions of rbot with data formats that require updating
  15     # NB this function is called _early_ in init(), pretty much all you have to
  16     # work with is @bot.botclass.
  17     def upgrade_data
  18       if File.exist?("#{@bot.botclass}/registry.db")
  19         log "upgrading old-style (rbot 0.9.5 or earlier) plugin registry to new format"
  20         old = BDB::Hash.open("#{@bot.botclass}/registry.db", nil,
  21                              "r+", 0600)
  22         new = BDB::CIBtree.open("#{@bot.botclass}/plugin_registry.db", nil,
  23                                 BDB::CREATE | BDB::EXCL,
  24                                 0600)
  25         old.each {|k,v|
  26           new[k] = v
  27         }
  28         old.close
  29         new.close
  30         File.delete("#{@bot.botclass}/registry.db")
  31       end
  32     end
  33
  34     def upgrade_data2
  35       if File.exist?("#{@bot.botclass}/plugin_registry.db")
  36         Dir.mkdir("#{@bot.botclass}/registry") unless File.exist?("#{@bot.botclass}/registry")
  37         env = BDB::Env.open("#{@bot.botclass}", BDB::INIT_TRANSACTION | BDB::CREATE | BDB::RECOVER)
  38         dbs = Hash.new
  39         log "upgrading previous (rbot 0.9.9 or earlier) plugin registry to new split format"
  40         old = BDB::CIBtree.open("#{@bot.botclass}/plugin_registry.db", nil,
  41           "r+", 0600, "env" => env)
  42         old.each {|k,v|
  43           prefix,key = k.split("/", 2)
  44           prefix.downcase!
  45           # subregistries were split with a +, now they are in separate folders
  46           if prefix.gsub!(/\+/, "/")
  47             # Ok, this code needs to be put in the db opening routines
  48             dirs = File.dirname("#{@bot.botclass}/registry/#{prefix}.db").split("/")
  49             dirs.length.times { |i|
  50               dir = dirs[0,i+1].join("/")+"/"
  51               unless File.exist?(dir)
  52                 log "creating subregistry directory #{dir}"
  53                 Dir.mkdir(dir)
  54               end
  55             }
  56           end
  57           unless dbs.has_key?(prefix)
  58             log "creating db #{@bot.botclass}/registry/#{prefix}.db"
  59             dbs[prefix] = BDB::CIBtree.open("#{@bot.botclass}/registry/#{prefix}.db",
  60               nil, BDB::CREATE | BDB::EXCL,
  61               0600, "env" => env)
  62           end
  63           dbs[prefix][key] = v
  64         }
  65         old.close
  66         File.rename("#{@bot.botclass}/plugin_registry.db", "#{@bot.botclass}/plugin_registry.db.old")
  67         dbs.each {|k,v|
  68           log "closing db #{k}"
  69           v.close
  70         }
  71         env.close
  72       end
  73     end
  74   end
  75
  76
  77   # This class provides persistent storage for plugins via a hash interface.
  78   # The default mode is an object store, so you can store ruby objects and
  79   # reference them with hash keys. This is because the default store/restore
  80   # methods of the plugins' RegistryAccessor are calls to Marshal.dump and
  81   # Marshal.restore,
  82   # for example:
  83   #   blah = Hash.new
  84   #   blah[:foo] = "fum"
  85   #   @registry[:blah] = blah
  86   # then, even after the bot is shut down and disconnected, on the next run you
  87   # can access the blah object as it was, with:
  88   #   blah = @registry[:blah]
  89   # The registry can of course be used to store simple strings, fixnums, etc as
  90   # well, and should be useful to store or cache plugin data or dynamic plugin
  91   # configuration.
  92   #
  93   # WARNING:
  94   # in object store mode, don't make the mistake of treating it like a live
  95   # object, e.g. (using the example above)
  96   #   @registry[:blah][:foo] = "flump"
  97   # will NOT modify the object in the registry - remember that BotRegistry#[]
  98   # returns a Marshal.restore'd object, the object you just modified in place
  99   # will disappear. You would need to:
 100   #   blah = @registry[:blah]
 101   #   blah[:foo] = "flump"
 102   #   @registry[:blah] = blah
 103
 104   # If you don't need to store objects, and strictly want a persistant hash of
 105   # strings, you can override the store/restore methods to suit your needs, for
 106   # example (in your plugin):
 107   #   def initialize
 108   #     class << @registry
 109   #       def store(val)
 110   #         val
 111   #       end
 112   #       def restore(val)
 113   #         val
 114   #       end
 115   #     end
 116   #   end
 117   # Your plugins section of the registry is private, it has its own namespace
 118   # (derived from the plugin's class name, so change it and lose your data).
 119   # Calls to registry.each etc, will only iterate over your namespace.
 120   class BotRegistryAccessor
 121     # plugins don't call this - a BotRegistryAccessor is created for them and
 122     # is accessible via @registry.
 123     def initialize(bot, name)
 124       @bot = bot
 125       @name = name.downcase
 126       dirs = File.dirname("#{@bot.botclass}/registry/#{@name}").split("/")
 127       dirs.length.times { |i|
 128         dir = dirs[0,i+1].join("/")+"/"
 129         unless File.exist?(dir)
 130           debug "creating subregistry directory #{dir}"
 131           Dir.mkdir(dir)
 132         end
 133       }
 134       @registry = DBTree.new bot, "registry/#{@name}"
 135       @default = nil
 136       # debug "initializing registry accessor with name #{@name}"
 137     end
 138
 139     def flush
 140       @registry.flush
 141       @registry.sync
 142     end
 143
 144     def close
 145       @registry.close
 146     end
 147
 148     # convert value to string form for storing in the registry
 149     # defaults to Marshal.dump(val) but you can override this in your module's
 150     # registry object to use any method you like.
 151     # For example, if you always just handle strings use:
 152     #   def store(val)
 153     #     val
 154     #   end
 155     def store(val)
 156       Marshal.dump(val)
 157     end
 158
 159     # restores object from string form, restore(store(val)) must return val.
 160     # If you override store, you should override restore to reverse the
 161     # action.
 162     # For example, if you always just handle strings use:
 163     #   def restore(val)
 164     #     val
 165     #   end
 166     def restore(val)
 167       begin
 168         Marshal.restore(val)
 169       rescue Exception => e
 170         warning "failed to restore marshal data for #{val.inspect}, falling back to default"
 171         debug e.inspect
 172         debug e.backtrace.join("\n")
 173         if @default != nil
 174           begin
 175             return Marshal.restore(@default)
 176           rescue
 177             return nil
 178           end
 179         else
 180           return nil
 181         end
 182       end
 183     end
 184
 185     # lookup a key in the registry
 186     def [](key)
 187       if @registry.has_key?(key)
 188         return restore(@registry[key])
 189       elsif @default != nil
 190         return restore(@default)
 191       else
 192         return nil
 193       end
 194     end
 195
 196     # set a key in the registry
 197     def []=(key,value)
 198       @registry[key] = store(value)
 199     end
 200
 201     # set the default value for registry lookups, if the key sought is not
 202     # found, the default will be returned. The default default (har) is nil.
 203     def set_default (default)
 204       @default = store(default)
 205     end
 206
 207     # just like Hash#each
 208     def each(&block)
 209       @registry.each {|key,value|
 210         block.call(key, restore(value))
 211       }
 212     end
 213
 214     # just like Hash#each_key
 215     def each_key(&block)
 216       @registry.each {|key, value|
 217         block.call(key)
 218       }
 219     end
 220
 221     # just like Hash#each_value
 222     def each_value(&block)
 223       @registry.each {|key, value|
 224         block.call(restore(value))
 225       }
 226     end
 227
 228     # just like Hash#has_key?
 229     def has_key?(key)
 230       return @registry.has_key?(key)
 231     end
 232     alias include? has_key?
 233     alias member? has_key?
 234
 235     # just like Hash#has_both?
 236     def has_both?(key, value)
 237       return @registry.has_both?(key, store(value))
 238     end
 239
 240     # just like Hash#has_value?
 241     def has_value?(value)
 242       return @registry.has_value?(store(value))
 243     end
 244
 245     # just like Hash#index?
 246     def index(value)
 247       ind = @registry.index(store(value))
 248       if ind
 249         return ind
 250       else
 251         return nil
 252       end
 253     end
 254
 255     # delete a key from the registry
 256     def delete(key)
 257       return @registry.delete(key)
 258     end
 259
 260     # returns a list of your keys
 261     def keys
 262       return @registry.keys
 263     end
 264
 265     # Return an array of all associations [key, value] in your namespace
 266     def to_a
 267       ret = Array.new
 268       @registry.each {|key, value|
 269         ret << [key, restore(value)]
 270       }
 271       return ret
 272     end
 273
 274     # Return an hash of all associations {key => value} in your namespace
 275     def to_hash
 276       ret = Hash.new
 277       @registry.each {|key, value|
 278         ret[key] = restore(value)
 279       }
 280       return ret
 281     end
 282
 283     # empties the registry (restricted to your namespace)
 284     def clear
 285       @registry.clear
 286     end
 287     alias truncate clear
 288
 289     # returns an array of the values in your namespace of the registry
 290     def values
 291       ret = Array.new
 292       self.each {|k,v|
 293         ret << restore(v)
 294       }
 295       return ret
 296     end
 297
 298     def sub_registry(prefix)
 299       return BotRegistryAccessor.new(@bot, @name + "/" + prefix)
 300     end
 301
 302     # returns the number of keys in your registry namespace
 303     def length
 304       self.keys.length
 305     end
 306     alias size length
 307
 308   end
 309
 310 end