← Back to branch summary

~ubuntu-branches/ubuntu/hardy/prewikka/hardy

« back to all changes in this revision

Viewing changes to prewikka/views/heartbeatlisting.py

  • Committer: Bazaar Package Importer
  • Author(s): Pierre Chifflier
  • Date: 2007-04-11 14:41:09 UTC
  • Revision ID: james.westby@ubuntu.com-20070411144109-2hh7zx3amwd27b4l
Tags: upstream-0.9.10
Import upstream version 0.9.10

Show diffs side-by-side

added added

removed removed

Lines of Context:
prewikka/views/heartbeatlisting.py
 
1
# Copyright (C) 2004,2005,2006 PreludeIDS Technologies. All Rights Reserved.
 
2
# Author: Nicolas Delon <nicolas.delon@prelude-ids.com>
 
3
#
 
4
# This file is part of the Prewikka program.
 
5
#
 
6
# This program is free software; you can redistribute it and/or modify
 
7
# it under the terms of the GNU General Public License as published by
 
8
# the Free Software Foundation; either version 2, or (at your option)
 
9
# any later version.
 
10
#
 
11
# This program is distributed in the hope that it will be useful,
 
12
# but WITHOUT ANY WARRANTY; without even the implied warranty of
 
13
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
14
# GNU General Public License for more details.
 
15
#
 
16
# You should have received a copy of the GNU General Public License
 
17
# along with this program; see the file COPYING.  If not, write to
 
18
# the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
 
19
 
 
20
from prewikka import view, User, utils
 
21
from prewikka.views.messagelisting import MessageListing, MessageListingParameters, ListedMessage
 
22
 
 
23
 
 
24
class HeartbeatListingParameters(MessageListingParameters):
 
25
    def register(self):
 
26
        MessageListingParameters.register(self)
 
27
        self.optional("heartbeat.analyzer(-1).name", str)
 
28
        self.optional("heartbeat.analyzer(-1).node.address.address", str)
 
29
        self.optional("heartbeat.analyzer(-1).node.name", str)
 
30
        self.optional("heartbeat.analyzer(-1).model", str)
 
31
 
 
32
 
 
33
 
 
34
class SensorHeartbeatListingParameters(HeartbeatListingParameters):
 
35
    def register(self):
 
36
        HeartbeatListingParameters.register(self)
 
37
        self.mandatory("analyzerid", long)
 
38
 
 
39
 
 
40
 
 
41
class ListedHeartbeat(ListedMessage):    
 
42
    def setMessage(self, message, ident):
 
43
        
 
44
        self["delete"] = ident
 
45
        self["summary"] = self.createMessageLink(ident, "heartbeat_summary")
 
46
        self["details"] = self.createMessageLink(ident, "heartbeat_details")
 
47
        self["agent"] = self.createInlineFilteredField("heartbeat.analyzer(-1).name",
 
48
                                                       message["heartbeat.analyzer(-1).name"])
 
49
        self["model"] = self.createInlineFilteredField("heartbeat.analyzer(-1).model",
 
50
                                                       message["heartbeat.analyzer(-1).model"])
 
51
        self["node_name"] = self.createInlineFilteredField("heartbeat.analyzer(-1).node.name",
 
52
                                                           message["heartbeat.analyzer(-1).node.name"])
 
53
 
 
54
        self["node_addresses"] = [ ]
 
55
 
 
56
        for address in message["heartbeat.analyzer(-1).node.address"]:
 
57
            hfield = self.createHostField("heartbeat.analyzer(-1).node.address.address", address["address"], address["category"])
 
58
            self["node_addresses"].append(hfield)
 
59
            
 
60
        self["time"] = self.createTimeField(message["heartbeat.create_time"], self.parameters["timezone"])
 
61
 
 
62
 
 
63
 
 
64
class HeartbeatListing(MessageListing, view.View):
 
65
    view_name = "heartbeat_listing"
 
66
    view_parameters = HeartbeatListingParameters
 
67
    view_permissions = [ User.PERM_IDMEF_VIEW ]
 
68
    view_template = "HeartbeatListing"
 
69
 
 
70
    root = "heartbeat"
 
71
    filters = { }
 
72
    summary_view = "heartbeat_summary"
 
