हैप्पी यूज़िंग

उस निर्देश के लिए सहायता और विकल्पों की सूची देखने के लिए -h किसी भी happy-* निर्देश के साथ फ़्लैग करें.

राज्य फ़ाइलें

हैप्पी स्टोर और एक रिकॉर्ड के साथ JSON फ़ाइल में अपनी टोपोलॉजी स्थिति को ध्यान से बनाए रखता है. इस स्टेट फ़ाइल का इस्तेमाल करके, हैप्पी टोपोलॉजी बनाने या हटाने के लिए सही निर्देश चला सकता है.

डिफ़ॉल्ट स्थिति वाली फ़ाइल ~/.happy_state.json पर मौजूद है. डिफ़ॉल्ट स्थिति का नाम happy है, जैसा कि happy-state आउटपुट में दिखता है:

happy-state

State Name:  happy

पैरलल स्टेट

हैप्पी एक से ज़्यादा समानांतर स्थितियों का समर्थन करता है. मौजूदा स्थिति HAPPY_STATE_ID के एनवायरमेंट वैरिएबल के हिसाब से तय की जाती है. अगर एनवायरमेंट में HAPPY_STATE_ID मौजूद नहीं है, तो happy की डिफ़ॉल्ट वैल्यू का इस्तेमाल किया जाता है.

हैप्पी इंस्टॉलेशन के दौरान HAPPY_STATE_ID नहीं बनाया जाता है. किसी दूसरे हैप्पी स्टेटस पर तुरंत स्विच करने के लिए, state के बजाय दूसरी वैल्यू के साथ एक वैल्यू बनाएं.

export HAPPY_STATE_ID="sunny"

अब happy-state के नतीजों की जांच किसी दूसरी स्थिति में की जा रही है:

happy-state

State Name:  sunny

हर राज्य की अपनी ~/.${HAPPY_STATE_ID}_state.json फ़ाइल बनी रहती है. एक से दूसरे राज्य पर जाने के लिए, export HAPPY_STATE_ID="<state-name>" निर्देश को फिर से चलाएं.

पैरलल स्थितियों के साथ अनइंस्टॉल करें

अगर आप पैरलल हैपी स्थिति का इस्तेमाल करते हैं और हैप्पी अनइंस्टॉल करना चाहते हैं, तो happy-state-delete को हर राज्य में चालू करके चलाएं. इससे यह पक्का होता है कि हैप्पी नेटवर्क से बनाए गए सभी नेटवर्क नेमस्पेस, आपके सिस्टम से Linux होस्ट नेटवर्क कॉन्फ़िगरेशन पर असर डाले बिना हटा दिए गए हैं.

उदाहरण के लिए, happy और sunny के दो राज्यों के साथ:

export HAPPY_STATE_ID="sunny"
happy-state-delete
export HAPPY_STATE_ID="happy"
happy-state-delete

ज़रूरत के मुताबिक हर पैरलल स्थिति वाली फ़ाइल को मैन्युअल तरीके से हटाएं:

rm -f ~/.sunny_state.json
rm -f ~/.sunny_state.json.lock
rm -f ~/.happy_state.json
rm -f ~/.happy_state.json.lock

लॉग

हैप्पी डिफ़ॉल्ट रूप से syslog को लॉग भेजता है. लॉग का दूसरा बैक अप /tmp/${HAPPY_STATE_ID}_debug_log.txt पर भेजा जाता है.

हैप्पी लॉग देखने के लिए, एक अलग टर्मिनल विंडो में happy-state -l चलाएं. जब आप खुश करने वाले निर्देश डालते हैं, तो लॉग में बैकग्राउंड में शेल से जुड़े निर्देशों की हैप्पी प्रॉब्लम दिखती हैं. अगर आप Linux नेटवर्क के नेमस्पेस में दिलचस्पी रखते हैं, तो यह बताने का यह एक अच्छा तरीका है कि कैसे #&93.

