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)

    77

        {}

    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

    """

    93

    94

    # normalize to dict

    95

    if not boot:

    96

        boot = { }

    97

    elif not isinstance(boot, dict):

    98

        boot = { None: boot }

    99

    else:

   100

        boot = dict(boot)

   101

   102

    # support either an instanced dict or a plain str or a mixed instanced-with-plain-str

   103

    boot_str = boot.pop(None, None)

   104

   105

    if not (set(boot) <= set(('filename', 'next-server', None))):

   106

        raise ValueError("Invalid boot.*: {instances}".format(instances=' '.join(boot)))

   107

   108

    # any boot= given overrides boot.* fields

   109

    if not boot_str:

   110

        pass

   111

    elif boot_str.startswith('/'):

   112

        boot['filename'] = boot_str

   113

   114

    elif boot_str.endswith(':'):

   115

        boot['next-server'] = boot_str[:-1]

   116

   117

    elif ':' in boot_str:

   118

        boot['next-server'], boot['filename'] = boot_str.split(':', 1)

   119

   120

    else :

   121

        raise ValueError("invalid boot={boot}".format(boot=boot_str))

   122

   123

    return boot

   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

   142

    if not value:

   143

        return { }

   144

   145

    if isinstance(value, dict):

   146

        values = value

   147

    else:

   148

        values = {None: value}

   149

   151

   152

class Host (object) :

   153

    """

   154

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

   155

    """

   156

   157

    EXTENSIONS = { }

   158

   159

    @classmethod

   160

    def build_extensions(cls, extensions):

   161

        for extension, value in extensions.iteritems():

   162

            extension_cls = cls.EXTENSIONS.get(extension)

   163

   164

            if extension_cls:

   165

                yield extension, extension_cls.build(**value)

   166

            else:

   167

                log.warning("skip unknown extension: %s", extension)

   168

   169

    @classmethod

   170

    def build (cls, name, domain,

   171

            ip=None, ip6=None,

   172

            ethernet=None,

   173

            owner=None,

   174

            location=None,

   175

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

   176

            forward=None, reverse=None,

   177

            down=None,

   178

            boot=None,

   179

            extensions={ },

   180

    ) :

   181

        """

   182

            Return a Host initialized from data attributes.

   183

   184

            This handles all string parsing to our data types.

   185

        """

   186

   187

        return cls(name,

   188

                domain      = domain,

   191

                ethernet    = parse_dict(ethernet,  parse_ethernet),

   192

                owner       = owner,

   193

                location    = parse_location(location, domain),

   194

                alias       = parse_list(alias),

   195

                alias4      = parse_list(alias4),

   196

                alias6      = parse_list(alias6),

   197

                forward     = parse_str(forward),

   198

                reverse     = parse_str(reverse),

   199

                down        = parse_bool(down),

   200

                boot        = parse_dhcp_boot(boot),

   201

                extensions  = dict(cls.build_extensions(extensions)),

   202

        )

   203

   204

    def __init__ (self, name, domain,

   205

            ip4=None, ip6=None,

   206

            ethernet={ },

   207

            owner=None,

   208

            location=None,

   209

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

   210

            forward=None, reverse=None,

   211

            down=None,

   212

            boot=None,

   213

            extensions={},

   214

    ):

   215

        """

   216

            name        - str

   217

            domain      - str

   218

            ip4         - primary ipaddr.IPv4Address

   219

            ip6         - primary ipaddr.IPv6Address

   220

            ethernet    - { index: ethernet }

   221

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

   222

            owner       - str: LDAP uid

   223

            location    - None or (name, domain)

   224

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

   225

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

   226

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

   227

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

   228

                          str: generate forward zone CNAME to given fqdn

   229

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

   230

                          False: omit PTR records for ip/ip6

   231

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

   232

            down        - mark as offline for polling

   233

        """

   234

   235

        self.name = name

   236

        self.domain = domain

   237

        self.ip4 = ip4

   238

        self.ip6 = ip6

   239

        self.ethernet = ethernet

   240

        self.alias = alias

   241

        self.alias4 = alias4

   242

        self.alias6 = alias6

   243

        self.owner = owner

   244

        self.location = location

   245

        self.boot = boot

   246

        self.forward = forward

   247

        self.reverse = reverse

   248

        self.down = down

   249

        self.extensions = extensions

   250

   251

    def sort_key (self):

   252

        """

   253

            Stable sort ordering

   254

        """

   255

   258

        else:

   259

            # sorts first

   260

            return ipaddr.IPAddress(0)

   261

   262

    def addresses (self):

   263

        """

   264

            Yield (sublabel, ipaddr) records.

   265

        """

   266

   269

   272

   273

        for extension in self.extensions.itervalues():

   274

            for sublabel, ip in extension.addresses():

   275

                yield sublabel, ip

   276

   277

    def fqdn (self):

   282

        if self.domain:

   283

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

   284

        else:

   285

            return pvl.dns.fqdn(self.name)

   286

   287

    def __str__ (self):

   288

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

   289

                domain      = self.domain or '',

   290

        )

   291

   292

class HostExtension (object):

   293

    """

   297

    """

   298

   299

    def addresses (self):

   304

        return ()

   305

   306

def extension (cls):

   307

    """

   308

        Register an extension class

   309

    """

   310

   311

    Host.EXTENSIONS[cls.EXTENSION] = cls

   312