class IDMEFTime(object):

    def __init__(self, res):

        self._res = res

    def __del__(self):

        idmef_time_destroy(self._res)

    def __int__(self):

        return idmef_time_get_sec(self._res)

    def __float__(self):

        return float(idmef_time_get_sec(self._res)) + float(idmef_time_get_usec(self._res)) / 10 ** 6

    def toYMDHMS(self):

        return time_to_ymdhms(time.localtime(idmef_time_get_sec(self._res)))

    def __getattribute__(self, name):

        if name is "sec":

            return idmef_time_get_sec(self._res)

    except KeyError:

        return None

class Message:

    def __init__(self, res, htmlsafe):

        self._res = res

        self._value_list = None

        self._htmlsafe = htmlsafe

    def __del__(self):

        idmef_message_destroy(self._res)

    def __iter__(self):

        if not self._value_list:

            raise TypeError, "iteration over a non-sequence"

        self._list_iterator = 0

        return self

            return idmef_value_get_count(self._value_list)

        return 1

    def next(self):

        next = idmef_value_get_nth(self._value_list, self._list_iterate)

        if not next:

        value = self._convert_value(next, self._root + "(%d)" % self._list_iterate)

        self._list_iterate += 1

        return value

    def _convert_value(self, idmef_value, key):

            value._value_list = idmef_value

            if self._value_list:

                idmef_value_ref(idmef_value)

        elif idmef_value_get_type(idmef_value) != IDMEF_VALUE_TYPE_CLASS:

            value = convert_idmef_value(idmef_value)

            if not self._value_list:

                idmef_value_destroy(idmef_value)

        else:

            if not self._value_list:

                idmef_value_destroy(idmef_value)

            value = Message(idmef_message_ref(self._res), self._htmlsafe)

            value._root = key

        return value

    def _get_raw_value(self, key):

        path = idmef_path_new_fast(key)

        idmef_value = idmef_path_get(path, self._res)

        if idmef_value:

            ret = self._convert_value(idmef_value, key)

        else:

                ret = []

            else:

                ret = None

        idmef_path_destroy(path)

        return ret

            return escape_value(self._get_raw_value(key))

        else:

            return self._get_raw_value(key)

    def match(self, criteria):

        if type(criteria) is list:

            criteria = " && ".join(criteria)

        return ret

        if htmlsafe != None:

            htmlsafe_bkp = self._htmlsafe

            self._htmlsafe = htmlsafe

        if val == None:

                val = default

        if htmlsafe != None:

            self._htmlsafe = htmlsafe_bkp

        return val

    def getAdditionalData(self, searched, many_values=False):

            meaning = self["%s.additional_data(%d).meaning" % (self._root, i)]

            if meaning is None:

                break

            if meaning == searched:

                value = self["%s.additional_data(%d).data" % (self._root, i)]

                if not many_values:

                    return value

                values.append(value)

            i += 1

        self._rows = [ ]

        self._has_cache = False

        self._res, self._len = results

    def __iter__(self):

        if self._has_cache:

            return iter(self._rows)

        else:

            return self

    def __len__(self):

        return self._len

    def __del__(self):

        if self._res:

            self._db_delete(self._res)

    def __getitem__(self, key):

        if isinstance(key, types.SliceType):

            start, stop, step = key.start, key.stop, key.step

            index = start + stop

        else:

            index = key

        if not self._has_cache:

            for r in self:

                if len(self._rows) >= index:

                    break

        return self._rows[key]

        if self._res == None:

            raise StopIteration

            raise StopIteration

        row = self._db_convert_row(values)

        self._rows.append(row)

        return row

class DbResultValues(DbResult):

    def __init__(self, selection, results):

        self._selection = selection

        DbResult.__init__(self, results)

    def _db_get_next(self):

        return preludedb_result_values_get_next(self._res)

    def _db_delete(self, result):

        if self._selection:

            preludedb_path_selection_destroy(self._selection)

        if result:

            preludedb_result_values_destroy(result)

    def _db_convert_row(self, values):

        row = []

        for value in values:

               row.append(None)

           else:

               row.append(convert_idmef_value(value))

        return row

class DbResultIdents(DbResult):

    def _db_get_next(self):

        return preludedb_result_idents_get_next(self._res)

    def _db_delete(self, result):

        if result:

            preludedb_result_idents_destroy(result)

    def _db_convert_row(self, value):

        return value

