Looking for configuration DSL that allows sparse specification and outputs JSON

Question

Background: We have all seen several ways to configure a distributed application. For my purposes, two of them stand out:

1. Have a massive database that all nodes have access to. Each node knows its own identity, and so can perform queries against said database to pull out the configuration information specific to itself.

2. Use tailored (i.e., specific to each node) configuration files (e.g., JSON) so that the nodes do not have to touch a database at all. They simply read the tailored config file and do what it says.

There are pros and cons to each. For my purposes, I would like to explore #2a little further, but the problem I'm running into is that the JSON files can get pretty big. I'm wondering if anyone knows a DSL that is well-suited for generating these JSON files.

Step-by-step examples to illustrate what I mean:

Suppose I make up this metalanguage that looks like this:

bike.%[0..3](Vehicle)

This would then output the following JSON:

{
    "bike.0": 
    {
        "type": "Vehicle"
    },

    "bike.1": 
    {
        "type": "Vehicle"
    },

    "bike.2": 
    {
        "type": "Vehicle"
    },

    "bike.3": 
    {
        "type": "Vehicle"
    }
}

The idea is that we've just created 4 bikes, each of which is of type Vehicle.

Going further:

bike[i=0..3](Vehicle)
    label: "hello %i"
    label.3: "last"

Now what this does is to name the index variable 'i' so that it can be used for the configuration information of each item. The JSON that would be output would be something like this:

{
    "bike.0": 
    {
        "type": "Vehicle",
        "cfg": 
        {
            "label": "hello 0"
        }
    },

    "bike.1": 
    {
        "type": "Vehicle",
        "cfg": 
        {
            "label": "hello 1"
        }
    },

    "bike.2": 
    {
        "type": "Vehicle",
        "cfg": 
        {
            "label": "hello.2"
        }
    },

    "bike.3": 
    {
        "type": "Vehicle",
        "cfg": 
        {
            "label": "last"
        }
    }
}

You can see how the last label was overridden, so this is a way to sparsely specify stuff. Is there anything already out there that lets one do this?

Thanks!

Answer 1

Rather than thinking of the metalanguage as a monolithic entity, it might be better to divide it into three parts:

1. An input specification. You can use a configuration file syntax to hold this specification.

2. A library or utility that can use print statements and for-loops to generate runtime configuration files. The Apache Velocity template engine comes to mind as something that is suitable for this purpose. I suggest you look at its user guide to get a feel for what it can do.

3. Some glue code to join together the above two items. In particular, the glue code reads name=value pairs from the input specification, and passes them to the template engine, which uses them as parameters to "instantiate" the template versions of the configuration files that you want to generate.

My answer to another StackOverflow question provides some more details of the above idea.