--- /dev/null
+// Copyright (C) The Arvados Authors. All rights reserved.
+//
+// SPDX-License-Identifier: AGPL-3.0
+
+package diagnostics
+
+import (
+ "bytes"
+ "flag"
+ "fmt"
+ "io"
+ "io/ioutil"
+ "net/http"
+ "strings"
+ "time"
+
+ "git.arvados.org/arvados.git/sdk/go/arvados"
+ "git.arvados.org/arvados.git/sdk/go/ctxlog"
+ "github.com/sirupsen/logrus"
+)
+
+type Command struct {
+ projectName string
+}
+
+func (diag Command) RunCommand(prog string, args []string, stdin io.Reader, stdout, stderr io.Writer) int {
+ f := flag.NewFlagSet(prog, flag.ContinueOnError)
+ f.StringVar(&diag.projectName, "project-name", "scratch area for diagnostics", "name of project to find/create in home project and use for temporary/test objects")
+ loglevel := f.String("log-level", "info", "logging level (debug, info, warning, error)")
+ checkInternal := f.Bool("internal-client", false, "check that this host is considered an \"internal\" client")
+ checkExternal := f.Bool("external-client", false, "check that this host is considered an \"external\" client")
+ err := f.Parse(args)
+ if err == flag.ErrHelp {
+ return 0
+ } else if err != nil {
+ fmt.Fprintln(stderr, err)
+ return 2
+ }
+
+ logger := ctxlog.New(stdout, "text", *loglevel)
+ logger.SetFormatter(&logrus.TextFormatter{DisableTimestamp: true, DisableLevelTruncation: true})
+
+ infof := logger.Infof
+ warnf := logger.Warnf
+ var errors []string
+ errorf := func(f string, args ...interface{}) {
+ logger.Errorf(f, args...)
+ errors = append(errors, fmt.Sprintf(f, args...))
+ }
+ defer func() {
+ if len(errors) == 0 {
+ logger.Info("--- no errors ---")
+ } else {
+ fmt.Fprint(stdout, "\n--- cut here --- error summary ---\n\n")
+ for _, e := range errors {
+ logger.Error(e)
+ }
+ }
+ }()
+
+ client := arvados.NewClientFromEnv()
+
+ var dd arvados.DiscoveryDocument
+ ddpath := "discovery/v1/apis/arvados/v1/rest"
+ testname := fmt.Sprintf("getting discovery document from https://%s/%s", client.APIHost, ddpath)
+ logger.Info(testname)
+ err = client.RequestAndDecode(&dd, "GET", ddpath, nil, nil)
+ if err != nil {
+ errorf("%s: %s", testname, err)
+ } else {
+ infof("%s: ok, BlobSignatureTTL is %d", testname, dd.BlobSignatureTTL)
+ }
+
+ var cluster arvados.Cluster
+ cfgpath := "arvados/v1/config"
+ testname = fmt.Sprintf("getting exported config from https://%s/%s", client.APIHost, cfgpath)
+ logger.Info(testname)
+ err = client.RequestAndDecode(&cluster, "GET", cfgpath, nil, nil)
+ if err != nil {
+ errorf("%s: %s", testname, err)
+ } else {
+ infof("%s: ok, Collections.BlobSigning = %v", testname, cluster.Collections.BlobSigning)
+ }
+
+ var user arvados.User
+ testname = "getting current user record"
+ logger.Info(testname)
+ err = client.RequestAndDecode(&user, "GET", "arvados/v1/users/current", nil, nil)
+ if err != nil {
+ errorf("%s: %s", testname, err)
+ return 2
+ } else {
+ infof("%s: ok, uuid = %s", testname, user.UUID)
+ }
+
+ // uncomment to create some spurious errors
+ // cluster.Services.WebDAVDownload.ExternalURL.Host = "0.0.0.0:9"
+
+ // TODO: detect routing errors here, like finding wb2 at the
+ // wb1 address.
+ for _, svc := range []*arvados.Service{
+ &cluster.Services.Keepproxy,
+ &cluster.Services.WebDAV,
+ &cluster.Services.WebDAVDownload,
+ &cluster.Services.Websocket,
+ &cluster.Services.Workbench1,
+ &cluster.Services.Workbench2,
+ } {
+ testname = fmt.Sprintf("connecting to service endpoint %s", svc.ExternalURL)
+ logger.Info(testname)
+ u := svc.ExternalURL
+ if strings.HasPrefix(u.Scheme, "ws") {
+ // We can do a real websocket test elsewhere,
+ // but for now we'll just check the https
+ // connection.
+ u.Scheme = "http" + u.Scheme[2:]
+ }
+ if svc == &cluster.Services.WebDAV && strings.HasPrefix(u.Host, "*") {
+ u.Host = "d41d8cd98f00b204e9800998ecf8427e-0" + u.Host[1:]
+ }
+ req, err := http.NewRequest(http.MethodGet, u.String(), nil)
+ if err != nil {
+ errorf("%s: %s", testname, err)
+ continue
+ }
+ resp, err := http.DefaultClient.Do(req)
+ if err != nil {
+ errorf("%s: %s", testname, err)
+ continue
+ }
+ resp.Body.Close()
+ infof("%s: ok", testname)
+ }
+
+ for _, url := range []string{
+ cluster.Services.Controller.ExternalURL.String(),
+ cluster.Services.Keepproxy.ExternalURL.String() + "d41d8cd98f00b204e9800998ecf8427e+0",
+ cluster.Services.WebDAVDownload.ExternalURL.String(),
+ } {
+ testname = fmt.Sprintf("checking CORS headers at %s", url)
+ logger.Info(testname)
+ req, err := http.NewRequest("GET", url, nil)
+ if err != nil {
+ errorf("%s: %s", testname, err)
+ continue
+ }
+ req.Header.Set("Origin", "https://example.com")
+ resp, err := http.DefaultClient.Do(req)
+ if err != nil {
+ errorf("%s: %s", testname, err)
+ continue
+ }
+ if hdr := resp.Header.Get("Access-Control-Allow-Origin"); hdr != "*" {
+ warnf("%s: expected \"Access-Control-Allow-Origin: *\", got %q", testname, hdr)
+ } else {
+ infof("%s: ok", testname)
+ }
+ }
+
+ var keeplist arvados.KeepServiceList
+ testname = "checking internal/external client detection"
+ logger.Info(testname)
+ err = client.RequestAndDecode(&keeplist, "GET", "arvados/v1/keep_services/accessible", nil, arvados.ListOptions{Limit: -1})
+ if err != nil {
+ errorf("%s: error getting keep services list: %s", testname, err)
+ } else if len(keeplist.Items) == 0 {
+ errorf("%s: controller did not return any keep services", testname)
+ } else {
+ found := map[string]int{}
+ for _, ks := range keeplist.Items {
+ found[ks.ServiceType]++
+ }
+ infof := infof
+ isInternal := found["proxy"] == 0 && len(keeplist.Items) > 0
+ isExternal := found["proxy"] > 0 && found["proxy"] == len(keeplist.Items)
+ if (*checkInternal && !isInternal) || (*checkExternal && !isExternal) {
+ infof = errorf
+ }
+ if isExternal {
+ infof("%s: controller returned only proxy services, this host is considered \"external\"", testname)
+ } else if isInternal {
+ infof("%s: controller returned only non-proxy services, this host is considered \"internal\"", testname)
+ } else {
+ errorf("%s: controller returned both proxy and non-proxy services: %v", testname, found)
+ }
+ }
+
+ var project arvados.Group
+ var grplist arvados.GroupList
+ testname = fmt.Sprintf("finding/creating %q project", diag.projectName)
+ logger.Info(testname)
+ err = client.RequestAndDecode(&grplist, "GET", "arvados/v1/groups", nil, arvados.ListOptions{
+ Filters: []arvados.Filter{
+ {"name", "=", diag.projectName},
+ {"group_class", "=", "project"},
+ {"owner_uuid", "=", user.UUID}},
+ Limit: -1})
+ if err != nil {
+ errorf("%s: list groups: %s", testname, err)
+ } else if len(grplist.Items) < 1 {
+ infof("%s: list groups: ok, no results", testname)
+ err = client.RequestAndDecode(&project, "POST", "arvados/v1/groups", nil, map[string]interface{}{"group": map[string]interface{}{
+ "name": diag.projectName,
+ "group_class": "project",
+ }})
+ if err != nil {
+ errorf("%s: create project: %s", testname, err)
+ } else {
+ infof("%s: created project, uuid = %s", testname, project.UUID)
+ }
+ } else {
+ project = grplist.Items[0]
+ infof("%s: ok, using existing project, uuid = %s", testname, project.UUID)
+ }
+
+ testname = "creating temporary collection"
+ logger.Info(testname)
+ var collection arvados.Collection
+ err = client.RequestAndDecode(&collection, "POST", "arvados/v1/collections", nil, map[string]interface{}{
+ "ensure_unique_name": true,
+ "collection": map[string]interface{}{
+ "name": "test collection",
+ "trash_at": time.Now().Add(time.Hour)}})
+ if err != nil {
+ errorf("%s: %s", testname, err)
+ } else {
+ infof("%s: ok, uuid = %s", testname, collection.UUID)
+ defer func() {
+ testname := "deleting temporary collection"
+ logger.Info(testname)
+ err := client.RequestAndDecode(nil, "DELETE", "arvados/v1/collections/"+collection.UUID, nil, nil)
+ if err != nil {
+ errorf("%s: %s", testname, err)
+ } else {
+ infof("%s: ok", testname)
+ }
+ }()
+ }
+
+ testname = "uploading file via webdav"
+ logger.Info(testname)
+ func() {
+ if collection.UUID == "" {
+ infof("%s: skipping, no test collection", testname)
+ return
+ }
+ req, err := http.NewRequest("PUT", cluster.Services.WebDAVDownload.ExternalURL.String()+"c="+collection.UUID+"/testfile", bytes.NewBufferString("testfiledata"))
+ if err != nil {
+ errorf("%s: BUG? http.NewRequest: %s", testname, err)
+ return
+ }
+ req.Header.Set("Authorization", "Bearer "+client.AuthToken)
+ resp, err := http.DefaultClient.Do(req)
+ if err != nil {
+ errorf("%s: error performing http request: %s", testname, err)
+ return
+ }
+ resp.Body.Close()
+ if resp.StatusCode != http.StatusCreated {
+ errorf("%s: status %s", testname, resp.Status)
+ return
+ }
+ infof("%s: ok, status %s", testname, resp.Status)
+ err = client.RequestAndDecode(&collection, "GET", "arvados/v1/collections/"+collection.UUID, nil, nil)
+ if err != nil {
+ errorf("%s: get updated collection: %s", testname, err)
+ return
+ }
+ infof("%s: get updated collection: ok, pdh %s", testname, collection.PortableDataHash)
+ }()
+
+ davurl := cluster.Services.WebDAV.ExternalURL
+ testname = fmt.Sprintf("checking WebDAV ExternalURL wildcard (%s)", davurl)
+ logger.Info(testname)
+ if strings.HasPrefix(davurl.Host, "*--") || strings.HasPrefix(davurl.Host, "*.") {
+ infof("%s: looks ok", testname)
+ } else if davurl.Host == "" {
+ warnf("%s: host missing - content previews will not work", testname)
+ } else {
+ warnf("%s: host has no leading wildcard - content previews will not work unless TrustAllContent==true", testname)
+ }
+
+ for _, trial := range []struct {
+ status int
+ fileurl string
+ }{
+ {http.StatusNotFound, strings.Replace(davurl.String(), "*", "d41d8cd98f00b204e9800998ecf8427e-0", 1) + "foo"},
+ {http.StatusNotFound, strings.Replace(davurl.String(), "*", "d41d8cd98f00b204e9800998ecf8427e-0", 1) + "testfile"},
+ {http.StatusNotFound, cluster.Services.WebDAVDownload.ExternalURL.String() + "c=d41d8cd98f00b204e9800998ecf8427e+0/_/foo"},
+ {http.StatusNotFound, cluster.Services.WebDAVDownload.ExternalURL.String() + "c=d41d8cd98f00b204e9800998ecf8427e+0/_/testfile"},
+ {http.StatusOK, strings.Replace(davurl.String(), "*", strings.Replace(collection.PortableDataHash, "+", "-", -1), 1) + "testfile"},
+ {http.StatusOK, cluster.Services.WebDAVDownload.ExternalURL.String() + "c=" + collection.UUID + "/_/testfile"},
+ } {
+ func() {
+ testname := fmt.Sprintf("downloading from webdav (%s)", trial.fileurl)
+ logger.Info(testname)
+ if collection.UUID == "" {
+ errorf("%s: skipping, no test collection", testname)
+ return
+ }
+ req, err := http.NewRequest("GET", trial.fileurl, nil)
+ if err != nil {
+ errorf("%s: %s", testname, err)
+ return
+ }
+ req.Header.Set("Authorization", "Bearer "+client.AuthToken)
+ resp, err := http.DefaultClient.Do(req)
+ if err != nil {
+ errorf("%s: %s", testname, err)
+ return
+ }
+ defer resp.Body.Close()
+ body, err := ioutil.ReadAll(resp.Body)
+ if err != nil {
+ errorf("%s: error reading response: %s", testname, err)
+ }
+ if resp.StatusCode != trial.status {
+ errorf("%s: unexpected response status: %s", testname, resp.Status)
+ } else if trial.status == http.StatusOK && string(body) != "testfiledata" {
+ errorf("%s: unexpected response content: %q", testname, body)
+ } else {
+ infof("%s: ok", testname)
+ }
+ }()
+ }
+
+ return 0
+}
projects / arvados.git / commitdiff