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

class Host (object) :

    36

    # the label used for alias4/6 hosts

    37

    ALIAS4_FMT = '{host}-ipv4'

    38

    ALIAS6_FMT = '{host}-ipv6'

    39

    40

    @classmethod

    41

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

    42

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

    43

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

    44

    45

        if forward is not None :

    46

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

    47

        else :

    48

            _forward = lambda i: forward

    49

    50

        if reverse is not None :

    51

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

    52

        else :

    53

            _reverse = lambda i: reverse

    54

    55

        for i in range :

    56

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

    57

                    ip      = ip(i),

    58

                    forward = _forward(i),

    59

                    reverse = _reverse(i),

    60

                    **opts

    61

            )

    62

    63

    @classmethod

    64

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

    65

        """

    66

            Yield Hosts from a config section's scalars.

    67

    68

                options     - pvl.args Options

    69

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

    70

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

    71

                              used for domain

    72

        """

    73

    74

        if domain :

    75

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

    76

        elif '.' in host :

    77

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

    78

            domain = None

    79

        elif options.hosts_domain :

    80

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

    81

            domain = options.hosts_domain

    82

        elif section :

    83

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

    84

            domain = section

    85

        else :

    86

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

    87

    88

        if '{' in host :

    89

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

    90

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

    91

    92

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

    93

            host = pre + "$" + post

    94

    95

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

    96

                yield host

    97

        else :

    98

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

    99

   100

    @classmethod

   101

    def build (cls, options, host, domain,

   102

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

   103

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

   104

            forward=None, reverse=None,

   105

            down=None,

   106

            boot=None,

   107

            **extra) :

   108

        """

   109

            Return a Host from a config section's scalars.

   110

   111

        """

   112

   113

        if alias :

   114

            alias = alias.split()

   115

        else :

   116

            alias = ()

   117

   118

        if alias4 :

   119

            alias4 = alias4.split()

   120

        else :

   121

            alias4 = ()

   122

   123

        if alias6 :

   124

            alias6 = alias6.split()

   125

        else :

   126

            alias6 = ()

   127

   128

        ethernet = { }

   129

        extensions = collections.defaultdict(dict)

   130

   131

        for field, value in extra.iteritems() :

   132

            if ':' in field :

   133

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

   134

   135

                extensions[extension][field] = value

   136

   137

                continue

   138

   139

            if '.' in field :

   140

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

   141

            else :

   142

                instance = None

   143

   144

            if field == 'ethernet' :

   145

                if instance :

   146

                    ethernet[instance] = value

   147

                else :

   148

                    for eth in value.split() :

   149

                        ethernet[len(ethernet)] = eth

   150

            else :

   151

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

   152

   153

   154

        if forward is None :

   155

            # normal zone

   156

            pass

   157

        elif forward :

   158

            # alias to external zone

   159

            pass

   160

        else :

   161

            # omit

   162

            forward = False

   163

   164

        if reverse is None :

   165

            # normal zone

   166

            pass

   167

        elif reverse :

   168

            # alias to external zone

   169

            pass

   170

        else :

   171

            # omit

   172

            reverse = False

   173

   174

        if down :

   175

            down = True

   176

        else :

   177

            down = None

   178

   179

        if not location :

   180

            location = None

   181

   182

        return cls(host,

   183

                domain      = domain,

   184

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

   185

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

   186

                ethernet    = ethernet,

   187

                alias       = alias,

   188

                alias4      = alias4,

   189

                alias6      = alias6,

   190

                owner       = owner,

   191

                location    = location,

   192

                boot        = boot,

   193

                forward     = forward,

   194

                reverse     = reverse,

   195

                down        = down,

   196

   197

                **extensions

   198

        )

   199

   200

    def __init__ (self, host,

   201

            domain=None,

   202

            ip=None, ip6=None,

   203

            ethernet={ },

   204

            alias=(),

   205

            owner=None,

   206

            location=None,

   207

            boot=None,

   208

            alias4=None, alias6=None,

   209

            forward=None, reverse=None,

   210

            down=None,

   211

            **extensions

   212

    ) :

   213

        """

   214

            host        - str

   215

            domain      - str

   216

            ip          - ipaddr.IPv4Address

   217

            ip6         - ipaddr.IPv6Address

   218

            ethernet    - { index: ethernet }

   219

            alias       - list

   220

            owner       - str: LDAP uid

   221

            location    - name

   222

            alias4      - list (CNAME -> A)

   223

            alias6      - list (CNAME -> AAAA)

   224

            forward     - generate forward records, or CNAME into given zone

   225

            reverse     - generate reverse records, or CNAME into given zone

   226

            down        - not online

   227

        """

   228

   229

        self.host = host

   230

        self.domain = domain

   231

        self.ip = ip

   232

        self.ip6 = ip6

   233

        self.ethernet = ethernet

   234

        self.alias = alias

   235

        self.alias4 = alias4

   236

        self.alias6 = alias6

   237

        self.owner = owner

   238

        self.location = location

   239

        self.boot = boot

   240

        self.forward = forward

   241

        self.reverse = reverse

   242

        self.down = down

   243

   244

        self.extensions = extensions

   245

   246

    def fqdn (self) :

   247

        if '.' in self.host :

   248

            return self.host + '.'

   249

        elif self.domain :

   250

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

   251

        else :

   252

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

   253

   254

    def __str__ (self) :

   255

        return str(self.host)

   256

   257

