services/keepproxy/keepproxy.go

   1 package main
   2
   3 import (
   4         "git.curoverse.com/arvados.git/sdk/go/keepclient"
   5         "git.curoverse.com/arvados.git/sdk/go/arvadosclient"
   6         "flag"
   7         "fmt"
   8         "github.com/gorilla/mux"
   9         "io"
  10         "log"
  11         "net"
  12         "net/http"
  13         "os"
  14         "os/signal"
  15         "sync"
  16         "syscall"
  17         "time"
  18 )
  19
  20 // Default TCP address on which to listen for requests.
  21 // Initialized by the -listen flag.
  22 const DEFAULT_ADDR = ":25107"
  23
  24 var listener net.Listener
  25
  26 func main() {
  27         var (
  28                 listen           string
  29                 no_get           bool
  30                 no_put           bool
  31                 default_replicas int
  32                 pidfile          string
  33         )
  34
  35         flagset := flag.NewFlagSet("default", flag.ExitOnError)
  36
  37         flagset.StringVar(
  38                 &listen,
  39                 "listen",
  40                 DEFAULT_ADDR,
  41                 "Interface on which to listen for requests, in the format "+
  42                         "ipaddr:port. e.g. -listen=10.0.1.24:8000. Use -listen=:port "+
  43                         "to listen on all network interfaces.")
  44
  45         flagset.BoolVar(
  46                 &no_get,
  47                 "no-get",
  48                 false,
  49                 "If set, disable GET operations")
  50
  51         flagset.BoolVar(
  52                 &no_put,
  53                 "no-put",
  54                 false,
  55                 "If set, disable PUT operations")
  56
  57         flagset.IntVar(
  58                 &default_replicas,
  59                 "default-replicas",
  60                 2,
  61                 "Default number of replicas to write if not specified by the client.")
  62
  63         flagset.StringVar(
  64                 &pidfile,
  65                 "pid",
  66                 "",
  67                 "Path to write pid file")
  68
  69         flagset.Parse(os.Args[1:])
  70
  71         arv, err := arvadosclient.MakeArvadosClient()
  72         if err != nil {
  73                 log.Fatalf("Error setting up arvados client %s", err.Error())
  74         }
  75
  76         kc, err := keepclient.MakeKeepClient(&arv)
  77         if err != nil {
  78                 log.Fatalf("Error setting up keep client %s", err.Error())
  79         }
  80
  81         if pidfile != "" {
  82                 f, err := os.Create(pidfile)
  83                 if err == nil {
  84                         fmt.Fprint(f, os.Getpid())
  85                         f.Close()
  86                 } else {
  87                         log.Printf("Error writing pid file (%s): %s", pidfile, err.Error())
  88                 }
  89         }
  90
  91         kc.Want_replicas = default_replicas
  92
  93         listener, err = net.Listen("tcp", listen)
  94         if err != nil {
  95                 log.Fatalf("Could not listen on %v", listen)
  96         }
  97
  98         go RefreshServicesList(&kc)
  99
 100         // Shut down the server gracefully (by closing the listener)
 101         // if SIGTERM is received.
 102         term := make(chan os.Signal, 1)
 103         go func(sig <-chan os.Signal) {
 104                 s := <-sig
 105                 log.Println("caught signal:", s)
 106                 listener.Close()
 107         }(term)
 108         signal.Notify(term, syscall.SIGTERM)
 109         signal.Notify(term, syscall.SIGINT)
 110
 111         if pidfile != "" {
 112                 f, err := os.Create(pidfile)
 113                 if err == nil {
 114                         fmt.Fprint(f, os.Getpid())
 115                         f.Close()
 116                 } else {
 117                         log.Printf("Error writing pid file (%s): %s", pidfile, err.Error())
 118                 }
 119         }
 120
 121         log.Printf("Arvados Keep proxy started listening on %v with server list %v", listener.Addr(), kc.ServiceRoots())
 122
 123         // Start listening for requests.
 124         http.Serve(listener, MakeRESTRouter(!no_get, !no_put, &kc))
 125
 126         log.Println("shutting down")
 127
 128         if pidfile != "" {
 129                 os.Remove(pidfile)
 130         }
 131 }
 132
 133 type ApiTokenCache struct {
 134         tokens     map[string]int64
 135         lock       sync.Mutex
 136         expireTime int64
 137 }
 138
 139 // Refresh the keep service list every five minutes.
 140 func RefreshServicesList(kc *keepclient.KeepClient) {
 141         for {
 142                 time.Sleep(300 * time.Second)
 143                 oldservices := kc.ServiceRoots()
 144                 kc.DiscoverKeepServers()
 145                 newservices := kc.ServiceRoots()
 146                 s1 := fmt.Sprint(oldservices)
 147                 s2 := fmt.Sprint(newservices)
 148                 if s1 != s2 {
 149                         log.Printf("Updated server list to %v", s2)
 150                 }
 151         }
 152 }
 153
 154 // Cache the token and set an expire time.  If we already have an expire time
 155 // on the token, it is not updated.
 156 func (this *ApiTokenCache) RememberToken(token string) {
 157         this.lock.Lock()
 158         defer this.lock.Unlock()
 159
 160         now := time.Now().Unix()
 161         if this.tokens[token] == 0 {
 162                 this.tokens[token] = now + this.expireTime
 163         }
 164 }
 165
 166 // Check if the cached token is known and still believed to be valid.
 167 func (this *ApiTokenCache) RecallToken(token string) bool {
 168         this.lock.Lock()
 169         defer this.lock.Unlock()
 170
 171         now := time.Now().Unix()
 172         if this.tokens[token] == 0 {
 173                 // Unknown token
 174                 return false
 175         } else if now < this.tokens[token] {
 176                 // Token is known and still valid
 177                 return true
 178         } else {
 179                 // Token is expired
 180                 this.tokens[token] = 0
 181                 return false
 182         }
 183 }
 184
 185 func GetRemoteAddress(req *http.Request) string {
 186         if realip := req.Header.Get("X-Real-IP"); realip != "" {
 187                 if forwarded := req.Header.Get("X-Forwarded-For"); forwarded != realip {
 188                         return fmt.Sprintf("%s (X-Forwarded-For %s)", realip, forwarded)
 189                 } else {
 190                         return realip
 191                 }
 192         }
 193         return req.RemoteAddr
 194 }
 195
 196 func CheckAuthorizationHeader(kc keepclient.KeepClient, cache *ApiTokenCache, req *http.Request) (pass bool, tok string) {
 197         var auth string
 198         if auth = req.Header.Get("Authorization"); auth == "" {
 199                 return false, ""
 200         }
 201
 202         _, err := fmt.Sscanf(auth, "OAuth2 %s", &tok)
 203         if err != nil {
 204                 // Scanning error
 205                 return false, ""
 206         }
 207
 208         if cache.RecallToken(tok) {
 209                 // Valid in the cache, short circut
 210                 return true, tok
 211         }
 212
 213         arv := *kc.Arvados
 214         arv.ApiToken = tok
 215         if err := arv.Call("HEAD", "users", "", "current", nil, nil); err != nil {
 216                 log.Printf("%s: CheckAuthorizationHeader error: %v", GetRemoteAddress(req), err)
 217                 return false, ""
 218         }
 219
 220         // Success!  Update cache
 221         cache.RememberToken(tok)
 222
 223         return true, tok
 224 }
 225
 226 type GetBlockHandler struct {
 227         *keepclient.KeepClient
 228         *ApiTokenCache
 229 }
 230
 231 type PutBlockHandler struct {
 232         *keepclient.KeepClient
 233         *ApiTokenCache
 234 }
 235
 236 type InvalidPathHandler struct{}
 237
 238 // MakeRESTRouter
 239 //     Returns a mux.Router that passes GET and PUT requests to the
 240 //     appropriate handlers.
 241 //
 242 func MakeRESTRouter(
 243         enable_get bool,
 244         enable_put bool,
 245         kc *keepclient.KeepClient) *mux.Router {
 246
 247         t := &ApiTokenCache{tokens: make(map[string]int64), expireTime: 300}
 248
 249         rest := mux.NewRouter()
 250
 251         if enable_get {
 252                 rest.Handle(`/{hash:[0-9a-f]{32}}+{hints}`,
 253                         GetBlockHandler{kc, t}).Methods("GET", "HEAD")
 254                 rest.Handle(`/{hash:[0-9a-f]{32}}`, GetBlockHandler{kc, t}).Methods("GET", "HEAD")
 255         }
 256
 257         if enable_put {
 258                 rest.Handle(`/{hash:[0-9a-f]{32}}+{hints}`, PutBlockHandler{kc, t}).Methods("PUT")
 259                 rest.Handle(`/{hash:[0-9a-f]{32}}`, PutBlockHandler{kc, t}).Methods("PUT")
 260         }
 261
 262         rest.NotFoundHandler = InvalidPathHandler{}
 263
 264         return rest
 265 }
 266
 267 func (this InvalidPathHandler) ServeHTTP(resp http.ResponseWriter, req *http.Request) {
 268         log.Printf("%s: %s %s unroutable", GetRemoteAddress(req), req.Method, req.URL.Path)
 269         http.Error(resp, "Bad request", http.StatusBadRequest)
 270 }
 271
 272 func (this GetBlockHandler) ServeHTTP(resp http.ResponseWriter, req *http.Request) {
 273
 274         kc := *this.KeepClient
 275
 276         hash := mux.Vars(req)["hash"]
 277         hints := mux.Vars(req)["hints"]
 278
 279         locator := keepclient.MakeLocator2(hash, hints)
 280
 281         log.Printf("%s: %s %s", GetRemoteAddress(req), req.Method, hash)
 282
 283         var pass bool
 284         var tok string
 285         if pass, tok = CheckAuthorizationHeader(kc, this.ApiTokenCache, req); !pass {
 286                 http.Error(resp, "Missing or invalid Authorization header", http.StatusForbidden)
 287                 return
 288         }
 289
 290         // Copy ArvadosClient struct and use the client's API token
 291         arvclient := *kc.Arvados
 292         arvclient.ApiToken = tok
 293         kc.Arvados = &arvclient
 294
 295         var reader io.ReadCloser
 296         var err error
 297         var blocklen int64
 298
 299         if req.Method == "GET" {
 300                 reader, blocklen, _, err = kc.AuthorizedGet(hash, locator.Signature, locator.Timestamp)
 301                 defer reader.Close()
 302         } else if req.Method == "HEAD" {
 303                 blocklen, _, err = kc.AuthorizedAsk(hash, locator.Signature, locator.Timestamp)
 304         }
 305
 306         if blocklen > 0 {
 307                 resp.Header().Set("Content-Length", fmt.Sprint(blocklen))
 308         }
 309
 310         switch err {
 311         case nil:
 312                 if reader != nil {
 313                         n, err2 := io.Copy(resp, reader)
 314                         if n != blocklen {
 315                                 log.Printf("%s: %s %s mismatched return %v with Content-Length %v error %v", GetRemoteAddress(req), req.Method, hash, n, blocklen, err2)
 316                         } else if err2 == nil {
 317                                 log.Printf("%s: %s %s success returned %v bytes", GetRemoteAddress(req), req.Method, hash, n)
 318                         } else {
 319                                 log.Printf("%s: %s %s returned %v bytes error %v", GetRemoteAddress(req), req.Method, hash, n, err.Error())
 320                         }
 321                 } else {
 322                         log.Printf("%s: %s %s success", GetRemoteAddress(req), req.Method, hash)
 323                 }
 324         case keepclient.BlockNotFound:
 325                 http.Error(resp, "Not found", http.StatusNotFound)
 326         default:
 327                 http.Error(resp, err.Error(), http.StatusBadGateway)
 328         }
 329
 330         if err != nil {
 331                 log.Printf("%s: %s %s error %s", GetRemoteAddress(req), req.Method, hash, err.Error())
 332         }
 333 }
 334
 335 func (this PutBlockHandler) ServeHTTP(resp http.ResponseWriter, req *http.Request) {
 336
 337         kc := *this.KeepClient
 338
 339         hash := mux.Vars(req)["hash"]
 340         hints := mux.Vars(req)["hints"]
 341
 342         locator := keepclient.MakeLocator2(hash, hints)
 343
 344         var contentLength int64 = -1
 345         if req.Header.Get("Content-Length") != "" {
 346                 _, err := fmt.Sscanf(req.Header.Get("Content-Length"), "%d", &contentLength)
 347                 if err != nil {
 348                         resp.Header().Set("Content-Length", fmt.Sprintf("%d", contentLength))
 349                 }
 350
 351         }
 352
 353         log.Printf("%s: %s %s Content-Length %v", GetRemoteAddress(req), req.Method, hash, contentLength)
 354
 355         if contentLength < 1 {
 356                 http.Error(resp, "Must include Content-Length header", http.StatusLengthRequired)
 357                 return
 358         }
 359
 360         if locator.Size > 0 && int64(locator.Size) != contentLength {
 361                 http.Error(resp, "Locator size hint does not match Content-Length header", http.StatusBadRequest)
 362                 return
 363         }
 364
 365         var pass bool
 366         var tok string
 367         if pass, tok = CheckAuthorizationHeader(kc, this.ApiTokenCache, req); !pass {
 368                 http.Error(resp, "Missing or invalid Authorization header", http.StatusForbidden)
 369                 return
 370         }
 371
 372         // Copy ArvadosClient struct and use the client's API token
 373         arvclient := *kc.Arvados
 374         arvclient.ApiToken = tok
 375         kc.Arvados = &arvclient
 376
 377         // Check if the client specified the number of replicas
 378         if req.Header.Get("X-Keep-Desired-Replicas") != "" {
 379                 var r int
 380                 _, err := fmt.Sscanf(req.Header.Get(keepclient.X_Keep_Desired_Replicas), "%d", &r)
 381                 if err != nil {
 382                         kc.Want_replicas = r
 383                 }
 384         }
 385
 386         // Now try to put the block through
 387         hash, replicas, err := kc.PutHR(hash, req.Body, contentLength)
 388
 389         // Tell the client how many successful PUTs we accomplished
 390         resp.Header().Set(keepclient.X_Keep_Replicas_Stored, fmt.Sprintf("%d", replicas))
 391
 392         switch err {
 393         case nil:
 394                 // Default will return http.StatusOK
 395                 log.Printf("%s: %s %s finished, stored %v replicas (desired %v)", GetRemoteAddress(req), req.Method, hash, replicas, kc.Want_replicas)
 396                 n, err2 := io.WriteString(resp, hash)
 397                 if err2 != nil {
 398                         log.Printf("%s: wrote %v bytes to response body and got error %v", n, err2.Error())
 399                 }
 400
 401         case keepclient.OversizeBlockError:
 402                 // Too much data
 403                 http.Error(resp, fmt.Sprintf("Exceeded maximum blocksize %d", keepclient.BLOCKSIZE), http.StatusRequestEntityTooLarge)
 404
 405         case keepclient.InsufficientReplicasError:
 406                 if replicas > 0 {
 407                         // At least one write is considered success.  The
 408                         // client can decide if getting less than the number of
 409                         // replications it asked for is a fatal error.
 410                         // Default will return http.StatusOK
 411                         n, err2 := io.WriteString(resp, hash)
 412                         if err2 != nil {
 413                                 log.Printf("%s: wrote %v bytes to response body and got error %v", n, err2.Error())
 414                         }
 415                 } else {
 416                         http.Error(resp, "", http.StatusServiceUnavailable)
 417                 }
 418
 419         default:
 420                 http.Error(resp, err.Error(), http.StatusBadGateway)
 421         }
 422
 423         if err != nil {
 424                 log.Printf("%s: %s %s stored %v replicas (desired %v) got error %v", GetRemoteAddress(req), req.Method, hash, replicas, kc.Want_replicas, err.Error())
 425         }
 426
 427 }