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

ट्रेनिंग

git clone https://github.com/m0sth8/skimmer ./skimmer 

 go get -d ./src/ 

 go run ./src/main.go 

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

पहला कदम। पेश है मार्टिनी।

 git checkout step-1 

 // Martini represents the top level web application. inject.Injector methods can be invoked to map services on a global level. type Martini struct { inject.Injector handlers []Handler action Handler logger *log.Logger } 

 // Classic creates a classic Martini with some basic default middleware - martini.Logger, martini.Recovery, and martini.Static. func Classic() *ClassicMartini { r := NewRouter() m := New() m.Use(Logger()) m.Use(Recovery()) m.Use(Static("public")) m.Action(r.Handle) return &ClassicMartini{m, r} } 

 type Router interface { // Get adds a route for a HTTP GET request to the specified matching pattern. Get(string, ...Handler) Route // Patch adds a route for a HTTP PATCH request to the specified matching pattern. Patch(string, ...Handler) Route // Post adds a route for a HTTP POST request to the specified matching pattern. Post(string, ...Handler) Route // Put adds a route for a HTTP PUT request to the specified matching pattern. Put(string, ...Handler) Route // Delete adds a route for a HTTP DELETE request to the specified matching pattern. Delete(string, ...Handler) Route // Options adds a route for a HTTP OPTIONS request to the specified matching pattern. Options(string, ...Handler) Route // Any adds a route for any HTTP method request to the specified matching pattern. Any(string, ...Handler) Route // NotFound sets the handlers that are called when a no route matches a request. Throws a basic 404 by default. NotFound(...Handler) // Handle is the entry point for routing. This is used as a martini.Handler Handle(http.ResponseWriter, *http.Request, Context) } 

 func main() { api := martini.Classic() api.Any("/", func(res http.ResponseWriter, req *http.Request,) { if dumped, err := httputil.DumpRequest(req, true); err == nil { res.WriteHeader(200) res.Write(dumped) } else { res.WriteHeader(500) fmt.Fprintf(res, "Error: %v", err) } }) api.Run() } 

 go run ./src/main.go 

 > curl -X POST -d "fizz=buzz" http://127.0.0.1:3000 POST / HTTP/1.1 Host: 127.0.0.1:3000 Accept: */* Content-Type: application/x-www-form-urlencoded User-Agent: curl/7.24.0 (x86_64-apple-darwin12.0) libcurl/7.24.0 OpenSSL/0.9.8y zlib/1.2.5 fizz=buzz 

चरण दो हम बिन मॉडल बनाते हैं और अनुरोधों का जवाब देते हैं।

 git checkout step-2 

संरचना में फ़ील्ड का क्रम काफी महत्वपूर्ण है, लेकिन हम इसके बारे में नहीं सोचते हैं, लेकिन जो लोग जानना चाहते हैं कि ऑर्डर मेमोरी में संरचना के आकार को कैसे प्रभावित करता है, वे इन लेखों को पढ़ सकते हैं - www.goinggo.net/2013/07/understanding-type-in -go.html और www.geeksforgeeks.org/structure-member-alignment-padding-and-data-packing ।

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

 package main import ( "reflect" "fmt" ) type Bin struct { Name string `json:"name"` } func main() { bin := Bin{} bt := reflect.TypeOf(bin) field := bt.Field(0) fmt.Printf("Field's '%s' json name is '%s'", field.Name, field.Tag.Get("json")) } 

उत्पादन करेगा
Field's 'Name' json name is 'name'

एन्कोडिंग / json पैकेज टैगिंग के लिए विभिन्न विकल्पों का समर्थन करता है:

 //   Field int `json:"-"` //  json     myName Field int `json:"myName"` 

दूसरा पैरामीटर हो सकता है, उदाहरण के लिए, omitempty विकल्प - यदि मान में मान छोड़ा जाता है, तो फ़ील्ड नहीं भरा जाता है। इसलिए, उदाहरण के लिए, यदि फ़ील्ड एक लिंक है, तो हम यह पता लगा सकते हैं कि क्या यह शून्य ऑब्जेक्ट के साथ तुलना में मौजूद है। आप डॉक्यूमेंटेशन में json serialization के बारे में अधिक पढ़ सकते हैं ।

 type Bin struct { Name string `json:"name"` Created int64 `json:"created"` Updated int64 `json:"updated"` RequestCount int `json:"requestCount"` } func NewBin() *Bin { now := time.Now().Unix() bin := Bin{ Created: now, Updated: now, Name: rs.Generate(6), } return &bin } 

गो में संरचनाएं दो तरीकों से आरंभ की जा सकती हैं:

1) क्रम में सभी क्षेत्रों की अनिवार्य सूची:

 Bin{rs.Generate(6), now, now, 0} 

