WebSVN - OpenConcerto - Diff - Rev 174 and 180 - /trunk/OpenConcerto/src/org/openconcerto/utils/FileUtils.java

  */
  package org.openconcerto.utils;
 import org.openconcerto.utils.CollectionMap2.Mode;
+import org.openconcerto.utils.DesktopEnvironment.Gnome;
 import org.openconcerto.utils.OSFamily.Unix;
-import org.openconcerto.utils.ProcessStreams.Action;
 import org.openconcerto.utils.StringUtils.Escaper;
 import org.openconcerto.utils.cc.ExnTransformer;
 import org.openconcerto.utils.cc.IClosure;
 import java.awt.Desktop;
 import java.nio.file.DirectoryStream;
 import java.nio.file.DirectoryStream.Filter;
 import java.nio.file.FileVisitResult;
 import java.nio.file.Files;
 import java.nio.file.LinkOption;
+import java.nio.file.OpenOption;
 import java.nio.file.Path;
 import java.nio.file.SimpleFileVisitor;
 import java.nio.file.StandardCopyOption;
+import java.nio.file.StandardOpenOption;
 import java.nio.file.attribute.BasicFileAttributes;
 import java.nio.file.attribute.PosixFileAttributeView;
 import java.nio.file.attribute.PosixFilePermissions;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.List;
 import java.util.Map;
 import java.util.Map.Entry;