उदाहरण के लिए, happy-node-add node00 एक हैप्पी नोड बनाता है. इस निर्देश का लॉग आउटपुट है:

DEBUG [HappyHost:_namespaceExists():56] Happy: namespace happy000 does not exist
DEBUG [Driver:writeState():365] Happy: writing Happy state to file
DEBUG [Driver:CallCmd():416] Happy [happy]: > sudo ip netns add happy000
DEBUG [HappyHost:_namespaceExists():56] Happy: namespace happy000 exists
DEBUG [Driver:CallCmd():416] Happy [happy]: > sudo ip netns exec happy000 ifconfig lo up

सभी Driver:CallCmd() लाइनें शेल कमांड होती हैं, जो कॉल को खुश करती हैं. लॉग में हर लाइन पर विचार करें:

# Check to see if the target namespace (happy000) exists
DEBUG [HappyHost:_namespaceExists():56] Happy: namespace happy000 does not exist

# Write the link between node00 and happy000 in ~/.happy_state.json
DEBUG [Driver:writeState():365] Happy: writing Happy state to file

# Create the network namespace for the node
DEBUG [Driver:CallCmd():416] Happy [happy]: > sudo ip netns add happy000

# Check to see if the target namespace (happy000) exists
DEBUG [HappyHost:_namespaceExists():56] Happy: namespace happy000 exists

# Bring up the loopback interface within the happy000 namespace
DEBUG [Driver:CallCmd():416] Happy [happy]: > sudo ip netns exec happy000 ifconfig lo up

साइट का नमूना

नमूना देने वाले टॉपोलॉजी, हैपी और ओपनवेव रिपॉज़िटरी, दोनों में जांच के लिए शामिल किए जाते हैं. साथ ही, मुश्किल विषयों को बनाने के लिए, निर्देशों के बारे में जानें.

टॉपोलॉजी, JSON और Shell Script फ़ॉर्मैट में होती हैं.

JSON

JSON टोपोलॉजी फ़ाइलें happy-state-load या weave-state-load निर्देशों का इस्तेमाल करके लोड की जाती हैं. अगर टोपोलॉजी में वेव शामिल है, तो टोपोलॉजी को लोड करने के लिए आपको weave-state-load का इस्तेमाल करना होगा. ऐसा न करने पर, वीव-खास निर्देशों को छोड़ दिया जाता है.

उदाहरण के लिए, बुनाई के बिना एक टोपोलॉजी:

happy-state-load thread_wifi_ap_internet.json

बुनाई के साथ एक टोपोलॉजी:

weave-state-load three_nodes_on_thread_weave.json

अपनी मौजूदा टोपोलॉजी को बाद में इस्तेमाल करने के लिए एक अलग JSON फ़ाइल के रूप में सेव करने के लिए (उदाहरण के लिए, टेस्ट केस स्क्रिप्ट), happy-shell -s का इस्तेमाल करें:

happy-shell -s my_topology.json

इससे $HOME डायरेक्ट्री में टोपोलॉजी स्टेट फ़ाइल सेव हो जाती है.

शेल स्क्रिप्ट

शेल स्क्रिप्ट टोपोलॉजी फ़ाइलों में हैप्पी और वीव कमांड का सेट होता है, ताकि JSON फ़ाइलों में टोपोलॉजी बनाई जा सकें. इन स्क्रिप्ट के पास डिफ़ॉल्ट रूप से एक्ज़ीक्यूटेबल अनुमतियां नहीं होती हैं. उन्हें दो तरीकों से चलाया जा सकता है:

bash निर्देश का इस्तेमाल करके:

bash thread_wifi_ap_internet.sh

एक्ज़ीक्यूटेबल अनुमतियां लागू करके:

chmod +x thread_wifi_ap_internet.sh
./thread_wifi_ap_internet.sh

कॉन्फ़िगरेशन

हैप्पी पर तीन कॉन्फ़िगरेशन फ़ाइलें हैं:

कॉन्फ़िगरेशन फ़ाइलब्यौरा
~/.happy_conf.jsonनिजी या प्लग-इन का इस्तेमाल करने के लिए कॉन्फ़िगरेशन वैरिएबल. happy-configuration निर्देश का इस्तेमाल करके, इन मानों को सेट करें.
<path-to-happy>/happy/conf/main_config.jsonमुख्य हैप्पी कॉन्फ़िगरेशन वैरिएबल.
<path-to-happy>/happy/conf/log_config.jsonलॉग कॉन्फ़िगरेशन.

कॉन्फ़िगरेशन वैरिएबल जोड़ना

हमारा सुझाव है कि आप happy-configuration कमांड का इस्तेमाल करके, किसी भी निजी या प्लग-इन वैरिएबल को उन डिफ़ॉल्ट प्राथमिकताओं के अलावा सेट करें जिनका पालन करना ज़रूरी है.

उदाहरण के लिए, हैप्पी स्क्रिप्ट को टेस्ट स्क्रिप्ट के लिए test-apps डायरेक्ट्री में कहां ढूंढना है, यह बताने के लिए, weave_path वैरिएबल सेट करें:

happy-configuration weave_path <path-to-openweave-core>/build/x86_64-unknown-linux-gnu/src/test-apps

हैप्पी कॉन्फ़िगरेशन कॉन्फ़िगरेशन ~/.happy_conf.json में स्टोर होते हैं.

नोड में मौजूद प्रोसेस

हैप्पी सिम्युलेट किए गए नोड में प्रोसेस शुरू और बंद करने के निर्देश देता है.

प्रोसेस शुरू करने के लिए:

happy-process-start <node-name> <custom-process-name> <command>

उदाहरण के लिए, ThreadNode नाम वाले नोड में लगातार पिंग चलाने के लिए:

happy-process-start ThreadNode ContinuousPing ping 8.8.8.8

ऊपर दिए गए उदाहरण में, ConstantPing प्रक्रिया के लिए उपयोगकर्ता का तय किया गया नाम है, जिसका इस्तेमाल हैप्पी उस प्रक्रिया को प्रबंधित करने के लिए करता है. प्रोसेस खत्म करने के लिए happy-process-wait का और प्रोसेस को खत्म करने के लिए happy-process-stop का इस्तेमाल करें.

प्रक्रिया का आउटपुट /tmp में है. उदाहरण के लिए, ConstantPing प्रोसेस शुरू करने के बाद, /tmp डायरेक्ट्री देखें:

ls /tmp/happy*
/tmp/happy_018691_1524087014.192197_ContinuousPing.out

इस .out फ़ाइल में ConstantPing प्रोसेस के लिए आउटपुट है.

sudo का इस्तेमाल

हैप्पी नेटवर्क कॉन्फ़िगरेशन, Linux kernel के कंट्रोल में है. सिर्फ़ root ही kernel कॉन्फ़िगरेशन को बदल सकता है. इसलिए, हैप्पी कार्रवाई के दौरान आपको sudo पासवर्ड डालने का संकेत देता है.

हैप्पी sudo को कॉल करने के लिए $SUDO सिस्टम परिवेश वैरिएबल का उपयोग करता है. अगर $SUDO के बारे में नहीं बताया गया है, तो हैप्पी आम तौर पर sudo कॉल करता है.

Python स्क्रिप्टिंग

इंस्टॉल करने के बाद, हैप्पी Python पैकेज Python परिवेश में इस import स्टेटमेंट का इस्तेमाल करके इंपोर्ट किए जा सकते हैं:

import happy

/happy में अलग-अलग कमांड मॉड्यूल इंपोर्ट किए गए हैं:

import happy.HappyNodeAdd

मॉड्यूल विकल्प फिर से पाने के लिए, option() फ़ंक्शन पर कॉल करें. उदाहरण के लिए, HappyNodeAdd मॉड्यूल के विकल्प वापस पाने के लिए:

module options
import happy.HappyNodeAdd
options = happy.HappyNodeAdd.option()