Should the Micronaut build plugins set a dev environment during gradle run / mn:run

[sdelamo]

The only problem with this is that the MICRONAUT_ENVIRONMENTS variable is not additive, so if the user has something defined via ApplicationContextBuilder, it will be overriden

[sdelamo]

I like the idea but I think we are late for this change in Micronaut Framework 4. I think we should consider how this change impacts default environment.

I think what we could do is generate every new app in starter with :

public class Application {
    @ContextConfigurer
    public static class Configurer implements ApplicationContextConfigurer {
        @Override
        public void configure(@NonNull ApplicationContextBuilder builder) {
            builder.defaultEnvironments("dev");
        }
    }
    public static void main(String[] args) {
        Micronaut.run(Application.class, args);
    }
}

[sdelamo]

@micronaut-projects/core-developers thoughts?

[timyates]

Adding the ApplicationContextConfigurer would always run in the dev environment though wouldn't it, unless something was done when the code was pushed to production?

One confusion I sometimes see is we have developmentOnly dependencies (at least for Gradle builds) which are added (eg for microstream-rest) which are unrelated to running with the Application environment containing "dev", and exist only when we do ./gradlew run

[sdelamo]

True, Micronaut Gradle plugin has a "development" mode already. When you do gradle run, it uses the developmentOnly Gradle configuration.

[graemerocher]

this should be implemented in the plugins if it is to be implemented. ./gradlew run and mvn mn:run should activate these. However probably too late for 4.0.x

[melix]

Having something like builder.defaultEnvironments("dev") sounds quite dangerous to me. Say something goes to production and no environment is set, then the dev environment would be used.

Maybe we should have a different environment variable, say MICRONAUT_DEV_ENVIRONMENTS which would be additive once the actual set of environments has been computed by Micronaut (using plural for consistency with ENVIRONMENTS).

One of the issues with having the build plugins do magic is that this won't work unless delegating to the IDE, which is the default for Gradle + Intellij IDEA CE, but not for Maven nor IDEA Ultimate.

[sdelamo]

yes, we have to bear in mind that not everyone may want to use our build plugins.

[graemerocher]

right, IMO we should probably do something that detects some dev environment only file like micronaut-cli.yml or something, but doing this is not easy because the root directly changes depending whether you run from Gradle, Maven or the IDE

[sdelamo]

Say something goes to production and no environment is set, then the dev environment would be used.

Exactly. Until now it was not as easy to happen because cloud environment detection was turned on and in most cases a cloud env would be detected and thus the default env was not being used.

[melix]

So, our build plugins are already capable of injecting dev dependencies (e.g developmentOnly). So we could provide a new module which exposes an ApplicationContextConfigurer which does this:

    @ContextConfigurer
    public class DevelopmentEnvironmentConfigurer implements ApplicationContextConfigurer {
        @Override
        public void configure(@NonNull ApplicationContextBuilder builder) {
            builder.defaultEnvironments("dev");
        }
    }

In Maven you'd have this in provided scope.

[melix]

This would work for Maven as far as I can tell. For Gradle if you delegate to Gradle for builds.

[graemerocher]

which IntelliJ ultimate doesn't do :(

[melix]

It doesn't but in any case there are many things broken if you don't delegate to Gradle. File watching will not work for example. Test resources are already broken if you don't delegate either. The developmentOnly configuration is a Micronaut only thing, so Jetbrains should implement the required things if they don't want to delegate to Gradle, for whatever reason.

[sdelamo]

@melix

Are you suggesting:

A) we create a module such as: io.micronaut:micronaut-development
B) Inside that module, we add a class with contents:

    @ContextConfigurer
    public class DevelopmentEnvironmentConfigurer implements ApplicationContextConfigurer {
        @Override
        public void configure(@NonNull ApplicationContextBuilder builder) {
            builder.defaultEnvironments("dev");
        }
    }
}

C) We add the dependency transparently with developmentOnly("io.mcronaut:mcironatu-development") through the Gradle Plugin.

The result of that would be to run with dev environment when running gradle run. Moreover, the default environment dev will not leak to production since a developmentOnly dependency will not be leaked into the production classpath.

I like the idea.

However, What will happen if a user set a default environment directly in their app?

[melix]

Yes, that's what I'm suggesting.

However, What will happen if a user set a default environment directly in their app?

as far as I can tell, the default environment would be applied, builder.defaultEnvironments is additive.