ConfigApp

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 '--secret=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 secret config to (/opt/etc/myapp/.config/secret.conf):config/secret.conf
Config Permissions (defaults to rwx------): rwxrw----
Add config path in the form <key>=<value> (leave blank when finished):myapp.secret.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:password

Then, running 'MyApp --secret=config/secret.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 secret config:

myapp.another.config.entry : **** obscured **** # secret.conf: 1
myapp.secret.password : **** obscured **** # secret.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 secret config from the remaining config, or just ensuring to limit the scope of the config itself.

Linear Supertypes

LowPriorityArgs4cImplicits, AnyRef, Any

Type Members

abstract type Result

The result of running this application
implicit class RichArgs extends AnyRef

Definition Classes
LowPriorityArgs4cImplicits
implicit class RichString extends AnyRef

Definition Classes
LowPriorityArgs4cImplicits
case class SecretConfigDoesntExist(path: Path) extends SecretConfigResult with Product with Serializable

Attributes
protected
case class SecretConfigParsed(path: Path, config: Config) extends SecretConfigResult with Product with Serializable

Attributes
protected
sealed abstract class SecretConfigResult extends AnyRef

Attributes
protected

Abstract Value Members

abstract def run(config: Config): Result

Instead of 'main', this 'apply' should run w/ a config
Instead of 'main', this 'apply' should run w/ a config
config
the configuration to run with

Concrete Value Members

final def !=(arg0: Any): Boolean

Definition Classes
AnyRef → Any
final def ##(): Int

Definition Classes
AnyRef → Any
final def ==(arg0: Any): Boolean

Definition Classes
AnyRef → Any
object SecretConfigNotSpecified extends SecretConfigResult with Product with Serializable

Attributes
protected
final def asInstanceOf[T0]: T0

Definition Classes
Any
implicit def asRichConfig(c: Config): RichConfig

Definition Classes
LowPriorityArgs4cImplicits
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
def defaultConfig(): Config

returns
the default config to overlay the user args over.
def defaultIgnoreDefaultSecretConfigArg: String

returns
he command-line argument flag which tells the application NOT to load the default secret config file if it exists. e.g., try running the app without the secret config.

Attributes
protected
def defaultSecretConfigArg: String

returns
the command-line argument to specify the path to an encrypted secret config file (e.g. MyApp -secret=.passwords.conf)

Attributes
protected
def defaultSetupUserArgFlag: String

returns
the flag which should indicate that we should prompt to setup secret configurations

Attributes
protected
final def eq(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def equals(arg0: Any): Boolean

Definition Classes
AnyRef → Any
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
def hashCode(): Int

Definition Classes
AnyRef → Any
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
def isPasswordSetup(userArgs: Array[String], setupArg: String): Boolean

Attributes
protected
def main(args: Array[String]): Unit

exposes a main entry point which will then:
exposes a main entry point which will then:
1) parse the user args as a configuration 2) check the user args if we should just 'show' a particular configuration setting (obscuring sensitive entries) 3) check the user args if we should run 'setup' to configure an encrypted configuration
args
the user arguments
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
def obscure(secretPathsOpt: Option[Seq[String]])(configPath: String, value: String): String

Attributes
protected
def onUnrecognizedUserArg(allowedArgs: Set[String])(arg: String): Config

Attributes
protected
def pathToSecretConfigFromArgs(userArgs: Array[String], pathToSecretConfigArg: String): Option[String]

Attributes
protected
def runMain(userArgs: Array[String], readLine: (String) ⇒ String, setupUserArgFlag: String = defaultSetupUserArgFlag, ignoreDefaultSecretConfigArg: String = defaultIgnoreDefaultSecretConfigArg, pathToSecretConfigArg: String = defaultSecretConfigArg): Option[Result]

