स्काला में बाहरी प्रक्रियाओं को चलाना

परिचय

मेरे घर के एक प्रोजेक्ट में, मुझे एक छोटे बाहरी प्रोसेस मैनेजर को लिखने की आवश्यकता थी। एप्लिकेशन को बाहरी डेमॉन शुरू करने में सक्षम होना चाहिए, समय-समय पर इसकी स्थिति की निगरानी करें, जब इसे बंद करना, चालू करना, सेटिंग्स बदलना आदि आवश्यक हो। इस तरह के कार्यों के लिए जावा में मौजूदा कार्यक्षमता बहुत ही दुर्लभ है, और चूंकि मैं स्काला के साथ एक साथ काम कर रहा था, इसलिए मैंने यह देखने का फैसला किया कि वह इसके साथ क्या कर रही है। और मैं सुखद आश्चर्यचकित था: स्काला ने मेरी राय में बाहरी प्रक्रियाओं के साथ काम करने के लिए एक अच्छा एपीआई प्रदान किया।
इस लेख में, मैं इस बारे में अधिक बात करना चाहूंगा।

प्रक्रिया शुरू

दो लक्षण प्रक्रियाओं के साथ काम की आधारशिला हैं: ये scala.sys.process.Process और scala.sys.process.ProcessBuilder हैं ।
प्रक्रिया आपको पहले से चल रही प्रक्रिया के साथ काम करने की अनुमति देती है, और प्रोसेसब्यूलर आपको स्टार्टअप मापदंडों को कॉन्फ़िगर करने की अनुमति देता है।
ये इकाइयाँ पैकेज scala.sys.process में हैं । एक सरल उदाहरण चलाने के लिए, कोड चलाएँ:

scala> import scala.sys.process._ scala> val process: Process = Process("echo Hello World").run() scala> println(process.exitValue()) 

रन विधि एक प्रक्रिया शुरू करने के लिए मुख्य विधि है जिसका घोषणापत्र ProcessBuilder ट्रे में स्थित है। किसी प्रकार की प्रक्रिया का संदर्भ देता है। चल रही प्रक्रिया पृष्ठभूमि में चलती है, डेटा कंसोल के लिए आउटपुट है। प्रक्रिया ट्रे में दो विधियाँ घोषित की गई हैं:

• exitValue() - प्रक्रिया के पूरा होने का इंतजार करता है और exitValue() कोड लौटाता है;
• destroy() - चल रही प्रक्रिया को नष्ट कर देता है।

यह विशेषता मानक जावा वर्ग java.lang.Process के समान है।
ProcessBuilder ट्रे में प्रक्रिया शुरू करने के लिए और अधिक विशिष्ट तरीके हैं। मैं मुख्य का संक्षिप्त विवरण दूंगा:

• ! - प्रक्रिया शुरू करता है, पूरा होने का इंतजार करता है, कंसोल को डेटा निष्पादित करता है, और परिणामस्वरूप प्रक्रिया पूरा होने का कोड देता है;
• !! - प्रक्रिया शुरू करता है, पूरा होने की प्रतीक्षा करता है, कंसोल में डेटा प्रदर्शित करता है, यदि पूरा कोड शून्य से अलग है - एक अपवाद फेंकता है, परिणामस्वरूप यह स्ट्रिंग के रूप में प्रक्रिया का आउटपुट देता है;
• lines - प्रक्रिया शुरू करता है, स्ट्रीम [स्ट्रिंग] देता है। यह धागा आपको प्रक्रिया डेटा को प्रक्रिया के समानांतर पढ़ने की अनुमति देता है। यदि जानकारी उपलब्ध नहीं है, तो स्ट्रीम अवरुद्ध हो जाती है और सूचना के दोबारा आने तक प्रतीक्षा करेगी, या प्रक्रिया निष्पादन को पूरा करती है। यदि प्रक्रिया समाप्ति कोड गैर-शून्य है, तो विधि एक अपवाद फेंक देगी। एक अपवाद से बचने के लिए, आपको लाइनों को कॉल करना चाहिए_!
• run - प्रक्रिया शुरू करता है और प्रक्रिया के लिए एक लिंक देता है।

