ग्रैडल से वर्तमान ओएस का पता कैसे लगाएं

98

मुझे यह जवाब मिला कि इसे ग्रूवी के साथ कैसे करना है:

Groovy / Grails द्वारा प्लेटफ़ॉर्म (विंडो या लिनक्स) का पता लगाना :

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

क्या कोई बेहतर तरीका है?

gradle

— डैनियल स्पेरी
स्रोत

इस toLowerCase().contains()भाग के बिना, मैं क्या उपयोग करता हूं, जैसा कि मुझे सिर्फ नाम की आवश्यकता है।

— केविन वेलकर

आप ओएस संस्करण भी प्राप्त कर सकते हैं,System.getProperty('os.arch')

— केविन वेलकर

13

"WINDOWS".toLowerCase()लोकेल पर निर्भर है और wındowsमशीनों पर वापस आ जाएगा (नोटलेस i) मशीनों पर जहां लोकेल तुर्की है। toLowerCase(Locale.ROOT)इसके बजाय सुरक्षित पक्ष पर उपयोग करें ।

— मथायस ब्रौन

125

वास्तव में, मैंने ग्रैडल प्रोजेक्ट को देखा, और यह थोड़ा साफ दिखता है क्योंकि यह चींटी की मौजूदा संरचना का उपयोग करता है :

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

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

मुझे यह निम्न ग्रेडेल शाखा में मिला, और यह अच्छी तरह से काम करने लगता है। Gradle / Gradle कोर / शाखाओं / आरबी-0.3 / build.gradle

— पीटर कहन
स्रोत

7

