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

    12

def optparser (parser) :

    13

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

    14

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

    15

            help="Encoding used for host files")

    16

    17

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

    18

            help="Default domain for hosts")

    19

    20

    return hosts

    21

    22

class Host (object) :

    23

    @classmethod

    24

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

    25

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

    26

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

    27

    28

        for i in range :

    29

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

    30

                    ip  = ip(i),

    31

                    **opts

    32

            )

    33

    34

    @classmethod

    35

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

    36

        """

    37

            Yield Hosts from a config section's scalars.

    38

        """

    39

    40

        if '{' in host :

    41

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

    42

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

    43

    44

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

    45

            host = pre + "$" + post

    46

    47

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

    48

                yield host

    49

        else :

    50

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

    51

    52

    @classmethod

    53

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

    54

        """

    55

            Return a Host from a config section's scalars.

    56

        """

    57

    58

        ethernet = []

    59

        alias = []

    60

    61

        for attr, value in extra.iteritems() :

    62

            if attr.startswith('ethernet') :

    63

                ethernet.append(value)

    64

            elif attr.startswith('alias') :

    65

                alias.append(value)

    66

            else :

    67

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

    68

    69

        if domain is None :

    70

            domain = options.hosts_domain

    71

    72

        return cls(host,

    73

                domain      = domain,

    74

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

    75

                ethernet    = ethernet,

    76

                alias       = alias,

    77

                owner       = owner,

    78

        )

    79

    80

    def __init__ (self, host, domain=None, ip=None, ethernet=(), alias=(), owner=None) :

    81

        """

    82

            host        - str

    83

            domain      - str

    84

            ip          - ipaddr.IPAddress

    85

            ethernet    - list

    86

            alias       - list

    87

            owner       - str: LDAP uid

    88

        """

    89

        self.host = host

    90

        self.domain = domain

    91

        self.ip = ip

    92

        self.ethernet = ethernet

    93

        self.alias = alias

    94

        self.owner = owner

    95

    96

    def __str__ (self) :

    97

        return str(self.host)

    98

    99

def apply_hosts_file (options, file) :

   100

    """

   101

        Load Hosts from a file.

   102

    """

   103

    config = configobj.ConfigObj(file,

   104

            encoding    = options.hosts_charset,

   105

    )

   106

   107

    for name in config.sections :

   108

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

   109

            yield host

   110

   111

def apply_hosts (options, files) :

   112

    """

   113

        Load Hosts from files.

   114

    """

   115

   116

    for file in files :

   117

        for host in apply_hosts_file(options, file) :

   118

            yield host

   119

   120

def sort_hosts (options, hosts) :

   121

    """

   122

        Yields hosts with a sorting key.

   123

    """

   124

   125

    for host in hosts :

   126

        if host.ip :

   127

            sort = host.ip

   128

        else :

   129

            # sorts first

   130

            sort = ipaddr.IPAddress(0)

   131

   132

        yield sort, host

   133

   134

def apply (options, args) :

   135

    """

   136

        Load Hosts from arguments.

   137

    """

   138

   139

    # without unicode

   140

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

   141

   142

    # load configs

   143

    hosts = apply_hosts(options, files)

   144

   145

    # sort

   146

    hosts = list(sort_hosts(options, hosts))

   147

    hosts.sort()

   148

    hosts = [host for sort, host in hosts]

   149

   150

    return hosts