1

import collections

     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_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, **opts):

    89

    if not value:

    90

        return { }

    91

    92

    if isinstance(value, dict):

    93

        values = value

    94

    else:

    95

        values = {None: value}

    96

    97

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

    98

    99

class Host (object) :

   100

    """

   101

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

   102

    """

   103

   104

    EXTENSIONS = { }

   105

    EXTENSION_FIELDS = { }

   106

   107

    @classmethod

   108

    def parse_extensions(cls, extensions, extra):

   109

        """

   110

            Parse extensions and extension fields to yield

   111

                (HostExtension, field, value)

   112

        """

   113

   114

        for extension, values in extensions.iteritems():

   115

            extension_cls = cls.EXTENSIONS.get(extension)

   116

   117

            if not extension_cls:

   118

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

   119

                continue

   120

   121

            for field, value in values.iteritems():

   122

                yield extension_cls, field, value

   123

   124

        for field, value in extra.iteritems():

   125

            extension_cls = cls.EXTENSION_FIELDS.get(field)

   126

   127

            if not extension_cls:

   128

                raise ValueError("unknown field: {field}".format(field=field))

   129

   130

            yield extension_cls, field, value

   131

   132

    @classmethod

   133

    def build (cls, name, domain,

   134

            ip=None, ip6=None,

   135

            ethernet=None,

   136

            owner=None,

   137

            location=None,

   138

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

   139

            forward=None, reverse=None,

   140

            down=None,

   141

            extensions={ },

   142

            **extra

   143

    ) :

   144

        """

   145

            Return a Host initialized from data attributes.

   146

   147

            This handles all string parsing to our data types.

   148

        """

   149

   150

        extension_classes = { }

   151

   152

        for extension_cls, field, value in cls.parse_extensions(extensions, extra):

   153

            extension_classes.setdefault(extension_cls, dict())[field] = value

   154

   155

        extensions = {extension_cls.EXTENSION: extension_cls.build(**params) for extension_cls, params in extension_classes.iteritems()}

   156

   157

        return cls(name,

   158

                domain      = domain,

   161

                ethernet    = parse_dict(ethernet,  parse_ethernet),

   162

                owner       = owner,

   163

                location    = parse_location(location, domain),

   164

                alias       = parse_list(alias),

   165

                alias4      = parse_list(alias4),

   166

                alias6      = parse_list(alias6),

   167

                forward     = parse_str(forward),

   168

                reverse     = parse_str(reverse),

   169

                down        = parse_bool(down),

   170

                extensions  = extensions,

   171

        )

   172

   173

    def __init__ (self, name, domain,

   174

            ip4=None, ip6=None,

   175

            ethernet={ },

   176

            owner=None,

   177

            location=None,

   178

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

   179

            forward=None, reverse=None,

   180

            down=None,

   181

            extensions={},

   182

    ):

   183

        """

   184

            name        - str

   185

            domain      - str

   188

            ethernet    - { index: ethernet }

   189

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

   190

            owner       - str: LDAP uid

   191

            location    - None or (name, domain)

   192

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

   193

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

   194

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

   195

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

   196

                          str: generate forward zone CNAME to given fqdn

   197

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

   198

                          False: omit PTR records for ip/ip6

   199

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

   200

            down        - mark as offline for polling

   201

        """

   202

   203

        self.name = name

   204

        self.domain = domain

   205

        self.ip4 = ip4

   206

        self.ip6 = ip6

   207

        self.ethernet = ethernet

   208

        self.alias = alias

   209

        self.alias4 = alias4

   210

        self.alias6 = alias6

   211

        self.owner = owner

   212

        self.location = location

   213

        self.forward = forward

   214

        self.reverse = reverse

   215

        self.down = down

   216

        self.extensions = extensions

   217

   218

    def sort_key (self):

   219

        """

   220

            Stable sort ordering

   221

        """

   222

   223

        if self.ip4:

   224

            return self.ip4

   225

        else:

   226

            # sorts first

   228

   229

    def addresses (self):

   230

        """

   232

        """

   233

   234

        if self.ip4:

   235

            yield None, self.ip4

   236

   237

        if self.ip6:

   238

            yield None, self.ip6

   239

   240

        for extension in self.extensions.itervalues():

   241

            for sublabel, ip in extension.addresses():

   242

                yield sublabel, ip

   243

   244

    def fqdn (self):

   245

        """

   246

            Return DNS FQDN for this host in its domain.

   247

        """

   248

   249

        if self.domain:

   250

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

   251

        else:

   252

            return pvl.dns.fqdn(self.name)

   253

   254

    def __str__ (self):

   255

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

   256

                domain      = self.domain or '',

   257

        )

   258

   259

class HostExtension (object):

   260

    """

   261

        Base class for Host.EXTENSIONS

   262

   263

        Provides default no-op behaviours for extension hooks.

   264

    """

   265

   266

    EXTENSION = None

   267

    EXTENSION_FIELDS = ()

   268

   269

    def addresses (self):

   270

        """

   271

            Yield additional (sublabel, ipaddr) records.

   272

        """

   273

   274

        return ()

   275

   276

def register_extension (cls):

   277

    """

   278

        Register an extension class

   279

    """

   280

   281

    Host.EXTENSIONS[cls.EXTENSION] = cls

   282

   283

    for field in cls.EXTENSION_FIELDS:

   284

        Host.EXTENSION_FIELDS[field] = cls