The configuration language is designed to have a simple interface for configuring the controller and switches. This language is implemented using a compiler front-end that checks for valid syntax and typing. The main structures in the language are bindings between stages and identifiers, and the staging of those identifiers. The types in the language are predefined, with literals for IPv4, IPv6, integers, time, protocols, strings, and OpenFlow protocol versions. These literals can be combined into predefined types, which form stages. The stages include Realm, Authentication, Authorization, Initialization, but, for a switch agent, Realm is replaced with Connector. These stages are designed to be run in the order specified by the symbol “->” in the language. Each stage describes the behavior a controller should exhibit when making or accepting new connections, or for a switch agent describes its connection behavior. The advantage of using a compiler front-end and a more robust language for configuration is that the configuration can be checked for validity and more advanced configuration features can be implemented.
The configuration language is supported by a utility that will check grammar and typing, and then generate commands that can be run to configure the controller or switch agent. This utility runs in four stages: tokenizing, parsing, elaboration, and evaluation. The parsing stage will check that the input is properly formatted using a grammar designed to be simple to read and write. The elaboration stage checks that all input matches types defined by the language, preventing incorrect input for specific fields. After this stage, guarantees can be made that settings that should hold specific kinds of values are only holding these types of values. Lastly, the input is evaluated and transformed into commands that can be run by the controller or switch agent. Tokenizing is not mentioned because it occurs concurrently with parsing.