40

    parser.add_option_group(pvl.verkko.db.parser(parser, table=db.wlan_sta))

    54

from pvl.verkko import db

    56

class WlanStaDatabase (object) :

    59

    DB_TABLE = db.wlan_sta

    60

    DB_LAST_SEEN = db.wlan_sta.c.last_seen

    61

    DB_SELECT = (db.dhcp_hosts.c.gw, db.dhcp_hosts.c.ip)

    62

    63

    def __init__ (self, db, interface_map=None) :

    67

        self.db = db

    70

    71

    def select (self, distinct=DB_SELECT, interval=None) :

    72

        """

    73

            SELECT unique gw/ip hosts, for given interval.

    74

        """

    75

    76

        query = db.select(distinct, distinct=True)

    77

    78

        if interval :

    79

            # timedelta

    80

            query = query.where(db.func.now() - self.DB_LAST_SEEN < interval)

    81

    82

        return self.db.select(query)

    83

    84

    def insert (self, key, update, timestamp, count=True) :

    85

        """

    86

            INSERT new host

    87

        """

    88

    89

        query = self.DB_TABLE.insert().values(**key).values(**update).values(

    90

                first_seen  = timestamp,

    91

                last_seen   = timestamp,

    92

        )

    93

    94

        if count :

    95

            query = query.values(count=1)

    96

    97

        # -> id

    98

        return self.db.insert(query)

    99

   100

    def update (self, key, update, timestamp, count=True) :

   101

        """

   102

            UPDATE existing host, or return False if not found.

   103

        """

   104

   105

        table = self.DB_TABLE

   106

        query = table.update()

   107

   108

        for col, value in key.iteritems() :

   109

            query = query.where(table.c[col] == value)

   110

   111

        query = query.values(last_seen=timestamp)

   112

   113

        if count :

   114

            query = query.values(count=db.func.coalesce(table.c.count, 0) + 1)

   115

   116

        query = query.values(**update)

   117

   118

        # -> any matched rows?

   119

        return self.db.update(query)

   120

   121

    def touch (self, key, update, timestamp, **opts) :

   122

        # update existing?

   123

        if self.update(key, update, timestamp, **opts) :

   124

            log.info("Update: %s: %s: %s", key, update, timestamp)

   125

        else :

   126

            log.info("Insert: %s: %s: %s", key, update, timestamp)

   127

            self.insert(key, update, timestamp, **opts)

   128

   139

        return match.groupdict()

   141

    def __call__ (self, item) :

   142

        match = self.parse(item)

   143

   144

        if not match :

   145

            return

   146

   147

        # lookup?

   148

        ap, wlan = item['host'], match['wlan']

   156

        # update/insert

   157

        self.touch(

   158

            dict(

   162

            ), dict(

   164

            ), item['timestamp']

   169

   170

    # database

   171

    db = pvl.verkko.db.apply(options)

   181

   182

    # handler

   183

    handler = WlanStaDatabase(db, interface_map=interfaces)

   188

            handler(item)