vendor/github.com/fsouza/go-dockerclient/external/github.com/gorilla/context/context.go

   1 // Copyright 2012 The Gorilla Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style
   3 // license that can be found in the LICENSE file.
   4
   5 package context
   6
   7 import (
   8         "net/http"
   9         "sync"
  10         "time"
  11 )
  12
  13 var (
  14         mutex sync.RWMutex
  15         data  = make(map[*http.Request]map[interface{}]interface{})
  16         datat = make(map[*http.Request]int64)
  17 )
  18
  19 // Set stores a value for a given key in a given request.
  20 func Set(r *http.Request, key, val interface{}) {
  21         mutex.Lock()
  22         if data[r] == nil {
  23                 data[r] = make(map[interface{}]interface{})
  24                 datat[r] = time.Now().Unix()
  25         }
  26         data[r][key] = val
  27         mutex.Unlock()
  28 }
  29
  30 // Get returns a value stored for a given key in a given request.
  31 func Get(r *http.Request, key interface{}) interface{} {
  32         mutex.RLock()
  33         if ctx := data[r]; ctx != nil {
  34                 value := ctx[key]
  35                 mutex.RUnlock()
  36                 return value
  37         }
  38         mutex.RUnlock()
  39         return nil
  40 }
  41
  42 // GetOk returns stored value and presence state like multi-value return of map access.
  43 func GetOk(r *http.Request, key interface{}) (interface{}, bool) {
  44         mutex.RLock()
  45         if _, ok := data[r]; ok {
  46                 value, ok := data[r][key]
  47                 mutex.RUnlock()
  48                 return value, ok
  49         }
  50         mutex.RUnlock()
  51         return nil, false
  52 }
  53
  54 // GetAll returns all stored values for the request as a map. Nil is returned for invalid requests.
  55 func GetAll(r *http.Request) map[interface{}]interface{} {
  56         mutex.RLock()
  57         if context, ok := data[r]; ok {
  58                 result := make(map[interface{}]interface{}, len(context))
  59                 for k, v := range context {
  60                         result[k] = v
  61                 }
  62                 mutex.RUnlock()
  63                 return result
  64         }
  65         mutex.RUnlock()
  66         return nil
  67 }
  68
  69 // GetAllOk returns all stored values for the request as a map and a boolean value that indicates if
  70 // the request was registered.
  71 func GetAllOk(r *http.Request) (map[interface{}]interface{}, bool) {
  72         mutex.RLock()
  73         context, ok := data[r]
  74         result := make(map[interface{}]interface{}, len(context))
  75         for k, v := range context {
  76                 result[k] = v
  77         }
  78         mutex.RUnlock()
  79         return result, ok
  80 }
  81
  82 // Delete removes a value stored for a given key in a given request.
  83 func Delete(r *http.Request, key interface{}) {
  84         mutex.Lock()
  85         if data[r] != nil {
  86                 delete(data[r], key)
  87         }
  88         mutex.Unlock()
  89 }
  90
  91 // Clear removes all values stored for a given request.
  92 //
  93 // This is usually called by a handler wrapper to clean up request
  94 // variables at the end of a request lifetime. See ClearHandler().
  95 func Clear(r *http.Request) {
  96         mutex.Lock()
  97         clear(r)
  98         mutex.Unlock()
  99 }
 100
 101 // clear is Clear without the lock.
 102 func clear(r *http.Request) {
 103         delete(data, r)
 104         delete(datat, r)
 105 }
 106
 107 // Purge removes request data stored for longer than maxAge, in seconds.
 108 // It returns the amount of requests removed.
 109 //
 110 // If maxAge <= 0, all request data is removed.
 111 //
 112 // This is only used for sanity check: in case context cleaning was not
 113 // properly set some request data can be kept forever, consuming an increasing
 114 // amount of memory. In case this is detected, Purge() must be called
 115 // periodically until the problem is fixed.
 116 func Purge(maxAge int) int {
 117         mutex.Lock()
 118         count := 0
 119         if maxAge <= 0 {
 120                 count = len(data)
 121                 data = make(map[*http.Request]map[interface{}]interface{})
 122                 datat = make(map[*http.Request]int64)
 123         } else {
 124                 min := time.Now().Unix() - int64(maxAge)
 125                 for r := range data {
 126                         if datat[r] < min {
 127                                 clear(r)
 128                                 count++
 129                         }
 130                 }
 131         }
 132         mutex.Unlock()
 133         return count
 134 }
 135
 136 // ClearHandler wraps an http.Handler and clears request values at the end
 137 // of a request lifetime.
 138 func ClearHandler(h http.Handler) http.Handler {
 139         return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 140                 defer Clear(r)
 141                 h.ServeHTTP(w, r)
 142         })
 143 }