frontend.properties

#
# dCache - http://www.dcache.org/
#
# Copyright (C) 2016 Deutsches Elektronen-Synchrotron
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU Affero General Public License as
# published by the Free Software Foundation, either version 3 of the
# License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU Affero General Public License for more details.
#
# You should have received a copy of the GNU Affero General Public License
# along with this program.  If not, see <http://www.gnu.org/licenses/>.
#

#  -----------------------------------------------------------------------
#     Default values for Frontend doors
#  -----------------------------------------------------------------------
@DEFAULTS_HEADER@

#  ---- Cell name of the door
#
frontend.cell.name=Frontend-${host.name}

#  ---- Named queues to consume from
#
#   A service can consume messages from named queues. Other services can
#   write messages to such queues. A named queue has an unqualified cell
#   address, that is, an address without a domain name.
#
#   This property contains a comma separated list of named queues to
#   consume from.
#
frontend.cell.consume=${frontend.cell.name}

frontend.cell.subscribe=${frontend.pool-monitor.topic},${frontend.loginbroker.update-topic},${frontend.restore-requests.topic}

#  ----- Whether the service is replicable
#
#   Any service in dCache can have several instances as long as these
#   represent separate logical services. Some services can have several
#   instances representing the same logical service, providing some
#   degree of fault tolerance and load balancing. Such services are said
#   to be replicable.
#
#   Instances of a logical service share the same service name, and it is
#   important that the configuration for such instances is synchronized.
#
#   This property indicates if this service is replicable.
#
(immutable)frontend.cell.replicable = false

# Cell address of alarms service
frontend.service.alarms=${dcache.service.alarms}

# Cell address of pnfsmanager service
frontend.service.pnfsmanager=${dcache.service.pnfsmanager}

# Cell address of pinmanager service
frontend.service.pinmanager=${dcache.service.pinmanager}

# Cell address for poolmanager service
frontend.service.poolmanager=${dcache.service.poolmanager}

# Cell address for spacemanager service
frontend.service.spacemanager=${dcache.service.spacemanager}

# Cell address of gplazma service
frontend.service.gplazma=${dcache.service.gplazma}

# Cell address of billing service
frontend.service.billing=${dcache.queue.billing}

# Timeout for pool cell stub requests
frontend.service.pool.timeout=300000
(one-of?MILLISECONDS|SECONDS|MINUTES|HOURS|DAYS)frontend.service.pool.timeout.unit=MILLISECONDS

# Timeout for pinmanager requests
frontend.service.pinmanager.timeout=300000
(one-of?MILLISECONDS|SECONDS|MINUTES|HOURS|DAYS)frontend.service.pinmanager.timeout.unit=MILLISECONDS

# Timeout for pnfsmanager requests
frontend.service.pnfsmanager.timeout = 120000
(one-of?MILLISECONDS|SECONDS|MINUTES|HOURS|DAYS)frontend.service.pnfsmanager.timeout.unit=MILLISECONDS

# Timeout for poolmanager requests
frontend.service.poolmanager.timeout = 300000
(one-of?MILLISECONDS|SECONDS|MINUTES|HOURS|DAYS)frontend.service.poolmanager.timeout.unit=MILLISECONDS

# Timeout for spacemanager requests
frontend.service.spacemanager.timeout = 300000
(one-of?MILLISECONDS|SECONDS|MINUTES|HOURS|DAYS)frontend.service.spacemanager.timeout.unit=MILLISECONDS

# Timeout for billing requests
# These properties can also be set interactively through the admin door
frontend.service.billing.timeout = 5
(one-of?MILLISECONDS|SECONDS|MINUTES|HOURS|DAYS)frontend.service.billing.timeout.unit=MINUTES

# Timeout for gplazma requests
frontend.service.gplazma.timeout = 180000
(one-of?MILLISECONDS|SECONDS|MINUTES|HOURS|DAYS)frontend.service.gplazma.timeout.unit=MILLISECONDS

# Timeout for transfer info collection
# These properties can also be set interactively through the admin door
frontend.service.transfers.timeout=1
(one-of?MILLISECONDS|SECONDS|MINUTES|HOURS|DAYS)frontend.service.transfers.timeout.unit=MINUTES
frontend.service.transfers.maxCacheSize=1000

# Timeout for cell info collection
# These properties can also be set interactively through the admin door
frontend.service.cell-info.timeout=1
(one-of?MILLISECONDS|SECONDS|MINUTES|HOURS|DAYS)frontend.service.cell-info.timeout.unit=MINUTES