+import java.util.Objects;
 import java.util.Set;
 import java.util.logging.Level;
 import java.util.regex.Pattern;
 public final class FileUtils {
+    public static void main(String[] args) throws Exception {
+        final String cmd = args[0];
+        if ("browseFile".equals(cmd))
+            browseFile(new File(args[1]));
+        else if ("browse".equals(cmd))
+            browse(new URI(args[1]));
+        else
+            System.err.println("Unkown command : " + cmd);
+    }
     private FileUtils() {
         // all static
+    }
     public static void browseFile(final File f) throws IOException {
+        browse(null, Objects.requireNonNull(f));
+    }
+    private static void browse(URI uri, final File f) throws IOException {
+        assert (uri == null) != (f == null);
+        boolean handled = false;
+        final Desktop.Action action = Desktop.Action.BROWSE;
-        if (Desktop.isDesktopSupported()) {
+        if (isDesktopDesirable(action) && Desktop.isDesktopSupported()) {
-            Desktop d = Desktop.getDesktop();
+            final Desktop d = Desktop.getDesktop();
-            if (d.isSupported(Desktop.Action.BROWSE)) {
+            if (d.isSupported(action)) {
+                if (uri == null)
-                d.browse(f.getCanonicalFile().toURI());
+                    uri = f.getCanonicalFile().toURI();
+                if (!uri.getScheme().equals("file") && DesktopEnvironment.getDE() instanceof Gnome) {
-            } else {
+                    ProcessBuilder pb = null;
+                    final String version = DesktopEnvironment.getDE().getVersion();
+                    // Ubuntu 12.04, 14.04, 16.04
+                    if (version.startsWith("3.4.") || version.startsWith("3.10.") || version.startsWith("3.18.")) {
+                        pb = new ProcessBuilder("gvfs-mount", uri.toASCIIString());
-                openNative(f);
+                        // Ubuntu 18.04
+                    } else if (version.startsWith("3.28")) {
+                        // gio/gio-tool-mount.c#mount() calls g_file_mount_enclosing_volume.
+                        // TODO find out how glib computes "the volume that contains the file
+                        // location". E.g why does mount "davs://example.com/webdav/dir/dir" mounts
+                        // "davs://example.com/webdav/".
+                        // Return 0 if not yet mounted, 2 if it was already mounted.
+                        pb = new ProcessBuilder("gio", "mount", uri.toASCIIString());
+                    }
+                    if (pb != null) {
+                        try {
+                            startDiscardingOutput(pb).waitFor();
+                        } catch (InterruptedException e) {
+                            throw new RTInterruptedException("Interrupted while waiting on mount for " + uri, e);
+                        }
+                    }
+                }
+                d.browse(uri);
+                handled = true;
-        } else {
+            }
+        }
+        if (!handled) {
+            // if the caller passed a file use it instead of our converted URI
+            if (f != null)
-            openNative(f);
+                openNative(f);
+            else
+                openNative(uri);
+        }
+    }
-    public static void browse(URI uri) throws Exception {
+    public static boolean isDesktopDesirable(Desktop.Action action) {
-        final boolean windows = System.getProperty("os.name").startsWith("Windows");
+        // apparently the JRE just checks if gnome libs are available (e.g. open Nautilus in XFCE)
-        if (windows) {
-            Desktop.getDesktop().browse(uri);
-        } else {
-            String[] cmdarray = new String[] { "xdg-open", uri.toString() };
-            final int res = Runtime.getRuntime().exec(cmdarray).waitFor();
-            if (res != 0)
-                throw new IOException("error (" + res + ") executing " + Arrays.asList(cmdarray));
+        return !(action == Desktop.Action.BROWSE && OSFamily.getInstance() == OSFamily.Linux && !(DesktopEnvironment.getDE() instanceof Gnome));
+    }
+    public static void browse(URI uri) throws IOException {
+        browse(Objects.requireNonNull(uri), null);
+    }
     public static void openFile(File f) throws IOException {
         if (!f.exists()) {
             throw new FileNotFoundException(f.getAbsolutePath() + " not found");
     public static final byte[] readBytes(File f) throws IOException {
         // works for /proc files which report 0 size
         return Files.readAllBytes(f.toPath());
+    }
+    /**
+     * Write the passed string with default charset to the passed file, truncating it.
+     *
+     * @param s the string.
+     * @param f the file.
+     * @throws IOException if an error occurs.
+     * @deprecated use {@link #writeUTF8(Path, String, OpenOption...)} or
+     *             {@link #write2Step(String, Path)}
+     */
     public static void write(String s, File f) throws IOException {
-        write(s, f, null, false);
+        write2Step(s, f, Charset.defaultCharset(), false);
+    }
+    public static void writeUTF8(String s, File f) throws IOException {
+        writeUTF8(f.toPath(), s);
+    }
+    public static void writeUTF8(Path path, String s, OpenOption... options) throws IOException {
+        Files.write(path, s.getBytes(StandardCharsets.UTF_8), options);
+    }
-    public static void write(String s, File f, Charset charset, boolean append) throws IOException {
+    public static void write2Step(String s, File f, Charset charset, boolean append) throws IOException {
+        write2Step(s, f.toPath(), charset, append);
+    }
+    public static void write2Step(final String s, final Path f) throws IOException {
+        // UTF_8 default like Files.newBufferedReader()
+        write2Step(s, f, StandardCharsets.UTF_8);
+    }
+    public static void write2Step(final String s, final Path f, final Charset charset) throws IOException {
+        write2Step(s, f, charset, false);
+    }
+    public static void write2Step(final String s, final Path f, final Charset charset, final boolean append) throws IOException {
+        // create temporary file in the same directory so we can move it
-        try (final FileOutputStream fileStream = new FileOutputStream(f, append);
+        final Path tmpFile = Files.createTempFile(f.toAbsolutePath().getParent(), null, null);
+        try {
+            // 1. write elsewhere
-                final BufferedWriter w = new BufferedWriter(charset == null ? new OutputStreamWriter(fileStream) : new OutputStreamWriter(fileStream, charset))) {
+            final byte[] bs = charset == null ? s.getBytes() : s.getBytes(charset);
+            if (append) {
+                // REPLACE_EXISTING since tmpFile exists
+                Files.copy(f, tmpFile, StandardCopyOption.REPLACE_EXISTING);
+                Files.write(tmpFile, bs, StandardOpenOption.APPEND);
+            } else {
+                Files.write(tmpFile, bs);
+            }
+            // 2. move into place (cannot use ATOMIC_MOVE because f might exists ; and we would need
+            // to handle AtomicMoveNotSupportedException)
+            Files.move(tmpFile, f, StandardCopyOption.REPLACE_EXISTING);
+            // don't try to delete if move() successful
+        } catch (RuntimeException | Error | IOException e) {
+            try {
+                Files.deleteIfExists(tmpFile);
+            } catch (Exception e1) {
+                e.addSuppressed(e1);
+            }
-            w.write(s);
+            throw e;
+        }
+    }
     /**
      * Create a writer for the passed file, and write the XML declaration.
             // 1. needs CYGWIN=winsymlinks to create a shortcut, but even then "ln -f" doesn't work
             // since it tries to delete l instead of l.LNK
             // 2. it sets the system flag so "dir" doesn't show the shortcut (unless you add /AS)
             // 3. the shortcut is recognized as a symlink thanks to a special attribute that can get
             // lost (e.g. copying in eclipse)
-            ps = Runtime.getRuntime().exec(new String[] { "cscript", getShortCutFile().getAbsolutePath(), link.getAbsolutePath(), target.getCanonicalPath() });
+            ps = startDiscardingOutput("cscript", getShortCutFile().getAbsolutePath(), link.getAbsolutePath(), target.getCanonicalPath());
             res = new File(link.getParentFile(), link.getName() + ".LNK");
         } else {
             final String rel = FileUtils.relative(link.getAbsoluteFile().getParentFile(), target);
             // add -f to replace existing links
             // add -n so that ln -sf aDir anExistantLinkToIt succeed
             final String[] cmdarray = { "ln", "-sfn", rel, link.getAbsolutePath() };
-            ps = Runtime.getRuntime().exec(cmdarray);
+            ps = startDiscardingOutput(cmdarray);
             res = link;
+        }
-        // no need for output, either it succeeds or it fails
-        ProcessStreams.handle(ps, Action.CLOSE);
         try {
             final int exitValue = ps.waitFor();
             if (exitValue == 0)
                 return res;
             else
      * and that it will not be called thousands of times per second.
+     *
      * @param prefix the prefix string to be used in generating the directory's name.
      * @return the newly-created directory.
      * @throws IllegalStateException if the directory could not be created.
+     * @deprecated use
+     *             {@link Files#createTempDirectory(String, java.nio.file.attribute.FileAttribute...)}
      */
     public static File createTempDir(final String prefix) {
         final File baseDir = new File(System.getProperty("java.io.tmpdir"));
         final String baseName = prefix + System.currentTimeMillis() + "-";
             openNative(f);
         } catch (IOException exn) {
             for (int i = 0; i < executables.length; i++) {
                 final String executable = executables[i];
                 try {
-                    ProcessStreams.handle(Runtime.getRuntime().exec(new String[] { executable, f.getCanonicalPath() }), Action.CLOSE);
+                    startDiscardingOutput(executable, f.getCanonicalPath());
                     return;
                 } catch (IOException e) {
+                    exn.addSuppressed(new IOException("unable to open with " + executable, e));
                     // try the next one
+                }
+            }
-            throw ExceptionUtils.createExn(IOException.class, "unable to open " + f + " with: " + Arrays.asList(executables), exn);
+            throw new IOException("unable to open " + f, exn);
+        }
+    }
     /**
      * Open the passed file as if it were graphically opened by the current user (user's "open
+     *
      * @param f the file to open.
      * @throws IOException if f couldn't be opened.
      */
     private static final void openNative(File f) throws IOException {
+        openNative(f.getCanonicalPath());
+    }
+    private static final void openNative(URI uri) throws IOException {
+        openNative(uri.toASCIIString());
+    }
+    private static final void openNative(String param) throws IOException {
         final OSFamily os = OSFamily.getInstance();
         final String[] cmdarray;
         if (os == OSFamily.Windows) {
-            cmdarray = new String[] { "cmd", "/c", "start", "\"\"", f.getCanonicalPath() };
+            cmdarray = new String[] { "cmd", "/c", "start", "\"\"", param };
         } else if (os == OSFamily.Mac) {
-            cmdarray = new String[] { "open", f.getCanonicalPath() };
+            cmdarray = new String[] { "open", param };
         } else if (os instanceof Unix) {
-            cmdarray = new String[] { "xdg-open", f.getCanonicalPath() };
+            cmdarray = new String[] { "xdg-open", param };
         } else {
-            throw new IOException("unknown way to open " + f);
+            throw new IOException("unknown way to open " + param);
+        }
         try {
-            final Process ps = Runtime.getRuntime().exec(cmdarray);
+            final Process ps = startDiscardingOutput(cmdarray);
-            ProcessStreams.handle(ps, Action.CLOSE);
             // can wait since the command return as soon as the native application is launched
             // (i.e. this won't wait 30s for OpenOffice)
             final int res = ps.waitFor();
             if (res != 0)
                 throw new IOException("error (" + res + ") executing " + Arrays.asList(cmdarray));
         } catch (InterruptedException e) {
             throw ExceptionUtils.createExn(IOException.class, "interrupted waiting for " + Arrays.asList(cmdarray), e);
+        }
+    }
+    private static final Process startDiscardingOutput(final String... command) throws IOException {
+        return startDiscardingOutput(new ProcessBuilder(command));
+    }
+    private static final Process startDiscardingOutput(final ProcessBuilder pb) throws IOException {
+        final Process res = pb.redirectOutput(ProcessStreams.DISCARD).redirectError(ProcessStreams.DISCARD).start();
+        res.getOutputStream().close();
+        return res;
+    }
     static final boolean gnomeRunning() {
         try {
-            final Process ps = Runtime.getRuntime().exec(new String[] { "pgrep", "-u", System.getProperty("user.name"), "nautilus" });
+            final Process ps = startDiscardingOutput("pgrep", "-u", System.getProperty("user.name"), "nautilus");
             // no need for output, use exit status
-            ProcessStreams.handle(ps, Action.CLOSE);
             return ps.waitFor() == 0;
         } catch (Exception e) {
             return false;
+        }
+    }

Dépôt officiel du code source de l'ERP OpenConcerto

svn://code.openconcerto.org/openconcerto

(root)/trunk/OpenConcerto/src/org/openconcerto/utils/FileUtils.java @ 174 - Rev 174 → 180