2) उन क्षेत्रों का संकेत जिनके लिए मान असाइन किए गए हैं:

 Bin{ Created: now, Updated: now, Name: rs.Generate(6), } 

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

 var rs = NewRandomString("0123456789abcdefghijklmnopqrstuvwxyz") 

 type RandomString struct { pool string rg *rand.Rand } func NewRandomString(pool string) *RandomString { return &RandomString{ pool, rand.New(rand.NewSource(time.Now().Unix())), } } func (rs *RandomString) Generate(length int) (r string) { if length < 1 { return } b := make([]byte, length) for i, _ := range b { b[i] = rs.pool[rs.rg.Intn(len(rs.pool))] } r = string(b) return } 

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

  api.Post("/api/v1/bins/", func(r render.Render){ bin := NewBin() bins[bin.Name] = bin history = append(history, bin.Name) r.JSON(http.StatusCreated, bin) }) 

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

  api.Get("/api/v1/bins/", func(r render.Render){ filteredBins := []*Bin{} for _, name := range(history) { if bin, ok := bins[name]; ok { filteredBins = append(filteredBins, bin) } } r.JSON(http.StatusOK, filteredBins) }) 

एक विशिष्ट उदाहरण प्राप्त करना

  api.Get("/api/v1/bins/:bin", func(r render.Render, params martini.Params){ if bin, ok := bins[params["bin"]]; ok{ r.JSON(http.StatusOK, bin) } else { r.Error(http.StatusNotFound) } }) 

गो में, हम एक शब्दकोश तत्व को दो तरीकों से एक्सेस कर सकते हैं:

1. कुंजी मूल्य का अनुरोध करने के बाद a := m[key] , इस मामले में या तो शब्दकोश में मुख्य मूल्य, यदि कोई हो, या डिफ़ॉल्ट मूल्य आरंभीकरण मूल्य वापस आ जाएगा। इस प्रकार, उदाहरण के लिए, संख्याओं के लिए, यह समझना मुश्किल है कि क्या कुंजी में 0 है या बस इस कुंजी का मान मौजूद नहीं है। इसलिए, गो के लिए दूसरा विकल्प प्रदान किया जाता है।
2. इस विधि में, कुंजी का अनुरोध करना और पहले पैरामीटर के रूप में उसका मूल्य प्राप्त करना और दूसरे पैरामीटर के रूप में इस कुंजी के अस्तित्व का सूचक - a, ok := m[key]

 go run ./src/main.go 

 > curl -i -X POST "127.0.0.1:3000/api/v1/bins/" HTTP/1.1 201 Created Content-Type: application/json; charset=UTF-8 Date: Mon, 03 Mar 2014 04:10:38 GMT Content-Length: 76 {"name":"7xpogf","created":1393819838,"updated":1393819838,"requestCount":0} 

 > curl -i "127.0.0.1:3000/api/v1/bins/" HTTP/1.1 200 OK Content-Type: application/json; charset=UTF-8 Date: Mon, 03 Mar 2014 04:11:18 GMT Content-Length: 78 [{"name":"7xpogf","created":1393819838,"updated":1393819838,"requestCount":0}] 

 curl -i "127.0.0.1:3000/api/v1/bins/7xpogf" HTTP/1.1 200 OK Content-Type: application/json; charset=UTF-8 Date: Mon, 03 Mar 2014 04:12:13 GMT Content-Length: 76 {"name":"7xpogf","created":1393819838,"updated":1393819838,"requestCount":0} 

चरण तीन हम अनुरोधों को स्वीकार करते हैं और उन्हें भंडार में सहेजते हैं।

 git checkout step-3 