# Used for processing updates on messages returned from cells
frontend.service.cell-info.update-threads=10

# Timeout for restore info collection
# These properties can also be set interactively through the admin door
frontend.service.restores.timeout=1
(one-of?MILLISECONDS|SECONDS|MINUTES|HOURS|DAYS)frontend.service.restores.timeout.unit=MINUTES
frontend.service.restores.maxCacheSize=1000

# Timeout for alarms info collection
# These properties can also be set interactively through the admin door
frontend.service.alarms.timeout=1
(one-of?MILLISECONDS|SECONDS|MINUTES|HOURS|DAYS)frontend.service.alarms.timeout.unit=MINUTES

# Timeout for pool info collection
# These properties can also be set interactively through the admin door
frontend.service.pool-info.timeout=1
(one-of?MILLISECONDS|SECONDS|MINUTES|HOURS|DAYS)frontend.service.pool-info.timeout.unit=MINUTES

# Timeout for pool history info collection
# These properties can also be set interactively through the admin door
frontend.service.pool-history.timeout=1
(one-of?MILLISECONDS|SECONDS|MINUTES|HOURS|DAYS)frontend.service.pool-history.timeout.unit=MINUTES

# Name of pool history service
frontend.service.pool-history=${dcache.service.history}

# Used for processing updates on messages returned from pools
frontend.service.pool-info.update-threads=10

# Used for collecting file locality info for paths (WLCG ArchiveInfo resource)
frontend.service.wlcg.file-locality-collector-threads=20

# Used for throttling the number of paths in ArchiveInfo request
frontend.service.wlcg.file-locality-max-files=10000

# Maximum number of items to return for pool activity listings, such
# as flushes, restores, movers, etc.
frontend.service.pool-info.maxPoolActivityListSize=1000

# Cell address of bulk service
frontend.service.bulk-service=${dcache.service.bulk}

# Timeout for bulk service messaging
frontend.service.bulk-service.timeout=1
(one-of?MILLISECONDS|SECONDS|MINUTES|HOURS|DAYS)frontend.service.bulk-service.timeout.unit=MINUTES

# Topic on which to expect pool monitor updates
frontend.pool-monitor.topic = ${dcache.pool-monitor.topic}

# Cell address of qos service
frontend.service.qos=${dcache.service.qos}

# Timeout for qos service messaging
frontend.service.qos.timeout=1
(one-of?MILLISECONDS|SECONDS|MINUTES|HOURS|DAYS)frontend.service.qos.timeout.unit=MINUTES

# Topic on which to expect request handler updates for restore requests
frontend.restore-requests.topic = ${dcache.restore-requests.topic}

#  ---- TCP port to listen on
#
#   Specifies the TCP port on which the door accepts connections.
#
frontend.net.port = 3880

#  ---- What IP address to listen on
#
#   Specifies the IP address to which the door listens for
#   connections from clients. Defaults to the wildcard address.
#
frontend.net.listen = ${dcache.net.listen}

#  ---- Whether to use HTTP or HTTPS
#
#   Specifies whether the HTTP or the HTTPS protocol is used. For
#   HTTPS, a server certificate and a trust store need to be
#   created. By default these are stored under /etc/grid-security/.

(one-of?http|https)frontend.authn.protocol = https

(immutable)frontend.authn.connector-for-http = PLAIN
(immutable)frontend.authn.connector-for-https = TLS
(immutable)frontend.authn.connector = ${frontend.authn.connector-for-${frontend.authn.protocol}}

#  ---- Whether client certificates are accepted for HTTPS
#
#   This parameter specifies whether the door will accept a client
#   certificate for authentication.
#
(one-of?true|false)frontend.authn.accept-client-cert = true

#  ---- Whether client certificates are required for HTTPS
#
#   This parameter specifies whether the door will require a
#   client certificate for authentication.
#
(one-of?true|false)frontend.authn.require-client-cert = false

#  ---- Whether HTTP Basic authentication is enabled
#
#   When enabled a user name and password will be requested on
#   authorization failures.
#
#   Note that HTTP Basic authentication essentially transfers
#   passwords in clear text. A secure setup should only use HTTP Basic
#   authentication over HTTPS.
#
(immutable)frontend.authn.basic-for-http = false
(immutable)frontend.authn.basic-for-https = true
(immutable)frontend.authn.basic-for-https-jglobus = true
(one-of?true|false|${frontend.authn.basic-for-${frontend.authn.protocol}})\
frontend.authn.basic = ${frontend.authn.basic-for-${frontend.authn.protocol}}