73
    details_view = "heartbeat_details"
 
74
    listed_heartbeat = ListedHeartbeat
 
75
 
 
76
    def _getMessageIdents(self, criteria, limit=-1, offset=-1):
 
77
        return self.env.idmef_db.getHeartbeatIdents(criteria, limit, offset)
 
78
 
 
79
    def _countMessages(self, criteria):
 
80
        return self.env.idmef_db.countHeartbeats(criteria)
 
81
 
 
82
    def _fetchMessage(self, ident):
 
83
        return self.env.idmef_db.getHeartbeat(ident)
 
84
 
 
85
    def _setMessage(self, message, ident):
 
86
        msg = self.listed_heartbeat(self.view_name, self.env, self.parameters)
 
87
        msg.view_name = self.view_name
 
88
        msg.setMessage(message, ident)
 
89
 
 
90
        return msg
 
91
 
 
92
    def _applyInlineFilters(self, criteria):
 
93
        filter_found = False
 
94
        for column, path in (("name", "heartbeat.analyzer(-1).name"),
 
95
                             ("model", "heartbeat.analyzer(-1).model"),
 
96
                             ("address", "heartbeat.analyzer(-1).node.address.address"),
 
97
                             ("node_name", "heartbeat.analyzer(-1).node.name")):
 
98
            self.dataset[column + "_filtered"] = False
 
99
            if not filter_found:
 
100
                if self.parameters.has_key(path):
 
101
                    criteria.append("%s == '%s'" % (path, utils.escape_criteria(self.parameters[path])))
 
102
                    self.dataset[column + "_filtered"] = True
 
103
                    filter_found = True
 
104
        
 
105
    def _deleteMessage(self, ident):
 
106
        self.env.idmef_db.deleteHeartbeat(ident)
 
107
 
 
108
    def render(self):
 
109
        self._deleteMessages()
 
110
        criteria = [ ]
 
111
        start = end = None
 
112
 
 
113
        if self.parameters.has_key("timeline_unit") and self.parameters["timeline_unit"] != "unlimited":
 
114
            start, end = self._getTimelineRange()
 
115
            criteria.append("heartbeat.create_time >= '%s' && heartbeat.create_time < '%s'" % (str(start), str(end)))
 
116
        self._applyInlineFilters(criteria)
 
117
        self._adjustCriteria(criteria)
 
118
 
 
119
        self._setTimeline(start, end)
 
120
        self._setNavPrev(self.parameters["offset"])
 
121
 
 
122
        count = self.env.idmef_db.countHeartbeats(criteria and " && ".join(criteria) or None)
 
123
 
 
124
        self._setMessages(criteria)
 
125
 
 
126
        self._setHiddenParameters()
 
127
        
 
128
        self.dataset["nav.from"] = self.parameters["offset"] + 1
 
129
        self.dataset["nav.to"] = self.parameters["offset"] + len(self.dataset["messages"])
 
130
        self.dataset["limit"] = self.parameters["limit"]
 
131
        self.dataset["total"] = count
 
132
 
 
133
        self._setNavNext(self.parameters["offset"], count)
 
134
        self._setTimezone()
 
135
 
 
136
 
 
137
 
 
138
class SensorHeartbeatListing(HeartbeatListing, view.View):
 
139
    view_name = "sensor_heartbeat_listing"
 
140
    view_parameters = SensorHeartbeatListingParameters
 
141
    view_permissions = [ User.PERM_IDMEF_VIEW ]
 
142
    view_template = "SensorHeartbeatListing"
 
143
 
 
144
    listed_heartbeat = ListedHeartbeat
 
145
 
 
146
    def _adjustCriteria(self, criteria):
 
147
        criteria.append("heartbeat.analyzer.analyzerid == %d" % self.parameters["analyzerid"])
 
148
 
 
149
    def _setHiddenParameters(self):
 
150
        HeartbeatListing._setHiddenParameters(self)
 
151
        self.dataset["hidden_parameters"].append(("analyzerid", self.parameters["analyzerid"]))
 
152
 
 
153
    def render(self):
 
154
        HeartbeatListing.render(self)
 
155
        self.dataset["analyzer"] = self.env.idmef_db.getAnalyzer(self.parameters["analyzerid"])