← Back to branch summary

~ubuntu-branches/ubuntu/wily/prewikka/wily

« back to all changes in this revision

Viewing changes to prewikka/Core.py

  • Committer: Bazaar Package Importer
  • Author(s): Pierre Chifflier
  • Date: 2008-07-02 16:49:06 UTC
  • mfrom: (6.1.2 intrepid)
  • Revision ID: james.westby@ubuntu.com-20080702164906-q2bkfn6i40hd95tt
Tags: 0.9.14-2
* Update watch file
* Bump Standards version to 3.8.0 (no changes)

Show diffs side-by-side

added added

removed removed

Lines of Context:
prewikka/Core.py
22
22
 
23
23
import prewikka.views
24
24
from prewikka import view, Config, Log, Database, IDMEFDatabase, \
25
 
     User, Auth, DataSet, Error, utils, siteconfig, localization
 
25
     User, Auth, DataSet, Error, utils, siteconfig, localization, resolve
 
26
 
 
27
try:
 
28
    from threading import Lock
 
29
except ImportError:
 
30
    from dummy_threading import Lock
26
31
 
27
32
 
28
33
class InvalidQueryError(Error.PrewikkaUserError):
34
39
    view_name = "logout"
35
40
    view_parameters = view.Parameters
36
41
    view_permissions = [ ]
37
 
                
 
42
 
38
43
    def render(self):
39
44
        self.env.auth.logout(self.request)
40
 
                    
41
 
                    
 
45
 
 
46
 
42
47
def init_dataset(dataset, config, request):
43
48
    interface = config.interface
44
49
    dataset["document.title"] = "[PREWIKKA]"
45
50
    dataset["document.charset"] = localization.getCurrentCharset()
46
51
    dataset["document.css_files"] = [ "prewikka/css/style.css" ]
47
 
    dataset["document.js_files"] = [ "prewikka/js/functions.js" ]
 
52
    dataset["document.js_files"] = [ "prewikka/js/jquery.js", "prewikka/js/functions.js" ]
48
53
    dataset["prewikka.title"] = interface.getOptionValue("title", " ")
49
54
    dataset["prewikka.software"] = interface.getOptionValue("software", " ")
50
55
    dataset["prewikka.place"] = interface.getOptionValue("place", " ")
55
60
        dataset["prewikka.external_link_target"] = "_blank"
56
61
    else:
57
62
        dataset["prewikka.external_link_target"] = "_self"
58
 
            
 
63
 
59
64
    qstring = request.getQueryString()
60
65
    if qstring[0:2] == "/?":
61
66
        qstring = qstring[2:]
68
73
        referer = referer[idx + 1:]
69
74
        if referer[0:1] == "?":
70
75
            referer = referer[1:]
71
 
        
 
76
 
72
77
    dataset["prewikka.url.referer"] = referer
73
 
    
 
78
 
74
79
    dataset["arguments"] = []
75
80
    for name, value in request.arguments.items():
76
81
        if name in ("_login", "_password"):
77
82
            continue
78
 
                
 
83
 
79
84
        if name == "view" and value == "logout":
80
85
            continue
81
 
        
 
86
 
82
87
        dataset["arguments"].append((name, value))
83
 
            
84
 
            
 
88
 
 
89
 
85
90
def load_template(name, dataset):
86
91
    template = getattr(__import__("prewikka.templates." + name, globals(), locals(), [ name ]), name)(filtersLib=CheetahFilters)
87
 
        
 
92
 
88
93
    for key, value in dataset.items():
89
94
        setattr(template, key, value)
90
95
 
92
97
 
93
98
 
94
99
_core_cache = { }
95
 
 
96
 
try:
97
 
    import threading
98
 
except ImportError:
99
 
    _has_threads = False
100
 
else:
101
 
    _has_threads = True
102
 
    _core_cache_lock = threading.Lock()
103
 
 
104
 
 
105
 
def get_core_from_config(path, threaded=False):    
 
100
_core_cache_lock = Lock()
 
101
 
 
102
 
 
103
def get_core_from_config(path, threaded=False):
106
104
    global _core_cache
 
105
    global _core_cache_lock
