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

    @classmethod

    25

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

    26

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

    27

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

    28

    29

        for i in range :

    30

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

    31

                    ip  = ip(i),

    32

                    **opts

    33

            )

    34

    35

    @classmethod

    36

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

    37

        """

    38

            Yield Hosts from a config section's scalars.

    39

        """

    40

    41

        if '{' in host :

    42

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

    43

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

    44

    45

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

    46

            host = pre + "$" + post

    47

    48

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

    49

                yield host

    50

        else :

    51

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

    52

    53

    @classmethod

    54

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

    55

        """

    56

            Return a Host from a config section's scalars.

    57

        """

    58

    59

        if alias :

    60

            alias = alias.split()

    61

        else :

    62

            alias = ()

    63

    64

        ethernet = { }

    65

    66

        for field, value in extra.iteritems() :

    67

            if '.' in field :

    68

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

    69

            else :

    70

                instance = None

    71

    72

            if field == 'ethernet' :

    73

                if instance :

    74

                    ethernet[instance] = value

    75

                else :

    76

                    for eth in value.split() :

    77

                        ethernet[len(ethernet)] = eth

    78

            else :

    80

    81

        if domain is None :

    82

            domain = options.hosts_domain

    83

    84

        return cls(host,

    85

                domain      = domain,

    86

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

    87

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

    88

                ethernet    = ethernet,

    89

                alias       = alias,

    90

                owner       = owner,

    91

                boot        = boot,

    92

        )

    93

    94

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

    95

        """

    96

            host        - str

    97

            domain      - str

    98

            ip          - ipaddr.IPv4Address

    99

            ip6         - ipaddr.IPv6Address

   100

            ethernet    - { index: ethernet }

   101

            alias       - list

   102

            owner       - str: LDAP uid

   103

        """

   104

        self.host = host

   105

        self.domain = domain

   106

        self.ip = ip

   107

        self.ip6 = ip6

   108

        self.ethernet = ethernet

   109

        self.alias = alias

   110

        self.owner = owner

   111

        self.boot = boot

   112

   113

    def fqdn (self) :

   114

        if '.' in self.host :

   115

            return self.host + '.'

   116

        elif self.domain :

   117

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

   118

        else :

   119

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

   120

   121

    def __str__ (self) :

   122

        return str(self.host)

   123

   124

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

   125

    """

   126

        Load hosts from a ConfigObj section.

   127

    """

   128

   129

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

   130

   131

    if config.sections :

   132

        # recurse; this is a domain meta-section

   133

        params = dict(defaults, domain=name, **scalars)

   134

   135

        for section in config.sections :

   136

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

   137

                yield host

   138

   139

    elif name :

   140

        params = dict(defaults, **scalars)

   141

   142

        # this is a host section

   143

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

   144

            yield host

   145

   146

    else :

   147

        raise ValueError("No sections in config")

   148

   149

   150

def apply_hosts_file (options, file) :

   151

    """

   152

        Load Hosts from a file.

   153

   154

    """

   155

   156

    config = configobj.ConfigObj(file,

   157

            encoding    = options.hosts_charset,

   158

    )

   159

   160

    # use file basename as default

   161

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

   162

   163

    return apply_hosts_config(options, config, name)

   164

   165

def apply_hosts (options, files) :

   166

    """

   167

        Load Hosts from files.

   168

    """

   169

   170

    for file in files :

   171

        for host in apply_hosts_file(options, file) :

   172

            yield host

   173

   174

def sort_hosts (options, hosts) :

   175

    """

   176

        Yields hosts with a sorting key.

   177

    """

   178

   179

    for host in hosts :

   180

        if host.ip :

   181

            sort = host.ip

   182

        else :

   183

            # sorts first

   184

            sort = ipaddr.IPAddress(0)

   185

   186

        yield sort, host

   187

   188

def apply (options, args) :

   189

    """

   190

        Load Hosts from arguments.

   191

    """

   192

   193

    # without unicode

   194

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

   195

   196

    # load configs

   197

    hosts = apply_hosts(options, files)

   198

   199

    # sort

   200

    hosts = list(sort_hosts(options, hosts))

   201

    hosts.sort()

   202

    hosts = [host for sort, host in hosts]

   203

   204

    return hosts