# Host (server) certificate for https authentication
frontend.authn.hostcert.cert=${dcache.authn.hostcert.cert}

# Host (server) key for https authentication
frontend.authn.hostcert.key=${dcache.authn.hostcert.key}

# How often to check the host certificate for updates
frontend.authn.hostcert.refresh=${dcache.authn.hostcert.refresh}
(one-of?MILLISECONDS|SECONDS|MINUTES|HOURS|DAYS|${dcache.authn.hostcert.refresh.unit})frontend.authn.hostcert.refresh.unit=${dcache.authn.hostcert.refresh.unit}

# Path to directory with trusted CA certificates for https authentication
frontend.authn.capath=${dcache.authn.capath}

# How often to check the CA certificates for updates
frontend.authn.capath.refresh=${dcache.authn.capath.refresh}
(one-of?MILLISECONDS|SECONDS|MINUTES|HOURS|DAYS|${dcache.authn.capath.refresh.unit})frontend.authn.capath.refresh.unit=${dcache.authn.capath.refresh.unit}

# ---- Certificate Authority Namespace usage mode
(one-of?GLOBUS_EUGRIDPMA|EUGRIDPMA_GLOBUS|GLOBUS|EUGRIDPMA|GLOBUS_EUGRIDPMA_REQUIRE|EUGRIDPMA_GLOBUS_REQUIRE|GLOBUS_REQUIRE|EUGRIDPMA_REQUIRE|EUGRIDPMA_AND_GLOBUS|EUGRIDPMA_AND_GLOBUS_REQUIRE|IGNORE|${dcache.authn.namespace-mode})\
frontend.authn.namespace-mode=${dcache.authn.namespace-mode}

# ---- Certificate Revocation List usage mode
(one-of?REQUIRE|IF_VALID|IGNORE|${dcache.authn.crl-mode})\
frontend.authn.crl-mode=${dcache.authn.crl-mode}

# ---- On-line Certificate Status Protocol usage mode
(one-of?REQUIRE|IF_AVAILABLE|IGNORE|${dcache.authn.ocsp-mode})\
frontend.authn.ocsp-mode=${dcache.authn.ocsp-mode}

#  ---- Level of access granted to anonymous users
#
#   Specifies which HTTP methods are granted to anonymous
#   clients. NONE specifies that all anonymous requests will be
#   rejected; READONLY specifies that only read requests are allowed
#   (that is, GET, HEAD, OPTIONS and PROPFIND); FULL specifies that
#   all HTTP methods are allowed.
#
#   Anonymous clients are still subject to authorisation: Only
#   operations with world access are granted.
#
(one-of?NONE|READONLY|FULL)frontend.authz.anonymous-operations=NONE

#  ---- Determines whether operations exposing file information
#       can be viewed by non-admin users.
#
#       When false (default), restores, queue operations on the pools,
#       billing records, and transfers which are not owned by the user
#       and are not anonymous can only be seen by admins.
#
#       Setting this value to true allows all users (including anonymous users) access
#       to this information.
#
(one-of?true|false)frontend.authz.unlimited-operation-visibility=false

#  ---- Whether the door is read only
#
#   When set to true, only read operations are allowed through the frontend.
#
(one-of?true|false)frontend.authz.readonly = false

# ---- Whether to expect the haproxy Proxy Protocol
#
# Many load balancers and reverse proxies support the Proxy Protocol, a
# de facto standard introduced by the haproxy product. Support for this
# protocol has to be enabled in both the load balancer/reverse proxy and
# the backend service.
#
# If enabled, the proxy injects the actual clients IP address into the data
# stream, thus letting the backend be aware of the clients address.
#
# Only version 1 of the proxy protocol is supported.
#
(one-of?true|false)frontend.enable.proxy-protocol = false

# ---- Whether to expect the space manager service to be running
#
(one-of?true|false|${dcache.enable.space-reservation})frontend.enable.space-reservation=${dcache.enable.space-reservation}

# ---- Threads that accept TCP connections
#
# The number of threads that accept and dispatch new client connections.
# Except under very high connection rates, a single thread should be
# sufficient.
#
frontend.limits.acceptors=1

