Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance. Project price only 1 $
You can buy this project and download/modify it how often you want.
/*
* This file is part of dependency-check-core.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
* Copyright (c) 2017 Jeremy Long. All Rights Reserved.
*/
package org.owasp.dependencycheck.utils;
import java.io.File;
import java.io.IOException;
import java.io.RandomAccessFile;
import java.nio.channels.FileLock;
import java.security.SecureRandom;
import java.sql.Timestamp;
import java.util.Date;
import javax.annotation.concurrent.NotThreadSafe;
import org.owasp.dependencycheck.exception.WriteLockException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
* A lock file implementation; creates a custom lock file so that only a single
* instance of dependency-check can update the a given resource.
*
* @author Jeremy Long
*/
@NotThreadSafe
public class WriteLock implements AutoCloseable {
/**
* The logger.
*/
private static final Logger LOGGER = LoggerFactory.getLogger(WriteLock.class);
/**
* Secure random number generator.
*/
private static final SecureRandom SECURE_RANDOM = new SecureRandom();
/**
* How long to sleep waiting for the lock.
*/
public static final int SLEEP_DURATION = 15000;
/**
* Max attempts to obtain a lock.
*/
public static final int MAX_SLEEP_COUNT = 160;
/**
* The file lock.
*/
private FileLock lock = null;
/**
* Reference to the file that we are locking.
*/
private RandomAccessFile file = null;
/**
* The lock file.
*/
private File lockFile = null;
/**
* The configured settings.
*/
private final Settings settings;
/**
* A random string used to validate the lock.
*/
private final String magic;
/**
* A flag indicating whether or not an resource is lockable.
*/
private final boolean isLockable;
/**
* The name of the lock file.
*/
private final String lockFileName;
/**
* The shutdown hook used to remove the lock file in case of an unexpected
* shutdown.
*/
private WriteLockShutdownHook hook = null;
/**
* Constructs a new Write Lock object with the configured settings.
*
* @param settings the configured settings
* @throws WriteLockException thrown if a lock could not be obtained
*/
public WriteLock(Settings settings) throws WriteLockException {
this(settings, true);
}
/**
* Constructs a new Write Lock object with the configured settings.
*
* @param settings the configured settings
* @param isLockable a flag indicating if a lock can be obtained for the
* resource; if false the lock does nothing. This is useful in the case of
* ODC where we need to lock for updates against H2 but we do not need to
* lock updates for other databases.
* @throws WriteLockException thrown if a lock could not be obtained
*/
public WriteLock(Settings settings, boolean isLockable) throws WriteLockException {
this(settings, isLockable, "odc.update.lock");
}
/**
* Constructs a new Write Lock object with the configured settings.
*
* @param settings the configured settings
* @param isLockable a flag indicating if a lock can be obtained for the
* resource; if false the lock does nothing. This is useful in the case of
* ODC where we need to lock for updates against H2 but we do not need to
* lock updates for other databases.
* @param lockFileName the name of the lock file; note the lock file will be
* in the ODC data directory.
* @throws WriteLockException thrown if a lock could not be obtained
*/
public WriteLock(Settings settings, boolean isLockable, String lockFileName) throws WriteLockException {
this.settings = settings;
final byte[] random = new byte[16];
SECURE_RANDOM.nextBytes(random);
magic = Checksum.getHex(random);
this.isLockable = isLockable;
this.lockFileName = lockFileName;
lock();
}
/**
* Obtains a lock on the resource.
*
* @throws WriteLockException thrown if a lock could not be obtained
*/
public final void lock() throws WriteLockException {
if (!isLockable) {
return;
}
try {
final File dir = settings.getDataDirectory();
lockFile = new File(dir, lockFileName);
checkState();
int ctr = 0;
do {
try {
if (!lockFile.exists() && lockFile.createNewFile()) {
file = new RandomAccessFile(lockFile, "rw");
lock = file.getChannel().lock();
file.writeBytes(magic);
file.getChannel().force(true);
Thread.sleep(20);
file.seek(0);
final String current = file.readLine();
if (current != null && !current.equals(magic)) {
lock.close();
lock = null;
LOGGER.debug("Another process obtained a lock first ({})", Thread.currentThread().getName());
} else {
addShutdownHook();
final Timestamp timestamp = new Timestamp(System.currentTimeMillis());
LOGGER.debug("Lock file created ({}) {} @ {}", Thread.currentThread().getName(), magic, timestamp);
}
}
} catch (InterruptedException ex) {
Thread.currentThread().interrupt();
LOGGER.trace("Expected error as another thread has likely locked the file", ex);
} catch (IOException ex) {
LOGGER.trace("Expected error as another thread has likely locked the file", ex);
} finally {
if (lock == null && file != null) {
try {
file.close();
file = null;
} catch (IOException ex) {
LOGGER.trace("Unable to close the lock file", ex);
}
}
}
if (lock == null || !lock.isValid()) {
try {
final Timestamp timestamp = new Timestamp(System.currentTimeMillis());
LOGGER.debug("Sleeping thread {} ({}) for {} seconds because an exclusive lock on the database could not be obtained ({})",
Thread.currentThread().getName(), magic, SLEEP_DURATION / 1000, timestamp);
Thread.sleep(SLEEP_DURATION);
} catch (InterruptedException ex) {
LOGGER.debug("sleep was interrupted.", ex);
Thread.currentThread().interrupt();
}
}
} while (++ctr < MAX_SLEEP_COUNT && (lock == null || !lock.isValid()));
if (lock == null || !lock.isValid()) {
throw new WriteLockException("Unable to obtain the update lock, skipping the database update. Skipping the database update.");
}
} catch (IOException ex) {
throw new WriteLockException(ex.getMessage(), ex);
}
}
/**
* Releases the lock on the resource.
*/
@Override
public void close() {
if (!isLockable) {
return;
}
if (lock != null) {
try {
lock.release();
lock = null;
} catch (IOException ex) {
LOGGER.debug("Failed to release lock", ex);
}
}
if (file != null) {
try {
file.close();
file = null;
} catch (IOException ex) {
LOGGER.debug("Unable to delete lock file", ex);
}
}
if (lockFile != null && lockFile.isFile()) {
final String msg = readLockFile();
if (msg != null && msg.equals(magic) && !lockFile.delete()) {
LOGGER.error("Lock file '{}' was unable to be deleted. Please manually delete this file.", lockFile.toString());
lockFile.deleteOnExit();
}
}
lockFile = null;
removeShutdownHook();
final Timestamp timestamp = new Timestamp(System.currentTimeMillis());
LOGGER.debug("Lock released ({}) {} @ {}", Thread.currentThread().getName(), magic, timestamp);
}
/**
* Checks the state of the custom write lock file and under some conditions
* will attempt to remove the lock file.
*
* @throws WriteLockException thrown if the lock directory does not exist
* and cannot be created
*/
private void checkState() throws WriteLockException {
if (!lockFile.getParentFile().isDirectory() && !lockFile.mkdir()) {
throw new WriteLockException("Unable to create path to data directory.");
}
if (lockFile.isFile()) {
//TODO - this 30 minute check needs to be configurable.
if (getFileAge(lockFile) > 30) {
LOGGER.debug("An old write lock file was found: {}", lockFile.getAbsolutePath());
if (!lockFile.delete()) {
LOGGER.warn("An old write lock file was found but the system was unable to delete "
+ "the file. Consider manually deleting {}", lockFile.getAbsolutePath());
}
} else {
LOGGER.info("Lock file found `{}`", lockFile);
LOGGER.info("Existing update in progress; waiting for update to complete");
}
}
}
/**
* Reads the first line from the lock file and returns the results as a
* string.
*
* @return the first line from the lock file; or null if the contents could
* not be read
*/
private String readLockFile() {
String msg = null;
try (RandomAccessFile f = new RandomAccessFile(lockFile, "rw")) {
msg = f.readLine();
} catch (IOException ex) {
LOGGER.debug(String.format("Error reading lock file: %s", lockFile), ex);
}
return msg;
}
/**
* Returns the age of the file in minutes.
*
* @param file the file to calculate the age
* @return the age of the file
*/
private double getFileAge(File file) {
final Date d = new Date();
final long modified = file.lastModified();
final double time = (d.getTime() - modified) / 1000.0 / 60.0;
LOGGER.debug("Lock file age is {} minutes", time);
return time;
}
/**
* Adds the shutdown hook to the JVM.
*/
private void addShutdownHook() {
if (hook == null) {
hook = WriteLockShutdownHookFactory.getHook(settings);
hook.add(this);
}
}
/**
* Removes the shutdown hook.
*/
private void removeShutdownHook() {
if (hook != null) {
hook.remove();
hook = null;
}
}
}
