How to use external .groovy config file in Grails 3

Question

Section 24.3 in Externalized Configuration indicates a .properties or .yml file can be used for external config, but I would like my external config to be a .groovy file just like my application.groovy file which I have already converted from .yml. How can I make this happen?

Grails version 3.2.0.M2

UPDATE:

I was able to get this working based on the answer provided by @Michal_Szulc

Note that the ConfigSlurper needed the current environment to work correctly. Also note that these changes are to be made to the my_grails_app/grails-app/init/my_grails_app/Application.groovy file, not the my_grails_app/grails-app/conf/application.groovy file which you may have if you converted from a .yml configuration to a .groovy configuration.

package my_grails_app

import grails.boot.GrailsApp
import grails.boot.config.GrailsAutoConfiguration
import org.springframework.context.EnvironmentAware
import org.springframework.core.env.Environment
import org.springframework.core.env.MapPropertySource

class Application extends GrailsAutoConfiguration implements EnvironmentAware {
    static void main( String[] args ) {
        GrailsApp.run( Application, args )
    }

    @Override
    void setEnvironment( Environment environment ) {
        def appName = grails.util.Metadata.current.getApplicationName()

        // The value of this environment variable should be the absolute path to an external .groovy config file like /opt/my_grails_app/my_grails_app-config.groovy.
        def envVarName = "MY_GRAILS_APP_CONFIG"

        // If you don't want to use an environment variable you can specify your external .groovy config file here, but the environment variable will still be checked first.
        def dfltAppConfigFileName = "/opt/${ appName }/${ appName }-config.groovy"
        def appConfigFile = null
        def loadDfltConfig = false

        // Try to load config specified by the environment variable first
        println "Checking the environment variable ${ envVarName } for the configuration file location..."
        def envVarVal = System.getenv( envVarName ) ?: System.getProperty( envVarName )
        if( envVarVal ) {
            appConfigFile = new File( envVarVal )
            if( !appConfigFile.exists() ) {
                println "The configuration file ${ appConfigFile } specified by the environment variable ${ envVarName } does not exist.  Checking for the default configuration file ${ dfltAppConfigFileName } instead..."
                appConfigFile = null
                loadDfltConfig = true
            }
        } else {
            println "The environment variable ${ envVarName } which specifies the configuration file to be loaded does not exist.  Checking for the default configuration file ${ dfltAppConfigFileName } instead..."
            appConfigFile = null
            loadDfltConfig = true
        }

        // Try loading the default config file since we couldn't find one specified by the environment variable
        if( loadDfltConfig ) {
            appConfigFile = new File( dfltAppConfigFileName )
            if( !appConfigFile.exists() ) {
                println "The default configuration file ${ dfltAppConfigFileName } does not exist."
                appConfigFile = null
            }
        }

        // Load the config file if it exists, otherwise exit
        if( appConfigFile ) {
            println "Loading configuration file ${ appConfigFile }"
            def config = new ConfigSlurper( environment.activeProfiles.first() ).parse( appConfigFile.toURI().toURL() )
            environment.propertySources.addFirst( new MapPropertySource( "${ appName }-config", config ) )
        } else {
            println "No configuration file found.  Exiting."
            System.exit( 1 )
        }

Answer 1

I found this thread and quotation by Graeme Rocher:

Grails 3 uses Spring's property sources concept, so it will resolve properties from the system, the environment and finally the application.yml/application.groovy

and code by Clyde Balneaves:

class Application extends GrailsAutoConfiguration implements EnvironmentAware {
    static void main(String[] args) {
    GrailsApp.run(Application)
    }

    @Override
    void setEnvironment(Environment environment) {
    //Set up Configuration directory
    def krakenHome = System.getenv('KRAKEN_HOME') ?: System.getProperty('KRAKEN_HOME') ?: "/opt/kraken"

    println ""
    println "Loading configuration from ${krakenHome}"
    def appConfigured = new File(krakenHome, 'KrakenConfig.groovy').exists()
    println "Loading configuration file ${new File(krakenHome, 'KrakenConfig.groovy')}"
    println "Config file found : " + appConfigured

    if (appConfigured) {
        def config = new ConfigSlurper().parse(new File(krakenHome, 'KrakenConfig.groovy').toURL())
        environment.propertySources.addFirst(new MapPropertySource("KrakenConfig", config))
    }
    }
}

Answer 2

May be you can also try this way (Overriding run method)

import grails.boot.GrailsApp
import grails.boot.config.GrailsAutoConfiguration
import grails.util.Environment
import grails.util.Holders
import org.springframework.boot.CommandLineRunner

class Application extends GrailsAutoConfiguration implements CommandLineRunner {

    static void main(String[] args) {
        GrailsApp.run(Application, args)
    }

    @Override
    void run(final String... args) throws Exception {
        println "Running in ${Environment.current.name}"

        // Get configuration from Holders.
        def config = Holders.getConfig()
        def locations = config.grails.config.locations
        locations.each {
            String configFileName = it.split("file:")[1]
            File configFile = new File(configFileName)
            if (configFile.exists()) {
                config.merge(new ConfigSlurper(Environment.current.name).parse(configFile.text))
            }
        }
    }
}