Develop Reference

AWS Beanstalk + Kotlin + Spring boot: NoSuchMethodException main()

I've a Spring Boot app written in Kotlin that I have deployed to AWS Beanstalk that is throwing the following exception:
Exception in thread "main" java.lang.NoSuchMethodException: com.prototype.demo.DemoApplication.main([Ljava.lang.String;)
at java.base/java.lang.Class.getDeclaredMethod(Class.java:2675)
at org.springframework.boot.loader.MainMethodRunner.run(MainMethodRunner.java:47)
Locally, when I run the app from IntelliJ I've no issues.
I have the spring-boot-maven-plugin and the kotlin-maven-plugin in my project.
Any ideas about what could be causing the issue? I previously built a similar app in Java but didn't run into this issue.
Thank you for your expertise and time.
Update: something interesting to notice is that I had to set in the properties of my POM the following line in order to make the project executable by IntelliJ during development (i had forgotten about it): <start-class>com.prototype.demo.DemoApplication</start-class>
Now I've removed it and I get a different error when running the jar file. I will spend some time on it and see if that's related or not and update the question accordingly.
Thank you!

The issue was raised by the following property declared in my POM file: <start-class>com.prototype.demo.DemoApplication</start-class>.
Once I removed it and added the open keyword to the Configuration annotated classes and to the DemoApplication(the class containing the main) it finally worked.

Solution for build.gradle.kts
I had the same problem when deploying my application to ECS.
First things first:
When you see such an error in AWS logs -> do as the author of the question has done and test the issue locally. Most probably if the application is failing on AWS, it will also fail on you local machine. To do so, you build a jar locally, the jar file is usually saved in build/libs/application-x.x.x-SNAPSHOT.jar and run java -jar application-x.x.x-SNAPSHOT.jar
Now you can fix your build task and test it locally before deploying it again.
Fix Gradle:
My main method was defined in MyApplication.kt file, but in the definition of the main class in gradle I had to set the following:
tasks.getByName<org.springframework.boot.gradle.tasks.bundling.BootJar>("bootJar") {
mainClass.set("com.company.app.MyApplicationKt")
}
Notice: MyApplicationKt
That is the only thing I had to change for me to fix this issue.

How can I run Cucumber Test runner from CLI without using Maven

I have seen the posts -
How to run cucumber file from command line
Cucumber java project without maven - how to run from command prompt if i am having Runner class
But the solutions given there are not very clear.
My CucumberRunner.java looks like -
#RunWith(Cucumber.class)
#CucumberOptions(
features = "src/test/resources/features",
tags="#Regression",
monochrome = false,
plugin = {"pretty",
"com.aventstack.extentreports.cucumber.adapter.ExtentCucumberAdapter:",
"timeline:test-output-thread/",
"json:target/cucumber-reports/jsonReports/Cucumber.json",
"html:target/cucumber-reports/Cucumber.html"}
)
public class CucumberRunner {
}
Unfortunately because of security reasons I can not install maven on Linux machine. So I want to run this CucumberRunner file from CLI.
As suggested in the previous posts I tried below in my Cucumber class
public class CucumberRunner {
public static void main(String[] args){
Main.main(new String[]{"-g", "src/test/java/stepdefinitions", "src/test/resources/features/Validate.feature"});
}
}
But it gives me exception
Exception in thread "main" java.lang.NoClassDefFoundError: io/cucumber/core/cli/Main
at CucumberRunner.main(CucumberRunner.java:29)
Caused by: java.lang.ClassNotFoundException: io.cucumber.core.cli.Main
at java.net.URLClassLoader.findClass(URLClassLoader.java:387)
at java.lang.ClassLoader.loadClass(ClassLoader.java:419)
at sun.misc.Launcher$AppClassLoader.loadClass(Launcher.java:352)
at java.lang.ClassLoader.loadClass(ClassLoader.java:352)
... 1 more
But This also doesn't give any solution to run on the basis of Cucumber tags.
Any solution or pointer is appreciated.
Kind Regards,
Abhi

