001/* 002 * Licensed to the Apache Software Foundation (ASF) under one 003 * or more contributor license agreements. See the NOTICE file 004 * distributed with this work for additional information 005 * regarding copyright ownership. The ASF licenses this file 006 * to you under the Apache License, Version 2.0 (the 007 * "License"); you may not use this file except in compliance 008 * with the License. You may obtain a copy of the License at 009 * 010 * http://www.apache.org/licenses/LICENSE-2.0 011 * 012 * Unless required by applicable law or agreed to in writing, 013 * software distributed under the License is distributed on an 014 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY 015 * KIND, either express or implied. See the License for the 016 * specific language governing permissions and limitations 017 * under the License. 018 */ 019package org.eclipse.aether; 020 021/** 022 * The keys and defaults for common configuration properties. 023 * 024 * @see RepositorySystemSession#getConfigProperties() 025 */ 026public final class ConfigurationProperties { 027 028 /** 029 * Prefix for all configurations. <em>For internal use only.</em> 030 * 031 * @since 2.0.0 032 */ 033 public static final String PREFIX_AETHER = "aether."; 034 035 /** 036 * Prefix for repository system related configurations. <em>For internal use only.</em> 037 * 038 * @since 2.0.0 039 */ 040 public static final String PREFIX_SYSTEM = PREFIX_AETHER + "system."; 041 042 /** 043 * Prefix for sync context related configurations. <em>For internal use only.</em> 044 * 045 * @since 2.0.0 046 */ 047 public static final String PREFIX_SYNC_CONTEXT = PREFIX_AETHER + "syncContext."; 048 049 /** 050 * Prefix for connector related configurations. <em>For internal use only.</em> 051 * 052 * @since 2.0.0 053 */ 054 public static final String PREFIX_CONNECTOR = PREFIX_AETHER + "connector."; 055 056 /** 057 * Prefix for layout related configurations. <em>For internal use only.</em> 058 * 059 * @since 2.0.0 060 */ 061 public static final String PREFIX_LAYOUT = PREFIX_AETHER + "layout."; 062 063 /** 064 * Prefix for checksum related configurations. <em>For internal use only.</em> 065 * 066 * @since 2.0.0 067 */ 068 public static final String PREFIX_CHECKSUMS = PREFIX_AETHER + "checksums."; 069 070 /** 071 * Prefix for local repository manager related configurations. <em>For internal use only.</em> 072 * 073 * @since 2.0.0 074 */ 075 public static final String PREFIX_LRM = PREFIX_AETHER + "lrm."; 076 077 /** 078 * Prefix for generator related configurations. <em>For internal use only.</em> 079 * 080 * @since 2.0.0 081 */ 082 public static final String PREFIX_GENERATOR = PREFIX_AETHER + "generator."; 083 084 /** 085 * Prefix for util related configurations. <em>For internal use only.</em> 086 * 087 * @since 2.0.10 088 */ 089 public static final String PREFIX_UTIL = PREFIX_AETHER + "util."; 090 091 /** 092 * Prefix for transport related configurations. <em>For internal use only.</em> 093 * 094 * @since 2.0.0 095 */ 096 public static final String PREFIX_TRANSPORT = PREFIX_AETHER + "transport."; 097 098 /** 099 * Prefix for HTTP protocol related configurations. <em>For internal use only.</em> 100 * 101 * @since 2.0.0 102 */ 103 public static final String PREFIX_TRANSPORT_HTTP = PREFIX_TRANSPORT + "http."; 104 105 /** 106 * Prefix for HTTPS protocol related configurations. <em>For internal use only.</em> 107 * 108 * @since 2.0.0 109 */ 110 public static final String PREFIX_TRANSPORT_HTTPS = PREFIX_TRANSPORT + "https."; 111 112 /** 113 * The prefix for properties that control the priority of pluggable extensions like transporters. For example, for 114 * an extension with the fully qualified class name "org.eclipse.MyExtensionFactory", the configuration properties 115 * "aether.priority.org.eclipse.MyExtensionFactory", "aether.priority.MyExtensionFactory" and 116 * "aether.priority.MyExtension" will be consulted for the priority, in that order (obviously, the last key is only 117 * tried if the class name ends with "Factory"). The corresponding value is a float and the special value 118 * {@link Float#NaN} or "NaN" (case-sensitive) can be used to disable the extension. 119 */ 120 public static final String PREFIX_PRIORITY = PREFIX_AETHER + "priority."; 121 122 /** 123 * A flag indicating whether the priorities of pluggable extensions are implicitly given by their iteration order 124 * such that the first extension has the highest priority. If set, an extension's built-in priority as well as any 125 * corresponding {@code aether.priority.*} configuration properties are ignored when searching for a suitable 126 * implementation among the available extensions. This priority mode is meant for cases where the application will 127 * present/inject extensions in the desired search order. 128 * 129 * @configurationSource {@link RepositorySystemSession#getConfigProperties()} 130 * @configurationType {@link java.lang.Boolean} 131 * @configurationDefaultValue {@link #DEFAULT_IMPLICIT_PRIORITIES} 132 * @configurationRepoIdSuffix No 133 */ 134 public static final String IMPLICIT_PRIORITIES = PREFIX_PRIORITY + "implicit"; 135 136 /** 137 * The default extension priority mode if {@link #IMPLICIT_PRIORITIES} isn't set. 138 */ 139 public static final boolean DEFAULT_IMPLICIT_PRIORITIES = false; 140 141 /** 142 * A flag indicating whether the created ordered components should be cached in session. 143 * 144 * @since 2.0.0 145 * @configurationSource {@link RepositorySystemSession#getConfigProperties()} 146 * @configurationType {@link java.lang.Boolean} 147 * @configurationDefaultValue {@link #DEFAULT_CACHED_PRIORITIES} 148 * @configurationRepoIdSuffix No 149 */ 150 public static final String CACHED_PRIORITIES = PREFIX_PRIORITY + "cached"; 151 152 /** 153 * The priority to use for a certain extension class. {@code <class>} can either be the fully qualified 154 * name or the simple name of a class. If the class name ends with Factory that suffix could optionally be left out. 155 * This configuration is used by {@code org.eclipse.aether.internal.impl.PrioritizedComponents} internal utility 156 * to sort classes by priority. This is reusable utility (so an extension can make use of it), but by default 157 * in "vanilla" Resolver following classes are sorted: 158 * <ul> 159 * <li>{@code org.eclipse.aether.spi.localrepo.LocalRepositoryManagerFactory}</li> 160 * <li>{@code org.eclipse.aether.spi.connector.RepositoryConnectorFactory}</li> 161 * <li>{@code org.eclipse.aether.spi.connector.layout.RepositoryLayoutFactory}</li> 162 * <li>{@code org.eclipse.aether.spi.connector.transport.TransporterFactory}</li> 163 * <li>{@code org.eclipse.aether.spi.artifact.decorator.ArtifactDecoratorFactory}</li> 164 * <li>{@code org.eclipse.aether.spi.artifact.generator.ArtifactGeneratorFactory}</li> 165 * <li>{@code org.eclipse.aether.impl.MetadataGeneratorFactory}</li> 166 * </ul> 167 * 168 * @configurationSource {@link RepositorySystemSession#getConfigProperties()} 169 * @configurationType {@link java.lang.Float} 170 * @configurationRepoIdSuffix No 171 */ 172 public static final String CLASS_PRIORITIES = PREFIX_PRIORITY + "<class>"; 173 174 /** 175 * The default caching of priority components if {@link #CACHED_PRIORITIES} isn't set. Default value is {@code true}. 176 * 177 * @since 2.0.0 178 */ 179 public static final boolean DEFAULT_CACHED_PRIORITIES = true; 180 181 /** 182 * A flag indicating whether interaction with the user is allowed. 183 * 184 * @configurationSource {@link RepositorySystemSession#getConfigProperties()} 185 * @configurationType {@link java.lang.Boolean} 186 * @configurationDefaultValue {@link #DEFAULT_INTERACTIVE} 187 * @configurationRepoIdSuffix No 188 */ 189 public static final String INTERACTIVE = PREFIX_AETHER + "interactive"; 190 191 /** 192 * The default interactive mode if {@link #INTERACTIVE} isn't set. 193 */ 194 public static final boolean DEFAULT_INTERACTIVE = false; 195 196 /** 197 * The user agent that repository connectors should report to servers. 198 * 199 * @configurationSource {@link RepositorySystemSession#getConfigProperties()} 200 * @configurationType {@link java.lang.String} 201 * @configurationDefaultValue {@link #DEFAULT_USER_AGENT} 202 * @configurationRepoIdSuffix No 203 */ 204 public static final String USER_AGENT = PREFIX_TRANSPORT_HTTP + "userAgent"; 205 206 /** 207 * The default user agent to use if {@link #USER_AGENT} isn't set. 208 */ 209 public static final String DEFAULT_USER_AGENT = "Aether"; 210 211 /** 212 * The maximum amount of time (in milliseconds) to wait for a successful connection to a remote server. Non-positive 213 * values indicate no timeout. 214 * 215 * @configurationSource {@link RepositorySystemSession#getConfigProperties()} 216 * @configurationType {@link java.lang.Integer} 217 * @configurationDefaultValue {@link #DEFAULT_CONNECT_TIMEOUT} 218 * @configurationRepoIdSuffix Yes 219 */ 220 public static final String CONNECT_TIMEOUT = PREFIX_TRANSPORT_HTTP + "connectTimeout"; 221 222 /** 223 * The default connect timeout to use if {@link #CONNECT_TIMEOUT} isn't set. 224 */ 225 public static final int DEFAULT_CONNECT_TIMEOUT = 30 * 1000; 226 227 /** 228 * The maximum amount of time (in milliseconds) to wait for remaining data to arrive from a remote server. Note that 229 * this timeout does not restrict the overall duration of a request, it only restricts the duration of inactivity 230 * between consecutive data packets. Non-positive values indicate no timeout. 231 * 232 * @configurationSource {@link RepositorySystemSession#getConfigProperties()} 233 * @configurationType {@link java.lang.Integer} 234 * @configurationDefaultValue {@link #DEFAULT_REQUEST_TIMEOUT} 235 * @configurationRepoIdSuffix Yes 236 */ 237 public static final String REQUEST_TIMEOUT = PREFIX_TRANSPORT_HTTP + "requestTimeout"; 238 239 /** 240 * The default request timeout to use if {@link #REQUEST_TIMEOUT} isn't set. 241 */ 242 public static final int DEFAULT_REQUEST_TIMEOUT = 1800 * 1000; 243 244 /** 245 * The request headers to use for HTTP-based repository connectors. The headers are specified using a 246 * {@code Map<String, String>}, mapping a header name to its value. Besides this general key, clients may also 247 * specify headers for a specific remote repository by appending the suffix {@code .<repoId>} to this key when 248 * storing the headers map. The repository-specific headers map is supposed to be complete, i.e. is not merged with 249 * the general headers map. 250 * 251 * @configurationSource {@link RepositorySystemSession#getConfigProperties()} 252 * @configurationType {@link java.util.Map} 253 * @configurationRepoIdSuffix Yes 254 */ 255 public static final String HTTP_HEADERS = PREFIX_TRANSPORT_HTTP + "headers"; 256 257 /** 258 * The encoding/charset to use when exchanging credentials with HTTP servers. Besides this general key, clients may 259 * also specify the encoding for a specific remote repository by appending the suffix {@code .<repoId>} to this key 260 * when storing the charset name. 261 * 262 * @configurationSource {@link RepositorySystemSession#getConfigProperties()} 263 * @configurationType {@link java.lang.String} 264 * @configurationDefaultValue {@link #DEFAULT_HTTP_CREDENTIAL_ENCODING} 265 * @configurationRepoIdSuffix Yes 266 */ 267 public static final String HTTP_CREDENTIAL_ENCODING = PREFIX_TRANSPORT_HTTP + "credentialEncoding"; 268 269 /** 270 * The default encoding/charset to use if {@link #HTTP_CREDENTIAL_ENCODING} isn't set. 271 */ 272 public static final String DEFAULT_HTTP_CREDENTIAL_ENCODING = "ISO-8859-1"; 273 274 /** 275 * The maximum number of times a request to a remote server should be retried in case of an error. 276 * 277 * @since 1.9.6 278 * @configurationSource {@link RepositorySystemSession#getConfigProperties()} 279 * @configurationType {@link java.lang.Integer} 280 * @configurationDefaultValue {@link #DEFAULT_HTTP_RETRY_HANDLER_COUNT} 281 * @configurationRepoIdSuffix Yes 282 */ 283 public static final String HTTP_RETRY_HANDLER_COUNT = PREFIX_TRANSPORT_HTTP + "retryHandler.count"; 284 285 /** 286 * The default number of retries to use if {@link #HTTP_RETRY_HANDLER_COUNT} isn't set. 287 * 288 * @since 1.9.6 289 */ 290 public static final int DEFAULT_HTTP_RETRY_HANDLER_COUNT = 3; 291 292 /** 293 * The initial retry interval in millis of request to a remote server should be waited in case of 294 * "too many requests" (HTTP codes 429 and 503). Accepts long as milliseconds. This value is used if remote server 295 * does not use {@code Retry-After} header, in which case Server value is obeyed. 296 * 297 * @since 1.9.16 298 * @configurationSource {@link RepositorySystemSession#getConfigProperties()} 299 * @configurationType {@link java.lang.Long} 300 * @configurationDefaultValue {@link #DEFAULT_HTTP_RETRY_HANDLER_INTERVAL} 301 * @configurationRepoIdSuffix Yes 302 */ 303 public static final String HTTP_RETRY_HANDLER_INTERVAL = PREFIX_TRANSPORT_HTTP + "retryHandler.interval"; 304 305 /** 306 * The default initial retry interval to use if {@link #HTTP_RETRY_HANDLER_INTERVAL} isn't set. 307 * Default value 5000ms. 308 * 309 * @since 1.9.16 310 */ 311 public static final long DEFAULT_HTTP_RETRY_HANDLER_INTERVAL = 5000L; 312 313 /** 314 * The maximum retry interval in millis of request to a remote server above which the request should be aborted 315 * instead. In theory, a malicious server could tell Maven "come back after 100 years" that would stall the build 316 * for some. Using this parameter Maven will fail the request instead, if interval is above this value. 317 * 318 * @since 1.9.16 319 * @configurationSource {@link RepositorySystemSession#getConfigProperties()} 320 * @configurationType {@link java.lang.Long} 321 * @configurationDefaultValue {@link #DEFAULT_HTTP_RETRY_HANDLER_INTERVAL_MAX} 322 * @configurationRepoIdSuffix Yes 323 */ 324 public static final String HTTP_RETRY_HANDLER_INTERVAL_MAX = PREFIX_TRANSPORT_HTTP + "retryHandler.intervalMax"; 325 326 /** 327 * The default retry interval maximum to use if {@link #HTTP_RETRY_HANDLER_INTERVAL_MAX} isn't set. 328 * Default value 5 minutes. 329 * 330 * @since 1.9.16 331 */ 332 public static final long DEFAULT_HTTP_RETRY_HANDLER_INTERVAL_MAX = 300_000L; 333 334 /** 335 * The HTTP codes of remote server responses that should be handled as "too many requests" 336 * (examples: HTTP codes 429 and 503). Accepts comma separated list of HTTP response codes. 337 * 338 * @since 1.9.16 339 * @configurationSource {@link RepositorySystemSession#getConfigProperties()} 340 * @configurationType {@link java.lang.String} 341 * @configurationDefaultValue {@link #DEFAULT_HTTP_RETRY_HANDLER_SERVICE_UNAVAILABLE} 342 * @configurationRepoIdSuffix Yes 343 */ 344 public static final String HTTP_RETRY_HANDLER_SERVICE_UNAVAILABLE = 345 PREFIX_TRANSPORT_HTTP + "retryHandler.serviceUnavailable"; 346 347 /** 348 * The default HTTP codes of remote server responses that should be handled as "too many requests". 349 * Default value: "429,503". 350 * 351 * @since 1.9.16 352 */ 353 public static final String DEFAULT_HTTP_RETRY_HANDLER_SERVICE_UNAVAILABLE = "429,503"; 354 355 /** 356 * Should HTTP client use preemptive-authentication for all HTTP verbs (works only w/ BASIC). By default, is 357 * disabled, as it is considered less secure. 358 * 359 * @since 1.9.6 360 * @configurationSource {@link RepositorySystemSession#getConfigProperties()} 361 * @configurationType {@link java.lang.Boolean} 362 * @configurationDefaultValue {@link #DEFAULT_HTTP_PREEMPTIVE_AUTH} 363 * @configurationRepoIdSuffix Yes 364 */ 365 public static final String HTTP_PREEMPTIVE_AUTH = PREFIX_TRANSPORT_HTTP + "preemptiveAuth"; 366 367 /** 368 * The default value to use if {@link #HTTP_PREEMPTIVE_AUTH} isn't set (false). 369 * 370 * @since 1.9.6 371 */ 372 public static final boolean DEFAULT_HTTP_PREEMPTIVE_AUTH = false; 373 374 /** 375 * Should HTTP client reuse connections (in other words, pool connections) or not? 376 * 377 * @since 1.9.8 378 * @configurationSource {@link RepositorySystemSession#getConfigProperties()} 379 * @configurationType {@link java.lang.Boolean} 380 * @configurationDefaultValue {@link #DEFAULT_HTTP_REUSE_CONNECTIONS} 381 * @configurationRepoIdSuffix Yes 382 */ 383 public static final String HTTP_REUSE_CONNECTIONS = PREFIX_TRANSPORT_HTTP + "reuseConnections"; 384 385 /** 386 * The default value to use if {@link #HTTP_REUSE_CONNECTIONS} isn't set (true). 387 * 388 * @since 1.9.8 389 */ 390 public static final boolean DEFAULT_HTTP_REUSE_CONNECTIONS = true; 391 392 /** 393 * Total time to live in seconds for an HTTP connection, after that time, the connection will be dropped 394 * (no matter for how long it was idle). 395 * 396 * @since 1.9.8 397 * @configurationSource {@link RepositorySystemSession#getConfigProperties()} 398 * @configurationType {@link java.lang.Integer} 399 * @configurationDefaultValue {@link #DEFAULT_HTTP_CONNECTION_MAX_TTL} 400 * @configurationRepoIdSuffix Yes 401 */ 402 public static final String HTTP_CONNECTION_MAX_TTL = PREFIX_TRANSPORT_HTTP + "connectionMaxTtl"; 403 404 /** 405 * The default value to use if {@link #HTTP_CONNECTION_MAX_TTL} isn't set (300 seconds). 406 * 407 * @since 1.9.8 408 */ 409 public static final int DEFAULT_HTTP_CONNECTION_MAX_TTL = 300; 410 411 /** 412 * The maximum concurrent connections per route HTTP client is allowed to use. 413 * 414 * @since 1.9.8 415 * @configurationSource {@link RepositorySystemSession#getConfigProperties()} 416 * @configurationType {@link java.lang.Integer} 417 * @configurationDefaultValue {@link #DEFAULT_HTTP_MAX_CONNECTIONS_PER_ROUTE} 418 * @configurationRepoIdSuffix Yes 419 */ 420 public static final String HTTP_MAX_CONNECTIONS_PER_ROUTE = PREFIX_TRANSPORT_HTTP + "maxConnectionsPerRoute"; 421 422 /** 423 * The default value to use if {@link #HTTP_MAX_CONNECTIONS_PER_ROUTE} isn't set (50 connections). 424 * 425 * @since 1.9.8 426 */ 427 public static final int DEFAULT_HTTP_MAX_CONNECTIONS_PER_ROUTE = 50; 428 429 /** 430 * The local address (interface) to use with HTTP transport. Not all transport supports this option. 431 * 432 * @since 2.0.0 433 * @configurationSource {@link RepositorySystemSession#getConfigProperties()} 434 * @configurationType {@link java.lang.String} 435 * @configurationRepoIdSuffix Yes 436 */ 437 public static final String HTTP_LOCAL_ADDRESS = PREFIX_TRANSPORT_HTTP + "localAddress"; 438 439 /** 440 * Boolean flag should the HTTP transport support WebDAV remote. Not all transport support this option. 441 * 442 * @since 2.0.0 (moved out from maven-resolver-transport-http). 443 * @configurationSource {@link RepositorySystemSession#getConfigProperties()} 444 * @configurationType {@link java.lang.Boolean} 445 * @configurationDefaultValue {@link #DEFAULT_HTTP_SUPPORT_WEBDAV} 446 * @configurationRepoIdSuffix Yes 447 */ 448 public static final String HTTP_SUPPORT_WEBDAV = PREFIX_TRANSPORT_HTTP + "supportWebDav"; 449 450 /** 451 * Default value to use if {@link #HTTP_SUPPORT_WEBDAV} is not set: {@code false}. 452 * 453 * @since 2.0.0 454 */ 455 public static final boolean DEFAULT_HTTP_SUPPORT_WEBDAV = false; 456 457 /** 458 * Boolean flag should the HTTP transport use preemptive-auth for PUT requests. Not all transport support this 459 * option. 460 * 461 * @since 2.0.0 (moved out from maven-resolver-transport-http). 462 * @configurationSource {@link RepositorySystemSession#getConfigProperties()} 463 * @configurationType {@link java.lang.Boolean} 464 * @configurationDefaultValue {@link #DEFAULT_HTTP_PREEMPTIVE_PUT_AUTH} 465 * @configurationRepoIdSuffix Yes 466 */ 467 public static final String HTTP_PREEMPTIVE_PUT_AUTH = PREFIX_TRANSPORT_HTTP + "preemptivePutAuth"; 468 469 /** 470 * Default value if {@link #HTTP_PREEMPTIVE_PUT_AUTH} is not set: {@code true}. 471 * 472 * @since 2.0.0 473 */ 474 public static final boolean DEFAULT_HTTP_PREEMPTIVE_PUT_AUTH = true; 475 476 /** 477 * Boolean flag should the HTTP transport use expect-continue handshake for PUT requests. Not all transport support 478 * this option. This option may be needed for some broken HTTP servers. Default value corresponds to given 479 * transport default one (resolver does not override those), but if configuration IS given, it will replace 480 * given transport own default value. 481 * 482 * @since 1.9.17 483 * @configurationSource {@link RepositorySystemSession#getConfigProperties()} 484 * @configurationType {@link java.lang.Boolean} 485 * @configurationRepoIdSuffix Yes 486 */ 487 public static final String HTTP_EXPECT_CONTINUE = PREFIX_TRANSPORT_HTTP + "expectContinue"; 488 489 /** 490 * The mode that sets HTTPS transport "security mode": to ignore any SSL errors (certificate validity checks, 491 * hostname verification). The default value is {@link #HTTPS_SECURITY_MODE_DEFAULT}. 492 * 493 * @see #HTTPS_SECURITY_MODE_DEFAULT 494 * @see #HTTPS_SECURITY_MODE_INSECURE 495 * @since 1.9.6 496 * @configurationSource {@link RepositorySystemSession#getConfigProperties()} 497 * @configurationType {@link java.lang.String} 498 * @configurationDefaultValue {@link #HTTPS_SECURITY_MODE_DEFAULT} 499 * @configurationRepoIdSuffix Yes 500 */ 501 public static final String HTTPS_SECURITY_MODE = PREFIX_TRANSPORT_HTTPS + "securityMode"; 502 503 /** 504 * The default HTTPS security mode. 505 * 506 * @since 1.9.6 507 */ 508 public static final String HTTPS_SECURITY_MODE_DEFAULT = "default"; 509 510 /** 511 * The insecure HTTPS security mode (certificate validation, hostname verification are all ignored). 512 * 513 * @since 1.9.6 514 */ 515 public static final String HTTPS_SECURITY_MODE_INSECURE = "insecure"; 516 517 /** 518 * A flag indicating which visitor should be used to "flatten" the dependency graph into list. Default is 519 * same as in older resolver versions "preOrder", while it can accept values like "postOrder" and "levelOrder". 520 * 521 * @see #REPOSITORY_SYSTEM_DEPENDENCY_VISITOR_PREORDER 522 * @see #REPOSITORY_SYSTEM_DEPENDENCY_VISITOR_POSTORDER 523 * @see #REPOSITORY_SYSTEM_DEPENDENCY_VISITOR_LEVELORDER 524 * @since 2.0.0 525 * @configurationSource {@link RepositorySystemSession#getConfigProperties()} 526 * @configurationType {@link java.lang.String} 527 * @configurationDefaultValue {@link #REPOSITORY_SYSTEM_DEPENDENCY_VISITOR_PREORDER} 528 * @configurationRepoIdSuffix No 529 */ 530 public static final String REPOSITORY_SYSTEM_DEPENDENCY_VISITOR = PREFIX_SYSTEM + "dependencyVisitor"; 531 532 /** 533 * The visitor strategy "preOrder". 534 * 535 * @since 2.0.0 536 */ 537 public static final String REPOSITORY_SYSTEM_DEPENDENCY_VISITOR_PREORDER = "preOrder"; 538 539 /** 540 * The visitor strategy "postOrder". This was the only one supported in Resolver 1.x and is hence the 541 * default as well. 542 * 543 * @since 2.0.0 544 */ 545 public static final String REPOSITORY_SYSTEM_DEPENDENCY_VISITOR_POSTORDER = "postOrder"; 546 547 /** 548 * The visitor strategy "levelOrder". 549 * 550 * @since 2.0.0 551 */ 552 public static final String REPOSITORY_SYSTEM_DEPENDENCY_VISITOR_LEVELORDER = "levelOrder"; 553 554 /** 555 * A flag indicating whether version scheme cache statistics should be printed on JVM shutdown. 556 * This is useful for analyzing cache performance and effectiveness in development and testing scenarios. 557 * 558 * @since 2.0.10 559 * @configurationSource {@link RepositorySystemSession#getConfigProperties()} 560 * @configurationType {@link java.lang.Boolean} 561 * @configurationDefaultValue {@link #DEFAULT_VERSION_SCHEME_CACHE_DEBUG} 562 * @configurationRepoIdSuffix No 563 */ 564 public static final String VERSION_SCHEME_CACHE_DEBUG = PREFIX_UTIL + "versionScheme.cacheDebug"; 565 566 /** 567 * The default value for version scheme cache debug if {@link #VERSION_SCHEME_CACHE_DEBUG} isn't set. 568 * 569 * @since 2.0.10 570 */ 571 public static final boolean DEFAULT_VERSION_SCHEME_CACHE_DEBUG = false; 572 573 private ConfigurationProperties() { 574 // hide constructor 575 } 576}