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('main')

    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

    prog = argv[0]

    27

    28

    parser = optparse.OptionParser(

    29

            prog        = prog,

    30

            usage       = '%prog: [options]',

    31

            version     = __version__,

    32

    33

            # module docstring

    34

            description = __doc__,

    35

    )

    36

    37

    # logging

    38

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

    39

    40

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

    41

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

    42

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

    43

    44

    parser.add_option_group(general)

    45

    46

    # defaults

    47

    parser.set_defaults(

    48

        loglevel            = logging.WARN,

    49

        expand              = [],

    50

    )

    51

    52

    # parse

    53

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

    54

    55

    # configure

    56

    logging.basicConfig(

    57

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

    58

        level   = options.loglevel,

    59

    )

    60

    61

    return options, args

    62

    63

# date fmt to use in serial

    64

DATE_FMT = '%Y%m%d'

    65

DATE_LEN = 8

    66

    67

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

    68

SERIAL_LEN = 10

    69

    70

def format_serial (date, count) :

    71

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

    72

    73

def next_count (value, date, count) :

    74

    """

    75

        Return serial with next count.

    76

    """

    77

    78

    count += 1

    79

    80

    # check

    81

    if count > 99 :

    82

        serial = str(value + 1)

    83

    84

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

    85

    86

        return serial

    87

    88

    return format_serial(date, count)

    89

    90

def update_serial (serial) :

    91

    """

    92

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

    93

    """

    94

    95

    today = datetime.now().date()

    96

    97

    # handle

    98

    if not serial :

    99

        # fresh

   100

        log.info("Setting initial serial: %s01", today)

   101

   102

        return format_serial(today, 1)

   103

   104

    elif len(serial) != SERIAL_LEN :

   105

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

   106

   107

        value = int(serial)

   108

        serial = str(value + 1)

   109

   110

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

   111

   112

        return serial

   113

   114

    else :

   115

        # parse

   116

        value = int(serial)

   117

   118

        try :

   119

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

   120

            count = int(serial[DATE_LEN:])

   121

   122

        except ValueError, e :

   123

            # invalid date/count format?

   124

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

   125

   126

            serial = str(value + 1)

   127

   128

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

   129

   130

            return serial

   131

   132

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

   133

   134

    # update

   135

    if date < today :

   136

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

   137

   138

        # update date

   139

        return format_serial(today, 1)

   140

   141

    elif date == today :

   142

        # keep date, update count

   143

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

   144

   145

        # handle count rollover

   146

        return next_count(value, date, count)

   147

   148

    elif date > today :

   149

        # keep, update count

   150

        serial = next_count(value, date, count)

   151

   152

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

   153

   154

        return serial

   155

   156

    else :

   157

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

   158

   159

def process_serial (path) :

   160

    """

   161

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

   162

    """

   163

   164

    # read

   165

    if os.path.exists(path) :

   166

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

   167

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

   168

   169

    else :

   170

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

   171

        serial = None

   172

   173

    # update

   174

    serial = update_serial(serial)

   175

   176

    # write

   177

    open(path, 'w').write(serial + '\n')

   178

   179

    return serial

   180

   181

def main (argv) :

   182

    global options

   183

   184

    options, args = parse_options(argv)

   185

   186

    # serial files to update

   187

    for path in args :

   188

        process_serial(path)

   189

   190

    return 0

   191

   192

if __name__ == '__main__':

   193

    import sys

   194

   195

    sys.exit(main(sys.argv))