107
106
 
108
107
    if not path:
109
108
        path = siteconfig.conf_dir + "/prewikka.conf"
110
109
 
111
 
    if _has_threads and threaded:
 
110
    if threaded:
112
111
        _core_cache_lock.acquire()
113
 
    
 
112
 
114
113
    if not _core_cache.has_key(path):
115
114
        _core_cache[path] = Core(path)
116
115
 
117
 
    if _has_threads and threaded:
 
116
    if threaded:
118
117
        _core_cache_lock.release()
119
 
    
 
118
 
120
119
    return _core_cache[path]
121
120
 
122
121
 
127
126
        self._env = Env()
128
127
        self._env.auth = None # In case of database error
129
128
        self._env.config = Config.Config(config)
 
129
        self._env.log = Log.Log(self._env.config)
 
130
        self._env.dns_max_delay = float(self._env.config.general.getOptionValue("dns_max_delay", 0))
130
131
        self._env.max_aggregated_source = int(self._env.config.general.getOptionValue("max_aggregated_source", 10))
131
132
        self._env.max_aggregated_target = int(self._env.config.general.getOptionValue("max_aggregated_target", 10))
132
133
        self._env.default_locale = self._env.config.general.getOptionValue("default_locale", None)
 
134
 
 
135
        if self._env.dns_max_delay != -1:
 
136
            resolve.init(self._env)
 
137
 
133
138
        preludedb.preludedb_init()
134
139
 
135
 
        self._database_schema_error = None        
 
140
        self._database_schema_error = None
136
141
        try:
137
142
            self._initDatabase()
138
143
        except Database.DatabaseSchemaError, e:
139
144
            self._database_schema_error = e
140
145
            return
141
 
            
 
146
 
142
147
        self._env.idmef_db = IDMEFDatabase.IDMEFDatabase(self._env.config.idmef_database)
143
 
        self._env.log = Log.Log(self._env.config)
144
148
        self._initHostCommands()
145
149
        self._loadViews()
146
150
        self._loadModules()
147
151
        self._initAuth()
148
 
                
 
152
 
 
153
 
149
154
    def _initDatabase(self):
150
155
        config = { }
151
156
        for key in self._env.config.database.keys():
152
157
            config[key] = self._env.config.database.getOptionValue(key)
153
158
 
154
159
        self._env.db = Database.Database(config)
155
 
            
 
160
 
156
161
    def _initHostCommands(self):
157
162
        self._env.host_commands = { }
158
 
        
 
163
 
159
164
        for option in self._env.config.host_commands.getOptions():
160
165
            if os.access(option.value.split(" ")[0], os.X_OK):
161
166
                self._env.host_commands[option.name] = option.value
162
 
        
 
167
 
163
168
    def _initAuth(self):
164
169
        if self._env.auth.canLogout():
165
170
            self._views.update(Logout().get())
167
172
    def _loadViews(self):
168
173
        self._view_to_tab = { }
169
174
        self._view_to_section = { }
