1

"""

     2

    Host definitions.

     3

"""

     4

     5

import pvl.args

     6

import pvl.dns.zone

     7

     8

import collections

     9

import configobj

    10

import ipaddr

    11

import optparse

    12

import os.path

    13

    14

import logging; log = logging.getLogger('pvl.hosts')

    15

    16

def optparser (parser) :

    17

    hosts = optparse.OptionGroup(parser, "Hosts input")

    18

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

    19

            help="Encoding used for host files")

    20

    21

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

    22

            help="Default domain for hosts")

    23

    24

    hosts.add_option('--hosts-include',         metavar='PATH',

    25

            help="Optional path for hosts includes, beyond host config dir")

    26

    27

    return hosts

    28

    29

class HostError (Exception) :

    30

    pass

    31

    32

class HostConfigError (HostError) :

    33

    pass

    34

    35

def parse_ethernet (value) :

    36

    """

    37

        Normalize ethernet str.

    38

    """

    39

    40

    return ':'.join('%02x' % int(x, 16) for x in value.split(':'))

    41

    42

class Host (object) :

    43

    # the label used for alias4/6 hosts

    44

    ALIAS4_FMT = '{host}-ipv4'

    45

    ALIAS6_FMT = '{host}-ipv6'

    46

    47

    @classmethod

    48

    def expand (cls, options, range, host, domain, ip, forward=None, reverse=None, **opts) :

    49

        host = pvl.dns.zone.parse_generate_field(host)

    50

        ip = pvl.dns.zone.parse_generate_field(ip)

    51

    52

        if forward is not None :

    53

            _forward = pvl.dns.zone.parse_generate_field(forward)

    54

        else :

    55

            _forward = lambda i: forward

    56

    57

        if reverse is not None :

    58

            _reverse = pvl.dns.zone.parse_generate_field(reverse)

    59

        else :

    60

            _reverse = lambda i: reverse

    61

    62

        for i in range :

    63

            yield cls.build(options, host(i), domain,

    64

                    ip      = ip(i),

    65

                    forward = _forward(i),

    66

                    reverse = _reverse(i),

    67

                    **opts

    68

            )

    69

    70

    @classmethod

    71

    def config (cls, options, host, section=None, domain=None, ip=None, **extra) :

    72

        """

    73

            Yield Hosts from a config section's scalars.

    74

    75

                options     - pvl.args Options

    76

                host        - the name of the section (or file) containing this host item.

    77

                section     - the parent section containing this host item, or None

    78

                              used for domain

    79

        """

    80

    81

        if domain :

    82

            log.debug("%s: explicit domain: %s", host, domain)

    83

        elif '.' in host :

    84

            log.debug("%s: using as fqdn without domain", host)

    85

            domain = None

    86

        elif options.hosts_domain :

    87

            log.debug("%s: default domain to --hots-domain: %s", host, options.hosts_domain)

    88

            domain = options.hosts_domain

    89

        elif section :

    90

            log.debug("%s: default domain to section: %s", host, section)

    91

            domain = section

    92

        else :

    93

            raise ValueError("%s: no domain given" % (host, ))

    94

    95

        if '{' in host :

    96

            pre, host = host.split('{', 1)

    97

            range, post = host.rsplit('}', 1)

    98

    99

            range = pvl.dns.zone.parse_generate_range(range)

   100

            host = pre + "$" + post

   101

   102

            for host in cls.expand(options, range, host, domain, ip, **extra) :

   103

                yield host

   104

        else :

   105

            yield cls.build(options, host, domain, ip=ip, **extra)

   106

   107

    @classmethod

   108

    def build (cls, options, host, domain,

   109

            ip=None, ip6=None, owner=None, location=None,

   110

            alias=None, alias4=None, alias6=None,

   111

            forward=None, reverse=None,

   112

            down=None,

   113

            boot=None,

   114

            **extra) :

   115

        """

   116

            Return a Host from a config section's scalars.

   117

   118

        """

   119

   120

        if alias :

   121

            alias = alias.split()

   122

        else :

   123

            alias = ()

   124

   125

        if alias4 :

   126

            alias4 = alias4.split()

   127

        else :

   128

            alias4 = ()

   129

   130

        if alias6 :

   131

            alias6 = alias6.split()

   132

        else :

   133

            alias6 = ()

   134

   135

        ethernet = { }

   136

        extensions = collections.defaultdict(dict)

   137

   138

        for field, value in extra.iteritems() :

   139

            if ':' in field :

   140

                extension, field = field.split(':', 1)

   141

   142

                extensions[extension][field] = value

   143

   144

                continue

   145

   146

            if '.' in field :

   147

                field, instance = field.split('.')

   148

            else :

   149

                instance = None

   150

   151

            if field == 'ethernet' :

   152

                if instance :

   153

                    ethernet[instance] = parse_ethernet(value)

   154

                else :

   155

                    for eth in value.split() :

   156

                        ethernet[len(ethernet)] = parse_ethernet(eth)

   157

            else :

   158

                raise ValueError("%s: Unknown host field: %s=%s" % (host, field, value))

   159

   160

   161

        if forward is None :

   162

            # normal zone

   163

            pass

   164

        elif forward :

   165

            # alias to external zone

   166

            pass

   167

        else :

   168

            # omit

   169

            forward = False

   170

   171

        if reverse is None :

   172

            # normal zone

   173

            pass

   174

        elif reverse :

   175

            # alias to external zone

   176

            pass

   177

        else :

   178

            # omit

   179

            reverse = False

   180

   181

        if down :

   182

            down = True

   183

        else :

   184

            down = None

   185

   186

        if not location :

   187

            location = location_domain = None

   188

        elif '@' in location:

   189

            location, location_domain = location.split('@', 1)

   190

        else:

   191

            location_domain = None

   192

   193

        return cls(host,

   194

                domain      = domain,

   195

                ip          = ipaddr.IPv4Address(ip) if ip else None,

   196

                ip6         = ipaddr.IPv6Address(ip6) if ip6 else None,

   197

                ethernet    = ethernet,

   198

                alias       = alias,

   199

                alias4      = alias4,

   200

                alias6      = alias6,

   201

                owner       = owner,

   202

                location    = location,

   203

                location_domain = location_domain,

   204

                boot        = boot,

   205

                forward     = forward,

   206

                reverse     = reverse,

   207

                down        = down,

   208

   209

                **extensions

   210

        )

   211

   212

    def __init__ (self, host,

   213

            domain=None,

   214

            ip=None, ip6=None,

   215

            ethernet={ },

   216

            alias=(),

   217

            owner=None,

   218

            location=None,

   219

            location_domain=None,

   220

            boot=None,

   221

            alias4=None, alias6=None,

   222

            forward=None, reverse=None,

   223

            down=None,

   224

            **extensions

   225

    ) :

   226

        """

   227

            host        - str

   228

            domain      - str

   229

            ip          - ipaddr.IPv4Address

   230

            ip6         - ipaddr.IPv6Address

   231

            ethernet    - { index: ethernet }

   232

            alias       - list

   233

            owner       - str: LDAP uid

   234

            location    - location name@ part

   235

            location_domain - location @domain part

   236

            alias4      - list (CNAME -> A)

   237

            alias6      - list (CNAME -> AAAA)

   238

            forward     - generate forward records, or CNAME into given zone

   239

            reverse     - generate reverse records, or CNAME into given zone

   240

            down        - not online

   241

        """

   242

   243

        self.host = host

   244

        self.domain = domain

   245

        self.ip = ip

   246

        self.ip6 = ip6

   247

        self.ethernet = ethernet

   248

        self.alias = alias

   249

        self.alias4 = alias4

   250

        self.alias6 = alias6

   251

        self.owner = owner

   252

        self.location = location

   253

        self.location_domain = location_domain

   254

        self.boot = boot

   255

        self.forward = forward

   256

        self.reverse = reverse

   257

        self.down = down

   258

   259

        self.extensions = extensions

   260

   261

    def fqdn (self) :

   262

        if '.' in self.host :

   263

            return self.host + '.'

   264

        elif self.domain :

   265

            return pvl.dns.zone.fqdn(self.host, self.domain)

   266

        else :

   267

            raise ValueError("%s: have no fqdn/domain" % (self, ))

   268

   269

    def __str__ (self) :

   270

        return str(self.host)

   271

   272

