अवधारणाएँ

यह पेज उन विचारों को समझाता है जिन पर Signal Lab बना है, ताकि बाकी दस्तावेज़ आसानी से पढ़े जा सकें। हर हिस्सा उस पेज का लिंक देता है जो उसका विषय पूरा समझाता है।

स्क्रीन और प्रयोग

Signal Lab में काम करने के दो तरीके हैं, और आप दोनों उपयोग करेंगे।

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

दोनों कई जगह मिलते हैं। HTTP और OSC स्क्रीन पर, प्रयोग में जोड़ें जो आपने अभी भेजा उसे प्रयोग का अगला चरण बना देता है। OSC मॉनिटर और MQTT स्क्रीन पर, इसकी प्रतीक्षा करें किसी प्राप्त संदेश को उसकी प्रतीक्षा करने वाला चरण बना देता है। और लाइब्रेरी का कोई सिग्नल एक चरण बन सकता है — कोई भी, सिवाय hex में लिखे रॉ UDP बाइट के।

सिग्नल और लाइब्रेरी

एक सिग्नल वह संदेश है जिसे आप रखते हैं: एक नाम, एक फ़ोल्डर, इस पर एक नोट कि यह क्या करवाना चाहिए, और यह जो भेजता है — एक OSC संदेश, रॉ UDP बाइट, एक HTTP रिक्वेस्ट या एक MQTT पब्लिश। सिग्नल लाइब्रेरी उन्हें ऐसे फ़ोल्डरों में रखती है जिन्हें आप नेस्ट, नाम बदल और खींच कर इधर-उधर कर सकते हैं।

• आप OSC, HTTP और MQTT स्क्रीन से सिग्नल सहेजते हैं (सहेजें…), सिग्नल स्क्रीन पर एक बनाते हैं, या इंस्पेक्टर द्वारा पकड़ा कोई फ़्रेम सहेजते हैं (सिग्नल के रूप में सहेजें), जो फिर उसे बाइट दर बाइट दोबारा भेजता है।
• आप इसे सिग्नल स्क्रीन से, कहीं से भी Ctrl+K से, प्रयोग के एक चरण के रूप में, या टर्मिनल से signallab fire के साथ भेजते हैं।
• एक सिग्नल ठीक वही भेजता है जो उसकी स्क्रीन भेजती: वही बाइट, उसी रास्ते से, इंस्पेक्टर में उसके असली प्रोटोकॉल के नीचे दिखते हुए।

लाइब्रेरी डेटा फ़ोल्डर में एक फ़ाइल, signals.json, है: सादा JSON जिसे आप पढ़, संपादित, किसी दूसरी मशीन पर कॉपी या किसी रिपॉज़िटरी में रख सकते हैं। यह उदाहरण सिग्नलों के एक सेट से शुरू होती है, सभी 127.0.0.1 की ओर। देखें सिग्नल।

जॉब

जो कुछ भी उसका बटन दबाने के बाद चलता रहता है, वह जॉब है: एक OSC मॉनिटर या जनरेटर, एक ब्रोकर या WebSocket कनेक्शन, एक बीकन या डिस्कवरी लिसनर, एक HTTP लोड बर्स्ट, एक एमुलेटर, एक बाधा रिले, एक स्टॉर्म, एक स्कैन, एक प्रयोग रन।

• हर जॉब का निचले पैनल की पट्टी में एक पिल होता है, जिस पर उसका नंबर, वह क्या है, और उसे रोकने का एक बटन होता है। साइडबार दिखाता है कि हर स्क्रीन के कितने जॉब चल रहे हैं।
• हेडर में सभी रोकें एक साथ हर जॉब रोक देता है।
• जो जॉब अपने आप समाप्त हो जाता है — कोई स्कैन जो पूरा हुआ, कोई रन जो पास हुआ, कोई मॉनिटर जिसका पोर्ट विफल हुआ — अपनी पिल छोड़ जाता है, और कंसोल बताता है कि वह कैसे समाप्त हुआ।
• जब आप दूसरी स्क्रीनों पर काम करते हैं तब भी जॉब चलता रहता है।
• अपडेट इंस्टॉल करना पहले हर जॉब रोक देता है।