# ---- Time before an idle connection is closed
#
# An idle connection is one on which no data is transferred.
#
# Note that a connection may appear idle because the door is blocked
# on other operations on dCache, such as waiting for a file to stage from
# tape, or waiting for a mover to start. It is advisable that this timeout
# is not lower than the individual timeouts configured for talking to other
# dCache services.
#
frontend.limits.idle-time=300
(one-of?MILLISECONDS|SECONDS|MINUTES|HOURS|DAYS)\
frontend.limits.idle-time.unit=SECONDS

# ---- Subscription to login broker topic
#
frontend.loginbroker.request-topic=${dcache.loginbroker.request-topic}
frontend.loginbroker.update-topic=${dcache.loginbroker.update-topic}

# ---- Login subscription tags (doors are filtered on this basis)
#
frontend.protocols.tags=

# ---- Time before an idle TCP connection is closed during high load
#
# An idle connection is one on which no data is transferred. The door
# is considered under high load when all request processing threads
# are busy.
#
# Under high load, new connections will be configured with this timeout
# rather than the timeout defined by frontend.limits.idle-time. Currently,
# existing connections are not affected, although this may change in
# the future.
#
frontend.limits.low-resource-idle-time=30
(one-of?MILLISECONDS|SECONDS|MINUTES|HOURS|DAYS)\
frontend.limits.low-resource-idle-time.unit=SECONDS

# ---- TCP backlog
#
# Maximum number of TCP connections queued for accept. If the acceptor
# threads cannot keep up, up to this number of connections are queued
# before new connections are rejected.
frontend.limits.backlog=1024

# ---- Maximum number of threads used for request processing
#
# Whenever a client submits a request, the request is processed by a thread.
# This setting controls the maximum number of such threads.
#
frontend.limits.threads.max=500

# ---- Minimum number of threads used for request processing
#
# Request processing threads that have been idle for a while are terminated.
# This setting controls a minimum number of threads to keep alive even
# when idle.
frontend.limits.threads.min=1

# ---- Time before an idle request processing thread is terminated
frontend.limits.threads.idle-time=60
(one-of?MILLISECONDS|SECONDS|MINUTES|HOURS|DAYS)\
frontend.limits.threads.idle-time.unit=SECONDS

# ---- Maximum number of queued requests
#
# Once the limit is reached no new connections will be accepted;
# instead, the operating system will queue them in the TCP backlog.
# Once the TCP backlog is filled, the operating system will reject
# further TCP connections.
#
frontend.limits.queue-length=500

# ---- Cache lifetime for evicting stale lists of pool manager restore requests
#
frontend.restore-requests.lifetime=1
(one-of?MILLISECONDS|SECONDS|MINUTES|HOURS|DAYS)frontend.restore-requests.lifetime.unit = HOURS

# ---- Shutdown timeout
#
# During shutdown no new connections will be accepted. Existing
# connections will be given this much time to complete the
# request, after which the connections are forcefully broken.
#
frontend.limits.graceful-shutdown=2
(one-of?MILLISECONDS|SECONDS|MINUTES|HOURS|DAYS)\
frontend.limits.graceful-shutdown.unit=SECONDS

#   Custom HTTP headers in response
#
#   The following configuration prefix is used to add custom headers
#   to dCache responses.  The key part (after the prefix) is used as
#   the header; the value is the header's value.  For example, specifying
#
#       frontend.custom-response-header!Foo = bar
#
#   ensures that HTTP responses will include the line:
#
#       Foo: bar
#
#   The pool.mover.http.custom-response-header property has a similar
#   effect for pools.
#
(prefix)frontend.custom-response-header = HTTP headers that are always included in dCache responses
frontend.custom-response-header!Server = dCache/${dcache.version}

#
#   Document which TCP ports are opened
#
(immutable)frontend.net.ports.tcp=${frontend.net.port}

#  Flags to disable problematic crypto ciphers
#
#  See dcache.authn.ciphers for details.
frontend.authn.ciphers = ${dcache.authn.ciphers}

frontend.enable.authn.anonymous-fallback-on-failed-login = ${dcache.enable.authn.anonymous-fallback-on-failed-login}

# Set Http authentication realm
frontend.authn.realm = ${dcache.description}

# maximal number of entries in the cache
frontend.service.gplazma.cache.size = 1024

# cache entry maximal lifetime
frontend.service.gplazma.cache.timeout = 10