170
 
        
171
 
        for section, tabs in (prewikka.views.events_section, prewikka.views.agents_section, 
 
175
 
 
176
        for section, tabs in (prewikka.views.events_section, prewikka.views.agents_section,
172
177
                              prewikka.views.settings_section, prewikka.views.about_section):
173
178
            for tab, views in tabs:
174
179
                for view in views:
175
180
                    self._view_to_tab[view] = tab
176
181
                    self._view_to_section[view] = section
177
 
                    
 
182
 
178
183
        self._views = { }
179
184
        for object in prewikka.views.objects:
180
185
            self._views.update(object.get())
181
 
        
 
186
 
182
187
    def _loadModule(self, type, name, config):
183
188
        module = __import__("prewikka.modules.%s.%s.%s" % (type, name, name), globals(), locals(), [ name ])
184
189
        return module.load(self._env, config)
189
194
        if config.auth:
190
195
            self._env.auth = self._loadModule("auth", config.auth.name, config.auth)
191
196
        else:
192
 
            self._env.auth = Auth.AnonymousAuth(self._env)
 
197
            self._env.auth = self._loadModule("auth", "anonymous", config.auth)
193
198
 
194
199
    def _setupView(self, view, request, parameters, user):
195
200
        object = view["object"]
196
201
        if not object.view_initialized:
197
202
            object.init(self._env)
198
203
            object.view_initialized = True
199
 
        
 
204
 
200
205
        object = copy.copy(object)
201
206
 
202
207
        object.request = request
206
211
        object.env = self._env
207
212
 
208
213
        return object
209
 
    
 
214
 
210
215
    def _cleanupView(self, view):
211
216
        del view.request
212
217
        del view.parameters
213
218
        del view.user
214
219
        del view.dataset
215
220
        del view.env
216
 
        
 
221
 
217
222
    def _setupDataSet(self, dataset, request, user, view=None, parameters={}):
218
223
        init_dataset(dataset, self._env.config, request)
219
 
       
220
 
        is_anon = isinstance(self._env.auth, Auth.AnonymousAuth)
 
224
 
221
225
        sections = prewikka.views.events_section, prewikka.views.agents_section, prewikka.views.settings_section, \
222
226
                   prewikka.views.about_section
223
227
 
224
228
        section_to_tabs = { }
225
229
        dataset["interface.sections"] = [ ]
226
230
        for section_name, tabs in sections:
227
 
            first_tab = None   
228
 
   
 
231
            first_tab = None
 
232
 
229
233
            for tab_name, views in tabs:
230
234
                view_name = views[0]
231
 
        
232
 
                if is_anon and tab_name == "Users":
233
 
                    continue
234
 
        
235
 
                if not user or is_anon or user.has(self._views[view_name]["permissions"]):
 
235
 
 
236
                if not user or user.has(self._views[view_name]["permissions"]):
236
237
                    if not first_tab:
237
238
                        first_tab = view_name
238
239
                        section_to_tabs[section_name] = []
239
 
                    
240
 
                    section_to_tabs[section_name] += [ ((_(tab_name), utils.create_link(views[0]))) ]
241
 
                    
 
240
 
 
241
                    section_to_tabs[section_name] += [ ((tab_name, utils.create_link(views[0]))) ]
 
242
 
242
243
            if first_tab:
243
 
                dataset["interface.sections"].append( (_(section_name), utils.create_link(first_tab)) )
244
 
    
245
 
 
246
 
        if isinstance(parameters, prewikka.view.RelativeViewParameters):
 
244
                dataset["interface.sections"].append( (section_name, utils.create_link(first_tab)) )
 
245
 
 
246
 
 
247
        if isinstance(parameters, prewikka.view.RelativeViewParameters) and parameters.has_key("origin"):
247
248
            view_name = parameters["origin"]
248
249
        elif view:
249
250
            view_name = view["name"]
250
251
        else:
251
252
            view_name = None
252
 
            
 
253
 
253
254
        if view_name and self._view_to_section.has_key(view_name):
254
255
            active_section = self._view_to_section[view_name]
255
256
            active_tab = self._view_to_tab[view_name]
256
 
            tabs = section_to_tabs[active_section]
257
 
        
 
257
            tabs = section_to_tabs.get(active_section, [])
 
258
 
258
259
        else:
259
260
            active_section, tabs, active_tab = "", [ ], ""
260
261
 
261
262
        dataset["interface.tabs"] = tabs
262
263
        dataset["prewikka.user"] = user
263
 
        
 
264
 
264
265
        if user:
265
 
            if is_anon:
266
 
                dataset["prewikka.userlink"] = "<b>%s</b>" % utils.escape_html_string(_(user.login))
267
 
            else:
268
 
                dataset["prewikka.userlink"] = "<b><a href=\"%s\">%s</a></b>" % (utils.create_link("user_settings_display"), utils.escape_html_string(user.login))
269
 
            
270
 
        dataset["interface.active_tab"] = _(active_tab)
271
 
        dataset["interface.active_section"] = _(active_section)
 
266
            dataset["prewikka.userlink"] = "<b><a href=\"%s\">%s</a></b>" % (utils.create_link("user_settings_display"), utils.escape_html_string(user.login))
 
267
 
 
268
        dataset["interface.active_tab"] = active_tab
 
269
        dataset["interface.active_section"] = active_section
272
270
        dataset["prewikka.logout_link"] = (user and self._env.auth.canLogout()) and utils.create_link("logout") or None
273
271
 
274
272
    def _printDataSet(self, dataset, level=0):
279
277
                self._printDataSet(value, level + 1)
280
278
            else:
281
279
                print "%s: %s" % (key, value)
282
 
                    
 
280
 
283
281
    def _checkPermissions(self, request, view, user):
284
282
        if user and view.has_key("permissions"):
285
283
            if not user.has(view["permissions"]):
290
288
        parameters.normalize(view["name"], user)
291
289
 
292
290
        return parameters
293
 
        
 
291
 
294
292
    def _getView(self, request, user):
295
293
        name = request.getView()
296
294
        try:
303
301
        user = self._env.auth.getUser(request)
304
302
        if not user.language and self._env.default_locale:
305
303
            user.setLanguage(self._env.default_locale)
306
 
            
 
304
 
307
305
        return user
308
 
        
 
306
 
 
307
    def prepareError(self, e, request, user, login, view):
 
308
        self._env.log.error("%s" % str(e), request, login)
 
309
        error = Error.PrewikkaUserError("Prewikka internal error", str(e),
 
310
                                        display_traceback=not self._env.config.general.has_key("disable_error_traceback"))
 
311
        self._setupDataSet(error.dataset, request, user, view=view)
 
312
        return error
 
313
 
309
314
    def process(self, request):
310
315
        login = None
311
316
        view = None
313
318
        try:
314
319
            if self._database_schema_error != None:
315
320
                raise Error.PrewikkaUserError("Database error", self._database_schema_error)
316
 
                
 
321
 
317
322
            user = self.checkAuth(request)
318
323
            login = user.login
319
324
            view = self._getView(request, user)
321
326
            self._checkPermissions(request, view, user)
322
327
            parameters = self._getParameters(request, view, user)
323
328
            view_object = self._setupView(view, request, parameters, user)
324
 
            
 
329
 
325
330
            if not isinstance(view_object, Logout):
326
331
                self._env.log.info("Loading view", request, user.login)
327
 
            
 
332
 
328
333
            getattr(view_object, view["handler"])()
329
334
            self._setupDataSet(view_object.dataset, request, user, view, parameters)
330
 
            
 
335
 
331
336
            dataset = view_object.dataset
332
337
            template_name = view["template"]
333
338
 
334
339
            self._cleanupView(view_object)
335
 
            
 
340
 
336
341
        except Error.PrewikkaUserError, e:
337
342
            if e._log_priority:
338
343
                self._env.log.log(e._log_priority, "%s" % str(e), request=request, user=login or e._log_user)
339
 
                
 
344
 
340
345
            self._setupDataSet(e.dataset, request, user, view=view)
341
346
            dataset, template_name = e.dataset, e.template
342
 
                    
 
347
 
343
348
        except Exception, e:
344
 
            self._env.log.error("%s" % str(e), request, login)
345
 
            error = Error.PrewikkaUserError("Prewikka internal error", str(e),
346
 
                                            display_traceback=not self._env.config.general.has_key("disable_error_traceback"))
347
 
            self._setupDataSet(error.dataset, request, user, view=view)
 
349
            error = self.prepareError(e, request, user, login, view)
348
350
            dataset, template_name = error.dataset, error.template
349
 
        
 
351
 
350
352
        #self._printDataSet(dataset)
351
353
        template = load_template(template_name, dataset)
352
354
 
353
 
        # We check the character set after loading the template, 
 
355
        # We check the character set after loading the template,
354
356
        # since the template might trigger a language change.
355
357
        dataset["document.charset"] = localization.getCurrentCharset()
356
 
        
357
 
        request.content = str(template)
 
358
        resolve.process(self._env.dns_max_delay)
 
359
 
 
360
        try:
 
361
                request.content = str(template)
 
362
        except Exception, e:
 
363
            error = self.prepareError(e, request, user, login, view)
 
364
            request.content = str(load_template(error.template, error.dataset))
 
365
 
358
366
        request.sendResponse()
 
367