🧚🏾 🤟 📉 गो पर एक वेब सेवा लिखना (भाग दो) 💰 👩🏿‍🌾 😖

गो पर एक छोटा, पूर्ण विशेषताओं वाला एप्लिकेशन लिखने के बारे में लेख की निरंतरता।

पहले भाग में, हमने REST API कार्यान्वित किया और आने वाले HTTP अनुरोधों को एकत्र करना सीखा। इस भाग में, हम अपने एप्लिकेशन को परीक्षणों के साथ कवर करेंगे, AngularJS और बूटस्ट्रैप पर आधारित एक सुंदर वेब इंटरफ़ेस जोड़ेंगे, और विभिन्न उपयोगकर्ताओं के लिए एक्सेस प्रतिबंध लागू करेंगे।

इस भाग में, निम्नलिखित चरण हमें इंतजार कर रहे हैं:

चौथा चरण। लेकिन परीक्षणों का क्या?
पांच चरण - अलंकरण और एक वेब इंटरफ़ेस;
चरण छह कुछ गोपनीयता जोड़ें।
सातवां चरण। हम अनावश्यक को साफ करते हैं;
आठ कदम। हम भंडारण के लिए रेडिस का उपयोग करते हैं।

चौथा चरण। लेकिन परीक्षणों का क्या?

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

परीक्षण के साथ काम करने के लिए मूल पैकेज परीक्षण है। यहां दो मुख्य प्रकार सामान्य यूनिट टेस्ट के लिए T और लोड टेस्ट के लिए B । गो में टेस्ट मुख्य पैकेज के रूप में एक ही पैकेज में लिखे गए हैं, जिसमें प्रत्यय _test जोड़ा गया है। इसलिए, पैकेज के अंदर उपलब्ध कोई भी निजी डेटा संरचनाएं परीक्षणों के अंदर भी उपलब्ध हैं (यह भी सच है कि परीक्षणों में एक दूसरे के साथ एक सामान्य वैश्विक गुंजाइश है)। मुख्य कार्यक्रम का संकलन करते समय, परीक्षण फ़ाइलों को अनदेखा किया जाता है।

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

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

चौथे चरण के लिए कोड डाउनलोड करें:

 git checkout step-4

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

 func TestXxx(*testing.T)

हम अपना पहला परीक्षण लिखेंगे, जो बिन वस्तु के सही निर्माण की जाँच करेगा:

 func TestNewBin(t *testing.T) { now := time.Now().Unix() bin := NewBin() if assert.NotNil(t, bin) { assert.Equal(t, len(bin.Name), 6) assert.Equal(t, bin.RequestCount, 0) assert.Equal(t, bin.Created, bin.Updated) assert.True(t, bin.Created < (now+1)) assert.True(t, bin.Created > (now-1)) } }

गवाही में सभी परीक्षण विधियाँ * परीक्षण को स्वीकार करती हैं। पहला पैरामीटर के रूप में ऑब्जेक्ट।
अगला, हम सभी परिदृश्यों का परीक्षण करते हैं, गलत रास्तों और सीमा मूल्यों को नहीं भूलते हैं। मैं लेख के सभी परीक्षणों के कोड का हवाला नहीं दूंगा, क्योंकि उनमें से बहुत सारे हैं, और आप रिपॉजिटरी में उनके साथ खुद को परिचित कर सकते हैं, मैं केवल सबसे दिलचस्प बिंदुओं का उल्लेख करूंगा।

Api_test.go फ़ाइल पर ध्यान दें, इसमें हम अपने REST API का परीक्षण करते हैं। हमारे डेटा के भंडारण कार्यान्वयन पर निर्भर नहीं होने के लिए, हम एक नकली वस्तु जोड़ते हैं जो स्टोरेज इंटरफेस के व्यवहार को लागू करती है। हम नकली पैकेज की गवाही देते हुए इसका उपयोग करते हैं। यह आसानी से नकली वस्तुओं को लिखने के लिए एक तंत्र प्रदान करता है, जिसका उपयोग परीक्षण लिखने के दौरान वास्तविक वस्तुओं के बजाय किया जा सकता है।

