1

"""

     2

    Configuration file output for the ISC DHCP server

     3

"""

     4

     5

import conf

     6

     7

import itertools

     8

    31

class Section (conf.ConfObject) :

    32

    """

    33

        A section holds a list of params and a list of decls

    34

    """

    35

    37

        """

    38

            If params/decls are given, those are the used as the initial contents of this section

    41

        """

    42

    43

        self.params = params or []

    44

        self.decls = decls or []

    46

    47

    def add_param (self, param) :

    48

        """

    49

            Add the given Parameter to the end of this section's params

    50

        """

    51

    52

        self.params.append(param)

    53

    54

    def add_params (self, params) :

    55

        for param in params :

    56

            self.add_param(param)

    57

    58

    def add_decl (self, decl) :

    59

        """

    60

            Add the given Declaration to the end of this section's decls

    61

        """

    62

    63

        self.decls.append(decl)

    64

    65

    def add_decls (self, decls) :

    66

        for decl in decls :

    67

            self.add_decl(decl)

    68

    77

    def fmt_lines (self) :

    78

        """

    79

            Format all of our params and decls, in that order

    80

        """

    81

    86

        # then output each content line

    87

        for stmt in itertools.chain(self.params, self.decls) :

    88

            # skip Nones

    89

            if stmt is None :

    90

                continue

    91

    92

            for line in stmt.fmt_lines() :

    93

                yield line

    94

    95

class ConfFile (Section, conf.File) :

    96

    DEFAULT_NAME = "dhcpd.conf"

    97

    DEFAULT_PATH = "/etc/dhcp3/dhcpd.conf"

    98

    99

    def __init__ (self, name=DEFAULT_NAME, path=DEFAULT_PATH, params=None, decls=None) :

   100

        """

   101

            Initialize the dhcpd config file, but don't open it yet.

   102

        """

   103

   104

        conf.File.__init__(self, name, path)

   105

        Section.__init__(self, params, decls)

   106

   107

class Statement (conf.ConfObject) :

   108

    """

   109

        A statement is a single line in the config file

   110

    """

   111

   112

    def __init__ (self, name, *args) :

   113

        """

   114

            Arguments given as None will be ignored.

   115

        """

   116

   117

        self.name = name

   119

   120

    def _fmt_arg (self, arg) :

   121

        """

   122

            Formats a arg for use in output, the following types are supported:

   123

   124

                list/tuple/iter:    results in a comma-and-space separated list of formatted values

   125

                unicode:            results in an encoded str

   126

                str:                results in the string itself, quoted if needed

   127

                other:              attempt to convert to a str, and then format that

   128

        """

   129

   130

        # format lists specially

   131

        # XXX: iterators?

   132

        if isinstance(arg, (list, tuple)) :

   133

            # recurse as a comma-and-space separated list

   134

            return ', '.join(self._fmt_arg(a) for a in arg)

   135

   136

        elif isinstance(arg, Literal) :

   137

            # use what it specifies

   138

            return arg.fmt_arg()

   139

   140

        elif isinstance(arg, unicode) :

   141

            # recurse with the str version

   142

            # XXX: what encoding to use?

   143

            return self._fmt_arg(arg.encode('utf8'))

   144

   145

        elif isinstance(arg, str) :

   146

            # XXX: quoting

   147

            return arg

   148

   149

        else :

   150

            # try and use it as a string

   151

            return self._fmt_arg(str(arg))

   152

   153

    def _fmt_data (self) :

   154

        """

   155

            Formats the statement name/params as a single line, ignoring None

   156

        """

   157

   159

   160

class Literal (Statement) :

   161

    """

   162

        A literal is something that goes into the config file as-is, with no formatting or escaping applied.

   163

    """

   164

   165

    def __init__ (self, literal) :

   166

        self.literal = literal

   167

   168

    def fmt_arg (self) :

   169

        return self.literal

   170

   171

    def fmt_lines (self) :

   172

        yield self.literal

   173

   174

