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.rename("#{@bot.botclass}/registry.db", "#{@bot.botclass}/registry.db.old")
  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)# | BDB::TXN_NOSYNC)
  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       # debug "fushing registry #{@registry}"
 141       @registry.flush
 142       @registry.sync
 143     end
 144
 145     def close
 146       # debug "closing registry #{@registry}"
 147       @registry.close
 148     end
 149
 150     # convert value to string form for storing in the registry
 151     # defaults to Marshal.dump(val) but you can override this in your module's
 152     # registry object to use any method you like.
 153     # For example, if you always just handle strings use:
 154     #   def store(val)
 155     #     val
 156     #   end
 157     def store(val)
 158       Marshal.dump(val)
 159     end
 160
 161     # restores object from string form, restore(store(val)) must return val.
 162     # If you override store, you should override restore to reverse the
 163     # action.
 164     # For example, if you always just handle strings use:
 165     #   def restore(val)
 166     #     val
 167     #   end
 168     def restore(val)
 169       begin
 170         Marshal.restore(val)
 171       rescue Exception => e
 172         warning "failed to restore marshal data for #{val.inspect}, falling back to default"
 173         debug e.inspect
 174         debug e.backtrace.join("\n")
 175         if @default != nil
 176           begin
 177             return Marshal.restore(@default)
 178           rescue
 179             return nil
 180           end
 181         else
 182           return nil
 183         end
 184       end
 185     end
 186
 187     # lookup a key in the registry
 188     def [](key)
 189       if @registry.has_key?(key)
 190         return restore(@registry[key])
 191       elsif @default != nil
 192         return restore(@default)
 193       else
 194         return nil
 195       end
 196     end
 197
 198     # set a key in the registry
 199     def []=(key,value)
 200       @registry[key] = store(value)
 201     end
 202
 203     # set the default value for registry lookups, if the key sought is not
 204     # found, the default will be returned. The default default (har) is nil.
 205     def set_default (default)
 206       @default = store(default)
 207     end
 208
 209     # just like Hash#each
 210     def each(&block)
 211       @registry.each {|key,value|
 212         block.call(key, restore(value))
 213       }
 214     end
 215
 216     # just like Hash#each_key
 217     def each_key(&block)
 218       @registry.each {|key, value|
 219         block.call(key)
 220       }
 221     end
 222
 223     # just like Hash#each_value
 224     def each_value(&block)
 225       @registry.each {|key, value|
 226         block.call(restore(value))
 227       }
 228     end
 229
 230     # just like Hash#has_key?
 231     def has_key?(key)
 232       return @registry.has_key?(key)
 233     end
 234     alias include? has_key?
 235     alias member? has_key?
 236
 237     # just like Hash#has_both?
 238     def has_both?(key, value)
 239       return @registry.has_both?(key, store(value))
 240     end
 241
 242     # just like Hash#has_value?
 243     def has_value?(value)
 244       return @registry.has_value?(store(value))
 245     end
 246
 247     # just like Hash#index?
 248     def index(value)
 249       ind = @registry.index(store(value))
 250       if ind
 251         return ind
 252       else
 253         return nil
 254       end
 255     end
 256
 257     # delete a key from the registry
 258     def delete(key)
 259       return @registry.delete(key)
 260     end
 261
 262     # returns a list of your keys
 263     def keys
 264       return @registry.keys
 265     end
 266
 267     # Return an array of all associations [key, value] in your namespace
 268     def to_a
 269       ret = Array.new
 270       @registry.each {|key, value|
 271         ret << [key, restore(value)]
 272       }
 273       return ret
 274     end
 275
 276     # Return an hash of all associations {key => value} in your namespace
 277     def to_hash
 278       ret = Hash.new
 279       @registry.each {|key, value|
 280         ret[key] = restore(value)
 281       }
 282       return ret
 283     end
 284
 285     # empties the registry (restricted to your namespace)
 286     def clear
 287       @registry.clear
 288     end
 289     alias truncate clear
 290
 291     # returns an array of the values in your namespace of the registry
 292     def values
 293       ret = Array.new
 294       self.each {|k,v|
 295         ret << restore(v)
 296       }
 297       return ret
 298     end
 299
 300     def sub_registry(prefix)
 301       return BotRegistryAccessor.new(@bot, @name + "/" + prefix.to_s)
 302     end
 303
 304     # returns the number of keys in your registry namespace
 305     def length
 306       self.keys.length
 307     end
 308     alias size length
 309
 310   end
 311
 312 end