सर्वर पर, जॉब सर्वर के होते हैं: उस पर साइन इन हर पेज वही जॉब देखता है और उन्हें रोक सकता है।

कैप्चर और इंस्पेक्टर

हर औज़ार — भेजने वाले, मॉनिटर, लिसनर, एमुलेटर, रिले, प्रयोग रन — जो भी फ़्रेम भेजता या पाता है, उसे एक कैप्चर को सौंपता है, और इंस्पेक्टर उसे एक ही टाइमलाइन में दिखाता है।

• कैप्चर तब तक बंद रहता है जब तक आप उसे कैप्चर चालू करें से चालू न करें, और बंद रहते इसका कोई ख़र्च नहीं होता। आप जिस भी स्क्रीन पर हों, यह तब तक चालू रहता है जब तक आप उसे बंद न करें।
• यह अधिकतम 8192 फ़्रेम और उनके 64 MiB बाइट रखता है; सबसे पुराने फ़्रेम नए के लिए जगह बनाते हैं। हर फ़्रेम अपने अधिकतम 256 KiB बाइट रखता है, और सूची उसका पहला KiB दिखाती है।
• दृश्य रोकें सूची को हिलना रोक देता है ताकि आप उसे पढ़ सकें; नीचे कैप्चर चलता रहता है।
• किसी रन द्वारा उपयोग किए गए सीक्रेट मान हर फ़्रेम में मास्क होते हैं।
• पूरा कैप्चर, हर रखी गई बाइट के साथ, .jsonl या .txt फ़ाइल में निर्यात किया जा सकता है।

एमुलेटर

एक एमुलेटर दूसरा पक्ष निभाता है: वह API, डिवाइस या सेवा जिससे आपका सिस्टम बात करता है। हर एक एक दस्तावेज़ है जिसमें एक प्रोटोकॉल, वह पता जिस पर वह सुनता है, और यह बताने वाले नियम होते हैं कि क्या जवाब देना है:

प्रोटोकॉल	क्या एमुलेट करता है
HTTP	एक API: मेथड और पाथ के अनुसार रूट, क्रम में, बारी-बारी या रैंडम रूप से जवाब, विलंब और फ़ॉल्ट के साथ
OSC	एक डिवाइस जो OSC संदेशों का जवाब पते और आर्ग्युमेंट से देता है
UDP	एक डिवाइस जो डेटाग्राम का जवाब उनके पेलोड से देता है
TCP	एक डिवाइस जो TCP कनेक्शन पर पंक्तियों का जवाब देता है, एक अभिवादन के साथ
MQTT	एक ब्रोकर जो रूट करता है कि क्लाइंट क्या पब्लिश करते हैं, और किसी डिवाइस की तरह नियमों से जवाब देता है

एक एमुलेटर धीमा जवाब दे सकता है, विफल हो सकता है, कनेक्शन बंद कर सकता है, ख़राब बॉडी भेज सकता है, या किसी शेड्यूल पर बंद हो सकता है। हर आदान-प्रदान गिना जाता है, उसकी स्क्रीन पर सूचीबद्ध होता है और इंस्पेक्टर के लिए कैप्चर किया जाता है।

आप एक एमुलेटर स्क्रीन से शुरू करते हैं, जहाँ वह एक जॉब के रूप में चलता है; किसी प्रयोग के एमुलेटर नोड से, जहाँ वह पूरे रन के लिए जवाब देता है; या signallab emulate के साथ। एमुलेटर लाइब्रेरी डेटा फ़ोल्डर में emulators.json है। यह हर तरह का एक एमुलेटर लेकर शुरू होती है, सभी 127.0.0.1 पर:

