1

"""

     2

    Configuration file output for the ISC DHCP server

     3

"""

     4

     5

import conf

     6

     7

import itertools

     8

    15

        """

    18

    65

        """

    66

    69

    71

    """

    73

    """

    74

    75

    def __init__ (self, name, *args) :

    76

        """

    77

            The statement will be formatted like this:

    78

                <name> [ <arg> [ ... ] ] ";"

    81

        """

    82

    83

        self.name = name

    84

        self.args = args

    85

    86

    def _fmt_arg (self, arg) :

    87

        """

    88

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

    89

    90

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

    91

                unicode:            results in an encoded str

    92

                str:                results in the string itself, quoted if needed

    93

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

    94

        """

    95

    96

        # format lists specially

    97

        # XXX: iterators?

    98

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

    99

            # recurse as a comma-and-space separated list

   100

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

   101

   102

        elif isinstance(arg, Literal) :

   103

            # use what it specifies

   104

            return arg.fmt_arg()

   105

   106

        elif isinstance(arg, unicode) :

   107

            # recurse with the str version

   108

            # XXX: what encoding to use?

   109

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

   110

   111

        elif isinstance(arg, str) :

   112

            # XXX: quoting

   113

            return arg

   114

   115

        else :

   116

            # try and use it as a string

   117

            return self._fmt_arg(str(arg))

   118

   119

    def _fmt_data (self) :

   120

        """

   122

        """

   123

   125

   126

class Literal (Statement) :

   127

    """

   128

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

   129

    """

   130

   131

    def __init__ (self, literal) :

   132

        self.literal = literal

   133

   134

    def fmt_arg (self) :

   135

        return self.literal

   136

   137

    def fmt_lines (self) :

   138

        yield self.literal

   139

   140

class Parameter (Statement) :

   141

    """

   142

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

   143

   144

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

   146

    """

   147

   148

    def fmt_lines (self) :

   149

        """

   150

            Yields a single ;-terminated line

   151

        """

   152

   153

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

   154

   156

    """

   159

   160

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

   162

        }

   163

   164

    """

   165

   167

        """

   168

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

   169

            an iterable of Declarations.

   170

        """

   171

   172

        # init the statement bit

   174

        Statement.__init__(self, name, *args)

   175

   176

    def fmt_lines (self) :

   177

        """

   178

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

   179

        """

   180

   181

        # the header to open the block

   182

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

   183

   188

        # and then close the block

   189

        yield "}"

   190

   191

class SharedNetwork (Declaration) :

   192

    """

   193

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

   194

        optionally with some shared params.

   195

   196

        shared-network <name> {

   197

            [ parameters ]

   198

            [ declarations ]

   199

        }

   200

    """

   201

   202

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

   203

        """

   204

            @param name the name of the shared-subnet

   205

            @param params optional parameters

   206

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

   207

        """

   208

   209

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

   210

   211

class Subnet (Declaration) :

   212

    """

   213

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

   214

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

   215

   216

        subnet <subnet-number> netmask <netmask> {

   217

            [ parameters ]

   218

            [ declarations ]

   219

        }

   220

    """

   221

   223

        """

   224

            @param network the addr.Network for the subnet

   225

            @param params optional parameters

   226

            @param decls optional decls, e.g. subnets

   227

        """

   228

   229

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

   230

   231

class Group (Declaration) :

   232

    """

   233

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

   234

   235

        group {

   236

            [ parameters ]

   237

            [ declarations ]

   238

        }

   239

    """

   240

   242

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

   243

   244

   245

class Host (Declaration) :

   246

    """

   247

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

   248

   249

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

   250

   251

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

   252

        "hardware" parameter.

   253

   254

        host <hostname> {

   255

            [ parameters ]

   256

            [ declarations ]

   257

        }

   258

    """

   259

   261

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

   262

   263

class Option (Parameter) :

   264

    """

   265

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

   266

    """

   267

   268

    def __init__ (self, name, *args) :

   269

        """

   270

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

   271

        """

   272

   273

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

   274