1 # <a id="language-reference"></a> Language Reference
3 ## <a id="object-definition"></a> Object Definition
5 Icinga 2 features an object-based configuration format. You can define new
6 objects using the `object` keyword:
8 object Host "host1.example.org" {
11 address = "192.168.0.1"
15 In general you need to write each statement on a new line. Expressions started
16 with `{`, `(` and `[` extend until the matching closing character and can be broken
17 up into multiple lines.
19 Alternatively you can write multiple statements on a single line by separating
20 them with a semicolon:
22 object Host "host1.example.org" {
23 display_name = "host1"
25 address = "192.168.0.1"; address6 = "::1"
28 Each object is uniquely identified by its type (`Host`) and name
29 (`host1.example.org`). Some types have composite names, e.g. the
30 `Service` type which uses the `host_name` attribute and the name
31 you specified to generate its object name.
33 Exclamation marks (!) are not permitted in object names.
35 Objects can contain a comma-separated list of property
36 declarations. Instead of commas semicolons may also be used.
37 The following data types are available for property values:
39 All objects have at least the following attributes:
41 Attribute | Description
42 ---------------------|-----------------------------
43 name | The name of the object. This attribute can be modified in the object definition to override the name specified with the `object` directive.
44 type | The type of the object.
46 ## <a id="expressions"></a> Expressions
48 The following expressions can be used on the right-hand side of assignments.
50 ### <a id="numeric-literals"></a> Numeric Literals
52 A floating-point number.
58 ### <a id="duration-literals"></a> Duration Literals
60 Similar to floating-point numbers except for the fact that they support
61 suffixes to help with specifying time durations.
67 Supported suffixes include ms (milliseconds), s (seconds), m (minutes),
68 h (hours) and d (days).
70 Duration literals are converted to seconds by the config parser and
71 are treated like numeric literals.
73 ### <a id="string-literals"></a> String Literals
81 #### <a id="string-literals-escape-sequences"></a> String Literals Escape Sequences
83 Certain characters need to be escaped. The following escape sequences
86 Character | Escape sequence
87 --------------------------|------------------------------------
91 <CARRIAGE-RETURN> | \\r
92 <LINE-FEED> | \\n
94 <FORM-FEED> | \\f
96 In addition to these pre-defined escape sequences you can specify
97 arbitrary ASCII characters using the backslash character (\\) followed
98 by an ASCII character in octal encoding.
100 ### <a id="multiline-string-literals"></a> Multi-line String Literals
102 Strings spanning multiple lines can be specified by enclosing them in
112 Unlike in ordinary strings special characters do not have to be escaped
113 in multi-line string literals.
115 ### <a id="boolean-literals"></a> Boolean Literals
117 The keywords `true` and `false` are used to denote truth values.
119 ### <a id="null-value"></a> Null Value
121 The `null` keyword can be used to specify an empty value.
123 ### <a id="dictionary"></a> Dictionary
125 An unordered list of key-value pairs. Keys must be unique and are
126 compared in a case-sensitive manner.
128 Individual key-value pairs must either be comma-separated or on separate lines.
129 The comma after the last key-value pair is optional.
134 address = "192.168.0.1"
138 Identifiers may not contain certain characters (e.g. space) or start
139 with certain characters (e.g. digits). If you want to use a dictionary
140 key that is not a valid identifier, you can enclose the key in double
143 ### <a id="array"></a> Array
145 An ordered list of values.
147 Individual array elements must be comma-separated.
148 The comma after the last element is optional.
154 An array may simultaneously contain values of different types, such as
157 ### <a id="expression-operators"></a> Operators
159 The following operators are supported in expressions. The operators are by descending precedence.
161 Operator | Precedence | Examples (Result) | Description
162 ---------|------------|-----------------------------------------------|--------------------------------
163 () | 1 | (3 + 3) * 5 | Groups sub-expressions
164 () | 1 | Math.random() | Calls a function
165 [] | 1 | a[3] | Array subscript
166 . | 1 | a.b | Element access
167 ! | 2 | !"Hello" (false), !false (true) | Logical negation of the operand
168 ~ | 2 | ~true (false) | Bitwise negation of the operand
169 + | 2 | +3 | Unary plus
170 - | 2 | -3 | Unary minus
171 * | 3 | 5m * 10 (3000) | Multiplies two numbers
172 / | 3 | 5m / 5 (60) | Divides two numbers
173 % | 3 | 17 % 12 (5) | Remainder after division
174 + | 4 | 1 + 3 (4), "hello " + "world" ("hello world") | Adds two numbers; concatenates strings
175 - | 4 | 3 - 1 (2) | Subtracts two numbers
176 << | 5 | 4 << 8 (1024) | Left shift
177 >> | 5 | 1024 >> 4 (64) | Right shift
178 < | 6 | 3 < 5 (true) | Less than
179 > | 6 | 3 > 5 (false) | Greater than
180 <= | 6 | 3 <= 3 (true) | Less than or equal
181 >= | 6 | 3 >= 3 (true) | Greater than or equal
182 in | 7 | "foo" in [ "foo", "bar" ] (true) | Element contained in array
183 !in | 7 | "foo" !in [ "bar", "baz" ] (true) | Element not contained in array
184 == | 8 | "hello" == "hello" (true), 3 == 5 (false) | Equal to
185 != | 8 | "hello" != "world" (true), 3 != 3 (false) | Not equal to
186 & | 9 | 7 & 3 (3) | Binary AND
187 ^ | 10 | 17 ^ 12 (29) | Bitwise XOR
188 | | 11 | 2 | 3 (3) | Binary OR
189 && | 13 | true && false (false), 3 && 7 (7), 0 && 7 (0) | Logical AND
190 || | 14 | true || false (true), 0 || 7 (7)| Logical OR
191 = | 12 | a = 3 | Assignment
192 => | 15 | x => x * x (function with arg x) | Lambda, for loop
194 ### <a id="function-calls"></a> Function Calls
196 Functions can be called using the `()` operator:
198 const MyGroups = [ "test1", "test" ]
201 check_interval = len(MyGroups) * 1m
204 A list of available functions is available in the [Library Reference](18-library-reference.md#library-reference) chapter.
206 ## <a id="dictionary-operators"></a> Assignments
208 In addition to the `=` operator shown above a number of other operators
209 to manipulate attributes are supported. Here's a list of all
212 ### <a id="operator-assignment"></a> Operator =
214 Sets an attribute to the specified value.
223 In this example `a` has the value `7` after both instructions are executed.
225 ### <a id="operator-additive-assignment"></a> Operator +=
227 The += operator is a shortcut. The following expression:
241 ### <a id="operator-substractive-assignment"></a> Operator -=
243 The -= operator is a shortcut. The following expression:
257 ### <a id="operator-multiply-assignment"></a> Operator \*=
259 The *= operator is a shortcut. The following expression:
273 ### <a id="operator-dividing-assignment"></a> Operator /=
275 The /= operator is a shortcut. The following expression:
289 ## <a id="indexer"></a> Indexer
291 The indexer syntax provides a convenient way to set dictionary elements.
299 Example (alternative syntax):
302 hello["key"] = "world"
305 This is equivalent to writing:
313 If the `hello` attribute does not already have a value, it is automatically initialized to an empty dictionary.
315 ## <a id="template-imports"></a> Template Imports
317 Objects can import attributes from other objects.
321 template Host "default-host" {
325 template Host "test-host" {
326 import "default-host"
331 object Host "localhost" {
334 address = "127.0.0.1"
338 The `default-host` and `test-host` objects are marked as templates
339 using the `template` keyword. Unlike ordinary objects templates are not
340 instantiated at run-time. Parent objects do not necessarily have to be
341 templates, however in general they are.
343 The `vars` dictionary for the `localhost` object contains all three
344 custom attributes and the custom attribute `colour` has the value `"blue"`.
346 Parent objects are resolved in the order they're specified using the
349 Default templates which are automatically imported into all object definitions
350 can be specified using the `default` keyword:
352 template CheckCommand "plugin-check-command" default {
356 Default templates are imported before any other user-specified statement in an
357 object definition is evaluated.
359 If there are multiple default templates the order in which they are imported
362 ## <a id="constants"></a> Constants
364 Global constants can be set using the `const` keyword:
366 const VarName = "some value"
368 Once defined a constant can be accessed from any file. Constants cannot be changed
371 Icinga 2 provides a number of special global constants. Some of them can be overridden using the `--define` command line parameter:
373 Variable |Description
374 --------------------|-------------------
375 PrefixDir |**Read-only.** Contains the installation prefix that was specified with cmake -DCMAKE_INSTALL_PREFIX. Defaults to "/usr/local".
376 SysconfDir |**Read-only.** Contains the path of the sysconf directory. Defaults to PrefixDir + "/etc".
377 ZonesDir |**Read-only.** Contains the path of the zones.d directory. Defaults to SysconfDir + "/zones.d".
378 LocalStateDir |**Read-only.** Contains the path of the local state directory. Defaults to PrefixDir + "/var".
379 RunDir |**Read-only.** Contains the path of the run directory. Defaults to LocalStateDir + "/run".
380 PkgDataDir |**Read-only.** Contains the path of the package data directory. Defaults to PrefixDir + "/share/icinga2".
381 StatePath |**Read-write.** Contains the path of the Icinga 2 state file. Defaults to LocalStateDir + "/lib/icinga2/icinga2.state".
382 ObjectsPath |**Read-write.** Contains the path of the Icinga 2 objects file. Defaults to LocalStateDir + "/cache/icinga2/icinga2.debug".
383 PidPath |**Read-write.** Contains the path of the Icinga 2 PID file. Defaults to RunDir + "/icinga2/icinga2.pid".
384 Vars |**Read-write.** Contains a dictionary with global custom attributes. Not set by default.
385 NodeName |**Read-write.** Contains the cluster node name. Set to the local hostname by default.
386 EventEngine |**Read-write.** The name of the socket event engine, can be "poll" or "epoll". The epoll interface is only supported on Linux.
387 AttachDebugger |**Read-write.** Whether to attach a debugger when Icinga 2 crashes. Defaults to false.
388 RunAsUser |**Read-write.** Defines the user the Icinga 2 daemon is running as. Used in the `init.conf` configuration file.
389 RunAsGroup |**Read-write.** Defines the group the Icinga 2 daemon is running as. Used in the `init.conf` configuration file.
390 PlatformName |**Read-only.** The name of the operating system, e.g. "Ubuntu".
391 PlatformVersion |**Read-only.** The version of the operating system, e.g. "14.04.3 LTS".
392 PlatformKernel |**Read-only.** The name of the operating system kernel, e.g. "Linux".
393 PlatformKernelVersion|**Read-only.** The version of the operating system kernel, e.g. "3.13.0-63-generic".
394 BuildCompilerName |**Read-only.** The name of the compiler Icinga was built with, e.g. "Clang".
395 BuildCompilerVersion|**Read-only.** The version of the compiler Icinga was built with, e.g. "7.3.0.7030031".
396 BuildHostName |**Read-only.** The name of the host Icinga was built on, e.g. "acheron".
398 ## <a id="apply"></a> Apply
400 The `apply` keyword can be used to create new objects which are associated with
401 another group of objects.
403 apply Service "ping" to Host {
404 import "generic-service"
406 check_command = "ping4"
408 assign where host.name == "localhost"
411 In this example the `assign where` condition is a boolean expression which is
412 evaluated for all objects of type `Host` and a new service with name "ping"
413 is created for each matching host. [Expression operators](17-language-reference.md#expression-operators)
414 may be used in `assign where` conditions.
416 The `to` keyword and the target type may be omitted if there is only one target
417 type, e.g. for the `Service` type.
419 Depending on the object type used in the `apply` expression additional local
420 variables may be available for use in the `where` condition:
422 Source Type | Target Type | Variables
423 ------------------|-------------|--------------
424 Service | Host | host
425 Dependency | Host | host
426 Dependency | Service | host, service
427 Notification | Host | host
428 Notification | Service | host, service
429 ScheduledDowntime | Host | host
430 ScheduledDowntime | Service | host, service
432 Any valid config attribute can be accessed using the `host` and `service`
433 variables. For example, `host.address` would return the value of the host's
434 "address" attribute -- or null if that attribute isn't set.
436 More usage examples are documented in the [monitoring basics](3-monitoring-basics.md#using-apply-expressions)
439 ## <a id="apply-for"></a> Apply For
441 [Apply](17-language-reference.md#apply) rules can be extended with the
442 [for loop](17-language-reference.md#for-loops) keyword.
444 apply Service "prefix-" for (key => value in host.vars.dictionary) to Host {
445 import "generic-service"
447 check_command = "ping4"
448 vars.host_value = value
452 Any valid config attribute can be accessed using the `host` and `service`
453 variables. The attribute must be of the Array or Dictionary type. In this example
454 `host.vars.dictionary` is of the Dictionary type which needs a key-value-pair
457 In this example all generated service object names consist of `prefix-` and
458 the value of the `key` iterator. The prefix string can be omitted if not required.
460 The `key` and `value` variables can be used for object attribute assignment, e.g. for
461 setting the `check_command` attribute or custom attributes as command parameters.
463 `apply for` rules are first evaluated against all objects matching the `for loop` list
464 and afterwards the `assign where` and `ignore where` conditions are evaluated.
466 It is not necessary to check attributes referenced in the `for loop` expression
467 for their existance using an additional `assign where` condition.
469 More usage examples are documented in the [monitoring basics](3-monitoring-basics.md#using-apply-for)
472 ## <a id="group-assign"></a> Group Assign
474 Group objects can be assigned to specific member objects using the `assign where`
475 and `ignore where` conditions.
477 object HostGroup "linux-servers" {
478 display_name = "Linux Servers"
480 assign where host.vars.os == "Linux"
483 In this example the `assign where` condition is a boolean expression which is evaluated
484 for all objects of the type `Host`. Each matching host is added as member to the host group
485 with the name "linux-servers". Membership exclusion can be controlled using the `ignore where`
486 condition. [Expression operators](17-language-reference.md#expression-operators) may be used in `assign where` and
487 `ignore where` conditions.
489 Source Type | Variables
490 ------------------|--------------
492 ServiceGroup | host, service
496 ## <a id="boolean-values"></a> Boolean Values
498 The `assign where`, `ignore where`, `if` and `while` statements, the `!` operator as
499 well as the `bool()` function convert their arguments to a boolean value based on the
502 Description | Example Value | Boolean Value
503 ---------------------|-------------------|--------------
504 Empty value | null | false
506 Non-zero integer | -23945 | true
507 Empty string | "" | false
508 Non-empty string | "Hello" | true
509 Empty array | [] | false
510 Non-empty array | [ "Hello" ] | true
511 Empty dictionary | {} | false
512 Non-empty dictionary | { key = "value" } | true
514 For a list of supported expression operators for `assign where` and `ignore where`
515 statements, see [expression operators](17-language-reference.md#expression-operators).
517 ## <a id="comments"></a> Comments
519 The Icinga 2 configuration format supports C/C++-style and shell-style comments.
526 object Host "localhost" {
527 check_interval = 30 // this is also a comment.
528 retry_interval = 15 # yet another comment
531 ## <a id="includes"></a> Includes
533 Other configuration files can be included using the `include` directive.
534 Paths must be relative to the configuration file that contains the
539 include "some/other/file.conf"
540 include "conf.d/*.conf"
542 Wildcard includes are not recursive.
544 Icinga also supports include search paths similar to how they work in a
549 Note the use of angle brackets instead of double quotes. This causes the
550 config compiler to search the include search paths for the specified
551 file. By default $PREFIX/share/icinga2/include is included in the list of search
552 paths. Additional include search paths can be added using
553 [command-line options](11-cli-commands.md#config-include-path).
555 Wildcards are not permitted when using angle brackets.
557 ## <a id="recursive-includes"></a> Recursive Includes
559 The `include_recursive` directive can be used to recursively include all
560 files in a directory which match a certain pattern.
564 include_recursive "conf.d", "*.conf"
565 include_recursive "templates"
567 The first parameter specifies the directory from which files should be
568 recursively included.
570 The file names need to match the pattern given in the second parameter.
571 When no pattern is specified the default pattern "*.conf" is used.
573 ## <a id="zone-includes"></a> Zone Includes
575 The `include_zones` recursively includes all subdirectories for the
578 In addition to that it sets the `zone` attribute for all objects created
579 in these subdirectories to the name of the subdirectory.
583 include_zones "etc", "zones.d", "*.conf"
584 include_zones "puppet", "puppet-zones"
586 The first parameter specifies a tag name for this directive. Each `include_zones`
587 invocation should use a unique tag name. When copying the zones' configuration
588 files Icinga uses the tag name as the name for the destination directory in
589 `/var/lib/icinga2/api/config`.
591 The second parameter specifies the directory which contains the subdirectories.
593 The file names need to match the pattern given in the third parameter.
594 When no pattern is specified the default pattern "*.conf" is used.
596 ## <a id="library"></a> Library directive
598 The `library` directive can be used to manually load additional
599 libraries. Libraries can be used to provide additional object types and
606 ## <a id="functions"></a> Functions
608 Functions can be defined using the `function` keyword.
612 function multiply(a, b) {
616 When encountering the `return` keyword further execution of the function is terminated and
617 the specified value is supplied to the caller of the function:
621 In this example the `multiply` function we declared earlier is invoked with two arguments (3 and 5).
622 The function computes the product of those arguments and makes the result available to the
625 When no value is supplied for the `return` statement the function returns `null`.
627 Functions which do not have a `return` statement have their return value set to the value of the
628 last expression which was performed by the function. For example, we could have also written our
629 `multiply` function like this:
631 function multiply(a, b) {
635 Anonymous functions can be created by omitting the name in the function definition. The
636 resulting function object can be used like any other value:
638 var fn = function() { 3 }
642 ## <a id="lambdas"></a> Lambda Expressions
644 Functions can also be declared using the alternative lambda syntax.
650 Multiple statements can be used by putting the function body into braces:
657 Just like with ordinary functions the return value is the value of the last statement.
659 For lambdas which take exactly one argument the braces around the arguments can be omitted:
663 ## <a id="nullary-lambdas"></a> Abbreviated Lambda Syntax
665 Lambdas which take no arguments can also be written using the abbreviated lambda syntax.
671 This creates a new function which returns the value 3.
673 ## <a id="variable-scopes"></a> Variable Scopes
675 When setting a variable Icinga checks the following scopes in this order whether the variable
676 already exists there:
682 The local scope contains variables which only exist during the invocation of the current function,
683 object or apply statement. Local variables can be declared using the `var` keyword:
685 function multiply(a, b) {
690 Each time the `multiply` function is invoked a new `temp` variable is used which is in no way
691 related to previous invocations of the function.
693 When setting a variable which has not previously been declared as local using the `var` keyword
694 the `this` scope is used.
696 The `this` scope refers to the current object which the function or object/apply statement
699 object Host "localhost" {
703 In this example the `this` scope refers to the "localhost" object. The `check_interval` attribute
704 is set for this particular host.
706 You can explicitly access the `this` scope using the `this` keyword:
708 object Host "localhost" {
709 var check_interval = 5m
711 /* This explicitly specifies that the attribute should be set
712 * for the host, if we had omitted `this.` the (poorly named)
713 * local variable `check_interval` would have been modified instead.
715 this.check_interval = 1m
718 Similarly the keywords `locals` and `globals` are available to access the local and global scope.
720 Functions also have a `this` scope. However unlike for object/apply statements the `this` scope for
721 a function is set to whichever object was used to invoke the function. Here's an example:
726 function init(word) {
731 /* Let's invoke the init() function */
734 We're using `hm.init` to invoke the function which causes the value of `hm` to become the `this`
735 scope for this function call.
737 ## <a id="closures"></a> Closures
739 By default `function`s, `object`s and `apply` rules do not have access to variables declared
740 outside of their scope (except for global variables).
742 In order to access variables which are defined in the outer scope the `use` keyword can be used:
744 function MakeHelloFunction(name) {
745 return function() use(name) {
746 log("Hello, " + name)
750 In this case a new variable `name` is created inside the inner function's scope which has the
751 value of the `name` function argument.
753 Alternatively a different value for the inner variable can be specified:
755 function MakeHelloFunction(name) {
756 return function() use (greeting = "Hello, " + name) {
761 ## <a id="conditional-statements"></a> Conditional Statements
763 Sometimes it can be desirable to only evaluate statements when certain conditions are met. The if/else
764 construct can be used to accomplish this.
778 An if/else construct can also be used in place of any other value. The value of an if/else statement
779 is the value of the last statement which was evaluated for the branch which was taken:
782 log("Taking the 'true' branch")
785 log("Taking the 'false' branch")
789 This example prints the log message "Taking the 'true' branch" and the `a` variable is set to 21 (7 * 3).
791 The value of an if/else construct is null if the condition evaluates to false and no else branch is given.
793 ## <a id="while-loops"></a> While Loops
795 The `while` statement checks a condition and executes the loop body when the condition evaluates to `true`.
796 This is repeated until the condition is no longer true.
807 The `continue` and `break` keywords can be used to control how the loop is executed: The `continue` keyword
808 skips over the remaining expressions for the loop body and begins the next loop evaluation. The `break` keyword
809 breaks out of the loop.
811 ## <a id="for-loops"></a> For Loops
813 The `for` statement can be used to iterate over arrays and dictionaries.
817 var list = [ "a", "b", "c" ]
823 The loop body is evaluated once for each item in the array. The variable `item` is declared as a local
824 variable just as if the `var` keyword had been used.
826 Iterating over dictionaries can be accomplished in a similar manner:
828 var dict = { a = 3, b = 7 }
830 for (key => value in dict) {
831 log("Key: " + key + ", Value: " + value)
834 The `continue` and `break` keywords can be used to control how the loop is executed: The `continue` keyword
835 skips over the remaining expressions for the loop body and begins the next loop evaluation. The `break` keyword
836 breaks out of the loop.
838 ## <a id="constructor"></a> Constructors
840 In order to create a new value of a specific type constructor calls may be used.
844 var pd = PerfdataValue()
848 You can also try to convert an existing value to another type by specifying it as an argument for the constructor call.
852 var s = String(3) /* Sets s to "3". */
854 ## <a id="throw"></a> Exceptions
856 Built-in commands may throw exceptions to signal errors such as invalid arguments. User scripts can throw exceptions
857 using the `throw` keyword.
861 throw "An error occurred."
863 There is currently no way for scripts to catch exceptions.
865 ## <a id="breakpoints"></a> Breakpoints
867 The `debugger` keyword can be used to insert a breakpoint. It may be used at any place where an assignment would also be a valid expression.
869 By default breakpoints have no effect unless Icinga is started with the `--script-debugger` command-line option. When the script debugger is enabled Icinga stops execution of the script when it encounters a breakpoint and spawns a console which lets the user inspect the current state of the execution environment.
871 ## <a id="types"></a> Types
873 All values have a static type. The `typeof` function can be used to determine the type of a value:
875 typeof(3) /* Returns an object which represents the type for numbers */
877 The following built-in types are available:
879 Type | Examples | Description
880 -----------|-------------------|------------------------
881 Number | 3.7 | A numerical value.
882 Boolean | true, false | A boolean value.
883 String | "hello" | A string.
884 Array | [ "a", "b" ] | An array.
885 Dictionary | { a = 3 } | A dictionary.
887 Depending on which libraries are loaded additional types may become available. The `icinga`
888 library implements a whole bunch of other [object types](9-object-types.md#object-types),
889 e.g. Host, Service, CheckCommand, etc.
891 Each type has an associated type object which describes the type's semantics. These
892 type objects are made available using global variables which match the type's name:
894 /* This logs 'true' */
895 log(typeof(3) == Number)
897 The type object's `prototype` property can be used to find out which methods a certain type
900 /* This returns: ["contains","find","len","lower","replace","reverse","split","substr","to_string","trim","upper"] */
901 keys(String.prototype)
903 Additional documentation on type methods is available in the
904 [library reference](18-library-reference.md#library-reference).
906 ## <a id="location-information"></a> Location Information
908 The location of the currently executing script can be obtained using the
909 `current_filename` and `current_line` keywords.
913 log("Hello from '" + current_filename + "' in line " + current_line)
915 ## <a id="reserved-keywords"></a> Reserved Keywords
917 These keywords are reserved and must not be used as constants or custom attributes.
947 You can escape reserved keywords using the `@` character. The following example
948 tries to set `vars.include` which references a reserved keyword and generates
951 [2014-09-15 17:24:00 +0200] critical/config: Location:
952 /etc/icinga2/conf.d/hosts/localhost.conf(13): vars.sla = "24x7"
953 /etc/icinga2/conf.d/hosts/localhost.conf(14):
954 /etc/icinga2/conf.d/hosts/localhost.conf(15): vars.include = "some cmdb export field"
956 /etc/icinga2/conf.d/hosts/localhost.conf(16): }
957 /etc/icinga2/conf.d/hosts/localhost.conf(17):
959 Config error: in /etc/icinga2/conf.d/hosts/localhost.conf: 15:8-15:14: syntax error, unexpected include (T_INCLUDE), expecting T_IDENTIFIER
960 [2014-09-15 17:24:00 +0200] critical/config: 1 errors, 0 warnings.
962 You can escape the `include` keyword by prefixing it with an additional `@` character:
964 object Host "localhost" {
965 import "generic-host"
967 address = "127.0.0.1"
973 vars.@include = "some cmdb export field"