Gradle'dan mevcut işletim sistemi nasıl tespit edilir

Groovy ile nasıl yapılacağına dair şu cevabı buldum:

Groovy / Grails ile platformu (Pencere veya Linux) algılama :

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

Daha iyi bir yol var mı?

Aslında, Gradle projesinde baktım ve kullandığı olarak bu biraz daha temiz görünüyor Ant'ın mevcut yapıyı:

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

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

Bunu aşağıdaki Gradle şubesinde buldum ve güzel çalışıyor gibi görünüyor. gradle / gradle-core / dallar / RB-0.3 / build.gradle

2020 Ortası Güncellemesi : Hala kuluçka aşamasında:

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

Erken 2019 Güncellemesi : current()kaldırıldı.

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

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

Yine de kuluçka aşamasında olduğunu unutmayın .

2018 Ortası Güncellemesi : tıpkı yorumlarda belirtildiği gibi, şimdi bu sınıf farklı bir pakete taşındı, bu yüzden biri kullanmalıorg.gradle.nativeplatform.platform.OperatingSystem.current()

2015 ortası itibariyle, Peter Kahn'ın cevabı hala geçerli. Çevre tabanlı profil aktivasyonu, Maven'de hala nispeten daha kolay yapılan bir şey. Ancak org.apache.tools.ant.taskdefs.condition.Os.isFamilybunun, belirli bir parametre ile doğru döndürülmesi durumunda, başka herhangi bir parametre için mutlaka yanlış döndürdüğü anlamına gelmediği anlamında dışlayıcı olmadığını unutmayın . Örneğin:

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))
    }
}

Bu hem gerçek dönecektir Os.FAMILY_MACve Os.FAMILY_UNIXMacOS üzerinde. Genellikle, komut dosyalarında ihtiyacınız olan bir şey değildir.

Gradle 2+ API kullanarak bunu başarmanın başka bir yolu vardır:

import org.gradle.internal.os.OperatingSystem;

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

Org.gradle.nativeplatform.platform.OperatingSystem arabiriminin belgelerine bakın . Bu arayüzün kuluçka notuyla işaretlendiğini , yani "özellik şu anda devam eden bir çalışmadır ve herhangi bir zamanda değişebilir" olduğunu belirtmekte fayda var. Gerçeklemedeki "dahili" ad alanı da bize bunun değişebileceğini bilerek bunu kullanmamız gerektiğine dair bir ipucu verir.

Ama şahsen bu çözümü tercih ederim. Gelecekte bir şeylerin değişmesi ihtimaline karşı karıştırmamak için bir sarmalayıcı sınıfı yazmak daha iyidir.

Linux, Unix, Windows ve OS X arasındaki derleme ortamı ayırt edilebilir - Gradle nativeplatform.platform.OperatingSystem ise hedef ortamı farklılaştırır ( FreeBSD ve Solaris dahil ).

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.
}

Ayrıca bir Ant görevi ( kaynak ) kullanılabilir:

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

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

Veya osName'i string olarak tanımlayabilirsiniz ...

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;
}

... ve daha sonra kullanın - örneğin yerel bir kitaplık eklemek için:

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

Ancak OperatingSystem tam olarak kodunuz gibi çalıştığı için hiçbir şeyi değiştirmez:

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;
    }
}

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

Düzenle:

Aynı şeyi mimari için de yapabilirsiniz:

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

ve:

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

GetArch () işlevinin şunu döndüreceğini unutmayın:

• PowerPC'de "ppc"
• 64b'de "amd64"
• 32b'de "i386" VEYA "x86".

getArch () Solaris'te "x86" veya başka herhangi bir platform için "i386" döndürecektir.

Düzenleme 2:

Veya herhangi bir içe aktarmayı önlemek istiyorsanız, bunu kendiniz yapabilirsiniz:

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);
}

Gradle, işletim sistemini tespit etmek için genel bir API sağlamaz. Bu nedenle, os.sistem özellikleri en iyi seçeneğinizdir.

İşletim sistemini Gradle'da özellikler veya bir Ant görevi aracılığıyla algılamayı sevmiyorum ve OperatingSystemsınıf artık current()yöntemi içermiyor .

Bu yüzden, bence işletim sistemini tespit etmenin en temiz yolu:

DefaultNativePlatform'u İçe Aktar:

import org.gradle.nativeplatform.platform.internal.DefaultNativePlatform

Sonra DefaultNativePlatformgörevinizde kullanın :

if (DefaultNativePlatform.getCurrentOperatingSystem().isWindows()) {
   println 'Windows'
}

Gradle dahili API'sini kullandığı için bu yöntemin ideal olmadığını unutmayın.

Gradle 4.10 ile test edildi.