GoでのWebサービスの作成（パート2）

Goで小型のフル機能アプリケーションを作成する方法に関する記事の続き。



最初の部分では、REST APIを実装し、着信HTTPリクエストを収集する方法を学びました。 このパートでは、アプリケーションをテストでカバーし、AngularJSとBootstrapに基づいた美しいWebインターフェースを追加し、さまざまなユーザーのアクセス制限を実装します。





このパートでは、次の段階が待っています。

1. 4番目のステップ。 しかし、テストはどうですか？
2. ステップ5 —装飾とWebインターフェース。
3. ステップ6 プライバシーを追加します。
4. 7番目のステップ。 不要なものをきれいにします。
5. ステップ8。 ストレージにはRedisを使用しています。

4番目のステップ。 しかし、テストはどうですか？

Goには、テストを処理するための多数の組み込みツールがあります。 通常の単体テスト（単体テスト）と、たとえばベンチマークテストの両方を作成することができます。 このツールキットでは、テストでコードカバレッジを確認することもできます。



テストを操作するための基本パッケージはtestingです。 ここでの2つの主なタイプは、通常の単体テスト用のT



と負荷テスト用のB



です。 Goのテストは、メインプログラムと同じパッケージに_test



され、接尾辞_test



追加されます。 したがって、パッケージ内で使用可能なプライベートデータ構造は、テスト内でも使用できます（テストが互いに共通のグローバルスコープを持っていることも事実です）。 メインプログラムをコンパイルするとき、テストファイルは無視されます。



基本的なテストパッケージに加えて、テストの記述を簡素化する、または1つまたは別のスタイル（ BDDスタイルでも）で記述できるようにする多数のサードパーティライブラリがあります。 たとえば、ここでは、 TDDスタイルでGoを記述する方法に関する優れた入門記事があります。



GitHubには、テストライブラリを比較するためのプレートがあります。その中には、Webインターフェースを提供するgoconveyなどのモンスターや、テストの合格に関する通知などのシステムとの相互作用もあります。 しかし、物事を複雑にしないために、このプロジェクトでは、条件をチェックしてモックオブジェクトを作成するためのいくつかのプリミティブのみを追加する小さな証言ライブラリを使用します。



4番目のステップのコードをダウンロードします。

 git checkout step-4
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

モデルのテストを書くことから始めましょう。 ファイルmodels_test.goを作成します。 go testユーティリティで検出するには、テスト付きの関数が次のパターンを満たしている必要があります。

 func TestXxx(*testing.T)
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

Binオブジェクトの正しい作成をチェックする最初のテストを作成します。

 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)) } }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

testifyのすべてのテストメソッドは、* testing.Tオブジェクトを最初のパラメーターとして受け入れます。

次に、間違ったパスと境界値を忘れずに、すべてのシナリオをテストします。 記事にはすべてのテストのコードを引用するつもりはありません。多くのテストがあり、リポジトリでそれらに慣れることができるので、最も興味深い点のみを述べます。



api_test.goファイルに注意してください。このファイルでREST APIをテストします。 データのストレージ実装に依存しないように、Storageインターフェースの動作を実装するモックオブジェクトを追加します。 これは、 模擬パッケージ testifyを使用して行います 。 モックオブジェクトを簡単に作成するためのメカニズムを提供し、テストを作成するときに実際のオブジェクトの代わりに使用できます。



彼のコードは次のとおりです。

 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) }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

さらにテスト自体では、APIを作成するときに、モックオブジェクトを注入します。

  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）を返すと、Returnに渡された最初の引数が返されます、この場合はrealBin。 インターフェイス{}型のオブジェクトを返すGetメソッドに加えて、インターフェイスを必要な型に変換するInt、String、Bool、Errorのヘルパーメソッドがあります。 mockedStorage.AssertExpectations（t）メソッドは、テスト中に予想されるすべてのメソッドが呼び出されたかどうかを確認します。