अनुरोध मॉडल

 type Request struct { Id string `json:"id"` Created int64 `json:"created"` Method string `json:"method"` // GET, POST, PUT, etc. Proto string `json:"proto"` // "HTTP/1.0" Header http.Header `json:"header"` ContentLength int64 `json:"contentLength"` RemoteAddr string `json:"remoteAddr"` Host string `json:"host"` RequestURI string `json:"requestURI"` Body string `json:"body"` FormValue map[string][]string `json:"formValue"` FormFile []string `json:"formFile"` } 

 func NewRequest(httpRequest *http.Request, maxBodySize int) *Request { var ( bodyValue string formValue map[string][]string formFile []string ) //             if body, err := ioutil.ReadAll(httpRequest.Body); err == nil { if len(body) > 0 && maxBodySize != 0 { if maxBodySize == -1 || httpRequest.ContentLength < int64(maxBodySize) { bodyValue = string(body) } else { bodyValue = fmt.Sprintf("%s\n<<<TRUNCATED , %d of %d", string(body[0:maxBodySize]), maxBodySize, httpRequest.ContentLength) } } httpRequest.Body = ioutil.NopCloser(bytes.NewBuffer(body)) defer httpRequest.Body.Close() } httpRequest.ParseMultipartForm(0) if httpRequest.MultipartForm != nil { formValue = httpRequest.MultipartForm.Value for key := range httpRequest.MultipartForm.File { formFile = append(formFile, key) } } else { formValue = httpRequest.PostForm } request := Request{ Id: rs.Generate(12), Created: time.Now().Unix(), Method: httpRequest.Method, Proto: httpRequest.Proto, Host: httpRequest.Host, Header: httpRequest.Header, ContentLength: httpRequest.ContentLength, RemoteAddr: httpRequest.RemoteAddr, RequestURI: httpRequest.RequestURI, FormValue: formValue, FormFile: formFile, Body: bodyValue, } return &request } 

 type Storage interface { LookupBin(name string) (*Bin, error) // get one bin element by name LookupBins(names []string) ([]*Bin, error) // get slice of bin elements LookupRequest(binName, id string) (*Request, error) // get request from bin by id LookupRequests(binName string, from, to int) ([]*Request, error) // get slice of requests from bin by position CreateBin(bin *Bin) error // create bin in memory storage UpdateBin(bin *Bin) error // save CreateRequest(bin *Bin, req *Request) error } 

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

 type BaseStorage struct { maxRequests int } 

 type MemoryStorage struct { BaseStorage sync.RWMutex binRecords map[string]*BinRecord } 

बेनामी क्षेत्र हमें सीधे गुमनाम संरचनाओं के तरीकों और क्षेत्रों को कॉल करने की क्षमता प्रदान करते हैं। उदाहरण के लिए, यदि हमारे पास मेमोरीस्टोरीज का एक ओब्जेक्ट वेरिएबल है, तो हम सीधे maxjequests फ़ील्ड का उपयोग कर सकते हैं obj.BaseStorage.maxRequests, या मानो वे MemoryStorage obj.maxRequest के सदस्य हैं। प्रलेखन में डेटा संरचनाओं में अनाम फ़ील्ड के बारे में और पढ़ें।

 type BinRecord struct { bin *Bin requests []*Request requestMap map[string]*Request } 

वर्तमान कार्यान्वयन में शब्दकोश में शब्दकोश तालिका का एक हैश है, इसलिए शब्दकोश में एक तत्व की खोज का एक निरंतर मूल्य है। इस खूबसूरत लेख में आंतरिक उपकरण के बारे में और पढ़ें।

 func (binRecord *BinRecord) ShrinkRequests(size int) { if size > 0 && len(binRecord.requests) > size { requests := binRecord.requests lenDiff := len(requests) - size removed := requests[:lenDiff] for _, removedReq := range removed { delete(binRecord.requestMap, removedReq.Id) } requests = requests[lenDiff:] binRecord.requests = requests } } 

 package skimmer import ( "errors" "sync" ) type MemoryStorage struct { BaseStorage sync.RWMutex binRecords map[string]*BinRecord } type BinRecord struct { bin *Bin requests []*Request requestMap map[string]*Request } func (binRecord *BinRecord) ShrinkRequests(size int) { if size > 0 && len(binRecord.requests) > size { requests := binRecord.requests lenDiff := len(requests) - size removed := requests[:lenDiff] for _, removedReq := range removed { delete(binRecord.requestMap, removedReq.Id) } requests = requests[lenDiff:] binRecord.requests = requests } } func NewMemoryStorage(maxRequests int) *MemoryStorage { return &MemoryStorage{ BaseStorage{ maxRequests: maxRequests, }, sync.RWMutex{}, map[string]*BinRecord{}, } } func (storage *MemoryStorage) getBinRecord(name string) (*BinRecord, error) { storage.RLock() defer storage.RUnlock() if binRecord, ok := storage.binRecords[name]; ok { return binRecord, nil } return nil, errors.New("Bin not found") } func (storage *MemoryStorage) LookupBin(name string) (*Bin, error) { if binRecord, err := storage.getBinRecord(name); err == nil { return binRecord.bin, nil } else { return nil, err } } func (storage *MemoryStorage) LookupBins(names []string) ([]*Bin, error) { bins := []*Bin{} for _, name := range names { if binRecord, err := storage.getBinRecord(name); err == nil { bins = append(bins, binRecord.bin) } } return bins, nil } func (storage *MemoryStorage) CreateBin(bin *Bin) error { storage.Lock() defer storage.Unlock() binRec := BinRecord{bin, []*Request{}, map[string]*Request{}} storage.binRecords[bin.Name] = &binRec return nil } func (storage *MemoryStorage) UpdateBin(_ *Bin) error { return nil } func (storage *MemoryStorage) LookupRequest(binName, id string) (*Request, error) { if binRecord, err := storage.getBinRecord(binName); err == nil { if request, ok := binRecord.requestMap[id]; ok { return request, nil } else { return nil, errors.New("Request not found") } } else { return nil, err } } func (storage *MemoryStorage) LookupRequests(binName string, from int, to int) ([]*Request, error) { if binRecord, err := storage.getBinRecord(binName); err == nil { requestLen := len(binRecord.requests) if to >= requestLen { to = requestLen } if to < 0 { to = 0 } if from < 0 { from = 0 } if from > to { from = to } reversedLen := to - from reversed := make([]*Request, reversedLen) for i, request := range binRecord.requests[from:to] { reversed[reversedLen-i-1] = request } return reversed, nil } else { return nil, err } } func (storage *MemoryStorage) CreateRequest(bin *Bin, req *Request) error { if binRecord, err := storage.getBinRecord(bin.Name); err == nil { storage.Lock() defer storage.Unlock() binRecord.requests = append(binRecord.requests, req) binRecord.requestMap[req.Id] = req binRecord.ShrinkRequests(storage.maxRequests) binRecord.bin.RequestCount = len(binRecord.requests) return nil } else { return err } } 

  memoryStorage := NewMemoryStorage(MAX_REQUEST_COUNT) api.MapTo(memoryStorage, (*Storage)(nil)) 

  api.Post("/api/v1/bins/", func(r render.Render, storage Storage){ bin := NewBin() if err := storage.CreateBin(bin); err == nil { history = append(history, bin.Name) r.JSON(http.StatusCreated, bin) } else { r.JSON(http.StatusInternalServerError, ErrorMsg{err.Error()}) } }) api.Get("/api/v1/bins/", func(r render.Render, storage Storage){ if bins, err := storage.LookupBins(history); err == nil { r.JSON(http.StatusOK, bins) } else { r.JSON(http.StatusInternalServerError, ErrorMsg{err.Error()}) } }) api.Get("/api/v1/bins/:bin", func(r render.Render, params martini.Params, storage Storage){ if bin, err := storage.LookupBin(params["bin"]); err == nil{ r.JSON(http.StatusOK, bin) } else { r.JSON(http.StatusNotFound, ErrorMsg{err.Error()}) } }) 

 //    api.Get("/api/v1/bins/:bin/requests/", func(r render.Render, storage Storage, params martini.Params, req *http.Request){ if bin, error := storage.LookupBin(params["bin"]); error == nil { from := 0 to := 20 if fromVal, err := strconv.Atoi(req.FormValue("from")); err == nil { from = fromVal } if toVal, err := strconv.Atoi(req.FormValue("to")); err == nil { to = toVal } if requests, err := storage.LookupRequests(bin.Name, from, to); err == nil { r.JSON(http.StatusOK, requests) } else { r.JSON(http.StatusInternalServerError, ErrorMsg{err.Error()}) } } else { r.Error(http.StatusNotFound) } }) //     Request api.Get("/api/v1/bins/:bin/requests/:request", func(r render.Render, storage Storage, params martini.Params){ if request, err := storage.LookupRequest(params["bin"], params["request"]); err == nil { r.JSON(http.StatusOK, request) } else { r.JSON(http.StatusNotFound, ErrorMsg{err.Error()}) } }) //  http    Request  Bin(name) api.Any("/bins/:name", func(r render.Render, storage Storage, params martini.Params, req *http.Request){ if bin, error := storage.LookupBin(params["name"]); error == nil { request := NewRequest(req, REQUEST_BODY_SIZE) if err := storage.CreateRequest(bin, request); err == nil { r.JSON(http.StatusOK, request) } else { r.JSON(http.StatusInternalServerError, ErrorMsg{err.Error()}) } } else { r.Error(http.StatusNotFound) } }) 

 > curl -i -X POST "127.0.0.1:3000/api/v1/bins/" HTTP/1.1 201 Created Content-Type: application/json; charset=UTF-8 Date: Mon, 03 Mar 2014 12:19:28 GMT Content-Length: 76 {"name":"ws87ui","created":1393849168,"updated":1393849168,"requestCount":0} 

 > curl -X POST -d "fizz=buzz" http://127.0.0.1:3000/bins/ws87ui {"id":"i0aigrrc1b40","created":1393849284,...} 

 > curl http://127.0.0.1:3000/api/v1/bins/ws87ui/requests/ [{"id":"i0aigrrc1b40","created":1393849284,...}]