1

#!/usr/bin/env python

     2

     3

"""

     4

    Manipulate host definitions for dns/dhcp.

     5

"""

     6

     7

import pvl.args, optparse

     8

import pvl.dns.zone

     9

import pvl.dhcp.config

    10

import pvl.ldap.args

    11

    12

import collections

    13

import re

    14

import logging; log = logging.getLogger('main')

    15

    16

__version__ = '0.1'

    17

    18

def parse_options (argv) :

    19

    """

    20

        Parse command-line arguments.

    21

    """

    22

    23

    parser = optparse.OptionParser(

    24

            prog        = argv[0],

    25

            usage       = '%prog: [options]',

    26

            version     = __version__,

    27

    28

            # module docstring

    29

            description = __doc__,

    30

    )

    31

    32

    # logging

    33

    parser.add_option_group(pvl.args.parser(parser))

    34

    parser.add_option_group(pvl.ldap.args.parser(parser))

    35

    36

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

    37

            help="Encoding used for input files")

    38

    39

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

    40

            help="Encoding used for output files")

    41

    42

    # input

    43

    parser.add_option('--import-zone-hosts',    metavar='FILE',

    44

            help="Load hosts from DNS zone")

    45

    46

    parser.add_option('--import-dhcp-hosts',    metavar='FILE',

    47

            help="Load hosts from DHCP config")

    48

    49

    parser.add_option('--dump-host-comments',   action='store_true',

    50

            help="Dump out info on imported host comments")

    51

    52

    # defaults

    53

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

    54

            help="Default domain for hosts")

    55

    56

    parser.add_option('--zone-unused',          metavar='HOST',

    57

            help="DNS name for unallocated hosts")

    58

    59

    # output

    60

    parser.add_option('--output-hosts',         metavar='FILE',

    61

            help="Output hosts file")

    62

    63

    # defaults

    64

    parser.set_defaults(

    65

    66

    )

    67

    68

    # parse

    69

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

    70

    71

    # apply

    72

    pvl.args.apply(options, argv[0])

    73

    74

    return options, args

    75

    76

def process_zone_hosts (options, file) :

    77

    """

    78

        Yield host info from zonefile records.

    79

    """

    80

    81

    for rr in pvl.dns.zone.ZoneRecord.load(file) :

    82

        if options.zone_unused and rr.name == options.zone_unused :

    83

            log.debug("%s: skip %s", rr.name, rr)

    84

            continue

    85

    86

        elif rr.type == 'A' :

    87

            ip, = rr.data

    88

    89

            yield rr.name, 'ip', ip

    90

    91

            if rr.comment :

    92

                yield rr.name, 'comment', rr.comment

    93

    94

        elif rr.type == 'CNAME' :

    95

            host, = rr.data

    96

    97

            yield host, 'alias', rr.name

    98

    99

        else :

   100

            log.warn("%s: unknown rr: %s", rr.name, rr)

   101

   102

def process_dhcp_host (options, host, items) :

   103

    """

   104

        Yield host infos from a dhcp host ... { ... }

   105

    """

   106

   107

    hostname = None

   108

    ethernet = []

   109

    fixed_address = None

   110

   111

    for item in items :

   112

        item, args = item[0], item[1:]

   113

   114

        if item == 'hardware' :

   115

            _ethernet, ethernet = args

   116

            assert _ethernet == 'ethernet'

   117

        elif item == 'fixed-address' :

   118

            fixed_address, = args

   119

        elif item == 'option' :

   120

            option = args.pop(0)

   121

   122

            if option == 'host-name' :

   123

                hostname, = args

   124

            else :

   125

                log.warn("host %s: ignore unknown option: %s", host, option)

   126

        else :

   127

            log.warn("host %s: ignore unknown item: %s", host, item)

   128

   129

    # determine hostname

   130

    if hostname :

   131

        pass

   132

    elif fixed_address and not re.match(r'\d+\.\d+\.\d+.\d+', fixed_address) :

   133

        hostname, domain = fixed_address.split('.', 1)

   134

    elif '-' in host :

   135

        hostname, suffix = host.rsplit('-', 1)

   136

    else :

   137

        log.warn("%s: guess hostname: %s", host, host)

   138

        hostname = host

   139

   140

    if hostname :

   141

        yield hostname, 'ethernet', ethernet

   142

   143

