Understanding Namespaces in Icinga 2 DSL

I hope you now have a basic understanding of what namespaces are in Icinga 2. Now, we’re going to explore how to create our own custom namespaces. Careful though, as this is where things get a bit messy. Unlike other programming languages, Icinga 2’s implementation of namespaces is somewhat limited and has its quirks. But don’t worry, I’ll guide you through it. To create a custom namespace, you use the `namespace` keyword followed by the name of the namespace and a block of code enclosed in curly braces. Here’s an example:

namespace utils {
    function IsValidUrl(url) {
        return regex("^http(s)?://[^:/]+(?::[0-9]+)?(/.*)?$", url)
    }

    function ParseUrl(url) {
        if (!IsValidUrl(url)) {
          return null // Return null if the URL is not valid.
        }
        var result = {}
        var parts = url.split(":")
        result.protocol = parts[0]
        // Skip the '//' after the protocol and extract the hostname and path.
        result.hostname = parts[1].substr(2).split("/")[0]
        result.port = result.protocol == "https" ? 443 : 80
        if (parts.len() >= 3) {
            result.port = parts[2]
        }
        return result
    }

    function IsSpace(char) {
        return char in [ " ", "\t", "\n", "\r", "\b", "\f" ]
    }

    function TrimSpace(hostname) {
        var start = 0
        var end = hostname.len() - 1
        while (start <= end && IsSpace(hostname.substr(start, 1))) {
            start += 1
        }
        while (end >= start && IsSpace(hostname.substr(end, 1))) {
            end -= 1
        }
        return hostname.substr(start, end - start + 1)
    }
}

In this example, we’ve created a namespace called utils that contains four functions: IsValidUrl(), ParseUrl(), IsSpace(), and TrimSpace().  We can now use these functions elsewhere in our Icinga 2 configuration by using the fully qualified name, like so: utils.ParseUrl("https://example.com:8080/path"). For instance, we can use the above utils namespace to validate and parse a messed up URL like this for our apply rules:

object Host "vm.icinga.com" {
  check_command = "ping4"
  address = "vm.icinga.com"

  vars.http_urls = [
    "  \t\r\n   https://rsync.icinga.com:873\n \r ",
    "  \t https://packages.icinga.com \n \b ",
    "  \r\n\t\f https://demo.icinga.com \r ",
  ]
}

apply Service for (url in host.vars.http_urls) {
  check_command = "http"

  var parsed = utils.ParseUrl(utils.TrimSpace(url))
  if (parsed == null) {
    log(LogCritical, "HTTP APPLY RULE", "Invalid URL encountered - hostname: " + host_name + ", url: " + url)
    throw "Invalid HTTP URL" // Causes the config load to fail.
  }
  name = parsed.hostname
  vars.http_address = parsed.hostname
  vars.http_port = parsed.port
  vars.http_ssl = parsed.protocol == "https"
}

This will create HTTP services for each URL in the http_urls variable of the host, after trimming any leading or trailing whitespace characters and parsing the URL into its components. This is just a simple example and might not cover all edge cases, but it demonstrates how you can use custom namespaces to organize your code better. For instance, you could place the above namespace in a separate file called utils.conf somewhere and include it in your main configuration file using the include directive like so: include "/path/to/utils.conf".