1

"""

     2

    Format LogLines into some other representation

     3

"""

     4

     5

import re, xml.sax.saxutils

     6

     7

from log_line import LogTypes

     8

from log_formatter_pil import PILImageFormatter

    10

    11

class LogFormatter (object) :

    12

    """

    13

        Provides a method to format series of LogLines into various output formats, with varying themes.

    14

    """

    15

    16

    # machine-readable name

    17

    name = None

    18

    19

    # human-readable name

    20

    title = None

    21

    22

    ## parameters

    23

    # use a fixed-width font for HTML output

    24

    html_fixedwidth = True

    25

    26

    def __init__ (self, tz, timestamp_fmt, img_ttf_path, img_font_size) :

    27

        """

    28

            Initialize to format timestamps with the given timezone and timestamp.

    29

    30

            Use the given TTF font to render image text with the given size, if given, otherwise, a default one.

    31

        """

    32

    33

        self.tz = tz

    34

        self.timestamp_fmt = timestamp_fmt

    35

        self.img_ttf_path = img_ttf_path

    36

        self.img_font_size = img_font_size

    37

    38

    def _format_line_text (self, line, template_dict, full_timestamp=False) :

    39

        """

    40

            Format the given line as text, using the given { type: string template } dict

    41

        """

    42

    43

        # look up the template

    44

        template = template_dict[line.type]

    45

    46

        # convert timestamp into display timezone

    47

        dtz = line.timestamp.astimezone(self.tz)

    48

    49

        # full timestamps?

    50

        if full_timestamp :

    51

            # XXX: ugly hack

    52

            timestamp_fmt = '%Y-%m-%d ' + self.timestamp_fmt

    53

    54

        else :

    55

            timestamp_fmt = self.timestamp_fmt

    56

    57

        # build timestamp

    58

        timestamp = dtz.strftime(timestamp_fmt)

    59

    60

        # format with dict

    61

        return template % dict(

    62

            timestamp       = timestamp,

    63

            source          = line.source,

    64

            data            = line.data,

    65

        )

    66

    67

    def format_txt (self, lines, full_timestamps=False) :

    68

        """

    69

            Format given lines as plaintext.

    70

    71

            If full_timestamps is given, the output will contain full timestamps with both date and time.

    72

    73

            No trailing newlines.

    74

        """

    75

    76

        abstract

    77

    78

    def format_html (self, lines, full_timestamps=False) :

    79

        """

    80

            Format as HTML.

    81

    82

            See format_txt for information about arguments

    83

        """

    84

    85

        abstract

    86

    88

        """

    89

            Format as a PNG image, returning the binary PNG data

    90

        """

    91

   101

class BaseHTMLFormatter (object) :

   102

    """

   103

        Implements some HTML-formatting utils

   104

    """

   105

   106

    URL_REGEXP = re.compile(r"http://\S+")

   107

   108

    def _process_links (self, line) :

   109

        """

   110

            Processed the rendered line, adding in <a href>'s for things that look like URLs, returning the new line.

   111

   112

            The line should already be escaped

   113

        """

   114

   115

        def _encode_url (match) :

   116

            # encode URL

   117

            url_html = match.group(0)

   118

            url_link = xml.sax.saxutils.unescape(url_html)

   119

   120

            return '<a href="%(url_link)s">%(url_html)s</a>' % dict(url_link=url_link, url_html=url_html)

   121

   122

        return self.URL_REGEXP.sub(_encode_url, line)

   123

   125

    """

   126

        Implements format_txt for irssi-style output

   127

    """

   128

   129

    # format definitions by type

   130

    __FMT = {

   131

        LogTypes.RAW        : "%(timestamp)s %(data)s",

   132

    }

   133

   134

    def format_txt (self, lines, full_timestamps=False) :

   135

        # ...handle each line

   136

        for line in lines :

   137

            # using __TYPES

   138

            yield line, self._format_line_text(line, self.__FMT, full_timestamps)

   139

   140

class IrssiFormatter (IrssiTextFormatter, BaseHTMLFormatter) :

   141

    """

   142

        Implements plain black-and-white irssi-style formatting

   143

    """

   144

   145

    # name

   146

    name = 'irssi'

   147

    title = "Irssi (plain)"

   148

   149

    # parameters

   150

    html_fixedwidth = True

   151

   152

    def format_html (self, lines, **kwargs) :

   153

        """

   154

            Just uses format_txt, but processes links, etc

   155

        """

   156

   157

        # format using IrssiTextFormatter

   158

        for line, txt in self.format_txt(lines, **kwargs) :

   159

            # escape HTML

   160

            html = xml.sax.saxutils.escape(txt)

   161

   162

            # process links

   163

            html = self._process_links(html)

   164

   165

            # yield

   166

            yield line, html

   167

   168

def by_name (name) :

   169

    """

   170

        Lookup and return a class LogFormatter by name

   171

    """

   172

   173

    return FORMATTERS[name]

   174