httptest.NewRecorderで作成されたResponseRecorderオブジェクトも興味深いものです。ResponseWriterの動作を実装し、要求データをどこにも表示せずに、最終的に返されるもの（応答コード、ヘッダー、応答本文）を確認できます。



テストを実行するには、次のコマンドを実行する必要があります。

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

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

テスト開始チームには多数のフラグがあります。次のようにフラグを理解できます。

 > go help testflag
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

それらで遊ぶことができますが、次のコマンドに興味があります（Goバージョン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バージョンを作成し、ブラウザーで開きます。

Goでのテストカバレッジ。非常に興味深い実装です。 コードをコンパイルする前に、ソースファイルが変更され、カウンターがソースコードに挿入されます。 たとえば、次のようなコード：

 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が用意され、テストで覆われたので、Webインターフェースの装飾と構築を開始できます。

ステップ5-装飾とWebインターフェース。

Goパッケージには、 htmlテンプレートを操作するための完全なライブラリがありますが、javascriptを介してAPIと直接連携する、いわゆる単一ページアプリケーションを作成します。 このAngularJSを手伝ってください。



新しいステップのコードを更新します。

 > git checkout step-5
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

最初の章で述べたように、Martiniには静的ファイルを配布するためのハンドラがあり、デフォルトではパブリックディレクトリから静的ファイルを配布します。 そこに必要なjsおよびcssライブラリを配置します。 これは私たちの記事の目標ではないので、フロントエンドの作業について説明します。角度に精通している人のために、ソースファイルを自分で見ることができます。



メインページを表示するには、別のハンドラーを追加します。

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

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

Glob **



文字は、index.htmlファイルがすべてのアドレスに対して返されることを示します。 テンプレートを正しく操作するために、テンプレートの入手先を示すレンダラーを作成するときにオプションを追加しました。 さらに、アンギュラーテンプレートと競合しないように、{{}}を{[{}]}に再割り当てします。

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

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

さらに、色フィールド（RGB色値を格納する3バイト）とファビコン（データURI画像、色が必要）がビンモデルに追加されました。これらは、オブジェクトを作成するときにランダムに生成され、異なるビンオブジェクトを色で区別します。

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

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

これで、ほぼ完全に機能するWebアプリケーションが作成されました。実行できます。

 > go run ./src/main.go
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

そして、ブラウザで開きます（ 127.0.0.1:3000



127.0.0.1:3000



）遊びます。



残念ながら、アプリケーションにはまだ2つの問題があります。プログラムが終了した後、すべてのデータが失われ、ユーザー間の分離はありません。誰もが同じことを見ています。 さあ、やってみましょう。

ステップ6 プライバシーを追加します。

6番目のステップのコードをダウンロードします。

 > git checkout step-6
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

セッションを使用して、ユーザーを互いに分離します。 開始するには、それらを保存する場所を選択します。 martini-contribのセッションは、 ゴリラ Webライブラリセッションに基づいています。

Gorillaは、Webフレームワークを実装するためのツールのセットです。 これらのツールはすべて相互に疎結合されているため、あらゆる部分に参加して自分に組み込むことができます。

これにより、ゴリラにすでに実装されているリポジトリを使用できます。 私たちはクッキーベースです。



セッションリポジトリを作成します。

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

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

NewCookieStore関数はパラメーターとしてキーペアを受け入れます。ペアの最初のキーは認証に必要で、2番目は暗号化に必要です。 2番目のキーはスキップできます。 セッションを失うことなくキーをローテーションできるようにするには、複数のキーペアを使用できます。 セッションを作成するとき、最初のペアのキーが使用されますが、データをチェックするときは、すべてのキーが最初のペアから順番に使用されます。

アプリケーションには異なるキーが必要なので、このパラメーターをConfigオブジェクトに配置します。これは将来、環境設定または起動フラグに基づいてアプリケーションを構成するのに役立ちます。