In order to run a Java application, you need to be able to resolve ALL dependencies at runtime. This means that, every single library referenced on the POM under the dependencies tag, must be somewhere in the machine where Selenium (Cucumber) is running. Likewise, if those libraries have dependencies of their own, you must also download them somewhere in the machine.
You have a few choices to access the dependent libraries. You need to reference all dependencies as external JARs (reside outside your application JAR) or you need to package them inside your application JAR. You can use a build tool like ANT to build your JAR and map your dependencies similar to how is done in Maven. Obviously the difference is that you need to do what I described before (your build tool will need to know where these JARs are physically located).
To execute, you will obviously need a main method. Because this is using Selenium (Cucumber), your Runner class is ran by JUnit or TestNG (depending on what you are using). After that, the rest is up to you. For example, you could simply create a batch file to launch your application, or you could use a tool like Launch4J to create an executable. Of course, the latter required creating an executable JAR.

"Class not found" when runing feature with karate.jar

I have a feature that execute a function from a Java class. So for this reason I use this command to get the class and create a new instance:
When I run this feature with maven (mvn test -Dtest...) everything is okay. The problem is when I run this feature with karate standalone jar, karate can't find the RCNUtils class.
Error:
org.graalvm.polyglot.PolyglotException: TypeError: Access to host class utilities.RCNUtils is not allowed or does not exist.
GraalJS error: https://github.com/oracle/graaljs/blob/master/docs/user/FAQ.md#typeerror-access-to-host-class-commyexamplemyclass-is-not-allowed-or-does-not-exist
I think it's a classpath problem but I have tried with a lot of differents paths and commands to execute the jar, and nothing works.
I don't know if this is a known issue or if there is a karate example using utilities classes and executed with karate.jar
I tested this problem with differents Karate versions. Actually I'm using Karate 1.1.0
Some of the options I have tried with no results:
Use -w / --workdir param to change working directory with no results
Use java -cp instead of java -jar to set classpath following:
Unable to use read('classpath:') when running tests with standalone karate.jar
Use -Dkarate.config.dir param
Note: I don't think it's a security problem because if I try to get "RCNUtils.java" file with "karate.read()" or "read()" in the same feature, it works. I think because I can put the path to the file. The problem is that I can't put the path to java class in "Java.type()" method
Same error here: Executing Karate jar with mock using external library Spring Framework
Thanks in advance.

MemoryMeter : Instrumentation is not set; Jamm must be set as -javaagent

After cloning jamm and setting the maven URL in the build.xml to https://repo1.maven.org/maven2/org/apache/ivy/ivy, I was able to install it with ant jar. Now I'm trying to use MemoryMeter in my project code.
The official GitHub README says: 'To use MemoryMeter, start the JVM with "-javaagent:/jamm.jar"'.
Following this advice and using a javaagent for the first time in my life (in a Grails 2.5.6 project) I've set the following in my IDEA IntelliJ run configuration:
in VM options: -javaagent:"/home/myusername/git/laser-ygor/lib/jamm-0.3.4-SNAPSHOT.jar"
in Command line: -noreloading -javaagent:"/home/myusername/git/laser-ygor/lib/jamm-0.3.4-SNAPSHOT.jar" run-app
I think one of those two javaagent settings should be obsolete, but I don't know which of them works, and I believe it won't do any harm to set them both.
Anyway, I'm experiencing: Instrumentation is not set; Jamm must be set as -javaagent.
which obviously is caused by instrumentation being null.
So, how can I use this javaagent with instrumentation being not null?

What's the proper way to have various URL endpoints for dev and release in a Java application?

I'm building a Java desktop application, using JavaFX, Gradle, javafx-gradle-plugin. This application connects to a server that I also build. When I compile a release version, running gradle jfxNative, I want it to talk to the production server; but otherwise, I want it to talk to localhost.
What's the proper Java/Gradle way of handling this? Some sort of compilation profile?

You can use Gradle's source sets for this:
Sample build.gradle:
apply plugin: 'java'
sourceSets {
prod {
java {
srcDirs = ['src/main/java', 'src/prod/java']
}
}
dev {
java {
srcDirs = ['src/main/java', 'src/dev/java']
}
}
}
task devJar(type: Jar) {
from sourceSets.dev.output
manifest {
attributes("Main-Class": "MyPackage.MyClass")
}
}
task prodJar(type: Jar) {
from sourceSets.prod.output
manifest {
attributes("Main-Class": "MyPackage.MyClass")
}
}
Now you can create two configuration classes for your dev and prod versions:
src/dev/java/MyPackage/Configuration.java
src/prod/java/MyPackage/Configuration.java
All the common code will be in the main source set:
src/main/java/MyPackage/MyClass.java
MyClass can get some values from the configuration class (e.g. Configuration.getBaseUrl())
Running gradle devJar/ gradle prodJar builds one of the variants.
Note: you may need to extend jfxNative/jfxJar instead of Jar in your case.

