mirror of
https://github.com/Frooodle/Stirling-PDF.git
synced 2026-02-17 13:52:14 +01:00
V2 settings api (Added to V1) (#4015)
# Description of Changes <!-- Please provide a summary of the changes, including: - What was changed - Why the change was made - Any challenges encountered Closes #(issue_number) --> --- ## Checklist ### General - [ ] I have read the [Contribution Guidelines](https://github.com/Stirling-Tools/Stirling-PDF/blob/main/CONTRIBUTING.md) - [ ] I have read the [Stirling-PDF Developer Guide](https://github.com/Stirling-Tools/Stirling-PDF/blob/main/devGuide/DeveloperGuide.md) (if applicable) - [ ] I have read the [How to add new languages to Stirling-PDF](https://github.com/Stirling-Tools/Stirling-PDF/blob/main/devGuide/HowToAddNewLanguage.md) (if applicable) - [ ] I have performed a self-review of my own code - [ ] My changes generate no new warnings ### Documentation - [ ] I have updated relevant docs on [Stirling-PDF's doc repo](https://github.com/Stirling-Tools/Stirling-Tools.github.io/blob/main/docs/) (if functionality has heavily changed) - [ ] I have read the section [Add New Translation Tags](https://github.com/Stirling-Tools/Stirling-PDF/blob/main/devGuide/HowToAddNewLanguage.md#add-new-translation-tags) (for new translation tags only) ### UI Changes (if applicable) - [ ] Screenshots or videos demonstrating the UI changes are attached (e.g., as comments or direct attachments in the PR) ### Testing (if applicable) - [ ] I have tested my changes locally. Refer to the [Testing Guide](https://github.com/Stirling-Tools/Stirling-PDF/blob/main/devGuide/DeveloperGuide.md#6-testing) for more details. --------- Co-authored-by: a <a> Co-authored-by: pixeebot[bot] <104101892+pixeebot[bot]@users.noreply.github.com>
This commit is contained in:
Anthony Stirling
GitHub
@@ -25,6 +25,9 @@ import org.springframework.core.io.Resource;
|
||||
import org.springframework.core.io.support.EncodedResource;
|
||||
import org.springframework.stereotype.Component;
|
||||
|
||||
import com.fasterxml.jackson.annotation.JsonIgnore;
|
||||
import com.fasterxml.jackson.annotation.JsonProperty;
|
||||
|
||||
import lombok.Data;
|
||||
import lombok.Getter;
|
||||
import lombok.Setter;
|
||||
@@ -58,7 +61,10 @@ public class ApplicationProperties {
|
||||
private Mail mail = new Mail();
|
||||
|
||||
private Premium premium = new Premium();
|
||||
|
||||
@JsonIgnore // Deprecated - completely hidden from JSON serialization
|
||||
private EnterpriseEdition enterpriseEdition = new EnterpriseEdition();
|
||||
|
||||
private AutoPipeline autoPipeline = new AutoPipeline();
|
||||
private ProcessExecutor processExecutor = new ProcessExecutor();
|
||||
|
||||
@@ -168,14 +174,27 @@ public class ApplicationProperties {
|
||||
private Boolean autoCreateUser = false;
|
||||
private Boolean blockRegistration = false;
|
||||
private String registrationId = "stirling";
|
||||
@ToString.Exclude private String idpMetadataUri;
|
||||
|
||||
@ToString.Exclude
|
||||
@JsonProperty("idpMetadataUri")
|
||||
private String idpMetadataUri;
|
||||
|
||||
private String idpSingleLogoutUrl;
|
||||
private String idpSingleLoginUrl;
|
||||
private String idpIssuer;
|
||||
private String idpCert;
|
||||
@ToString.Exclude private String privateKey;
|
||||
@ToString.Exclude private String spCert;
|
||||
|
||||
@JsonProperty("idpCert")
|
||||
private String idpCert;
|
||||
|
||||
@ToString.Exclude
|
||||
@JsonProperty("privateKey")
|
||||
private String privateKey;
|
||||
|
||||
@ToString.Exclude
|
||||
@JsonProperty("spCert")
|
||||
private String spCert;
|
||||
|
||||
@JsonIgnore
|
||||
public InputStream getIdpMetadataUri() throws IOException {
|
||||
if (idpMetadataUri.startsWith("classpath:")) {
|
||||
return new ClassPathResource(idpMetadataUri.substring("classpath".length()))
|
||||
@@ -192,6 +211,7 @@ public class ApplicationProperties {
|
||||
}
|
||||
}
|
||||
|
||||
@JsonIgnore
|
||||
public Resource getSpCert() {
|
||||
if (spCert == null) return null;
|
||||
if (spCert.startsWith("classpath:")) {
|
||||
@@ -201,6 +221,7 @@ public class ApplicationProperties {
|
||||
}
|
||||
}
|
||||
|
||||
@JsonIgnore
|
||||
public Resource getIdpCert() {
|
||||
if (idpCert == null) return null;
|
||||
if (idpCert.startsWith("classpath:")) {
|
||||
@@ -210,6 +231,7 @@ public class ApplicationProperties {
|
||||
}
|
||||
}
|
||||
|
||||
@JsonIgnore
|
||||
public Resource getPrivateKey() {
|
||||
if (privateKey.startsWith("classpath:")) {
|
||||
return new ClassPathResource(privateKey.substring("classpath:".length()));
|
||||
@@ -321,8 +343,12 @@ public class ApplicationProperties {
|
||||
|
||||
@Data
|
||||
public static class TempFileManagement {
|
||||
@JsonProperty("baseTmpDir")
|
||||
private String baseTmpDir = "";
|
||||
|
||||
@JsonProperty("libreofficeDir")
|
||||
private String libreofficeDir = "";
|
||||
|
||||
private String systemTempDir = "";
|
||||
private String prefix = "stirling-pdf-";
|
||||
private long maxAgeHours = 24;
|
||||
@@ -330,12 +356,14 @@ public class ApplicationProperties {
|
||||
private boolean startupCleanup = true;
|
||||
private boolean cleanupSystemTemp = false;
|
||||
|
||||
@JsonIgnore
|
||||
public String getBaseTmpDir() {
|
||||
return baseTmpDir != null && !baseTmpDir.isEmpty()
|
||||
? baseTmpDir
|
||||
: java.lang.System.getProperty("java.io.tmpdir") + "/stirling-pdf";
|
||||
}
|
||||
|
||||
@JsonIgnore
|
||||
public String getLibreofficeDir() {
|
||||
return libreofficeDir != null && !libreofficeDir.isEmpty()
|
||||
? libreofficeDir
|
||||
@@ -611,12 +639,24 @@ public class ApplicationProperties {
|
||||
|
||||
@Data
|
||||
public static class TimeoutMinutes {
|
||||
@JsonProperty("libreOfficetimeoutMinutes")
|
||||
private long libreOfficeTimeoutMinutes;
|
||||
|
||||
@JsonProperty("pdfToHtmltimeoutMinutes")
|
||||
private long pdfToHtmlTimeoutMinutes;
|
||||
|
||||
@JsonProperty("pythonOpenCvtimeoutMinutes")
|
||||
private long pythonOpenCvTimeoutMinutes;
|
||||
|
||||
@JsonProperty("weasyPrinttimeoutMinutes")
|
||||
private long weasyPrintTimeoutMinutes;
|
||||
|
||||
@JsonProperty("installApptimeoutMinutes")
|
||||
private long installAppTimeoutMinutes;
|
||||
|
||||
@JsonProperty("calibretimeoutMinutes")
|
||||
private long calibreTimeoutMinutes;
|
||||
|
||||
private long tesseractTimeoutMinutes;
|
||||
private long qpdfTimeoutMinutes;
|
||||
private long ghostscriptTimeoutMinutes;
|
||||
|
||||
@@ -4,7 +4,11 @@ import java.io.File;
|
||||
import java.io.FileOutputStream;
|
||||
import java.io.IOException;
|
||||
import java.io.InputStream;
|
||||
import java.lang.management.ManagementFactory;
|
||||
import java.net.*;
|
||||
import java.nio.channels.FileChannel;
|
||||
import java.nio.channels.FileLock;
|
||||
import java.nio.channels.OverlappingFileLockException;
|
||||
import java.nio.charset.StandardCharsets;
|
||||
import java.nio.file.*;
|
||||
import java.nio.file.attribute.BasicFileAttributes;
|
||||
@@ -15,6 +19,9 @@ import java.util.Enumeration;
|
||||
import java.util.List;
|
||||
import java.util.Locale;
|
||||
import java.util.UUID;
|
||||
import java.util.concurrent.ConcurrentHashMap;
|
||||
import java.util.concurrent.TimeUnit;
|
||||
import java.util.concurrent.locks.ReentrantReadWriteLock;
|
||||
|
||||
import org.springframework.core.io.ClassPathResource;
|
||||
import org.springframework.core.io.Resource;
|
||||
@@ -37,6 +44,33 @@ public class GeneralUtils {
|
||||
private static final List<String> DEFAULT_VALID_SCRIPTS =
|
||||
List.of("png_to_webp.py", "split_photos.py");
|
||||
|
||||
// Concurrency control for settings file operations
|
||||
private static final ReentrantReadWriteLock settingsLock =
|
||||
new ReentrantReadWriteLock(true); // fair locking
|
||||
private static volatile String lastSettingsHash = null;
|
||||
|
||||
// Lock timeout configuration
|
||||
private static final long LOCK_TIMEOUT_SECONDS = 30; // Maximum time to wait for locks
|
||||
private static final long FILE_LOCK_TIMEOUT_MS = 1000; // File lock timeout
|
||||
|
||||
// Track active file locks for diagnostics
|
||||
private static final ConcurrentHashMap<String, String> activeLocks = new ConcurrentHashMap<>();
|
||||
|
||||
// Configuration flag for force bypass mode
|
||||
private static final boolean FORCE_BYPASS_EXTERNAL_LOCKS =
|
||||
Boolean.parseBoolean(
|
||||
System.getProperty("stirling.settings.force-bypass-locks", "true"));
|
||||
|
||||
// Initialize settings hash on first access
|
||||
static {
|
||||
try {
|
||||
lastSettingsHash = calculateSettingsHash();
|
||||
} catch (Exception e) {
|
||||
log.warn("Could not initialize settings hash: {}", e.getMessage());
|
||||
lastSettingsHash = "";
|
||||
}
|
||||
}
|
||||
|
||||
public static File convertMultipartFileToFile(MultipartFile multipartFile) throws IOException {
|
||||
String customTempDir = System.getenv("STIRLING_TEMPFILES_DIRECTORY");
|
||||
if (customTempDir == null || customTempDir.isEmpty()) {
|
||||
@@ -397,12 +431,447 @@ public class GeneralUtils {
|
||||
* Internal Implementation Details *
|
||||
*------------------------------------------------------------------------*/
|
||||
|
||||
/**
|
||||
* Thread-safe method to save a key-value pair to settings file with concurrency control.
|
||||
* Prevents race conditions and data corruption when multiple threads/admins modify settings.
|
||||
*
|
||||
* @param key The setting key in dot notation (e.g., "security.enableCSRF")
|
||||
* @param newValue The new value to set
|
||||
* @throws IOException If file operations fail
|
||||
* @throws IllegalStateException If settings file was modified by another process
|
||||
*/
|
||||
public static void saveKeyToSettings(String key, Object newValue) throws IOException {
|
||||
String[] keyArray = key.split("\\.");
|
||||
// Use timeout to prevent infinite blocking
|
||||
boolean lockAcquired = false;
|
||||
try {
|
||||
lockAcquired = settingsLock.writeLock().tryLock(LOCK_TIMEOUT_SECONDS, TimeUnit.SECONDS);
|
||||
if (!lockAcquired) {
|
||||
throw new IOException(
|
||||
String.format(
|
||||
"Could not acquire write lock for setting '%s' within %d seconds. "
|
||||
+ "Another admin operation may be in progress or the system may be under heavy load.",
|
||||
key, LOCK_TIMEOUT_SECONDS));
|
||||
}
|
||||
Path settingsPath = Paths.get(InstallationPathConfig.getSettingsPath());
|
||||
|
||||
// Get current thread and process info for diagnostics
|
||||
String currentThread = Thread.currentThread().getName();
|
||||
String currentProcess = ManagementFactory.getRuntimeMXBean().getName();
|
||||
String lockAttemptInfo =
|
||||
String.format(
|
||||
"Thread:%s Process:%s Setting:%s", currentThread, currentProcess, key);
|
||||
|
||||
log.debug(
|
||||
"Attempting to acquire file lock for setting '{}' from {}",
|
||||
key,
|
||||
lockAttemptInfo);
|
||||
|
||||
// Check what locks are currently active
|
||||
if (!activeLocks.isEmpty()) {
|
||||
log.debug("Active locks detected: {}", activeLocks);
|
||||
}
|
||||
|
||||
// Attempt file locking with proper retry logic
|
||||
long startTime = System.currentTimeMillis();
|
||||
int retryCount = 0;
|
||||
final int maxRetries = (int) (FILE_LOCK_TIMEOUT_MS / 100); // 100ms intervals
|
||||
|
||||
while ((System.currentTimeMillis() - startTime) < FILE_LOCK_TIMEOUT_MS) {
|
||||
FileChannel channel = null;
|
||||
FileLock fileLock = null;
|
||||
|
||||
try {
|
||||
// Open channel and keep it open during lock attempts
|
||||
channel =
|
||||
FileChannel.open(
|
||||
settingsPath,
|
||||
StandardOpenOption.READ,
|
||||
StandardOpenOption.WRITE,
|
||||
StandardOpenOption.CREATE);
|
||||
|
||||
// Try to acquire exclusive lock
|
||||
fileLock = channel.tryLock();
|
||||
|
||||
if (fileLock != null) {
|
||||
// Successfully acquired lock - track it for diagnostics
|
||||
String lockInfo =
|
||||
String.format(
|
||||
"%s acquired at %d",
|
||||
lockAttemptInfo, System.currentTimeMillis());
|
||||
activeLocks.put(settingsPath.toString(), lockInfo);
|
||||
|
||||
// Successfully acquired lock - perform the update
|
||||
try {
|
||||
// Validate that we can actually read/write to detect stale locks
|
||||
if (!Files.isWritable(settingsPath)) {
|
||||
throw new IOException(
|
||||
"Settings file is not writable - permissions issue");
|
||||
}
|
||||
|
||||
// Perform the actual update
|
||||
String[] keyArray = key.split("\\.");
|
||||
YamlHelper settingsYaml = new YamlHelper(settingsPath);
|
||||
settingsYaml.updateValue(Arrays.asList(keyArray), newValue);
|
||||
settingsYaml.saveOverride(settingsPath);
|
||||
|
||||
// Update hash after successful write
|
||||
lastSettingsHash = null; // Will be recalculated on next access
|
||||
|
||||
log.debug(
|
||||
"Successfully updated setting: {} = {} (attempt {}) by {}",
|
||||
key,
|
||||
newValue,
|
||||
retryCount + 1,
|
||||
lockAttemptInfo);
|
||||
return; // Success - exit method
|
||||
|
||||
} finally {
|
||||
// Remove from active locks tracking
|
||||
activeLocks.remove(settingsPath.toString());
|
||||
|
||||
// Ensure file lock is always released
|
||||
if (fileLock.isValid()) {
|
||||
fileLock.release();
|
||||
}
|
||||
}
|
||||
} else {
|
||||
// Lock not available - log diagnostic info
|
||||
retryCount++;
|
||||
log.debug(
|
||||
"File lock not available for setting '{}', attempt {} of {} by {}. Active locks: {}",
|
||||
key,
|
||||
retryCount,
|
||||
maxRetries,
|
||||
lockAttemptInfo,
|
||||
activeLocks.isEmpty() ? "none" : activeLocks);
|
||||
|
||||
// Wait before retry with exponential backoff (100ms, 150ms, 200ms, etc.)
|
||||
long waitTime = Math.min(100 + (retryCount * 50), 500);
|
||||
Thread.sleep(waitTime);
|
||||
}
|
||||
|
||||
} catch (OverlappingFileLockException e) {
|
||||
// This specific exception means another thread in the same JVM has the lock
|
||||
retryCount++;
|
||||
log.debug(
|
||||
"Overlapping file lock detected for setting '{}', attempt {} of {} by {}. Another thread in this JVM has the lock. Active locks: {}",
|
||||
key,
|
||||
retryCount,
|
||||
maxRetries,
|
||||
lockAttemptInfo,
|
||||
activeLocks);
|
||||
|
||||
try {
|
||||
// Wait before retry with exponential backoff
|
||||
long waitTime = Math.min(100 + (retryCount * 50), 500);
|
||||
Thread.sleep(waitTime);
|
||||
} catch (InterruptedException ie) {
|
||||
Thread.currentThread().interrupt();
|
||||
throw new IOException("Interrupted while waiting for file lock retry", ie);
|
||||
}
|
||||
} catch (IOException e) {
|
||||
// If this is a specific lock contention error, continue retrying
|
||||
if (e.getMessage() != null
|
||||
&& (e.getMessage().contains("locked")
|
||||
|| e.getMessage().contains("another process")
|
||||
|| e.getMessage().contains("sharing violation"))) {
|
||||
|
||||
retryCount++;
|
||||
log.debug(
|
||||
"File lock contention for setting '{}', attempt {} of {} by {}. IOException: {}. Active locks: {}",
|
||||
key,
|
||||
retryCount,
|
||||
maxRetries,
|
||||
lockAttemptInfo,
|
||||
e.getMessage(),
|
||||
activeLocks);
|
||||
|
||||
try {
|
||||
// Wait before retry with exponential backoff
|
||||
long waitTime = Math.min(100 + (retryCount * 50), 500);
|
||||
Thread.sleep(waitTime);
|
||||
} catch (InterruptedException ie) {
|
||||
Thread.currentThread().interrupt();
|
||||
throw new IOException(
|
||||
"Interrupted while waiting for file lock retry", ie);
|
||||
}
|
||||
} else {
|
||||
// Different type of IOException - don't retry
|
||||
throw e;
|
||||
}
|
||||
} catch (InterruptedException e) {
|
||||
Thread.currentThread().interrupt();
|
||||
throw new IOException("Interrupted while waiting for file lock", e);
|
||||
} finally {
|
||||
// Clean up resources
|
||||
if (fileLock != null && fileLock.isValid()) {
|
||||
try {
|
||||
fileLock.release();
|
||||
} catch (IOException e) {
|
||||
log.warn(
|
||||
"Failed to release file lock for setting {}: {}",
|
||||
key,
|
||||
e.getMessage());
|
||||
}
|
||||
}
|
||||
if (channel != null && channel.isOpen()) {
|
||||
try {
|
||||
channel.close();
|
||||
} catch (IOException e) {
|
||||
log.warn(
|
||||
"Failed to close file channel for setting {}: {}",
|
||||
key,
|
||||
e.getMessage());
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// If we get here, we couldn't acquire the file lock within timeout
|
||||
// If no internal locks are active, this is likely an external system lock
|
||||
// Try one final force write attempt if bypass is enabled
|
||||
if (FORCE_BYPASS_EXTERNAL_LOCKS && activeLocks.isEmpty()) {
|
||||
log.debug(
|
||||
"No internal locks detected - attempting force write bypass for setting '{}' due to external system lock (bypass enabled)",
|
||||
key);
|
||||
try {
|
||||
// Attempt direct file write without locking
|
||||
String[] keyArray = key.split("\\.");
|
||||
YamlHelper settingsYaml = new YamlHelper(settingsPath);
|
||||
settingsYaml.updateValue(Arrays.asList(keyArray), newValue);
|
||||
settingsYaml.saveOverride(settingsPath);
|
||||
|
||||
// Update hash after successful write
|
||||
lastSettingsHash = null;
|
||||
|
||||
log.debug(
|
||||
"Force write bypass successful for setting '{}' = {} (external system lock detected)",
|
||||
key,
|
||||
newValue);
|
||||
return; // Success
|
||||
|
||||
} catch (Exception forceWriteException) {
|
||||
log.error(
|
||||
"Force write bypass failed for setting '{}': {}",
|
||||
key,
|
||||
forceWriteException.getMessage());
|
||||
// Fall through to original exception
|
||||
}
|
||||
} else if (!FORCE_BYPASS_EXTERNAL_LOCKS && activeLocks.isEmpty()) {
|
||||
log.debug(
|
||||
"External system lock detected for setting '{}' but force bypass is disabled (use -Dstirling.settings.force-bypass-locks=true to enable)",
|
||||
key);
|
||||
}
|
||||
|
||||
throw new IOException(
|
||||
String.format(
|
||||
"Could not acquire file lock for setting '%s' within %d ms by %s. "
|
||||
+ "The settings file may be locked by another process or there may be file system issues. "
|
||||
+ "Final active locks: %s. Force bypass %s",
|
||||
key,
|
||||
FILE_LOCK_TIMEOUT_MS,
|
||||
lockAttemptInfo,
|
||||
activeLocks,
|
||||
activeLocks.isEmpty()
|
||||
? "attempted but failed"
|
||||
: "not attempted (internal locks detected)"));
|
||||
|
||||
} catch (InterruptedException e) {
|
||||
Thread.currentThread().interrupt();
|
||||
throw new IOException("Interrupted while waiting for settings lock", e);
|
||||
} catch (Exception e) {
|
||||
log.error("Unexpected error updating setting {}: {}", key, e.getMessage(), e);
|
||||
if (e instanceof IOException) {
|
||||
throw (IOException) e;
|
||||
}
|
||||
throw new IOException("Failed to update settings: " + e.getMessage(), e);
|
||||
} finally {
|
||||
if (lockAcquired) {
|
||||
settingsLock.writeLock().unlock();
|
||||
|
||||
// Recalculate hash after releasing the write lock
|
||||
try {
|
||||
if (lastSettingsHash == null) {
|
||||
lastSettingsHash = calculateSettingsHash();
|
||||
log.debug("Updated settings hash after write operation");
|
||||
}
|
||||
} catch (Exception e) {
|
||||
log.warn("Failed to update settings hash after write: {}", e.getMessage());
|
||||
lastSettingsHash = "";
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Calculates MD5 hash of the settings file for change detection
|
||||
*
|
||||
* @return Hash string, or empty string if file doesn't exist
|
||||
*/
|
||||
private static String calculateSettingsHash() throws Exception {
|
||||
Path settingsPath = Paths.get(InstallationPathConfig.getSettingsPath());
|
||||
YamlHelper settingsYaml = new YamlHelper(settingsPath);
|
||||
settingsYaml.updateValue(Arrays.asList(keyArray), newValue);
|
||||
settingsYaml.saveOverride(settingsPath);
|
||||
if (!Files.exists(settingsPath)) {
|
||||
return "";
|
||||
}
|
||||
|
||||
boolean lockAcquired = false;
|
||||
try {
|
||||
lockAcquired = settingsLock.readLock().tryLock(LOCK_TIMEOUT_SECONDS, TimeUnit.SECONDS);
|
||||
if (!lockAcquired) {
|
||||
throw new IOException(
|
||||
String.format(
|
||||
"Could not acquire read lock for settings hash calculation within %d seconds. "
|
||||
+ "System may be under heavy load or there may be a deadlock.",
|
||||
LOCK_TIMEOUT_SECONDS));
|
||||
}
|
||||
|
||||
// Use OS-level file locking with proper retry logic
|
||||
long startTime = System.currentTimeMillis();
|
||||
int retryCount = 0;
|
||||
final int maxRetries = (int) (FILE_LOCK_TIMEOUT_MS / 100); // 100ms intervals
|
||||
|
||||
while ((System.currentTimeMillis() - startTime) < FILE_LOCK_TIMEOUT_MS) {
|
||||
FileChannel channel = null;
|
||||
FileLock fileLock = null;
|
||||
|
||||
try {
|
||||
// Open channel and keep it open during lock attempts
|
||||
channel = FileChannel.open(settingsPath, StandardOpenOption.READ);
|
||||
|
||||
// Try to acquire shared lock for reading
|
||||
fileLock = channel.tryLock(0L, Long.MAX_VALUE, true);
|
||||
|
||||
if (fileLock != null) {
|
||||
// Successfully acquired lock - calculate hash
|
||||
try {
|
||||
byte[] fileBytes = Files.readAllBytes(settingsPath);
|
||||
MessageDigest md = MessageDigest.getInstance("MD5");
|
||||
byte[] hashBytes = md.digest(fileBytes);
|
||||
|
||||
StringBuilder sb = new StringBuilder();
|
||||
for (byte b : hashBytes) {
|
||||
sb.append(String.format("%02x", b));
|
||||
}
|
||||
log.debug(
|
||||
"Successfully calculated settings hash (attempt {})",
|
||||
retryCount + 1);
|
||||
return sb.toString();
|
||||
} finally {
|
||||
fileLock.release();
|
||||
}
|
||||
} else {
|
||||
// Lock not available - log and retry
|
||||
retryCount++;
|
||||
log.debug(
|
||||
"File lock not available for hash calculation, attempt {} of {}",
|
||||
retryCount,
|
||||
maxRetries);
|
||||
|
||||
// Wait before retry with exponential backoff
|
||||
long waitTime = Math.min(100 + (retryCount * 50), 500);
|
||||
Thread.sleep(waitTime);
|
||||
}
|
||||
|
||||
} catch (IOException e) {
|
||||
// If this is a specific lock contention error, continue retrying
|
||||
if (e.getMessage() != null
|
||||
&& (e.getMessage().contains("locked")
|
||||
|| e.getMessage().contains("another process")
|
||||
|| e.getMessage().contains("sharing violation"))) {
|
||||
|
||||
retryCount++;
|
||||
log.debug(
|
||||
"File lock contention for hash calculation, attempt {} of {}: {}",
|
||||
retryCount,
|
||||
maxRetries,
|
||||
e.getMessage());
|
||||
|
||||
try {
|
||||
// Wait before retry with exponential backoff
|
||||
long waitTime = Math.min(100 + (retryCount * 50), 500);
|
||||
Thread.sleep(waitTime);
|
||||
} catch (InterruptedException ie) {
|
||||
Thread.currentThread().interrupt();
|
||||
throw new IOException(
|
||||
"Interrupted while waiting for file lock retry", ie);
|
||||
}
|
||||
} else {
|
||||
// Different type of IOException - don't retry
|
||||
throw e;
|
||||
}
|
||||
} catch (InterruptedException e) {
|
||||
Thread.currentThread().interrupt();
|
||||
throw new IOException("Interrupted while waiting for file lock", e);
|
||||
} finally {
|
||||
// Clean up resources
|
||||
if (fileLock != null && fileLock.isValid()) {
|
||||
try {
|
||||
fileLock.release();
|
||||
} catch (IOException e) {
|
||||
log.warn(
|
||||
"Failed to release file lock for hash calculation: {}",
|
||||
e.getMessage());
|
||||
}
|
||||
}
|
||||
if (channel != null && channel.isOpen()) {
|
||||
try {
|
||||
channel.close();
|
||||
} catch (IOException e) {
|
||||
log.warn(
|
||||
"Failed to close file channel for hash calculation: {}",
|
||||
e.getMessage());
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// If we couldn't get the file lock, throw an exception
|
||||
throw new IOException(
|
||||
String.format(
|
||||
"Could not acquire file lock for settings hash calculation within %d ms. "
|
||||
+ "The settings file may be locked by another process.",
|
||||
FILE_LOCK_TIMEOUT_MS));
|
||||
|
||||
} catch (InterruptedException e) {
|
||||
Thread.currentThread().interrupt();
|
||||
throw new IOException(
|
||||
"Interrupted while waiting for settings read lock for hash calculation", e);
|
||||
} finally {
|
||||
if (lockAcquired) {
|
||||
settingsLock.readLock().unlock();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Thread-safe method to read settings values with proper locking and timeout
|
||||
*
|
||||
* @return YamlHelper instance for reading
|
||||
* @throws IOException If timeout occurs or file operations fail
|
||||
*/
|
||||
public static YamlHelper getSettingsReader() throws IOException {
|
||||
boolean lockAcquired = false;
|
||||
try {
|
||||
lockAcquired = settingsLock.readLock().tryLock(LOCK_TIMEOUT_SECONDS, TimeUnit.SECONDS);
|
||||
if (!lockAcquired) {
|
||||
throw new IOException(
|
||||
String.format(
|
||||
"Could not acquire read lock for settings within %d seconds. "
|
||||
+ "System may be under heavy load or there may be a deadlock.",
|
||||
LOCK_TIMEOUT_SECONDS));
|
||||
}
|
||||
|
||||
Path settingsPath = Paths.get(InstallationPathConfig.getSettingsPath());
|
||||
return new YamlHelper(settingsPath);
|
||||
|
||||
} catch (InterruptedException e) {
|
||||
Thread.currentThread().interrupt();
|
||||
throw new IOException("Interrupted while waiting for settings read lock", e);
|
||||
} finally {
|
||||
if (lockAcquired) {
|
||||
settingsLock.readLock().unlock();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public static String generateMachineFingerprint() {
|
||||
|
||||
Reference in New Issue
Block a user