You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@cassandra.apache.org by jj...@apache.org on 2019/02/05 03:54:38 UTC
[cassandra] branch trunk updated: Clean up all javadoc related
errors
This is an automated email from the ASF dual-hosted git repository.
jjirsa pushed a commit to branch trunk
in repository https://gitbox.apache.org/repos/asf/cassandra.git
The following commit(s) were added to refs/heads/trunk by this push:
new ff73c33 Clean up all javadoc related errors
ff73c33 is described below
commit ff73c33ab78f70cd0e70280c89e8d8a46f5536d8
Author: Dinesh A. Joshi <di...@apple.com>
AuthorDate: Tue Jan 22 15:36:02 2019 -0800
Clean up all javadoc related errors
Patch by Dinesh Joshi; Reviewed by Jeff Jirsa for CASSANDRA-14995
---
.../org/apache/cassandra/audit/AuditEvent.java | 2 +-
.../org/apache/cassandra/audit/AuditLogFilter.java | 3 ++
.../apache/cassandra/audit/AuditLogManager.java | 21 +++++++++++
src/java/org/apache/cassandra/auth/AuthCache.java | 6 ++--
src/java/org/apache/cassandra/auth/Role.java | 4 +--
src/java/org/apache/cassandra/auth/Roles.java | 4 +--
src/java/org/apache/cassandra/config/Config.java | 4 +--
src/java/org/apache/cassandra/cql3/Terms.java | 2 +-
.../apache/cassandra/cql3/functions/TimeFcts.java | 4 +--
.../apache/cassandra/cql3/selection/Selector.java | 1 -
.../statements/schema/AlterTableStatement.java | 2 +-
.../cassandra/db/ColumnFamilyStoreMBean.java | 1 -
src/java/org/apache/cassandra/db/LivenessInfo.java | 4 +--
.../cassandra/db/compaction/ActiveCompactions.java | 2 +-
.../cassandra/db/compaction/CompactionManager.java | 1 -
.../db/compaction/CompactionStrategyManager.java | 16 ++++-----
.../org/apache/cassandra/db/filter/DataLimits.java | 2 +-
.../org/apache/cassandra/db/rows/BTreeRow.java | 2 +-
.../org/apache/cassandra/db/rows/ColumnData.java | 2 +-
src/java/org/apache/cassandra/db/rows/Row.java | 2 +-
.../db/rows/ThrottledUnfilteredIterator.java | 4 +--
.../org/apache/cassandra/db/rows/Unfiltered.java | 2 +-
.../cassandra/dht/RangeFetchMapCalculator.java | 6 ++--
.../org/apache/cassandra/diag/DiagnosticEvent.java | 2 ++
.../diag/LastEventIdBroadcasterMBean.java | 3 +-
.../cassandra/hadoop/cql3/CqlBulkOutputFormat.java | 7 ++--
.../cassandra/hadoop/cql3/CqlOutputFormat.java | 3 +-
.../cassandra/index/SecondaryIndexManager.java | 2 +-
.../sasi/analyzer/StandardTokenizerInterface.java | 2 +-
.../cassandra/io/sstable/format/SSTableReader.java | 4 +--
.../cassandra/locator/AbstractEndpointSnitch.java | 4 +--
.../apache/cassandra/locator/IEndpointSnitch.java | 2 +-
.../apache/cassandra/locator/TokenMetadata.java | 6 ++--
.../apache/cassandra/metrics/KeyspaceMetrics.java | 2 +-
src/java/org/apache/cassandra/net/MessageOut.java | 2 +-
.../org/apache/cassandra/net/MessagingService.java | 2 +-
.../apache/cassandra/net/async/NettyFactory.java | 4 +--
.../repair/consistent/ConsistentSession.java | 42 +++++++++++-----------
.../cassandra/repair/consistent/LocalSessions.java | 2 +-
src/java/org/apache/cassandra/schema/Schema.java | 2 +-
.../service/EmbeddedCassandraService.java | 1 -
.../cassandra/service/StorageServiceMBean.java | 2 +-
src/java/org/apache/cassandra/tools/NodeProbe.java | 3 +-
.../transport/frame/FrameBodyTransformer.java | 2 +-
.../cassandra/utils/CoalescingStrategies.java | 2 +-
.../org/apache/cassandra/utils/btree/BTree.java | 4 +--
.../StreamingTombstoneHistogramBuilder.java | 7 ++--
.../compaction/CompactionStrategyManagerTest.java | 3 +-
48 files changed, 117 insertions(+), 95 deletions(-)
diff --git a/src/java/org/apache/cassandra/audit/AuditEvent.java b/src/java/org/apache/cassandra/audit/AuditEvent.java
index b21fe58..d59114e 100644
--- a/src/java/org/apache/cassandra/audit/AuditEvent.java
+++ b/src/java/org/apache/cassandra/audit/AuditEvent.java
@@ -26,7 +26,7 @@ import org.apache.cassandra.diag.DiagnosticEvent;
import org.apache.cassandra.diag.DiagnosticEventService;
/**
- * {@Link AuditLogEntry} wrapper to expose audit events as {@link DiagnosticEvent}s.
+ * {@link AuditLogEntry} wrapper to expose audit events as {@link DiagnosticEvent}s.
*/
public final class AuditEvent extends DiagnosticEvent
{
diff --git a/src/java/org/apache/cassandra/audit/AuditLogFilter.java b/src/java/org/apache/cassandra/audit/AuditLogFilter.java
index 163114d..71c224d 100644
--- a/src/java/org/apache/cassandra/audit/AuditLogFilter.java
+++ b/src/java/org/apache/cassandra/audit/AuditLogFilter.java
@@ -50,6 +50,9 @@ public class AuditLogFilter
/**
* (Re-)Loads filters from config. Called during startup as well as JMX invocations.
+ *
+ * @param auditLogOptions
+ * @return
*/
public static AuditLogFilter create(AuditLogOptions auditLogOptions)
{
diff --git a/src/java/org/apache/cassandra/audit/AuditLogManager.java b/src/java/org/apache/cassandra/audit/AuditLogManager.java
index d11eaa0..1e1337e 100644
--- a/src/java/org/apache/cassandra/audit/AuditLogManager.java
+++ b/src/java/org/apache/cassandra/audit/AuditLogManager.java
@@ -181,6 +181,14 @@ public class AuditLogManager
/**
* Logs Batch queries to both FQL and standard audit logger.
+ *
+ * @param type The type of the batch
+ * @param queryOrIdList
+ * @param values Values to bind to as parameters for the queries
+ * @param prepared Prepared statement
+ * @param options Options associated with the query invocation
+ * @param state Timestamp state associated with the query invocation
+ * @param queryStartTimeMillis Timestamp when the query was started
*/
public void logBatch(BatchStatement.Type type,
List<Object> queryOrIdList,
@@ -287,6 +295,18 @@ public class AuditLogManager
oldLogger.stop();
}
+
+ /**
+ * Configure FQL
+ *
+ * @param path Path to store FQL files
+ * @param rollCycle How often to roll FQL log segments so they can potentially be reclaimed
+ * @param blocking Whether the FQL should block if the FQL falls behind or should drop log records
+ * @param maxQueueWeight Maximum weight of in memory queue for records waiting to be written to the file before blocking or dropping
+ * @param maxLogSize Maximum size of the rolled files to retain on disk before deleting the oldest file
+ * @param archiveCommand the archive command to execute on rolled log files
+ * @param maxArchiveRetries max number of retries of failed archive commands
+ */
public void configureFQL(Path path, String rollCycle, boolean blocking, int maxQueueWeight, long maxLogSize, String archiveCommand, int maxArchiveRetries)
{
if (path.equals(auditLogger.path()))
@@ -311,6 +331,7 @@ public class AuditLogManager
/**
* ONLY FOR TESTING
*/
+ @VisibleForTesting
FullQueryLogger getFullQueryLogger()
{
return fullQueryLogger;
diff --git a/src/java/org/apache/cassandra/auth/AuthCache.java b/src/java/org/apache/cassandra/auth/AuthCache.java
index 4bf15c1..6d7e31d 100644
--- a/src/java/org/apache/cassandra/auth/AuthCache.java
+++ b/src/java/org/apache/cassandra/auth/AuthCache.java
@@ -57,9 +57,11 @@ public class AuthCache<K, V> implements AuthCacheMBean
/**
* @param name Used for MBean
- * @param setValidityDelegate Used to set cache validity period. See {@link Policy#expireAfterWrite()}
+ * @param setValidityDelegate Used to set cache validity period.
+ * See {@link Caffeine#expireAfterAccess}
* @param getValidityDelegate Getter for validity period
- * @param setUpdateIntervalDelegate Used to set cache update interval. See {@link Policy#refreshAfterWrite()}
+ * @param setUpdateIntervalDelegate Used to set cache update interval.
+ * See {@link Caffeine#refreshAfterWrite}
* @param getUpdateIntervalDelegate Getter for update interval
* @param setMaxEntriesDelegate Used to set max # entries in cache. See {@link com.github.benmanes.caffeine.cache.Policy.Eviction#setMaximum(long)}
* @param getMaxEntriesDelegate Getter for max entries.
diff --git a/src/java/org/apache/cassandra/auth/Role.java b/src/java/org/apache/cassandra/auth/Role.java
index e98cc7d..f826aea 100644
--- a/src/java/org/apache/cassandra/auth/Role.java
+++ b/src/java/org/apache/cassandra/auth/Role.java
@@ -30,8 +30,8 @@ public class Role
/**
* Represents a user or group in the auth subsystem.
* Roles may be members of other roles, but circular graphs of roles are not permitted.
- * The reason that memberOf is a Set<String> and not Set<Role> is to simplify loading
- * for IRoleManager implementations (in particular, CassandraRoleManager)
+ * The reason that memberOf is a {@code Set<String>} and not {@code Set<Role>} is to simplify loading
+ * for {@link IRoleManager} implementations (in particular, {@link CassandraRoleManager})
*/
public final RoleResource resource ;
diff --git a/src/java/org/apache/cassandra/auth/Roles.java b/src/java/org/apache/cassandra/auth/Roles.java
index 22eb0d3..243d06e 100644
--- a/src/java/org/apache/cassandra/auth/Roles.java
+++ b/src/java/org/apache/cassandra/auth/Roles.java
@@ -70,7 +70,7 @@ public class Roles
* Get detailed info on all the roles granted to the role identified by the supplied RoleResource.
* This includes superuser status and login privileges for the primary role and all roles granted directly
* to it or inherited.
- * The returnred roles may be cached if roles_validity_in_ms > 0
+ * The returnred roles may be cached if {@code roles_validity_in_ms > 0}
* This method is used where we need to know specific attributes of the collection of granted roles, i.e.
* when checking for superuser status which may be inherited from *any* granted role.
*
@@ -117,7 +117,7 @@ public class Roles
* Returns the map of custom options for the named role. These options are not inherited from granted roles, but
* are set directly.
* @param role the role identifier
- * @return map of option_name -> value. If no options are set for the named role, the map will be empty
+ * @return map of {@code option_name -> value}. If no options are set for the named role, the map will be empty
* but never null.
*/
public static Map<String, String> getOptions(RoleResource role)
diff --git a/src/java/org/apache/cassandra/config/Config.java b/src/java/org/apache/cassandra/config/Config.java
index 7371df7..99e15be 100644
--- a/src/java/org/apache/cassandra/config/Config.java
+++ b/src/java/org/apache/cassandra/config/Config.java
@@ -423,8 +423,8 @@ public class Config
/**
* flags for enabling tracking repaired state of data during reads
- * separate flags for range & single partition reads as single partition reads are only tracked
- * when CL > 1 and a digest mismatch occurs. Currently, range queries don't use digests so if
+ * separate flags for range & single partition reads as single partition reads are only tracked
+ * when {@code CL > 1} and a digest mismatch occurs. Currently, range queries don't use digests so if
* enabled for range reads, all such reads will include repaired data tracking. As this adds
* some overhead, operators may wish to disable it whilst still enabling it for partition reads
*/
diff --git a/src/java/org/apache/cassandra/cql3/Terms.java b/src/java/org/apache/cassandra/cql3/Terms.java
index 33ce2e9..cfd968f 100644
--- a/src/java/org/apache/cassandra/cql3/Terms.java
+++ b/src/java/org/apache/cassandra/cql3/Terms.java
@@ -197,7 +197,7 @@ public interface Terms
/**
* Creates a {@code Terms} containing a set of {@code Term}.
*
- * @param term the {@code Term}
+ * @param terms {@code List<Term>}
* @return a {@code Terms} containing a set of {@code Term}.
*/
public static Terms of(final List<Term> terms)
diff --git a/src/java/org/apache/cassandra/cql3/functions/TimeFcts.java b/src/java/org/apache/cassandra/cql3/functions/TimeFcts.java
index f029e59..045c009 100644
--- a/src/java/org/apache/cassandra/cql3/functions/TimeFcts.java
+++ b/src/java/org/apache/cassandra/cql3/functions/TimeFcts.java
@@ -92,7 +92,7 @@ public abstract class TimeFcts
/**
* Function that convert a value of <code>TIMEUUID</code> into a value of type <code>TIMESTAMP</code>.
- * @deprecated Replaced by the {@link #timeUuidToTimestamp} function
+ * @deprecated Replaced by the {@link #toUnixTimestamp} function
*/
public static final NativeScalarFunction dateOfFct = new NativeScalarFunction("dateof", TimestampType.instance, TimeUUIDType.instance)
{
@@ -118,7 +118,7 @@ public abstract class TimeFcts
/**
* Function that convert a value of type <code>TIMEUUID</code> into an UNIX timestamp.
- * @deprecated Replaced by the {@link #timeUuidToUnixTimestamp} function
+ * @deprecated Replaced by the {@link #toUnixTimestamp} function
*/
public static final NativeScalarFunction unixTimestampOfFct = new NativeScalarFunction("unixtimestampof", LongType.instance, TimeUUIDType.instance)
{
diff --git a/src/java/org/apache/cassandra/cql3/selection/Selector.java b/src/java/org/apache/cassandra/cql3/selection/Selector.java
index 3262b9c..985c7c5 100644
--- a/src/java/org/apache/cassandra/cql3/selection/Selector.java
+++ b/src/java/org/apache/cassandra/cql3/selection/Selector.java
@@ -108,7 +108,6 @@ public abstract class Selector
/**
* Checks if this factory creates <code>Selector</code>s that simply return a column value.
*
- * @param index the column index
* @return <code>true</code> if this factory creates <code>Selector</code>s that simply return a column value,
* <code>false</code> otherwise.
*/
diff --git a/src/java/org/apache/cassandra/cql3/statements/schema/AlterTableStatement.java b/src/java/org/apache/cassandra/cql3/statements/schema/AlterTableStatement.java
index c348cc4..27e90a8 100644
--- a/src/java/org/apache/cassandra/cql3/statements/schema/AlterTableStatement.java
+++ b/src/java/org/apache/cassandra/cql3/statements/schema/AlterTableStatement.java
@@ -90,7 +90,7 @@ public abstract class AlterTableStatement extends AlterSchemaStatement
abstract KeyspaceMetadata apply(KeyspaceMetadata keyspace, TableMetadata table);
/**
- * ALTER TABLE <table> ALTER <column> TYPE <newtype>;
+ * {@code ALTER TABLE <table> ALTER <column> TYPE <newtype>;}
*
* No longer supported.
*/
diff --git a/src/java/org/apache/cassandra/db/ColumnFamilyStoreMBean.java b/src/java/org/apache/cassandra/db/ColumnFamilyStoreMBean.java
index fb0d611..23c2e24 100644
--- a/src/java/org/apache/cassandra/db/ColumnFamilyStoreMBean.java
+++ b/src/java/org/apache/cassandra/db/ColumnFamilyStoreMBean.java
@@ -152,7 +152,6 @@ public interface ColumnFamilyStoreMBean
* @param verifySSTables if the new sstables should be verified that they are not corrupt
* @param verifyTokens if the tokens in the new sstables should be verified that they are owned by the current node
* @param invalidateCaches if row cache should be invalidated for the keys in the new sstables
- * @param jbodCheck if the new sstables should be placed 'optimally' - count tokens and move the sstable to the directory where it has the most keys
* @param extendedVerify if we should run an extended verify checking all values in the new sstables
*
* @return list of failed import directories
diff --git a/src/java/org/apache/cassandra/db/LivenessInfo.java b/src/java/org/apache/cassandra/db/LivenessInfo.java
index 1340c00..6002794 100644
--- a/src/java/org/apache/cassandra/db/LivenessInfo.java
+++ b/src/java/org/apache/cassandra/db/LivenessInfo.java
@@ -183,11 +183,11 @@ public class LivenessInfo
* Whether this liveness information supersedes another one (that is
* whether is has a greater timestamp than the other or not).
*
- * </br>
+ * <br>
*
* If timestamps are the same and none of them are expired livenessInfo,
* livenessInfo with greater TTL supersedes another. It also means, if timestamps are the same,
- * ttl superseders no-ttl. This is the same rule as {@link Conflicts#resolveRegular}
+ * ttl superseders no-ttl. This is the same rule as {@link org.apache.cassandra.db.rows.Cells#resolveRegular}
*
* If timestamps are the same and one of them is expired livenessInfo. Expired livenessInfo
* supersedes, ie. tombstone supersedes.
diff --git a/src/java/org/apache/cassandra/db/compaction/ActiveCompactions.java b/src/java/org/apache/cassandra/db/compaction/ActiveCompactions.java
index bba0601..07319a0 100644
--- a/src/java/org/apache/cassandra/db/compaction/ActiveCompactions.java
+++ b/src/java/org/apache/cassandra/db/compaction/ActiveCompactions.java
@@ -51,7 +51,7 @@ public class ActiveCompactions implements ActiveCompactionsTracker
/**
* Iterates over the active compactions and tries to find the CompactionInfo for the given sstable
*
- * Number of entries in compactions should be small (< 10) but avoid calling in any time-sensitive context
+ * Number of entries in compactions should be small ({@code < 10}) but avoid calling in any time-sensitive context
*/
public CompactionInfo getCompactionForSSTable(SSTableReader sstable)
{
diff --git a/src/java/org/apache/cassandra/db/compaction/CompactionManager.java b/src/java/org/apache/cassandra/db/compaction/CompactionManager.java
index 01e3aa6..2a2d18b 100644
--- a/src/java/org/apache/cassandra/db/compaction/CompactionManager.java
+++ b/src/java/org/apache/cassandra/db/compaction/CompactionManager.java
@@ -717,7 +717,6 @@ public class CompactionManager implements CompactionManagerMBean
* @param replicas token ranges to be repaired
* @param validatedForRepair SSTables containing the repaired ranges. Should be referenced before passing them.
* @param sessionID the repair session we're anti-compacting for
- * @throws InterruptedException
* @throws IOException
*/
public void performAnticompaction(ColumnFamilyStore cfs,
diff --git a/src/java/org/apache/cassandra/db/compaction/CompactionStrategyManager.java b/src/java/org/apache/cassandra/db/compaction/CompactionStrategyManager.java
index b978641..5e27f2f 100644
--- a/src/java/org/apache/cassandra/db/compaction/CompactionStrategyManager.java
+++ b/src/java/org/apache/cassandra/db/compaction/CompactionStrategyManager.java
@@ -85,13 +85,13 @@ import static org.apache.cassandra.db.compaction.AbstractStrategyHolder.GroupedS
* pending repair id.
*
* Operations on this class are guarded by a {@link ReentrantReadWriteLock}. This lock performs mutual exclusion on
- * reads and writes to the following variables: {@link this#repaired}, {@link this#unrepaired}, {@link this#isActive},
- * {@link this#params}, {@link this#currentBoundaries}. Whenever performing reads on these variables,
- * the {@link this#readLock} should be acquired. Likewise, updates to these variables should be guarded by
- * {@link this#writeLock}.
+ * reads and writes to the following variables: {@link CompactionStrategyManager#repaired}, {@link CompactionStrategyManager#unrepaired}, {@link CompactionStrategyManager#isActive},
+ * {@link CompactionStrategyManager#params}, {@link CompactionStrategyManager#currentBoundaries}. Whenever performing reads on these variables,
+ * the {@link CompactionStrategyManager#readLock} should be acquired. Likewise, updates to these variables should be guarded by
+ * {@link CompactionStrategyManager#writeLock}.
*
* Whenever the {@link DiskBoundaries} change, the compaction strategies must be reloaded, so in order to ensure
- * the compaction strategy placement reflect most up-to-date disk boundaries, call {@link this#maybeReloadDiskBoundaries()}
+ * the compaction strategy placement reflect most up-to-date disk boundaries, call {@link CompactionStrategyManager#maybeReloadDiskBoundaries()}
* before acquiring the read lock to acess the strategies.
*
*/
@@ -470,11 +470,11 @@ public class CompactionStrategyManager implements INotificationConsumer
* Checks if the disk boundaries changed and reloads the compaction strategies
* to reflect the most up-to-date disk boundaries.
*
- * This is typically called before acquiring the {@link this#readLock} to ensure the most up-to-date
+ * This is typically called before acquiring the {@link CompactionStrategyManager#readLock} to ensure the most up-to-date
* disk locations and boundaries are used.
*
- * This should *never* be called inside by a thread holding the {@link this#readLock}, since it
- * will potentially acquire the {@link this#writeLock} to update the compaction strategies
+ * This should *never* be called inside by a thread holding the {@link CompactionStrategyManager#readLock}, since it
+ * will potentially acquire the {@link CompactionStrategyManager#writeLock} to update the compaction strategies
* what can cause a deadlock.
*/
//TODO improve this to reload after receiving a notification rather than trying to reload on every operation
diff --git a/src/java/org/apache/cassandra/db/filter/DataLimits.java b/src/java/org/apache/cassandra/db/filter/DataLimits.java
index 50baf21..a4000f8 100644
--- a/src/java/org/apache/cassandra/db/filter/DataLimits.java
+++ b/src/java/org/apache/cassandra/db/filter/DataLimits.java
@@ -155,7 +155,7 @@ public abstract class DataLimits
* @param countPartitionsWithOnlyStaticData if {@code true} the partitions with only static data should be counted
* as 1 valid row.
* @param enforceStrictLiveness whether the row should be purged if there is no PK liveness info,
- * normally retrieved from {@link CFMetaData#enforceStrictLiveness()}
+ * normally retrieved from {@link org.apache.cassandra.schema.TableMetadata#enforceStrictLiveness()}
* @return a new {@code Counter} for this limits.
*/
public abstract Counter newCounter(int nowInSec,
diff --git a/src/java/org/apache/cassandra/db/rows/BTreeRow.java b/src/java/org/apache/cassandra/db/rows/BTreeRow.java
index dc3219a..4b5f6dc 100644
--- a/src/java/org/apache/cassandra/db/rows/BTreeRow.java
+++ b/src/java/org/apache/cassandra/db/rows/BTreeRow.java
@@ -379,7 +379,7 @@ public class BTreeRow extends AbstractRow
* Returns a copy of the row where all timestamps for live data have replaced by {@code newTimestamp} and
* all deletion timestamp by {@code newTimestamp - 1}.
*
- * This exists for the Paxos path, see {@link PartitionUpdate#updateAllTimestamp} for additional details.
+ * This exists for the Paxos path, see {@link PartitionUpdate.Builder#updateAllTimestamp(long)} for additional details.
*/
public Row updateAllTimestamp(long newTimestamp)
{
diff --git a/src/java/org/apache/cassandra/db/rows/ColumnData.java b/src/java/org/apache/cassandra/db/rows/ColumnData.java
index f2da132..56f7971 100644
--- a/src/java/org/apache/cassandra/db/rows/ColumnData.java
+++ b/src/java/org/apache/cassandra/db/rows/ColumnData.java
@@ -83,7 +83,7 @@ public abstract class ColumnData
* Returns a copy of the data where all timestamps for live data have replaced by {@code newTimestamp} and
* all deletion timestamp by {@code newTimestamp - 1}.
*
- * This exists for the Paxos path, see {@link PartitionUpdate#updateAllTimestamp} for additional details.
+ * This exists for the Paxos path, see {@link PartitionUpdate.Builder#updateAllTimestamp} for additional details.
*/
public abstract ColumnData updateAllTimestamp(long newTimestamp);
diff --git a/src/java/org/apache/cassandra/db/rows/Row.java b/src/java/org/apache/cassandra/db/rows/Row.java
index 0174adc..52c1767 100644
--- a/src/java/org/apache/cassandra/db/rows/Row.java
+++ b/src/java/org/apache/cassandra/db/rows/Row.java
@@ -115,7 +115,7 @@ public interface Row extends Unfiltered, Iterable<ColumnData>
*
* @param nowInSec the current time to decide what is deleted and what isn't
* @param enforceStrictLiveness whether the row should be purged if there is no PK liveness info,
- * normally retrieved from {@link CFMetaData#enforceStrictLiveness()}
+ * normally retrieved from {@link TableMetadata#enforceStrictLiveness()}
* @return true if there is some live information
*/
public boolean hasLiveData(int nowInSec, boolean enforceStrictLiveness);
diff --git a/src/java/org/apache/cassandra/db/rows/ThrottledUnfilteredIterator.java b/src/java/org/apache/cassandra/db/rows/ThrottledUnfilteredIterator.java
index a2e8425..ebb5675 100644
--- a/src/java/org/apache/cassandra/db/rows/ThrottledUnfilteredIterator.java
+++ b/src/java/org/apache/cassandra/db/rows/ThrottledUnfilteredIterator.java
@@ -30,7 +30,7 @@ import org.apache.cassandra.utils.CloseableIterator;
import com.google.common.annotations.VisibleForTesting;
/**
- * A utility class to split the given {@link#UnfilteredRowIterator} into smaller chunks each
+ * A utility class to split the given {@link UnfilteredRowIterator} into smaller chunks each
* having at most {@link #throttle} + 1 unfiltereds.
*
* Only the first output contains partition level info: {@link UnfilteredRowIterator#partitionLevelDeletion}
@@ -41,7 +41,7 @@ import com.google.common.annotations.VisibleForTesting;
*
* The lifecycle of outputed {{@link UnfilteredRowIterator} only last till next call to {@link #next()}.
*
- * A subsequent {@link #next} call will exhaust the previously returned iterator before computing the next,
+ * A subsequent {@link ThrottledUnfilteredIterator#next} call will exhaust the previously returned iterator before computing the next,
* effectively skipping unfiltereds up to the throttle size.
*
* Closing this iterator will close the underlying iterator.
diff --git a/src/java/org/apache/cassandra/db/rows/Unfiltered.java b/src/java/org/apache/cassandra/db/rows/Unfiltered.java
index 81b63b7..132e396 100644
--- a/src/java/org/apache/cassandra/db/rows/Unfiltered.java
+++ b/src/java/org/apache/cassandra/db/rows/Unfiltered.java
@@ -41,7 +41,7 @@ public interface Unfiltered extends Clusterable
/**
* Digest the atom using the provided {@link Hasher}.
*
- * @param hasher the {@see Hasher} to use.
+ * @param hasher the {@link Hasher} to use.
*/
public void digest(Hasher hasher);
diff --git a/src/java/org/apache/cassandra/dht/RangeFetchMapCalculator.java b/src/java/org/apache/cassandra/dht/RangeFetchMapCalculator.java
index 2a2de01..3c501ba 100644
--- a/src/java/org/apache/cassandra/dht/RangeFetchMapCalculator.java
+++ b/src/java/org/apache/cassandra/dht/RangeFetchMapCalculator.java
@@ -62,9 +62,9 @@ import org.psjava.ds.math.Function;
* - if we have more machines than ranges to stream the capacity will be 1 (each machine will stream at most 1 range)
* * Since the sum of the capacity on the edges from the super source to the range-vertices is less or equal to the sum
* of the capacities between the node-vertices and super sink we know that to get maximum flow we will use all the
- * range-vertices. (Say we have x ranges, y machines to provide them, total supersource -> range-vertice capacity will be x,
- * total node-vertice -> supersink capacity will be (y * ceil(x / y)) which worst case is x if x==y). The capacity between
- * the range-vertices and node-vertices is infinite.
+ * range-vertices. (Say we have x ranges, y machines to provide them, total {@code supersource -> range-vertice capacity} will be x,
+ * total {@code node-vertice -> supersink} capacity will be {@code(y * ceil(x / y))} which worst case is x {@code if
+ * x==y)}. The capacity between the range-vertices and node-vertices is infinite.
* * Then we try to solve the max-flow problem using psjava
* * If we can't find a solution where the total flow is = number of range-vertices, we bump the capacity between the node-vertices
* and the super source and try again.
diff --git a/src/java/org/apache/cassandra/diag/DiagnosticEvent.java b/src/java/org/apache/cassandra/diag/DiagnosticEvent.java
index 5de703b..bb7b625 100644
--- a/src/java/org/apache/cassandra/diag/DiagnosticEvent.java
+++ b/src/java/org/apache/cassandra/diag/DiagnosticEvent.java
@@ -45,6 +45,8 @@ public abstract class DiagnosticEvent
* maps, but must be Serializable, as returned values may be consumed by external clients. It's strongly recommended
* to stick to standard Java classes to avoid distributing custom classes to clients and also prevent potential
* class versioning conflicts.
+ *
+ * @return Returns map of key-value pairs containing relevant event details.
*/
public abstract Map<String, Serializable> toMap();
}
diff --git a/src/java/org/apache/cassandra/diag/LastEventIdBroadcasterMBean.java b/src/java/org/apache/cassandra/diag/LastEventIdBroadcasterMBean.java
index 03f05dc..7fd90d6 100644
--- a/src/java/org/apache/cassandra/diag/LastEventIdBroadcasterMBean.java
+++ b/src/java/org/apache/cassandra/diag/LastEventIdBroadcasterMBean.java
@@ -6,9 +6,8 @@ import java.util.Map;
* Provides a list of event types and the corresponding highest event IDs. Consumers may these IDs to determine
* if new data is available.
*
- * <p>Example result</p>
- *
* <table>
+ * <caption>Example result</caption>
* <tr>
* <th>Event</th>
* <th>Last ID</th>
diff --git a/src/java/org/apache/cassandra/hadoop/cql3/CqlBulkOutputFormat.java b/src/java/org/apache/cassandra/hadoop/cql3/CqlBulkOutputFormat.java
index dfdf855..492cf9e 100644
--- a/src/java/org/apache/cassandra/hadoop/cql3/CqlBulkOutputFormat.java
+++ b/src/java/org/apache/cassandra/hadoop/cql3/CqlBulkOutputFormat.java
@@ -43,11 +43,8 @@ import org.apache.hadoop.util.Progressable;
*
* <p>
* As is the case with the {@link org.apache.cassandra.hadoop.cql3.CqlOutputFormat},
- * you need to set the prepared statement in your
- * Hadoop job Configuration. The {@link CqlConfigHelper} class, through its
- * {@link org.apache.cassandra.hadoop.ConfigHelper#setOutputPreparedStatement} method, is provided to make this
- * simple.
- * you need to set the Keyspace. The {@link ConfigHelper} class, through its
+ * you need to set the prepared statement in your Hadoop job Configuration.
+ * You need to set the Keyspace. The {@link ConfigHelper} class, through its
* {@link org.apache.cassandra.hadoop.ConfigHelper#setOutputColumnFamily} method, is provided to make this
* simple.
* </p>
diff --git a/src/java/org/apache/cassandra/hadoop/cql3/CqlOutputFormat.java b/src/java/org/apache/cassandra/hadoop/cql3/CqlOutputFormat.java
index cc0a6b1..b2d3681 100644
--- a/src/java/org/apache/cassandra/hadoop/cql3/CqlOutputFormat.java
+++ b/src/java/org/apache/cassandra/hadoop/cql3/CqlOutputFormat.java
@@ -34,8 +34,7 @@ import org.apache.hadoop.mapreduce.*;
* table.
*
* <p>
- * As is the case with the {@link org.apache.cassandra.hadoop.ColumnFamilyInputFormat},
- * you need to set the prepared statement in your
+ * You need to set the prepared statement in your
* Hadoop job Configuration. The {@link CqlConfigHelper} class, through its
* {@link CqlConfigHelper#setOutputCql} method, is provided to make this
* simple.
diff --git a/src/java/org/apache/cassandra/index/SecondaryIndexManager.java b/src/java/org/apache/cassandra/index/SecondaryIndexManager.java
index ec54a65..f9c7bc2 100644
--- a/src/java/org/apache/cassandra/index/SecondaryIndexManager.java
+++ b/src/java/org/apache/cassandra/index/SecondaryIndexManager.java
@@ -110,7 +110,7 @@ import org.apache.cassandra.utils.concurrent.Refs;
* a target replica.
* <br><br>
* Finally, this class provides a clear and safe lifecycle to manage index builds, either full rebuilds via
- * {@link this#rebuildIndexesBlocking(Set)} or builds of new sstables
+ * {@link SecondaryIndexManager#rebuildIndexesBlocking} or builds of new sstables
* added via {@link org.apache.cassandra.notifications.SSTableAddedNotification}s, guaranteeing
* the following:
* <ul>
diff --git a/src/java/org/apache/cassandra/index/sasi/analyzer/StandardTokenizerInterface.java b/src/java/org/apache/cassandra/index/sasi/analyzer/StandardTokenizerInterface.java
index 327a674..4641681 100644
--- a/src/java/org/apache/cassandra/index/sasi/analyzer/StandardTokenizerInterface.java
+++ b/src/java/org/apache/cassandra/index/sasi/analyzer/StandardTokenizerInterface.java
@@ -57,7 +57,7 @@ public interface StandardTokenizerInterface
*
* All internal variables are reset, the old input stream
* <b>cannot</b> be reused (internal buffer is discarded and lost).
- * Lexical state is set to <tt>ZZ_INITIAL</tt>.
+ * Lexical state is set to <code>{@literal ZZ_INITIAL}</code>.
*
* @param reader the new input stream
*/
diff --git a/src/java/org/apache/cassandra/io/sstable/format/SSTableReader.java b/src/java/org/apache/cassandra/io/sstable/format/SSTableReader.java
index 01e30d6..249c897 100644
--- a/src/java/org/apache/cassandra/io/sstable/format/SSTableReader.java
+++ b/src/java/org/apache/cassandra/io/sstable/format/SSTableReader.java
@@ -394,7 +394,7 @@ public abstract class SSTableReader extends SSTable implements SelfRefCounted<SS
* @param components
* @param metadata
* @return opened SSTableReader
- * @throws IOException
+ * @throws CorruptSSTableException
*/
public static SSTableReader openForBatch(Descriptor descriptor, Set<Component> components, TableMetadataRef metadata)
{
@@ -477,7 +477,7 @@ public abstract class SSTableReader extends SSTable implements SelfRefCounted<SS
* @param isOffline Whether we are opening this SSTable "offline", for example from an external tool or not for inclusion in queries (validations)
* This stops regenerating BF + Summaries and also disables tracking of hotness for the SSTable.
* @return {@link SSTableReader}
- * @throws IOException
+ * @throws CorruptSSTableException
*/
public static SSTableReader open(Descriptor descriptor,
Set<Component> components,
diff --git a/src/java/org/apache/cassandra/locator/AbstractEndpointSnitch.java b/src/java/org/apache/cassandra/locator/AbstractEndpointSnitch.java
index 2e7408b..99ee40b 100644
--- a/src/java/org/apache/cassandra/locator/AbstractEndpointSnitch.java
+++ b/src/java/org/apache/cassandra/locator/AbstractEndpointSnitch.java
@@ -25,10 +25,10 @@ public abstract class AbstractEndpointSnitch implements IEndpointSnitch
public abstract int compareEndpoints(InetAddressAndPort target, Replica r1, Replica r2);
/**
- * Sorts the <tt>Collection</tt> of node addresses by proximity to the given address
+ * Sorts the <code>{@literal Collection}</code> of node addresses by proximity to the given address
* @param address the address to sort by proximity to
* @param unsortedAddress the nodes to sort
- * @return a new sorted <tt>List</tt>
+ * @return a new sorted <code>{@literal List}</code>
*/
public <C extends ReplicaCollection<? extends C>> C sortedByProximity(final InetAddressAndPort address, C unsortedAddress)
{
diff --git a/src/java/org/apache/cassandra/locator/IEndpointSnitch.java b/src/java/org/apache/cassandra/locator/IEndpointSnitch.java
index 381a642..090da2d 100644
--- a/src/java/org/apache/cassandra/locator/IEndpointSnitch.java
+++ b/src/java/org/apache/cassandra/locator/IEndpointSnitch.java
@@ -61,7 +61,7 @@ public interface IEndpointSnitch
}
/**
- * returns a new <tt>List</tt> sorted by proximity to the given endpoint
+ * returns a new <code>{@literal List}</code> sorted by proximity to the given endpoint
*/
public <C extends ReplicaCollection<? extends C>> C sortedByProximity(final InetAddressAndPort address, C addresses);
diff --git a/src/java/org/apache/cassandra/locator/TokenMetadata.java b/src/java/org/apache/cassandra/locator/TokenMetadata.java
index cb189c8..865c571 100644
--- a/src/java/org/apache/cassandra/locator/TokenMetadata.java
+++ b/src/java/org/apache/cassandra/locator/TokenMetadata.java
@@ -57,7 +57,7 @@ public class TokenMetadata
/** Maintains endpoint to host ID map of every node in the cluster */
private final BiMap<InetAddressAndPort, UUID> endpointToHostIdMap;
- // Prior to CASSANDRA-603, we just had <tt>Map<Range, InetAddressAndPort> pendingRanges<tt>,
+ // Prior to CASSANDRA-603, we just had <code>{@literal Map<Range, InetAddressAndPort> pendingRanges}</code>,
// which was added to when a node began bootstrap and removed from when it finished.
//
// This is inadequate when multiple changes are allowed simultaneously. For example,
@@ -70,8 +70,8 @@ public class TokenMetadata
//
// So, we made two changes:
//
- // First, we changed pendingRanges to a <tt>Multimap<Range, InetAddressAndPort></tt> (now
- // <tt>Map<String, Multimap<Range, InetAddressAndPort>></tt>, because replication strategy
+ // First, we changed pendingRanges to a <code>{@literal Multimap<Range, InetAddressAndPort>}</code> (now
+ // <code>{@literal Map<String, Multimap<Range, InetAddressAndPort>>}</code>, because replication strategy
// and options are per-KeySpace).
//
// Second, we added the bootstrapTokens and leavingEndpoints collections, so we can
diff --git a/src/java/org/apache/cassandra/metrics/KeyspaceMetrics.java b/src/java/org/apache/cassandra/metrics/KeyspaceMetrics.java
index ef3338e..f2c7ae8 100644
--- a/src/java/org/apache/cassandra/metrics/KeyspaceMetrics.java
+++ b/src/java/org/apache/cassandra/metrics/KeyspaceMetrics.java
@@ -135,7 +135,7 @@ public class KeyspaceMetrics
*/
public final Meter confirmedRepairedInconsistencies;
/**
- * Incremented where an inconsistency is detected, but there are pending & uncommitted repair sessions
+ * Incremented where an inconsistency is detected, but there are pending & uncommitted repair sessions
* in play on at least one replica. This may indicate a false positive as the inconsistency could be due to
* replicas marking the repair session as committed at slightly different times and so some consider it to
* be part of the repaired set whilst others do not.
diff --git a/src/java/org/apache/cassandra/net/MessageOut.java b/src/java/org/apache/cassandra/net/MessageOut.java
index 834435e..a6b829c 100644
--- a/src/java/org/apache/cassandra/net/MessageOut.java
+++ b/src/java/org/apache/cassandra/net/MessageOut.java
@@ -74,7 +74,7 @@ import static org.apache.cassandra.tracing.Tracing.isTracing;
* encoded as two bytes, followed by the UTF-8 byte encoding of the string (see {@link java.io.DataOutput#writeUTF(java.lang.String)}).
* The body is serialized with it's length, encoded as four bytes, followed by the bytes of the value.
*
- * * @param <T> The type of the message payload.
+ * @param <T> The type of the message payload.
*/
public class MessageOut<T>
{
diff --git a/src/java/org/apache/cassandra/net/MessagingService.java b/src/java/org/apache/cassandra/net/MessagingService.java
index f5c064e..04b9da1 100644
--- a/src/java/org/apache/cassandra/net/MessagingService.java
+++ b/src/java/org/apache/cassandra/net/MessagingService.java
@@ -1624,7 +1624,7 @@ public final class MessagingService implements MessagingServiceMBean
}
/**
- * This method is used to determine the preferred IP & Port of a peer using the
+ * This method is used to determine the preferred IP & Port of a peer using the
* {@link OutboundMessagingPool} and SystemKeyspace.
*/
public InetAddressAndPort getPreferredRemoteAddr(InetAddressAndPort to)
diff --git a/src/java/org/apache/cassandra/net/async/NettyFactory.java b/src/java/org/apache/cassandra/net/async/NettyFactory.java
index 81de5d8..26abb7e 100644
--- a/src/java/org/apache/cassandra/net/async/NettyFactory.java
+++ b/src/java/org/apache/cassandra/net/async/NettyFactory.java
@@ -359,8 +359,8 @@ public final class NettyFactory
/**
* {@inheritDoc}
*
- * To determine if we should enable TLS, we only need to check if {@link #params#encryptionOptions} is set.
- * The logic for figuring that out is is located in {@link MessagingService#getMessagingConnection(InetAddress)};
+ * To determine if we should enable TLS, we only need to check if {@link #params}'s {@code encryptionOptions} is set.
+ * The logic for figuring that out is is located in {@link MessagingService#getMessagingConnection(InetAddressAndPort)};
*/
public void initChannel(SocketChannel channel) throws Exception
{
diff --git a/src/java/org/apache/cassandra/repair/consistent/ConsistentSession.java b/src/java/org/apache/cassandra/repair/consistent/ConsistentSession.java
index 03de157..fa89347 100644
--- a/src/java/org/apache/cassandra/repair/consistent/ConsistentSession.java
+++ b/src/java/org/apache/cassandra/repair/consistent/ConsistentSession.java
@@ -52,11 +52,11 @@ import org.apache.cassandra.tools.nodetool.RepairAdmin;
/**
* Base class for consistent Local and Coordinator sessions
*
- * <p/>
+ * <br>
* There are 4 stages to a consistent incremental repair.
*
* <h1>Repair prepare</h1>
- * First, the normal {@link ActiveRepairService#prepareForRepair(UUID, InetAddressAndPort, Set, RepairOption, List)} stuff
+ * First, the normal {@link ActiveRepairService#prepareForRepair} stuff
* happens, which sends out {@link PrepareMessage} and creates a {@link ActiveRepairService.ParentRepairSession}
* on the coordinator and each of the neighbors.
*
@@ -68,18 +68,18 @@ import org.apache.cassandra.tools.nodetool.RepairAdmin;
* being repaired from the rest of the table data. When the preparation completes, the session state is set to
* {@code PREPARED}, and a {@link PrepareConsistentResponse} is sent to the coordinator indicating success or failure.
* If the pending anti-compaction fails, the local session state is set to {@code FAILED}.
- * <p/>
+ * <br>
* (see {@link LocalSessions#handlePrepareMessage(InetAddressAndPort, PrepareConsistentRequest)}
- * <p/>
+ * <br>
* Once the coordinator recieves positive {@code PrepareConsistentResponse} messages from all the participants, the
* coordinator begins the normal repair process.
- * <p/>
- * (see {@link CoordinatorSession#handlePrepareResponse(InetAddress, boolean)}
+ * <br>
+ * (see {@link CoordinatorSession#handlePrepareResponse}
*
* <h1>Repair</h1>
* The coordinator runs the normal data repair process against the sstables segregated in the previous step. When a
* node recieves a {@link ValidationRequest}, it sets it's local session state to {@code REPAIRING}.
- * <p/>
+ * <br>
*
* If all of the RepairSessions complete successfully, the coordinator begins the {@code Finalization} process. Otherwise,
* it begins the {@code Failure} process.
@@ -90,37 +90,37 @@ import org.apache.cassandra.tools.nodetool.RepairAdmin;
* and respond with a {@link FinalizePromise} message. Once the coordinator has received promise messages from all participants,
* it will send a {@link FinalizeCommit} message to all of them, ending the coordinator session. When a node receives the
* {@code FinalizeCommit} message, it will set it's sessions state to {@code FINALIZED}, completing the {@code LocalSession}.
- * <p/>
+ * <br>
*
* For the sake of simplicity, finalization does not immediately mark pending repair sstables repaired because of potential
* conflicts with in progress compactions. The sstables will be marked repaired as part of the normal compaction process.
- * <p/>
+ * <br>
*
- * On the coordinator side, see {@link CoordinatorSession#finalizePropose()}, {@link CoordinatorSession#handleFinalizePromise(InetAddress, boolean)},
- * & {@link CoordinatorSession#finalizeCommit()}
- * <p/>
+ * On the coordinator side, see {@link CoordinatorSession#finalizePropose()}, {@link CoordinatorSession#handleFinalizePromise},
+ * & {@link CoordinatorSession#finalizeCommit()}
+ * <br>
*
* On the local session side, see {@link LocalSessions#handleFinalizeProposeMessage(InetAddressAndPort, FinalizePropose)}
- * & {@link LocalSessions#handleFinalizeCommitMessage(InetAddressAndPort, FinalizeCommit)}
+ * & {@link LocalSessions#handleFinalizeCommitMessage(InetAddressAndPort, FinalizeCommit)}
*
* <h1>Failure</h1>
* If there are any failures or problems during the process above, the session will be failed. When a session is failed,
* the coordinator will send {@link FailSession} messages to each of the participants. In some cases (basically those not
* including Validation and Sync) errors are reported back to the coordinator by the local session, at which point, it
* will send {@code FailSession} messages out.
- * <p/>
+ * <br>
* Just as with finalization, sstables aren't immediately moved back to unrepaired, but will be demoted as part of the
* normal compaction process.
*
- * <p/>
+ * <br>
* See {@link LocalSessions#failSession(UUID, boolean)} and {@link CoordinatorSession#fail()}
*
- * <h1>Failure Recovery & Session Cleanup</h1>
+ * <h1>Failure Recovery & Session Cleanup</h1>
* There are a few scenarios where sessions can get stuck. If a node fails mid session, or it misses a {@code FailSession}
* or {@code FinalizeCommit} message, it will never finish. To address this, there is a cleanup task that runs every
* 10 minutes that attempts to complete idle sessions.
*
- * <p/>
+ * <br>
* If a session is not completed (not {@code FINALIZED} or {@code FAILED}) and there's been no activity on the session for
* over an hour, the cleanup task will attempt to finish the session by learning the session state of the other participants.
* To do this, it sends a {@link StatusRequest} message to the other session participants. The participants respond with a
@@ -130,16 +130,16 @@ import org.apache.cassandra.tools.nodetool.RepairAdmin;
* it's received {@code FinalizePromise} messages from <i>all</i> participants, this is safe.
*
*
- * <p/>
+ * <br>
* If a session is not completed, and hasn't had any activity for over a day, the session is auto-failed.
*
- * <p/>
+ * <br>
* Once a session has been completed for over 2 days, it's deleted.
*
- * <p/>
+ * <br>
* Operators can also manually fail sessions with {@code nodetool repair_admin --cancel}
*
- * <p/>
+ * <br>
* See {@link LocalSessions#cleanup()} and {@link RepairAdmin}
*
*/
diff --git a/src/java/org/apache/cassandra/repair/consistent/LocalSessions.java b/src/java/org/apache/cassandra/repair/consistent/LocalSessions.java
index c28391a..8761763 100644
--- a/src/java/org/apache/cassandra/repair/consistent/LocalSessions.java
+++ b/src/java/org/apache/cassandra/repair/consistent/LocalSessions.java
@@ -91,7 +91,7 @@ import static org.apache.cassandra.repair.consistent.ConsistentSession.State.*;
/**
* Manages all consistent repair sessions a node is participating in.
- * <p/>
+ * <br>
* Since sessions need to be loaded, and since we need to handle cases where sessions might not exist, most of the logic
* around local sessions is implemented in this class, with the LocalSession class being treated more like a simple struct,
* in contrast with {@link CoordinatorSession}
diff --git a/src/java/org/apache/cassandra/schema/Schema.java b/src/java/org/apache/cassandra/schema/Schema.java
index 2c2d444..05feb00 100644
--- a/src/java/org/apache/cassandra/schema/Schema.java
+++ b/src/java/org/apache/cassandra/schema/Schema.java
@@ -886,7 +886,7 @@ public final class Schema
/**
* Converts the given schema version to a string. Returns {@code unknown}, if {@code version} is {@code null}
- * or {@code "(empty)"}, if {@code version} refers to an {@link SchemaConstants#emptyVersion empty) schema.
+ * or {@code "(empty)"}, if {@code version} refers to an {@link SchemaConstants#emptyVersion} empty) schema.
*/
public static String schemaVersionToString(UUID version)
{
diff --git a/src/java/org/apache/cassandra/service/EmbeddedCassandraService.java b/src/java/org/apache/cassandra/service/EmbeddedCassandraService.java
index 9172eab..dabbffe 100644
--- a/src/java/org/apache/cassandra/service/EmbeddedCassandraService.java
+++ b/src/java/org/apache/cassandra/service/EmbeddedCassandraService.java
@@ -24,7 +24,6 @@ import java.io.IOException;
* This kind of service is useful when running unit tests of
* services using cassandra for example.
*
- * See {@link org.apache.cassandra.service.EmbeddedCassandraServiceTest} for usage.
* <p>
* This is the implementation of https://issues.apache.org/jira/browse/CASSANDRA-740
* <p>
diff --git a/src/java/org/apache/cassandra/service/StorageServiceMBean.java b/src/java/org/apache/cassandra/service/StorageServiceMBean.java
index e82d1ba..9e09032 100644
--- a/src/java/org/apache/cassandra/service/StorageServiceMBean.java
+++ b/src/java/org/apache/cassandra/service/StorageServiceMBean.java
@@ -362,7 +362,7 @@ public interface StorageServiceMBean extends NotificationEmitter
/**
* Get the status of a given parent repair session.
* @param cmd the int reference returned when issuing the repair
- * @return status of parent repair from enum {@link org.apache.cassandra.repair.RepairRunnable.Status}
+ * @return status of parent repair from enum {@link org.apache.cassandra.service.ActiveRepairService.ParentRepairStatus}
* followed by final message or messages of the session
*/
@Nullable
diff --git a/src/java/org/apache/cassandra/tools/NodeProbe.java b/src/java/org/apache/cassandra/tools/NodeProbe.java
index 197dd50..eda4d12 100644
--- a/src/java/org/apache/cassandra/tools/NodeProbe.java
+++ b/src/java/org/apache/cassandra/tools/NodeProbe.java
@@ -1590,7 +1590,8 @@ public class NodeProbe implements AutoCloseable
/**
* Retrieve Proxy metrics
- * @param connections, connectedNativeClients, connectedNativeClientsByUser, clientsByProtocolVersion
+ * @param metricName valid values include (connections, connectedNativeClients, connectedNativeClientsByUser,
+ * clientsByProtocolVersion)
*/
public Object getClientMetric(String metricName)
{
diff --git a/src/java/org/apache/cassandra/transport/frame/FrameBodyTransformer.java b/src/java/org/apache/cassandra/transport/frame/FrameBodyTransformer.java
index 0a6b22f..3211843 100644
--- a/src/java/org/apache/cassandra/transport/frame/FrameBodyTransformer.java
+++ b/src/java/org/apache/cassandra/transport/frame/FrameBodyTransformer.java
@@ -48,7 +48,7 @@ public interface FrameBodyTransformer
/**
* Returns an EnumSet of the flags that should be added to the header for any message whose frame body has been
- * modified by the transformer. E.g. it may add perform chunking & checksumming to the frame body,
+ * modified by the transformer. E.g. it may add perform chunking & checksumming to the frame body,
* compress it, or both.
* @return EnumSet containing the header flags to set on messages transformed
*/
diff --git a/src/java/org/apache/cassandra/utils/CoalescingStrategies.java b/src/java/org/apache/cassandra/utils/CoalescingStrategies.java
index 2f9e5bb..3e316a4 100644
--- a/src/java/org/apache/cassandra/utils/CoalescingStrategies.java
+++ b/src/java/org/apache/cassandra/utils/CoalescingStrategies.java
@@ -100,7 +100,7 @@ public class CoalescingStrategies
* {@link #currentCoalescingTimeNanos()}.
* <p>
* Note that it is expected that a call {@link #currentCoalescingTimeNanos()} will come just after a call to
- * {@link #newArrival(Coalescable))}, as the intent of the value returned by the former method is "Given a new message, how much
+ * {@link #newArrival(Coalescable)}, as the intent of the value returned by the former method is "Given a new message, how much
* time should I wait for more messages to arrive and be coalesced with that message". But both calls are separated
* as one may not want to call {@link #currentCoalescingTimeNanos()} after every call to {@link #newArrival(Coalescable)}
* and we thus save processing. How arrivals influence the coalescing time is however entirely up to the strategy and some
diff --git a/src/java/org/apache/cassandra/utils/btree/BTree.java b/src/java/org/apache/cassandra/utils/btree/BTree.java
index 6d0af6e..aee393b 100644
--- a/src/java/org/apache/cassandra/utils/btree/BTree.java
+++ b/src/java/org/apache/cassandra/utils/btree/BTree.java
@@ -435,7 +435,7 @@ public class BTree
/**
* Honours result semantics of {@link Arrays#binarySearch}, as though it were performed on the tree flattened into an array
- * @return index of item in tree, or <tt>(-(<i>insertion point</i>) - 1)</tt> if not present
+ * @return index of item in tree, or <code>{@literal (-(insertion point) - 1)}</code> if not present
*/
public static <V> int findIndex(Object[] node, Comparator<? super V> comparator, V find)
{
@@ -801,7 +801,7 @@ public class BTree
}
/**
- * tree index => index of key wrt all items in the tree laid out serially
+ * tree {@code index => index} of key wrt all items in the tree laid out serially
*
* This version of the method permits requesting out-of-bounds indexes, -1 and size
* @param root to calculate tree index within
diff --git a/src/java/org/apache/cassandra/utils/streamhist/StreamingTombstoneHistogramBuilder.java b/src/java/org/apache/cassandra/utils/streamhist/StreamingTombstoneHistogramBuilder.java
index 9856253..cac40ea 100755
--- a/src/java/org/apache/cassandra/utils/streamhist/StreamingTombstoneHistogramBuilder.java
+++ b/src/java/org/apache/cassandra/utils/streamhist/StreamingTombstoneHistogramBuilder.java
@@ -38,11 +38,12 @@ import static org.apache.cassandra.utils.streamhist.StreamingTombstoneHistogramB
* <ol>
* <li>If point <i>p</i> is already exists in collection, add <i>m</i> to recorded value of point <i>p</i> </li>
* <li>If there is no point <i>p</i> in the collection, add point <i>p</i> with weight <i>m</i> </li>
- * <li>If point was added and collection size became lorger than maxBinSize:</li>
+ * <li>If point was added and collection size became lorger than maxBinSize:
* <ol type="a">
* <li>Find nearest points <i>p1</i> and <i>p2</i> in the collection </li>
* <li>Replace theese two points with one weighted point <i>p3 = (p1*m1+p2*m2)/(p1+p2)</i></li>
* </ol>
+ * </li>
* </ol>
* <p>
* There are some optimization to make histogram builder faster:
@@ -50,10 +51,10 @@ import static org.apache.cassandra.utils.streamhist.StreamingTombstoneHistogramB
* <li>Spool: big map that saves from excessively merging of small bin. This map can contains up to maxSpoolSize points and accumulate weight from same points.
* For example, if spoolSize=100, binSize=10 and there are only 50 different points. it will be only 40 merges regardless how many points will be added.</li>
* <li>Spool is organized as open-addressing primitive hash map where odd elements are points and event elements are values.
- * Spool can not resize => when number of collisions became bigger than threashold or size became large that <i>array_size/2</i> Spool is drained to bin</li>
+ * Spool can not resize when number of collisions became bigger than threashold or size became large that <i>array_size/2</i> Spool is drained to bin</li>
* <li>DistanceHolder - sorted collection of distances between points in Bin. It is used to find nearest points in constant time</li>
* <li>Distances and Bin organized as sorted arrays. It reduces garbage collection pressure and allows to find elements in log(binSize) time via binary search</li>
- * <li>To use existing Arrays.binarySearch <i></>{point, values}</i> in bin and <i></>{distance, left_point}</i> pairs is packed in one long</li>
+ * <li>To use existing Arrays.binarySearch <i>{point, values}</i> in bin and <i>{distance, left_point}</i> pairs is packed in one long</li>
* </ol>
*/
public class StreamingTombstoneHistogramBuilder
diff --git a/test/unit/org/apache/cassandra/db/compaction/CompactionStrategyManagerTest.java b/test/unit/org/apache/cassandra/db/compaction/CompactionStrategyManagerTest.java
index 73e6852..a02ade0 100644
--- a/test/unit/org/apache/cassandra/db/compaction/CompactionStrategyManagerTest.java
+++ b/test/unit/org/apache/cassandra/db/compaction/CompactionStrategyManagerTest.java
@@ -89,7 +89,8 @@ public class CompactionStrategyManagerTest
DatabaseDescriptor.setIncrementalBackupsEnabled(false);
/**
* We use byte ordered partitioner in this test to be able to easily infer an SSTable
- * disk assignment based on its generation - See {@link this#getSSTableIndex(Integer[], SSTableReader)}
+ * disk assignment based on its generation - See
+ * {@link CompactionStrategyManagerTest#getSSTableIndex(Integer[], SSTableReader)}
*/
originalPartitioner = StorageService.instance.setPartitionerUnsafe(ByteOrderedPartitioner.instance);
SchemaLoader.createKeyspace(KS_PREFIX,
---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@cassandra.apache.org
For additional commands, e-mail: commits-help@cassandra.apache.org