← Back to branch summary

~ubuntu-branches/debian/sid/zeitgeist/sid

« back to all changes in this revision

Viewing changes to _zeitgeist/engine/extensions/datasource_registry.py

  • Committer: Bazaar Package Importer
  • Author(s): Siegfried-Angel Gevatter Pujals
  • Date: 2011-01-22 14:15:38 UTC
  • mfrom: (1.1.6 upstream) (8.1.1 experimental)
  • Revision ID: james.westby@ubuntu.com-20110122141538-a28l12bxa3lxvi11
Tags: 0.7-1
* New upstream release. Some of the changes are:
   - Various performance improvements (speed, reduced I/O, etc).
   - Enhancements to the extensions system (eg. feature to ask which
     extensions are active).
   - Various bug fixes (eg. fixed find_event_for_template Python API method).
   - Added new mimetype mappings.
* Updated debian/copyright and debian/zeitgeist-core.install.

Show diffs side-by-side

added added

removed removed

Lines of Context:
_zeitgeist/engine/extensions/datasource_registry.py
7
7
#
8
8
# This program is free software: you can redistribute it and/or modify
9
9
# it under the terms of the GNU Lesser General Public License as published by
10
 
# the Free Software Foundation, either version 3 of the License, or
 
10
# the Free Software Foundation, either version 2.1 of the License, or
11
11
# (at your option) any later version.
12
12
#
13
13
# This program is distributed in the hope that it will be useful,
30
30
from _zeitgeist.engine.extension import Extension
31
31
from _zeitgeist.engine import constants
32
32
 
33
 
logging.basicConfig(level=logging.DEBUG)
34
33
log = logging.getLogger("zeitgeist.datasource_registry")
35
34
 
36
35
DATA_FILE = os.path.join(constants.DATA_PATH, "datasources.pickle")
73
72
                dbus.service.Object.__init__(self, dbus.SessionBus(),
74
73
                        REGISTRY_DBUS_OBJECT_PATH)
75
74
                
 
75
                self._registry = {}
76
76
                if os.path.exists(DATA_FILE):
77
77
                        try:
78
 
                                self._registry = [DataSource.from_list(
79
 
                                        datasource) for datasource in pickle.load(open(DATA_FILE))]
 
78
                                with open(DATA_FILE) as data_file:
 
79
                                        for datasource in pickle.load(data_file):
 
80
                                                ds = DataSource.from_list(datasource)
 
81
                                                self._registry[ds[DataSource.UniqueId]] = ds
80
82
                                log.debug("Loaded data-source data from %s" % DATA_FILE)
81
83
                        except Exception, e:
82
84
                                log.warn("Failed to load data file %s: %s" % (DATA_FILE, e))
83
 
                                self._registry = []
84
85
                else:
85
86
                        log.debug("No existing data-source data found.")
86
 
                        self._registry = []
87
87
                self._running = {}
88
88
                
89
89
                # Connect to client disconnection signals
94
94
            )
95
95
        
96
96
        def _write_to_disk(self):
97
 
                data = [DataSource.get_plain(datasource) for datasource in self._registry]
 
97
                data = [DataSource.get_plain(datasource) for datasource in
 
98
                        self._registry.itervalues()]
98
99
                with open(DATA_FILE, "w") as data_file:
99
100
                        pickle.dump(data, data_file)
100
101
                #log.debug("Data-source registry update written to disk.")
101
102
        
102
 
        def _get_data_source(self, unique_id):
103
 
                for datasource in self._registry:
104
 
                        if datasource[DataSource.UniqueId] == unique_id:
105
 
                                return datasource
106
 
        
107
 
        def insert_event_hook(self, event, sender):
 
103
        def pre_insert_event(self, event, sender):
108
104
                for (unique_id, bus_names) in self._running.iteritems():
109
105
                        if sender in bus_names:
110
 
                                datasource = self._get_data_source(unique_id)
 
106
                                datasource = self._registry[unique_id]
111
107
                                # Update LastSeen time
112
 
                                datasource[DataSource.LastSeen] = get_timestamp_for_now()