एमुलेटर	कहाँ सुनता है	क्या करता है
डेमो API	127.0.0.1:8080 (HTTP)	एक हेल्थ चेक, id से एक उपयोगकर्ता, एक क्रिएट, एक धीमा जवाब, और एक रूट जो काम करने से पहले दो बार विफल होता है
डेमो OSC डिवाइस	127.0.0.1:9100 (OSC)	/ping का जवाब /pong और गिनती से देता है, /fader/… को /ack से स्वीकार करता है, /cue/… बिना कुछ कहे ले लेता है
डेमो UDP डिवाइस	127.0.0.1:7100 (UDP)	PING का जवाब PONG और गिनती से देता है, बाकी किसी भी चीज़ को कितने बाइट मिले यह बताकर
डेमो TCP डिवाइस	127.0.0.1:7200 (TCP)	प्रोजेक्टर जैसा लाइन प्रोटोकॉल: READY से अभिवादन, पावर बताता और बदलता है, QUIT पर BYE कहकर काट देता है
डेमो MQTT ब्रोकर	127.0.0.1:1883 (MQTT)	एक retained lab/status, और एक लैंप: lab/<name>/set पर पब्लिश किया गया ON या OFF lab/<name>/state पर जवाब पाता है

देखें एमुलेटर।

बाधा रिले

एक बाधा रिले किसी क्लाइंट और उसके लक्ष्य के बीच बैठता है। आप क्लाइंट को असली लक्ष्य के बजाय रिले के सुनने के पते की ओर मोड़ते हैं; रिले दोनों तरफ़ भेजता है और जो गुज़रता है उसे एक प्रोफ़ाइल से बिगाड़ता है:

• UDP पर, हर डेटाग्राम का अपना भविष्य तय होता है: लेटेंसी और जिटर, लॉस और लॉस के बर्स्ट, डुप्लिकेट, डेटा का बिगड़ना (corruption), क्रम बदलना, एक बैंडविड्थ सीमा, या कुछ भी नहीं (ऑफ़लाइन);
• TCP पर, हर कनेक्शन लक्ष्य तक अपने एक अलग कनेक्शन से जुड़ता है, और दोनों स्ट्रीम विलंबित, एक बैंडविड्थ सीमा पर रोकी गई, रीसेट, या अर्ध-खुली छोड़ी जाती हैं।

प्रीसेट एक क्लिक में एक प्रोफ़ाइल सेट करते हैं, एक केबल से लेकर सैटेलाइट लिंक तक। रिले चलते समय एक बदलाव लागू होता है, उसका पोर्ट गिराए बिना। हर निर्णय एक सीड से लिया जाता है, इसलिए वही ट्रैफ़िक फिर वही भविष्य पाता है।

बाधा स्क्रीन पर एक रिले एक जॉब के रूप में चलता है। किसी प्रयोग में, एक नेटवर्क बाधा नोड रन के लिए एक खोलता है और बाधा बदलें रन के बीच में उसकी प्रोफ़ाइल बदल देता है। देखें बाधा और फ़ॉल्ट।

प्रयोग

नोड और कनेक्शन

एक प्रयोग नोड का एक ग्राफ़ है जो कनेक्शनों से जुड़ा होता है। हर नोड एक चरण है: वह कुछ भेजता है, किसी चीज़ की प्रतीक्षा करता है, किसी मान की जाँच करता है, एक निकालता है, फ़्लो बदलता है, या रन तैयार करता है — एक एमुलेटर, एक बाधा रिले। हर प्रयोग में ठीक एक शुरुआत और एक अंत होता है, और वह अधिकतम 64 नोड रखता है। एडिटर में खुला प्रयोग आपके संपादन के साथ सहेजा जाता है। देखें नोड।

आउटपुट