मेरी परियोजना में, मुझे बाहरी प्रक्रियाओं के लिंक संग्रहीत करने की आवश्यकता नहीं थी, इसलिए मैंने लगभग रन विधि का उपयोग नहीं किया। और यहाँ विधि है ! बस मेरे लिए फिट है।
पिछले उदाहरण को फिर से लिखा जा सकता है:

 scala> Process("echo Hello World!").! Hello World! res1: Int = 0 scala> Process("echo Hello World!").!! res2: String = "Hello World!" scala> Process("echo Hello World!").lines res3: Stream[String] = Stream(Hello World!, ?) 

अवैध कास्टिंग

स्पष्ट रूप से कास्टिंग स्ट्रिंग्स ( java.lang.String ) और अनुक्रम ( scala.collection.Seq ) के लिए तरीके ProcessBuilder विशेषता हैं ।
हम अपना कोड इस तरह लिख सकते हैं:

 scala> "echo Hello World!".! Hello World! res2: Int = 0 

या तो:

 scala> Seq("echo", "Hello", "World!").! Hello World! res3: Int = 0 

काफी हद तक, यह लेखन को कम और सरल करता है, और कोड अधिक समझ में आता है।
और यह बदले में भविष्य में त्रुटियों की संख्या को कम करता है।

प्रक्रिया संयोजन (पाइप)