The simplest solution: Have a configuration file containing such information.
You either compile it into the application as a java resource or place it next to the jar file so it can be easily looked up via the filesystem.
With gradle all you need to do is define two build tasks with different input properties and insert the values into your properties file with groovy templating.
application.properties in src/main/resources:
server.address=${serverAddress}
add to your build.gradle
task setProductionServerAddress {
processResources.expand([serverAddress: "https://app.example.com/v1"])
}
jfxJar.dependsOn(setProductionServerAddress)
jfxNative.dependsOn(setProductionServerAddress)
And then on the application:
Properties properties = new Properties();
properties.load(getClass().getResourceAsStream("/application.properties"));
if (properties.getProperty("server.address").equals("${serverAddress}")) {
setUrl("http://localhost:8080/v1");
} else {
setUrl(properties.getProperty("server.address"));
}

Have it check environment variables for names of configuration files. Nothing to do with gradle or build. The same program should run properly wherever it is deployed.
See, e.g., Properties for dev and production
The easiest approach is to define a system property which specifies where the file system location for your data is. The production appserver would define one value (using java -D in the startup script), and your dev app server would define another value. Your application source would consult the system property value (using System.getProperty()) to discover the appropriate location
Also, this makes sense.
Put the information you need in JNDI - that's what it is designed for.
Consider letting your application refuse to do anything if the information is not there.
Another reference: What is the best way to manage configuration data
EDIT: Well, what you're asking is logically not possible then, it seems to me. "It should connect to production, unless a specific someone wants to connect to development, but that feature should only be available to unknown persons" The start menu is only a shortcut for running the application, so you can install a "dev" shortcut with command line settings that are read as environment vars.

I would go with the one of the "12 factor app" concept which can be read here
One of its main concept is to use system environment variable which should determine whether you are working on a prod or dev or qa env etc.
each project/environment/machine should contain its relevant env property, which after then can be retrieved through the gradle process similar to maven profile plugin.
An example for how to detect:
`if (project.hasProperty('env') && project.getProperty('env') == 'prod') {
apply from: 'gradle/production.gradle'
} else {
apply from: 'gradle/development.gradle'
}`
more on this approach using gradle can be found: gradle profile

In my opinion and like others have suggested, this has little to do with the build and more to do with Run Time.
Therefore you could resort to checking for some kind of run time flag - a convenient and often used approach is to use System Properties.
On your Dev box, you could set an Environment variable - lets say FX _DESKTOP_APP_ENV = DEV or some such.
From your code you can look this up and decide the URL you want to use.
String env = System.getenv("FX _DESKTOP_APP_ENV");
String url = env == null ? "Production" : env;
On windows systems you can set up your system environment variables like so -- enter link description here
On *nix systems enter link description here
Hope this helps

You need to pick a configuration scheme (if JavaFX doesn't pick one for you).
I like https://github.com/typesafehub/config .
The config library will have instructions on how to make your "production" config differ from your "development" config.
See also JavaFX:Editable Configuration Files After Packaging
What's the proper Java/Gradle way of handling this? Some sort of compilation profile?
No, I would strongly recommend against compiling different code for production v.s. test. It will invalidate your testing. This should be handled in configuration, not in code. The conventional Java way of doing this is with configuration files (which can be compiled into the JAR as resources).
How to do this with Typesafe Config
I've had a bit of a look, and I am surprised not to find a good quality tutorial I can link you to here, sorry (I found a few rubbish ones). Perhaps this question will become a reference for others.
I would do something like this:
Create a "dev" and "prod" config files, along the lines of https://stackoverflow.com/a/33261928/8261
Arrange for your app to use the "dev" config file when running in your IDE and "prod" config file when running from a compiled JAR, as per Can you tell on runtime if you're running java from within a jar?
My guess as to why there aren't many tutorials for this is that all application or web Frameworks handle this for you.