def process_dhcp_hosts (options, blocks) :

   144

    """

   145

        Process hosts from a parsed block

   146

    """

   147

   148

    for block, items, blocks in blocks :

   149

        log.info("%s", block)

   150

   151

        block, args = block[0], block[1:]

   152

   153

        if block == 'group' :

   154

            for info in process_dhcp_hosts(options, blocks) :

   155

                yield info

   156

        elif block == 'host' :

   157

            host, = args

   158

   159

            try :

   160

                for info in process_dhcp_host(options, host, items) :

   161

                    yield info

   162

            except ValueError as error :

   163

                log.warn("%s: invalid host: %s", host, error)

   164

        else:

   165

            log.warn("ignore unknown block: %s", block)

   166

   167

def process_dhcp_conf (options, file) :

   168

    items, blocks = pvl.dhcp.config.DHCPConfigParser().load(file)

   169

   170

    for item in items :

   171

        item, args = item[0], item[1:]

   172

   173

        if item == 'include' :

   174

            include, = args

   175

            for info in process_dhcp_conf(options, pvl.args.apply_file(include)) :

   176

                yield info

   177

        else :

   178

            log.warn("ignore unknown item: %s", item)

   179

   180

    for info in process_dhcp_hosts(options, blocks) :

   181

        yield info

   182

   183

def apply_hosts_import (options) :

   184

    """

   185

        Import host infos from given files.

   186

    """

   187

   188

    if options.import_zone_hosts:

   189

        for info in process_zone_hosts(options,

   190

                pvl.args.apply_file(options.import_zone_hosts)) :

   191

            yield info

   192

   193

    if options.import_dhcp_hosts:

   194

        for info in process_dhcp_conf(options,

   195

                pvl.args.apply_file(options.import_dhcp_hosts)) :

   196

            yield info

   197

   198

ZONE_COMMENTS = (

   199

        re.compile(r'(?P<owner>[^/]+)\s*-\s+(?P<host>.+)'),

   200

        re.compile(r'(?P<group>.+?)\s*/\s*(?P<owner>.+)\s+[/-]\s+(?P<host>.+)'),

   201

        re.compile(r'(?P<group>.+?)\s*/\s*(?P<owner>.+)\s+[(]\s*(?P<host>.+)[)]'),

   202

        re.compile(r'(?P<group>.+?)\s*/\s*(?P<owner>.+)'),

   203

        re.compile(r'(?P<owner>.+)'),

   204

)

   205

   206

ZONE_OWNER_MAIL = re.compile(r'(?P<owner>.*?)\s*<(?P<mail>.+?)>')

   207

   208

def process_zone_comment (options, hostname, comment) :

   209

    """

   210

        Attempt to parse a host comment field... :D

   211

   212

        Yields (field, value) bits

   213

    """

   214

   215

    for regex in ZONE_COMMENTS :

   216

        match = regex.match(comment)

   217

   218

        if match :

   219

            break

   220

    else :

   221

        log.warn("%s: unparsed comment: %s", hostname, comment)

   222

        return

   223

   224

    matches = match.groupdict()

   225

    owner = matches.pop('owner', None)

   226

   227

    if owner :

   228

        mail_match = ZONE_OWNER_MAIL.match(owner)

   229

   230

        if mail_match :

   231

            mail_matches = mail_match.groupdict()

   232

   233

            owner = mail_matches['owner']

   234

            yield 'mail', mail_matches['mail'].strip()

   235

   236

    yield 'owner', owner.strip()

   237

   238

    for field, value in matches.iteritems() :

   239

        if value :

   240

            yield field, value.strip()

   241

   242

