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

    78

def parse_config_field(field):

    79

    """

    80

        Parse structured config fields.

    81

    82

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

    83

    """

    84

    85

    if ':' in field :

    86

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

    87

    else:

    88

        extension = None

    89

    90

    if '.' in field :

    91

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

    92

    else :

    93

        instance = None

    94

    95

    return extension, field, instance

    96

    97

def apply_host (name, domain, config):

    98

    """

    99

        Return Host from an (expanded) config section.

   100

   101

            name        - (expanded) name of host

   102

            domain      - domain for host

   103

            config      - host config fields to parse

   104

   105

        Fields can either be scalar string values, or instance'd dicts. If a field has both a non-instance'd value and instance'd values,

   106

        the non-instance'd value will be use instance=None:

   107

   108

        Raises ValueError.

   109

    """

   110

   111

    fields = { }

   112

    extensions = fields['extensions'] = { }

   113

   114

    for field, value in config.iteritems():

   115

        extension, field, instance = parse_config_field(field)

   116

   117

        if extension:

   118

            f = extensions.setdefault(extension, {})

   119

        else:

   120

            f = fields

   121

   124

        if instance:

   125

            if field not in f:

   126

                f[field] = { }

   127

            elif not isinstance(f[field], dict):

   128

                # convert to dict

   129

                f[field] = {None: f[field]}

   130

   131

            f[field][instance] = value

   134

        else:

   135

            f[field] = value

   136

   137

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

   138

   139

def apply_hosts (parent, name, config):

   140

    """

   141

        Yield Hosts from a given config section.

   142

   143

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

   144

                          used for domain

   145

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

   146

                          used for hostname

   147

            config      - host parameters to parse

   148

   149

        Raises ValueError.

   150

    """

   151

   152

    if '@' in name:

   153

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

   154

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

   155

    elif '.' in name:

   156

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

   157

        domain = None

   158

    elif parent:

   159

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

   160

        domain = parent

   161

    else:

   162

        # XXX: impossible?

   163

        raise ValueError("no domain given")

   164

   165

    # expand?

   166

    name, range = parse_expand(name)

   167

   168

    if range:

   169

        generate_name = pvl.dns.parse_generate_field(name)

   170

   171

        # expand all fields

   172

        generate_config = {field: pvl.dns.parse_generate_field(value) for field, value in config.iteritems()}

   173

   174

        for i in range:

   175

            yield apply_host(generate_name(i), domain, 

   176

                    {field: value(i) for field, value in generate_config.iteritems()},

   177

            )

   178

   179

    else:

   180

        # single host

   181

        yield apply_host(name, domain, config)

   182

   183

def parse_config_includes (options, config_path, includes, **opts):

   184

    """

   185

        Yield file paths from a given config's include=... value

   186

    """

   187

   188

    # relative

   189

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

   190

   191

    if options.hosts_include:

   192

        include_paths.append(options.hosts_include)

   193

   194

    for include in includes:

   195

        for include_path in include_paths:

   196

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

   197

   198

            if os.path.exists(path):

   199

                break

   200

        else:

   201

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

   202

                    include=include,

   203

                    include_path=' '.join(include_paths),

   204

            ))

   205

   206

   207

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

   208

        yield path

   209

   210

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

   211

    """

   212

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

   213

   214

            options         global options

   215

            path            filesystem path of file (for errors)

   216

            name            name of this section/file

   217

            config          configobj.Section

   218

            parent          parent section from included files or --hosts-domain

   219

            defaults        hierarchial section defaults

   220

    """

   221

   222

    # items in this section

   223

    section = dict(defaults)

   224

    for scalar in config.scalars:

   225

        section[scalar] = config[scalar]

   226

   227

    # process includes?

   228

    if 'include' in section:

   229

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

   230

   231

        includes = list(parse_config_includes(options, path, includes))

   232

   233

        # within our domain context

   234

        for host in apply_hosts_files(options, includes, parent=name):

   235

            yield host

   236

    else:

   237

        includes = None

   238

   239

    if config.sections:

   240

        # this is a top-level section that includes hosts

   241

        if parent:

   242

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

   243

   244

            name = pvl.dns.join(name, parent)

   245

        else:

   246

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

   247

   248

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

   249

        for section_name in config.sections:

   250

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

   251

   252

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

   253

                yield host

   254

   255

    elif parent:

   256

        # this is a host section

   257

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

   258

   259

        try:

   260

            for host in apply_hosts(parent, name, section):

   261

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

   262

   263

                yield host

   264

   265

        except ValueError as error:

   266

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

   267

   268

            raise HostConfigError(path, "{parent}: {name}: {error}".format(parent=parent, name=name, error=error))

   269

   270

    elif includes:

   271

        # includes-only zone

   272

        pass

   273

   274

    elif section:

   275

        raise HostConfigError(path, "Top-level hosts are only allowed in included confs")

   276

    else:

   277

        # empty file

   278

        log.info("%s: skip empty conf", path)

   279

   280