एक कनेक्शन किसी नोड के आउटपुट से दूसरे नोड के इनपुट तक जाता है। ज़्यादातर नोड का एक आउटपुट होता है; कुछ कई में से चुनते हैं: शाखा के लिए हाँ और नहीं, किसी wait के लिए मेल खाया और टाइमआउट, लूप के लिए बॉडी, पूर्ण और सीमा, समानांतर शाखा के लिए शाखा 1 और शाखा 2।

एक आउटपुट के कई कनेक्शन हो सकते हैं: हर एक अपनी अलग शाखा के रूप में, समानांतर चलता है, और एक शाखाएँ जोड़ें उसमें आने वाले हर कनेक्शन की प्रतीक्षा करता है। केवल एक लूप की बॉडी ही वापस जा सकती है; बाकी कोई भी चक्र एक त्रुटि है। देखें फ़्लो।

पैरामीटर और प्रोफ़ाइल

एक पैरामीटर एक नामित मान है — एक होस्ट, एक पोर्ट, एक उपयोगकर्ता नाम — जो पैरामीटर के नीचे एक बार लिखा जाता है और किसी भी फ़ील्ड में {{name}} के रूप में उपयोग होता है। एक प्रोफ़ाइल एक साथ कई पैरामीटर बदल देती है: एक लैपटॉप के लिए, एक स्टेज के लिए, एक जगह के लिए। आप चुनते हैं कि रन कौन-सी प्रोफ़ाइल उपयोग करें, या इसके साथ चलाएँ… से किसी एक रन के लिए कोई प्रोफ़ाइल, दूसरे मान या कोई सीड देते हैं, प्रयोग बदले बिना। एक प्रयोग अधिकतम 64 पैरामीटर और 32 प्रोफ़ाइल रखता है। देखें डेटा।

टेम्पलेट

नोड के ज़्यादातर टेक्स्ट फ़ील्ड टेम्पलेट होते हैं: सादा टेक्स्ट जिसमें डबल ब्रेसों में व्यंजक होते हैं, जो चरण चलते समय भरे जाते हैं।

• {{host}} — एक पैरामीटर, या रन में पहले सेट किया कोई वेरिएबल, जैसे कोई मान जो मान निकालें नोड ने किसी रिस्पॉन्स से लिया, या कोई जवाब जो किसी wait ने पाया ({{reply.args[0]}})।
• {{secret.API_TOKEN}} — एक सीक्रेट।
• {{run.id}}, {{run.seed}}, {{now}}, {{now.iso}}, {{counter}} — रन और वह क्षण।
• {{uuid}}, {{random_int(1, 10)}}, {{random_float(0, 1, 2)}}, {{pick("a", "b")}} — जनरेट किए मान।

केवल इंजन ही टेम्पलेट भरता है, इसलिए किसी फ़ील्ड का अर्थ एक रन में, एडिटर के प्रीव्यू में और अभी भेजें में एक ही होता है। अज्ञात नाम एक त्रुटि है, ख़ाली टेक्स्ट कभी नहीं। देखें डेटा।

सीक्रेट

एक सीक्रेट वह मान है जो एक प्रयोग उपयोग करता है पर कभी रखता नहीं — कोई टोकन, कोई पासवर्ड। प्रयोग केवल उसका नाम रखता है; फ़ील्ड उसे {{secret.NAME}} के रूप में उपयोग करते हैं; और एक रन जो भी टेक्स्ट रिपोर्ट करता है, हर चरण, रिपोर्ट और हर इंस्पेक्टर फ़्रेम उसे मास्क करके दिखाता है। कोई कमांड कभी सीक्रेट का मान वापस नहीं देता।

मान कहाँ रहते हैं, यह इस पर निर्भर करता है कि Signal Lab कहाँ चलता है:

• Windows पर डेस्कटॉप ऐप उन्हें Windows Credential Manager में रखता है। आप उन्हें पैरामीटर → सीक्रेट के नीचे सेट करते हैं।
• Linux पर डेस्कटॉप ऐप के पास उन्हें रखने के लिए कोई credential स्टोर नहीं है, इसलिए सीक्रेट उपयोग करने वाले प्रयोग वहाँ कमांड लाइन या सर्वर से चलते हैं।
• एक सर्वर उन्हें अपने एनवायरनमेंट (SIGNALLAB_SECRET_<NAME>) से, या उसके सीक्रेट फ़ोल्डर में हर नाम की एक फ़ाइल से (डिफ़ॉल्ट रूप से /run/secrets/signallab/<NAME>), केवल पढ़ने योग्य रूप में पढ़ता है; उन्हें ब्राउज़र से सेट नहीं किया जा सकता।
• कमांड लाइन उन्हें सर्वर की तरह ही पढ़ती है, या कहे जाने पर सिस्टम के credential स्टोर से। देखें कमांड लाइन।

सीड

हर रन का एक सीड होता है, एक संख्या जो उसमें हर रैंडम चीज़ तय करती है: जनरेट किए मान, किसी repeat का जिटर, किसी एमुलेटर का रिस्पॉन्स का रैंडम चुनाव, किसी बाधा रिले का हर निर्णय। वही सीड और वही ट्रैफ़िक वही रन देते हैं। हर रन के लिए एक नया सीड निकाला जाता है, जब तक प्रयोग कोई सीड पिन न करे — रन टाइमलाइन में पिन करें अंतिम रन का सीड पिन करता है, और पैरामीटर के नीचे सीड एक सेट करता है।

रन और रिपोर्ट

एक रन शुरुआत पर शुरू होता है, कनेक्शनों का अनुसरण करता है और तब पास होता है जब वह बिना कोई चरण विफल हुए अंत तक पहुँचता है। अगर यह 300 सेकंड से ज़्यादा ले, तो इसे रोक दिया जाता है। हर चरण शुरू और समाप्त होते समय रन टाइमलाइन में दिखता है।

जो रन समाप्त होता है, पास हो या विफल, वह डेटा फ़ोल्डर के runs फ़ोल्डर में एक रिपोर्ट लिखता है: प्रयोग का नाम, सीड, प्रोफ़ाइल और उपयोग किए गए मान, यह कब शुरू और समाप्त हुआ, नतीजा और उसकी त्रुटि, हर चरण, और उसके एमुलेटरों और रिले ने क्या गिना। एक ही प्रयोग के दो रन की तुलना की जा सकती है। देखें रन और रिपोर्ट।

डेटा फ़ोल्डर

Signal Lab जो कुछ भी रखता है, वह एक फ़ोल्डर में एक फ़ाइल है: आपके home फ़ोल्डर में Documents/SignalLab, Windows और Linux दोनों पर। एक सर्वर अपना अलग रखता है, जिसे आप उसे शुरू करते समय चुनते हैं (Docker image में /data)।

फ़ाइल या फ़ोल्डर	क्या रखता है
experiment.json	एडिटर में खुला प्रयोग
signals.json	सिग्नल लाइब्रेरी
emulators.json	एमुलेटर लाइब्रेरी
runs/	हर रन की एक रिपोर्ट
exports/	प्रयोगों के डायलॉग से निर्यात किए प्रयोग
capture-….jsonl, capture-….txt	इंस्पेक्टर के निर्यात

फ़ाइलें JSON हैं, पूरी की पूरी लिखी जाती हैं। अगर कोई पढ़ी न जा सके, तो Signal Lab बताता है कि कौन-सी फ़ाइल और त्रुटि कहाँ है, और उसे वैसे ही छोड़ देता है, शुरू से शुरू करने के बजाय। देखें फ़ाइलें और फ़ोल्डर।

डेस्कटॉप और सर्वर