यहाँ उसका कोड है:

 type MockedStorage struct{ mock.Mock } func (s *MockedStorage) CreateBin(_ *Bin) error { args := s.Mock.Called() return args.Error(0) } func (s *MockedStorage) UpdateBin(bin *Bin) error { args := s.Mock.Called(bin) return args.Error(0) } func (s *MockedStorage) LookupBin(name string) (*Bin, error) { args := s.Mock.Called(name) return args.Get(0).(*Bin), args.Error(1) } func (s *MockedStorage) LookupBins(names []string) ([]*Bin, error) { args := s.Mock.Called(names) return args.Get(0).([]*Bin), args.Error(1) } func (s *MockedStorage) LookupRequest(binName, id string) (*Request, error) { args := s.Mock.Called(binName, id) return args.Get(0).(*Request), args.Error(1) } func (s *MockedStorage) CreateRequest(bin *Bin, req *Request) error { args := s.Mock.Called(bin) return args.Error(0) } func (s *MockedStorage) LookupRequests(binName string, from, to int) ([]*Request, error) { args := s.Mock.Called(binName, from, to) return args.Get(0).([]*Request), args.Error(1) }

एपीआई का निर्माण करते समय परीक्षणों में आगे, हम अपनी नकली वस्तु को इंजेक्ट करते हैं:

  req, _ := http.NewRequest("GET", "/api/v1/bins/", nil) api = GetApi() mockedStorage := &MockedStorage{} api.MapTo(mockedStorage, (*Storage)(nil)) res = httptest.NewRecorder() mockedStorage.On("LookupBins", []string{}).Return([]*Bin(nil), errors.New("Storage error")) api.ServeHTTP(res, req) mockedStorage.AssertExpectations(t) if assert.Equal(t, res.Code, 500) { assert.Contains(t, res.Body.String(), "Storage error") }

परीक्षण में, हम मॉक ऑब्जेक्ट के लिए अपेक्षित अनुरोधों और उनके लिए आवश्यक उत्तरों का वर्णन करते हैं। इसलिए, जिस समय हम s.Mock.Called(names) विधि को ऑब्जेक्ट की नकली विधि के अंदर कहते हैं, यह दिए गए मापदंडों के पत्राचार और विधि के नाम को खोजने की कोशिश करता है, और जब हम args.Get (0) वापस आते हैं, तो पहला तर्क रिटर्न में दिया जाता है। , इस मामले में realBin। गेट मेथड के अलावा, जो टाइप इंटरफेस {} का ऑब्जेक्ट लौटाता है, इसमें हेल्पर मेथड्स, स्ट्रिंग, बूल, एरर होते हैं, जो इंटरफेस को हमारी जरूरत के प्रकार में बदल देते हैं। परीक्षण के दौरान हमारे द्वारा सभी अपेक्षित तरीकों को देखने के लिए mockedStorage.AssertExpectations (t) विधि जाँच करता है।

RespptRecorder ऑब्जेक्ट को canptest.NewRecorder में बनाया गया है, यहाँ भी दिलचस्प है, यह ResponseWriter व्यवहार को लागू करता है और हमें अनुरोध डेटा को प्रदर्शित किए बिना कहीं भी अनुमति देता है, यह देखने के लिए कि आखिरकार क्या होगा (प्रतिक्रिया कोड, हेडर और प्रतिक्रिया निकाय)।

परीक्षण चलाने के लिए, आपको कमांड चलाने की आवश्यकता है:

 > go test ./src/skimmer ok _/.../src/skimmer 0.032s

परीक्षण लॉन्च टीम में बड़ी संख्या में झंडे हैं, आप खुद को उनके साथ इस तरह से परिचित कर सकते हैं:

 > go help testflag

आप उनके साथ खेल सकते हैं, लेकिन अब हम निम्नलिखित कमांड में रुचि रखते हैं (गो संस्करण 1.2 के लिए प्रासंगिक):

 > go test ./src/skimmer/ -coverprofile=c.out && go tool cover -html=c.out

यदि यह आपके लिए काम नहीं करता है, तो आपको पहले कवरेज टूल को स्थापित करना पड़ सकता है

 > go get code.google.com/p/go.tools/cmd/cover

