# Maximum wall clock time to spend handling an incoming request.
RequestTimeout: 5m
+ WebsocketKeepaliveTimeout: 60s
+ WebsocketClientEventQueue: 64
+ WebsocketServerEventQueue: 4
+
Users:
# Config parameters to automatically setup new users. If enabled,
# this users will be able to self-activate. Enable this if you want
const defaultCrunchDispatchSlurmConfigPath = "/etc/arvados/crunch-dispatch-slurm/crunch-dispatch-slurm.yml"
+func loadOldClientConfig(cluster *arvados.Cluster, client *arvados.Client) {
+ if client == nil {
+ return
+ }
+ if client.APIHost != "" {
+ cluster.Services.Controller.ExternalURL.Host = client.APIHost
+ }
+ if client.Scheme != "" {
+ cluster.Services.Controller.ExternalURL.Scheme = client.Scheme
+ } else {
+ cluster.Services.Controller.ExternalURL.Scheme = "https"
+ }
+ if client.AuthToken != "" {
+ cluster.SystemRootToken = client.AuthToken
+ }
+ cluster.TLS.Insecure = client.Insecure
+}
+
// update config using values from an crunch-dispatch-slurm config file.
func (ldr *Loader) loadOldCrunchDispatchSlurmConfig(cfg *arvados.Config) error {
var oc oldCrunchDispatchSlurmConfig
return err
}
- if oc.Client != nil {
- u := arvados.URL{}
- u.Host = oc.Client.APIHost
- if oc.Client.Scheme != "" {
- u.Scheme = oc.Client.Scheme
- } else {
- u.Scheme = "https"
- }
- cluster.Services.Controller.ExternalURL = u
- cluster.SystemRootToken = oc.Client.AuthToken
- cluster.TLS.Insecure = oc.Client.Insecure
- }
+ loadOldClientConfig(cluster, oc.Client)
if oc.SbatchArguments != nil {
cluster.Containers.SLURM.SbatchArgumentsList = *oc.SbatchArguments
cfg.Clusters[cluster.ClusterID] = *cluster
return nil
}
+
+type oldWsConfig struct {
+ Client *arvados.Client
+ Postgres *arvados.PostgreSQLConnection
+ PostgresPool *int
+ Listen *string
+ LogLevel *string
+ LogFormat *string
+
+ PingTimeout *arvados.Duration
+ ClientEventQueue *int
+ ServerEventQueue *int
+
+ ManagementToken *string
+}
+
+const defaultWebsocketsConfigPath = "/etc/arvados/ws/ws.yml"
+
+// update config using values from an crunch-dispatch-slurm config file.
+func (ldr *Loader) loadOldWebsocketsConfig(cfg *arvados.Config) error {
+ var oc oldWsConfig
+ err := ldr.loadOldConfigHelper("arvados-ws", ldr.WebsocketsPath, &oc)
+ if os.IsNotExist(err) && ldr.WebsocketsPath == defaultWebsocketsConfigPath {
+ return nil
+ } else if err != nil {
+ return err
+ }
+
+ cluster, err := cfg.GetCluster("")
+ if err != nil {
+ return err
+ }
+
+ loadOldClientConfig(cluster, oc.Client)
+ fmt.Printf("Clllllllllllient %v %v", *oc.Client, cluster.Services.Controller.ExternalURL)
+
+ if oc.Postgres != nil {
+ cluster.PostgreSQL.Connection = *oc.Postgres
+ }
+ if oc.PostgresPool != nil {
+ cluster.PostgreSQL.ConnectionPool = *oc.PostgresPool
+ }
+ if oc.Listen != nil {
+ cluster.Services.Websocket.InternalURLs[arvados.URL{Host: *oc.Listen}] = arvados.ServiceInstance{}
+ }
+ if oc.LogLevel != nil {
+ cluster.SystemLogs.LogLevel = *oc.LogLevel
+ }
+ if oc.LogFormat != nil {
+ cluster.SystemLogs.Format = *oc.LogFormat
+ }
+ if oc.PingTimeout != nil {
+ cluster.API.WebsocketKeepaliveTimeout = *oc.PingTimeout
+ }
+ if oc.ClientEventQueue != nil {
+ cluster.API.WebsocketClientEventQueue = *oc.ClientEventQueue
+ }
+ if oc.ServerEventQueue != nil {
+ cluster.API.WebsocketServerEventQueue = *oc.ServerEventQueue
+ }
+ if oc.ManagementToken != nil {
+ cluster.ManagementToken = *oc.ManagementToken
+ }
+
+ cfg.Clusters[cluster.ClusterID] = *cluster
+ return nil
+}
"API.MaxRequestSize": true,
"API.RailsSessionSecretToken": false,
"API.RequestTimeout": true,
+ "API.WebsocketClientEventQueue": false,
+ "API.WebsocketKeepaliveTimeout": true,
+ "API.WebsocketServerEventQueue": false,
"AuditLogs": false,
"AuditLogs.MaxAge": false,
"AuditLogs.MaxDeleteBatch": false,
# Maximum wall clock time to spend handling an incoming request.
RequestTimeout: 5m
+ WebsocketKeepaliveTimeout: 60s
+ WebsocketClientEventQueue: 64
+ WebsocketServerEventQueue: 4
+
Users:
# Config parameters to automatically setup new users. If enabled,
# this users will be able to self-activate. Enable this if you want
Path string
KeepstorePath string
CrunchDispatchSlurmPath string
+ WebsocketsPath string
configdata []byte
}
flagset.StringVar(&ldr.Path, "config", arvados.DefaultConfigFile, "Site configuration `file` (default may be overridden by setting an ARVADOS_CONFIG environment variable)")
flagset.StringVar(&ldr.KeepstorePath, "legacy-keepstore-config", defaultKeepstoreConfigPath, "Legacy keepstore configuration `file`")
flagset.StringVar(&ldr.CrunchDispatchSlurmPath, "legacy-crunch-dispatch-slurm-config", defaultCrunchDispatchSlurmConfigPath, "Legacy crunch-dispatch-slurm configuration `file`")
+ flagset.StringVar(&ldr.WebsocketsPath, "legacy-ws-config", defaultWebsocketsConfigPath, "Legacy arvados-ws configuration `file`")
}
// MungeLegacyConfigArgs checks args for a -config flag whose argument
return ioutil.ReadAll(f)
}
+func (ldr *Loader) LoadDefaults() (*arvados.Config, error) {
+ ldr.configdata = []byte(`Clusters: {zzzzz: {}}`)
+ defer func() { ldr.configdata = nil }()
+ return ldr.Load()
+}
+
func (ldr *Loader) Load() (*arvados.Config, error) {
if ldr.configdata == nil {
buf, err := ldr.loadBytes(ldr.Path)
for _, err := range []error{
ldr.loadOldKeepstoreConfig(&cfg),
ldr.loadOldCrunchDispatchSlurmConfig(&cfg),
+ ldr.loadOldWebsocketsConfig(&cfg),
} {
if err != nil {
return nil, err
MaxRequestSize int
RailsSessionSecretToken string
RequestTimeout Duration
+ WebsocketKeepaliveTimeout Duration
+ WebsocketClientEventQueue int
+ WebsocketServerEventQueue int
}
AuditLogs struct {
MaxAge Duration
content := []byte(`
Client:
APIHost: example.com
- APIToken: abcdefg
+ AuthToken: abcdefg
SbatchArguments: ["--foo", "bar"]
PollPeriod: 12s
PrioritySpread: 42
c.Check(err, IsNil)
c.Check(s.disp.cluster.Services.Controller.ExternalURL, Equals, arvados.URL{Scheme: "https", Host: "example.com"})
+ c.Check(s.disp.cluster.SystemRootToken, Equals, "abcdefg")
c.Check(s.disp.cluster.Containers.SLURM.SbatchArgumentsList, DeepEquals, []string{"--foo", "bar"})
c.Check(s.disp.cluster.Containers.CloudVMs.PollInterval, Equals, arvados.Duration(12*time.Second))
c.Check(s.disp.cluster.Containers.SLURM.PrioritySpread, Equals, int64(42))
+++ /dev/null
-// Copyright (C) The Arvados Authors. All rights reserved.
-//
-// SPDX-License-Identifier: AGPL-3.0
-
-package main
-
-import (
- "time"
-
- "git.curoverse.com/arvados.git/sdk/go/arvados"
-)
-
-type wsConfig struct {
- Client arvados.Client
- Postgres arvados.PostgreSQLConnection
- PostgresPool int
- Listen string
- LogLevel string
- LogFormat string
-
- PingTimeout arvados.Duration
- ClientEventQueue int
- ServerEventQueue int
-
- ManagementToken string
-}
-
-func defaultConfig() wsConfig {
- return wsConfig{
- Client: arvados.Client{
- APIHost: "localhost:443",
- },
- Postgres: arvados.PostgreSQLConnection{
- "dbname": "arvados_production",
- "user": "arvados",
- "password": "xyzzy",
- "host": "localhost",
- "connect_timeout": "30",
- "sslmode": "require",
- "fallback_application_name": "arvados-ws",
- },
- PostgresPool: 64,
- LogLevel: "info",
- LogFormat: "json",
- PingTimeout: arvados.Duration(time.Minute),
- ClientEventQueue: 64,
- ServerEventQueue: 4,
- }
-}
import (
"flag"
"fmt"
+ "os"
- "git.curoverse.com/arvados.git/sdk/go/config"
+ "git.curoverse.com/arvados.git/lib/config"
+ "git.curoverse.com/arvados.git/sdk/go/arvados"
"git.curoverse.com/arvados.git/sdk/go/ctxlog"
+ "github.com/sirupsen/logrus"
+ "gopkg.in/yaml.v2"
)
var logger = ctxlog.FromContext
var version = "dev"
-func main() {
- log := logger(nil)
+func configure(log logrus.FieldLogger, args []string) *arvados.Cluster {
+ flags := flag.NewFlagSet(args[0], flag.ExitOnError)
+ dumpConfig := flags.Bool("dump-config", false, "show current configuration and exit")
+ getVersion := flags.Bool("version", false, "Print version information and exit.")
+
+ loader := config.NewLoader(nil, log)
+ loader.SetupFlags(flags)
+ args = loader.MungeLegacyConfigArgs(log, args[1:], "-legacy-ws-config")
- configPath := flag.String("config", "/etc/arvados/ws/ws.yml", "`path` to config file")
- dumpConfig := flag.Bool("dump-config", false, "show current configuration and exit")
- getVersion := flag.Bool("version", false, "Print version information and exit.")
- cfg := defaultConfig()
- flag.Parse()
+ flags.Parse(args)
// Print version information if requested
if *getVersion {
fmt.Printf("arvados-ws %s\n", version)
- return
+ return nil
}
- err := config.LoadFile(&cfg, *configPath)
+ cfg, err := loader.Load()
if err != nil {
log.Fatal(err)
}
- ctxlog.SetLevel(cfg.LogLevel)
- ctxlog.SetFormat(cfg.LogFormat)
+ cluster, err := cfg.GetCluster("")
+ if err != nil {
+ log.Fatal(err)
+ }
+
+ ctxlog.SetLevel(cluster.SystemLogs.LogLevel)
+ ctxlog.SetFormat(cluster.SystemLogs.Format)
if *dumpConfig {
- txt, err := config.Dump(&cfg)
+ out, err := yaml.Marshal(cfg)
if err != nil {
log.Fatal(err)
}
- fmt.Print(string(txt))
+ _, err = os.Stdout.Write(out)
+ if err != nil {
+ log.Fatal(err)
+ }
+ return nil
+ }
+ return cluster
+}
+
+func main() {
+ log := logger(nil)
+
+ cluster := configure(log, os.Args)
+ if cluster == nil {
return
}
log.Printf("arvados-ws %s started", version)
- srv := &server{wsConfig: &cfg}
+ srv := &server{cluster: cluster}
log.Fatal(srv.Run())
}
"sync/atomic"
"time"
+ "git.curoverse.com/arvados.git/sdk/go/arvados"
"git.curoverse.com/arvados.git/sdk/go/ctxlog"
"git.curoverse.com/arvados.git/sdk/go/health"
"github.com/sirupsen/logrus"
}
type router struct {
- Config *wsConfig
+ client arvados.Client
+ cluster *arvados.Cluster
eventSource eventSource
newPermChecker func() permChecker
func (rtr *router) setup() {
rtr.handler = &handler{
- PingTimeout: rtr.Config.PingTimeout.Duration(),
- QueueSize: rtr.Config.ClientEventQueue,
+ PingTimeout: time.Duration(rtr.cluster.API.WebsocketKeepaliveTimeout),
+ QueueSize: rtr.cluster.API.WebsocketClientEventQueue,
}
rtr.mux = http.NewServeMux()
rtr.mux.Handle("/websocket", rtr.makeServer(newSessionV0))
rtr.mux.Handle("/status.json", rtr.jsonHandler(rtr.Status))
rtr.mux.Handle("/_health/", &health.Handler{
- Token: rtr.Config.ManagementToken,
+ Token: rtr.cluster.ManagementToken,
Prefix: "/_health/",
Routes: health.Routes{
"db": rtr.eventSource.DBHealth,
stats := rtr.handler.Handle(ws, rtr.eventSource,
func(ws wsConn, sendq chan<- interface{}) (session, error) {
- return newSession(ws, sendq, rtr.eventSource.DB(), rtr.newPermChecker(), &rtr.Config.Client)
+ return newSession(ws, sendq, rtr.eventSource.DB(), rtr.newPermChecker(), &rtr.client)
})
log.WithFields(logrus.Fields{
"sync"
"time"
+ "git.curoverse.com/arvados.git/sdk/go/arvados"
"github.com/coreos/go-systemd/daemon"
)
type server struct {
httpServer *http.Server
listener net.Listener
- wsConfig *wsConfig
+ cluster *arvados.Cluster
eventSource *pgEventSource
setupOnce sync.Once
}
func (srv *server) setup() {
log := logger(nil)
- ln, err := net.Listen("tcp", srv.wsConfig.Listen)
+ var listen arvados.URL
+ for listen, _ = range srv.cluster.Services.Websocket.InternalURLs {
+ break
+ }
+ ln, err := net.Listen("tcp", listen.Host)
if err != nil {
- log.WithField("Listen", srv.wsConfig.Listen).Fatal(err)
+ log.WithField("Listen", listen).Fatal(err)
}
log.WithField("Listen", ln.Addr().String()).Info("listening")
+ client := arvados.Client{}
+ client.APIHost = srv.cluster.Services.Controller.ExternalURL.Host
+ client.AuthToken = srv.cluster.SystemRootToken
+ client.Insecure = srv.cluster.TLS.Insecure
+
srv.listener = ln
srv.eventSource = &pgEventSource{
- DataSource: srv.wsConfig.Postgres.String(),
- MaxOpenConns: srv.wsConfig.PostgresPool,
- QueueSize: srv.wsConfig.ServerEventQueue,
+ DataSource: srv.cluster.PostgreSQL.Connection.String(),
+ MaxOpenConns: srv.cluster.PostgreSQL.ConnectionPool,
+ QueueSize: srv.cluster.API.WebsocketServerEventQueue,
}
+
srv.httpServer = &http.Server{
- Addr: srv.wsConfig.Listen,
+ Addr: listen.Host,
ReadTimeout: time.Minute,
WriteTimeout: time.Minute,
MaxHeaderBytes: 1 << 20,
Handler: &router{
- Config: srv.wsConfig,
+ cluster: srv.cluster,
+ client: client,
eventSource: srv.eventSource,
- newPermChecker: func() permChecker { return newPermChecker(srv.wsConfig.Client) },
+ newPermChecker: func() permChecker { return newPermChecker(client) },
},
}
import (
"encoding/json"
"io/ioutil"
+ "log"
"net/http"
+ "os"
"sync"
"time"
+ "git.curoverse.com/arvados.git/lib/config"
"git.curoverse.com/arvados.git/sdk/go/arvados"
"git.curoverse.com/arvados.git/sdk/go/arvadostest"
check "gopkg.in/check.v1"
var _ = check.Suite(&serverSuite{})
type serverSuite struct {
- cfg *wsConfig
- srv *server
- wg sync.WaitGroup
+ cluster *arvados.Cluster
+ srv *server
+ wg sync.WaitGroup
}
func (s *serverSuite) SetUpTest(c *check.C) {
- s.cfg = s.testConfig()
- s.srv = &server{wsConfig: s.cfg}
+ var err error
+ s.cluster, err = s.testConfig()
+ c.Assert(err, check.IsNil)
+ s.srv = &server{cluster: s.cluster}
}
-func (*serverSuite) testConfig() *wsConfig {
- cfg := defaultConfig()
- cfg.Client = *(arvados.NewClientFromEnv())
- cfg.Postgres = testDBConfig()
- cfg.Listen = ":"
- cfg.ManagementToken = arvadostest.ManagementToken
- return &cfg
+func (*serverSuite) testConfig() (*arvados.Cluster, error) {
+ ldr := config.NewLoader(nil, nil)
+ cfg, err := ldr.LoadDefaults()
+ if err != nil {
+ return nil, err
+ }
+ cluster, err := cfg.GetCluster("")
+ if err != nil {
+ return nil, err
+ }
+ client := arvados.NewClientFromEnv()
+ cluster.Services.Controller.ExternalURL.Host = client.APIHost
+ cluster.SystemRootToken = client.AuthToken
+ cluster.TLS.Insecure = client.Insecure
+ cluster.PostgreSQL.Connection = testDBConfig()
+ cluster.Services.Websocket.InternalURLs = map[arvados.URL]arvados.ServiceInstance{arvados.URL{Host: ":"}: arvados.ServiceInstance{}}
+ cluster.ManagementToken = arvadostest.ManagementToken
+ return cluster, nil
}
// TestBadDB ensures Run() returns an error (instead of panicking or
// deadlocking) if it can't connect to the database server at startup.
func (s *serverSuite) TestBadDB(c *check.C) {
- s.cfg.Postgres["password"] = "1234"
+ s.cluster.PostgreSQL.Connection["password"] = "1234"
var wg sync.WaitGroup
wg.Add(1)
go s.srv.Run()
defer s.srv.Close()
s.srv.WaitReady()
- for _, token := range []string{"", "foo", s.cfg.ManagementToken} {
+ for _, token := range []string{"", "foo", s.cluster.ManagementToken} {
req, err := http.NewRequest("GET", "http://"+s.srv.listener.Addr().String()+"/_health/ping", nil)
c.Assert(err, check.IsNil)
if token != "" {
}
resp, err := http.DefaultClient.Do(req)
c.Check(err, check.IsNil)
- if token == s.cfg.ManagementToken {
+ if token == s.cluster.ManagementToken {
c.Check(resp.StatusCode, check.Equals, http.StatusOK)
buf, err := ioutil.ReadAll(resp.Body)
c.Check(err, check.IsNil)
}
func (s *serverSuite) TestHealthDisabled(c *check.C) {
- s.cfg.ManagementToken = ""
+ s.cluster.ManagementToken = ""
go s.srv.Run()
defer s.srv.Close()
c.Check(resp.StatusCode, check.Equals, http.StatusNotFound)
}
}
+
+func (s *serverSuite) TestLoadLegacyConfig(c *check.C) {
+ content := []byte(`
+Client:
+ APIHost: example.com
+ AuthToken: abcdefg
+Postgres:
+ "dbname": "arvados_production"
+ "user": "arvados"
+ "password": "xyzzy"
+ "host": "localhost"
+ "connect_timeout": "30"
+ "sslmode": "require"
+ "fallback_application_name": "arvados-ws"
+PostgresPool: 63
+Listen: ":8765"
+LogLevel: "debug"
+LogFormat: "text"
+PingTimeout: 61s
+ClientEventQueue: 62
+ServerEventQueue: 5
+ManagementToken: qqqqq
+`)
+ tmpfile, err := ioutil.TempFile("", "example")
+ if err != nil {
+ log.Fatal(err)
+ }
+
+ defer os.Remove(tmpfile.Name()) // clean up
+
+ if _, err := tmpfile.Write(content); err != nil {
+ log.Fatal(err)
+ }
+ if err := tmpfile.Close(); err != nil {
+ log.Fatal(err)
+
+ }
+ cluster := configure(logger(nil), []string{"arvados-ws", "-config", tmpfile.Name()})
+ c.Check(cluster, check.NotNil)
+
+ c.Check(cluster.Services.Controller.ExternalURL, check.Equals, arvados.URL{Scheme: "https", Host: "example.com"})
+ c.Check(cluster.SystemRootToken, check.Equals, "abcdefg")
+
+ c.Check(cluster.PostgreSQL.Connection.String(), check.Equals, "connect_timeout='30' dbname='arvados_production' fallback_application_name='arvados-ws' host='localhost' password='xyzzy' sslmode='require' user='arvados' ")
+ c.Check(cluster.PostgreSQL.ConnectionPool, check.Equals, 63)
+ c.Check(cluster.Services.Websocket.InternalURLs, check.DeepEquals, map[arvados.URL]arvados.ServiceInstance{
+ arvados.URL{Host: ":8765"}: arvados.ServiceInstance{}})
+ c.Check(cluster.SystemLogs.LogLevel, check.Equals, "debug")
+ c.Check(cluster.SystemLogs.Format, check.Equals, "text")
+ c.Check(cluster.API.WebsocketKeepaliveTimeout, check.Equals, arvados.Duration(61*time.Second))
+ c.Check(cluster.API.WebsocketClientEventQueue, check.Equals, 62)
+ c.Check(cluster.API.WebsocketServerEventQueue, check.Equals, 5)
+ c.Check(cluster.ManagementToken, check.Equals, "qqqqq")
+}
projects / arvados.git / commitdiff