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