1

"""

     2

    Load Hosts from config files.

     3

"""

     4

     5

import configobj

     6

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

     7

import optparse

     8

import os.path

     9

import pvl.args

    10

import pvl.dns

    11

import sys

    12

    13

from pvl.hosts.host import Host

    14

    15

def optparser (parser):

    16

    hosts = optparse.OptionGroup(parser, "Hosts config files")

    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. Default uses config file basename")

    22

    23

    hosts.add_option('--hosts-include',         metavar='PATH',

    24

            help="Optional path for hosts includes, in addition to the host config dir")

    25

    26

    return hosts

    27

    28

class HostConfigError (Exception):

    29

    """

    30

        Generic error for file path.

    31

    """

    32

    33

    def __init__ (self, config, error):

    34

        self.config = config

    35

        self.error = error

    36

    37

    def __str__ (self):

    38

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

    39

    40

class HostConfigObjError (Exception):

    41

    """

    42

        An error from ConfigObj for a config file path.

    43

    """

    44

    45

    def __init__ (self, config, error):

    46

        self.config = config

    47

        self.error = error

    48

    49

        self.line_contents = error.line

    50

    51

    def __str__ (self):

    52

        return "{self.config}:{self.error.line_number}: {self.error.message}".format(self=self)        

    53

    54

def parse_expand(name):

    55

    """

    56

        Parse a name containing an optional expansion part.

    57

    58

            name:           hostname containing optional "{...}" part

    59

    60

        Returns (name, range or None).

    61

    """

    62

    63

    if '{' in name:

    64

        # consume the first {...} token as the range

    65

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

    66

        range, post = name.split('}', 1)

    67

    68

        # if there's a second {...} token, it will be re-composed into ${...}

    69

        name = pre + "$" + post

    70

    71

        # TODO: raise HostConfigError

    72

        range = pvl.dns.parse_generate_range(range)

    73

    else:

    74

        range = None

    75

    76

    return name, range

    77

    79

    """

    80

        Parse structured config fields.

    83

    """

    84

    89

    96

    98

    """

   106

    """

   107

   108

    fields = { }

   109

    extensions = fields['extensions'] = { }

   110

   114

        if extension:

   115

            f = extensions.setdefault(extension, {})

   116

        else:

   117

            f = fields

   118

   119

        if not instance and field not in f:

   120

            f[field] = value

   121

   122

        elif field not in f:

   123

            f[field] = {instance: value}

   124

        elif isinstance(f[field], dict):

   125

            f.setdefault(field, {})[instance] = value

   126

        else:

   129

    return Host.build(name, domain, **fields)

   130

   132

    """

   133

        Yield Hosts from a given config section.

   142

    """

   143

   144

    if '@' in name:

   145

        name, domain = name.split('@', 1)

   146

        log.debug("%s: using explicit domain: %s", name, domain)

   147

    elif '.' in name:

   148

        log.debug("%s: using as fqdn without domain", name)

   149

        domain = None

   150

    elif parent:

   151

        log.debug("%s: default domain to section: %s", name, parent)

   152

        domain = parent

   153

    else:

   156

   158

    name, range = parse_expand(name)

   159

   160

    if range:

   171

    else:

   174

   176

    """

   177

        Yield files from a given config's include=... value

   178

    """

   179

   180

    include_paths = [os.path.dirname(config_path)]

   181

   182

    if options.hosts_include:

   183

        include_paths.append[options.hosts_include]

   184

   185

    for include in include.split():

   186

        for include_path in include_paths:

   187

            path = os.path.join(include_path, include)

   188

            if os.path.exists(path):

   189

                break

   190

        else:

   191

            raise HostConfigError(config_path, "Unable to find include {include} in include path: {include_path}".format(

   192

                    include=include,

   193

                    include_path=' '.join(include_paths),

   194

            ))

   195

   196

        if include.endswith('/'):

   197

            for name in os.listdir(path):

   198

                file_path = os.path.join(path, name)

   199

   200

                if name.startswith('.'):

   201

                    pass

   202

                elif not os.path.exists(file_path):

   203

                    log.warn("%s: skip nonexistant include: %s", config_path, file_path)

   204

                else:

   205

                    log.info("%s: include: %s", config_path, file_path)

   206

                    yield open(file_path)

   207

   208

        else:

   209

            log.info("%s: include: %s", config_path, path)

   210

            yield open(path)

   211

   213

    """

   214

        Load hosts from a configobj.Section (which can be the top-level ConfigObj).

   215

   216

            options         global options

   217

            path            filesystem path of file (for errors)

   219

            config          configobj.Section

   221

            defaults        hierarchial section defaults

   222

    """

   223

   224

    # items in this section

   225

    section = dict(defaults)

   226

    for scalar in config.scalars:

   227

        section[scalar] = config[scalar]

   229

    if config.sections:

   230

        # this is a top-level section that includes hosts

   231

        log.info("%s: @%s", path, name)

   232

   233

        # process includes?

   234

        includes = section.pop('include', '')

   235

   237

            # within our domain context

   238

            for host in apply_hosts_file(options, file, parent=name):

   239

                yield host

   240

   241

        # recurse until we hit a scalar-only section representing a host

   242

        for section_name in config.sections:

   243

            log.debug("%s: %s: %s", path, name, section_name)

   244

   246

                yield host

   247

   248

    elif parent:

   249

        # this is a host section

   250

        log.debug("%s: %s@%s", path, name, parent)

   251

   252

        try:

   254

                log.info("%s: %s", path, host)

   255

   256

                yield host

   260

   262

   263

    else:

   264

        raise HostConfigError(path, "No sections in config")

   265

   266

def apply_hosts_file (options, file, parent=None):

   267

    """

   268

        Load Hosts from a file path.

   269

   270

            path:str        filesystem path

   272

   273

        Raises

   274

            HostConfigError

   275

            HostConfigObjError

   276

    """

   277

   278

    # use file basename as default domain

   279

    path = file.name

   280

    name = os.path.basename(path)

   281

   282

    try:

   283

        config = configobj.ConfigObj(file,

   284

                raise_errors    = True, # raise ConfigPObjError immediately

   285

                interpolation   = 'Template',

   286

                encoding        = options.hosts_charset,

   287

        )

   288

    except configobj.ConfigObjError as ex:

   289

        raise HostConfigObjError(path, ex)

   290

   292

   294

    """

   295

        Load Hosts from files.

   296

   297

            files:[str]     list of filesystem paths

   298

    """

   299

   300

    for path in files:

   301

        try:

   302

            file = open(path)

   303

        except IOError as ex:

   304

            raise HostConfigError(path, ex.strerror)

   305

   307

            yield host

   308

   309

def apply (options, args):

   310

    """

   311

        Load Hosts from arguments.

   312

   313

        Exits with status=2 if loading the confs fails.

   314

    """

   315

   316

    try:

   317

        # load hosts from configs

   319

    except HostConfigObjError as error:

   320

        log.error("%s", error)

   321

        log.error("\t%s", error.line_contents)

   322

        sys.exit(2)

   323

   324

    except HostConfigError as error:

   325

        log.error("%s", error)

   326

        sys.exit(2)

   327

   328

    # stable ordering

   329

    return sorted(hosts, key=Host.sort_key)