यह कमांड परीक्षण चलाता है और c.out फ़ाइल में टेस्ट कवरेज प्रोफाइल को बचाता है, और फिर go tool html संस्करण बनाता है, जो ब्राउज़र में खुलता है।

गो में टेस्ट कवरेज, काफी दिलचस्प तरीके से लागू किया गया। कोड संकलित करने से पहले, स्रोत फ़ाइलों को बदल दिया जाता है, काउंटरों को स्रोत कोड में डाला जाता है। उदाहरण के लिए, ऐसा कोड:
 func Size(a int) string { switch { case a < 0: return "negative" case a == 0: return "zero" } return "enormous" } 
इस में बदल जाता है:
 func Size(a int) string { GoCover.Count[0] = 1 switch { case a < 0: GoCover.Count[2] = 1 return "negative" case a == 0: GoCover.Count[3] = 1 return "zero" } GoCover.Count[1] = 1 return "enormous" } 
यह न केवल कवरेज दिखाना संभव है, बल्कि कोड के प्रत्येक अनुभाग को कितनी बार परीक्षण किया जाता है। हमेशा की तरह, आप प्रलेखन में अधिक पढ़ सकते हैं।

अब जब हमारे पास एक पूर्ण REST API है, और परीक्षणों से आच्छादित है, तो आप वेब इंटरफ़ेस को अलंकृत करना और बनाना शुरू कर सकते हैं।

पांच चरण - सजावट और वेब इंटरफ़ेस।

Html टेम्पलेट के साथ काम करने के लिए गो पैकेज में एक पूरी लाइब्रेरी है, लेकिन हम एक तथाकथित सिंगल-पेज एप्लिकेशन बनाएंगे जो सीधे जावास्क्रिप्ट के माध्यम से एपीआई के साथ काम करता है। इस AngularJS के साथ हमारी मदद करें।

नए चरण के लिए कोड अपडेट करना:

 > git checkout step-5

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

मुख्य पृष्ठ प्रदर्शित करने के लिए, हम एक अलग हैंडलर जोड़ेंगे:

  api.Get("**", func(r render.Render){ r.HTML(200, "index", nil) })

ग्लोब ** अक्षर कहते हैं कि किसी भी पते के लिए एक index.html फ़ाइल वापस कर दी जाएगी। सही तरीके से टेम्प्लेट के साथ काम करने के लिए, हमने एक रेंडरर बनाते समय विकल्प जोड़े जो यह दर्शाता है कि टेम्प्लेट कहाँ से प्राप्त करें। प्लस, ताकि कोणीय टेम्पलेट्स के साथ कोई संघर्ष न हो, {{}} से {[{}]} पर पुन: असाइन करें।

  api.Use(render.Renderer(render.Options{ Directory: "public/static/views", Extensions: []string{".html"}, Delims: render.Delims{"{[{", "}]}"}, }))

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

 type Bin struct { ... Color [3]byte `json:"color"` Favicon string `json:"favicon"` } func NewBin() *Bin { color:= RandomColor() bin := Bin{ ... Color: color, Favicon: Solid16x16gifDatauri(color), } ... }

अब हमारे पास लगभग पूर्ण विशेषताओं वाला वेब अनुप्रयोग है, आप इसे चला सकते हैं:

 > go run ./src/main.go

और ब्राउज़र में खोलें ( 127.0.0.1:3000 127.0.0.1:3000 ) के आसपास खेलने के लिए।

दुर्भाग्य से, एप्लिकेशन को अभी भी दो समस्याएं हैं: कार्यक्रम समाप्त होने के बाद, सभी डेटा खो जाता है और हम उपयोगकर्ताओं के बीच कोई अलगाव नहीं करते हैं, हर कोई एक ही चीज देखता है। अच्छा, चलो करते हैं।

चरण छह कुछ गोपनीयता जोड़ें।

छठे चरण के लिए कोड डाउनलोड करें:

 > git checkout step-6

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

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

यह हमें गोरिल्ला में पहले से लागू रिपॉजिटरी का उपयोग करने की अनुमति देता है। हमारा कुकी आधारित होगा।

