सॉफ्टवेयर कॉन्फ़िगरेशन पर जाएं

सभी को नमस्कार! गो पर प्रोग्रामिंग के पांच साल बाद, मैंने खुद को काफी पाया
कार्यक्रम विन्यास के लिए एक विशिष्ट दृष्टिकोण के एक प्रबल समर्थक। इसमें
मैं लेख में उनके मुख्य विचारों को प्रकट करने की कोशिश करूंगा, साथ ही साथ एक छोटा सा हिस्सा भी बताऊंगा
एक पुस्तकालय जो इन विचारों को लागू करता है।

जाहिर है, लेख बहुत व्यक्तिपरक है और उद्देश्यपूर्ण होने का दिखावा नहीं करता है
सच तो यह है। हालांकि, मुझे उम्मीद है कि यह समुदाय के लिए उपयोगी हो सकता है और कम करने में मदद कर सकता है
ऐसे तुच्छ कार्य पर समय व्यतीत होता है।

क्या बात कर रहे हो

सामान्य तौर पर, कॉन्फ़िगरेशन, मेरी राय में, हमारे के चर की परिभाषा है
ऐसे कार्यक्रम जिनके मूल्य हम बाहर से पहले ही प्राप्त कर सकते हैं।
यह तर्क या कमांड लाइन पैरामीटर, पर्यावरण चर हो सकते हैं,
कॉन्फ़िगरेशन फ़ाइलों को डिस्क पर या कहीं भी नेटवर्क, डेटाबेस तालिकाओं पर संग्रहीत किया जाता है
डेटा और इतने पर।

चूंकि गो एक दृढ़ता से स्थिर टाइप की गई भाषा है, इसलिए हम चाहेंगे
अपने प्रकार को ध्यान में रखते हुए, इस तरह के चर के लिए मूल्य निर्धारित करें और प्राप्त करें।

बड़ी संख्या में ओपन-सोर्स लाइब्रेरी या फ्रेमवर्क भी हैं,
ऐसी समस्याओं को हल करना। उनमें से ज्यादातर अपनी दृष्टि का प्रतिनिधित्व करते हैं।
कैसे करना है।

मैं प्रोग्राम कॉन्फ़िगरेशन के लिए कम सामान्य दृष्टिकोण के बारे में बात करना चाहूंगा।
इसके अलावा, यह दृष्टिकोण मुझे सबसे सरल लगता है।

flag पैकेज

हां, यह मजाक नहीं है और मैं वास्तव में हर चीज पर आपका ध्यान आकर्षित करना चाहता हूं
प्रसिद्ध गो मानक पुस्तकालय पैकेज।

पहली नज़र में, flag कमांड मापदंडों के साथ काम करने का एक उपकरण है
लाइनें और नहीं। लेकिन इस पैकेज का उपयोग इंटरफेस के रूप में भी किया जा सकता है।
हमारे कार्यक्रम के मापदंडों का निर्धारण । और चर्चा किए गए दृष्टिकोण के संदर्भ में
flag मुख्य रूप से उस तरह से उपयोग किया जाता है।

जैसा कि ऊपर उल्लेख किया गया है, हम टाइप किए गए पैरामीटर रखना चाहेंगे।
flag पैकेज सबसे बुनियादी प्रकारों के लिए ऐसा करने की क्षमता प्रदान करता है।
- flag.String() , flag.Int() और यहां तक ​​कि flag.Duration() । flag.Duration() ।

अधिक जटिल प्रकारों के लिए, जैसे []string या time.Time एक इंटरफ़ेस है
flag.Value , जो आपको यह वर्णन करने की अनुमति देता है flag.Value पैरामीटर से मान flag.Value प्राप्त करें
स्ट्रिंग प्रतिनिधित्व ।

उदाहरण के लिए, टाइप time.Time का एक पैरामीटर इस तरह लागू किया जा सकता है:

 // TimeValue is an implementation of flag.Value interface. type TimeValue struct { P *time.Time Layout string } func (t *TimeValue) Set(s string) error { v, err := time.Parse(t.Layout, s) if err == nil { (*tP) = v } return err } func (t *TimeValue) String() string { return tPFormat(t.Layout) } 

पैकेज की एक महत्वपूर्ण संपत्ति मानक पुस्तकालय में इसकी उपस्थिति है - flag है
कार्यक्रमों को कॉन्फ़िगर करने का मानक तरीका , जिसका अर्थ है इसकी संभावना
विभिन्न परियोजनाओं और पुस्तकालयों के बीच उपयोग दूसरों की तुलना में अधिक है
समुदाय में पुस्तकालय।

flag इस्तेमाल क्यों नहीं?

यह मुझे लगता है कि अन्य पुस्तकालयों का उपयोग किया जाता है और दो कारणों से मौजूद हैं:

• पैरामीटर न केवल कमांड लाइन से पढ़े जाते हैं
• मैं मापदंडों की संरचना करना चाहता हूं

यदि मापदंडों को पढ़ना, उदाहरण के लिए, फ़ाइलों से, सब कुछ अधिक या कम स्पष्ट है (के बारे में)
यह बाद में), फिर संरचनात्मक मापदंडों के बारे में कुछ शब्द सीधे कहने के लायक है
अब।

मेरी राय में, कॉन्फ़िगरेशन निर्धारित करने का सबसे अच्छा तरीका नहीं है
संरचनाएँ जिनके क्षेत्र अन्य संरचनाएँ हो सकती हैं, जैसे कार्यक्रम
आगे:

 type AppConfig struct { Port int Database struct { Endpoint string Timeout time.Duration } ... } 

और यह मुझे लगता है कि क्यों पुस्तकालयों का उपयोग किया जाता है और मौजूद है
चौखटे जो आपको विन्यास के साथ काम करने की अनुमति देते हैं।

मुझे लगता है कि flag को संरचनात्मक कॉन्फ़िगरेशन क्षमताओं को प्रदान नहीं करना चाहिए।
यह आसानी से कोड की कुछ पंक्तियों (या एक पुस्तकालय) के साथ प्राप्त किया जा सकता है
flagutil , जिसकी चर्चा नीचे की गई है)।

इसके अलावा, यदि आप इसके बारे में सोचते हैं, तो ऐसी संरचना का अस्तित्व एक मजबूत होता है
उपयोग किए गए घटकों के बीच कनेक्टिविटी।

संरचनात्मक विन्यास

विचार संरचना की परवाह किए बिना मापदंडों को परिभाषित करना है
कार्यक्रम और जहाँ तक संभव हो, जहाँ उनका उपयोग किया जाता है - यानी
सीधे पैकेज स्तर पर।

मान लीजिए कि हमारे पास कुछ सेवा के लिए एक ग्राहक कार्यान्वयन है (डेटाबेस,
एपीआई या जो कुछ भी कहा जाता है)

 package yoogle type Config struct { Endpoint string Timeout time.Duration } func New(c *Config) *Client { // ... } 

yoogle.Config संरचना को पॉप्युलेट करने के लिए, हमें एक फ़ंक्शन की आवश्यकता है जो
प्राप्त *flag.FlagSet में संरचना क्षेत्रों को पंजीकृत करता है। *flag.FlagSet ।

इस तरह के एक समारोह yoogle पैकेज yoogle या एक पैकेज में घोषित किया जा सकता है
yooglecfg (तृतीय-पक्ष लाइब्रेरी के मामले में, हम ऐसा फ़ंक्शन लिख सकते हैं
कहीं और):

 package yooglecfg import ( "flag" "app/yoogle" ) func Export(flag *flag.FlagSet) *yoogle.Config { var c yoogle.Config flag.StringVar(&c.Endpoint, "endpoint", "https://example.com", "endpoint for our API", ) flag.DurationVar(&c.Timeout, "timeout", time.Second, "timeout for operations", ) return &c } 

flag पैकेज पर निर्भरता को समाप्त करने के लिए, आप एक इंटरफ़ेस को परिभाषित कर सकते हैं
आवश्यक flag.FlagSet तरीके:

 package yooglecfg import "app/yoogle" type FlagSet interface { StringVar(p *string, name, value, desc string) } func Export(flag FlagSet) *yoogle.Config { var c yoogle.Config flag.StringVar(&c.Endpoint, "endpoint", "https://example.com", "endpoint for our API", ) return &c } 

और अगर कॉन्फ़िगरेशन पैरामीटर मानों (उदाहरण के लिए, मापदंडों के बीच) पर निर्भर करता है
कुछ का एल्गोरिथ्म इंगित किया गया है), फ़ंक्शन yooglecfg.Export() वापस आ सकता है
सभी मानों को पार्स करने के बाद कहा जाने वाला निर्माण कार्य
विन्यास:

 package yooglecfg import "app/yoogle" type FlagSet interface { StringVar(p *string, name, value, desc string) } func Export(flag FlagSet) func() *yoogle.Config { var algorithm string flag.StringVar(&algorithm, "algorithm", "quick", "algorithm used to do something", ) var c yoogle.Config return func() *yoogle.Config { switch algorithm { case "quick": c.Impl = quick.New() case "merge": c.Impl = merge.New() case "bubble": panic(...) } return c } } 

निर्यात फ़ंक्शन आपको संरचना को जाने बिना पैकेज मापदंडों को परिभाषित करने की अनुमति देता है
कार्यक्रम विन्यास और उनके मूल्यों को कैसे प्राप्त करें।

