67

    def network (self) :

    68

        return self.gw

    69

   111

   146

def column (attr, title, column, rowhtml=None, sort=True, filter=True, colcss=True, rowfilter=True, rowtitle=None, rowcss=None) :

   147

    """

   148

        web.Table column spec.

   149

    """

   150

   151

    return (attr, title, column, sort, filter, colcss, rowhtml, rowfilter, rowtitle, rowcss)

   152

   164

   165

    TABLE = Host

   166

    TABLE_COLUMNS = (

   167

        #column('id',    "#",        Host.id         ),

   168

        column('ip',    "IP",       Host.ip,        ),

   169

        column('mac',   "MAC",      Host.mac,       Host.render_mac),

   170

        column('name',  "Hostname", Host.name,      Host.render_name, rowfilter=False),

   171

        column('gw',    "Network",  Host.gw,        Host.network, rowfilter=False),

   172

        column('seen',  "Seen",     Host.last_seen, Host.seen, rowfilter=False),

   173

        column('state', "State",    Host.count,     rowtitle=Host.state_title, rowcss=Host.state_class, rowfilter=False),

   174

    )

   175

   176

    # attr -> column

   177

    TABLE_ATTRS = dict((attr, column) for attr, title, column, sort, filter, colcss, rowhtml, rowfilter, rowtitle, rowcss in TABLE_COLUMNS)

   178

   179

    # default sort

   180

    TABLE_SORT = Host.last_seen.desc()

   181

   182

    # items per page

   183

    TABLE_PAGE = 10

   184

   185

    # target for items

   186

    TABLE_URL = None

   187

    TABLE_ITEM_URL = None

   190

        """

   191

            Database SELECT query.

   192

        """

   193

   194

        return self.db.query(self.TABLE)

   196

    def sort (self, query, default=TABLE_SORT) :

   197

        """

   198

            Apply ?sort= from requset args to query.

   199

   200

            Return { attr: sort }, query

   201

        """

   202

   211

            order_by = self.TABLE_ATTRS[name]

   215

        # prefix -> ordering

   224

   225

        # apply

   228

        query = query.order_by(order_by)

   230

        return sort, query

   232

    def filter_seen (self, value) :

   233

        """

   234

            Return filter expression for given attr == value

   235

        """

   236

   237

        column = Host.last_seen

   238

   239

        if value.isdigit() :

   240

            # specific date

   241

            date = datetime.datetime.strptime(value, Host.DATE_FMT).date()

   242

   243

            return db.between(date.strftime(Host.DATE_FMT), 

   244

                    db.func.strftime(Host.DATE_FMT, Host.first_seen),

   245

                    db.func.strftime(Host.DATE_FMT, Host.last_seen)

   246

            )

   247

        else :

   248

            # recent

   249

            timedelta = parse_timedelta(value)

   250

   251

            return ((db.func.now() - Host.last_seen) < timedelta)

   252

   253

            # XXX: for sqlite, pgsql should handle this natively?

   254

            # to seconds

   255

            #timeout = timedelta.days * (24 * 60 * 60) + timedelta.seconds

   256

   257

            # WHERE strftime('%s', 'now') - strftime('%s', last_seen) < :timeout

   258

            #filter = (db.func.strftime('%s', 'now') - db.func.strftime('%s', Host.last_seen) < timeout)

   259

   260

    def filter_ip (self, value) :

   261

        column = Host.ip

   262

   263

        # column is IPv4 string literal format...

   264

        if '/' in value :

   265

            return (db.func.inet(Host.ip).op('<<')(db.func.cidr(value)))

   266

        else :

   267

            return (db.func.inet(Host.ip) == db.func.inet(value))

   268

   269

    def filter_mac (self, value) :

   270

        return self.filter_attr('mac', Host.normalize_mac(value))

   271

   277

        # preprocess

   278

        like = False

   280

        if value.endswith('*') :

   281

            like = value.replace('*', '%')

   283

        # filter

   284

        column = self.TABLE_ATTRS[attr]

   286

        if like :

   287

            return (column.like(like))

   289

            return (column == value)

   290

   291

    def _filter (self, attr, values) :

   292

        """

   293

            Apply filters for given attr -> (value, expression)

   294

        """

   296

        for value in values :

   297

            value = value.strip()

   298

   299

            # ignore empty fields

   300

            if not value :

   301

                continue

   303

            # lookup attr-specific filter

   304

            filter = getattr(self, 'filter_{attr}'.format(attr=attr), None)

   305

   306

            if filter :

   307

                filter = filter(value)

   309

                # use generic

   310

                filter = self.filter_attr(attr, value)

   311

   312

            log.debug("%s: %s: %s", attr, value, filter)

   313

   314

            yield value, filter

   316

    def filter (self, query) :

   326

        for attr in self.TABLE_ATTRS :

   327

            # from request args

   328

            values = self.request.args.getlist(attr)

   329

   330

            # lookup attr filters as expressions

   331

            value_filters = list(self._filter(attr, values))

   334

            if not value_filters :

   336

   337

            # filtering values, and filter expressions

   338

            values, expressions = zip(*value_filters)

   340

            # apply

   341

            query = query.filter(db.or_(*expressions))

   344

        return filters, query

   353

    def render_table (self, query, caption=None, sort=None, filters=None, page=None, hilight=None) :

   354

        """

   355

            Return <table> element. Wrapped in <form> if filters.

   357

                query   - filter()'d sort()'d SELECT query()

   358

                caption - optional <caption>

   359

                sort    - None for no sorting ui, sort-attr otherwise.

   360

                filters - None for no filtering ui, dict of filters otherwise.

   361

                page    - display pagination for given page

   362

                hilight - { attr: value } cells to hilight

   363

        """

   364

   365

        def url (filters=filters, sort=sort, **opts) :

   366

            """

   367

                URL for table with given opts, keeping our sorting/filtering unless overriden.

   368

            """

   369

   374

   375

            if sort :

   376

                args['sort'] = sort

   377

   378

            if opts :

   379

                args.update(opts)

   381

            return self.url(self.TABLE_URL, **args)

   382

   383

        def sorturl (attr, sort=sort) :

   384

            """

   385

                URL for table sorted by given column, reversing direction if already sorting by given column.

   386

            """

   387

   388

            if not sort :

   390

            elif sort.lstrip('+-') != attr :

   392

            elif sort.startswith('-') :

   397

            return url(sort=sort)

   399

        def itemurl (item) :

   401

                URL for given item, by id.

   402

            """

   403

   404

            if self.TABLE_ITEM_URL :

   405

                # separate page

   406

                return self.url(self.TABLE_ITEM_URL, id=item.id)

   407

            else :

   408

                # to our table

   409

                return url() + '#{id}'.format(id=item.id)

   410

   411

        def render_filter (attr) :

   412

            """

   413

                Render filter-input for column.

   414

            """

   415

   416

            value = filters.get(attr)

   417

   418

            if value :

   419

                # XXX: multi-valued filters?

   420

                value = value[0]

   421

            else :

   422

                value = None

   423

   424

            return html.input(type='text', name=attr, value=value)

   425

   426

        def render_head () :

   427

            """

   428

                Yield header, filter rows for columns in table header.

   429

            """

   430

   431

            # id

   432

            yield html.td('#'), html.td(html.input(type='submit', value=u'\u00BF'))

   433

   434

            for attr, title, column, sort, filter, colcss, rowhtml, rowfilter, rowtitle, rowcss in self.TABLE_COLUMNS :

   435

                header = title

   436

   437

                if sort :

   438

                    header = html.a(href=sorturl(attr))(header)

   439

   440

                header = html.th(header)

   441

   442

                if filters is not None and filter :

   443

                    filter = render_filter(attr)

   444

                else  :

   445

                    filter = None

   446

   447

                if colcss is True :

   448

                    colcss = attr

   449

   450

                filter = html.td(class_=colcss)(filter)

   451

   452

                yield header, filter

   453

   454

        def render_cell (attr, value, rowhtml=None, colcss=True, filter=None, rowtitle=None, rowcss=None, hilight=hilight) :

   455

            """

   456

                Render a single cell.

   457

   458

                    colcss      - css class for column; True -> attr

   459

                    filter      - render filter link for value?

   460

                    htmlvalue   - rendered value?

   461

                    title       - mouseover title for cell

   462

                    rowcss      - css class for row

   463

            """

   464

   465

            if not rowhtml :

   466

                rowhtml = value

   467

   468

            if filter :

   469

                cell = html.a(href=url(filters=None, **{attr: value}))(rowhtml)

   470

            else :

   471

                cell = rowhtml

   472

   473

            if colcss is True :

   474

                colcss = attr

   475

   476

            if hilight :

   477

                hilight = attr in hilight and value in hilight[attr]

   478

   479

            css = (colcss, rowcss, 'hilight' if hilight else None)

   480

            css = ' '.join(cls for cls in css if cls)

   481

   482

            return html.td(class_=css, title=rowtitle)(cell)

   483

   484

        def render_row (item) :

   485

            """

   486

                Yield columns for row.

   487

            """

   488

   489

            for attr, title, column, sort, filter, colcss, rowhtml, rowfilter, rowtitle, rowcss in self.TABLE_COLUMNS :

   490

                # XXX: this is sometimes broken, figure out how to index by column

   491

                value = getattr(item, attr)

   492

   493

                if rowhtml :