def apply_host_includes (options, config_path, include) :

   273

    """

   274

        Yield files from a given config's include=... value

   275

    """

   276

   277

    if options.hosts_include :

   278

        include_paths = (os.path.dirname(config_path), options.hosts_include)

   279

    else :

   280

        include_paths = (os.path.dirname(config_path), )

   281

   282

    for include in include.split() :

   283

        for include_path in include_paths :

   284

            path = os.path.join(include_path, include)

   285

            if os.path.exists(path) :

   286

                break

   287

        else :

   288

            raise HostConfigError(config_path, "Unable to find include %s in include path: %s" % (include, ' '.join(include_paths)))

   289

   290

        if include.endswith('/') :

   291

            for name in os.listdir(path) :

   292

                file_path = os.path.join(path, name)

   293

   294

                if name.startswith('.') :

   295

                    pass

   296

                elif not os.path.exists(file_path) :

   297

                    log.warn("%s: skip nonexistant include: %s", config_path, file_path)

   298

                else :

   299

                    log.info("%s: include: %s", config_path, file_path)

   300

                    yield open(file_path)

   301

   302

        else :

   303

            log.info("%s: include: %s", config_path, path)

   304

            yield open(path)

   305

   306

def apply_hosts_config (options, path, name, config, defaults={}, parent=None) :

   307

    """

   308

        Load hosts from a ConfigObj section.

   309

    """

   310

   311

    scalars = dict((scalar, config[scalar]) for scalar in config.scalars)

   312

   313

    if config.sections :

   314

        # includes?

   315

        for file in apply_host_includes(options, path, scalars.pop('include', '')) :

   316

            # within our domain context

   317

            for host in apply_hosts_file(options, file, parent=name) :

   318

                yield host

   319

   320

        # recurse; this is a domain meta-section

   321

        params = dict(defaults)

   322

        params.update(**scalars) # override

   323

   324

        log.debug("%s: %s -> %s", path, parent, name)

   325

   326

        for section in config.sections :

   327

            for host in apply_hosts_config(options, path, section, config[section], params, name) :

   328

                yield host

   329

   330

    elif name :

   331

        params = dict(defaults, **scalars)

   332

   333

        log.debug("%s: %s: %s", path, parent, name)

   334

   335

        # this is a host section

   336

        for host in Host.config(options, name, parent, **params) :

   337

            yield host

   338

   339

    else :

   340

        raise ValueError("No sections in config")

   341

   342

   343