चेतावनी दी जाए, Os.isFamily (Os.FAMILY_UNIX) यूनिक्स और मैक दोनों के लिए सही लौटेगा (जबकि Os.isFamily (Os.FAMILY_MAC) भी वैध है

— shabunc

3

सावधान रहें कि यह वास्तव में ओएस है और कहता है कि शेल ग्रेडल के बारे में कुछ भी शुरू नहीं हुआ (जैसे यह मिंगव, साइगविन या अन्य बैश शेल हो सकता है)। इसलिए सावधान रहें यदि आप पर्यावरण चर को पढ़ने के लिए उपयोग करते हैं, तो वे वह नहीं हो सकते हैं जो आप अपेक्षा करते हैं।

— एस्टनी

2

@shabunc के पास org.gradle.internal.os.OperatingSystem का उपयोग करके एक बेहतर समाधान है

— पीटर

task checkWin() << {तुम्हें यह क्यों चाहिए? आप बस लिख सकते हैंif (Os.isFamily(Os.FAMILY_WINDOWS)) { println "*** WINDOWS " }

— user25

यह भी उपयोग करने के लिए बेहतर है org.gradle.internal.os.OperatingSystemऔर if (OperatingSystem.current() == OperatingSystem.WINDOWS)(यदि हम ग्रेड के बारे में बात करते हैं कि अपने स्वयं के कार्यान्वयन का उपयोग क्यों नहीं करते हैं)

— user25

67

2020 के मध्य अद्यतन : फिर भी ऊष्मायन:

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

2019 की शुरुआत अपडेट : current()हटा दी गई।

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

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

ध्यान रखें कि यह अभी भी ऊष्मायन कर रहा है।

मध्य 2018 अपडेट : जैसे टिप्पणियों में उल्लेख किया गया था, अब यह वर्ग एक अलग पैकेज में चला गया, इसलिए किसी को उपयोग करना चाहिएorg.gradle.nativeplatform.platform.OperatingSystem.current()

2015 के मध्य तक, पीटर कान का जवाब अभी भी मान्य है। पर्यावरण आधारित प्रोफ़ाइल सक्रियण अभी भी मावेन में अपेक्षाकृत आसान है। लेकिन ध्यान रखें कि org.apache.tools.ant.taskdefs.condition.Os.isFamilyइस अर्थ में अनन्य नहीं है कि अगर यह एक विशेष पैरामीटर के साथ सच हो जाता है, तो जरूरी नहीं कि इसका मतलब यह है कि यह किसी अन्य पैरामीटर के लिए गलत है। उदाहरण के लिए:

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

यह दोनों के लिए Os.FAMILY_MACऔर Os.FAMILY_UNIXMacOS पर सही लौटेगा । आमतौर पर यह कुछ ऐसा नहीं होता है जिसकी आपको स्क्रिप्ट बनाने की जरूरत होती है।

हालांकि, ग्रेड 2+ एपीआई का उपयोग करके इसे प्राप्त करने का एक और तरीका है, अर्थात्:

import org.gradle.internal.os.OperatingSystem;

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

Org.gradle.nativeplatform.platform.peratingSystem इंटरफ़ेस के लिए दस्तावेज़ देखें । यह उल्लेख के लायक है कि इस इंटरफ़ेस को इनक्यूबेटिंग एनोटेशन के साथ चिह्नित किया गया है , अर्थात "यह सुविधा वर्तमान में एक कार्य-प्रगति है और किसी भी समय बदल सकती है"। कार्यान्वयन में "आंतरिक" नाम स्थान भी हमें एक संकेत देता है कि हमें यह जानने का उपयोग करना चाहिए कि यह बदल सकता है।

लेकिन व्यक्तिगत रूप से मैं इस समाधान के साथ जाना होगा। यह सिर्फ इतना है कि एक रैपर क्लास लिखना बेहतर है, ताकि भविष्य में कुछ गड़बड़ न हो।

— shabunc
स्रोत

8

क्या यह बदल गया है? ग्रैडल 2.5 का उपयोग OperatingSystemकरने पर ऐसा प्रतीत नहीं होता.current()

— रॉस ड्रू

6

आंतरिक पैकेज को ध्यान में रखें:org.gradle.internal.os.OperatingSystem.current()

— ब्रायन

@danblack आपको OperatingSystemबिना किसी उदाहरण के कैसे मिलता है current()?

— ट्वीस्ट्रीमोब

1

एक मिला OperatingSystem os = org.gradle.nativeplatform.platform.internal.DefaultNativePlatform.currentOperatingSystem:; इच्छा थी कि एक सार्वजनिक @PeterNiederwieser

— TWiStErRob

चूंकि मैक ओएस, विंडोज और लिनक्स केवल ऑपरेटिंग सिस्टम नहीं हैं, यह अच्छा होगा अगर z / OS को शामिल किया गया। हालांकि एक चुटकी में, यह पसंद करना कि दूसरों में से कोई भी काम न कर सके।

— जॉन Czukkermann

18

एक अंतर कर सकते हैं का निर्माण लिनक्स, यूनिक्स, विंडोज और ओएस एक्स के बीच में पर्यावरण - जबकि Gradle nativeplatform.platform.OperatingSystem अलग लक्ष्य पर्यावरण (। सहित FreeBSD और सोलारिस )।

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

एक चींटी कार्य ( स्रोत ) का भी उपयोग कर सकती है :

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

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

— मार्टिन ज़ेटलर
स्रोत

7

ग्रैगल ऑपरेटिंग सिस्टम का पता लगाने के लिए एक सार्वजनिक एपीआई प्रदान नहीं करता है। इसलिए os.सिस्टम गुण आपकी सबसे अच्छी शर्त है।

— पीटर निडरविसर
स्रोत

7

या आप एक स्ट्रिंग के रूप में osName परिभाषित कर सकते हैं ...

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

... और बाद में इसका उपयोग करें - उदाहरण के लिए एक देशी पुस्तकालय को शामिल करने के लिए:

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

लेकिन यह कुछ भी नहीं बदलेगा क्योंकि ऑपरेटिंग सिस्टम आपके कोड की तरह ही काम करता है:

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

स्रोत: https://github.com/gradle/gradle/blob/master/subprojects/base-services/src/main/java/org/gradle/internal/os/OperatingSystem.java

संपादित करें:

आप वास्तुकला के लिए भी ऐसा कर सकते हैं:

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

तथा:

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

बस ध्यान रखें कि getArch () वापस आ जाएगा:

पावरपीसी पर "पीपीसी"
64b पर "amd64"
32 बी पर "I386" या "x86"।

getArch () किसी अन्य प्लेटफ़ॉर्म के लिए सोलारिस या "i386" पर "x86" लौटाएगा।

2 संपादित करें:

या यदि आप किसी भी आयात से बचना चाहते हैं, तो आप इसे स्वयं कर सकते हैं:

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

— tirz
स्रोत

4

मैं गुण या चींटी कार्य के माध्यम से ग्रेड में ओएस का पता लगाना पसंद नहीं करता, और OperatingSystemकक्षा में अब current()विधि नहीं है।

तो, मेरी राय में, ओएस का पता लगाने का सबसे साफ तरीका होगा:

DefaultNativePlatform आयात करें:

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

फिर DefaultNativePlatformअपने कार्य में उपयोग करें:

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

मन कि यह विधि आदर्श नहीं है क्योंकि यह ग्रेडल आंतरिक एपीआई का उपयोग कर रहा है।

इसका परीक्षण ग्रेडल 4.10 के साथ किया गया था।

— रुस्लान पिलिन
स्रोत