16534: Merge branch 'master'

[arvados.git] / lib / controller / router / response.go

diff --git a/lib/controller/router/response.go b/lib/controller/router/response.go
index ddbeee666ff13f3ce4bd6b0a601c2774efc46622..543e25d0ce44f73c6cd87cc221aaace564f41a2c 100644 (file)
--- a/lib/controller/router/response.go
+++ b/lib/controller/router/response.go
@@ -6,18 +6,21 @@ package router
 
 import (
        "encoding/json"
+       "fmt"
        "net/http"
+       "regexp"
        "strings"
        "time"
 
-       "git.curoverse.com/arvados.git/sdk/go/arvados"
-       "git.curoverse.com/arvados.git/sdk/go/httpserver"
+       "git.arvados.org/arvados.git/sdk/go/arvados"
+       "git.arvados.org/arvados.git/sdk/go/httpserver"
 )
 
 const rfc3339NanoFixed = "2006-01-02T15:04:05.000000000Z07:00"
 
 type responseOptions struct {
        Select []string
+       Count  string
 }
 
 func (rtr *router) responseOptions(opts interface{}) (responseOptions, error) {
@@ -25,26 +28,84 @@ func (rtr *router) responseOptions(opts interface{}) (responseOptions, error) {
        switch opts := opts.(type) {
        case *arvados.GetOptions:
                rOpts.Select = opts.Select
+       case *arvados.ListOptions:
+               rOpts.Select = opts.Select
+               rOpts.Count = opts.Count
        }
        return rOpts, nil
 }
 
-func (rtr *router) sendResponse(w http.ResponseWriter, resp interface{}, opts responseOptions) {
+func applySelectParam(selectParam []string, orig map[string]interface{}) map[string]interface{} {
+       if len(selectParam) == 0 {
+               return orig
+       }
+       selected := map[string]interface{}{}
+       for _, attr := range selectParam {
+               if v, ok := orig[attr]; ok {
+                       selected[attr] = v
+               }
+       }
+       // Some keys are always preserved, even if not requested
+       for _, k := range []string{"etag", "kind", "writable_by"} {
+               if v, ok := orig[k]; ok {
+                       selected[k] = v
+               }
+       }
+       return selected
+}
+
+func (rtr *router) sendResponse(w http.ResponseWriter, req *http.Request, resp interface{}, opts responseOptions) {
        var tmp map[string]interface{}
+
+       if resp, ok := resp.(http.Handler); ok {
+               // resp knows how to write its own http response
+               // header and body.
+               resp.ServeHTTP(w, req)
+               return
+       }
+
        err := rtr.transcode(resp, &tmp)
        if err != nil {
                rtr.sendError(w, err)
                return
        }
-       if len(opts.Select) > 0 {
-               selected := map[string]interface{}{}
-               for _, attr := range opts.Select {
-                       if v, ok := tmp[attr]; ok {
-                               selected[attr] = v
+
+       respKind := kind(resp)
+       if respKind != "" {
+               tmp["kind"] = respKind
+       }
+       defaultItemKind := ""
+       if strings.HasSuffix(respKind, "List") {
+               defaultItemKind = strings.TrimSuffix(respKind, "List")
+       }
+
+       if items, ok := tmp["items"].([]interface{}); ok {
+               for i, item := range items {
+                       // Fill in "kind" by inspecting UUID/PDH if
+                       // possible; fall back on assuming each
+                       // Items[] entry in an "arvados#fooList"
+                       // response should have kind="arvados#foo".
+                       item, _ := item.(map[string]interface{})
+                       infix := ""
+                       if uuid, _ := item["uuid"].(string); len(uuid) == 27 {
+                               infix = uuid[6:11]
                        }
+                       if k := kind(infixMap[infix]); k != "" {
+                               item["kind"] = k
+                       } else if pdh, _ := item["portable_data_hash"].(string); pdh != "" {
+                               item["kind"] = "arvados#collection"
+                       } else if defaultItemKind != "" {
+                               item["kind"] = defaultItemKind
+                       }
+                       items[i] = applySelectParam(opts.Select, item)
+               }
+               if opts.Count == "none" {
+                       delete(tmp, "items_available")
                }
-               tmp = selected
+       } else {
+               tmp = applySelectParam(opts.Select, tmp)
        }
+
        // Format non-nil timestamps as rfc3339NanoFixed (by default
        // they will have been encoded to time.RFC3339Nano, which
        // omits trailing zeroes).
@@ -68,7 +129,10 @@ func (rtr *router) sendResponse(w http.ResponseWriter, resp interface{}, opts re
                        tmp[k] = t.Format(rfc3339NanoFixed)
                }
        }
-       json.NewEncoder(w).Encode(tmp)
+       w.Header().Set("Content-Type", "application/json")
+       enc := json.NewEncoder(w)
+       enc.SetEscapeHTML(false)
+       enc.Encode(tmp)
 }
 
 func (rtr *router) sendError(w http.ResponseWriter, err error) {
@@ -78,3 +142,21 @@ func (rtr *router) sendError(w http.ResponseWriter, err error) {
        }
        httpserver.Error(w, err.Error(), code)
 }
+
+var infixMap = map[string]interface{}{
+       "4zz18": arvados.Collection{},
+       "j7d0g": arvados.Group{},
+}
+
+var mungeKind = regexp.MustCompile(`\..`)
+
+func kind(resp interface{}) string {
+       t := fmt.Sprintf("%T", resp)
+       if !strings.HasPrefix(t, "arvados.") {
+               return ""
+       }
+       return mungeKind.ReplaceAllStringFunc(t, func(s string) string {
+               // "arvados.CollectionList" => "arvados#collectionList"
+               return "#" + strings.ToLower(s[1:])
+       })
+}