lib/controller/router/request.go

   1 // Copyright (C) The Arvados Authors. All rights reserved.
   2 //
   3 // SPDX-License-Identifier: AGPL-3.0
   4
   5 package router
   6
   7 import (
   8         "encoding/json"
   9         "fmt"
  10         "io"
  11         "mime"
  12         "net/http"
  13         "strconv"
  14         "strings"
  15
  16         "github.com/gorilla/mux"
  17 )
  18
  19 func guessAndParse(k, v string) (interface{}, error) {
  20         // All of these form values arrive as strings, so we need some
  21         // type-guessing to accept non-string inputs:
  22         //
  23         // Values for parameters that take ints (limit=1) or bools
  24         // (include_trash=1) are parsed accordingly.
  25         //
  26         // "null" and "" are nil.
  27         //
  28         // Values that look like JSON objects, arrays, or strings are
  29         // parsed as JSON.
  30         //
  31         // The rest are left as strings.
  32         switch {
  33         case intParams[k]:
  34                 return strconv.ParseInt(v, 10, 64)
  35         case boolParams[k]:
  36                 return stringToBool(v), nil
  37         case v == "null" || v == "":
  38                 return nil, nil
  39         case strings.HasPrefix(v, "["):
  40                 var j []interface{}
  41                 err := json.Unmarshal([]byte(v), &j)
  42                 return j, err
  43         case strings.HasPrefix(v, "{"):
  44                 var j map[string]interface{}
  45                 err := json.Unmarshal([]byte(v), &j)
  46                 return j, err
  47         case strings.HasPrefix(v, "\""):
  48                 var j string
  49                 err := json.Unmarshal([]byte(v), &j)
  50                 return j, err
  51         default:
  52                 return v, nil
  53         }
  54         // TODO: Need to accept "?foo[]=bar&foo[]=baz" as
  55         // foo=["bar","baz"]?
  56 }
  57
  58 // Parse req as an Arvados V1 API request and return the request
  59 // parameters.
  60 //
  61 // If the request has a parameter whose name is attrsKey (e.g.,
  62 // "collection"), it is renamed to "attrs".
  63 func (rtr *router) loadRequestParams(req *http.Request, attrsKey string) (map[string]interface{}, error) {
  64         err := req.ParseForm()
  65         if err != nil {
  66                 return nil, httpError(http.StatusBadRequest, err)
  67         }
  68         params := map[string]interface{}{}
  69
  70         // Load parameters from req.Form, which (after
  71         // req.ParseForm()) includes the query string and -- when
  72         // Content-Type is application/x-www-form-urlencoded -- the
  73         // request body.
  74         for k, values := range req.Form {
  75                 for _, v := range values {
  76                         params[k], err = guessAndParse(k, v)
  77                         if err != nil {
  78                                 return nil, err
  79                         }
  80                 }
  81         }
  82
  83         // Decode body as JSON if Content-Type request header is
  84         // missing or application/json.
  85         mt := req.Header.Get("Content-Type")
  86         if ct, _, err := mime.ParseMediaType(mt); err != nil && mt != "" {
  87                 return nil, fmt.Errorf("error parsing media type %q: %s", mt, err)
  88         } else if (ct == "application/json" || mt == "") && req.ContentLength != 0 {
  89                 jsonParams := map[string]interface{}{}
  90                 err := json.NewDecoder(req.Body).Decode(&jsonParams)
  91                 if err != nil {
  92                         return nil, httpError(http.StatusBadRequest, err)
  93                 }
  94                 for k, v := range jsonParams {
  95                         switch v := v.(type) {
  96                         case string:
  97                                 // The Ruby "arv" cli tool sends a
  98                                 // JSON-encode params map with
  99                                 // JSON-encoded values.
 100                                 dec, err := guessAndParse(k, v)
 101                                 if err != nil {
 102                                         return nil, err
 103                                 }
 104                                 jsonParams[k] = dec
 105                                 params[k] = dec
 106                         default:
 107                                 params[k] = v
 108                         }
 109                 }
 110                 if attrsKey != "" && params[attrsKey] == nil {
 111                         // Copy top-level parameters from JSON request
 112                         // body into params[attrsKey]. Some SDKs rely
 113                         // on this Rails API feature; see
 114                         // https://api.rubyonrails.org/v5.2.1/classes/ActionController/ParamsWrapper.html
 115                         params[attrsKey] = jsonParams
 116                 }
 117         }
 118
 119         for k, v := range mux.Vars(req) {
 120                 params[k] = v
 121         }
 122
 123         if v, ok := params[attrsKey]; ok && attrsKey != "" {
 124                 params["attrs"] = v
 125                 delete(params, attrsKey)
 126         }
 127
 128         if order, ok := params["order"].(string); ok {
 129                 // We must accept strings ("foo, bar desc") and arrays
 130                 // (["foo", "bar desc"]) because RailsAPI does.
 131                 // Convert to an array here before trying to unmarshal
 132                 // into options structs.
 133                 if order == "" {
 134                         delete(params, "order")
 135                 } else {
 136                         params["order"] = strings.Split(order, ",")
 137                 }
 138         }
 139
 140         return params, nil
 141 }
 142
 143 // Copy src to dst, using json as an intermediate format in order to
 144 // invoke src's json-marshaling and dst's json-unmarshaling behaviors.
 145 func (rtr *router) transcode(src interface{}, dst interface{}) error {
 146         var errw error
 147         pr, pw := io.Pipe()
 148         go func() {
 149                 defer pw.Close()
 150                 errw = json.NewEncoder(pw).Encode(src)
 151         }()
 152         defer pr.Close()
 153         err := json.NewDecoder(pr).Decode(dst)
 154         if errw != nil {
 155                 return errw
 156         }
 157         return err
 158 }
 159
 160 var intParams = map[string]bool{
 161         "limit":  true,
 162         "offset": true,
 163 }
 164
 165 var boolParams = map[string]bool{
 166         "distinct":                true,
 167         "ensure_unique_name":      true,
 168         "include_trash":           true,
 169         "include_old_versions":    true,
 170         "redirect_to_new_user":    true,
 171         "send_notification_email": true,
 172         "bypass_federation":       true,
 173 }
 174
 175 func stringToBool(s string) bool {
 176         switch s {
 177         case "", "false", "0":
 178                 return false
 179         default:
 180                 return true
 181         }
 182 }