एक सत्र भंडार बनाएँ:

 func GetApi(config *Config) *martini.ClassicMartini { ... store := sessions.NewCookieStore([]byte(config.SessionSecret)) ...

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

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

हमारे एपीआई में एक मध्यवर्ती हैंडलर जोड़ें जो सत्रों के साथ काम जोड़ता है:

 // Sessions is a Middleware that maps a session.Session service into the Martini handler chain. // Sessions can use a number of storage solutions with the given store. func Sessions(name string, store Store) martini.Handler { return func(res http.ResponseWriter, r *http.Request, c martini.Context, l *log.Logger) { // Map to the Session interface s := &session{name, r, l, store, nil, false} c.MapTo(s, (*Session)(nil)) // Use before hook to save out the session rw := res.(martini.ResponseWriter) rw.Before(func(martini.ResponseWriter) { if s.Written() { check(s.Session().Save(r, res), l) } }) ... c.Next() } }

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

अब हम अपने इतिहास (जो सिर्फ एक टुकड़ा हुआ करता था) को फिर से लिखते हैं, history.go file:

 type History interface { All() []string Add(string) } type SessionHistory struct { size int name string session sessions.Session data []string } func (history *SessionHistory) All() []string { if history.data == nil { history.load() } return history.data } func (history *SessionHistory) Add(name string) { if history.data == nil { history.load() } history.data = append(history.data, "") copy(history.data[1:], history.data) history.data[0] = name history.save() } func (history *SessionHistory) save() { size := history.size if size > len(history.data){ size = len(history.data) } history.session.Set(history.name, history.data[:size]) } func (history *SessionHistory) load() { sessionValue := history.session.Get(history.name) history.data = []string{} if sessionValue != nil { if values, ok := sessionValue.([]string); ok { history.data = append(history.data, values...) } } } func NewSessionHistoryHandler(size int, name string) martini.Handler { return func(c martini.Context, session sessions.Session) { history := &SessionHistory{size: size, name: name, session: session} c.MapTo(history, (*History)(nil)) } }

NewSessionHistoryHandler विधि में, हम एक SessionHistory ऑब्जेक्ट बनाते हैं जो इतिहास इंटरफ़ेस (सभी इतिहास ऑब्जेक्ट के जोड़ और क्वेरी का वर्णन करते हुए) को लागू करता है, और फिर इसे प्रत्येक अनुरोध के संदर्भ में जोड़ देता है। SessionHistory ऑब्जेक्ट में सहायक तरीके लोड और सेव होते हैं, जो सत्र में डेटा को लोड और सेव करते हैं। इसके अलावा, सत्र से डेटा डाउनलोड करना केवल मांग पर किया जाता है। अब, सभी एपीआई विधियों में जहां इतिहास टुकड़ा पहले इस्तेमाल किया गया था, इतिहास प्रकार की एक नई वस्तु का उपयोग किया जाएगा।

इस क्षण से, प्रत्येक उपयोगकर्ता का बिन वस्तुओं का अपना इतिहास होगा, लेकिन एक सीधा लिंक के माध्यम से हम अभी भी किसी भी बिन को देख सकते हैं। हम इसे निजी बिन ऑब्जेक्ट बनाने की क्षमता जोड़कर ठीक करेंगे।

चलो बिन में दो नए क्षेत्र बनाते हैं:

 type Bin struct { ... Private bool `json:"private"` SecretKey string `json:"-"` }

सीक्रेटके फील्ड में एक कुंजी संग्रहीत की जाएगी, जो निजी बिन तक पहुंच प्रदान करती है (जहां निजी ध्वज सही पर सेट है)। वह विधि जोड़ें जो हमारी वस्तु को निजी बनाती है:

 func (bin *Bin) SetPrivate() { bin.Private = true bin.SecretKey = rs.Generate(32) }

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

 func DecodeJsonPayload(r *http.Request, v interface{}) error { content, err := ioutil.ReadAll(r.Body) r.Body.Close() if err != nil { return err } err = json.Unmarshal(content, v) if err != nil { return err } return nil }

अब हम नए व्यवहार को लागू करने के लिए एपीआई को संशोधित करेंगे:

  api.Post("/api/v1/bins/", func(r render.Render, storage Storage, history History, session sessions.Session, req *http.Request){ payload := Bin{} if err := DecodeJsonPayload(req, &payload); err != nil { r.JSON(400, ErrorMsg{fmt.Sprintf("Decoding payload error: %s", err)}) return } bin := NewBin() if payload.Private { bin.SetPrivate() } if err := storage.CreateBin(bin); err == nil { history.Add(bin.Name) if bin.Private { session.Set(fmt.Sprintf("pr_%s", bin.Name), bin.SecretKey) } r.JSON(http.StatusCreated, bin) } else { r.JSON(http.StatusInternalServerError, ErrorMsg{err.Error()}) } })

सबसे पहले, हम प्रकार बिन के एक पेलोड ऑब्जेक्ट बनाते हैं, जिनमें से फ़ील्ड अनुरोध बॉडी से DecodeJsonPayload फ़ंक्शन में मानों से भरे होंगे। उसके बाद, यदि विकल्प "निजी" इनपुट में सेट है, तो हम अपने बिन को निजी बनाते हैं। इसके अलावा, निजी वस्तुओं के लिए, हम सत्र सत्र में प्रमुख मूल्य को session.Set(fmt.Sprintf("pr_%s", bin.Name), bin.SecretKey) । अब हमें अन्य एपीआई विधियों को बदलने की आवश्यकता है ताकि वे निजी बिन वस्तुओं के लिए सत्र में कुंजी के अस्तित्व की जांच करें।

यह इस प्रकार किया जाता है:

  api.Get("/api/v1/bins/:bin", func(r render.Render, params martini.Params, session sessions.Session, storage Storage){ if bin, err := storage.LookupBin(params["bin"]); err == nil{ if bin.Private && bin.SecretKey != session.Get(fmt.Sprintf("pr_%s", bin.Name)){ r.JSON(http.StatusForbidden, ErrorMsg{"The bin is private"}) } else { r.JSON(http.StatusOK, bin) } } else { r.JSON(http.StatusNotFound, ErrorMsg{err.Error()}) } })

सादृश्य द्वारा, अन्य तरीकों से किया जाता है। नए व्यवहार को ध्यान में रखने के लिए कुछ परीक्षण भी निर्धारित किए गए थे, कोड में विशिष्ट परिवर्तन देखे जा सकते हैं।

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

सब कुछ ठीक है, लेकिन अब हमारे भंडारण में सभी ऑब्जेक्ट लगभग हमेशा के लिए रहते हैं, जो शायद सही नहीं है, क्योंकि कोई शाश्वत स्मृति नहीं हो सकती है, इसलिए हम उनके जीवन के समय को सीमित करने का प्रयास करेंगे।

सातवां चरण। हम अनावश्यक साफ करते हैं।

सातवां चरण कोड डाउनलोड करें:

 git checkout step-7

आधार संग्रहण संरचना में एक और फ़ील्ड जोड़ें:

 type BaseStorage struct { ... binLifetime int64 }

यह बिन ऑब्जेक्ट और संबंधित प्रश्नों के अधिकतम जीवनकाल को संग्रहीत करेगा। अब हम मेमोरी में अपने स्टोरेज को फिर से लिखते हैं - memory.go। बिनलाइन लाइफटाइम सेकंड से अधिक के लिए अपडेट नहीं किए गए सभी बिनकार्ड को साफ़ करने की मुख्य विधि:

 func (storage *MemoryStorage) clean() { storage.Lock() defer storage.Unlock() now := time.Now().Unix() for name, binRecord := range storage.binRecords { if binRecord.bin.Updated < (now - storage.binLifetime) { delete(storage.binRecords, name) } } }

हम इसके साथ मेमोरीस्टेज प्रकार में काम करने के लिए एक टाइमर और तरीके भी जोड़ते हैं:

 type MemoryStorage struct { ... cleanTimer *time.Timer } func (storage *MemoryStorage) StartCleaning(timeout int) { defer func(){ storage.cleanTimer = time.AfterFunc(time.Duration(timeout) * time.Second, func(){storage.StartCleaning(timeout)}) }() storage.clean() } func (storage *MemoryStorage) StopCleaning() { if storage.cleanTimer != nil { storage.cleanTimer.Stop() } }

पैकेज विधि समय AfterFunc एक अलग गोरोइन में निर्दिष्ट फ़ंक्शन शुरू करता है (यह मापदंडों के बिना होना चाहिए, इसलिए, हम टाइमआउट पास करने के लिए यहां क्लोजर का उपयोग करेंगे), जैसे समय समाप्त होने के बाद। पहला तर्क में पारित।

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

चरण आठ। हम भंडारण के लिए रेडिस का उपयोग करते हैं।

आधिकारिक Redis प्रलेखन गो के लिए ग्राहकों की एक विस्तृत सूची पर हमें सलाह देता है। लेखन के समय, अनुशंसित मूलांक और रेडिगो हैं । हम रेडिगो का चयन करेंगे, क्योंकि यह सक्रिय रूप से विकसित हो रहा है और इसमें एक बड़ा समुदाय है।

चलो वांछित कोड पर चलते हैं:

 git checkout step-8

Redis.go फ़ाइल पर एक नज़र डालें, और यह Redis के लिए संग्रहण का हमारा कार्यान्वयन होगा। मूल संरचना काफी सरल है:

 type RedisStorage struct { BaseStorage pool *redis.Pool prefix string cleanTimer *time.Timer }

पूल में, मूली के लिए कनेक्शन के पूल को उपसर्ग में संग्रहीत किया जाएगा - सभी कुंजी के लिए सामान्य उपसर्ग। एक पूल बनाने के लिए, redigo उदाहरणों से कोड लें:

 func getPool(server string, password string) (pool *redis.Pool) { pool = &redis.Pool{ MaxIdle: 3, IdleTimeout: 240 * time.Second, Dial: func() (redis.Conn, error) { c, err := redis.Dial("tcp", server) if err != nil { return nil, err } if password != "" { if _, err := c.Do("AUTH", password); err != nil { c.Close() return nil, err } } return c, err }, TestOnBorrow: func(c redis.Conn, _ time.Time) error { _, err := c.Do("PING") return err }, } return pool }

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

पैकेज में भी हमने कई स्थिरांक घोषित किए हैं:

 const ( KEY_SEPARATOR = "|" //   BIN_KEY = "bins" //     Bin REQUESTS_KEY = "rq" //      REQUEST_HASH_KEY = "rhsh" //        CLEANING_SET = "cln" // ,      Bin   CLEANING_FACTOR = 3 //      )

हमें इस पैटर्न के अनुसार कुंजियाँ मिलती हैं:

 func (storage *RedisStorage) getKey(keys ...string) string { return fmt.Sprintf("%s%s%s", storage.prefix, KEY_SEPARATOR, strings.Join(keys, KEY_SEPARATOR)) }

हमारे डेटा को मूली में संग्रहीत करने के लिए, उन्हें कुछ के साथ क्रमबद्ध करने की आवश्यकता है। हम लोकप्रिय msgpack प्रारूप का चयन करेंगे और लोकप्रिय कोडेक लाइब्रेरी का उपयोग करेंगे।

हम उन तरीकों का वर्णन करते हैं जो बाइनरी डेटा में संभव है और इसके विपरीत सब कुछ को क्रमबद्ध करते हैं:

 func (storage *RedisStorage) Dump(v interface{}) (data []byte, err error) { var ( mh codec.MsgpackHandle h = &mh ) err = codec.NewEncoderBytes(&data, h).Encode(v) return } func (storage *RedisStorage) Load(data []byte, v interface{}) error { var ( mh codec.MsgpackHandle h = &mh ) return codec.NewDecoderBytes(data, h).Decode(v) }

अब हम अन्य विधियों का वर्णन करते हैं।

एक बिन वस्तु का निर्माण

 func (storage *RedisStorage) UpdateBin(bin *Bin) (err error) { dumpedBin, err := storage.Dump(bin) if err != nil { return } conn := storage.pool.Get() defer conn.Close() key := storage.getKey(BIN_KEY, bin.Name) conn.Send("SET", key, dumpedBin) conn.Send("EXPIRE", key, storage.binLifetime) conn.Flush() return err } func (storage *RedisStorage) CreateBin(bin *Bin) error { if err := storage.UpdateBin(bin); err != nil { return err } return nil }

सबसे पहले, हम डंप विधि का उपयोग करके बिन को क्रमबद्ध करते हैं। फिर हम पूल से मूली यौगिक लेते हैं (यह भूलकर कि इसे defer का उपयोग करके वापस किया जाना चाहिए)।

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

हम अपने नाम से बिन के डेटा को बचाने के लिए दो आदेश, "सेट" भेजते हैं और इस रिकॉर्ड के जीवनकाल को निर्धारित करने की समय सीमा समाप्त करते हैं।

बिन वस्तु पाना

 func (storage *RedisStorage) LookupBin(name string) (bin *Bin, err error) { conn := storage.pool.Get() defer conn.Close() reply, err := redis.Bytes(conn.Do("GET", storage.getKey(BIN_KEY, name))) if err != nil { if err == redis.ErrNil { err = errors.New("Bin was not found") } return } err = storage.Load(reply, &bin) return }

सहायक विधि redis.Bytes बाइट सरणी में conn.Do से प्रतिक्रिया को पढ़ने की कोशिश करती है। यदि ऑब्जेक्ट नहीं मिला, तो मूली विशेष त्रुटि प्रकार redis.ErrNil वापस कर देगी। यदि सबकुछ ठीक हो गया, तो डेटा को लोड ऑब्जेक्ट के संदर्भ में पारित करके, बिन ऑब्जेक्ट में लोड किया जाता है।

बिन वस्तुओं की सूची प्राप्त करना

 func (storage *RedisStorage) LookupBins(names []string) ([]*Bin, error) { bins := []*Bin{} if len(names) == 0 { return bins, nil } args := redis.Args{} for _, name := range names { args = args.Add(storage.getKey(BIN_KEY, name)) } conn := storage.pool.Get() defer conn.Close() if values, err := redis.Values(conn.Do("MGET", args...)); err == nil { bytes := [][]byte{} if err = redis.ScanSlice(values, &bytes); err != nil { return nil, err } for _, rawbin := range bytes { if len(rawbin) > 0 { bin := &Bin{} if err := storage.Load(rawbin, bin); err == nil { bins = append(bins, bin) } } } return bins, nil } else { return nil, err } }

यहां, लगभग सब कुछ पिछली विधि के समान है, सिवाय इसके कि एमजीईटी कमांड का उपयोग डेटा स्लाइस और रिडिस करने के लिए किया जाता है। स्केन्स्लीस हेल्पर विधि से वांछित प्रकार के स्लाइस में प्रतिक्रिया को लोड करने के लिए।

अनुरोध अनुरोध बनाना

 func (storage *RedisStorage) CreateRequest(bin *Bin, req *Request) (err error) { data, err := storage.Dump(req) if err != nil { return } conn := storage.pool.Get() defer conn.Close() key := storage.getKey(REQUESTS_KEY, bin.Name) conn.Send("LPUSH", key, req.Id) conn.Send("EXPIRE", key, storage.binLifetime) key = storage.getKey(REQUEST_HASH_KEY, bin.Name) conn.Send("HSET", key, req.Id, data) conn.Send("EXPIRE", key, storage.binLifetime) conn.Flush() requestCount, err := redis.Int(conn.Receive()) if err != nil { return } if requestCount < storage.maxRequests { bin.RequestCount = requestCount } else { bin.RequestCount = storage.maxRequests } bin.Updated = time.Now().Unix() if requestCount > storage.maxRequests * CLEANING_FACTOR { conn.Do("SADD", storage.getKey(CLEANING_SET), bin.Name) } if err = storage.UpdateBin(bin); err != nil { return } return }

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

बिन वस्तुओं के साथ सादृश्य द्वारा अनुरोध की प्राप्ति और अनुरोधों की सूची तैयार की जाती है।

सफाई

 func (storage *RedisStorage) clean() { for { conn := storage.pool.Get() defer conn.Close() binName, err := redis.String(conn.Do("SPOP", storage.getKey(CLEANING_SET))) if err != nil { break } conn.Send("LRANGE", storage.getKey(REQUESTS_KEY, binName), storage.maxRequests, -1) conn.Send("LTRIM", storage.getKey(REQUESTS_KEY, binName), 0, storage.maxRequests-1) conn.Flush() if values, error := redis.Values(conn.Receive()); error == nil { ids := []string{} if err := redis.ScanSlice(values, &ids); err != nil { continue } if len(ids) > 0 { args := redis.Args{}.Add(storage.getKey(REQUEST_HASH_KEY, binName)).AddFlat(ids) conn.Do("HDEL", args...) } } } }

मेमोरीस्टोरेज के विपरीत, यहां हम निरर्थक अनुरोधों को स्पष्ट करते हैं, क्योंकि जीवनकाल EXPIRE मूली कमांड द्वारा सीमित है। सबसे पहले, हम सफाई के लिए सूची से एक आइटम लेते हैं, इसके लिए अनुरोधकर्ताओं के पहचानकर्ता से अनुरोध करते हैं, जो सीमा में शामिल नहीं हैं, और सूची को जिस आकार की आवश्यकता है, उसे संपीड़ित करने के लिए LTRIM कमांड का उपयोग करें। हम HDEL कमांड का उपयोग करके पहले से प्राप्त पहचानकर्ताओं को हैश टेबल से हटा देते हैं, जो एक ही बार में कई कुंजी स्वीकार करता है।

हमने रेडिसस्टोरी का वर्णन करना समाप्त कर दिया है, इसके आगे, redis_test.go फ़ाइल में आपको समान परीक्षण मिलेंगे।

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

 type RedisConfig struct { RedisAddr string RedisPassword string RedisPrefix string } type Config struct { ... Storage string RedisConfig } func GetApi(config *Config) *martini.ClassicMartini { var storage Storage switch config.Storage{ case "redis": redisStorage := NewRedisStorage(config.RedisAddr, config.RedisPassword, config.RedisPassword, MAX_REQUEST_COUNT, BIN_LIFETIME) redisStorage.StartCleaning(60) storage = redisStorage default: memoryStorage := NewMemoryStorage(MAX_REQUEST_COUNT, BIN_LIFETIME) memoryStorage.StartCleaning(60) storage = memoryStorage } ...

हमने अपनी कॉन्फ़िगरेशन संरचना में एक नया संग्रहण फ़ील्ड जोड़ा और इसके आधार पर, RedisStorage या MemoryStorage को प्रारंभ करते हुए। विशिष्ट मूली विकल्पों के लिए RedisConfig कॉन्फ़िगरेशन भी जोड़ा।

हम लॉन्च की जा रही main.go फाइल में भी बदलाव करते हैं:

 import ( "skimmer" "flag" ) var ( config = skimmer.Config{ SessionSecret: "secret123", RedisConfig: skimmer.RedisConfig{ RedisAddr: "127.0.0.1:6379", RedisPassword: "", RedisPrefix: "skimmer", }, } ) func init() { flag.StringVar(&config.Storage, "storage", "memory", "available storages: redis, memory") flag.StringVar(&config.SessionSecret, "sessionSecret", config.SessionSecret, "") flag.StringVar(&config.RedisAddr, "redisAddr", config.RedisAddr, "redis storage only") flag.StringVar(&config.RedisPassword, "redisPassword", config.RedisPassword, "redis storage only") flag.StringVar(&config.RedisPrefix, "redisPrefix", config.RedisPrefix, "redis storage only") } func main() { flag.Parse() api := skimmer.GetApi(&config) api.Run() }

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

इनिट फ़ंक्शन गो के लिए विशेष है; पैकेज लोड होने पर इसे हमेशा निष्पादित किया जाता है। गो में चल रहे कार्यक्रमों के बारे में अधिक जानें ।

अब --हेल्प विकल्प के साथ अपना प्रोग्राम शुरू करके, हम उपलब्ध विकल्पों की एक सूची देखेंगे:

 > go run ./src/main.go --help Usage of .../main: -redisAddr="127.0.0.1:6379": redis storage only -redisPassword="": redis storage only -redisPrefix="skimmer": redis storage only -sessionSecret="secret123": -storage="memory": available storages: redis, memory

अब हमारे पास एक ऐसा एप्लिकेशन है जो अभी भी काफी कच्चा है, और अनुकूलित नहीं है, लेकिन सर्वर पर काम करने और चलाने के लिए तैयार है।

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

मुझे लेख के किसी भी सुधार और सुझाव पर खुशी होगी।

गो पर एक वेब सेवा लिखना (भाग दो)