1

import collections

     2

import ipaddr

     3

import logging; log = logging.getLogger('pvl.hosts.host')

     4

import pvl.dns

     5

     6

class HostError (Exception):

     7

    """

     8

        An error associated with some specific Host.

     9

    """

    10

    11

    def __init__(self, host, error):

    12

        """

    13

            host    : Host which caused error

    14

            error   : Exception or str message

    15

        """

    16

        self.host = host

    17

        self.error = error

    18

    19

    def __str__ (self):

    20

        return "{self.host}: {self.error}".format(self=self)

    21

    22

def parse_bool(value):

    23

    """

    24

         Normalize optional boolean value.

    25

    """

    26

    27

    if value is None:

    28

        return None

    29

    elif value:

    30

        return True

    31

    else:

    32

        return False

    33

    34

def parse_ip(value, type):

    35

    if value:

    36

        return type(value)

    37

    else:

    38

        return None

    39

    40

def parse_list(value):

    41

    """

    42

        Parse list of strings.

    43

    """

    44

    45

    if value:

    46

        return value.split()

    47

    else:

    48

        return ()

    49

    50

def parse_location(location, domain):

    51

    """

    52

        Parse location@domain.

    53

    """

    54

    55

    if not location:

    56

        return None

    57

    58

    if '@' in location:

    59

        location, location_domain = location.split('@', 1)

    60

    else:

    61

        location_domain = domain

    62

    63

    return (location, location_domain)

    64

    65

def parse_ethernet(value):

    66

    """

    67

        Normalize ethernet str.

    68

    """

    69

    70

    return ':'.join('%02x' % int(x, 16) for x in value.split(':'))

    71

    72

def parse_dhcp_boot(boot):

    73

    """

    74

        Parse the dhcp boot=... option

    75

    76

        >>> print parse_dhcp_boot(None)

    78

        >>> print parse_dhcp_boot({'filename': '/foo'})

    79

        {'filename': '/foo'}

    80

        >>> print parse_dhcp_boot({'filename': '/foo', 'next-server': 'bar'})

    81

        {'next-server': 'bar', 'filename': '/foo'}

    82

        >>> print parse_dhcp_boot('/foo')

    83

        {'filename': '/foo'}

    84

        >>> print parse_dhcp_boot('bar:/foo')

    85

        {'next-server': 'bar', 'filename': '/foo'}

    86

        >>> print parse_dhcp_boot('bar:')

    87

        {'next-server': 'bar'}

    88

        >>> print parse_dhcp_boot('foo')

    89

        Traceback (most recent call last):

    90

            ...

    91

        ValueError: invalid boot=foo

    92

    """

    95

    if not boot:

   104

   107

   113

   116

   119

   120

    else :

   124

   125

def parse_str(value):

   126

    """

   127

        Normalize optional string value.

   128

    """

   129

   130

    if value is None:

   131

        # omit

   132

        return None

   133

   134

    elif value:

   135

        return str(value)

   136

   137

    else:

   138

        # empty value

   139

        return False

   140

   141

def parse_dict(value, parse):

   142

    if isinstance(value, dict):

   143

        values = value

   144

    else:

   145

        values = {None: value}

   146

   147

    return { instance: parse(value) for instance, value in values.iteritems() }

   148

   149

class Host (object) :

   150

    """

   151

        A host is a network node that can have multiple ethernet interfaces, and multiple IP addresses in different domains.

   152

    """

   153

   154

    # the label used for alias4/6 hosts

   155

    ALIAS4_FMT = '{host}-ipv4'

   156

    ALIAS6_FMT = '{host}-ipv6'

   157

   158

    @classmethod

   159

    def build (cls, name, domain,

   160

            ip=None, ip6=None,

   161

            ethernet={ },

   162

            owner=None,

   163

            location=None,

   164

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

   165

            forward=None, reverse=None,

   166

            down=None,

   167

            boot=None,

   168

            extensions=None,

   169

    ) :

   170

        """

   171

            Return a Host initialized from data attributes.

   172

   173

            This handles all string parsing to our data types.

   174

        """

   175

   176

        return cls(name,

   177

                domain      = domain,

   178

                ip          = parse_ip(ip, ipaddr.IPv4Address),

   179

                ip6         = parse_ip(ip6, ipaddr.IPv6Address),

   180

                ethernet    = parse_dict(ethernet,  parse_ethernet),

   181

                owner       = owner,

   182

                location    = parse_location(location, domain),

   183

                alias       = parse_list(alias),

   184

                alias4      = parse_list(alias4),

   185

                alias6      = parse_list(alias6),

   186

                forward     = parse_str(forward),

   187

                reverse     = parse_str(reverse),

   188

                down        = parse_bool(down),

   189

                boot        = parse_dhcp_boot(boot),

   190

                extensions  = extensions,

   191

        )

   192

   193

    def __init__ (self, name, domain,

   194

            ip=None, ip6=None,

   195

            ethernet={ },

   196

            owner=None,

   197

            location=None,

   198

            alias=(), alias4=(), alias6=(),

   199

            forward=None, reverse=None,

   200

            down=None,

   201

            boot=None,

   202

            extensions={},

   203

    ):

   204

        """

   205

            name        - str

   206

            domain      - str

   207

            ip          - ipaddr.IPv4Address

   208

            ip6         - ipaddr.IPv6Address

   209

            ethernet    - { index: ethernet }

   210

            alias       - [ str ]: generate CNAMEs for given relative names

   211

            owner       - str: LDAP uid

   212

            location    - None or (name, domain)

   213

            alias4      - [ str ]: generate additional A records for given relative names

   214

            alias6      - [ str ]: generate additional AAAA records for given relative names

   215

            forward     - None: generate forward zone A/AAAA records per ip/ip6

   216

                          False: omit A/AAAA records (and any alias= CNAMEs)

   217

                          str: generate forward zone CNAME to given fqdn

   218

            reverse     - None: generate reverse zone PTR records per ip/ip6

   219

                          False: omit PTR records for ip/ip6

   220

                          str: generate IPv4 reverse zone CNAME to given fqdn, and omit IPv6 PTR

   221

            down        - mark as offline for polling

   222

        """

   223

   224

        self.name = name

   225

        self.domain = domain

   226

        self.ip = ip

   227

        self.ip6 = ip6

   228

        self.ethernet = ethernet

   229

        self.alias = alias

   230

        self.alias4 = alias4

   231

        self.alias6 = alias6

   232

        self.owner = owner

   233

        self.location = location

   234

        self.boot = boot

   235

        self.forward = forward

   236

        self.reverse = reverse

   237

        self.down = down

   238

        self.extensions = extensions

   239

   240

    def sort_key (self):

   241

        """

   242

            Stable sort ordering

   243

        """

   244

   245

        if self.ip:

   246

            return self.ip

   247

        else:

   248

            # sorts first

   249

            return ipaddr.IPAddress(0)

   250

   251

    def fqdn (self):

   252

        if self.domain:

   253

            return pvl.dns.fqdn(self.name, self.domain)

   254

        else:

   255

            return pvl.dns.fqdn(self.name)

   256

   257

    def __str__ (self):

   258

        return "{self.name}@{domain}".format(self=self,

   259

                domain      = self.domain or '',

   260

        )