class IDMEFDatabase:

    _db_destroy = preludedb_destroy

    _db = None

    def __init__(self, config):

        settings = preludedb_sql_settings_new()

        for param in "file", "host", "port", "name", "user", "pass":

                raise "libpreludedb %s or higher is required (%s found)." % (wanted_version, cur)

            else:

                raise "libpreludedb %s or higher is required." % wanted_version

        self._db = preludedb_new(sql, None)

    def __del__(self):

        if self._db:

            self._db_destroy(self._db)

    def _getMessageIdents(self, get_message_idents, criteria, limit, offset, order_by):

        if type(criteria) is list:

            if len(criteria) == 0:

                criteria = None

            else:

                criteria = " && ".join(criteria)

        if criteria:

            criteria = idmef_criteria_new_from_string(criteria)

        idents = [ ]

        if order_by == "time_asc":

            order_by = PRELUDEDB_RESULT_IDENTS_ORDER_BY_CREATE_TIME_ASC

        else:

            order_by = PRELUDEDB_RESULT_IDENTS_ORDER_BY_CREATE_TIME_DESC

            result = get_message_idents(self._db, criteria, limit, offset, order_by)

        except:

            self._freeDbParams(criteria=criteria)

            raise

        if criteria:

            idmef_criteria_destroy(criteria)

        if not result:

        return DbResultIdents(result)

    def getAlertIdents(self, criteria=None, limit=-1, offset=-1, order_by="time_desc"):

        return self._getMessageIdents(preludedb_get_alert_idents2, criteria, limit, offset, order_by)

    def _getLastMessageIdent(self, type, get_message_idents, analyzerid):

        criteria = None

        idents = get_message_idents(criteria, limit=1)

        return idents[0]

        return self._getLastMessageIdent("alert", self.getAlertIdents, analyzer)

        return self._getLastMessageIdent("heartbeat", self.getHeartbeatIdents, analyzer)

    def getAlert(self, ident, htmlsafe=False):

    def _freeDbParams(self, selection=None, criteria=None):

        if selection:

            preludedb_path_selection_destroy(selection)

        if criteria:

            idmef_criteria_destroy(criteria)

    def getValues(self, selection, criteria=None, distinct=0, limit=-1, offset=-1):

        if type(criteria) is list:

            if len(criteria) == 0:

                criteria = None

            else:

                criteria = " && ".join([ "(" + c + ")" for c in criteria ])

        if criteria:

            criteria = idmef_criteria_new_from_string(criteria)

        my_selection = preludedb_path_selection_new()

        for selected in selection:

            my_selected = preludedb_selected_path_new_string(selected)

        except:

            self._freeDbParams(my_selection, criteria)

            raise

        if criteria:

        if not result:

            preludedb_path_selection_destroy(my_selection)

            return [ ]

        return DbResultValues(my_selection, result)

    def _countMessages(self, root, criteria):

        return self.getValues(["count(%s.create_time)" % root], criteria)[0][0]

    def countAlerts(self, criteria=None):

        return self._countMessages("alert", criteria)

                index += 1

            analyzer_paths.append(path)

    def getAnalyzer(self, analyzerid):

        ident = self.getLastHeartbeatIdent(analyzerid)

        heartbeat = self.getHeartbeat(ident)

                break

    if time.time() - int(heartbeat_time) > int(heartbeat_interval) + error_margin:

        return "missing", _("Missing")

    return "online", _("Online")

def analyzer_cmp(x, y):

    xmiss = x["status"] == "missing"

    ymiss = y["status"] == "missing"

    if xmiss and ymiss:

        return cmp(x["name"], y["name"])

    elif xmiss or ymiss:

        return ymiss - xmiss

    else:

        return cmp(x["name"], y["name"])

