+// Copyright (C) The Arvados Authors. All rights reserved.
+//
+// SPDX-License-Identifier: AGPL-3.0
+
package main
import (
"git.curoverse.com/arvados.git/sdk/go/arvados"
"git.curoverse.com/arvados.git/sdk/go/arvadosclient"
"git.curoverse.com/arvados.git/sdk/go/auth"
+ "git.curoverse.com/arvados.git/sdk/go/health"
"git.curoverse.com/arvados.git/sdk/go/httpserver"
"git.curoverse.com/arvados.git/sdk/go/keepclient"
)
type handler struct {
- Config *Config
- clientPool *arvadosclient.ClientPool
- setupOnce sync.Once
+ Config *Config
+ clientPool *arvadosclient.ClientPool
+ setupOnce sync.Once
+ healthHandler http.Handler
}
// parseCollectionIDFromDNSName returns a UUID or PDH if s begins with
func (h *handler) setup() {
h.clientPool = arvadosclient.MakeClientPool()
+
keepclient.RefreshServiceDiscoveryOnSIGHUP()
+
+ h.healthHandler = &health.Handler{
+ Token: h.Config.ManagementToken,
+ Prefix: "/_health/",
+ }
}
func (h *handler) serveStatus(w http.ResponseWriter, r *http.Request) {
httpserver.Log(remoteAddr, statusCode, statusText, w.WroteBodyBytes(), r.Method, r.Host, r.URL.Path, r.URL.RawQuery)
}()
+ if strings.HasPrefix(r.URL.Path, "/_health/") && r.Method == "GET" {
+ h.healthHandler.ServeHTTP(w, r)
+ return
+ }
+
if r.Method == "OPTIONS" {
method := r.Header.Get("Access-Control-Request-Method")
if method != "GET" && method != "POST" {
// SSL certificates. See
// http://www.w3.org/TR/cors/#user-credentials).
w.Header().Set("Access-Control-Allow-Origin", "*")
+ w.Header().Set("Access-Control-Expose-Headers", "Content-Range")
}
arv := h.clientPool.Get()
h.serveStatus(w, r)
return
} else if len(pathParts) >= 1 && strings.HasPrefix(pathParts[0], "c=") {
- // /c=ID/PATH...
+ // /c=ID[/PATH...]
targetID = parseCollectionIDFromURL(pathParts[0][2:])
stripParts = 1
} else if len(pathParts) >= 2 && pathParts[0] == "collections" {
forceReload = true
}
- var collection map[string]interface{}
+ var collection *arvados.Collection
tokenResult := make(map[string]int)
- found := false
for _, arv.ApiToken = range tokens {
var err error
collection, err = h.Config.Cache.Get(arv, targetID, forceReload)
if err == nil {
// Success
- found = true
break
}
if srvErr, ok := err.(arvadosclient.APIServerError); ok {
statusCode, statusText = http.StatusInternalServerError, err.Error()
return
}
- if !found {
+ if collection == nil {
if pathToken || !credentialsOK {
// Either the URL is a "secret sharing link"
// that didn't work out (and asking the client
basename := targetPath[len(targetPath)-1]
applyContentDispositionHdr(w, r, basename, attachment)
- j, err := json.Marshal(collection)
- if err != nil {
- panic(err)
- }
- var coll arvados.Collection
- err = json.Unmarshal(j, &coll)
- if err != nil {
- panic(err)
- }
- fs := coll.FileSystem(&arvados.Client{
+ fs := collection.FileSystem(&arvados.Client{
APIHost: arv.ApiServer,
AuthToken: arv.ApiToken,
Insecure: arv.ApiInsecure,
}, kc)
openPath := "/" + strings.Join(targetPath, "/")
if f, err := fs.Open(openPath); os.IsNotExist(err) {
+ // Requested non-existent path
statusCode = http.StatusNotFound
} else if err != nil {
+ // Some other (unexpected) error
statusCode, statusText = http.StatusInternalServerError, err.Error()
} else if stat, err := f.Stat(); err != nil {
+ // Can't get Size/IsDir (shouldn't happen with a collectionFS!)
statusCode, statusText = http.StatusInternalServerError, err.Error()
} else if stat.IsDir() && !strings.HasSuffix(r.URL.Path, "/") {
+ // If client requests ".../dirname", redirect to
+ // ".../dirname/". This way, relative links in the
+ // listing for "dirname" can always be "fnm", never
+ // "dirname/fnm".
h.seeOtherWithCookie(w, r, basename+"/", credentialsOK)
} else if stat.IsDir() {
- h.serveDirectory(w, r, &coll, fs, openPath, stripParts)
+ h.serveDirectory(w, r, collection.Name, fs, openPath, stripParts)
} else {
http.ServeContent(w, r, basename, stat.ModTime(), f)
- if int64(w.WroteBodyBytes()) != stat.Size() {
+ if r.Header.Get("Range") == "" && int64(w.WroteBodyBytes()) != stat.Size() {
+ // If we wrote fewer bytes than expected, it's
+ // too late to change the real response code
+ // or send an error message to the client, but
+ // at least we can try to put some useful
+ // debugging info in the logs.
n, err := f.Read(make([]byte, 1024))
statusCode, statusText = http.StatusInternalServerError, fmt.Sprintf("f.Size()==%d but only wrote %d bytes; read(1024) returns %d, %s", stat.Size(), w.WroteBodyBytes(), n, err)
.footer p {
font-size: 82%;
}
+ ul {
+ padding: 0;
+ }
ul li {
font-family: monospace;
+ list-style: none;
}
</STYLE>
</HEAD>
<BODY>
-<H1>{{ .Collection.Name }}</H1>
+<H1>{{ .CollectionName }}</H1>
<P>This collection of data files is being shared with you through
Arvados. You can download individual files listed below. To download
<H2>File Listing</H2>
+{{if .Files}}
<UL>
-{{range .Files}} <LI><A href="{{.}}">{{.}}</A></LI>{{end}}
+{{range .Files}} <LI>{{.Size | printf "%15d " | nbsp}}<A href="{{.Name}}">{{.Name}}</A></LI>{{end}}
</UL>
+{{else}}
+<P>(No files; this collection is empty.)</P>
+{{end}}
<HR noshade>
<DIV class="footer">
</BODY>
`
-func (h *handler) serveDirectory(w http.ResponseWriter, r *http.Request, collection *arvados.Collection, fs http.FileSystem, base string, stripParts int) {
- var files []string
+type fileListEnt struct {
+ Name string
+ Size int64
+}
+
+func (h *handler) serveDirectory(w http.ResponseWriter, r *http.Request, collectionName string, fs http.FileSystem, base string, stripParts int) {
+ var files []fileListEnt
var walk func(string) error
if !strings.HasSuffix(base, "/") {
base = base + "/"
return err
}
} else {
- files = append(files, path+ent.Name())
+ files = append(files, fileListEnt{
+ Name: path + ent.Name(),
+ Size: ent.Size(),
+ })
}
}
return nil
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
- tmpl, err := template.New("dir").Parse(dirListingTemplate)
+
+ funcs := template.FuncMap{
+ "nbsp": func(s string) template.HTML {
+ return template.HTML(strings.Replace(s, " ", " ", -1))
+ },
+ }
+ tmpl, err := template.New("dir").Funcs(funcs).Parse(dirListingTemplate)
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
- sort.Strings(files)
+ sort.Slice(files, func(i, j int) bool {
+ return files[i].Name < files[j].Name
+ })
w.WriteHeader(http.StatusOK)
tmpl.Execute(w, map[string]interface{}{
- "Collection": collection,
- "Files": files,
- "Request": r,
- "StripParts": stripParts,
+ "CollectionName": collectionName,
+ "Files": files,
+ "Request": r,
+ "StripParts": stripParts,
})
}
projects / arvados.git / blobdiff