< prev index next >

test/jdk/tools/jpackage/helpers/jdk/jpackage/test/LinuxHelper.java

Print this page

        

@@ -23,18 +23,15 @@
 package jdk.jpackage.test;
 
 import java.io.IOException;
 import java.nio.file.Files;
 import java.nio.file.Path;
-import java.util.Arrays;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-import java.util.Set;
+import java.util.*;
 import java.util.function.Function;
 import java.util.stream.Collectors;
 import java.util.stream.Stream;
+import jdk.jpackage.test.PackageTest.PackageHandlers;
 
 public class LinuxHelper {
     private static String getRelease(JPackageCommand cmd) {
         return cmd.getArgumentValue("--linux-app-release", () -> "1");
     }

@@ -43,10 +40,23 @@
         cmd.verifyIsOfType(PackageType.LINUX);
         return cmd.getArgumentValue("--linux-package-name",
                 () -> cmd.name().toLowerCase());
     }
 
+    public static Path getDesktopFile(JPackageCommand cmd) {
+        return getDesktopFile(cmd, null);
+    }
+
+    public static Path getDesktopFile(JPackageCommand cmd, String launcherName) {
+        cmd.verifyIsOfType(PackageType.LINUX);
+        String desktopFileName = String.format("%s-%s.desktop", getPackageName(
+                cmd), Optional.ofNullable(launcherName).orElseGet(
+                        () -> cmd.name()));
+        return cmd.appLayout().destktopIntegrationDirectory().resolve(
+                desktopFileName);
+    }
+
     static String getBundleName(JPackageCommand cmd) {
         cmd.verifyIsOfType(PackageType.LINUX);
 
         final PackageType packageType = cmd.packageType();
         String format = null;

@@ -71,22 +81,18 @@
         cmd.verifyIsOfType(PackageType.LINUX);
 
         final PackageType packageType = cmd.packageType();
         final Path packageFile = cmd.outputBundle();
 
-        Executor exec = new Executor();
+        Executor exec = null;
         switch (packageType) {
             case LINUX_DEB:
-                exec.setExecutable("dpkg")
-                        .addArgument("--contents")
-                        .addArgument(packageFile);
+                exec = Executor.of("dpkg", "--contents").addArgument(packageFile);
                 break;
 
             case LINUX_RPM:
-                exec.setExecutable("rpm")
-                        .addArgument("-qpl")
-                        .addArgument(packageFile);
+                exec = Executor.of("rpm", "-qpl").addArgument(packageFile);
                 break;
         }
 
         Stream<String> lines = exec.executeAndGetOutput().stream();
         if (packageType == PackageType.LINUX_DEB) {

@@ -107,12 +113,12 @@
                 return Stream.of(getDebBundleProperty(cmd.outputBundle(),
                         "Depends").split(",")).map(String::strip).collect(
                         Collectors.toList());
 
             case LINUX_RPM:
-                return new Executor().setExecutable("rpm")
-                .addArguments("-qp", "-R", cmd.outputBundle().toString())
+                return Executor.of("rpm", "-qp", "-R")
+                .addArgument(cmd.outputBundle())
                 .executeAndGetOutput();
         }
         // Unreachable
         return null;
     }

@@ -139,10 +145,61 @@
         }
         // Unrechable
         return null;
     }
 