def apply_hosts_file (options, file, parent=None) :

   344

    """

   345

        Load Hosts from a file.

   346

   347

    """

   348

   349

    # use file basename as default

   350

    path = file.name

   351

    name = os.path.basename(path)

   352

   353

    try :

   354

        config = configobj.ConfigObj(file,

   355

                encoding    = options.hosts_charset,

   356

        )

   357

    except configobj.ParseError as ex :

   358

        raise HostConfigError("%s:%d: %s" % (path, ex.line_number, ex))

   359

   360

   361

    return apply_hosts_config(options, path, name, config, parent=parent)

   362

   363

def apply_hosts (options, files) :

   364

    """

   365

        Load Hosts from files.

   366

    """

   367

   368

    for file in files :

   369

        for host in apply_hosts_file(options, file) :

   370

            yield host

   371

   372

def sort_hosts (options, hosts) :

   373

    """

   374

        Yields hosts with a sorting key.

   375

    """

   376

   377

    for host in hosts :

   378

        if host.ip :

   379

            sort = host.ip

   380

        else :

   381

            # sorts first

   382

            sort = ipaddr.IPAddress(0)

   383

   384

        yield sort, host

   385

   386

def apply (options, args) :

   387

    """

   388

        Load Hosts from arguments.

   389

    """

   390

   391

    # without unicode

   392

    files = pvl.args.apply_files(args, 'r')

   393

   394

    # load configs

   395

    hosts = apply_hosts(options, files)

   396

   397

    # sort

   398

    hosts = list(sort_hosts(options, hosts))

   399

    hosts.sort()

   400

    hosts = [host for sort, host in hosts]

   401

   402

    return hosts