def node_cmp(x, y):

    xmiss = x["missing"]

    ymiss = y["missing"]

    if xmiss or ymiss:

    else:

        return cmp(x["node_name"], y["node_name"])

    def init(self, env):

        self._heartbeat_count = int(env.config.general.getOptionValue("heartbeat_count", 30))

        self._heartbeat_error_margin = int(env.config.general.getOptionValue("heartbeat_error_margin", 3))

    def render(self):

        analyzers = { }

        locations = { }

        nodes = { }

            analyzer = self.env.idmef_db.getAnalyzer(analyzerid)

            parameters = { "analyzerid": analyzer["analyzerid"] }

            analyzer["alert_listing"] = utils.create_link("sensor_alert_listing", parameters)

            analyzer["heartbeat_listing"] = utils.create_link("sensor_heartbeat_listing", parameters)

            analyzer["heartbeat_analyze"] = utils.create_link("heartbeat_analyze", parameters)

                analyzer["node_name_link"] = utils.create_link(self.view_name,

                                                               { "filter_path": "heartbeat.analyzer(-1).node.name",

                analyzer["node_location_link"] = utils.create_link(self.view_name,

                                                                   { "filter_path": "heartbeat.analyzer(-1).node.location",

            node_key = ""

            for i in range(len(analyzer["node_addresses"])):

                addr = analyzer["node_addresses"][i]

                node_key += addr

                analyzer["node_addresses"][i] = {}

                analyzer["node_addresses"][i]["value"] = addr

                analyzer["node_addresses"][i]["inline_filter"] = utils.create_link(self.view_name,

                                                                           utils.create_link("Command",

                                                                                             { "origin": self.view_name,

                                                                                               "command": command, "host": addr })))

            analyzer["status"], analyzer["status_meaning"] = \

                                get_analyzer_status_from_latest_heartbeat(analyzer["last_heartbeat_status"],

                                                                          analyzer["last_heartbeat_time"],

            analyzer["last_heartbeat_time"] = utils.time_to_ymdhms(time.localtime(int(analyzer["last_heartbeat_time"]))) + \

                                              " %+.2d:%.2d" % utils.get_gmt_offset()

            osversion = analyzer["osversion"] or _("OS version n/a")

            ostype = analyzer["ostype"] or _("OS type n/a")

            addresses = analyzer["node_addresses"]

            node_key = node_name + osversion + ostype

            if not locations.has_key(node_location):

                locations[node_location] = { "total": 1, "missing": 0, "unknown": 0, "offline": 0, "online": 0, "nodes": { } }

            else:

                locations[node_location]["nodes"][node_key] = { "total": 1, "missing": 0, "unknown": 0, "offline": 0, "online": 0,

                                                                "analyzers": [ ],

                                                                "node_name": node_name, "node_location": node_location,

                                                                "node_addresses": addresses, "node_key": node_key }

            else:

                locations[node_location]["nodes"][node_key]["total"] += 1

            status = analyzer["status"]

            locations[node_location][status] += 1

            locations[node_location]["nodes"][node_key][status] += 1

                locations[node_location]["nodes"][node_key]["analyzers"].insert(0, analyzer)

            else:

                locations[node_location]["nodes"][node_key]["analyzers"].append(analyzer)

        self.dataset["locations"] = locations

class SensorMessagesDelete(SensorListing):

    view_name = "sensor_messages_delete"

            if self.parameters.has_key("heartbeats"):

                criteria = "heartbeat.analyzer(-1).analyzerid == %d" % long(analyzerid)

                self.env.idmef_db.deleteHeartbeat(self.env.idmef_db.getHeartbeatIdents(criteria))

        SensorListing.render(self)

    def init(self, env):

        self._heartbeat_count = int(env.config.general.getOptionValue("heartbeat_count", 30))

        self._heartbeat_error_margin = int(env.config.general.getOptionValue("heartbeat_error_margin", 3))

    def render(self):

        analyzerid = self.parameters["analyzerid"]

        analyzer = self.env.idmef_db.getAnalyzer(analyzerid)

        analyzer["last_heartbeat_time"] = str(analyzer["last_heartbeat_time"])

        analyzer["events"] = [ ]

        analyzer["status"] = "abnormal_offline"

        analyzer["status_meaning"] = "abnormal offline"

        start = time.time()

        idents = self.env.idmef_db.getHeartbeatIdents(criteria="heartbeat.analyzer(-1).analyzerid == %d" % analyzerid,

                                                      limit=self._heartbeat_count)

                    analyzer["events"].append({ "value": "sensor is down since %s" % older_time, "type": "down"})

            if newer:

                event = None

                if newer_status == "starting":

                    if older_status == "exiting":

                        event = { "value": "normal sensor start at %s" % str(newer_time),

                    if abs(int(newer_time) - int(older_time) - int(older_interval)) > self._heartbeat_error_margin:

                        event = { "value": "abnormal heartbeat interval between %s and %s" % (str(older_time), str(newer_time)),

                                  "type": "abnormal_heartbeat_interval" }

                if newer_status == "exiting":

                    event = { "value": "normal sensor stop at %s" % str(newer_time),