HOST_OWNERS = {

   243

    u'tech':        'root',

   244

    u'atk':         'root',

   245

    u'toimisto':    'root',

   246

}

   247

   248

def process_host_owner (options, host, info) :

   249

    """

   250

        Yield guesses for user from LDAP.

   251

    """

   252

   253

    if info.get('owner').lower() in HOST_OWNERS :

   254

        yield HOST_OWNERS[info.get('owner').lower()]

   255

   256

    if info.get('mail') :

   257

        for user in options.ldap.users.filter(

   258

                { 'mailLocalAddress': info['mail'] },

   259

                { 'uid': info['mail'] },

   260

        ) :

   261

            yield user['uid']

   262

   263

    if info.get('group') and info.get('owner') :

   264

        groups = options.ldap.groups.filter(cn=info['group'])

   265

   266

        for group in groups :

   267

            for user in options.ldap.users.filter({

   268

                'gidNumber': group['gidNumber'],

   269

                'cn': info['owner'],

   270

            }) :

   271

                yield user['uid']

   272

   273

    if info.get('owner') :

   274

            for user in options.ldap.users.filter({

   275

                'cn': info['owner'],

   276

            }) :

   277

                yield user['uid']

   278

   279

def process_host_comments (options, host, info) :

   280

    """

   281

        Process host fields from comment.

   282

   283

        Attempts to find owner from LDAP..

   284

    """

   285

   286

    log.debug("%s: %s", host, info)

   287

   288

    for owner in process_host_owner(options, host, info) :

   289

        log.info("%s: %s", host, owner)

   290

   291

        yield 'owner', owner,

   292

   293

        # only use the first match

   294

        break

   295

    else :

   296

        log.warn("%s: no owner: %s", host, info)

   300

   301

def process_hosts_comments (options, import_hosts) :

   302

    """

   303

        Parse out comments from host imports..

   304

    """

   305

   306

    for host, field, value in import_hosts :

   307

        if field != 'comment':

   308

            yield host, field, value

   309

            continue

   310

   311

        fields = dict(process_zone_comment(options, host, value))

   312

   313

        if options.dump_host_comments :

   314

            print u"{host:20} {comment:80} = {group:15} / {owner:20} <{mail:20}> / {hostinfo}".format(

   315

                    host        = host,

   316

                    comment     = value,

   317

                    group       = fields.get('group', ''),

   318

                    owner       = fields.get('owner', ''),

   319

                    mail        = fields.get('mail', ''),

   320

                    hostinfo    = fields.get('host', ''),

   321

            ).encode('utf-8')

   322

   323

   324

        for field, value in process_host_comments(options, host, fields) :

   325

            yield host, field, value

   326

   327

def process_hosts_import (options, import_hosts) :

   328

    """

   329

        Import host definitions from given infos

   330

    """

   331

   332

    hosts = collections.defaultdict(lambda: collections.defaultdict(list))

   333

   334

    for host, field, value in import_hosts :

   335

        hosts[host][field].append(value)

   336

   337

    return hosts.iteritems()

   338

   339

   340

def main (argv) :

   341

    options, args = parse_options(argv)

   342

   343

    options.ldap = pvl.ldap.args.apply(options)

   344

   345

    if args :

   346

        # direct from file

   347

        hosts = pvl.args.apply_files(args, 'r', options.input_charset)

   348

    else :

   349

        # import

   350

        import_hosts = apply_hosts_import(options)

   351

        import_hosts = process_hosts_comments(options, import_hosts)

   352

        hosts = process_hosts_import(options, import_hosts)

   353

   354

    # output

   355

    if options.output_hosts :

   356

        for host, fields in hosts :

   357

            print host

   358

   359

            for field, values in fields.iteritems() :

   360

                for value in values :

   361

                    print "\t", field, "\t", value.encode(options.output_charset)

   362

   363

    return 0

   364

   365

if __name__ == '__main__':

   366

    pvl.args.main(main)