def apply_hosts_config (options, file, **opts):

   281

    """

   282

        Load Hosts from a file path.

   283

   284

            file            - opened file object, with .name attribute

   285

   286

        Raises

   287

            HostConfigError

   288

            HostConfigObjError

   289

    """

   290

   291

    # use file basename as default domain

   292

    path = file.name

   293

    name = os.path.basename(path)

   294

   295

    try:

   296

        config = configobj.ConfigObj(file,

   297

                raise_errors    = True, # raise ConfigPObjError immediately

   298

                interpolation   = 'Template',

   299

                encoding        = options.hosts_charset,

   300

        )

   301

    except configobj.ConfigObjError as ex:

   302

        raise HostConfigObjError(path, ex)

   303

   304

    return apply_hosts_configs(options, path, name, config, **opts)

   305

   306

def apply_hosts_file (options, path, **opts):

   307

    """

   308

        Load Hosts from a file path.

   309

    """

   310

   311

    try:

   312

        file = open(path)

   313

    except IOError as ex:

   314

        raise HostConfigError(path, ex.strerror)

   315

   316

    for host in apply_hosts_config(options, file, **opts):

   317

        yield host

   318

   319

def apply_hosts_directory (options, root, **opts):

   320

    """

   321

        Load Hosts from a directory, loading each file within the directory.

   322

   323

        Skips .dotfiles.

   324

    """

   325

   326

    for name in sorted(os.listdir(root)):

   327

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

   328

   329

        if name.startswith('.'):

   330

            log.debug("%s: skip dotfile: %s", root, name)

   331

            continue

   332

   333

        if os.path.isdir(path):

   334

            log.debug("%s: skip directory: %s", root, name)

   335

            continue

   336

   337

        for host in apply_hosts_file(options, path, **opts):

   338

            yield host

   339

   340

def apply_hosts_files (options, files, **opts):

   341

    """

   342

        Load Hosts from files.

   343

   344

            files:[str]     list of filesystem paths, which may be directories or files

   345

    """

   346

   347

    for path in files:

   348

        if os.path.isdir(path):

   349

            for host in apply_hosts_directory(options, path, **opts):

   350

                yield host

   351

        else:

   352

            for host in apply_hosts_file(options, path, **opts):

   353

                yield host

   354

   355

def apply (options, args):

   356

    """

   357

        Load Hosts from arguments.

   358

   359

        Exits with status=2 if loading the confs fails.

   360

    """

   361

   362

    try:

   363

        # load hosts from configs

   364

        hosts = list(apply_hosts_files(options, args))

   365

    except HostConfigObjError as error:

   366

        log.error("%s", error)

   367

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

   368

        sys.exit(2)

   369

   370

    except HostConfigError as error:

   371

        log.error("%s", error)

   372

        sys.exit(2)

   373

   374

    # stable ordering

   375

    return sorted(hosts, key=Host.sort_key)

   376