セッションの処理を追加する中間ハンドラーをAPIに追加します。

 // 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ファイルの履歴（これは単なるスライスでした）を書き換えます。

 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メソッドでは、Historyインターフェイス（すべての履歴オブジェクトの追加とクエリについて説明します）を実装するSessionHistoryオブジェクトを作成し、それを各リクエストのコンテキストに追加します。 SessionHistoryオブジェクトには、データをセッションにロードおよび保存するヘルパーメソッドのロードおよび保存があります。 さらに、セッションからのデータのダウンロードは、オンデマンドでのみ実行されます。 これで、以前に履歴スライスが使用されていたすべてのAPIメソッドで、Historyタイプの新しいオブジェクトが使用されます。



この時点から、各ユーザーはBinオブジェクトの独自の履歴を保持しますが、直接リンクを介してすべてのBinを表示できます。 これを修正するには、プライベートBinオブジェクトを作成する機能を追加します。



Binに2つの新しいフィールドを作成しましょう。

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

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

キーはSecretKeyフィールドに保存され、プライベートBin（Privateフラグがtrueに設定されているもの）へのアクセスを許可します。 オブジェクトをプライベートにするメソッドを追加します。

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

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

プライベートBinを作成するために、フロントエンドはオブジェクトを作成するときに、プライベートフラグ付きのjsonオブジェクトを送信します。 着信jsonを解析するために、リクエスト本文を読み取り、必要な構造にアンパックする小さなDecodeJsonPayloadメソッドを作成しました。

 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を変更して、新しい動作を実装します。

  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()}) } })
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

最初に、タイプBinのペイロードオブジェクトを作成します。そのフィールドには、リクエスト本文からDecodeJsonPayload関数の値が入力されます。 その後、入力でオプション「private」が設定されている場合、ビンをプライベートにします。 さらに、プライベートオブジェクトの場合、セッションsession.Set(fmt.Sprintf("pr_%s", bin.Name), bin.SecretKey)



キー値を保存します。 ここで、他のAPIメソッドを変更して、プライベートBinオブジェクトのセッション内のキーの存在をチェックする必要があります。



これは次のように行われます。

  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()}) } })
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

類推により、他の方法で行われます。 一部のテストは、新しい動作を考慮して修正され、特定の変更をコードで表示できます。



アプリケーションを別のブラウザまたはシークレットモードで実行する場合、履歴が異なること、および作成されたブラウザのみがプライベートBinオブジェクトにアクセスできることを確認できます。



すべては問題ありませんが、今ではストレージ内のすべてのオブジェクトはほぼ永久に存続します。これはおそらく永遠ではないため、おそらく正しいとは言えません。

7番目のステップ。 不要なものをきれいにします。

7番目のステップコードをダウンロードします。

 git checkout step-7
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

ベースストレージ構造に別のフィールドを追加します。

 type BaseStorage struct { ... binLifetime int64 }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

Binオブジェクトと関連クエリの最大有効期間を保存します。 ここで、メモリ内のストレージを書き換えます-memory.go。 binLifetime秒以上更新されていないすべてのbinRecordsをクリアするメインメソッド：

 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) } } }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

また、タイマーとそれを操作するメソッドをMemoryStorageタイプに追加します。

 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() } }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

パッケージメソッドtime AfterFuncは、time.Durationなどのタイムアウトが最初の引数で渡された後、別のゴルーチンで指定された関数を開始します（したがって、パラメーターなしである必要があるため、ここでクロージャーを使用してタイムアウトを渡します）。



アプリケーションの水平スケーリングを行うには、異なるサーバーで実行する必要があるため、データ用に別のストレージが必要です。 Redisを例にとります。

ステップ8。 ストレージにはRedisを使用しています。

Redisの公式ドキュメントでは 、Goの広範なクライアントのリストについてアドバイスしています。 執筆時点では、推奨されるのはradixとredigoです。 redigoは積極的に開発されており、より大きなコミュニティがあるため、redigoを選択します。



目的のコードに進みましょう。

 git checkout step-8
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

redis.goファイルを見てください。これがStorage for Redisの実装になります。 基本的な構造は非常に単純です。

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

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

