summaryrefslogtreecommitdiff
path: root/lib/rbot/registry.rb
blob: a3c55da83953e72c8eb5646f107aae22e61ab9b5 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
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
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
require 'rbot/dbhash'

module Irc

  # this class is now used purely for upgrading from prior versions of rbot
  # the new registry is split into multiple DBHash objects, one per plugin
  class BotRegistry
    def initialize(bot)
      @bot = bot
      upgrade_data
      upgrade_data2
    end

    # check for older versions of rbot with data formats that require updating
    # 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")
        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.each {|k,v|
          new[k] = v
        }
        old.close
        new.close
        File.rename("#{@bot.botclass}/registry.db", "#{@bot.botclass}/registry.db.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)
        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.each {|k,v|
          prefix,key = k.split("/", 2)
          prefix.downcase!
          # subregistries were split with a +, now they are in separate folders
          if prefix.gsub!(/\+/, "/")
            # Ok, this code needs to be put in the db opening routines
            dirs = File.dirname("#{@bot.botclass}/registry/#{prefix}.db").split("/")
            dirs.length.times { |i|
              dir = dirs[0,i+1].join("/")+"/"
              unless File.exist?(dir)
                log "creating subregistry directory #{dir}"
                Dir.mkdir(dir) 
              end
            }
          end
          unless dbs.has_key?(prefix)
            log "creating db #{@bot.botclass}/registry/#{prefix}.db"
            dbs[prefix] = BDB::CIBtree.open("#{@bot.botclass}/registry/#{prefix}.db",
              nil, BDB::CREATE | BDB::EXCL,
              0600, "env" => env)
          end
          dbs[prefix][key] = v
        }
        old.close
        File.rename("#{@bot.botclass}/plugin_registry.db", "#{@bot.botclass}/plugin_registry.db.old")
        dbs.each {|k,v|
          log "closing db #{k}"
          v.close
        }
        env.close
      end
    end
  end


  # This class provides persistent storage for plugins via a hash interface.
  # The default mode is an object store, so you can store ruby objects and
  # reference them with hash keys. This is because the default store/restore
  # methods of the plugins' RegistryAccessor are calls to Marshal.dump and
  # Marshal.restore,
  # for example:
  #   blah = Hash.new
  #   blah[:foo] = "fum"
  #   @registry[:blah] = blah
  # then, even after the bot is shut down and disconnected, on the next run you
  # can access the blah object as it was, with:
  #   blah = @registry[:blah]
  # The registry can of course be used to store simple strings, fixnums, etc as
  # well, and should be useful to store or cache plugin data or dynamic plugin
  # configuration.
  #
  # WARNING:
  # in object store mode, don't make the mistake of treating it like a live
  # object, e.g. (using the example above)
  #   @registry[:blah][:foo] = "flump"
  # will NOT modify the object in the registry - remember that BotRegistry#[]
  # returns a Marshal.restore'd object, the object you just modified in place
  # will disappear. You would need to:
  #   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
  #     class << @registry
  #       def store(val)
  #         val
  #       end
  #       def restore(val)
  #         val
  #       end
  #     end
  #   end
  # Your plugins section of the registry is private, it has its own namespace
  # (derived from the plugin's class name, so change it and lose your data).
  # Calls to registry.each etc, will only iterate over your namespace.
  class BotRegistryAccessor
    # plugins don't call this - a BotRegistryAccessor is created for them and
    # is accessible via @registry.
    def initialize(bot, name)
      @bot = bot
      @name = name.downcase
      dirs = File.dirname("#{@bot.botclass}/registry/#{@name}").split("/")
      dirs.length.times { |i|
        dir = dirs[0,i+1].join("/")+"/"
        unless File.exist?(dir)
          debug "creating subregistry directory #{dir}"
          Dir.mkdir(dir) 
        end
      }
      @registry = DBTree.new bot, "registry/#{@name}"
      @default = nil
      # debug "initializing registry accessor with name #{@name}"
    end

    def flush
      # debug "fushing registry #{@registry}"
      @registry.flush
      @registry.sync
    end

    def close
      # debug "closing registry #{@registry}"
      @registry.close
    end

    # convert value to string form for storing in the registry
    # defaults to Marshal.dump(val) but you can override this in your module's
    # registry object to use any method you like.
    # For example, if you always just handle strings use:
    #   def store(val)
    #     val
    #   end
    def store(val)
      Marshal.dump(val)
    end

    # restores object from string form, restore(store(val)) must return val.
    # If you override store, you should override restore to reverse the
    # action.
    # For example, if you always just handle strings use:
    #   def restore(val)
    #     val
    #   end
    def restore(val)
      begin
        Marshal.restore(val)
      rescue Exception => e
        warning "failed to restore marshal data for #{val.inspect}, falling back to default"
        debug e.inspect
        debug e.backtrace.join("\n")
        if @default != nil
          begin
            return Marshal.restore(@default)
          rescue
            return nil
          end
        else
          return nil
        end
      end
    end

    # lookup a key in the registry
    def [](key)
      if @registry.has_key?(key)
        return restore(@registry[key])
      elsif @default != nil
        return restore(@default)
      else
        return nil
      end
    end

    # set a key in the registry
    def []=(key,value)
      @registry[key] = store(value)
    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)
    end

    # just like Hash#each
    def each(&block)
      @registry.each {|key,value|
        block.call(key, restore(value))
      }
    end

    # just like Hash#each_key
    def each_key(&block)
      @registry.each {|key, value|
        block.call(key)
      }
    end

    # just like Hash#each_value
    def each_value(&block)
      @registry.each {|key, value|
        block.call(restore(value))
      }
    end

    # just like Hash#has_key?
    def has_key?(key)
      return @registry.has_key?(key)
    end
    alias include? has_key?
    alias member? has_key?

    # just like Hash#has_both?
    def has_both?(key, value)
      return @registry.has_both?(key, store(value))
    end

    # just like Hash#has_value?
    def has_value?(value)
      return @registry.has_value?(store(value))
    end

    # just like Hash#index?
    def index(value)
      ind = @registry.index(store(value))
      if ind
        return ind
      else
        return nil
      end
    end

    # delete a key from the registry
    def delete(key)
      return @registry.delete(key)
    end

    # returns a list of your keys
    def keys
      return @registry.keys
    end

    # Return an array of all associations [key, value] in your namespace
    def to_a
      ret = Array.new
      @registry.each {|key, value|
        ret << [key, restore(value)]
      }
      return ret
    end

    # Return an hash of all associations {key => value} in your namespace
    def to_hash
      ret = Hash.new
      @registry.each {|key, value|
        ret[key] = restore(value)
      }
      return ret
    end

    # empties the registry (restricted to your namespace)
    def clear
      @registry.clear
    end
    alias truncate clear

    # returns an array of the values in your namespace of the registry
    def values
      ret = Array.new
      self.each {|k,v|
        ret << restore(v)
      }
      return ret
    end

    def sub_registry(prefix)
      return BotRegistryAccessor.new(@bot, @name + "/" + prefix.to_s)
    end

    # returns the number of keys in your registry namespace
    def length
      self.keys.length
    end
    alias size length

  end

end