// If not orchestrated
		// and not setup in reverse proxy
		if !orchestrated && !reverseProxy {
			// Check whether same path is not used in endpoints of a host on different port.
			// Only verify this on baremetal setups, DNS is not available in orchestrated
			// environments so we can't do much here.
			pathIPMap := make(map[string]set.StringSet)

	"golang.org/x/term"
)

// serverDebugLog will enable debug printing
var (
	serverDebugLog     = env.Get("_MINIO_SERVER_DEBUG", config.EnableOff) == config.EnableOn
	currentReleaseTime time.Time
	orchestrated       = IsKubernetes() || IsDocker()
)

func init() {
	if !term.IsTerminal(int(os.Stdout.Fd())) || !term.IsTerminal(int(os.Stderr.Fd())) {
		color.TurnOff()
	}

		Hidden: true,
		EnvVar: "MINIO_INTERFACE",
	},
	cli.DurationFlag{
		Name:   "dns-cache-ttl",
		Usage:  "custom DNS cache TTL",
		Hidden: true,
		Value: func() time.Duration {
			if orchestrated {
				return 30 * time.Second
			}
			return 10 * time.Minute
		}(),
		EnvVar: "MINIO_DNS_CACHE_TTL",
	},
	cli.IntFlag{
		Name:   "max-idle-conns-per-host",

@DisplayName("StrategyOrchestrator")
class StrategyOrchestratorTest {

    private StrategyOrchestrator orchestrator;
    private List<UpgradeStrategy> mockStrategies;

    @BeforeEach
    void setUp() {
        mockStrategies = List.of(mock(UpgradeStrategy.class), mock(UpgradeStrategy.class), mock(UpgradeStrategy.class));
        orchestrator = new StrategyOrchestrator(mockStrategies);
    }

    private UpgradeContext createMockContext() {

                new PluginUpgradeStrategy(),
                new InferenceStrategy());

        StrategyOrchestrator orchestrator = new StrategyOrchestrator(strategies);
        applyGoal = new Apply(orchestrator);
        checkGoal = new Check(orchestrator);
    }

    @Nested
    @DisplayName("Model Version Upgrade")
    class ModelVersionUpgradeTests {

        @Test

/**
 * The "apply" goal implementation.
 */
@Named("apply")
@Singleton
public class Apply extends AbstractUpgradeGoal {

    @Inject
    public Apply(StrategyOrchestrator orchestrator) {
        super(orchestrator);
    }

    @Override
    protected boolean shouldSaveModifications() {
        return true;
    }

    @Override
    public int execute(UpgradeContext context) throws Exception {

/**
 * The "check" goal implementation.
 */
@Named("check")
@Singleton
public class Check extends AbstractUpgradeGoal {

    @Inject
    public Check(StrategyOrchestrator orchestrator) {
        super(orchestrator);
    }

    @Override
    protected boolean shouldSaveModifications() {
        return false;
    }

    @Override
    public int execute(UpgradeContext context) throws Exception {

 * </ul>
 */
public abstract class AbstractUpgradeGoal implements Goal {

    private final StrategyOrchestrator orchestrator;

    @Inject
    public AbstractUpgradeGoal(StrategyOrchestrator orchestrator) {
        this.orchestrator = orchestrator;
    }

    /**
     * Executes the upgrade goal.
     * Template method that calls doUpgrade and optionally saves modifications.
     */

import org.apache.maven.api.di.Inject;
import org.apache.maven.api.di.Named;
import org.apache.maven.api.di.Singleton;
import org.apache.maven.cling.invoker.mvnup.UpgradeContext;

/**
 * domtrip-based orchestrator for executing different upgrade strategies.
 *
 * <p>This class provides the same functionality as StrategyOrchestrator but works
 * with domtrip-based strategies for superior formatting preservation.
 *

     */
    private static class TestableAbstractUpgradeGoal extends AbstractUpgradeGoal {

        TestableAbstractUpgradeGoal(StrategyOrchestrator orchestrator) {
            super(orchestrator);
        }

        @Override
        protected boolean shouldSaveModifications() {
            return true; // Enable actual file operations for tests
        }