feat(install): auto-discover target disk and run CopyFiles before GRUB

Revisit the command-line installer so a headless install needs no
interactive device entry:

- Resolve the target device from a CLI arg, an auto-discovered single JFAT
  mount, or an interactive prompt fallback, and feed it to the actions via
  the new ActionConstants.DEVICE_ID context value.
- GrubInstallerAction reads DEVICE_ID from the context (prompting only when
  absent) instead of always asking, so the install runs non-interactively
  once the device is known.
- Run CopyFilesAction before GrubInstallerAction so stage1.5 does not
  corrupt the freshly written FAT; resolve the mount point by filesystem
  identity (same as JGrub.getMountPoint) rather than by path substring.

Enabled by caching the InputContext/OutputContext so values pre-set in
start() survive the inherited super.start() run.

Author: LSantha

distr/src/install/org/jnode/install/action/ActionConstants.java

@@ -25,4 +25,5 @@
  */
 public interface ActionConstants {
     String INSTALL_ROOT_DIR = "INSTALL_ROOT_DIR";
+    String DEVICE_ID = "DEVICE_ID";
 }

distr/src/install/org/jnode/install/action/GrubInstallerAction.java

@@ -45,8 +45,17 @@ public ActionInput getInput(final InputContext inContext) {
         return new ActionInput() {
             public AbstractInstaller.Step collect() {
                 try {
-                    String deviceID =
-                        inContext.getStringInput("Enter the installation disk device name (example: hda0) : ");
+                    String deviceID = inContext.getStringValue(ActionConstants.DEVICE_ID);
+                    if (deviceID == null || deviceID.trim().length() == 0) {
+                        deviceID =
+                            inContext.getStringInput("Enter the installation disk device name (example: hda0) : ");
+                        if (deviceID == null || deviceID.trim().length() == 0) {
+                            return AbstractInstaller.Step.back;
+                        }
+                        deviceID = deviceID.trim();
+                        inContext.setStringValue(ActionConstants.DEVICE_ID, deviceID);
+                    }
+                    deviceID = deviceID.trim();
 
                     Device disk = DeviceUtils.getDevice(deviceID);
                     JGrub jgrub = new JGrub(new PrintWriter(new OutputStreamWriter(System.out)), disk);

distr/src/install/org/jnode/install/cmdline/CommandLineInstaller.java

@@ -21,51 +21,184 @@
 package org.jnode.install.cmdline;
 
 import java.io.BufferedReader;
+import java.io.File;
 import java.io.IOException;
 import java.io.InputStreamReader;
+import java.util.Map;
+
+import org.jnode.driver.Device;
+import org.jnode.driver.DeviceUtils;
+import org.jnode.fs.FileSystem;
+import org.jnode.fs.FileSystemType;
+import org.jnode.fs.service.FileSystemService;
 import org.jnode.install.AbstractInstaller;
 import org.jnode.install.InputContext;
 import org.jnode.install.OutputContext;
+import org.jnode.install.action.ActionConstants;
 import org.jnode.install.action.CopyFilesAction;
 import org.jnode.install.action.GrubInstallerAction;
+import org.jnode.naming.InitialNaming;
 
 /**
  * @author Levente S\u00e1ntha
  */
 public class CommandLineInstaller extends AbstractInstaller {
 
+    private final String deviceId;
+    private InputContext inputContext;
+    private OutputContext outputContext;
+
     public CommandLineInstaller() {
-        //grub
-        actionList.add(new GrubInstallerAction());
-        //files
+        this(null);
+    }
+
+    public CommandLineInstaller(String deviceId) {
+        this.deviceId = (deviceId == null || deviceId.trim().length() == 0) ? null : deviceId.trim();
+        //files first (before GRUB corrupts the FAT)
         actionList.add(new CopyFilesAction());
+        //grub last
+        actionList.add(new GrubInstallerAction());
     }
 
     public static void main(String... argv) {
-        new CommandLineInstaller().start();
+        String deviceId = (argv.length > 0) ? argv[0] : null;
+        new CommandLineInstaller(deviceId).start();
     }
 
+    public void start() {
+        InputContext in = getInputContext();
+        OutputContext out = getOutputContext();
 
-    protected InputContext getInputContext() {
-        return new InputContext() {
-            private BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
-
-            public String getStringInput(String message) {
-                try {
-                    System.out.println(message);
-                    return in.readLine();
-                } catch (IOException e) {
-                    throw new RuntimeException(e);
+        // Resolve target device: CLI arg, auto-discovered JFAT, then prompt.
+        String deviceID = this.deviceId;
+        if (deviceID == null) {
+            deviceID = in.getStringValue(ActionConstants.DEVICE_ID);
+        }
+        if (deviceID == null) {
+            deviceID = discoverDevice();
+        }
+        if (deviceID == null) {
+            deviceID = in.getStringInput(
+                "Enter the installation disk device name (example: hda0) : ");
+        }
+        if (deviceID == null || deviceID.trim().length() == 0) {
+            out.showMessage("Error: no device specified");
+            return;
+        }
+        deviceID = deviceID.trim();
+
+        // Validate device and resolve its mount point (same identity
+        // comparison as JGrub.getMountPoint, not a substring match).
+        try {
+            Device device = DeviceUtils.getDevice(deviceID);
+            String mountPoint = getMountPoint(device);
+            if (mountPoint == null) {
+                out.showMessage("Error: no mount point found for " + deviceID);
+                return;
+            }
+            if (!mountPoint.endsWith(File.separator)) {
+                mountPoint += File.separatorChar;
+            }
+            in.setStringValue(ActionConstants.DEVICE_ID, deviceID);
+            in.setStringValue(ActionConstants.INSTALL_ROOT_DIR, mountPoint);
+            out.showMessage("Installing to " + deviceID + " at " + mountPoint);
+        } catch (Exception e) {
+            out.showMessage("Error: " + e.getMessage());
+            return;
+        }
+
+        super.start();
+    }
+
+    /**
+     * Find the mount point for the given device by filesystem identity.
+     * Returns null when the device has no mounted filesystem.
+     */
+    private String getMountPoint(Device device) {
+        try {
+            FileSystemService fss = InitialNaming.lookup(FileSystemService.NAME);
+            FileSystem<?> target = fss.getFileSystem(device);
+            if (target == null) {
+                return null;
+            }
+            Map<String, FileSystem<?>> mountPoints = fss.getMountPoints();
+            for (Map.Entry<String, FileSystem<?>> entry : mountPoints.entrySet()) {
+                if (entry.getValue() == target) {
+                    return entry.getKey();
                 }
             }
-        };
+            return null;
+        } catch (Exception e) {
+            return null;
+        }
     }
 
-    protected OutputContext getOutputContext() {
-        return new OutputContext() {
-            public void showMessage(String msg) {
-                System.out.println(msg);
+    /**
+     * Auto-discover a JFAT partition suitable for installation.
+     * Returns the device name (e.g. "hda1") if exactly one is found, null otherwise.
+     */
+    private String discoverDevice() {
+        try {
+            FileSystemService fss = InitialNaming.lookup(FileSystemService.NAME);
+            Map<String, FileSystem<?>> mountPoints = fss.getMountPoints();
+            String candidate = null;
+            for (Map.Entry<String, FileSystem<?>> entry : mountPoints.entrySet()) {
+                String path = entry.getKey();
+                FileSystem<?> fs = entry.getValue();
+                if (path == null || fs == null || !path.startsWith("/devices/")) {
+                    continue;
+                }
+                // First segment under /devices/, e.g. "/devices/hda1" -> "hda1".
+                String rest = path.substring("/devices/".length());
+                int slash = rest.indexOf('/');
+                String devName = (slash < 0) ? rest : rest.substring(0, slash);
+                if (devName.length() == 0 || devName.startsWith("sg")) {
+                    // Skip CDROM drives (sg0, ...) and empty segments.
+                    continue;
+                }
+                FileSystemType<?> type = fs.getType();
+                if (type == null || !"JFAT".equalsIgnoreCase(type.getName())) {
+                    continue;
+                }
+                if (candidate == null) {
+                    candidate = devName;
+                } else if (!candidate.equals(devName)) {
+                    // Multiple candidates - can't auto-discover
+                    return null;
+                }
             }
-        };
+            return candidate;
+        } catch (Exception e) {
+            return null;
+        }
+    }
+
+    protected InputContext getInputContext() {
+        if (inputContext == null) {
+            inputContext = new InputContext() {
+                private BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
+
+                public String getStringInput(String message) {
+                    try {
+                        System.out.println(message);
+                        return in.readLine();
+                    } catch (IOException e) {
+                        throw new RuntimeException(e);
+                    }
+                }
+            };
+        }
+        return inputContext;
+    }
+
+    protected OutputContext getOutputContext() {
+        if (outputContext == null) {
+            outputContext = new OutputContext() {
+                public void showMessage(String msg) {
+                    System.out.println(msg);
+                }
+            };
+        }
+        return outputContext;
     }
 }