1

#!/usr/bin/env python

     2

     3

"""

     4

    Process zonefiles.

     5

"""

     6

     7

__version__ = '0.0.1-dev'

     8

     9

import optparse

    10

import codecs

    11

from datetime import datetime

    12

import logging

    13

    14

log = logging.getLogger('main')

    15

    16

# command-line options, global state

    17

options = None

    18

    19

def parse_options (argv) :

    20

    """

    21

        Parse command-line arguments.

    22

    """

    23

    24

    prog = argv[0]

    25

    26

    parser = optparse.OptionParser(

    27

            prog        = prog,

    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

    # input/output

    45

    parser.add_option('-c', '--input-charset',  metavar='CHARSET',  default='utf-8', 

    46

            help="Encoding used for input files")

    47

    48

    parser.add_option('-o', '--output',         metavar='FILE',     default='-',

    49

            help="Write to output file; default stdout")

    50

    51

    parser.add_option('--output-charset',       metavar='CHARSET',  default='utf-8', 

    52

            help="Encoding used for output files")

    53

    54

    # check stage

    55

    parser.add_option('--check-hosts',          action='store_true',

    56

            help="Check that host/IPs are unique. Use --quiet to silence warnings, and test exit status")

    57

    58

    parser.add_option('--check-exempt',         metavar='HOST', action='append',

    59

            help="Allow given names to have multiple records")

    60

    61

    # meta stage

    62

    parser.add_option('--meta-zone',            action='store_true',

    63

            help="Generate host metadata zone; requires --input-line-date")

    64

    65

    parser.add_option('--meta-ignore',          metavar='HOST', action='append',

    66

            help="Ignore given hostnames in metadata output")

    67

    68

    parser.add_option('--input-line-date',      action='store_true',

    69

            help="Parse timestamp prefix from each input line (e.g. `hg blame | ...`)")

    70

    71

    # forward stage

    72

    parser.add_option('--forward-zone',         action='store_true', 

    73

            help="Generate forward zone")

    74

    75

    parser.add_option('--forward-txt',          action='store_true',

    76

            help="Generate TXT records for forward zone")

    77

    78

    parser.add_option('--forward-mx',           metavar='MX',

    79

            help="Generate MX records for forward zone")

    80

    81

    # reverse stage

    82

    parser.add_option('--reverse-domain',       metavar='DOMAIN',

    83

            help="Domain to use for hosts in reverse zone")

    84

    85

    parser.add_option('--reverse-zone',         metavar='NET',

    86

            help="Generate forward zone for given subnet (x.z.y)")

    87

    92

    # defaults

    93

    parser.set_defaults(

    94

        loglevel            = logging.WARN,

    95

    96

        # XXX: combine

    97

        check_exempt        = [],

    98

        meta_ignore         = [],

    99

    )

   100

   101

    # parse

   102

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

   103

   104

    # configure

   105

    logging.basicConfig(

   106

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

   107

        level   = options.loglevel,

   108

    )

   109

   110

    return options, args

   111

   123

class ZoneLine (object) :

   124

    """

   125

        A line in a zonefile.

   126

    """

   127

   128

    file = None

   129

    lineno = None

   130

   131

    # data

   132

    indent = None # was the line indented?

   133

    data = None

   134

    parts = None # split line fields

   135

   136

    # optional

   137

    timestamp = None

   138

    comment = None

   139

   140

    PARSE_DATETIME_FORMAT = '%Y-%m-%d'

   141

   142

    @classmethod

   143

    def parse (cls, file, lineno, line, line_timestamp_prefix=False) :

   144

        """

   145

            Parse out given line and build.

   146

        """

   147

   148

        log.debug("parse: %s:%d: %s", file, lineno, line)

   149

   150

        ts = None

   151

   152

        if line_timestamp_prefix :

   153

            if ': ' not in line :

   155

   156

            # split prefix

   157

            prefix, line = line.split(': ', 1)

   158

   159

            # parse it out

   160

            ts = datetime.strptime(prefix, cls.PARSE_DATETIME_FORMAT)

   161

   162

            log.debug("  ts=%r", ts)

   163

   164

        # was line indented?

   165

        indent = line.startswith(' ') or line.startswith('\t')

   166

   167

        # strip

   168

        line = line.strip()

   169

   170

        log.debug("  indent=%r, line=%r", indent, line)

   171

   172

        # parse comment out?

   173

        if ';' in line :

   174

            line, comment = line.split(';', 1)

   175

   176

            line = line.strip()

   177

            comment = comment.strip()

   178

   179

        else :

   180

            line = line.strip()

   181

            comment = None

   182

   183

        log.debug("  line=%r, comment=%r", line, comment)

   184

   185

        # parse fields

   186

        if '"' in line :

   187

            pre, data, post = line.split('"', 2)

   188

            parts = pre.split() + [data] + post.split()

   189

   190

        else :

   191

            parts = line.split()

   192

   193

        log.debug("  parts=%r", parts)

   194

   195

        # build

   196

        return cls(file, lineno, indent, line, parts, timestamp=ts, comment=comment)

   197

   198

    def __init__ (self, file, lineno, indent, data, parts, timestamp=None, comment=None) :

   199

        self.file = file

   200

        self.lineno = lineno

   201

   202

        self.indent = indent

   203

        self.data = data

   204

        self.parts = parts

   205

   206

        self.timestamp = timestamp

   207

        self.comment = comment

   208

   209

    def __str__ (self) :

   210

        return "{file}:{lineno}".format(file=self.file, lineno=self.lineno)

   211

   212

class ZoneRecord (object) :

   213

    """

   214

        A record from a zonefile.

   215

    """

   216

   217

    # the underlying line

   218

    line = None

   219

   223

    # record fields

   224

    name = None

   225

    type = None

   226

   227

    # list of data fields

   228

    data = None

   229

   230

    # optional

   231

    ttl = None

   232

    cls = None

   233

   234

    @classmethod

   236

        """

   237

            Parse from ZoneLine. Returns None if there is no record on the line..

   238

        """

   239

   244

            # skip

   245

            return

   246

   247

        # indented lines don't have name

   248

        if line.indent :

   249

            name = None

   250

   251

        else :

   252

            name = parts.pop(0)

   253

   258

   259

        # parse ttl/cls/type

   260

        ttl = _cls = None

   261

   262

        if parts and parts[0][0].isdigit() :

   263

            ttl = parts.pop(0)

   264

   265

        if parts and parts[0].upper() in ('IN', 'CH') :

   266

            _cls = parts.pop(0)

   267

   268

        # always have type

   269

        type = parts.pop(0)

   270

   271

        # remaining parts are data

   272

        data = parts

   273

   274

        log.debug("  ttl=%r, cls=%r, type=%r, data=%r", ttl, _cls, type, data)

   275

   276

        return cls(name, type, data,

   278

            ttl     = ttl,

   279

            cls     = _cls,

   280

            line    = line,

   281

        )

   282

   284

        self.name = name

   285

        self.type = type

   286

        self.data = data

   287

   288

        self.ttl = ttl

   289

        self.cls = cls

   290

   292

        self.line = line

   293

   294

        # XXX: within line

   295

        self._comment = comment

   296

   297

    def build_line (self) :

   298

        """

   299

            Construct a zonefile-format line..."

   300

        """

   301

   302

        # XXX: comment?

   303

        if self._comment :

   304

            comment = '\t; ' + self._comment

   305

        else :

   306

            comment = ''

   307

   308

        return u"{name:25} {ttl:4} {cls:2} {type:5} {data}{comment}".format(

   309

                name    = self.name or '',

   310

                ttl     = self.ttl or '',

   311

                cls     = self.cls or '',

   312

                type    = self.type,

   313

                data    = ' '.join(unicode(data) for data in self.data),

   314

                comment = comment,

   315

        )

   316

   317

    def __str__ (self) :

   319

   320

class TXTRecord (ZoneRecord) :

   321

    """

   322

        TXT record.

   323

    """

   324

   325

    def __init__ (self, name, text, **opts) :

   326

        return super(TXTRecord, self).__init__(name, 'TXT', 

   327

            [u'"{0}"'.format(text.replace('"', '\\"'))], 

   328

            **opts

   329

        )

   330

   343

    """

   349

   365

    """

   366

   369

   376

   481

    """

   482

        Parse ZoneRecord items from the given zonefile, ignoring non-record lines.

   483

    """

   488