# Time unit used for timeout.
#
(one-of?MILLISECONDS|SECONDS|MINUTES|HOURS|DAYS)\
frontend.service.gplazma.cache.timeout.unit = MINUTES


# Used by the billing service for periodic collection
frontend.service.billing.collection.timeout = 1

# Whether to submit namespace qos requests to the QoSEngine or to use
# the embedded legacy mechanism.  Defaults to the new QoSEngine.
(one-of?true|false)frontend.service.namespace.use-qos-service= true

# Geographic placement
#
# A comma-separated list of ISO-3166 alpha-2 codes that identify where
# data may be located.
#
frontend.geographic-placement =

(one-of?MILLISECONDS|SECONDS|MINUTES|HOURS|DAYS)\
frontend.service.billing.collection.timeout.unit = MINUTES

#  ---- Directory with default static content
#
#   The directory in the local file system containing the dcache-view
#   files.
#
frontend.dcache-view.dir = ${dcache.paths.share}/dcache-view

#  ---- Directory with default static content
#
#   The directory in the local file system containing the dcache-view-admin
#   files.
#
frontend.dcache-view-admin.dir = ${dcache.paths.share}/dcache-view-admin

#  ---- Static values for frontend
#
#   The frontend can provide arbitrary information to clients based on
#   dCache configuration.  This is likely most useful for providing
#   static information (such as configuration) to clients that use
#   frontend.
#
#   The data is organised as key-value pairs.  These key-value pairs
#   are serialised into a JSON object.  This JSON object is available
#   to clients making GET requests in two forms: as the simple JSON
#   object itself and in the form of a simple JavaScript fragment that
#   defines the 'CONFIG' variable, depending on which MIME type the
#   client requests.
#
#   A colon-separated list of paths on which the client may request
#   the values.
#
frontend.static.path = /scripts/config.js

#   The information conveyed as a JSON object.  It is recommended that
#   all values intended for the same client have a common prefix.
#
#   The following keys are understood by dCache View:
#
#       dcache-view.endpoints.webapi
#
#           The webapi is offered by this frontend service, so the
#           default value is a relative path pointing back to this
#           server.
#
#           MUST end with a slash.
#
#       dcache-view.endpoints.webdav
#
#           dCacheView uses a WebDAV door for data transfers (uploads
#           and downloads) and for requesting Macaroons.
#
#           By default, dCacheView will search for WebDAV doors with
#           the tag 'dcache-view' and where the door-root is '/'.  If
#           there are multiple such doors, dCacheView will select the
#           least loaded.
#
#           This auto-detection behaviour may be overridden by specifying
#           the 'dcache-view.endpoints.webdav' property.  The value
#           is the URL of the WebDAV endpoint to use
#           (e.g., https://example.org:443/ ).  Any non-empty value
#           MUST end with a slash.
#
#       dcache-view.org-name
#
#           Name placed at the top of the dCacheView application.
#
#       dcache-view.oidc-provider-name-list
#       dcache-view.oidc-client-id-list
#       dcache-view.oidc-authz-endpoint-list
#
#           Support for OpenID Connect in dCacheView
#
#           After setting up openID connect in the webdav; dcache-view
#           needs to be configured. This will enable user to be able
#           to authenticate with an OpenID connect account.
#
#           These 3 properties below must be set.
#
#           If you have more than one OpenID connect provider, each
#           property takes a space separated value; that is, one for
#           each providers. Therefore, the set values of each
#           properties MUST be in the same order, since these will be
#           mapped together.
#
#           Example: Say you have enable two OpenID connect providers;
#           namely: openid1 and openid2. The 3 properties will be
#           setup as follow:
#
#           frontend.static!dcache-view.oidc-provider-name-list = openid1 openid2
#           frontend.static!dcache-view.oidc-client-id-list = clientID1 clientID2
#           frontend.static!dcache-view.oidc-authz-endpoint-list = \
#               https://oidc.example.com/authz \
#               https://auth.example.org/authorize
#
(prefix)frontend.static = A set of values exposed as a JSON response
frontend.static!dcache-view.endpoints.webapi = /api/v1/
frontend.static!dcache-view.endpoints.webdav =
frontend.static!dcache-view.org-name = ${dcache.description}
frontend.static!dcache-view.oidc-provider-name-list =
frontend.static!dcache-view.oidc-client-id-list =
frontend.static!dcache-view.oidc-authz-endpoint-list =