class Parameter (Statement) :

   175

    """

   176

        A parameter is a single statement that configures the behaviour of something.

   177

   178

        Parameters have a name, and optionally, a number of arguments, and are formatted as statements terminated with

   179

        a semicolon. For convenience, params/decls that are None are ignored.

   183

    """

   184

   185

    def fmt_lines (self) :

   186

        """

   187

            Yields a single ;-terminated line

   188

        """

   189

   190

        yield "%s;" % self._fmt_data()

   191

   192

class Declaration (Section, Statement) :

   193

    """

   194

        A declaration begins like a statement (with name and args), but then contains a curly-braces-delimited block

   195

        that acts like a Section.

   196

   197

        <name> [ <args> [ ... ] ] {

   198

            [ <Section> ]

   199

        }

   200

   201

    """

   202

   203

    def __init__ (self, name, args=[], params=None, decls=None) :

   204

        """

   205

            The name/args will be formatted as in Statement, but params should be an iterable of Parameters, and decls

   206

            an iterable of Declarations.

   207

        """

   208

   209

        # init the statement bit

   210

        Section.__init__(self, params, decls)

   211

        Statement.__init__(self, name, *args)

   212

   213

    def fmt_lines (self) :

   214

        """

   215

            Yields a header line, a series of indented body lines, and the footer line

   216

        """

   217

   218

        # the header to open the block

   219

        yield "%s {" % self._fmt_data()

   220

   221

        # then output the section stuff, indented

   222

        for line in Section.fmt_lines(self) :

   223

            yield "\t%s" % line

   224

   225

        # and then close the block

   226

        yield "}"

   227

   228

class SharedNetwork (Declaration) :

   229

    """

   230

        A shared-network declaration is used to define a set of subnets that share the same physical network,

   231

        optionally with some shared params.

   232

   233

        shared-network <name> {

   234

            [ parameters ]

   235

            [ declarations ]

   236

        }

   237

    """

   238

   239

    def __init__ (self, name, params=[], decls=[]) :

   240

        """

   241

            @param name the name of the shared-subnet

   242

            @param params optional parameters

   243

            @param decls the iterable of subnets or other declarations in the shared network

   244

        """

   245

   246

        super(SharedNetwork, self).__init__("shared-network", [name], params, decls)

   247

   248

class Subnet (Declaration) :

   249

    """

   250

        A subnet is used to provide the information about a subnet required to identify whether or not an IP address is

   251

        on that subnet, and may also be used to specify parameters/declarations for that subnet.

   252

   253

        subnet <subnet-number> netmask <netmask> {

   254

            [ parameters ]

   255

            [ declarations ]

   256

        }

   257

    """

   258

   259

    def __init__ (self, network, params=None, decls=None) :

   260

        """

   261

            @param network the addr.Network for the subnet

   262

            @param params optional parameters

   263

            @param decls optional decls, e.g. subnets

   264

        """

   265

   266

        super(Subnet, self).__init__("subnet", [network.net(), "netmask", network.netmask()], params, decls)

   267

   268

class Group (Declaration) :

   269

    """

   270

        A group is simply used to apply a set of parameters to a set of declarations.

   271

   272

        group {

   273

            [ parameters ]

   274

            [ declarations ]

   275

        }

   276

    """

   277

   278

    def __init__ (self, params=None, decls=None) :

   279

        super(Group, self).__init__("group", [], params, decls)

   280

   281

   282

class Host (Declaration) :

   283

    """

   284

        A host is used to match a request against specific host, and then apply settings for that host.

   285

   286

        The "hostname" is the DHCP name to identify the host. 

   287

   288

        If no dhcp-client-identifier option is specified in the parameters, then the host is matched using the

   289

        "hardware" parameter.

   290

   291

        host <hostname> {

   292

            [ parameters ]

   293

            [ declarations ]

   294

        }

   295

    """

   296

   297

    def __init__ (self, hostname, params=None, decls=None) :

   298

        super(Host, self).__init__("host", [hostname], params, decls)

   299

   300

class Option (Parameter) :

   301

    """

   302

        A generic 'option' parameter for a dhcpd.conf file

   303

    """

   304

   305

    def __init__ (self, name, *args) :

   306

        """

   307

            Formatted as a Satement with a name of "option <name>".

   308

        """

   309

   310

        super(Option, self).__init__("option %s" % name, *args)

   311