1

import collections

     2

import ipaddr

     3

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

     4

import pvl.dns

     5

     6

class HostError (Exception):

    17

        self.error = error

    18

    19

    def __str__ (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_str(value):

    73

    """

    74

        Normalize optional string value.

    75

    """

    76

    77

    if value is None:

    78

        # omit

    79

        return None

    80

    81

    elif value:

    82

        return str(value)

    83

    84

    else:

    85

        # empty value

    86

        return False

    87

    88

def parse_dict(value, parse):

    89

    if isinstance(value, dict):

    90

        values = value

    91

    else:

    92

        values = {None: value}

    93

    94

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

    95

    96

class Host (object) :

    97

    """

    98

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

    99

    """

   100

   101

    # the label used for alias4/6 hosts

   102

    ALIAS4_FMT = '{host}-ipv4'

   103

    ALIAS6_FMT = '{host}-ipv6'

   104

   105

    @classmethod

   106

    def build (cls, name, domain,

   107

            ip=None, ip6=None,

   108

            ethernet={ },

   109

            owner=None,

   110

            location=None,

   111

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

   112

            forward=None, reverse=None,

   113

            down=None,

   114

            boot=None,

   115

            **extensions

   116

    ) :

   117

        """

   118

            Return a Host initialized from data attributes.

   119

   120

            This handles all string parsing to our data types.

   121

        """

   122

   123

        return cls(name,

   124

                domain      = domain,

   125

                ip          = parse_ip(ip, ipaddr.IPv4Address),

   126

                ip6         = parse_ip(ip6, ipaddr.IPv6Address),

   127

                ethernet    = parse_dict(ethernet,  parse_ethernet),

   128

                owner       = owner,

   129

                location    = parse_location(location, domain),

   130

                alias       = parse_list(alias),

   131

                alias4      = parse_list(alias4),

   132

                alias6      = parse_list(alias6),

   133

                forward     = parse_str(forward),

   134

                reverse     = parse_str(reverse),

   135

                down        = parse_bool(down),

   136

                boot        = boot,

   137

                extensions  = extensions

   138

        )

   139

   140

    def __init__ (self, name, domain,

   141

            ip=None, ip6=None,

   142

            ethernet={ },

   143

            owner=None,

   144

            location=None,

   145

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

   146

            forward=None, reverse=None,

   147

            down=None,

   148

            boot=None,

   149

            extensions={},

   150

    ) :

   151

        """

   152

            name        - str

   153

            domain      - str

   154

            ip          - ipaddr.IPv4Address

   155

            ip6         - ipaddr.IPv6Address

   156

            ethernet    - { index: ethernet }

   157

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

   158

            owner       - str: LDAP uid

   159

            location    - None or (name, domain)

   160

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

   161

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

   162

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

   163

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

   164

                          str: generate forward zone CNAME to given fqdn

   165

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

   166

                          False: omit PTR records for ip/ip6

   167

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

   168

            down        - mark as offline for polling

   169

        """

   170

   171

        self.name = name

   172

        self.domain = domain

   173

        self.ip = ip

   174

        self.ip6 = ip6

   175

        self.ethernet = ethernet

   176

        self.alias = alias

   177

        self.alias4 = alias4

   178

        self.alias6 = alias6

   179

        self.owner = owner

   180

        self.location = location

   181

        self.boot = boot

   182

        self.forward = forward

   183

        self.reverse = reverse

   184

        self.down = down

   185

        self.extensions = extensions

   186

   187

    def sort_key (self):

   188

        """

   189

            Stable sort ordering

   190

        """

   191

   192

        if self.ip :

   193

            return self.ip

   194

        else :

   195

            # sorts first

   196

            return ipaddr.IPAddress(0)

   197

   198

    def fqdn (self) :

   199

        if self.domain :

   200

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

   201

        else :

   202

            return pvl.dns.fqdn(self.name)

   203

   204

    def __str__ (self) :

   205

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