#  ---- Root path
# Default directory to be exported by doors
#
frontend.root = ${dcache.root}

#  ---- Event support
#
# dCache supports delivering events: asynchronous notification for
# clients that something of interest has happened.  This is based on
# the Server-Sent Events (SSE) protocol.
#
# Events are delivered to clients via a channel, with each channel
# having a unique SSE endpoint.  A client should need only a single
# channel for all events.  Channels are not intended to be shared
# between clients.  Therefore each client needs its own channel.
#
# At any point in time, a client either has or has not established a
# TCP connection to its SSE endpoint.  If a client is disconnected
# from the SSE endpoint for an extended period, the corresponding
# channel is garbage collected automatically.  Channels have a default
# garbage-collection period, but this period may also be adjusted by
# the client.
#
#  ---- Maximum event channels
#
# The maximum number of concurrent channels any dCache user may have.
# Once this limit is reached, subsequent requests for a new channel
# will fail.
#
frontend.limit.events.channels-per-user = 128
#
#  ---- Garbage-collection policy
#
# The default period a client may be disconnected from the SSE
# endpoint before the corresponding channel is automatically garbage
# collected.
#
frontend.limit.events.disconnect-timeout.default = 5
frontend.limit.events.disconnect-timeout.default.unit = MINUTES
#
# The maximum a client can configure the garbage-collection period.
#
frontend.limit.events.disconnect-timeout.maximum = 1
frontend.limit.events.disconnect-timeout.maximum.unit = DAYS

#
# The maximum number of events that can take place while a client is
# disconnected without events being lost.  Setting this value too high
# will result in dCache running out of memory.
#
frontend.limit.events.backlog = 16383

#  ---- Macaroon support.
#
(one-of?true|false|${dcache.enable.macaroons})\
frontend.enable.macaroons = ${dcache.enable.macaroons}
frontend.macaroons.expired-removal-period = ${dcache.macaroons.expired-removal-period}
(one-of?MILLISECONDS|SECONDS|MINUTES|HOURS|DAYS|${dcache.macaroons.expired-removal-period.unit})\
frontend.macaroons.expired-removal-period.unit = ${dcache.macaroons.expired-removal-period.unit}
(one-of?true|false|${dcache.macaroons.accept-over-unencrypted-channel})\
frontend.macaroons.accept-over-unencrypted-channel = ${dcache.macaroons.accept-over-unencrypted-channel}

frontend.version.swagger-ui = @version.swagger-ui@


# ---- Storage Resource Reporting (SRR)
#
# Space reservations will always be published through SRR.
# To publish also poolgroups, they must be added to frontend.srr.shares,
# together with the VO they should be mapped to.
#
# Format:
#  poolgroup1:/vo1,poolgroup2:/vo2,...
#
# Example:
#  cms-user:/cms,default:/cms,default:/atlas
frontend.srr.shares =

#
# SRR path mappings
# This setting allows the optional path field to be set in the SRR
# storageshares entries (for either poolgroups or space reservations).
# The same key may be specified repeatedly to add multiple paths.
#
# Format:
#  poolgroup1:/path1,poolgroup2:/path2,spaceres1:/path/other,...
#
# Example:
#  cms-user:/cms/store/user,default:/cms,default:/atlas
#
frontend.srr.paths =

#
# Should SRR information be restricted to localhost only
#
(one-of?true|false)frontend.srr.public=false

#
# Comma-delimited list of well-known sitenames for which we support metadata (currently none).
#
frontend.stage.supported-sitenames=

(deprecated)frontend.wellknown!wlcg-tape-rest-api.path = Use dcache.wellknown!wlcg-tape-rest-api.path instead

(obsolete)frontend.dcache-view.endpoints.webapi = Use frontend.static!dcache-view.endpoints.webapi instead
(obsolete)frontend.dcache-view.endpoints.webdav = Use frontend.static!dcache-view.endpoints.webdav instead
(obsolete)frontend.dcache-view.org-name = Use frontend.static!dcache-view.org-name instead
(obsolete)frontend.dcache-view.oidc-provider-name-list = Use frontend.static!dcache-view.oidc-provider-name-list instead
(obsolete)frontend.dcache-view.oidc-client-id-list = Use frontend.static!dcache-view.oidc-client-id-list instead
(obsolete)frontend.dcache-view.oidc-authz-endpoint-list = Use frontend.static!dcache-view.oidc-authz-endpoint-list instead