github.com/gobwas/flagutil

हमने एक बड़ी कॉन्फ़िगरेशन संरचना का पता लगाया और हमारे पैरामीटर बनाए
स्वतंत्र, लेकिन यह अभी तक स्पष्ट नहीं है कि उन सभी को एक साथ कैसे लाया जाए और प्राप्त किया जाए
मान।

यह इस समस्या को हल करने के लिए था कि flagutil पैकेज लिखा गया था।

मापदंडों को एक साथ रखना

कार्यक्रम के सभी मापदंडों, इसके पैकेज और तीसरे पक्ष के पुस्तकालयों को उनके उपसर्ग प्राप्त होते हैं
और पैकेज स्तर पर एकत्र किए जाते हैं:

 package main import ( "flag" "app/yoogle" "app/yooglecfg" "github.com/gobwas/flagutil" ) func main() { flags := flag.NewFlagSet("my-app", flag.ExitOnError) var port int flag.IntVar(&port, "port", 4050, "port to bind to", ) var config *yoogle.Config flagutil.Subset(flags, "yoogle", func(sub *flag.FlagSet) { config = yooglecfg.Export(sub) }) } 

flagutil.Subset() फ़ंक्शन एक साधारण काम करता है: यह एक उपसर्ग जोड़ता है
( "yoogle" ) कॉलबैक के अंदर sub में पंजीकृत सभी मापदंडों के लिए।

कार्यक्रम चलाना अब इस तरह दिख सकता है:

 app -port 4050 -yoogle.endpoint https://example.com -yoogle.timeout 10s 

पैरामीटर मान प्राप्त करें

flag.FlagSet अंदर सभी पैरामीटर। flag.FlagSet में flag.FlagSet का कार्यान्वयन होता है। flag.Value ,
जिसमें एक Set(string) error विधि है - अर्थात, यह एक अवसर प्रदान करता है
मान का स्ट्रिंग प्रतिनिधित्व सेट करना।

यह कुंजी-मूल्य जोड़े के रूप में किसी भी स्रोत से मूल्यों को पढ़ने के लिए रहता है और
एक flag.Set(key, value) बनाओ। flag.Set(key, value) कॉल करें।

यह हमें कमांड पैरामीटर के सिंटैक्स का उपयोग नहीं करने का अवसर देता है
flag पैकेज में वर्णित लाइनें। आप तर्कों को किसी भी तरह से,
उदा। पॉज़िक्स प्रोग्राम के तर्कों की तरह।

 package main func main() { flags := flag.NewFlagSet("my-app", flag.ExitOnError) // ... flags.String( "config", "/etc/app/config.json", "path to configuration file", ) flagutil.Parse(flags, // First, use posix arguments syntax instead of `flag`. // Just to illustrate that it is possible. flagutil.WithParser(&pargs.Parser{ Args: os.Args[1:], }), // Then lookup for "config" flag value and try to // parse its value as a json configuration file. flagutil.WithParser(&file.Parser{ PathFlag: "config", Syntax: &json.Syntax{}, }), ) } 

तदनुसार, config.json फ़ाइल इस तरह दिख सकती है:

 { "port": 4050, "yoogle": { "endpoint": "https://example.com", "timeout": "10s" ... } } 

निष्कर्ष

बेशक, मैं इस तरह के दृष्टिकोण की बात करने वाला पहला व्यक्ति नहीं हूं। बहुत से
ऊपर वर्णित विचार पहले से ही एक तरह से या किसी और कई साल पहले, जब इस्तेमाल किया गया था
मैंने MailRu में काम किया।

तो, हमारे आवेदन के विन्यास को आसान बनाने के लिए और समय बर्बाद न करें
अगले विन्यास ढांचे का अध्ययन (या यहां तक ​​कि लेखन) प्रस्तावित है
निम्नलिखित:

• flag उपयोग पैरामीटर परिभाषा इंटरफ़ेस के रूप में करें
  कार्यक्रम
• संरचना के ज्ञान के बिना, प्रत्येक पैकेज के मापदंडों को अलग से निर्यात करें और
  बाद में मान प्राप्त करने का एक तरीका
• मान, उपसर्ग और कॉन्फ़िगरेशन संरचना को main से पढ़ने का तरीका निर्धारित करें

flagutil लाइब्रेरी मेरे परिचित flagutil लाइब्रेरी से flagutil
पीटरबर्गबर्ग / एफएफ - और मैं flagutil नहीं flagutil , अगर कुछ के लिए नहीं
उपयोग में विसंगतियां।

आपका ध्यान के लिए धन्यवाद!

संदर्भ

• लेख का अंग्रेजी संस्करण
• golang.org/pkg/flag
• github.com/gobwas/flagutil