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 sys

    11

    12

from pvl.hosts.host import Host

    13

    14

def optparser (parser):

    15

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

    16

    hosts.add_option('--hosts-charset',         metavar='CHARSET',  default='utf-8', 

    17

            help="Encoding used for host files")

    18

    19

    hosts.add_option('--hosts-domain',          metavar='DOMAIN',

    20

            help="Default domain for hosts. Default uses config file basename")

    21

    22

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

    23

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

    24

    25

    return hosts

    26

    27

class HostConfigError (Exception):

    28

    """

    29

        Generic error for file path.

    30

    """

    31

    32

    def __init__ (self, config, error):

    33

        self.config = config

    34

        self.error = error

    35

    36

    def __str__ (self):

    37

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

    38

    39

class HostConfigObjError (Exception):

    40

    """

    41

        An error from ConfigObj for a config file path.

    42

    """

    43

    44

    def __init__ (self, config, error):

    45

        self.config = config

    46

        self.error = error

    47

    48

        self.line_contents = error.line

    49

    50

    def __str__ (self):

    51

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

    52

    54

    """

    55

        Expand a templated host item.

    56

    """

    57

    58

    name = pvl.dns.zone.parse_generate_field(name)

    59

    60

    # expand all fields

    61

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

    62

    63

    for i in range:

    65

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

    66

        )

    71

    72

def parse_expand(name):

    73

    """

    74

        Parse a name containing an optional expansion part.

    75

    76

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

    77

    78

        Returns (name, range or None).

    79

    """

    80

    81

    if '{' in name:

    83

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

    88

    89

        range = pvl.dns.zone.parse_generate_range(range)

    90

    else:

    91

        range = None

    92

    93

    return name, range

    94

    95

def apply_host_config (options, path, parent, name,

    96

        domain=None,

    97

        **params

    98

):

    99

    """

   100

        Yield Hosts from a given config section.

   101

   102

            options     global options

   103

            path        config file for errors

   104

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

   105

                        used for domain

   106

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

   107

                        used for hostname

   108

            **params    host parameters

   109

    """

   110

   111

    if domain:

   112

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

   113

    elif '.' in name:

   114

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

   115

        domain = None

   116

    elif parent:

   117

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

   118

        domain = parent

   119

    elif options.hosts_domain:

   120

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

   121

        domain = options.hosts_domain

   122

    else:

   123

        raise HostsConfigError(path, "{name}: no domain given".format(name=name))

   124

   125

    # expand 

   126

    name, range = parse_expand(name)

   127

   128

    if range:

   130

            yield host

   131

    else:

   135

   137

   138

def apply_host_includes (options, config_path, include):

   139

    """

   140

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

   141

    """

   142

   143

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

   144

   145

    if options.hosts_include:

   146

        include_paths.append[options.hosts_include]

   147

   148

    for include in include.split():

   149

        for include_path in include_paths:

   150

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

   151

            if os.path.exists(path):

   152

                break

   153

        else:

   154

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

   155

                    include=include,

   156

                    include_path=' '.join(include_paths),

   157

            ))

   158

   159

        if include.endswith('/'):

   160

            for name in os.listdir(path):

   161

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

   162

   163

                if name.startswith('.'):

   164

                    pass

   165

                elif not os.path.exists(file_path):

   166

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

   167

                else:

   168

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

   169

                    yield open(file_path)

   170

   171

        else:

   172

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

   173

            yield open(path)

   174

   175

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

   176

    """

   177

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

   178

   179

            options         global options

   180

            path            filesystem path of file (for errors)

   181

            name            name of section/file

   182

            config          configobj.Section

   183

            defaults        hierarchial section defaults

   184

            parent          optional parent section for included files

   185

    """

   186

   187

    # items in this section

   188

    section = dict(defaults)

   189

    for scalar in config.scalars:

   190

        section[scalar] = config[scalar]

   191

   192

    if config.sections:

   193

        # this is a top-level section that includes hosts

   194

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

   195

   196

        # process includes?

   197

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

   198

   199

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

   200

            # within our domain context

   201

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

   202

                yield host

   203

   204

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

   205

        for section_name in config.sections:

   206

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

   207

   208

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

   209

                yield host

   210

   211

    elif parent:

   212

        # this is a host section

   213

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

   214

   215

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

   216

            yield host

   217

   218

    else:

   219

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

   220

   221

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

   222

    """

   223

        Load Hosts from a file path.

   224

   225

            path:str        filesystem path

   226

            parent          included from given name

   227

   228

        Raises

   229

            HostConfigError

   230

            HostConfigObjError

   231

    """

   232

   233

    # use file basename as default domain

   234

    path = file.name

   235

    name = os.path.basename(path)

   236

   237

    try:

   238

        config = configobj.ConfigObj(file,

   239

                raise_errors    = True, # raise ConfigPObjError immediately

   240

                interpolation   = 'Template',

   241

                encoding        = options.hosts_charset,

   242

        )

   243

    except configobj.ConfigObjError as ex:

   244

        raise HostConfigObjError(path, ex)

   245

   246

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

   247

   248

def apply_hosts (options, files):

   249

    """

   250

        Load Hosts from files.

   251

   252

            files:[str]     list of filesystem paths

   253

    """

   254

   255

    for path in files:

   256

        try:

   257

            file = open(path)

   258

        except IOError as ex:

   259

            raise HostConfigError(path, ex.strerror)

   260

   261

        for host in apply_hosts_file(options, file):

   262

            yield host

   263

   264

def apply (options, args):

   265

    """

   266

        Load Hosts from arguments.

   267

    """

   268

   269

    try:

   270

        # load hosts from configs

   271

        hosts = list(apply_hosts(options, args))

   272

    except HostConfigObjError as error:

   273

        log.error("%s", error)

   274

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

   275

        sys.exit(2)

   276

   277

    except HostConfigError as error:

   278

        log.error("%s", error)

   279

        sys.exit(2)

   280

   281

    # stable ordering

   282

    hosts = sorted(hosts, key=Host.sort_key)

   283

   284

    return hosts