डेस्कटॉप ऐप और एक सर्वर एक ही इंटरफ़ेस के पीछे एक ही इंजन चलाते हैं। जो अलग है:

	डेस्कटॉप ऐप	सर्वर, ब्राउज़र में
ट्रैफ़िक कहाँ से शुरू होता है, मॉनिटर कहाँ सुनते हैं	यह कंप्यूटर	सर्वर
डेटा फ़ोल्डर	Documents/SignalLab	सर्वर का; उसे देखने के लिए हेडर में सर्वर पर पॉइंटर रखें
सीक्रेट	Windows Credential Manager, ऐप में सेट; Linux पर कोई नहीं	केवल पढ़ने योग्य, सर्वर के एनवायरनमेंट या सीक्रेट फ़ाइलों से
रिपोर्ट, निर्यात, कैप्चर	डेटा फ़ोल्डर में लिखे जाते हैं; पथ दिखाया जाता है	ब्राउज़र द्वारा डाउनलोड किए जाते हैं
साइन इन	—	सर्वर के एक्सेस टोकन से, जब उसके पास हो
जॉब, HTTP स्क्रीन का कुकी जार	इस ऐप के	सर्वर के, उस पर साइन इन हर पेज द्वारा साझा
फ़ायरवॉल	एक सूचना Signal Lab को अनुमति देने की पेशकश करती है (Windows)	Signal Lab द्वारा कभी नहीं बदला जाता
अपडेट	आपके क्लिक पर हस्ताक्षरित रिलीज़ इंस्टॉल करता है	इसकी image के साथ अपडेट होता है

देखें सर्वर और सर्वर सुरक्षा।

Signal Lab अपने आप क्या नहीं करता

• यह केवल तभी भेजता है जब आप कोई काम करते हैं, और केवल उन पतों पर जो आप टाइप करते हैं। ऐप शुरू करना कुछ नहीं भेजता — सिवाय, डेस्कटॉप ऐप में, रोज़ाना अपडेट जाँच के, जिसे आप बंद कर सकते हैं। फ़ीडबैक तभी जाता है जब आप फ़ॉर्म भेजते हैं।
• इसके उदाहरण इसी कंप्यूटर पर रहते हैं। शुरुआती सिग्नल, शुरुआती एमुलेटर, नए एमुलेटर और प्रयोग टेम्पलेट सभी 127.0.0.1 उपयोग करते हैं। आप जो listeners शुरू करते हैं — एक OSC मॉनिटर, डिस्कवरी लिसनर, एक बाधा रिले — डिफ़ॉल्ट रूप से 0.0.0.0, यानी हर नेटवर्क कार्ड पर, ताकि दूसरी मशीनें उन तक पहुँच सकें; किसी को इसी कंप्यूटर पर रखने के लिए 127.0.0.1 टाइप करें।
• यह फ़ायरवॉल केवल तब बदलता है जब आप अनुमति दें दबाते हैं और Windows के अपने व्यवस्थापक प्रॉम्प्ट की पुष्टि करते हैं, या signallab firewall allow चलाते हैं। एक सर्वर अपने होस्ट का फ़ायरवॉल कभी नहीं बदलता।
• एक एक्सेस टोकन के बिना सर्वर केवल 127.0.0.1 पर सुनता है, और किसी और पते पर शुरू होने से इनकार कर देता है।
• यह सुरक्षा सीमाओं में रहता है: एक ब्रॉडकास्ट स्वीप अधिकतम 1024 होस्ट तक पहुँचता है, और एक बीकन अपने सभी लक्ष्यों पर मिलाकर प्रति सेकंड अधिकतम 50 000 पैकेट भेजता है।

सुरक्षा सीमाएँ अनुमति नहीं हैं: स्टॉर्म, स्कैनर और ब्रॉडकास्ट असली ट्रैफ़िक भेजते हैं। इन्हें केवल उन नेटवर्कों और होस्टों पर उपयोग करें जो आपके हैं या जिन्हें परखने की आपको अनुमति है।