Executing a shell command non-interactively is no longer possible if interactive mode is enabled in version 4.0.0

[mhdstg]

I have created a shell application with Spring Boot. In the application.yaml I have enabled interactive mode and script execution:

spring:
  application:
    name: AMELIOShell
  shell:
    history:
      name: "amelioshell.log"
    interactive:
      enabled: true
    script:
      enabled: true

With version Spring Shell 3.4 I could execute the shell non interactively by simply passing a command, e.g.:

java -jar .\amelioshell-5.3.0-SNAPSHOT.jar get-jobstate

The output of the command is displayed, and then the shell exits.

When I run the same command with a jar that was built with version 4.0 the shell starts interactively, and it stops at the prompt. If I add the parameter --spring.shell.interactive.enabled=false then the shell is executed non-interactively.

This is a valid bypass for me, but the previous behaviour was much better.

Is ist possible to find out at runtime whether a command was executed interactively or non interactively?

[czpilar]

Before it is resolved it could be solved by following example:

package org.springframework.shell.samples.helloworld.boot;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.shell.core.command.annotation.Command;
import org.springframework.shell.core.command.annotation.Option;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

@SpringBootApplication
public class SpringShellApplication {

	public static void main(String[] args) {
		List<String> list = new ArrayList<>(Arrays.asList(args));
		if (!list.isEmpty()) {
			boolean alreadySet = list.stream().anyMatch(s -> s.startsWith("--spring.shell.interactive.enabled"));
			if (!alreadySet) {
				list.add("--spring.shell.interactive.enabled=false");
			}
		}
		SpringApplication.run(SpringShellApplication.class, list.toArray(new String[0]));
	}

	@Command(name = "hello", description = "Say hello to a given name", group = "Greetings",
			help = "A command that greets the user with 'Hello ${name}!'. Usage: hello [-n | --name]=<name>")
	public void sayHello(@Option(shortName = 'n', longName = "name", description = "the name of the person to greet",
			defaultValue = "World") String name) {
		System.out.println("Hello " + name + "!");
	}

}

[czpilar]

Fixed in PR #1321

In this screenshot is help command present in the commad line:

In following screenshot there is no command:

[fmbenhassine]

I have enabled interactive mode and script execution
With version Spring Shell 3.4 I could execute the shell non interactively by simply passing a command

@mhdstg So with Spring Shell 3, even if I explicitly enable the interactive mode with a property, I can still run the app in a non-interactive mode, how confusing is that? What's the purpose of that property if the user can bypass it by specifying a command? I believe the behaviour of the shell should be configured either based on properties, or the presence/absence of a command, but not both (otherwise, it's confusing, error prone, and requires to define precedence and document that, etc).

Moreover, that also made the implementation on the framework side overly complex for no added value: all shell runners are enabled at once, the requirement to distinguish which commands are interactive or not (at the command definition level using an enumeration, etc).

In v4, this confusion has been addressed and things were simplified by making interactive / non-interactive modes exclusive, see Shell interactivity changes. You can still use the same app interactively or non-interactively, but you have to specify the mode explicitly at configuration time and adhere to that when invoking the app at runtime. Spring Shell will enforce that anyway with a log message:

Running in interactive mode, arguments will be ignored

#or

In non interactive mode, it expected to have at least one argument: the command to execute or the script file

Aa you mentioned, you can either add the property --spring.shell.interactive.enabled=false, or prefix your command with:

SPRING_SHELL_INTERACTIVE_ENABLED=FALSE java -jar ...

I know it's more typing, but it's less confusing and more explicit. If this becomes an issue, one could set the property once in the app's configuration file (like in the non-interactive sample) or set it as an environment variable.

@czpilar Thank you for the follow up and PR! While the idea to post-process the environment technically works, I am not keen to make the framework change that property at runtime based on the presence/absence of arguments. In fact, I can ship a shell app in a jar file that is designed to run interactively (ie expects input from the user), but one could pass an incomplete command and run the app in a way it was not designed for.

Thoughts?

[czpilar]

@fmbenhassine sure, not a problem - you can close the PR without merging. We are basically bypassing interactive mode to non-interactive the way I've commented in #1278 (comment), so everybody can do it this way as well.

[mhdstg]

@fmbenhassine I understand you arguments and it is fine for me if you close this issue and the PR without merging.