services/keepproxy/keepproxy.go

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