प्रोसेस कॉल को लिनक्स कमांड चेन के समान चेन में जोड़ा जा सकता है।

 scala> "ls".! 11.txt 1.txt 2.txt 3.txt res2: Int = 0 scala> ("ls" #| "grep 1").! 11.txt 1.txt res6: Int = 0 

Ls कमांड से आउटपुट को grep इनपुट के लिए निर्देशित किया गया था। Grep ने प्रविष्टि 1 पर प्राप्त जानकारी को फ़िल्टर किया।
आप सशर्त संचालन कर सकते हैं, उदाहरण के लिए:

 scala> ("find . -name *.txt -exec grep 0 {} ;" #| "xargs test -z" #&& "echo 0-free" #|| "echo 0-exists").! 0-exists res23: Int = 0 

यहाँ, यदि निर्देशिका में फ़ाइलें एक्सटेंशन * .txt और उनमें से किसी में हैं, तो पाठ में 0 है - यह आउटपुट 0-कंसोल पर मौजूद होगा, अन्यथा 0-मौजूद है।
#&& - यदि पिछले एक को सही तरीके से निष्पादित किया जाता है, तो अगली कमांड निष्पादित करता है;
#|| - पिछले कमांड को निष्पादित करता है यदि पिछले एक को त्रुटियों के साथ निष्पादित किया जाता है।
मुझे यह सुविधा सबसे अधिक पसंद है, यह आपको स्कैला के अंदर एक लाइनक्स जैसे पाइप का उपयोग करने की अनुमति देता है और अपने कोड के अंदर छोटे श स्क्रिप्ट लिखता है।

ओवरराइडिंग आई / ओ स्ट्रीम

बाहरी प्रक्रियाओं के इनपुट / आउटपुट को पुनर्परिभाषित करने की कार्यक्षमता के बिना हमारा सभी कोड असुविधाजनक और बेकार है।
अक्सर, आपको आदेश में प्रदर्शित जानकारी की निगरानी करने की आवश्यकता होती है, उदाहरण के लिए, हुई त्रुटि को डिक्रिप्ट करने के लिए, या यह सुनिश्चित करने के लिए कि सब कुछ सही ढंग से काम करता है।
प्रत्येक रन में, प्रोसेसब्यूलर ट्रे में ;, !!, लाइनों के तरीकों से, आप प्रोसेसलॉगर विशेषता के उदाहरण को स्थानांतरित कर सकते हैं, जो आपको प्रोग्राम के आउटपुट प्रवाह को फ़ाइल या लाइन पर पुनर्निर्देशित करने की अनुमति देता है।
प्रक्रिया द्वारा मुद्रित लाइनों की संख्या की गणना करने के लिए कैसे ProcessLogger का उपयोग करें:

 scala> var normalLines = 0 normalLines: Int = 0 scala> var errorLines = 0 errorLines: Int = 0 scala> val countLogger = ProcessLogger(line => normalLines += 1, | line => errorLines +=1) countLogger: scala.sys.process.ProcessLogger = scala.sys.process.ProcessLogger$$anon$1@459c8859 scala> "ls" ! countLogger res0: Int = 0 scala> println("normalLines: " + normalLines + ", errorLines: " + errorLines) normalLines: 4, errorLines: 0 

ProcessLogger आपको आउटपुट स्ट्रीम को ओवरराइड करने की अनुमति देता है। वर्ग scala.sys.process.ProcessIO का उपयोग इनपुट और आउटपुट दोनों को ओवरराइड करने के लिए किया जाता है।
एक छोटा सा उदाहरण:

 Seq("grep", "1") run new ProcessIO((output: java.io.OutputStream) => { output.write("1.txt\n2.txt\n3.txt\n11.txt".getBytes) output.close() }, (input: java.io.InputStream) => { println(Source.fromInputStream(input).mkString) input.close() }, _.close()) 

पहला पैरामीटर प्रक्रिया में इनपुट स्ट्रीम है: यहां हम प्रारंभिक डेटा लिखते हैं।
दूसरा पैरामीटर मानक आउटपुट है, और अंतिम त्रुटि आउटपुट है।
पैरामीटर ऐसे कार्य हैं जो आवश्यक थ्रेड्स को संभालते हैं।
इससे पहले, मैंने कहा कि बाहरी कमांड के निष्पादन को जोड़ा जा सकता है, इसके अलावा, एक ही रिकॉर्डिंग फॉर्म का उपयोग करके, आप डेटा को प्रक्रिया में स्थानांतरित कर सकते हैं, या उन्हें वहां से पढ़ सकते हैं।
आप #< पद्धति का उपयोग करके डेटा को एक प्रक्रिया से फ़ाइल में स्थानांतरित कर सकते हैं, और #> विधि का उपयोग करके डेटा लिख ​​सकते हैं:

 scala> ("echo -e 1.txt\\n2.txt\\n3.txt" #> new java.io.File("1.txt")).! res21: Int = 0 scala> ("grep 1" #< new java.io.File("1.txt")).!! res22: String = "1.txt" 

उसी तरह, उदाहरण के लिए, आप एक फ़ाइल से दूसरी में जानकारी कॉपी कर सकते हैं:

 scala> (new java.io.File("1.txt") #> new java.io.File("2.txt")).! res23: Int = 0 scala> "cat 2.txt".! 1.txt 2.txt 3.txt res24: Int = 0 

निष्कर्ष

लेख में, मैंने स्काला में बाहरी प्रक्रियाओं के साथ काम करने की मूल बातें के बारे में बात की। जावा में, इसे लागू करने के लिए, मुझे रैपरों का एक गुच्छा लिखना होगा, और इसके परिणामस्वरूप, मैं अभी भी इस तरह की सादगी के करीब नहीं पहुंच सका। आप http://www.scala-lang.org पर एपीआई के बारे में अधिक पढ़ सकते हैं या स्रोत में खोद सकते हैं (जो मैंने किया था, उदाहरण के लिए, वहां से कुछ उदाहरण लिया)। jdk1.7 में, हमने वर्ग java.lang.ProcessBuilder को थोड़ा विस्तार दिया, और जावा बाहरी कमांड चलाने और निष्पादित करने के लिए अधिक सुविधाजनक हो गया है। लेकिन स्काला की सादगी के लिए, jdk दूर है।