External properties file in grails 3

Question

I need read configuration from a external file properties in grails 3. In grails 2.x I link the file with:

grails.config.locations = [\"classpath:config.propert         


        

Answer 1

Because Grails 3 is built on Spring Boot, you can use the Spring Boot mechanisms for externalized properties. Namely, using the spring.config.location command line parameter, or the SPRING_BOOT_LOCATION environment variable. Here's the Spring documentation page on it.

The example the documentation provides for the command line parameter is this:

$ java -jar myproject.jar --spring.config.location=classpath:/default.properties,classpath:/override.properties

The way I have been using it is by setting an environment variable, like this:

export SPRING_CONFIG_LOCATION="/home/user/application-name/application.yml"

One of the nice features is that you can leave some properties in the properties file that is bundled in the app, but if there are some properties you do not want to include (such as passwords), those can be set specifically in the external config file.

Answer 2

Seems like there is no externalised config out of the box: http://grails.1312388.n4.nabble.com/Grails-3-External-config-td4658823.html

Answer 3

I am having the same problem to read the properties file from external location in Grails 3. I found this plugin which helpme to read the properties from external location. It has feature to read .yml, .groovy files as well.

Follow the steps mentioned in the documentation and it will work. The steps are like:

1. Add dependency in build.gradle:

   dependencies {compile 'org.grails.plugins:external-config:1.2.2'}
   

2. Add this in application.yml grails:

   config:
       locations:
           - file:///opt/abc/application.yml
   

3. Create file at external location. In my case /opt/abc/application.yml.

4. Build the application and run.

Answer 4

You can use

def cfg = new ConfigSlurper.parse(getClass().classLoader.getResource('path/myExternalConfigfile.groovy'))

Answer 5

When running from a .jar file, I found that Spring Boot looks at the current directory for an application.yml file.

java -jar app-0.3.jar

In the current directory, I created an application.yml file with one line:

org.xyz.app.title: 'XYZZY'

I also used this file to specify the database and other such info.

Answer 6

Take a look at https://gist.github.com/reduardo7/d14ea1cd09108425e0f5ecc8d3d7fca0

External configuration in Grails 3

Working on Grails 3 I realized that I no longer can specify external configuration using the standard grails.config.locations property in Config.groovy file.

Reason is obvious! There is no Config.groovy now in Grails 3. Instead we now use application.yml to configure the properties. However, you can't specify the external configuration using this file too!

What the hack?

Now Grails 3 uses Spring's property source concept. To enable external config file to work we need to do something extra now.

Suppose I want to override some properties in application.yml file with my external configuration file.

E.g., from this:

  dataSource:
    username: sa
    password:
    driverClassName: "org.h2.Driver"

To this:

dataSource:
  username: root
  password: mysql
  driverClassName: "com.mysql.jdbc.Driver"

First I need to place this file in application's root. E.g., I've following structure of my Grails 3 application with external configuration file app-config.yml in place:

[human@machine tmp]$ tree -L 1 myapp
myapp
├── app-config.yml // <---- external configuration file!
├── build.gradle
├── gradle
├── gradle.properties
├── gradlew
├── gradlew.bat
├── grails-app
└── src

Now, to enable reading this file just add following:

To your build.gradle file

bootRun {
  // local.config.location is just a random name. You can use yours.
  jvmArgs = ['-Dlocal.config.location=app-config.yml']
}

To your Application.groovy file

package com.mycompany

import grails.boot.GrailsApp
import grails.boot.config.GrailsAutoConfiguration
import org.springframework.beans.factory.config.YamlPropertiesFactoryBean
import org.springframework.context.EnvironmentAware
import org.springframework.core.env.Environment
import org.springframework.core.env.PropertiesPropertySource
import org.springframework.core.io.FileSystemResource
import org.springframework.core.io.Resource
class Application extends GrailsAutoConfiguration implements EnvironmentAware {
    public final static String LOCAL_CONFIG_LOCATION = "local.config.location"

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

    @Override
    void setEnvironment(Environment environment) {
        String configPath = System.properties[LOCAL_CONFIG_LOCATION]

        if (!configPath) {
           throw new RuntimeException("Local configuration location variable is required: " + LOCAL_CONFIG_LOCATION)
        }

        File configFile = new File(configPath)
        if (!configFile.exists()) {
           throw new RuntimeException("Configuration file is required: " + configPath)
        }

        Resource resourceConfig = new FileSystemResource(configPath)
        YamlPropertiesFactoryBean ypfb = new YamlPropertiesFactoryBean()
        ypfb.setResources([resourceConfig] as Resource[])
        ypfb.afterPropertiesSet()
        Properties properties = ypfb.getObject()
        environment.propertySources.addFirst(new PropertiesPropertySource(LOCAL_CONFIG_LOCATION, properties))
    }
}

Notice that Application class implements EnvironmentAware Interface and overrides its setEnvironment(Environment environment):void method.

Now this is all what you need to re-enable external config file in Grails 3 application.

Code and guidance is taken from following links with little modification:

1. http://grails.1312388.n4.nabble.com/Grails-3-External-config-td4658823.html
2. https://groups.google.com/forum/#!topic/grails-dev-discuss/_5VtFz4SpDY

Source: https://gist.github.com/ManvendraSK/8b166b47514ca817d36e