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

    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")

    22

    23

    return hosts

    24

    25

class Host (object) :

    26

    # the label used for alias4/6 hosts

    27

    ALIAS4_FMT = '{host}-ipv4'

    28

    ALIAS6_FMT = '{host}-ipv6'

    29

    30

    @classmethod

    32

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

    33

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

    34

    35

        for i in range :

    37

                    ip  = ip(i),

    38

                    **opts

    39

            )

    40

    41

    @classmethod

    43

        """

    44

            Yield Hosts from a config section's scalars.

    50

        """

    51

    66

        if '{' in host :

    67

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

    68

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

    69

    70

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

    71

            host = pre + "$" + post

    72

    74

                yield host

    75

        else :

    77

    78

    @classmethod

    82

        """

    83

            Return a Host from a config section's scalars.

    85

        """

    86

    87

        if alias :

    88

            alias = alias.split()

    89

        else :

    90

            alias = ()

    91

    92

        if alias4 :

    93

            alias4 = alias4.split()

    94

        else :

    95

            alias4 = ()

    96

    97

        if alias6 :

    98

            alias6 = alias6.split()

    99

        else :

   100

            alias6 = ()

   101

   102

        ethernet = { }

   103

   104

        for field, value in extra.iteritems() :

   105

            if '.' in field :

   106

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

   107

            else :

   108

                instance = None

   109

   110

            if field == 'ethernet' :

   111

                if instance :

   112

                    ethernet[instance] = value

   113

                else :

   114

                    for eth in value.split() :

   115

                        ethernet[len(ethernet)] = eth

   116

            else :

   117

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

   118

   129

   140

        return cls(host,

   141

                domain      = domain,

   142

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

   143

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

   144

                ethernet    = ethernet,

   145

                alias       = alias,

   146

                alias4      = alias4,

   147

                alias6      = alias6,

   148

                owner       = owner,

   149

                boot        = boot,

   152

        )

   153

   164

        """

   165

            host        - str

   166

            domain      - str

   167

            ip          - ipaddr.IPv4Address

   168

            ip6         - ipaddr.IPv6Address

   169

            ethernet    - { index: ethernet }

   170

            alias       - list

   171

            owner       - str: LDAP uid

   172

            alias4      - list (CNAME -> A)

   173

            alias6      - list (CNAME -> AAAA)

   176

        """

   178

        self.host = host

   179

        self.domain = domain

   180

        self.ip = ip

   181

        self.ip6 = ip6

   182

        self.ethernet = ethernet

   183

        self.alias = alias

   184

        self.alias4 = alias4

   185

        self.alias6 = alias6

   186

        self.owner = owner

   187

        self.boot = boot

   190

   191

    def fqdn (self) :

   192

        if '.' in self.host :

   193

            return self.host + '.'

   194

        elif self.domain :

   195

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

   196

        else :

   197

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

   198

   199

    def __str__ (self) :

   200

        return str(self.host)

   201

   203

    """

   204

        Load hosts from a ConfigObj section.

   205

    """

   206

   207

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

   208

   209

    if config.sections :

   210

        # recurse; this is a domain meta-section

   212

        params.update(**scalars) # override

   213

   214

        for section in config.sections :

   216

                yield host

   217

   218

    elif name :

   219

        params = dict(defaults, **scalars)

   220

   221

        # this is a host section

   223

            yield host

   224

   225

    else :

   226

        raise ValueError("No sections in config")

   227

   228

   229

def apply_hosts_file (options, file) :

   230

    """

   231

        Load Hosts from a file.

   232

   233

    """

   234

   235

    config = configobj.ConfigObj(file,

   236

            encoding    = options.hosts_charset,

   237

    )

   238

   239

    # use file basename as default

   240

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

   241

   242

    return apply_hosts_config(options, config, name)

   243

   244

def apply_hosts (options, files) :

   245

    """

   246

        Load Hosts from files.

   247

    """

   248

   249

    for file in files :

   250

        for host in apply_hosts_file(options, file) :

   251

            yield host

   252

   253

def sort_hosts (options, hosts) :

   254

    """

   255

        Yields hosts with a sorting key.

   256

    """

   257

   258

    for host in hosts :

   259

        if host.ip :

   260

            sort = host.ip

   261

        else :

   262

            # sorts first

   263

            sort = ipaddr.IPAddress(0)

   264

   265

        yield sort, host

   266

   267

def apply (options, args) :

   268

    """

   269

        Load Hosts from arguments.

   270

    """

   271

   272

    # without unicode

   273

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

   274

   275

    # load configs

   276

    hosts = apply_hosts(options, files)

   277

   278

    # sort

   279

    hosts = list(sort_hosts(options, hosts))

   280

    hosts.sort()

   281

    hosts = [host for sort, host in hosts]

   282

   283

    return hosts