プールには、大根への接続のプールがprefix-すべてのキーの共通プレフィックスに格納されます。 プールを作成するには、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 }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

Dialでは、Redisサーバーに接続した後、パスワードが指定されている場合にログインを試みる関数を渡します。 その後、確立された接続が返されます。 TestOnBorrow関数は、プールから接続が要求されたときに呼び出されます。この機能では、接続の実行可能性を確認できます。 2番目のパラメーターは、接続がプールに返されてからの時間です。 毎回pingを送信するだけです。



また、パッケージでは、いくつかの定数を宣言しています。

 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) }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

次に、他の方法について説明します。

Binオブジェクトの作成

 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 }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

最初に、Dumpメソッドを使用してビンをシリアル化します。 次に、大根化合物をプールから取り出します（deferを使用して返す必要があることを忘れずに）。

Redigoはパイプラインモードをサポートしています。Sendメソッドを使用してバッファーにコマンドを追加し、Flushメソッドを使用してバッファーからすべてのデータを送信し、Receiveで結果を取得できます。 Doコマンドは、3つすべてのチームを1つに結合します。 redigoのドキュメントでトランザクション性を実装することもできます 。

Binのデータを名前で保存する「SET」と、このレコードの有効期間を設定するExpireという2つのコマンドを送信します。

Binオブジェクトの取得

 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を返します。 すべてがうまくいった場合、データはbinオブジェクトにロードされ、参照によってLoadメソッドに渡されます。

Binオブジェクトのリストの取得

 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 } }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

ここでは、MGETコマンドを使用してデータスライスを取得し、redis.ScanSliceヘルパーメソッドを使用して応答を目的のタイプのスライスにロードすることを除いて、ほとんどすべてが前のメソッドと同じです。

リクエストを作成するリクエスト

 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 }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

まず、bin.Nameのリクエストリストにリクエスト識別子を保存し、次にハッシュテーブルにシリアル化されたリクエストを保存します。どちらの場合も、ライフタイムを追加することを忘れないでください。LPUSHコマンドは、requestCountリスト内のエントリの数を返します。この数が最大値に係数を掛けた値を超えた場合、このBinを次のクリーンアップの候補に追加します。



リクエストとリクエストのリストの受信は、Binオブジェクトと同様に行われます。

クリーニング

 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...) } } } }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

MemoryStorageとは異なり、ここでは冗長な要求をクリアします。これは、有効期限がEXPIRE radishコマンドによって制限されているためです。まず、クリーニングのためにリストからアイテムを取り出し、制限に含まれていないリクエストの識別子を要求し、LTRIMコマンドを使用してリストを必要なサイズに圧縮します。一度に複数のキーを受け入れるHDELコマンドを使用して、ハッシュテーブルから以前に取得した識別子を削除します。



redis_test.goファイルでRedisStorageの説明を終了しました。同じテストが見つかります。



次に、アプリケーションを起動するときに、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 } ...
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

新しいStorageフィールドを構成構造に追加し、それに応じて、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() }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

flagパッケージを使用します。これにより、プログラムの起動オプションを簡単かつ簡単に追加できます。「ストレージ」フラグをinit関数に追加します。これにより、「ストレージ」フィールドの構成に値が直接保存されます。また、大根の起動オプションを追加します。

init関数はGo専用であり、パッケージがロードされると常に実行されます。Goでのプログラムの実行の詳細。

ここで、-helpオプションを使用してプログラムを起動すると、使用可能なオプションのリストが表示されます。

 > 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
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

これで、まだ非常に未加工で最適化されていないアプリケーションができましたが、サーバー上で動作して実行する準備ができました。



3番目の部分では、GAE、コカイン、およびHerokuでのアプリケーションのレイアウトと起動、およびすべてのリソースを含む単一の実行可能ファイルとして配布する方法について説明します。最適化を行いながらパフォーマンステストを作成します。リクエストをプロキシし、必要なデータで応答する方法を学びます。最後に、アプリケーション内に分散グループキャッシュデータベースを埋め込みます。



この記事の修正や提案を歓迎します。