args4c
A convenience mix-in utility for a main entry point.
A convenience mix-in utility for a main entry point.
It parsed the user arguments using the default config (which is ConfigFactory.load() but w/ system environment variables overlaid)
If the config has a 'show=<path>' in it, then that path will be printed out and the program with return.
e.g. MyAppWhichExtendsConfigApp show=myapp.database.url
will display the value of myapp.database.url
It also interprets a single '--setup' to enable the configuration of sensitive configuration entries into a locally encrypted file.
Subsequent runs of your application would then use '--secure=path/to/encrypted.conf' to load that encrypted configuration and either take the password from an environment variable or standard input.
For example, running 'MyApp --setup' would then prompt like this:
Save secure config to (/opt/etc/myapp/.config/secure.conf):config/secure.conf
Config Permissions (defaults to rwx------): rwxrw----
Add config path in the form <key>=<value> (leave blank when finished):myapp.secure.password=hi
Add config path in the form <key>=<value> (leave blank when finished):myapp.another.config.entry=123
Add config path in the form <key>=<value> (leave blank when finished):
Config Password:passwordThen, running 'MyApp --secure=config/secure.conf -myapp.whocares=visible -show=myapp'
would prompt for the password from standard input, then produce the following, hiding the values which were present in the secure config:
myapp.another.config.entry : **** obscured **** # secure.conf: 1 myapp.secure.password : **** obscured **** # secure.conf: 1 myapp.whocares : visible # command-line
NOTE: even though the summary obscures the values, they ARE present as PLAIN TEXT STRINGS in the configuration, so take care in limiting the scope of where the configuration is used, either by filtering back out those values, otherwise separating the secure config from the remaining config, or just ensuring to limit the scope of the config itself.
Represents a request for user input when configuring the 'sensitive configurations'
Adds some scala utility around a typesafe config
Exposes new operations on a 'config'
An object returned from a dynamic select
A means to get a values from user prompts in order to set up a secure configuration
Makes available a means to initialize a sensitive, encrypted config file via SecureConfig.setupSecureConfig and ConfigApp.secureConfigForArgs
Makes available a means to initialize a sensitive, encrypted config file via SecureConfig.setupSecureConfig and ConfigApp.secureConfigForArgs
The idea is that a (service) user-only readable, password-protected AES encrypted config file can be set up via reading entries from standard input, and an application an use those configuration entries thereafter by taking the password from standard input.
Given the user arguments, produce a loaded configuration which interprets the user-args from left to right as:
Given the user arguments, produce a loaded configuration which interprets the user-args from left to right as:
$ a configuration file on the classpath or file system $ a key=value pair
Left-most values take precedence over right
the user command-line arguments
the default configuration to fall back to
the handler for unrecognized user arguments
a parsed configuration
a config for this map
essentially ConfigFactory.load() but with sysEnvAsConfig layered over the default application
Exposes the entry point for using a RichConfig,
Exposes the entry point for using a RichConfig,
mostly for converting user-args into a config
the config key (e.g. foo.bar.bazz)
the config value, as a string
a 'blacklist' which, if any of the entries are found anywhere in the configPath, then the value will be obscured
the
Converts environment variables into a configuration in order to more easily override any config setting based on an environment variable.
Converts environment variables into a configuration in order to more easily override any config setting based on an environment variable.
e.g. instead of having the config:
foo.bar.x = 123
foo.bar.x = $${?FOO_BAR_X}repeated for each setting we can just convert all environment variables split on '_' into lower-case configuration values.
e.g. 'FOO_BAR_X' would get converted into 'foo.bar.x'.
trims and unquotes a string (the single quotes is mine - added to demonstrate the full text):
trims and unquotes a string (the single quotes is mine - added to demonstrate the full text):
'"quoted"' becomes: 'quoted' ' "quoted" ' becomes: 'quoted' 'quoted" ' is unchanged: 'quoted" ' '"quoted ' is unchanged: 'quoted" '
the string to unquote
either the string unchanged or the single quotes removed as trimming whitespace around the quotes
Args4c (arguments for configuration) is intended to add some helpers and utilities in obtaining a typesafe configuration from user arguments.
The core is simply to convert an Array[String] to a Config where the arguments are either paths to configuration resources or simple key=value pairs via args4c.configForArgs
Left-most arguments take precedence. In this example, we assume 'prod.conf' is a resource on the classpath:
In addition to this core concept, this library also provides some additional configuration utilities via args4c.RichConfigOps which can be made available by extending args4c.LowPriorityArgs4cImplicits or importing args4c.implicits:
Where the 'summary' will produce sorted args4c.StringEntry values with potentially sensitive entries (e.g. passwords) obscured and a source comment for some sanity as to where each entry comes from:
myapp.foo : bar # command-line myapp.password : **** obscured **** # command-line myapp.saveTo : afile # file:/opt/etc/myapp/test.conf@3Also, when extracting user arguments into a configuration, an additional 'fallback' config is specified. Typically this would just be the ConfigFactory.load() configuration, but args4c uses the args4c.defaultConfig, which is essentially just the system environment variables converted from snake-caes to dotted lowercase values first, then falling back on ConfigFactory.load().
Applications can elect to not have this behaviour and provide their own fallback configs when parsing args, but the default provides a convenience for system environment variables to override e.g. 'foo.bar.x=default' by specifying
FOO_BAR_X=overrideas a system environment variable. Otherwise you may end up having to repeat this sort of thing all over you config:
foo.bar=default foo.bar=$${?FOO_BAR} foo.bazz=default2 foo.bazz=$${?FOO_BAZZ} ...Finally, args4c also provides a args4c.ConfigApp which provides some additional functionality to configuration-based applications.