You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@maven.apache.org by mi...@apache.org on 2021/12/12 19:51:44 UTC
[maven-resolver] 06/06: 100-column boundary
This is an automated email from the ASF dual-hosted git repository.
michaelo pushed a commit to branch file-lock
in repository https://gitbox.apache.org/repos/asf/maven-resolver.git
commit 2c38e1de5d267067ba5b1b51477013918752871a
Author: Michael Osipov <mi...@apache.org>
AuthorDate: Sun Dec 12 20:50:55 2021 +0100
100-column boundary
---
.../impl/synccontext/named/TakariNameMapper.java | 5 +++--
.../named/providers/FileLockNamedLockFactory.java | 4 ++--
.../aether/named/support/FileLockNamedLock.java | 15 ++++++++-------
.../aether/named/support/FileSystemFriendly.java | 12 ++++++------
.../java/org/eclipse/aether/named/support/Retry.java | 19 ++++++++++---------
5 files changed, 29 insertions(+), 26 deletions(-)
diff --git a/maven-resolver-impl/src/main/java/org/eclipse/aether/internal/impl/synccontext/named/TakariNameMapper.java b/maven-resolver-impl/src/main/java/org/eclipse/aether/internal/impl/synccontext/named/TakariNameMapper.java
index cd3cc03..984a086 100644
--- a/maven-resolver-impl/src/main/java/org/eclipse/aether/internal/impl/synccontext/named/TakariNameMapper.java
+++ b/maven-resolver-impl/src/main/java/org/eclipse/aether/internal/impl/synccontext/named/TakariNameMapper.java
@@ -37,8 +37,9 @@ import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
/**
- * A {@link NameMapper} that creates same name mapping as Takari Local Repository does, with baseDir (local repo).
- * Part of code blatantly copies parts of the Takari {@code LockingSyncContext}.
+ * A {@link NameMapper} that creates same name mapping as Takari Local Repository does, with
+ * {@code baseDir} (local repo). Part of code blatantly copies parts of the Takari
+ * {@code LockingSyncContext}.
*
* @see <a href="https://github.com/takari/takari-local-repository/blob/24133e50a0478dccb5620ac2f2255187608f165b/src/main/java/io/takari/aether/concurrency/LockingSyncContext.java">Takari
* LockingSyncContext.java</a>
diff --git a/maven-resolver-named-locks/src/main/java/org/eclipse/aether/named/providers/FileLockNamedLockFactory.java b/maven-resolver-named-locks/src/main/java/org/eclipse/aether/named/providers/FileLockNamedLockFactory.java
index 7e9e89d..b40772e 100644
--- a/maven-resolver-named-locks/src/main/java/org/eclipse/aether/named/providers/FileLockNamedLockFactory.java
+++ b/maven-resolver-named-locks/src/main/java/org/eclipse/aether/named/providers/FileLockNamedLockFactory.java
@@ -38,8 +38,8 @@ import org.eclipse.aether.named.support.NamedLockFactorySupport;
import org.eclipse.aether.named.support.NamedLockSupport;
/**
- * Named locks factory of {@link FileLockNamedLock}s. This is a bit special implementation, as it expects locks names
- * to be fully qualified absolute file system paths.
+ * Named locks factory of {@link FileLockNamedLock}s. This is a bit special implementation, as it
+ * expects locks names to be fully qualified absolute file system paths.
*
* @since TBD
*/
diff --git a/maven-resolver-named-locks/src/main/java/org/eclipse/aether/named/support/FileLockNamedLock.java b/maven-resolver-named-locks/src/main/java/org/eclipse/aether/named/support/FileLockNamedLock.java
index f519af2..b4c2877 100644
--- a/maven-resolver-named-locks/src/main/java/org/eclipse/aether/named/support/FileLockNamedLock.java
+++ b/maven-resolver-named-locks/src/main/java/org/eclipse/aether/named/support/FileLockNamedLock.java
@@ -35,14 +35,15 @@ import java.util.concurrent.locks.ReentrantLock;
import static org.eclipse.aether.named.support.Retry.retry;
/**
- * Named lock that uses {@link FileLock}. An instance of this class is about ONE LOCK (one file) and is possibly used
- * by multiple threads. Each thread (if properly coded re boxing) will try to obtain either shared or exclusive lock.
- * As file locks are JVM-scoped (so one JVM can obtain same file lock only once), the threads share file lock and
- * synchronize according to it. Still, as file lock obtain operation does not block (or in other words, the method
- * that does block cannot be controlled for how long it blocks), we are "simulating" thread blocking using
+ * Named lock that uses {@link FileLock}. An instance of this class is about ONE LOCK (one file)
+ * and is possibly used by multiple threads. Each thread (if properly coded re boxing) will try to
+ * obtain either shared or exclusive lock. As file locks are JVM-scoped (so one JVM can obtain
+ * same file lock only once), the threads share file lock and synchronize according to it. Still,
+ * as file lock obtain operation does not block (or in other words, the method that does block
+ * cannot be controlled for how long it blocks), we are "simulating" thread blocking using
* {@link Retry} utility.
- * This implementation performs coordination not only on thread (JVM-local) level, but also on process level,
- * as long as other parties are using this same "advisory" locking mechanism.
+ * This implementation performs coordination not only on thread (JVM-local) level, but also on
+ * process level, as long as other parties are using this same "advisory" locking mechanism.
*
* @since TBD
*/
diff --git a/maven-resolver-named-locks/src/main/java/org/eclipse/aether/named/support/FileSystemFriendly.java b/maven-resolver-named-locks/src/main/java/org/eclipse/aether/named/support/FileSystemFriendly.java
index 9e66ff1..d029e4e 100644
--- a/maven-resolver-named-locks/src/main/java/org/eclipse/aether/named/support/FileSystemFriendly.java
+++ b/maven-resolver-named-locks/src/main/java/org/eclipse/aether/named/support/FileSystemFriendly.java
@@ -20,13 +20,13 @@ package org.eclipse.aether.named.support;
*/
/**
- * A marker interface that mark component "file system friendly". In case of lock factory, it would mean that
- * passed in lock names MUST ADHERE to file path naming convention (and not use some special, non FS friendly
- * characters in it). Essentially, component marked with this interface expects (or uses) that "name" is an absolute
- * and valid file path.
+ * A marker interface that mark component "file system friendly". In case of lock factory, it
+ * would mean that passed in lock names MUST ADHERE to file path naming convention (and not use
+ * some special, non FS friendly characters in it). Essentially, component marked with this
+ * interface expects (or uses) that "name" is an absolute and valid file path.
*
- * <strong>Important note:</strong> Experimental interface, is not meant to be used outside of Maven Resolver codebase.
- * May change or be removed completely without any further notice.
+ * <strong>Important note:</strong> Experimental interface, is not meant to be used outside of
+ * Maven Resolver codebase. May change or be removed completely without any further notice.
*/
public interface FileSystemFriendly
{
diff --git a/maven-resolver-named-locks/src/main/java/org/eclipse/aether/named/support/Retry.java b/maven-resolver-named-locks/src/main/java/org/eclipse/aether/named/support/Retry.java
index ad37b00..1f5a61b 100644
--- a/maven-resolver-named-locks/src/main/java/org/eclipse/aether/named/support/Retry.java
+++ b/maven-resolver-named-locks/src/main/java/org/eclipse/aether/named/support/Retry.java
@@ -27,11 +27,11 @@ import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
- * Retry helper: retries given {@code Callable} as long it returns {@code null} (interpreted as "no answer yet") or
- * given time passes. This helper implements similar semantics regarding caller thread as
- * {@link java.util.concurrent.locks.Lock#tryLock(long, TimeUnit)} method does: blocks the caller thread until operation
- * return non-{@code null} value within the given waiting time and the current thread has not been
- * {@linkplain Thread#interrupt interrupted}.
+ * Retry helper: retries given {@code Callable} as long as it returns {@code null} (interpreted
+ * as "no answer yet") or given time passes. This helper implements similar semantics regarding
+ * caller threads as {@link java.util.concurrent.locks.Lock#tryLock(long, TimeUnit)} method does:
+ * blocks the caller thread until operation return non-{@code null} value within the given waiting
+ * time and the current thread has not been {@linkplain Thread#interrupt interrupted}.
*
* @since TBD
*/
@@ -45,10 +45,11 @@ public final class Retry
}
/**
- * Retries for given amount of time (time, unit) the passed in operation, sleeping given sleepMills between
- * retries. In case operation returns null, it is assumed "is not done yet" state, so retry will happen (if time
- * barrier allows). If time barrier passes, and still {@code null} ("is not done yet") is returned from operation,
- * the defaultResult is returned.
+ * Retries for given amount of time (time, unit) the passed in operation, sleeping given
+ * {@code sleepMills} between retries. In case operation returns {@code null}, it is assumed
+ * "is not done yet" state, so retry will happen (if time barrier allows). If time barrier
+ * passes, and still {@code null} ("is not done yet") is returned from operation, the
+ * {@code defaultResult} is returned.
*/
public static <R> R retry( final long time,
final TimeUnit unit,