org.eclipse.persistence.config.SystemProperties Maven / Gradle / Ivy
/*
* Copyright (c) 1998, 2024 Oracle and/or its affiliates. All rights reserved.
*
* This program and the accompanying materials are made available under the
* terms of the Eclipse Public License v. 2.0 which is available at
* http://www.eclipse.org/legal/epl-2.0,
* or the Eclipse Distribution License v. 1.0 which is available at
* http://www.eclipse.org/org/documents/edl-v10.php.
*
* SPDX-License-Identifier: EPL-2.0 OR BSD-3-Clause
*/
// Contributors:
// tware - added to allow pluggage archive factory
// 05/11/2020-2.7.0 Jody Grassel
// - 538296: Wrong month is returned if OffsetDateTime is used in JPA 2.2 code
package org.eclipse.persistence.config;
import java.util.concurrent.TimeUnit;
/**
* This class provides the list of System properties that are recognized by EclipseLink.
* @author tware
*
*/
public final class SystemProperties {
/**
* Configures the factory class we use to produce instances of org.eclispe.persistence.jpa.Archive
* These instances are used to examine persistence units and the files within them and are used for discovery
* of classes in the persistence unit
* Allows user-provided ArchiveFactory and Archive
*/
public static final String ARCHIVE_FACTORY = "eclipselink.archive.factory";
/**
* This property is used to debug weaving issues. When it is set, weaved classes will be
* output to the given path as they are weaved
*/
public static final String WEAVING_OUTPUT_PATH = "eclipselink.weaving.output.path";
/**
* This property is used in conjunction with WEAVING_OUTPUT_PATH. By default, existing classes
* on the path provided to WEAVING_OUTPUT_PATH will not be overridden. If this is set to true, they will be
*/
public static final String WEAVING_SHOULD_OVERWRITE = "eclipselink.weaving.overwrite.existing";
/**
* This property can be used to tell EclipseLink to process classes in the ASM Default manner. The fix for bug
* 370975 changes EclipseLink's weaving support to use ASM itself to examine class hierarchies. Setting this flag to
* true will cause us to use the default reflection mechanism again. This flag provides a means to workaround any issues encountered with
* the ASM-based weaving introspection
*/
public static final String WEAVING_REFLECTIVE_INTROSPECTION = "eclipselink.weaving.reflective-introspection";
/**
* This property is used in conjunction with
* org.eclipse.persistence.sessions.IdentityMapAccessor.printIdentityMapLocks().
* Setting this property will cause EclipseLink to record the stack trace of
* the lock acquisition and print it along with the identity map locks. This
* should only be set if the thread that owns a lock is not 'stuck' but
* still owns the lock when a normal printIdentityMapLocks is done.
*
* This can also be set in code statically through ConcurrencyManager.setShouldTrackStack(true)
*/
public static final String RECORD_STACK_ON_LOCK = "eclipselink.cache.record-stack-on-lock";
/**
* This property can be set to disable processing of X-Many relationship
* attributes for Query By Example objects. In previous versions of
* EclipseLink these attributes would have been ignored but as of this
* release they will be processed into the expression.
*/
public static final String DO_NOT_PROCESS_XTOMANY_FOR_QBE = "eclipselink.query.query-by-example.ignore-xtomany";
/**
* This system property can be set to override target server platform set by the Java EE container
* with the one either set in persistence.xml or auto-detected.
*/
public static final String ENFORCE_TARGET_SERVER = "eclipselink.target-server.enforce";
/**
* This system property can be set the specific time zone used by ConversionManager to convert
* LocalDateTime, OffsetDateTime, and OffsetTime types.
*/
public static final String CONVERSION_USE_TIMEZONE = "org.eclipse.persistence.conversion.useTimeZone";
/**
* This system property can be set to restore ConversionManager behavior with converting
* LocalDateTime, OffsetDateTime, and OffsetTime types back to using the JVM's default time zone instead
* of UTC. This restores behavior prior to fixing Bug 538296. This property is ignored if the
* System Property CONVERSION_USE_TIMEZONE has been set.
*/
public static final String CONVERSION_USE_DEFAULT_TIMEZONE = "org.eclipse.persistence.conversion.useDefaultTimeZoneForJavaTime";
/**
* This property can be set to {@code false} to enable UPDATE call to set
* foreign key value in the target row in unidirectional 1-Many mapping
* with not nullable FK. In previous versions of EclipseLink this was
* the default behaviour.
* Allowed values are: true/false.
*/
public static final String ONETOMANY_DEFER_INSERTS = "eclipselink.mapping.onetomany.defer-inserts";
/**
* This system property in milliseconds can control thread management in org.eclipse.persistence.internal.helper.ConcurrencyManager.
* It controls how much time loop wait before it tries to acquire lock for current thread again. If the value is set above 0 deadlock detection
* mechanism and related extended logging will be activated.
* Default value is 0 (unit is ms). Allowed values are: long
*/
public static final String CONCURRENCY_MANAGER_ACQUIRE_WAIT_TIME = "eclipselink.concurrency.manager.waittime";
/**
* This system property in milliseconds can control thread management in org.eclipse.persistence.internal.helper.ConcurrencyManager.
* It controls how much time ConcurrencyManager will wait before it will identify, that thread which builds new object/entity instance
* should be identified as a potential deadlock source. It leads into some additional log messages.
* Default value is 0 (unit is ms). In this case extended logging is not active. Allowed values are: long
*/
public static final String CONCURRENCY_MANAGER_BUILD_OBJECT_COMPLETE_WAIT_TIME = "eclipselink.concurrency.manager.build.object.complete.waittime";
/**
* This system property in milliseconds can control thread management in org.eclipse.persistence.internal.helper.ConcurrencyManager.
* It controls how long we are willing to wait before firing up an exception
* Default value is 40000 (unit is ms). Allowed values are: long
*/
public static final String CONCURRENCY_MANAGER_MAX_SLEEP_TIME = "eclipselink.concurrency.manager.maxsleeptime";
/**
* This system property in milliseconds can control thread management in org.eclipse.persistence.internal.helper.ConcurrencyManager and org.eclipse.persistence.internal.helper.ConcurrencyUtil.
* It controls how frequently the tiny dump log message is created.
* Default value is 40000 (unit is ms). Allowed values are: long
*/
public static final String CONCURRENCY_MANAGER_MAX_FREQUENCY_DUMP_TINY_MESSAGE = "eclipselink.concurrency.manager.maxfrequencytodumptinymessage";
/**
* This system property in milliseconds can control thread management in org.eclipse.persistence.internal.helper.ConcurrencyManager and org.eclipse.persistence.internal.helper.ConcurrencyUtil.
* It controls how frequently the massive dump log message is created.
* Default value is 60000 (unit is ms). Allowed values are: long
*/
public static final String CONCURRENCY_MANAGER_MAX_FREQUENCY_DUMP_MASSIVE_MESSAGE = "eclipselink.concurrency.manager.maxfrequencytodumpmassivemessage";
/**
*
* This property control (enable/disable) if {@code InterruptedException} fired when dead-lock diagnostic is enabled.
*
* Allowed Values (case sensitive String):
*
* - "{@code false}" - if aborting frozen thread is not effective it is preferable to not fire the interrupted exception let the system
* In the places where use this property normally if a thread is stuck it is because it is doing object building.
* Blowing the threads ups is not that dangerous. It can be very dangerous for production if the dead lock ends up
* not being resolved because the productive business transactions will become cancelled if the application has a
* limited number of retries to for example process an MDB. However, the code spots where we use this constant are
* not as sensible as when the write lock manager is starving to run commit.
*
- "{@code true}" (DEFAULT) - if we want the to fire up an exception to try to get the current thread to release all of its acquired locks and allow other
* threads to progress.
*
*/
public static final String CONCURRENCY_MANAGER_ALLOW_INTERRUPTED_EXCEPTION = "eclipselink.concurrency.manager.allow.interruptedexception";
/**
*
* This property control (enable/disable) if {@code ConcurrencyException} fired when dead-lock diagnostic is enabled.
*
* Allowed Values (case sensitive String):
*
* - "{@code false}" - if aborting frozen thread is not effective it is preferable to not fire the concurrency exception let the system
* freeze and die and force the administration to kill the server. This is preferable to aborting the transactions
* multiple times without success in resolving the dead lock and having business critical messages that after 3 JMS
* retries are discarded out. Failing to resolve a dead lock can have terrible impact in system recovery unless we
* have infinite retries for the business transactions.
*
- "{@code true}" (DEFAULT) - if we want the to fire up an exception to try to get the current thread to release all of its acquired
* locks and allow other threads to progress.
*
*/
public static final String CONCURRENCY_MANAGER_ALLOW_CONCURRENCY_EXCEPTION = "eclipselink.concurrency.manager.allow.concurrency.exception";
/**
*
* This property control (enable/disable) collection debug/trace information during ReadLock acquisition, when dead-lock diagnostic is enabled.
*
* Allowed Values (case sensitive String):
*
* - "{@code false}" (DEFAULT) - don't collect debug/trace information during ReadLock acquisition
*
- "{@code true}" - collect debug/trace information during ReadLock acquisition. Has negative impact to the performance.
*
*/
public static final String CONCURRENCY_MANAGER_ALLOW_STACK_TRACE_READ_LOCK = "eclipselink.concurrency.manager.allow.readlockstacktrace";
/**
*
* This property control (enable/disable) semaphore in {@link org.eclipse.persistence.internal.descriptors.ObjectBuilder}
*
* Object building see {@link org.eclipse.persistence.internal.descriptors.ObjectBuilder} could be one of the
* primary sources pressure on concurrency manager. Most of the cache key acquisition and releasing is taking place during object building.
* Enable {@code true} this property to try reduce the likelihood of having dead locks is to allow less threads to start object
* building in parallel. In this case there should be negative impact to the performance.
* Note: Parallel access to the same entity/entity tree from different threads is not recommended technique in EclipseLink.
*
* - "{@code true}" - means we want to override vanilla behavior and use a semaphore to not allow too many
* threads in parallel to do object building
*
- "{@code false}" (DEFAULT) - means just go ahead and try to build the object without any semaphore (false is
* vanilla behavior).
*
*/
public static final String CONCURRENCY_MANAGER_USE_SEMAPHORE_TO_SLOW_DOWN_OBJECT_BUILDING = "eclipselink.concurrency.manager.object.building.semaphore";
/**
*
* This property control (enable/disable) semaphore in {@link org.eclipse.persistence.internal.helper.WriteLockManager#acquireRequiredLocks}
*
* This algorithm
* {@link org.eclipse.persistence.internal.helper.WriteLockManager#acquireRequiredLocks}
* is being used when a transaction is committing and it is acquire locks to merge the change set.
* It should happen if algorithm has trouble when multiple threads report change sets on the same entity (e.g.
* one-to-many relations of master detail being enriched with more details on this master).
* Note: Parallel access to the same entity/entity tree from different threads is not recommended technique in EclipseLink.
*
* - "{@code true}" - means we want to override vanilla behavior and use a semaphore to not allow too many
* threads. In this case there should be negative impact to the performance.
*
- "{@code false}" (DEFAULT) - means just go ahead and try to build the object without any semaphore (false is
* vanilla behavior).
*
*/
public static final String CONCURRENCY_MANAGER_USE_SEMAPHORE_TO_SLOW_DOWN_WRITE_LOCK_MANAGER_ACQUIRE_REQUIRED_LOCKS = "eclipselink.concurrency.manager.write.lock.manager.semaphore";
/**
*
* This property control number of threads in semaphore in {@link org.eclipse.persistence.internal.descriptors.ObjectBuilder}
* If "eclipselink.concurrency.manager.object.building.semaphore" property is {@code true} default value is 10. Allowed values are: int
* If "eclipselink.concurrency.manager.object.building.semaphore" property is {@code false} (DEFAULT) number of threads is unlimited.
*
*/
public static final String CONCURRENCY_MANAGER_OBJECT_BUILDING_NO_THREADS = "eclipselink.concurrency.manager.object.building.no.threads";
/**
*
* This property control number of threads in semaphore in {@link org.eclipse.persistence.internal.helper.WriteLockManager#acquireRequiredLocks}
* If "eclipselink.concurrency.manager.write.lock.manager.semaphore" property is {@code true} default value is 2. Allowed values are: int
* If "eclipselink.concurrency.manager.write.lock.manager.semaphore" property is {@code false} (DEFAULT) number of threads is unlimited.
*
*/
public static final String CONCURRENCY_MANAGER_WRITE_LOCK_MANAGER_ACQUIRE_REQUIRED_LOCKS_NO_THREADS = "eclipselink.concurrency.manager.write.lock.manager.no.threads";
/**
*
* This property control semaphore the maximum time to wait for a permit in {@link org.eclipse.persistence.internal.helper.ConcurrencySemaphore#acquireSemaphoreIfAppropriate(boolean)}
* It's passed to {@link java.util.concurrent.Semaphore#tryAcquire(long, TimeUnit)}
* Default value is 2000 (unit is ms). Allowed values are: long
*
*/
public static final String CONCURRENCY_SEMAPHORE_MAX_TIME_PERMIT = "eclipselink.concurrency.semaphore.max.time.permit";
/**
*
* This property control timeout between log messages in {@link org.eclipse.persistence.internal.helper.ConcurrencySemaphore#acquireSemaphoreIfAppropriate(boolean)} when method/thread tries to get permit for the execution.
* Default value is 10000 (unit is ms). Allowed values are: long
*
*/
public static final String CONCURRENCY_SEMAPHORE_LOG_TIMEOUT = "eclipselink.concurrency.semaphore.log.timeout";
/**
*
* This property control which ASM implementation is used for classes bytecode modification.
*
*
* Allowed Values (case sensitive String):
*
* - "{@code eclipselink}" (DEFAULT) - use ASM implementation from org.eclipse.persistence.asm project.
* - "{@code ow2}" - use ASM implementation from org.ow2.asm project.
*
*/
public static final String ASM_SERVICE = "eclipselink.asm.service";
private SystemProperties() {
// no instance please
}
}