1

"""

     2

    Host definitions.

     3

"""

     4

     5

import pvl.args

     6

import pvl.dns.zone

     7

     8

import configobj

     9

import ipaddr

    10

import optparse

    11

import os.path

    12

    13

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

    14

    15

def optparser (parser) :

    16

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

    17

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

    18

            help="Encoding used for host files")

    19

    20

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

    21

            help="Default domain for hosts")

    25

    26

    return hosts

    27

    34

class Host (object) :

    35

    # the label used for alias4/6 hosts

    36

    ALIAS4_FMT = '{host}-ipv4'

    37

    ALIAS6_FMT = '{host}-ipv6'

    38

    39

    @classmethod

    40

    def expand (cls, options, range, host, domain, ip, **opts) :

    41

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

    42

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

    43

    44

        for i in range :

    45

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

    46

                    ip  = ip(i),

    47

                    **opts

    48

            )

    49

    50

    @classmethod

    51

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

    52

        """

    53

            Yield Hosts from a config section's scalars.

    54

    55

                options     - pvl.args Options

    56

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

    57

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

    58

                              used for domain

    59

        """

    60

    61

        if domain :

    62

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

    63

        elif options.hosts_domain :

    64

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

    65

            domain = options.hosts_domain

    66

        elif section :

    67

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

    68

            domain = section

    69

        elif '.' in host :

    70

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

    71

            domain = None

    72

        else :

    73

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

    74

    75

        if '{' in host :

    76

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

    77

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

    78

    79

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

    80

            host = pre + "$" + post

    81

    82

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

    83

                yield host

    84

        else :

    85

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

    86

    87

    @classmethod

    88

    def build (cls, options, host, domain,

    89

            ip=None, ip6=None, owner=None, boot=None, alias=None, alias4=None, alias6=None, forward=None, reverse=None,

    90

            **extra) :

    91

        """

    92

            Return a Host from a config section's scalars.

    93

    94

        """

    95

    96

        if alias :

    97

            alias = alias.split()

    98

        else :

    99

            alias = ()

   100

   101

        if alias4 :

   102

            alias4 = alias4.split()

   103

        else :

   104

            alias4 = ()

   105

   106

        if alias6 :

   107

            alias6 = alias6.split()

   108

        else :

   109

            alias6 = ()

   110

   111

        ethernet = { }

   112

   113

        for field, value in extra.iteritems() :

   114

            if '.' in field :

   115

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

   116

            else :

   117

                instance = None

   118

   119

            if field == 'ethernet' :

   120

                if instance :

   121

                    ethernet[instance] = value

   122

                else :

   123

                    for eth in value.split() :

   124

                        ethernet[len(ethernet)] = eth

   125

            else :

   126

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

   127

   128

   129

        if forward is None :

   130

            # normal zone

   131

            pass

   132

        elif forward :

   133

            # alias to external zone

   134

            pass

   135

        else :

   136

            # omit

   137

            forward = False

   138

   139

        if reverse is None :

   140

            # normal zone

   141

            pass

   142

        elif reverse :

   143

            # alias to external zone

   144

            pass

   145

        else :

   146

            # omit

   147

            reverse = False

   148

   149

        return cls(host,

   150

                domain      = domain,

   151

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

   152

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

   153

                ethernet    = ethernet,

   154

                alias       = alias,

   155

                alias4      = alias4,

   156

                alias6      = alias6,

   157

                owner       = owner,

   158

                boot        = boot,

   159

                forward     = forward,

   160

                reverse     = reverse,

   161

        )

   162

   163

    def __init__ (self, host,

   164

            domain=None,

   165

            ip=None, ip6=None,

   166

            ethernet={ },

   167

            alias=(),

   168

            owner=None,

   169

            boot=None,

   170

            alias4=None, alias6=None,

   171

            forward=None, reverse=None,

   172

    ) :

   173

        """

   174

            host        - str

   175

            domain      - str

   176

            ip          - ipaddr.IPv4Address

   177

            ip6         - ipaddr.IPv6Address

   178

            ethernet    - { index: ethernet }

   179

            alias       - list

   180

            owner       - str: LDAP uid

   181

            alias4      - list (CNAME -> A)

   182

            alias6      - list (CNAME -> AAAA)

   183

            forward     - generate forward records, or CNAME into given zone

   184

            reverse     - generate reverse records, or CNAME into given zone

   185

        """

   186

   187

        self.host = host

   188

        self.domain = domain

   189

        self.ip = ip

   190

        self.ip6 = ip6

   191

        self.ethernet = ethernet

   192

        self.alias = alias

   193

        self.alias4 = alias4

   194

        self.alias6 = alias6

   195

        self.owner = owner

   196

        self.boot = boot

   197

        self.forward = forward

   198

        self.reverse = reverse

   199

   200

    def fqdn (self) :

   201

        if '.' in self.host :

   202

            return self.host + '.'

   203

        elif self.domain :

   204

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

   205

        else :

   206

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

   207

   208

    def __str__ (self) :

   209

        return str(self.host)

   210

   211

def apply_host_includes (options, config_path, include) :

   212

    """

   213

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

   214

    """

   220

   221

    for include in include.split() :

   228

   229

        if include.endswith('/') :

   230

            for name in os.listdir(path) :

   231

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

   232

   233

                if name.startswith('.') :

   234

                    pass

   235

                elif not os.path.exists(file_path) :

   236

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

   237

                else :

   238

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

   239

                    yield open(file_path)

   240

   241

        else :

   242

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

   243

            yield open(path)

   244

   245

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

   246

    """

   247

        Load hosts from a ConfigObj section.

   248

    """

   249

   250

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

   251

   252

    if config.sections :

   253

        # includes?

   254

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

   255

            # within our domain context

   256

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

   257

                yield host

   258

   259

        # recurse; this is a domain meta-section

   260

        params = dict(defaults)

   261

        params.update(**scalars) # override

   262

   263

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

   264

   265

        for section in config.sections :

   266

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

   267

                yield host

   268

   269

    elif name :

   270

        params = dict(defaults, **scalars)

   271

   272

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

   273

   274

        # this is a host section

   275

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

   276

            yield host

   277

   278

    else :

   279

        raise ValueError("No sections in config")

   280

   281

   282

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

   283

    """

   284

        Load Hosts from a file.

   285

   286

    """

   287

   288

    config = configobj.ConfigObj(file,

   289

            encoding    = options.hosts_charset,

   290

    )

   291

   292

    # use file basename as default

   293

    path = file.name

   294

    name = os.path.basename(path)

   295

   296

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

   297

   298

def apply_hosts (options, files) :

   299

    """

   300

        Load Hosts from files.

   301

    """

   302

   303

    for file in files :

   304

        for host in apply_hosts_file(options, file) :

   305

            yield host

   306

   307

def sort_hosts (options, hosts) :

   308

    """

   309

        Yields hosts with a sorting key.

   310

    """

   311

   312

    for host in hosts :

   313

        if host.ip :

   314

            sort = host.ip

   315

        else :

   316

            # sorts first

   317

            sort = ipaddr.IPAddress(0)

   318

   319

        yield sort, host

   320

   321

def apply (options, args) :

   322

    """

   323

        Load Hosts from arguments.

   324

    """

   325

   326

    # without unicode

   327

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

   328

   329

    # load configs

   330

    hosts = apply_hosts(options, files)

   331

   332

    # sort

   333

    hosts = list(sort_hosts(options, hosts))

   334

    hosts.sort()

   335

    hosts = [host for sort, host in hosts]

   336

   337

    return hosts