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

def optparser (parser) :

    14

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

    15

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

    16

            help="Encoding used for host files")

    17

    18

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

    19

            help="Default domain for hosts")

    20

    21

    return hosts

    22

    23

class Host (object) :

    24

    # the label used for alias4/6 hosts

    25

    ALIAS4_FMT = '{host}-ipv4'

    26

    ALIAS6_FMT = '{host}-ipv6'

    27

    28

    @classmethod

    29

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

    30

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

    31

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

    32

    33

        for i in range :

    34

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

    35

                    ip  = ip(i),

    36

                    **opts

    37

            )

    38

    39

    @classmethod

    40

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

    41

        """

    42

            Yield Hosts from a config section's scalars.

    43

        """

    44

    45

        if '{' in host :

    46

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

    47

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

    48

    49

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

    50

            host = pre + "$" + post

    51

    52

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

    53

                yield host

    54

        else :

    55

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

    56

    57

    @classmethod

    58

    def build (cls, options, host, domain=None, ip=None, ip6=None, owner=None, boot=None, alias=None, alias4=None, alias6=None, **extra) :

    59

        """

    60

            Return a Host from a config section's scalars.

    61

        """

    62

    63

        if alias :

    64

            alias = alias.split()

    65

        else :

    66

            alias = ()

    67

    68

        if alias4 :

    69

            alias4 = alias4.split()

    70

        else :

    71

            alias4 = ()

    72

    73

        if alias6 :

    74

            alias6 = alias6.split()

    75

        else :

    76

            alias6 = ()

    77

    78

        ethernet = { }

    79

    80

        for field, value in extra.iteritems() :

    81

            if '.' in field :

    82

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

    83

            else :

    84

                instance = None

    85

    86

            if field == 'ethernet' :

    87

                if instance :

    88

                    ethernet[instance] = value

    89

                else :

    90

                    for eth in value.split() :

    91

                        ethernet[len(ethernet)] = eth

    92

            else :

    93

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

    94

    95

        if domain is None :

    96

            domain = options.hosts_domain

    97

    98

        return cls(host,

    99

                domain      = domain,

   100

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

   101

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

   102

                ethernet    = ethernet,

   103

                alias       = alias,

   104

                alias4      = alias4,

   105

                alias6      = alias6,

   106

                owner       = owner,

   107

                boot        = boot,

   108

        )

   109

   110

    def __init__ (self, host, domain=None, ip=None, ip6=None, ethernet={ }, alias=(), owner=None, boot=None, alias4=None, alias6=None) :

   111

        """

   112

            host        - str

   113

            domain      - str

   114

            ip          - ipaddr.IPv4Address

   115

            ip6         - ipaddr.IPv6Address

   116

            ethernet    - { index: ethernet }

   117

            alias       - list

   118

            owner       - str: LDAP uid

   119

            alias4      - list (CNAME -> A)

   120

            alias6      - list (CNAME -> AAAA)

   121

        """

   122

        self.host = host

   123

        self.domain = domain

   124

        self.ip = ip

   125

        self.ip6 = ip6

   126

        self.ethernet = ethernet

   127

        self.alias = alias

   128

        self.alias4 = alias4

   129

        self.alias6 = alias6

   130

        self.owner = owner

   131

        self.boot = boot

   132

   133

    def fqdn (self) :

   134

        if '.' in self.host :

   135

            return self.host + '.'

   136

        elif self.domain :

   137

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

   138

        else :

   139

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

   140

   141

    def __str__ (self) :

   142

        return str(self.host)

   143

   144

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

   145

    """

   146

        Load hosts from a ConfigObj section.

   147

    """

   148

   149

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

   150

   151

    if config.sections :

   152

        # recurse; this is a domain meta-section

   153

        params = dict(defaults, domain=name)

   154

        params.update(**scalars) # override

   155

   156

        for section in config.sections :

   157

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

   158

                yield host

   159

   160

    elif name :

   161

        params = dict(defaults, **scalars)

   162

   163

        # this is a host section

   164

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

   165

            yield host

   166

   167

    else :

   168

        raise ValueError("No sections in config")

   169

   170

   171

def apply_hosts_file (options, file) :

   172

    """

   173

        Load Hosts from a file.

   174

   175

    """

   176

   177

    config = configobj.ConfigObj(file,

   178

            encoding    = options.hosts_charset,

   179

    )

   180

   181

    # use file basename as default

   182

    name = os.path.basename(file.name)

   183

   184

    return apply_hosts_config(options, config, name)

   185

   186

def apply_hosts (options, files) :

   187

    """

   188

        Load Hosts from files.

   189

    """

   190

   191

    for file in files :

   192

        for host in apply_hosts_file(options, file) :

   193

            yield host

   194

   195

def sort_hosts (options, hosts) :

   196

    """

   197

        Yields hosts with a sorting key.

   198

    """

   199

   200

    for host in hosts :

   201

        if host.ip :

   202

            sort = host.ip

   203

        else :

   204

            # sorts first

   205

            sort = ipaddr.IPAddress(0)

   206

   207

        yield sort, host

   208

   209

def apply (options, args) :

   210

    """

   211

        Load Hosts from arguments.

   212

    """

   213

   214

    # without unicode

   215

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

   216

   217

    # load configs

   218

    hosts = apply_hosts(options, files)

   219

   220

    # sort

   221

    hosts = list(sort_hosts(options, hosts))

   222

    hosts.sort()

   223

    hosts = [host for sort, host in hosts]

   224

   225

    return hosts