+    static PackageHandlers createDebPackageHandlers() {
+        PackageHandlers deb = new PackageHandlers();
+        deb.installHandler = cmd -> {
+            cmd.verifyIsOfType(PackageType.LINUX_DEB);
+            Executor.of("sudo", "dpkg", "-i")
+            .addArgument(cmd.outputBundle())
+            .execute();
+        };
+        deb.uninstallHandler = cmd -> {
+            cmd.verifyIsOfType(PackageType.LINUX_DEB);
+            Executor.of("sudo", "dpkg", "-r", getPackageName(cmd)).execute();
+        };
+        deb.unpackHandler = (cmd, destinationDir) -> {
+            cmd.verifyIsOfType(PackageType.LINUX_DEB);
+            Executor.of("dpkg", "-x")
+            .addArgument(cmd.outputBundle())
+            .addArgument(destinationDir)
+            .execute();
+            return destinationDir.resolve(String.format(".%s",
+                    cmd.appInstallationDirectory())).normalize();
+        };
+        return deb;
+    }
+
+    static PackageHandlers createRpmPackageHandlers() {
+        PackageHandlers rpm = new PackageHandlers();
+        rpm.installHandler = cmd -> {
+            cmd.verifyIsOfType(PackageType.LINUX_RPM);
+            Executor.of("sudo", "rpm", "-i")
+            .addArgument(cmd.outputBundle())
+            .execute();
+        };
+        rpm.uninstallHandler = cmd -> {
+            cmd.verifyIsOfType(PackageType.LINUX_RPM);
+            Executor.of("sudo", "rpm", "-e", getPackageName(cmd)).execute();
+        };
+        rpm.unpackHandler = (cmd, destinationDir) -> {
+            cmd.verifyIsOfType(PackageType.LINUX_RPM);
+            Executor.of("sh", "-c", String.format(
+                    "rpm2cpio '%s' | cpio -idm --quiet",
+                    JPackageCommand.escapeAndJoin(
+                            cmd.outputBundle().toAbsolutePath().toString())))
+            .setDirectory(destinationDir)
+            .execute();
+            return destinationDir.resolve(String.format(".%s",
+                    cmd.appInstallationDirectory())).normalize();
+        };
+
+        return rpm;
+    }
+
     static Path getLauncherPath(JPackageCommand cmd) {
         cmd.verifyIsOfType(PackageType.LINUX);
 
         final String launcherName = cmd.name();
         final String launcherRelativePath = Path.of("/bin", launcherName).toString();

@@ -171,24 +228,19 @@
 
         return 0;
     }
 
     static String getDebBundleProperty(Path bundle, String fieldName) {
-        return new Executor()
-                .setExecutable("dpkg-deb")
-                .addArguments("-f", bundle.toString(), fieldName)
+        return Executor.of("dpkg-deb", "-f")
+                .addArgument(bundle)
+                .addArgument(fieldName)
                 .executeAndGetFirstLineOfOutput();
     }
 
     static String getRpmBundleProperty(Path bundle, String fieldName) {
-        return new Executor()
-                .setExecutable("rpm")
-                .addArguments(
-                        "-qp",
-                        "--queryformat",
-                        String.format("%%{%s}", fieldName),
-                        bundle.toString())
+        return Executor.of("rpm", "-qp", "--queryformat", String.format("%%{%s}", fieldName))
+                .addArgument(bundle)
                 .executeAndGetFirstLineOfOutput();
     }
 
     static void verifyPackageBundleEssential(JPackageCommand cmd) {
         String packageName = LinuxHelper.getPackageName(cmd);

@@ -262,17 +314,14 @@
         };
 
         test.addBundleVerifier(cmd -> {
             TKit.withTempDirectory("dpkg-control-files", tempDir -> {
                 // Extract control Debian package files into temporary directory
-                new Executor()
-                .setExecutable("dpkg")
-                .addArguments(
-                        "-e",
-                        cmd.outputBundle().toString(),
-                        tempDir.toString()
-                ).execute().assertExitCodeIsZero();
+                Executor.of("dpkg", "-e")
+                .addArgument(cmd.outputBundle())
+                .addArgument(tempDir)
+                .execute();
 
                 Path controlFile = Path.of("postinst");
 
                 // Lookup for xdg commands in postinstall script
                 String lineWithXsdCommand = verifier.apply(

@@ -316,10 +365,14 @@
                 "Failed to locate system .desktop files folder"));
     }
 
     static void addFileAssociationsVerifier(PackageTest test, FileAssociations fa) {
         test.addInstallVerifier(cmd -> {
+            if (cmd.isPackageUnpacked("Not running file associations checks")) {
+                return;
+            }
+
             PackageTest.withTestFileAssociationsFile(fa, testFile -> {
                 String mimeType = queryFileMimeType(testFile);
 
                 TKit.assertEquals(fa.getMime(), mimeType, String.format(
                         "Check mime type of [%s] file", testFile));

@@ -361,40 +414,34 @@
             });
         });
     }
 
     private static String queryFileMimeType(Path file) {
-        return new Executor()
-                .setExecutable("xdg-mime")
-                .addArguments("query", "filetype", file.toString())
+        return Executor.of("xdg-mime", "query", "filetype").addArgument(file)
                 .executeAndGetFirstLineOfOutput();
     }
 
     private static String queryMimeTypeDefaultHandler(String mimeType) {
-        return new Executor()
-                .setExecutable("xdg-mime")
-                .addArguments("query", "default", mimeType)
+        return Executor.of("xdg-mime", "query", "default", mimeType)
                 .executeAndGetFirstLineOfOutput();
     }
 
     public static String getDefaultPackageArch(PackageType type) {
         if (archs == null) {
             archs = new HashMap<>();
         }
 
         String arch = archs.get(type);
         if (arch == null) {
-            Executor exec = new Executor();
+            Executor exec = null;
             switch (type) {
                 case LINUX_DEB:
-                    exec.setExecutable("dpkg").addArgument(
-                            "--print-architecture");
+                    exec = Executor.of("dpkg", "--print-architecture");
                     break;
 
                 case LINUX_RPM:
-                    exec.setExecutable("rpmbuild").addArgument(
-                            "--eval=%{_target_cpu}");
+                    exec = Executor.of("rpmbuild", "--eval=%{_target_cpu}");
                     break;
             }
             arch = exec.executeAndGetFirstLineOfOutput();
             archs.put(type, arch);
         }
< prev index next >