Configurazione in base alla modalità di avvio

Question

La riproduzione può essere avviata in modalità dev (tramite run), in modalità produzione (tramite start) o in modalità test. C'è un modo per fornire un file di configurazione diverso (conf/application.conf) a seconda della modalità in cui viene avviato?

Answer 1

Di solito ho una configurazione di base (application.conf) e tre configurazioni aggiuntive per ambiente. In Play Framework 2.4 può essere fatto estendendo GuiceApplicationLoader e conf fusione di base con il proprio ambiente specifico conf. Puoi fare un passo in avanti e fornire diversi moduli guizzano per ambiente.

versione Scala:

class CustomApplicationLoader extends GuiceApplicationLoader { 

    override protected def builder(context: Context): GuiceApplicationBuilder = { 
     val builder = initialBuilder.in(context.environment).overrides(overrides(context): _*) 
     context.environment.mode match { 
      case Prod => 
       // start mode 
       val prodConf = Configuration(ConfigFactory.load("prod.conf")) 
       builder.loadConfig(prodConf ++ context.initialConfiguration).bindings(new ProdModule()); 
      case Dev => 
       // run mode 
       val devConf = Configuration(ConfigFactory.load("dev.conf")) 
       builder.loadConfig(devConf ++ context.initialConfiguration).bindings(new DevModule()); 
      case Test => 
       // test mode 
       val testConf = Configuration(ConfigFactory.load("test.conf")) 
       builder.loadConfig(testConf ++ context.initialConfiguration).bindings(new TestModule()); 
     } 
    } 
} 

versione Java:

public class CustomApplicationLoader extends GuiceApplicationLoader { 

    @Override 
    public GuiceApplicationBuilder builder(ApplicationLoader.Context context) { 
     final Environment environment = context.environment(); 
     GuiceApplicationBuilder builder = initialBuilder.in(environment); 
     Configuration config = context.initialConfiguration(); 
     if (environment.isTest()) { 
      config = merge("test.conf", config); 
      builder = builder.bindings(new TestModule()); 
     } else if (environment.isDev()) { 
      config = merge("dev.conf", config); 
      builder = builder.bindings(new DevModule()); 
     } else if (environment.isProd()) { 
      config = merge("prod.conf", config); 
      builder = builder.bindings(new DevModule()); 
     } else { 
      throw new IllegalStateException("No such mode."); 
     } 
     return builder.in(environment).loadConfig(config); 
    } 

    private Configuration merge(String configName, Configuration currentConfig) { 
     return new Configuration(currentConfig.getWrappedConfiguration().$plus$plus(new play.api.Configuration(ConfigFactory.load(configName)))); 
    } 
} 

Non dimenticare di includere play.application.loader = "modules.CustomApplicationLoader" al vostro application.conf.

Nelle versioni inferiori di Play è possibile ottenere qualcosa di simile utilizzando la classe GlobalSettings e sovrascrivendo onLoadConfig. Mind GlobalSettings in Play 2.4 è deprivato.

Se non ti piace tra cui test.conf e test mocks dal TestModule al vostro costruire produzione, è possibile filter i file con sbt.

Answer 2

È possibile impostare un file di configurazione diversa utilizzando uno dei 3 modi giocare dà a voi:

1 - Utilizzando -Dconfig.resource

Si cercherà un file di configurazione alternativa nel classpath dell'applicazione (di solito fornite questi file di configurazione alternativi nella cartella conf/directory prima della confezione ). Play guarderà a conf/quindi non dovrai aggiungere conf /.

$/path/to/bin/-Dconfig.resource = prod.conf

2 - Utilizzare -Dconfig.file

È inoltre possibile specificare un altro file di configurazione locale non confezionato nei manufatti di applicazione :

$/path/to/bin/-Dconfig.file =/opt/conf/prod.conf

3 - Utilizzo -Dconfig.url

È inoltre possibile specificare un file di configurazione da caricare da qualsiasi URL:

$/path/to/bin/ -Dconfig.url = http://conf.mycompany.com/conf/prod.conf

Checkout più:

https://www.playframework.com/documentation/2.3.x/ProductionConfiguration

Answer 3

Questa operazione può essere eseguita caricando i file di configurazione in base all'ambiente che può essere fornito tramite -Dmode=staging/dev/prod e per il caricamento dei file sovrascrivo onLoadConfig di GlobalSettings in Global.java.

Java snippet-

@Override 
public Configuration onLoadConfig(Configuration config, File file,ClassLoader classLoader) { 
Configuration updatedConfig = config; 
String mode = config.getString("mode"); 
if (StringUtils.isNotEmpty(mode)) { 
    try { 
    File modeFolder = FileUtils.getFile(file, "conf/" + mode); 
    if (modeFolder.exists()) { 
     play.api.Configuration modeConfig = config.getWrappedConfiguration(); 
     IOFileFilter fileFilter = new WildcardFileFilter("*.conf"); 
     Collection<File> fileList = FileUtils.listFiles(modeFolder, fileFilter, null); 
     for (File confFile : fileList) { 
     modeConfig = modeConfig 
      .$plus$plus(new play.api.Configuration(ConfigFactory.parseFile(confFile))); 

     } 
     updatedConfig = new Configuration(modeConfig); 
    } 
    } catch (Exception e) { 
    Logger.error("Exception while loading configuration for mode : " + mode, e); 
    } 
} else { 
    Logger.error("Please provide mode in which play application has to start (Ex. play -Dmode=<mode>) "); 
} 

Per ogni modo, creare una cartella (nome stesso di ambiente) e mantenere l'ambiente di configurazione specifica in quella cartella.