services/ws/permission.go

   1 // Copyright (C) The Arvados Authors. All rights reserved.
   2 //
   3 // SPDX-License-Identifier: AGPL-3.0
   4
   5 package ws
   6
   7 import (
   8         "context"
   9         "net/http"
  10         "net/url"
  11         "time"
  12
  13         "git.arvados.org/arvados.git/sdk/go/arvados"
  14         "git.arvados.org/arvados.git/sdk/go/ctxlog"
  15 )
  16
  17 const (
  18         maxPermCacheAge = time.Hour
  19         minPermCacheAge = 5 * time.Minute
  20 )
  21
  22 type permChecker interface {
  23         SetToken(token string)
  24         Check(ctx context.Context, uuid string) (bool, error)
  25 }
  26
  27 func newPermChecker(ac arvados.Client) permChecker {
  28         ac.AuthToken = ""
  29         return &cachingPermChecker{
  30                 Client:     &ac,
  31                 cache:      make(map[string]cacheEnt),
  32                 maxCurrent: 16,
  33         }
  34 }
  35
  36 type cacheEnt struct {
  37         time.Time
  38         allowed bool
  39 }
  40
  41 type cachingPermChecker struct {
  42         *arvados.Client
  43         cache      map[string]cacheEnt
  44         maxCurrent int
  45
  46         nChecks  uint64
  47         nMisses  uint64
  48         nInvalid uint64
  49 }
  50
  51 func (pc *cachingPermChecker) SetToken(token string) {
  52         if pc.Client.AuthToken == token {
  53                 return
  54         }
  55         pc.Client.AuthToken = token
  56         pc.cache = make(map[string]cacheEnt)
  57 }
  58
  59 func (pc *cachingPermChecker) Check(ctx context.Context, uuid string) (bool, error) {
  60         pc.nChecks++
  61         logger := ctxlog.FromContext(ctx).
  62                 WithField("token", pc.Client.AuthToken).
  63                 WithField("uuid", uuid)
  64         pc.tidy()
  65         now := time.Now()
  66         if perm, ok := pc.cache[uuid]; ok && now.Sub(perm.Time) < maxPermCacheAge {
  67                 logger.WithField("allowed", perm.allowed).Debug("cache hit")
  68                 return perm.allowed, nil
  69         }
  70         var buf map[string]interface{}
  71         path, err := pc.PathForUUID("get", uuid)
  72         if err != nil {
  73                 pc.nInvalid++
  74                 return false, err
  75         }
  76
  77         pc.nMisses++
  78         ctx, cancel := context.WithDeadline(context.Background(), time.Now().Add(time.Minute))
  79         defer cancel()
  80         err = pc.RequestAndDecodeContext(ctx, &buf, "GET", path, nil, url.Values{
  81                 "include_trash": {"true"},
  82                 "select":        {`["uuid"]`},
  83         })
  84
  85         var allowed bool
  86         if err == nil {
  87                 allowed = true
  88         } else if txErr, ok := err.(*arvados.TransactionError); ok && pc.isNotAllowed(txErr.StatusCode) {
  89                 allowed = false
  90         } else {
  91                 logger.WithError(err).Error("lookup error")
  92                 return false, err
  93         }
  94         logger.WithField("allowed", allowed).Debug("cache miss")
  95         pc.cache[uuid] = cacheEnt{Time: now, allowed: allowed}
  96         return allowed, nil
  97 }
  98
  99 func (pc *cachingPermChecker) isNotAllowed(status int) bool {
 100         switch status {
 101         case http.StatusForbidden, http.StatusUnauthorized, http.StatusNotFound:
 102                 return true
 103         default:
 104                 return false
 105         }
 106 }
 107
 108 func (pc *cachingPermChecker) tidy() {
 109         if len(pc.cache) <= pc.maxCurrent*2 {
 110                 return
 111         }
 112         tooOld := time.Now().Add(-minPermCacheAge)
 113         for uuid, t := range pc.cache {
 114                 if t.Before(tooOld) {
 115                         delete(pc.cache, uuid)
 116                 }
 117         }
 118         pc.maxCurrent = len(pc.cache)
 119 }