Ecosyste.ms: Awesome
An open API service indexing awesome lists of open source software.
https://github.com/npryce/konfig
Simple config properties API for Kotlin
https://github.com/npryce/konfig
command-line-parser configuration environment-variables jvm kotlin properties
Last synced: 1 day ago
JSON representation
Simple config properties API for Kotlin
- Host: GitHub
- URL: https://github.com/npryce/konfig
- Owner: npryce
- License: apache-2.0
- Created: 2015-12-01T23:39:23.000Z (about 9 years ago)
- Default Branch: master
- Last Pushed: 2022-06-05T11:15:13.000Z (over 2 years ago)
- Last Synced: 2025-01-19T09:05:20.489Z (8 days ago)
- Topics: command-line-parser, configuration, environment-variables, jvm, kotlin, properties
- Language: Kotlin
- Size: 257 KB
- Stars: 282
- Watchers: 7
- Forks: 38
- Open Issues: 16
-
Metadata Files:
- Readme: README.md
- License: LICENSE.txt
Awesome Lists containing this project
README
# Konfig - A Type Safe Configuration API for Kotlin
[](http://kotlinlang.org)
[](https://travis-ci.org/npryce/konfig)
[](http://search.maven.org/#search%7Cga%7C1%7Cg%3A%22com.natpryce%22%20AND%20a%3A%22konfig%22)
Konfig provides an extensible, type-safe API for configuration
properties gathered from multiple sources — built in resources, system
properties, property files, environment variables, command-line
arguments, etc.
A secondary goal of Konfig is to make configuration "self explanatory”.
Misconfiguration errors are reported with the location and “true name”
of the badly configured property. E.g. a program may look up a key
defined as `Key("http.port", intType)`. At runtime, it will be parsed
from an environment variable named `HTTP_PORT`. So the error message
reports the name of the environment variable, so that the user can
easily find and fix the error.
Configuration can be inspected and listed. For example, it can be
exposed by HTTP to a network management system to help site
reliability engineers understand the current configuration of a
running application.
Getting Started
---------------
To get started, add `com.natpryce:konfig:` as a dependency, import `com.natpryce.konfig.*` and then:
1. Define typed property keys
```kotlin
val server_port = Key("server.port", intType)
val server_host = Key("server.host", stringType)
```
2. Build a Configuration object that loads properties:
```kotlin
val config = systemProperties() overriding
EnvironmentVariables() overriding
ConfigurationProperties.fromFile(File("/etc/myservice.properties")) overriding
ConfigurationProperties.fromResource("defaults.properties")
```
3. Define some properties. For example, in `defaults.properties`:
```properties
server.port=8080
server.host=0.0.0.0
```
4. Look up properties by key. They are returned as typed values, not strings, and so can be used directly:
```kotlin
val server = Server(config[server_port], config[server_host])
server.start()
```
Konfig can load properties from:
* Java property files and resources
* Java system properties
* Environment variables
* Hard-coded maps (with convenient syntax)
* Command-line parameters (with long and short option syntax)
Konfig can easily be extended with new property types and sources of configuration data.
Konfig can report where configuration properties are searched for and where they were found.
# Naming of Properties
Konfig's Configuration objects expect property names to follow Java property name conventions: dots to represent hierarchy, lower-case identifiers within the hierarchy, hyphens to separate words in those identifiers.
For example: `servers.file-storage.s3-api-key`, `servers.file-storage.s3-bucket`.
Each Configuration implementation maps from that naming convention to the convention used by the underlying configuration store. E.g. the `EnvironmentVariables` implementation maps Java property name convention to the upper-case-and-underscores convention used for Unix environment variables.
Configuration is an interface and Key is a data class. This makes it straight forward to write an implementation of Configuration that translates the names of keys to different naming conventions, if your configuration follows an unusual convention.
# Reflectomagic key definition
Konfig has a few ways to reduce boilerplate code when defining configuration keys.
1) You can use Kotlin's delgated property protocol to name keys after the constants that hold them:
```
val host by stringType // defines a key named "host"
val port by intType // defines a key named "port"
...
val client = TcpClient(configuration[host], configuration[port])
```
2) You can declare objects that extend PropertyGroup to define hierarchies of property keys that follow the Konfig naming conventions described above:
```
object server : PropertyGroup() {
val base_uri by uriType // defines a key named "server.base-uri"
val api_key by stringType // defines a key named "server.api-key"
}
...
val client = HttpClient(configuration[server.base_uri], configuration[server.api_key])
```