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 apply_host_expand (options, range, name, domain, **params):

    55

    """

    56

        Expand a templated host item.

    57

    """

    58

    59

    name = pvl.dns.parse_generate_field(name)

    60

    61

    # expand all fields

    62

    params = {param: pvl.dns.parse_generate_field(value) for param, value in params.iteritems()}

    63

    64

    for i in range:

    65

        yield name(i), {param: value(i) for param, value in params.iteritems()}

    66

    67

def parse_expand(name):

    68

    """

    69

        Parse a name containing an optional expansion part.

    70

    71

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

    72

    73

        Returns (name, range or None).

    74

    """

    75

    76

    if '{' in name:

    77

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

    78

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

    79

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

    80

    81

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

    82

        name = pre + "$" + post

    83

    84

        # TODO: raise HostConfigError

    85

        range = pvl.dns.parse_generate_range(range)

    86

    else:

    87

        range = None

    88

    89

    return name, range

    90

    91

def parse_host_config(config):

    92

    """

    93

        Parse structured config fields.

    94

    """

    95

    96

    for field, value in config.iteritems():

    97

        if ':' in field :

    98

            extension, field = field.split(':', 1)

    99

        else:

   100

            extension = None

   101

   102

        if '.' in field :

   103

            field, instance = field.split('.')

   104

        else :

   105

            instance = None

   106

   107

        yield extension, field, instance, value

   108

   109

def apply_host(options, name, domain, config):

   110

    """

   111

        Returns Host from a given (expanded) config section.

   112

   113

        Parses config field names:

   114

   115

            [<extension> ":"] <field> ["." <instance>]

   116

    """

   117

   118

    fields = { }

   119

    extensions = fields['extensions'] = { }

   120

   121

    for extension, field, instance, value in parse_host_config(config):

   122

        if extension:

   123

            f = extensions.setdefault(extension, {})

   124

        else:

   125

            f = fields

   126

   127

        if not instance and field not in f:

   128

            f[field] = value

   129

   130

        elif field not in f:

   131

            f[field] = {instance: value}

   132

        elif isinstance(f[field], dict):

   133

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

   134

        else:

   135

            raise HostConfigError(None, "{name}: override instanced {field} value: {value}".format(name=name, field=field, value=value))

   136

   137

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

   138

   140

    """

   141

        Yield Hosts from a given config section.

   142

   143

            options     global options

   144

            parent      parent filename/section containing this host item, or None.

   145

                        used for domain

   146

            name        name of the section (or file) containing this host item.

   147

                        used for hostname

   148

            **config    host parameters

   149

    """

   150

   153

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

   154

    elif '.' in name:

   155

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

   156

        domain = None

   157

    elif parent:

   158

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

   159

        domain = parent

   160

    elif options.hosts_domain:

   161

        log.debug("%s: default domain to --hosts-domain: %s", name, options.hosts_domain)

   162

        domain = options.hosts_domain

   163

    else:

   164

        raise HostConfigError(None, "{name}: no domain given".format(name=name))

   165

   166

    # expand 

   167

    name, range = parse_expand(name)

   168

   169

    if range:

   170

        configs_iter = apply_host_expand(options, range, name, domain, **config)

   171

    else:

   172

        configs_iter = [(name, config)]

   173

   174

    for name, config in configs_iter:

   175

        yield apply_host(options, name, domain, config)

   176

   177

def apply_host_includes (options, config_path, include):

   178

    """

   179

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

   180

    """

   181

   182

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

   183

   184

    if options.hosts_include:

   185

        include_paths.append[options.hosts_include]

   186

   187

    for include in include.split():

   188

        for include_path in include_paths:

   189

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

   190

            if os.path.exists(path):

   191

                break

   192

        else:

   193

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

   194

                    include=include,

   195

                    include_path=' '.join(include_paths),

   196

            ))

   197

   198

        if include.endswith('/'):

   199

            for name in os.listdir(path):

   200

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

   201

   202

                if name.startswith('.'):

   203

                    pass

   204

                elif not os.path.exists(file_path):

   205

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

   206

                else:

   207

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

   208

                    yield open(file_path)

   209

   210

        else:

   211

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

   212

            yield open(path)

   213

   214

def apply_hosts_config (options, path, name, config, defaults={}, parent=None):

   215

    """

   216

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

   217

   218

            options         global options

   219

            path            filesystem path of file (for errors)

   220

            name            name of section/file

   221

            config          configobj.Section

   222

            defaults        hierarchial section defaults

   223

            parent          optional parent section for included files

   224

    """

   225

   226

    # items in this section

   227

    section = dict(defaults)

   228

    for scalar in config.scalars:

   229

        section[scalar] = config[scalar]

   230

   231

    if config.sections:

   232

        # this is a top-level section that includes hosts

   233

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

   234

   235

        # process includes?

   236

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

   237

   238

        for file in apply_host_includes(options, path, includes):

   239

            # within our domain context

   240

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

   241

                yield host

   242

   243

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

   244

        for section_name in config.sections:

   245

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

   246

   247

            for host in apply_hosts_config(options, path, section_name, config[section_name], defaults=section, parent=name):

   248

                yield host

   249

   250

    elif parent:

   251

        # this is a host section

   252

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

   253

   254

        try:

   255

            for host in apply_host_config(options, parent, name, **section):

   256

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

   257

   258

                yield host

   259

   260

        except HostConfigError as error:

   261

            # add in config path

   262

            error.config = path

   263

            raise

   264

   265

    else:

   266

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

   267

   268

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

   269

    """

   270

        Load Hosts from a file path.

   271

   272

            path:str        filesystem path

   273

            parent          included from given name

   274

   275

        Raises

   276

            HostConfigError

   277

            HostConfigObjError

   278

    """

   279

   280

    # use file basename as default domain

   281

    path = file.name

   282

    name = os.path.basename(path)

   283

   284

    try:

   285

        config = configobj.ConfigObj(file,

   286

                raise_errors    = True, # raise ConfigPObjError immediately

   287

                interpolation   = 'Template',

   288

                encoding        = options.hosts_charset,

   289

        )

   290

    except configobj.ConfigObjError as ex:

   291

        raise HostConfigObjError(path, ex)

   292

   293

    return apply_hosts_config(options, path, name, config, parent=parent)

   294

   295

def apply_hosts (options, files):

   296

    """

   297

        Load Hosts from files.

   298

   299

            files:[str]     list of filesystem paths

   300

    """

   301

   302

    for path in files:

   303

        try:

   304

            file = open(path)

   305

        except IOError as ex:

   306

            raise HostConfigError(path, ex.strerror)

   307

   308

        for host in apply_hosts_file(options, file):

   309

            yield host

   310

   311

def apply (options, args):

   312

    """

   313

        Load Hosts from arguments.

   314

   315

        Exits with status=2 if loading the confs fails.

   316

    """

   317

   318

    try:

   319

        # load hosts from configs

   320

        hosts = list(apply_hosts(options, args))

   321

    except HostConfigObjError as error:

   322

        log.error("%s", error)

   323

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

   324

        sys.exit(2)

   325

   326

    except HostConfigError as error:

   327

        log.error("%s", error)

   328

        sys.exit(2)

   329

   330

    # stable ordering

   331

    return sorted(hosts, key=Host.sort_key)