launch the application, which will create a typesafe config instance from the user arguments by :
launch the application, which will create a typesafe config instance from the user arguments by :
$ try to parse the user arguments into a config entry, interpreting them as key=value pairs or locations of config files $ try to load an encrypted 'secret' config if one has been setup to overlay over the other config $ try to map system environment variables as lowercase dot-separated paths so e.g. (FOO_BAR=x) can be used to override foo.bar
In addition to providing a configuration from the user arguments and environment variables, the user arguments are also checked for one of three special arguments:
$ The argument 'show=<key substring>' flag, in which case the configuration matching <key substring> is shown. This can be especially convenient to verify the right config values are picked up if there are multiple arguments, such as alternative property files, key=value pairs, etc.
$ The argument '--setup' in order to populate a password-encrypted secret config file from standard input. For example, running "MyMainEntryPoint --setup" will proceed to prompt the user for config entries which will be saved in a password-encrypted file with restricted permissions. Subsequent runs of the application will check for this file, either in the default location or from -secret=<path/to/encrypted/config>
If either the default or specified encrypted files are found, then the password is taken either from the CONFIG_SECRET if set, or else it prompted for from standard input
userArgs
the user arguments
readLine
a function to read in the user input
setupUserArgFlag
the argument to check for in order to run the secret config setup
ignoreDefaultSecretConfigArg
the argument which, if 'userArgs' contains this string, then we will NOT try
pathToSecretConfigArg
the value for the key in the form <key>=<path to secret password config> (e.g. defaults to "--secret", as in --secret=/etc/passwords.conf)
def runWithConfig(secretConfig: SecretConfigResult, parsedConfig: Config): Option[Result]

Exposes a run function which checks the parsedConfig for a 'show' user setting to display the config, otherwise invokes 'run' with the parsed config.
Exposes a run function which checks the parsedConfig for a 'show' user setting to display the config, otherwise invokes 'run' with the parsed config.
This method exposes access to the secret config parse result should the application need to do something with it
secretConfig
the result of the secret config user arguments
parsedConfig
the total configuration, potentially including the secret config

Attributes
protected
def secretConfigForArgs(userArgs: Array[String], readLine: (String) ⇒ String, ignoreDefaultSecretConfigArg: String, pathToSecretConfigArg: String): SecretConfigResult

Attributes
protected
def showValue(value: String, config: Config): Unit

displays the value for the given config for when the 'show' command-line arg was specified
displays the value for the given config for when the 'show' command-line arg was specified
value
the value to show
config
the config value at a particular path

Attributes
protected
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
def toString(): String

Definition Classes
AnyRef → Any
final def wait(): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long, arg1: Int): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )

Related Doc: package args4c

trait ConfigApp extends LowPriorityArgs4cImplicits

Type Members

abstract type Result

implicit class RichArgs extends AnyRef

implicit class RichString extends AnyRef

case class SecretConfigDoesntExist(path: Path) extends SecretConfigResult with Product with Serializable

case class SecretConfigParsed(path: Path, config: Config) extends SecretConfigResult with Product with Serializable

sealed abstract class SecretConfigResult extends AnyRef

Abstract Value Members

abstract def run(config: Config): Result

Concrete Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

object SecretConfigNotSpecified extends SecretConfigResult with Product with Serializable

final def asInstanceOf[T0]: T0

implicit def asRichConfig(c: Config): RichConfig

def clone(): AnyRef

def defaultConfig(): Config

def defaultIgnoreDefaultSecretConfigArg: String

def defaultSecretConfigArg: String

def defaultSetupUserArgFlag: String

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def finalize(): Unit

final def getClass(): Class[_]

def hashCode(): Int

final def isInstanceOf[T0]: Boolean

def isPasswordSetup(userArgs: Array[String], setupArg: String): Boolean

def main(args: Array[String]): Unit

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def obscure(secretPathsOpt: Option[Seq[String]])(configPath: String, value: String): String

def onUnrecognizedUserArg(allowedArgs: Set[String])(arg: String): Config

def pathToSecretConfigFromArgs(userArgs: Array[String], pathToSecretConfigArg: String): Option[String]

def runMain(userArgs: Array[String], readLine: (String) ⇒ String, setupUserArgFlag: String = defaultSetupUserArgFlag, ignoreDefaultSecretConfigArg: String = defaultIgnoreDefaultSecretConfigArg, pathToSecretConfigArg: String = defaultSecretConfigArg): Option[Result]

def runWithConfig(secretConfig: SecretConfigResult, parsedConfig: Config): Option[Result]

def secretConfigForArgs(userArgs: Array[String], readLine: (String) ⇒ String, ignoreDefaultSecretConfigArg: String, pathToSecretConfigArg: String): SecretConfigResult

def showValue(value: String, config: Config): Unit

final def synchronized[T0](arg0: ⇒ T0): T0

def toString(): String

final def wait(): Unit

final def wait(arg0: Long, arg1: Int): Unit

final def wait(arg0: Long): Unit

Inherited from LowPriorityArgs4cImplicits

Inherited from AnyRef

Inherited from Any

Ungrouped