Comment détecter le système d'exploitation actuel à partir de Gradle ?

Question

J'ai trouvé cette réponse sur la façon de le faire avec Groovy :

Détection de la plateforme (Window ou Linux) par Groovy/Grails :

if (System.properties['os.name'].toLowerCase().contains('windows')) {
    println "it's Windows"
} else {
    println "it's not Windows"
}

Y a-t-il un meilleur moyen ?

Answer 1

En fait, j'ai regardé le projet Gradle, et ceci semble un peu plus propre car il utilise Fourmi structure existante :

import org.apache.tools.ant.taskdefs.condition.Os

task checkWin() << {
    if (Os.isFamily(Os.FAMILY_WINDOWS)) {
        println "*** Windows "
    }
}

J'ai trouvé cela dans la branche Gradle suivante, et cela semble bien fonctionner. gradle/gradle-core/branches/RB-0.3/build.gradle

Answer 2

Mise à jour mi-2020 : Toujours en incubation :

OperatingSystem os = org.gradle.nativeplatform.platform.internal.DefaultNativePlatform.currentOperatingSystem; 

Mise à jour début 2019 : current() retiré.

org.gradle.nativeplatform.platform.OperatingSystem.getDisplayName()

org.gradle.nativeplatform.platform.OperatingSystem.isLinux()

Gardez à l'esprit que c'est toujours incubation cependant.

Mise à jour de la mi-2018 : comme cela a été mentionné dans les commentaires, cette classe a été déplacée dans un paquet différent, donc il faut utiliser org.gradle.nativeplatform.platform.OperatingSystem.current()

---

À la mi-2015, la réponse de Peter Kahn est toujours valable. L'activation de profil basée sur l'environnement est toujours quelque chose de fait relativement plus facilement dans Maven. Mais gardez à l'esprit que org.apache.tools.ant.taskdefs.condition.Os.isFamily n'est pas exclusif dans le sens où s'il retourne vrai avec un paramètre particulier, cela ne signifie pas nécessairement qu'il retourne faux pour tout autre paramètre. Par exemple :

import org.apache.tools.ant.taskdefs.condition.Os
task detect {
    doLast {
        println(Os.isFamily(Os.FAMILY_WINDOWS))
        println(Os.isFamily(Os.FAMILY_MAC))
        println(Os.isFamily(Os.FAMILY_UNIX))
    }
}

Il retournera vrai à la fois pour Os.FAMILY_MAC y Os.FAMILY_UNIX sur MacOS. Habituellement, ce n'est pas quelque chose dont vous avez besoin dans la construction scripts.

Il existe cependant un autre moyen d'y parvenir en utilisant l'API de Gradle 2+, à savoir :

import org.gradle.internal.os.OperatingSystem;

task detect {
    doLast {
        println(OperatingSystem.current().isMacOsX())
        println(OperatingSystem.current().isLinux())
    }
}

Consultez la documentation relative à la org.gradle.nativeplatform.platform.OperatingSystem interface. Il convient de mentionner que cette interface est marquée par le symbole incubation c'est-à-dire "la fonctionnalité est actuellement en cours de réalisation et peut être modifiée à tout moment". L'espace de nom "interne" dans l'implémentation nous donne également un indice que nous devrions utiliser cette fonctionnalité en sachant qu'elle peut changer.

Mais personnellement, j'opterais pour cette solution. C'est juste qu'il est préférable d'écrire une classe enveloppe pour ne pas se planter au cas où quelque chose changerait dans le futur.

Answer 3

On peut différencier les construire entre Linux, Unix, Windows et OS X - tandis que le Gradle nativeplatform.platform.OperatingSystem différencie les cible environnement (y compris FreeBSD y Solaris ).

import org.gradle.internal.os.OperatingSystem

String osName = OperatingSystem.current().getName();
String osVersion = OperatingSystem.current().getVersion();
println "*** $osName $osVersion was detected."

if (OperatingSystem.current().isLinux()) {
    // Consider Linux.
} else if (OperatingSystem.current().isUnix()) {
    // Consider UNIX.
} else if (OperatingSystem.current().isWindows()) {
    // Consider Windows.
} else if (OperatingSystem.current().isMacOsX()) {
    // Consider OS X.
} else {
    // Unknown OS.
}

On peut aussi utiliser une tâche Ant ( fuente ):

import org.apache.tools.ant.taskdefs.condition.Os

task checkWin() << {
    if (Os.isFamily(Os.FAMILY_WINDOWS)) {
        // Consider Windows.
    }
}

Answer 4

Ou vous pouvez définir osName comme une chaîne de caractères...

import org.gradle.internal.os.OperatingSystem

switch (OperatingSystem.current()) {
    case OperatingSystem.LINUX:
        project.ext.osName = "Linux";
        break;
    case OperatingSystem.MAC_OS:
        project.ext.osName = "macOS";
        break;
    case OperatingSystem.WINDOWS:
        project.ext.osName = "Windows";
        break;
}

... et l'utiliser plus tard - pour inclure une bibliothèque native par exemple :

run {
    systemProperty "java.library.path", "lib/$osName"
}

Mais cela ne changerait rien puisque OperatingSystem fonctionne exactement comme votre code :

public static OperatingSystem forName(String os) {
    String osName = os.toLowerCase();
    if (osName.contains("Windows")) {
        return WINDOWS;
    } else if (osName.contains("mac os x") || osName.contains("darwin") || osName.contains("osx")) {
        return MAC_OS;
    } else if (osName.contains("sunos") || osName.contains("solaris")) {
        return SOLARIS;
    } else if (osName.contains("linux")) {
        return LINUX;
    } else if (osName.contains("freebsd")) {
        return FREE_BSD;
    } else {
        // Not strictly true
        return UNIX;
    }
}

Fuente: https://github.com/gradle/gradle/blob/master/subprojects/base-services/src/main/java/org/gradle/internal/os/OperatingSystem.java

Edit :

Vous pouvez faire de même pour l'architecture :

project.ext.osArch = OperatingSystem.current().getArch();
if ("x86".equals(project.ext.osArch)) {
    project.ext.osArch = "i386";
}

et :

run {
    systemProperty "java.library.path", "lib/$osName/$osArch"
}

Sachez simplement que getArch() retournera :

• "ppc" sur PowerPC
• "amd64" sur 64b
• "i386" OU "x86" sur 32b.

getArch() renverra "x86" sur Solaris ou "i386" pour toute autre plate-forme.

Edit 2 :

Ou si vous voulez éviter toute importation, vous pouvez simplement le faire vous-même :

def getOsName(project) {
    final String osName = System.getProperty("os.name").toLowerCase();

    if (osName.contains("linux")) {
        return ("linux");
    } else if (osName.contains("mac os x") || osName.contains("darwin") || osName.contains("osx")) {
        return ("macos");
    } else if (osName.contains("windows")) {
        return ("windows");
    } else if (osName.contains("sunos") || osName.contains("solaris")) {
        return ("solaris");
    } else if (osName.contains("freebsd")) {
        return ("freebsd");
    }
    return ("unix");
}

def getOsArch(project) {
    final String osArch = System.getProperty("os.arch");

    if ("x86".equals(osArch)) {
        return ("i386");
    }
    else if ("x86_64".equals(osArch)) {
        return ("amd64");
    }
    else if ("powerpc".equals(osArch)) {
        return ("ppc");
    }
    return (osArch);
}

Answer 5

Gradle ne fournit pas d'API publique pour détecter le système d'exploitation. C'est pourquoi le os. les propriétés du système sont votre meilleure chance.