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