113
 
                                self._write_to_disk()
 
108
                                datasource.last_seen = get_timestamp_for_now()
114
109
                                # Check whether the data-source is allowed to insert events
115
 
                                if not [DataSource.Enabled]:
 
110
                                if not datasource.enabled:
116
111
                                        return None
117
112
                return event
118
113
        
 
114
        def unload(self):
 
115
                self._write_to_disk()
 
116
        
119
117
        # PUBLIC
120
118
        def register_data_source(self, unique_id, name, description, templates):
121
119
                source = DataSource(str(unique_id), unicode(name), unicode(description),
122
120
                        map(Event.new_for_struct, templates))
123
 
                for datasource in self._registry:
124
 
                        if datasource == source:
125
 
                                datasource.update_from_data_source(source)
126
 
                                self.DataSourceRegistered(datasource)
127
 
                                return datasource[DataSource.Enabled]
128
 
                self._registry.append(source)
 
121
                if unique_id in self._registry:
 
122
                        datasource = self._registry[unique_id]
 
123
                        datasource.update_from_data_source(source)
 
124
                else:
 
125
                        datasource = self._registry[unique_id] = source
129
126
                self._write_to_disk()
130
 
                self.DataSourceRegistered(source)
131
 
                return True
 
127
                self.DataSourceRegistered(datasource)
 
128
                return datasource.enabled
132
129
        
133
130
        # PUBLIC
134
131
        def get_data_sources(self):
135
 
                return self._registry
 
132
                return self._registry.values()
136
133
        
137
134
        # PUBLIC
138
135
        def set_data_source_enabled(self, unique_id, enabled):
139
 
                datasource = self._get_data_source(unique_id)
 
136
                datasource = self._registry[unique_id]
140
137
                if not datasource:
141
138
                        return False
142
 
                if datasource[DataSource.Enabled] != enabled:
143
 
                        datasource[DataSource.Enabled] = enabled
144
 
                        self.DataSourceEnabled(datasource[DataSource.UniqueId], enabled)
 
139
                if datasource.enabled != enabled:
 
140
                        datasource.enabled = enabled
 
141
                        self.DataSourceEnabled(datasource.unique_id, enabled)
145
142
                return True
146
143
        
147
144
        @dbus.service.method(REGISTRY_DBUS_INTERFACE,
170
167
                elif sender not in self._running[unique_id]:
171
168
                    self._running[unique_id].append(sender)
172
169
                return self.register_data_source(unique_id, name, description,
173
 
                    event_templates)
 
170
                        event_templates)
174
171
        
175
172
        @dbus.service.method(REGISTRY_DBUS_INTERFACE,
176
173
                                                 in_signature="",
200
197
                        matching the given ID.
201
198
                :rtype: Bool
202
199
                """
203
 
                return self.set_data_source_enabled(unique_id, enabled)
 
200
                self.set_data_source_enabled(unique_id, enabled)
204
201
 
205
202
        @dbus.service.signal(REGISTRY_DBUS_INTERFACE,
206
203
                                                signature="sb")
245
242
                        return
246
243
                uid = uid[0]
247
244
 
248
 
                datasource = self._get_data_source(uid)
 
245
                datasource = self._registry[uid]
249
246
                
250
247
                # Update LastSeen time
251
 
                datasource[DataSource.LastSeen] = get_timestamp_for_now()
252
 
                self._write_to_disk()
 
248
                datasource.last_seen = get_timestamp_for_now()
253
249
                
254
 
                strid = "%s (%s)" % (uid, datasource[DataSource.Name])
 
250
                strid = "%s (%s)" % (uid, datasource.name)
255
251
                log.debug("Client disconnected: %s" % strid)
256
252
                if len(self._running[uid]) == 1:
257
253
                        log.debug("No remaining client running: %s" % strid)
258
254
                        del self._running[uid]
259
 
                        datasource[DataSource.Running] = False
 
255
                        datasource.running = False
260
256
                        self.DataSourceDisconnected(datasource)
261
257
                else:
262
258
                        self._running[uid].remove(owner)