def apply_host_includes (options, config_path, include) :

   258

    """

   259

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

   260

    """

   261

   262

    if options.hosts_include :

   263

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

   264

    else :

   265

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

   266

   267

    for include in include.split() :

   268

        for include_path in include_paths :

   269

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

   270

            if os.path.exists(path) :

   271

                break

   272

        else :

   273

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

   274

   275

        if include.endswith('/') :

   276

            for name in os.listdir(path) :

   277

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

   278

   279

                if name.startswith('.') :

   280

                    pass

   281

                elif not os.path.exists(file_path) :

   282

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

   283

                else :

   284

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

   285

                    yield open(file_path)

   286

   287

        else :

   288

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

   289

            yield open(path)

   290

   291

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

   292

    """

   293

        Load hosts from a ConfigObj section.

   294

    """

   295

   296

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

   297

   298

    if config.sections :

   299

        # includes?

   300

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

   301

            # within our domain context

   302

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

   303

                yield host

   304

   305

        # recurse; this is a domain meta-section

   306

        params = dict(defaults)

   307

        params.update(**scalars) # override

   308

   309

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

   310

   311

        for section in config.sections :

   312

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

   313

                yield host

   314

   315

    elif name :

   316

        params = dict(defaults, **scalars)

   317

   318

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

   319

   320

        # this is a host section

   321

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

   322

            yield host

   323

   324

    else :

   325

        raise ValueError("No sections in config")

   326

   327

   328

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

   329

    """

   330

        Load Hosts from a file.

   331

   332

    """

   333

   334

    # use file basename as default

   335

    path = file.name

   336

    name = os.path.basename(path)

   337

   338

    try :

   339

        config = configobj.ConfigObj(file,

   340

                encoding    = options.hosts_charset,

   341

        )

   342

    except configobj.ParseError as ex :

   343

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

   344

   345

   346

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

   347

   348

def apply_hosts (options, files) :

   349

    """

   350

        Load Hosts from files.

   351

    """

   352

   353

    for file in files :

   354

        for host in apply_hosts_file(options, file) :

   355

            yield host

   356

   357

def sort_hosts (options, hosts) :

   358

    """

   359

        Yields hosts with a sorting key.

   360

    """

   361

   362

    for host in hosts :

   363

        if host.ip :

   364

            sort = host.ip

   365

        else :

   366

            # sorts first

   367

            sort = ipaddr.IPAddress(0)

   368

   369

        yield sort, host

   370

   371

def apply (options, args) :

   372

    """

   373

        Load Hosts from arguments.

   374

    """

   375

   376

    # without unicode

   377

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

   378

   379

    # load configs

   380

    hosts = apply_hosts(options, files)

   381

   382

    # sort

   383

    hosts = list(sort_hosts(options, hosts))

   384

    hosts.sort()

   385

    hosts = [host for sort, host in hosts]

   386

   387

    return hosts