← Back to branch summary

~zeitgeist/zeitgeist/bluebird

« back to all changes in this revision

Viewing changes to extensions/ds-registry.vala

  • Committer: Michal Hruby
  • Date: 2012-04-04 17:25:15 UTC
  • Revision ID: michal.mhr@gmail.com-20120404172515-s7wtbqxljb7ex69c
We can't auto-discard events from disabled data sources based on bus address, cause there can be multiple sources registered for the same address - fixes an issue with datahub

Show diffs side-by-side

added added

removed removed

Lines of Context:
extensions/ds-registry.vala
166
166
 
167
167
    class DataSourceRegistry: Extension, RemoteRegistry
168
168
    {
 
169
        private const string MULTIPLE_MARKER = "<multiple>";
169
170
        private HashTable<string, DataSource> sources;
170
 
        private HashTable<string, GenericArray<BusName>> running;
 
171
        private HashTable<string, GenericArray<BusName>> running_ds;
 
172
        private HashTable<string, string> bus_name_2_ds;
171
173
        private uint registration_id;
172
174
        private bool dirty;
173
175
 
180
182
 
181
183
        construct
182
184
        {
183
 
            running = new HashTable<string, GenericArray<BusName?>>(
 
185
            bus_name_2_ds = new HashTable<string, string> (str_hash, str_equal);
 
186
            running_ds = new HashTable<string, GenericArray<BusName?>>(
184
187
                str_hash, str_equal);
185
188
 
186
189
            Variant? registry = retrieve_config ("registry",
272
275
            }
273
276
 
274
277
 
275
 
            var sender_array = running.lookup (unique_id);
 
278
            var sender_array = running_ds.lookup (unique_id);
276
279
            if (sender_array == null)
277
280
            {
278
 
                running.insert (unique_id, new GenericArray<BusName?>());
279
 
                running.lookup (unique_id).add (sender);
280
 
            }
281
 
            else if (is_sender_known (sender, sender_array))
282
 
            {
283
 
                running.lookup (unique_id).add (sender);
 
281
                sender_array = new GenericArray<BusName?>();
 
282
                sender_array.add (sender);
 
283
                running_ds.insert (unique_id, sender_array);
 
284
            }
 
285
            else if (!is_sender_known (sender, sender_array))
 
286
            {
 
287
                sender_array.add (sender);
 
288
            }
 
289
 
 
290
            unowned string ds_id = bus_name_2_ds.lookup (sender);
 
291
            if (ds_id == null)
 
292
            {
 
293
                bus_name_2_ds.insert (sender, unique_id);
 
294
            }
 
295
            else if (ds_id != unique_id && ds_id != MULTIPLE_MARKER)
 
296
            {
 
297
                bus_name_2_ds.insert (sender, MULTIPLE_MARKER);
284
298
            }
285
299
 
286
300
            unowned DataSource? ds = sources.lookup (unique_id);
350
364
        public override void pre_insert_events (GenericArray<Event?> events,
351
365
            BusName? sender)
352
366
        {
353
 
            foreach (string unique_id in running.get_keys())
 
367
            foreach (unowned string unique_id in running_ds.get_keys())
354
368
            {
355
 
                GenericArray<BusName?> bus_names = running.lookup (unique_id);
 
369
                GenericArray<BusName?> bus_names = running_ds.lookup (unique_id);
356
370
                if (is_sender_known (sender, bus_names))
357
371
                {
358
372
                    var data_source = sources.lookup (unique_id);
359
373
 
360
 
                    data_source.timestamp =  Timestamp.now ();
 
374
                    data_source.timestamp = Timestamp.now ();
361
375
                    dirty = true;
362
376
 
363
 
                    if (!data_source.enabled)
 
377
                    // if one sender registers multiple unique data sources,
 
378
                    // we have to rely that it's the correct thing, otherwise
 
379
                    // we can just ignore the events
 
380
                    unowned string ds_id = bus_name_2_ds.lookup (sender);
 
381
                    if (!data_source.enabled && ds_id != MULTIPLE_MARKER)
364
382
                    {
365
383
                        for (int i = 0; i < events.length; i++)
366
384
                            events[i] = null;
386
404
            var disconnected_ds = new GenericArray<DataSource> ();
387
405
            {
388
406
                var iter = HashTableIter<string, GenericArray<BusName?>> (
389
 
                    running);
 
407
                    running_ds);
390
408
                unowned string uid;
391
409
                unowned GenericArray<BusName> name_arr;
392
410
                while (iter.next (out uid, out name_arr))
414
432
                ds.timestamp = Timestamp.now ();
415
433
                dirty = true;
416
434
 
417
 
                if (running.lookup (uid).length == 0)
 
435
                if (running_ds.lookup (uid).length == 0)
418
436
                {
419
437
                    debug ("No remaining client running: %s [%s]",
420
438
                        ds.name, uid);
421
 
                    running.remove (uid);
 
439
                    running_ds.remove (uid);
422
440
                    ds.running = false;
423
441
 
424
442
                    data_source_disconnected (ds.to_variant ());