lib/config/deprecated.go

   1 // Copyright (C) The Arvados Authors. All rights reserved.
   2 //
   3 // SPDX-License-Identifier: AGPL-3.0
   4
   5 package config
   6
   7 import (
   8         "encoding/json"
   9         "fmt"
  10         "io/ioutil"
  11         "net/url"
  12         "os"
  13         "strings"
  14
  15         "git.arvados.org/arvados.git/sdk/go/arvados"
  16         "github.com/ghodss/yaml"
  17 )
  18
  19 type deprRequestLimits struct {
  20         MaxItemsPerResponse            *int
  21         MultiClusterRequestConcurrency *int
  22 }
  23
  24 type deprCluster struct {
  25         RequestLimits deprRequestLimits
  26         NodeProfiles  map[string]nodeProfile
  27         Login         struct {
  28                 GoogleClientID                *string
  29                 GoogleClientSecret            *string
  30                 GoogleAlternateEmailAddresses *bool
  31                 ProviderAppID                 *string
  32                 ProviderAppSecret             *string
  33         }
  34 }
  35
  36 type deprecatedConfig struct {
  37         Clusters map[string]deprCluster
  38 }
  39
  40 type nodeProfile struct {
  41         Controller    systemServiceInstance `json:"arvados-controller"`
  42         Health        systemServiceInstance `json:"arvados-health"`
  43         Keepbalance   systemServiceInstance `json:"keep-balance"`
  44         Keepproxy     systemServiceInstance `json:"keepproxy"`
  45         Keepstore     systemServiceInstance `json:"keepstore"`
  46         Keepweb       systemServiceInstance `json:"keep-web"`
  47         DispatchCloud systemServiceInstance `json:"arvados-dispatch-cloud"`
  48         RailsAPI      systemServiceInstance `json:"arvados-api-server"`
  49         Websocket     systemServiceInstance `json:"arvados-ws"`
  50         Workbench1    systemServiceInstance `json:"arvados-workbench"`
  51 }
  52
  53 type systemServiceInstance struct {
  54         Listen   string
  55         TLS      bool
  56         Insecure bool
  57 }
  58
  59 func (ldr *Loader) applyDeprecatedConfig(cfg *arvados.Config) error {
  60         var dc deprecatedConfig
  61         err := yaml.Unmarshal(ldr.configdata, &dc)
  62         if err != nil {
  63                 return err
  64         }
  65         hostname, err := os.Hostname()
  66         if err != nil {
  67                 return err
  68         }
  69         for id, dcluster := range dc.Clusters {
  70                 cluster, ok := cfg.Clusters[id]
  71                 if !ok {
  72                         return fmt.Errorf("can't load legacy config %q that is not present in current config", id)
  73                 }
  74                 for name, np := range dcluster.NodeProfiles {
  75                         if name == "*" || name == os.Getenv("ARVADOS_NODE_PROFILE") || name == hostname {
  76                                 name = "localhost"
  77                         } else if ldr.Logger != nil {
  78                                 ldr.Logger.Warnf("overriding Clusters.%s.Services using Clusters.%s.NodeProfiles.%s (guessing %q is a hostname)", id, id, name, name)
  79                         }
  80                         applyDeprecatedNodeProfile(name, np.RailsAPI, &cluster.Services.RailsAPI)
  81                         applyDeprecatedNodeProfile(name, np.Controller, &cluster.Services.Controller)
  82                         applyDeprecatedNodeProfile(name, np.DispatchCloud, &cluster.Services.DispatchCloud)
  83                 }
  84                 if dst, n := &cluster.API.MaxItemsPerResponse, dcluster.RequestLimits.MaxItemsPerResponse; n != nil && *n != *dst {
  85                         *dst = *n
  86                 }
  87                 if dst, n := &cluster.API.MaxRequestAmplification, dcluster.RequestLimits.MultiClusterRequestConcurrency; n != nil && *n != *dst {
  88                         *dst = *n
  89                 }
  90
  91                 // Google* moved to Google.*
  92                 if dst, n := &cluster.Login.Google.ClientID, dcluster.Login.GoogleClientID; n != nil && *n != *dst {
  93                         *dst = *n
  94                         if *n != "" {
  95                                 // In old config, non-empty ClientID meant enable
  96                                 cluster.Login.Google.Enable = true
  97                         }
  98                 }
  99                 if dst, n := &cluster.Login.Google.ClientSecret, dcluster.Login.GoogleClientSecret; n != nil && *n != *dst {
 100                         *dst = *n
 101                 }
 102                 if dst, n := &cluster.Login.Google.AlternateEmailAddresses, dcluster.Login.GoogleAlternateEmailAddresses; n != nil && *n != *dst {
 103                         *dst = *n
 104                 }
 105
 106                 cfg.Clusters[id] = cluster
 107         }
 108         return nil
 109 }
 110
 111 func (ldr *Loader) applyDeprecatedVolumeDriverParameters(cfg *arvados.Config) error {
 112         for clusterID, cluster := range cfg.Clusters {
 113                 for volID, vol := range cluster.Volumes {
 114                         if vol.Driver == "S3" {
 115                                 var params struct {
 116                                         AccessKey       string `json:",omitempty"`
 117                                         SecretKey       string `json:",omitempty"`
 118                                         AccessKeyID     string
 119                                         SecretAccessKey string
 120                                 }
 121                                 err := json.Unmarshal(vol.DriverParameters, &params)
 122                                 if err != nil {
 123                                         return fmt.Errorf("error loading %s.Volumes.%s.DriverParameters: %w", clusterID, volID, err)
 124                                 }
 125                                 if params.AccessKey != "" || params.SecretKey != "" {
 126                                         if params.AccessKeyID != "" || params.SecretAccessKey != "" {
 127                                                 return fmt.Errorf("cannot use old keys (AccessKey/SecretKey) and new keys (AccessKeyID/SecretAccessKey) at the same time in %s.Volumes.%s.DriverParameters -- you must remove the old config keys", clusterID, volID)
 128                                         }
 129                                         var allparams map[string]interface{}
 130                                         err = json.Unmarshal(vol.DriverParameters, &allparams)
 131                                         if err != nil {
 132                                                 return fmt.Errorf("error loading %s.Volumes.%s.DriverParameters: %w", clusterID, volID, err)
 133                                         }
 134                                         for k := range allparams {
 135                                                 if lk := strings.ToLower(k); lk == "accesskey" || lk == "secretkey" {
 136                                                         delete(allparams, k)
 137                                                 }
 138                                         }
 139                                         ldr.Logger.Warnf("using your old config keys %s.Volumes.%s.DriverParameters.AccessKey/SecretKey -- but you should rename them to AccessKeyID/SecretAccessKey", clusterID, volID)
 140                                         allparams["AccessKeyID"] = params.AccessKey
 141                                         allparams["SecretAccessKey"] = params.SecretKey
 142                                         vol.DriverParameters, err = json.Marshal(allparams)
 143                                         if err != nil {
 144                                                 return err
 145                                         }
 146                                         cluster.Volumes[volID] = vol
 147                                 }
 148                         }
 149                 }
 150         }
 151         return nil
 152 }
 153
 154 func applyDeprecatedNodeProfile(hostname string, ssi systemServiceInstance, svc *arvados.Service) {
 155         scheme := "https"
 156         if !ssi.TLS {
 157                 scheme = "http"
 158         }
 159         if svc.InternalURLs == nil {
 160                 svc.InternalURLs = map[arvados.URL]arvados.ServiceInstance{}
 161         }
 162         host := ssi.Listen
 163         if host == "" {
 164                 return
 165         }
 166         if strings.HasPrefix(host, ":") {
 167                 host = hostname + host
 168         }
 169         svc.InternalURLs[arvados.URL{Scheme: scheme, Host: host, Path: "/"}] = arvados.ServiceInstance{}
 170 }
 171
 172 func (ldr *Loader) loadOldConfigHelper(component, path string, target interface{}) error {
 173         if path == "" {
 174                 return nil
 175         }
 176         buf, err := ioutil.ReadFile(path)
 177         if err != nil {
 178                 return err
 179         }
 180
 181         ldr.Logger.Warnf("you should remove the legacy %v config file (%s) after migrating all config keys to the cluster configuration file (%s)", component, path, ldr.Path)
 182
 183         err = yaml.Unmarshal(buf, target)
 184         if err != nil {
 185                 return fmt.Errorf("%s: %s", path, err)
 186         }
 187         return nil
 188 }
 189
 190 type oldCrunchDispatchSlurmConfig struct {
 191         Client *arvados.Client
 192
 193         SbatchArguments *[]string
 194         PollPeriod      *arvados.Duration
 195         PrioritySpread  *int64
 196
 197         // crunch-run command to invoke. The container UUID will be
 198         // appended. If nil, []string{"crunch-run"} will be used.
 199         //
 200         // Example: []string{"crunch-run", "--cgroup-parent-subsystem=memory"}
 201         CrunchRunCommand *[]string
 202
 203         // Extra RAM to reserve (in Bytes) for SLURM job, in addition
 204         // to the amount specified in the container's RuntimeConstraints
 205         ReserveExtraRAM *int64
 206
 207         // Minimum time between two attempts to run the same container
 208         MinRetryPeriod *arvados.Duration
 209
 210         // Batch size for container queries
 211         BatchSize *int64
 212 }
 213
 214 const defaultCrunchDispatchSlurmConfigPath = "/etc/arvados/crunch-dispatch-slurm/crunch-dispatch-slurm.yml"
 215
 216 func loadOldClientConfig(cluster *arvados.Cluster, client *arvados.Client) {
 217         if client == nil {
 218                 return
 219         }
 220         if client.APIHost != "" {
 221                 cluster.Services.Controller.ExternalURL.Host = client.APIHost
 222                 cluster.Services.Controller.ExternalURL.Path = "/"
 223         }
 224         if client.Scheme != "" {
 225                 cluster.Services.Controller.ExternalURL.Scheme = client.Scheme
 226         } else {
 227                 cluster.Services.Controller.ExternalURL.Scheme = "https"
 228         }
 229         if client.AuthToken != "" {
 230                 cluster.SystemRootToken = client.AuthToken
 231         }
 232         cluster.TLS.Insecure = client.Insecure
 233         ks := ""
 234         for i, u := range client.KeepServiceURIs {
 235                 if i > 0 {
 236                         ks += " "
 237                 }
 238                 ks += u
 239         }
 240         cluster.Containers.SLURM.SbatchEnvironmentVariables = map[string]string{"ARVADOS_KEEP_SERVICES": ks}
 241 }
 242
 243 // update config using values from an crunch-dispatch-slurm config file.
 244 func (ldr *Loader) loadOldCrunchDispatchSlurmConfig(cfg *arvados.Config) error {
 245         if ldr.CrunchDispatchSlurmPath == "" {
 246                 return nil
 247         }
 248         var oc oldCrunchDispatchSlurmConfig
 249         err := ldr.loadOldConfigHelper("crunch-dispatch-slurm", ldr.CrunchDispatchSlurmPath, &oc)
 250         if os.IsNotExist(err) && (ldr.CrunchDispatchSlurmPath == defaultCrunchDispatchSlurmConfigPath) {
 251                 return nil
 252         } else if err != nil {
 253                 return err
 254         }
 255
 256         cluster, err := cfg.GetCluster("")
 257         if err != nil {
 258                 return err
 259         }
 260
 261         loadOldClientConfig(cluster, oc.Client)
 262
 263         if oc.SbatchArguments != nil {
 264                 cluster.Containers.SLURM.SbatchArgumentsList = *oc.SbatchArguments
 265         }
 266         if oc.PollPeriod != nil {
 267                 cluster.Containers.CloudVMs.PollInterval = *oc.PollPeriod
 268         }
 269         if oc.PrioritySpread != nil {
 270                 cluster.Containers.SLURM.PrioritySpread = *oc.PrioritySpread
 271         }
 272         if oc.CrunchRunCommand != nil {
 273                 if len(*oc.CrunchRunCommand) >= 1 {
 274                         cluster.Containers.CrunchRunCommand = (*oc.CrunchRunCommand)[0]
 275                 }
 276                 if len(*oc.CrunchRunCommand) >= 2 {
 277                         cluster.Containers.CrunchRunArgumentsList = (*oc.CrunchRunCommand)[1:]
 278                 }
 279         }
 280         if oc.ReserveExtraRAM != nil {
 281                 cluster.Containers.ReserveExtraRAM = arvados.ByteSize(*oc.ReserveExtraRAM)
 282         }
 283         if oc.MinRetryPeriod != nil {
 284                 cluster.Containers.MinRetryPeriod = *oc.MinRetryPeriod
 285         }
 286         if oc.BatchSize != nil {
 287                 cluster.API.MaxItemsPerResponse = int(*oc.BatchSize)
 288         }
 289
 290         cfg.Clusters[cluster.ClusterID] = *cluster
 291         return nil
 292 }
 293
 294 type oldWsConfig struct {
 295         Client       *arvados.Client
 296         Postgres     *arvados.PostgreSQLConnection
 297         PostgresPool *int
 298         Listen       *string
 299         LogLevel     *string
 300         LogFormat    *string
 301
 302         PingTimeout      *arvados.Duration
 303         ClientEventQueue *int
 304         ServerEventQueue *int
 305
 306         ManagementToken *string
 307 }
 308
 309 const defaultWebsocketConfigPath = "/etc/arvados/ws/ws.yml"
 310
 311 // update config using values from an crunch-dispatch-slurm config file.
 312 func (ldr *Loader) loadOldWebsocketConfig(cfg *arvados.Config) error {
 313         if ldr.WebsocketPath == "" {
 314                 return nil
 315         }
 316         var oc oldWsConfig
 317         err := ldr.loadOldConfigHelper("arvados-ws", ldr.WebsocketPath, &oc)
 318         if os.IsNotExist(err) && ldr.WebsocketPath == defaultWebsocketConfigPath {
 319                 return nil
 320         } else if err != nil {
 321                 return err
 322         }
 323
 324         cluster, err := cfg.GetCluster("")
 325         if err != nil {
 326                 return err
 327         }
 328
 329         loadOldClientConfig(cluster, oc.Client)
 330
 331         if oc.Postgres != nil {
 332                 cluster.PostgreSQL.Connection = *oc.Postgres
 333         }
 334         if oc.PostgresPool != nil {
 335                 cluster.PostgreSQL.ConnectionPool = *oc.PostgresPool
 336         }
 337         if oc.Listen != nil {
 338                 cluster.Services.Websocket.InternalURLs[arvados.URL{Host: *oc.Listen, Path: "/"}] = arvados.ServiceInstance{}
 339         }
 340         if oc.LogLevel != nil {
 341                 cluster.SystemLogs.LogLevel = *oc.LogLevel
 342         }
 343         if oc.LogFormat != nil {
 344                 cluster.SystemLogs.Format = *oc.LogFormat
 345         }
 346         if oc.PingTimeout != nil {
 347                 cluster.API.SendTimeout = *oc.PingTimeout
 348         }
 349         if oc.ClientEventQueue != nil {
 350                 cluster.API.WebsocketClientEventQueue = *oc.ClientEventQueue
 351         }
 352         if oc.ServerEventQueue != nil {
 353                 cluster.API.WebsocketServerEventQueue = *oc.ServerEventQueue
 354         }
 355         if oc.ManagementToken != nil {
 356                 cluster.ManagementToken = *oc.ManagementToken
 357         }
 358
 359         cfg.Clusters[cluster.ClusterID] = *cluster
 360         return nil
 361 }
 362
 363 type oldKeepProxyConfig struct {
 364         Client          *arvados.Client
 365         Listen          *string
 366         DisableGet      *bool
 367         DisablePut      *bool
 368         DefaultReplicas *int
 369         Timeout         *arvados.Duration
 370         PIDFile         *string
 371         Debug           *bool
 372         ManagementToken *string
 373 }
 374
 375 const defaultKeepproxyConfigPath = "/etc/arvados/keepproxy/keepproxy.yml"
 376
 377 func (ldr *Loader) loadOldKeepproxyConfig(cfg *arvados.Config) error {
 378         if ldr.KeepproxyPath == "" {
 379                 return nil
 380         }
 381         var oc oldKeepProxyConfig
 382         err := ldr.loadOldConfigHelper("keepproxy", ldr.KeepproxyPath, &oc)
 383         if os.IsNotExist(err) && ldr.KeepproxyPath == defaultKeepproxyConfigPath {
 384                 return nil
 385         } else if err != nil {
 386                 return err
 387         }
 388
 389         cluster, err := cfg.GetCluster("")
 390         if err != nil {
 391                 return err
 392         }
 393
 394         loadOldClientConfig(cluster, oc.Client)
 395
 396         if oc.Listen != nil {
 397                 cluster.Services.Keepproxy.InternalURLs[arvados.URL{Host: *oc.Listen, Path: "/"}] = arvados.ServiceInstance{}
 398         }
 399         if oc.DefaultReplicas != nil {
 400                 cluster.Collections.DefaultReplication = *oc.DefaultReplicas
 401         }
 402         if oc.Timeout != nil {
 403                 cluster.API.KeepServiceRequestTimeout = *oc.Timeout
 404         }
 405         if oc.Debug != nil {
 406                 if *oc.Debug && cluster.SystemLogs.LogLevel != "debug" {
 407                         cluster.SystemLogs.LogLevel = "debug"
 408                 } else if !*oc.Debug && cluster.SystemLogs.LogLevel != "info" {
 409                         cluster.SystemLogs.LogLevel = "info"
 410                 }
 411         }
 412         if oc.ManagementToken != nil {
 413                 cluster.ManagementToken = *oc.ManagementToken
 414         }
 415
 416         // The following legacy options are no longer supported. If they are set to
 417         // true or PIDFile has a value, error out and notify the user
 418         unsupportedEntry := func(cfgEntry string) error {
 419                 return fmt.Errorf("the keepproxy %s configuration option is no longer supported, please remove it from your configuration file", cfgEntry)
 420         }
 421         if oc.DisableGet != nil && *oc.DisableGet {
 422                 return unsupportedEntry("DisableGet")
 423         }
 424         if oc.DisablePut != nil && *oc.DisablePut {
 425                 return unsupportedEntry("DisablePut")
 426         }
 427         if oc.PIDFile != nil && *oc.PIDFile != "" {
 428                 return unsupportedEntry("PIDFile")
 429         }
 430
 431         cfg.Clusters[cluster.ClusterID] = *cluster
 432         return nil
 433 }
 434
 435 const defaultKeepWebConfigPath = "/etc/arvados/keep-web/keep-web.yml"
 436
 437 type oldKeepWebConfig struct {
 438         Client *arvados.Client
 439
 440         Listen *string
 441
 442         AnonymousTokens    *[]string
 443         AttachmentOnlyHost *string
 444         TrustAllContent    *bool
 445
 446         Cache struct {
 447                 TTL                  *arvados.Duration
 448                 UUIDTTL              *arvados.Duration
 449                 MaxCollectionEntries *int
 450                 MaxCollectionBytes   *int64
 451                 MaxUUIDEntries       *int
 452         }
 453
 454         // Hack to support old command line flag, which is a bool
 455         // meaning "get actual token from environment".
 456         deprecatedAllowAnonymous *bool
 457
 458         // Authorization token to be included in all health check requests.
 459         ManagementToken *string
 460 }
 461
 462 func (ldr *Loader) loadOldKeepWebConfig(cfg *arvados.Config) error {
 463         if ldr.KeepWebPath == "" {
 464                 return nil
 465         }
 466         var oc oldKeepWebConfig
 467         err := ldr.loadOldConfigHelper("keep-web", ldr.KeepWebPath, &oc)
 468         if os.IsNotExist(err) && ldr.KeepWebPath == defaultKeepWebConfigPath {
 469                 return nil
 470         } else if err != nil {
 471                 return err
 472         }
 473
 474         cluster, err := cfg.GetCluster("")
 475         if err != nil {
 476                 return err
 477         }
 478
 479         loadOldClientConfig(cluster, oc.Client)
 480
 481         if oc.Listen != nil {
 482                 cluster.Services.WebDAV.InternalURLs[arvados.URL{Host: *oc.Listen, Path: "/"}] = arvados.ServiceInstance{}
 483                 cluster.Services.WebDAVDownload.InternalURLs[arvados.URL{Host: *oc.Listen, Path: "/"}] = arvados.ServiceInstance{}
 484         }
 485         if oc.AttachmentOnlyHost != nil {
 486                 cluster.Services.WebDAVDownload.ExternalURL = arvados.URL{Host: *oc.AttachmentOnlyHost, Path: "/"}
 487         }
 488         if oc.ManagementToken != nil {
 489                 cluster.ManagementToken = *oc.ManagementToken
 490         }
 491         if oc.TrustAllContent != nil {
 492                 cluster.Collections.TrustAllContent = *oc.TrustAllContent
 493         }
 494         if oc.Cache.TTL != nil {
 495                 cluster.Collections.WebDAVCache.TTL = *oc.Cache.TTL
 496         }
 497         if oc.Cache.MaxCollectionBytes != nil {
 498                 cluster.Collections.WebDAVCache.MaxCollectionBytes = arvados.ByteSize(*oc.Cache.MaxCollectionBytes)
 499         }
 500         if oc.AnonymousTokens != nil {
 501                 if len(*oc.AnonymousTokens) > 0 {
 502                         cluster.Users.AnonymousUserToken = (*oc.AnonymousTokens)[0]
 503                         if len(*oc.AnonymousTokens) > 1 {
 504                                 ldr.Logger.Warn("More than 1 anonymous tokens configured, using only the first and discarding the rest.")
 505                         }
 506                 }
 507         }
 508
 509         cfg.Clusters[cluster.ClusterID] = *cluster
 510         return nil
 511 }
 512
 513 const defaultGitHttpdConfigPath = "/etc/arvados/git-httpd/git-httpd.yml"
 514
 515 type oldGitHttpdConfig struct {
 516         Client          *arvados.Client
 517         Listen          *string
 518         GitCommand      *string
 519         GitoliteHome    *string
 520         RepoRoot        *string
 521         ManagementToken *string
 522 }
 523
 524 func (ldr *Loader) loadOldGitHttpdConfig(cfg *arvados.Config) error {
 525         if ldr.GitHttpdPath == "" {
 526                 return nil
 527         }
 528         var oc oldGitHttpdConfig
 529         err := ldr.loadOldConfigHelper("arvados-git-httpd", ldr.GitHttpdPath, &oc)
 530         if os.IsNotExist(err) && ldr.GitHttpdPath == defaultGitHttpdConfigPath {
 531                 return nil
 532         } else if err != nil {
 533                 return err
 534         }
 535
 536         cluster, err := cfg.GetCluster("")
 537         if err != nil {
 538                 return err
 539         }
 540
 541         loadOldClientConfig(cluster, oc.Client)
 542
 543         if oc.Listen != nil {
 544                 cluster.Services.GitHTTP.InternalURLs[arvados.URL{Host: *oc.Listen}] = arvados.ServiceInstance{}
 545         }
 546         if oc.ManagementToken != nil {
 547                 cluster.ManagementToken = *oc.ManagementToken
 548         }
 549         if oc.GitCommand != nil {
 550                 cluster.Git.GitCommand = *oc.GitCommand
 551         }
 552         if oc.GitoliteHome != nil {
 553                 cluster.Git.GitoliteHome = *oc.GitoliteHome
 554         }
 555         if oc.RepoRoot != nil {
 556                 cluster.Git.Repositories = *oc.RepoRoot
 557         }
 558
 559         cfg.Clusters[cluster.ClusterID] = *cluster
 560         return nil
 561 }
 562
 563 const defaultKeepBalanceConfigPath = "/etc/arvados/keep-balance/keep-balance.yml"
 564
 565 type oldKeepBalanceConfig struct {
 566         Client              *arvados.Client
 567         Listen              *string
 568         KeepServiceTypes    *[]string
 569         KeepServiceList     *arvados.KeepServiceList
 570         RunPeriod           *arvados.Duration
 571         CollectionBatchSize *int
 572         CollectionBuffers   *int
 573         RequestTimeout      *arvados.Duration
 574         LostBlocksFile      *string
 575         ManagementToken     *string
 576 }
 577
 578 func (ldr *Loader) loadOldKeepBalanceConfig(cfg *arvados.Config) error {
 579         if ldr.KeepBalancePath == "" {
 580                 return nil
 581         }
 582         var oc oldKeepBalanceConfig
 583         err := ldr.loadOldConfigHelper("keep-balance", ldr.KeepBalancePath, &oc)
 584         if os.IsNotExist(err) && ldr.KeepBalancePath == defaultKeepBalanceConfigPath {
 585                 return nil
 586         } else if err != nil {
 587                 return err
 588         }
 589
 590         cluster, err := cfg.GetCluster("")
 591         if err != nil {
 592                 return err
 593         }
 594
 595         loadOldClientConfig(cluster, oc.Client)
 596
 597         if oc.Listen != nil {
 598                 cluster.Services.Keepbalance.InternalURLs[arvados.URL{Host: *oc.Listen}] = arvados.ServiceInstance{}
 599         }
 600         if oc.ManagementToken != nil {
 601                 cluster.ManagementToken = *oc.ManagementToken
 602         }
 603         if oc.RunPeriod != nil {
 604                 cluster.Collections.BalancePeriod = *oc.RunPeriod
 605         }
 606         if oc.LostBlocksFile != nil {
 607                 cluster.Collections.BlobMissingReport = *oc.LostBlocksFile
 608         }
 609         if oc.CollectionBatchSize != nil {
 610                 cluster.Collections.BalanceCollectionBatch = *oc.CollectionBatchSize
 611         }
 612         if oc.CollectionBuffers != nil {
 613                 cluster.Collections.BalanceCollectionBuffers = *oc.CollectionBuffers
 614         }
 615         if oc.RequestTimeout != nil {
 616                 cluster.API.KeepServiceRequestTimeout = *oc.RequestTimeout
 617         }
 618
 619         msg := "The %s configuration option is no longer supported. Please remove it from your configuration file. See the keep-balance upgrade notes at https://doc.arvados.org/admin/upgrading.html for more details."
 620
 621         // If the keep service type provided is "disk" silently ignore it, since
 622         // this is what ends up being done anyway.
 623         if oc.KeepServiceTypes != nil {
 624                 numTypes := len(*oc.KeepServiceTypes)
 625                 if numTypes != 0 && !(numTypes == 1 && (*oc.KeepServiceTypes)[0] == "disk") {
 626                         return fmt.Errorf(msg, "KeepServiceTypes")
 627                 }
 628         }
 629
 630         if oc.KeepServiceList != nil {
 631                 return fmt.Errorf(msg, "KeepServiceList")
 632         }
 633
 634         cfg.Clusters[cluster.ClusterID] = *cluster
 635         return nil
 636 }
 637
 638 func (ldr *Loader) loadOldEnvironmentVariables(cfg *arvados.Config) error {
 639         if os.Getenv("ARVADOS_API_TOKEN") == "" && os.Getenv("ARVADOS_API_HOST") == "" {
 640                 return nil
 641         }
 642         cluster, err := cfg.GetCluster("")
 643         if err != nil {
 644                 return err
 645         }
 646         if tok := os.Getenv("ARVADOS_API_TOKEN"); tok != "" && cluster.SystemRootToken == "" {
 647                 ldr.Logger.Warn("SystemRootToken missing from cluster config, falling back to ARVADOS_API_TOKEN environment variable")
 648                 cluster.SystemRootToken = tok
 649         }
 650         if apihost := os.Getenv("ARVADOS_API_HOST"); apihost != "" && cluster.Services.Controller.ExternalURL.Host == "" {
 651                 ldr.Logger.Warn("Services.Controller.ExternalURL missing from cluster config, falling back to ARVADOS_API_HOST(_INSECURE) environment variables")
 652                 u, err := url.Parse("https://" + apihost)
 653                 if err != nil {
 654                         return fmt.Errorf("cannot parse ARVADOS_API_HOST: %s", err)
 655                 }
 656                 cluster.Services.Controller.ExternalURL = arvados.URL(*u)
 657                 if i := os.Getenv("ARVADOS_API_HOST_INSECURE"); i != "" && i != "0" {
 658                         cluster.TLS.Insecure = true
 659                 }
 660         }
 661         cfg.Clusters[cluster.ClusterID] = *cluster
 662         return nil
 663 }