1

#!/usr/bin/env python

     2

# vim: set ft=python :

     3

     4

"""

     5

    Update zone serials.

     6

"""

     7

     8

__version__ = '0.0.1-dev'

     9

    10

import optparse

    11

import codecs

    12

import os.path

    13

from datetime import datetime

    14

import logging

    15

    16

log = logging.getLogger()

    17

    18

# command-line options, global state

    19

options = None

    20

    21

def parse_options (argv) :

    22

    """

    23

        Parse command-line arguments.

    24

    """

    25

    26

    parser = optparse.OptionParser(

    27

            prog        = argv[0],

    28

            usage       = '%prog: [options]',

    29

            version     = __version__,

    30

    31

            # module docstring

    32

            description = __doc__,

    33

    )

    34

    35

    # logging

    36

    general = optparse.OptionGroup(parser, "General Options")

    37

    38

    general.add_option('-q', '--quiet',     dest='loglevel', action='store_const', const=logging.ERROR, help="Less output")

    39

    general.add_option('-v', '--verbose',   dest='loglevel', action='store_const', const=logging.INFO,  help="More output")

    40

    general.add_option('-D', '--debug',     dest='loglevel', action='store_const', const=logging.DEBUG, help="Even more output")

    41

    42

    parser.add_option_group(general)

    43

    44

    # defaults

    45

    parser.set_defaults(

    46

        loglevel            = logging.WARN,

    47

        expand              = [],

    48

    )

    49

    50

    # parse

    51

    options, args = parser.parse_args(argv[1:])

    52

    53

    # configure

    54

    logging.basicConfig(

    55

        format  = '%(processName)s: %(name)s: %(levelname)s %(funcName)s : %(message)s',

    56

        level   = options.loglevel,

    57

    )

    58

    59

    return options, args

    60

    61

# date fmt to use in serial

    62

DATE_FMT = '%Y%m%d'

    63

DATE_LEN = 8

    64

    65

SERIAL_FMT = "{date:8}{count:02}"

    66

SERIAL_LEN = 10

    67

    68

def format_serial (date, count) :

    69

    return SERIAL_FMT.format(date=date.strftime(DATE_FMT), count=count)

    70

    71

def next_count (value, date, count) :

    72

    """

    73

        Return serial with next count.

    74

    """

    75

    76

    count += 1

    77

    78

    # check

    79

    if count > 99 :

    80

        serial = str(value + 1)

    81

    82

        log.warn("Serial count rollover: %s, %s; fallback -> %s", date, count, serial)

    83

    84

        return serial

    85

    86

    return format_serial(date, count)

    87

    88

def update_serial (serial) :

    89

    """

    90

        Update new serial number into given file, based on date.

    91

    """

    92

    93

    today = datetime.now().date()

    94

    95

    # handle

    96

    if not serial :

    97

        # fresh

    98

        log.info("Setting initial serial: %s:%s", date, count)

    99

   100

        return format_serial(today, 1)

   101

   102

    elif len(serial) != SERIAL_LEN :

   103

        log.warn("Invalid serial format: %s", serial)

   104

   105

        value = int(serial)

   106

        serial = str(value + 1)

   107

   108

        log.info("Incrementing serial: %d -> %s", value, serial)

   109

   110

        return serial

   111

   112

    else :

   113

        # parse

   114

        value = int(serial)

   115

   116

        try :

   117

            date = datetime.strptime(serial[:DATE_LEN], DATE_FMT).date()

   118

            count = int(serial[DATE_LEN:])

   119

   120

        except ValueError, e :

   121

            # invalid date/count format?

   122

            log.warn("Unable to parse serial: %s: %s", serial, e)

   123

   124

            serial = str(value + 1)

   125

   126

            log.info("Incrementing serial: %d -> %s", value, serial)

   127

   128

            return serial

   129

   130

        log.debug("old serial=%s, value=%d, date=%s, count=%s", serial, value, date, count)

   131

   132

    # update

   133

    if date < today :

   134

        log.info("Updating to today: %s -> %s", date, today)

   135

   136

        # update date

   137

        return format_serial(today, 1)

   138

   139

    elif date == today :

   140

        # keep date, update count

   141

        log.info("Updating today's count: %s, %s", date, count)

   142

   143

        # handle count rollover

   144

        return next_count(value, date, count)

   145

   146

    elif date > today :

   147

        # keep, update count

   148

        serial = next_count(value, date, count)

   149

   150

        log.warn("Serial in future; incrementing count: %s, %s -> %s", date, count, serial)

   151

   152

        return serial

   153

   154

    else :

   155

        raise Exception("Invalid serial: %s:%s", old_date, old_count)

   156

   157

def process_serial (path) :

   158

    """

   159

        Read old serial, generate new one, and update file.

   160

    """

   161

   162

    # read

   163

    if os.path.exists(path) :

   164

        serial = open(path).read().strip()

   165

        log.debug("current serial: %s", serial)

   166

   167

    else :

   168

        log.warn("Given .serial does not yet exist: %s", path)

   169

        serial = None

   170

   171

    # update

   172

    serial = update_serial(serial)

   173

   174

    # write

   175

    open(path, 'w').write(serial)

   176

   177

    return serial

   178

   179

def main (argv) :

   180

    global options

   181

   182

    options, args = parse_options(argv)

   183

   184

    # serial files to update

   185

    for path in args :

   186

        process_serial(path)

   187

   188

    return 0

   189

   190

if __name__ == '__main__':

   191

    import sys

   192

   193

    sys.exit(main(sys.argv))