diff --git a/.build/README.md b/.build/README.md index ae50b5a738..f2c03c1dcc 100644 --- a/.build/README.md +++ b/.build/README.md @@ -29,6 +29,66 @@ The following applies to all build scripts. build_dir=/tmp/cass_Mtu462n .build/docker/check-code.sh +Running Sonar analysis (experimental) +------------------------------------- + +Run: + + ant sonar + +Sonar analysis requires the SonarQube server to be available. If there +is already some SonarQube server, it can be used by setting the +following env variables: + + SONAR_HOST_URL=http://sonar.example.com + SONAR_CASSANDRA_TOKEN=cassandra-project-analysis-token + SONAR_PROJECT_KEY= + +If SonarQube server is not available, one can be started locally in +a Docker container. The following command will create a SonarQube +container and start the server: + + ant sonar-create-server + +The server will be available at http://localhost:9000 with admin +credentials admin/password. The Docker container named `sonarqube` +is created and left running. When using this local SonarQube server, +no env variables to configure url, token, or project key are needed, +and the analysis can be run right away with `ant sonar`. + +After the analysis, the server remains running so that one can +inspect the results. + +To stop the local SonarQube server: + + ant sonar-stop-server + +However, this command just stops the Docker container without removing +it. It allows to start the container later with: + + docker container start sonarqube + +and access previous analysis results. To drop the container, run: + + docker container rm sonarqube + +When `SONAR_HOST_URL` is not provided, the script assumes a dedicated +local instance of the SonarQube server and sets it up automatically, +which includes creating a project, setting up the quality profile, and +quality gate from the configuration stored in +[sonar-quality-profile.xml](sonar%2Fsonar-quality-profile.xml) and +[sonar-quality-gate.json](sonar%2Fsonar-quality-gate.json) +respectively. To run the analysis with a custom quality profile, start +the server using `ant sonar-create-server`, create a project manually, +and set up a desired quality profile for it. Then, create the analysis +token for the project and export the following env variables: + + SONAR_HOST_URL="http://127.0.0.1:9000" + SONAR_CASSANDRA_TOKEN="" + SONAR_PROJECT_KEY="" + +The analysis can be run with `ant sonar`. + Building Artifacts (tarball and maven) ------------------------------------- diff --git a/.build/build-git.xml b/.build/build-git.xml index 0ba6502a94..50db9be2bf 100644 --- a/.build/build-git.xml +++ b/.build/build-git.xml @@ -51,5 +51,20 @@ Repository state is dirty ${git.diffstat} + + + + + + + + + + + + + + + diff --git a/.build/build-rat.xml b/.build/build-rat.xml index 2aaf9ad35c..27e8f63ae4 100644 --- a/.build/build-rat.xml +++ b/.build/build-rat.xml @@ -45,6 +45,7 @@ + @@ -59,7 +60,6 @@ - diff --git a/.build/build-sonar.xml b/.build/build-sonar.xml new file mode 100644 index 0000000000..250191064c --- /dev/null +++ b/.build/build-sonar.xml @@ -0,0 +1,247 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Downloading Sonar-Scanner CLI... + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/.build/sonar/sonar-quality-gate.json b/.build/sonar/sonar-quality-gate.json new file mode 100644 index 0000000000..3d535df216 --- /dev/null +++ b/.build/sonar/sonar-quality-gate.json @@ -0,0 +1,22 @@ +{ + "name": "cassandra", + "conditions": [ + { + "id": "AYuvOs-pRzmON3lNOtmB", + "metric": "blocker_violations", + "op": "GT", + "error": "0" + } + ], + "isBuiltIn": false, + "actions": { + "rename": true, + "setAsDefault": true, + "copy": true, + "associateProjects": true, + "delete": true, + "manageConditions": true, + "delegate": true + }, + "caycStatus": "compliant" +} \ No newline at end of file diff --git a/.build/sonar/sonar-quality-profile.xml b/.build/sonar/sonar-quality-profile.xml new file mode 100644 index 0000000000..f74e589036 --- /dev/null +++ b/.build/sonar/sonar-quality-profile.xml @@ -0,0 +1,30 @@ + + + + cassandra + java + + + java + S2095 + BUG + BLOCKER + + + + \ No newline at end of file diff --git a/.build/sonar/sonar-report.sh b/.build/sonar/sonar-report.sh new file mode 100755 index 0000000000..b73785f2f6 --- /dev/null +++ b/.build/sonar/sonar-report.sh @@ -0,0 +1,66 @@ +#!/bin/bash +# +# Licensed to the Apache Software Foundation (ASF) under one +# or more contributor license agreements. See the NOTICE file +# distributed with this work for additional information +# regarding copyright ownership. The ASF licenses this file +# to you 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. +# + +set -e + +REPORT_FILE="${1:-sonar-report.json}" +SEVERITIES="${2:-BLOCKER,CRITICAL,MAJOR}" +SCOPE=${3:-MAIN} + +if [ -z "$SONAR_HOST_URL" ]; then + SONAR_HOST_URL="http://127.0.0.1:9000" +fi + +if [ -z "$SONAR_PROJECT_KEY" ]; then + echo "SONAR_PROJECT_KEY is not set" + exit 1 +fi + +rm -f "$REPORT_FILE" + +# Maximum page size is 500, maximum number of returned issues is 10000 +for i in $(seq 1 20); do + if [ -n "$SONAR_CASSANDRA_TOKEN" ]; then + curl -sS --header "Authorization: Bearer ${SONAR_CASSANDRA_TOKEN}" "$SONAR_HOST_URL/api/issues/search?s=SEVERITY&asc=false&scopes=${SCOPE}&severities=${SEVERITIES}&components=${SONAR_PROJECT_KEY}&ps=500&p=$i" -o "${REPORT_FILE}.page" + else + curl -sS "$SONAR_HOST_URL/api/issues/search?s=SEVERITY&asc=false&scopes=${SCOPE}&severities=${SEVERITIES}&components=${SONAR_PROJECT_KEY}&ps=500&p=$i" -o "${REPORT_FILE}.page" + fi + if [ ! -s "${REPORT_FILE}.page" ]; then + echo "Failed to fetch SonarQube report" + rm -f "${REPORT_FILE}.page" + rm -f "${REPORT_FILE}.page.array" + rm -f "${REPORT_FILE}.array" + exit 1 + fi + cnt="$(jq '.issues | length' "${REPORT_FILE}.page")" + if [ "${cnt}" == "0" ] || [ "${cnt}" == "" ]; then + break + fi + jq -r '.issues' "${REPORT_FILE}.page" > "${REPORT_FILE}.page.array" + + if [ -f "${REPORT_FILE}" ]; then + jq -r -s '.[0] + .[1]' "${REPORT_FILE}" "${REPORT_FILE}.page.array" > "${REPORT_FILE}.array" + mv -f "${REPORT_FILE}.array" "${REPORT_FILE}" + else + mv -f "${REPORT_FILE}.page.array" "${REPORT_FILE}" + fi +done + +rm -f "${REPORT_FILE}.page" +rm -f "${REPORT_FILE}.page.array" diff --git a/.build/sonar/sonar-setup-local.sh b/.build/sonar/sonar-setup-local.sh new file mode 100755 index 0000000000..d1966b57ae --- /dev/null +++ b/.build/sonar/sonar-setup-local.sh @@ -0,0 +1,74 @@ +# +# Licensed to the Apache Software Foundation (ASF) under one +# or more contributor license agreements. See the NOTICE file +# distributed with this work for additional information +# regarding copyright ownership. The ASF licenses this file +# to you 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. +# + +#!/bin/sh + +set -e + +if [ -z "$SONAR_HOST_URL" ]; then + SONAR_HOST_URL="http://127.0.0.1:9000" +fi + +if [ -z "$SONAR_PROJECT_KEY" ]; then + echo "SONAR_PROJECT_KEY is not set" + exit 1 +fi + +creds="${1:-'admin:password'}" + +quality_profile_name="cassandra" +quality_profile_config="${2:-.build/sonar/sonar-quality-profile.xml}" + +quality_gate_name="cassandra" +quality_gate_config="${3:-.build/sonar/sonar-quality-gate.json}" + + +curl_cmd() { + curl -sS -u "$creds" "$@" +} + +# Create project +curl_cmd -X POST "${SONAR_HOST_URL}/api/projects/create?name=${SONAR_PROJECT_KEY}&mainBranch=trunk&newCodeDefinitionType=PREVIOUS_VERSION&project=${SONAR_PROJECT_KEY}&visibility=public" 1>&2 + +# Setup quality profile +curl_cmd -X POST "${SONAR_HOST_URL}/api/qualityprofiles/restore" --form "backup=@${quality_profile_config}" 1>&2 +curl_cmd -X POST "${SONAR_HOST_URL}/api/qualityprofiles/add_project?language=java&project=${SONAR_PROJECT_KEY}&qualityProfile=${quality_profile_name}" 1>&2 + +# Setup quality gate +curl_cmd -X POST "${SONAR_HOST_URL}/api/qualitygates/destroy?name=${quality_gate_name}" 1>&2 2>/dev/null || true +curl_cmd -X POST "${SONAR_HOST_URL}/api/qualitygates/create?name=${quality_gate_name}" 1>&2 +for cond_id in $(curl_cmd -X GET "${SONAR_HOST_URL}/api/qualitygates/show?name=${quality_gate_name}" | jq -r '.conditions[].id') +do + curl_cmd -X POST "${SONAR_HOST_URL}/api/qualitygates/delete_condition?id=${cond_id}" 1>&2 +done + +for cond in $(jq -r '.conditions[] | "metric=\(.metric)&op=\(.op)&error=\(.error)"' "${quality_gate_config}") +do + curl_cmd -X POST "${SONAR_HOST_URL}/api/qualitygates/create_condition?gateName=${quality_gate_name}&${cond}" 1>&2 +done + +curl_cmd -X POST "${SONAR_HOST_URL}/api/qualitygates/select?gateName=${quality_gate_name}&projectKey=${SONAR_PROJECT_KEY}" 1>&2 + +# Setup access token + +# Drop the existing access token so that we can create it once again - we need to recreate a token because it is +# impossible to read the existing token +curl_cmd -X POST "${SONAR_HOST_URL}/api/user_tokens/revoke?name=cassandra&projectKey=${SONAR_PROJECT_KEY}" 1>&2 2>/dev/null || true + +# Create the access token for the project analysis +curl_cmd -X POST "${SONAR_HOST_URL}/api/user_tokens/generate?name=cassandra&type=PROJECT_ANALYSIS_TOKEN&projectKey=${SONAR_PROJECT_KEY}" | jq -r '.token' diff --git a/build.xml b/build.xml index e45f9a4efd..856892020d 100644 --- a/build.xml +++ b/build.xml @@ -29,6 +29,7 @@ + @@ -534,6 +535,7 @@ + @@ -560,13 +562,13 @@ - + - + @@ -2064,4 +2066,5 @@ + diff --git a/src/java/org/apache/cassandra/cache/AutoSavingCache.java b/src/java/org/apache/cassandra/cache/AutoSavingCache.java index 5b1442bb32..3826eb412e 100644 --- a/src/java/org/apache/cassandra/cache/AutoSavingCache.java +++ b/src/java/org/apache/cassandra/cache/AutoSavingCache.java @@ -196,7 +196,6 @@ public class AutoSavingCache extends InstrumentingCache } } - @SuppressWarnings("resource") public IRowCacheEntry deserialize(ByteBuffer buf) { - try + try (RebufferingInputStream in = new DataInputBuffer(buf, false)) { - RebufferingInputStream in = new DataInputBuffer(buf, false); boolean isSentinel = in.readBoolean(); if (isSentinel) return new RowCacheSentinel(in.readLong()); diff --git a/src/java/org/apache/cassandra/cache/SerializingCache.java b/src/java/org/apache/cassandra/cache/SerializingCache.java index 8ee8e024e8..6cd14c6704 100644 --- a/src/java/org/apache/cassandra/cache/SerializingCache.java +++ b/src/java/org/apache/cassandra/cache/SerializingCache.java @@ -75,7 +75,6 @@ public class SerializingCache implements ICache }, serializer); } - @SuppressWarnings("resource") private V deserialize(RefCountedMemory mem) { try @@ -89,7 +88,6 @@ public class SerializingCache implements ICache } } - @SuppressWarnings("resource") private RefCountedMemory serialize(V value) { long serializedSize = serializer.serializedSize(value); @@ -148,7 +146,6 @@ public class SerializingCache implements ICache cache.invalidateAll(); } - @SuppressWarnings("resource") public V get(K key) { RefCountedMemory mem = cache.getIfPresent(key); @@ -166,7 +163,6 @@ public class SerializingCache implements ICache } } - @SuppressWarnings("resource") public void put(K key, V value) { RefCountedMemory mem = serialize(value); @@ -188,7 +184,6 @@ public class SerializingCache implements ICache old.unreference(); } - @SuppressWarnings("resource") public boolean putIfAbsent(K key, V value) { RefCountedMemory mem = serialize(value); @@ -212,7 +207,6 @@ public class SerializingCache implements ICache return old == null; } - @SuppressWarnings("resource") public boolean replace(K key, V oldToReplace, V value) { // if there is no old value in our cache, we fail @@ -256,7 +250,6 @@ public class SerializingCache implements ICache public void remove(K key) { - @SuppressWarnings("resource") RefCountedMemory mem = cache.asMap().remove(key); if (mem != null) mem.unreference(); diff --git a/src/java/org/apache/cassandra/concurrent/ExecutorLocals.java b/src/java/org/apache/cassandra/concurrent/ExecutorLocals.java index 4eeb2e5945..29985754aa 100644 --- a/src/java/org/apache/cassandra/concurrent/ExecutorLocals.java +++ b/src/java/org/apache/cassandra/concurrent/ExecutorLocals.java @@ -44,7 +44,6 @@ public class ExecutorLocals implements WithResources, Closeable public static class Impl { - @SuppressWarnings("resource") protected static void set(TraceState traceState, ClientWarn.State clientWarnState) { if (traceState == null && clientWarnState == null) locals.set(none); @@ -79,7 +78,6 @@ public class ExecutorLocals implements WithResources, Closeable return locals == none ? WithResources.none() : locals; } - @SuppressWarnings("resource") public static ExecutorLocals create(TraceState traceState) { ExecutorLocals current = locals.get(); diff --git a/src/java/org/apache/cassandra/cql3/functions/JavaBasedUDFunction.java b/src/java/org/apache/cassandra/cql3/functions/JavaBasedUDFunction.java index c84ab5668b..e51b9cbfc6 100644 --- a/src/java/org/apache/cassandra/cql3/functions/JavaBasedUDFunction.java +++ b/src/java/org/apache/cassandra/cql3/functions/JavaBasedUDFunction.java @@ -616,7 +616,6 @@ public final class JavaBasedUDFunction extends UDFunction return findType(result.toString()); } - @SuppressWarnings("resource") private NameEnvironmentAnswer findType(String className) { if (className.equals(this.className)) diff --git a/src/java/org/apache/cassandra/db/CassandraKeyspaceWriteHandler.java b/src/java/org/apache/cassandra/db/CassandraKeyspaceWriteHandler.java index f2cf93cc7e..ef9d0d1377 100644 --- a/src/java/org/apache/cassandra/db/CassandraKeyspaceWriteHandler.java +++ b/src/java/org/apache/cassandra/db/CassandraKeyspaceWriteHandler.java @@ -39,7 +39,6 @@ public class CassandraKeyspaceWriteHandler implements KeyspaceWriteHandler } @Override - @SuppressWarnings("resource") // group is closed when CassandraWriteContext is closed public WriteContext beginWrite(Mutation mutation, boolean makeDurable) throws RequestExecutionException { OpOrder.Group group = null; @@ -100,7 +99,6 @@ public class CassandraKeyspaceWriteHandler implements KeyspaceWriteHandler return CommitLog.instance.add(mutation); } - @SuppressWarnings("resource") // group is closed when CassandraWriteContext is closed private WriteContext createEmptyContext() { OpOrder.Group group = null; diff --git a/src/java/org/apache/cassandra/db/CassandraTableWriteHandler.java b/src/java/org/apache/cassandra/db/CassandraTableWriteHandler.java index 671c06d1e5..fc0979ff4f 100644 --- a/src/java/org/apache/cassandra/db/CassandraTableWriteHandler.java +++ b/src/java/org/apache/cassandra/db/CassandraTableWriteHandler.java @@ -31,7 +31,6 @@ public class CassandraTableWriteHandler implements TableWriteHandler } @Override - @SuppressWarnings("resource") public void write(PartitionUpdate update, WriteContext context, boolean updateIndexes) { CassandraWriteContext ctx = CassandraWriteContext.fromContext(context); diff --git a/src/java/org/apache/cassandra/db/ColumnFamilyStore.java b/src/java/org/apache/cassandra/db/ColumnFamilyStore.java index c4dd58ee7b..1ef67878d5 100644 --- a/src/java/org/apache/cassandra/db/ColumnFamilyStore.java +++ b/src/java/org/apache/cassandra/db/ColumnFamilyStore.java @@ -1294,7 +1294,6 @@ public class ColumnFamilyStore implements ColumnFamilyStoreMBean, Memtable.Owner Iterator writerIterator = flushResults.iterator(); while (writerIterator.hasNext()) { - @SuppressWarnings("resource") SSTableMultiWriter writer = writerIterator.next(); if (writer.getBytesWritten() > 0) { @@ -1431,7 +1430,6 @@ public class ColumnFamilyStore implements ColumnFamilyStoreMBean, Memtable.Owner * @param context write context for current update * @param updateIndexes whether secondary indexes should be updated */ - @SuppressWarnings("resource") // opGroup public void apply(PartitionUpdate update, CassandraWriteContext context, boolean updateIndexes) { @@ -1940,7 +1938,6 @@ public class ColumnFamilyStore implements ColumnFamilyStoreMBean, Memtable.Owner return nowInSec - metadata().params.gcGraceSeconds; } - @SuppressWarnings("resource") public RefViewFragment selectAndReference(Function> filter) { long failingSince = -1L; @@ -2549,7 +2546,6 @@ public class ColumnFamilyStore implements ColumnFamilyStoreMBean, Memtable.Owner Supplier>> rangesSupplier, Refs placeIntoRefs) { - @SuppressWarnings("resource") // closed by finish or on exception SSTableMultiWriter memtableContent = writeMemtableRanges(rangesSupplier, repairSessionID); if (memtableContent != null) { diff --git a/src/java/org/apache/cassandra/db/PartitionRangeReadCommand.java b/src/java/org/apache/cassandra/db/PartitionRangeReadCommand.java index c26baf211d..7aa1e01b6a 100644 --- a/src/java/org/apache/cassandra/db/PartitionRangeReadCommand.java +++ b/src/java/org/apache/cassandra/db/PartitionRangeReadCommand.java @@ -315,7 +315,6 @@ public class PartitionRangeReadCommand extends ReadCommand implements PartitionR } @VisibleForTesting - @SuppressWarnings("resource") public UnfilteredPartitionIterator queryStorage(final ColumnFamilyStore cfs, ReadExecutionController controller) { ColumnFamilyStore.ViewFragment view = cfs.select(View.selectLive(dataRange().keyRange())); @@ -328,7 +327,6 @@ public class PartitionRangeReadCommand extends ReadCommand implements PartitionR SSTableReadsListener readCountUpdater = newReadCountUpdater(); for (Memtable memtable : view.memtables) { - @SuppressWarnings("resource") // We close on exception and on closing the result returned by this method UnfilteredPartitionIterator iter = memtable.partitionIterator(columnFilter(), dataRange(), readCountUpdater); controller.updateMinOldestUnrepairedTombstone(memtable.getMinLocalDeletionTime()); inputCollector.addMemtableIterator(RTBoundValidator.validate(iter, RTBoundValidator.Stage.MEMTABLE, false)); @@ -344,7 +342,6 @@ public class PartitionRangeReadCommand extends ReadCommand implements PartitionR if (!intersects && !hasPartitionLevelDeletions && !hasRequiredStatics) continue; - @SuppressWarnings("resource") // We close on exception and on closing the result returned by this method UnfilteredPartitionIterator iter = sstable.partitionIterator(columnFilter(), dataRange(), readCountUpdater); inputCollector.addSSTableIterator(sstable, RTBoundValidator.validate(iter, RTBoundValidator.Stage.SSTABLE, false)); @@ -558,7 +555,6 @@ public class PartitionRangeReadCommand extends ReadCommand implements PartitionR } @Override - @SuppressWarnings("resource") public UnfilteredPartitionIterator executeLocally(ReadExecutionController executionController) { VirtualTable view = VirtualKeyspaceRegistry.instance.getTableNullable(metadata().id); diff --git a/src/java/org/apache/cassandra/db/RangeTombstoneList.java b/src/java/org/apache/cassandra/db/RangeTombstoneList.java index 46e74e1091..8b8cee2d39 100644 --- a/src/java/org/apache/cassandra/db/RangeTombstoneList.java +++ b/src/java/org/apache/cassandra/db/RangeTombstoneList.java @@ -353,7 +353,6 @@ public class RangeTombstoneList implements Iterable, IMeasurable return iterator(false); } - @SuppressWarnings("resource") public Iterator iterator(boolean reversed) { return reversed diff --git a/src/java/org/apache/cassandra/db/ReadCommand.java b/src/java/org/apache/cassandra/db/ReadCommand.java index 025d9a4826..b8ac0a2229 100644 --- a/src/java/org/apache/cassandra/db/ReadCommand.java +++ b/src/java/org/apache/cassandra/db/ReadCommand.java @@ -340,7 +340,6 @@ public abstract class ReadCommand extends AbstractReadQuery */ public abstract boolean isReversed(); - @SuppressWarnings("resource") public ReadResponse createResponse(UnfilteredPartitionIterator iterator, RepairedDataInfo rdi) { // validate that the sequence of RT markers is correct: open is followed by close, deletion times for both @@ -352,7 +351,6 @@ public abstract class ReadCommand extends AbstractReadQuery : ReadResponse.createDataResponse(iterator, this, rdi); } - @SuppressWarnings("resource") // We don't need to close an empty iterator. public ReadResponse createEmptyResponse() { UnfilteredPartitionIterator iterator = EmptyIterators.unfilteredPartition(metadata()); @@ -400,7 +398,6 @@ public abstract class ReadCommand extends AbstractReadQuery * * @return an iterator over the result of executing this command locally. */ - @SuppressWarnings("resource") // The result iterator is closed upon exceptions (we know it's fine to potentially not close the intermediary // iterators created inside the try as long as we do close the original resultIterator), or by closing the result. public UnfilteredPartitionIterator executeLocally(ReadExecutionController executionController) { @@ -851,7 +848,6 @@ public abstract class ReadCommand extends AbstractReadQuery return toCQLString(); } - @SuppressWarnings("resource") // resultant iterators are closed by their callers InputCollector iteratorsForPartition(ColumnFamilyStore.ViewFragment view, ReadExecutionController controller) { final BiFunction, RepairedDataInfo, UnfilteredRowIterator> merge = @@ -868,7 +864,6 @@ public abstract class ReadCommand extends AbstractReadQuery return new InputCollector<>(view, controller, merge, postLimitPartitions); } - @SuppressWarnings("resource") // resultant iterators are closed by their callers InputCollector iteratorsForRange(ColumnFamilyStore.ViewFragment view, ReadExecutionController controller) { final BiFunction, RepairedDataInfo, UnfilteredPartitionIterator> merge = @@ -952,7 +947,6 @@ public abstract class ReadCommand extends AbstractReadQuery unrepairedIters.add(iter); } - @SuppressWarnings("resource") // the returned iterators are closed by the caller List finalizeIterators(ColumnFamilyStore cfs, long nowInSec, long oldestUnrepairedTombstone) { if (repairedIters.isEmpty()) diff --git a/src/java/org/apache/cassandra/db/SinglePartitionReadCommand.java b/src/java/org/apache/cassandra/db/SinglePartitionReadCommand.java index 4b9b8a2582..ae692fc5b8 100644 --- a/src/java/org/apache/cassandra/db/SinglePartitionReadCommand.java +++ b/src/java/org/apache/cassandra/db/SinglePartitionReadCommand.java @@ -475,7 +475,6 @@ public class SinglePartitionReadCommand extends ReadCommand implements SinglePar metric.readLatency.addNano(latencyNanos); } - @SuppressWarnings("resource") // we close the created iterator through closing the result of this method (and SingletonUnfilteredPartitionIterator ctor cannot fail) protected UnfilteredPartitionIterator queryStorage(final ColumnFamilyStore cfs, ReadExecutionController executionController) { // skip the row cache and go directly to sstables/memtable if repaired status of @@ -495,7 +494,6 @@ public class SinglePartitionReadCommand extends ReadCommand implements SinglePar * If the partition is is not cached, we figure out what filter is "biggest", read * that from disk, then filter the result and either cache that or return it. */ - @SuppressWarnings("resource") private UnfilteredRowIterator getThroughCache(ColumnFamilyStore cfs, ReadExecutionController executionController) { assert !cfs.isIndex(); // CASSANDRA-5732 @@ -559,7 +557,6 @@ public class SinglePartitionReadCommand extends ReadCommand implements SinglePar final int rowsToCache = metadata().params.caching.rowsPerPartitionToCache(); final boolean enforceStrictLiveness = metadata().enforceStrictLiveness(); - @SuppressWarnings("resource") // we close on exception or upon closing the result of this method UnfilteredRowIterator iter = fullPartitionRead(metadata(), nowInSec(), partitionKey()).queryMemtableAndDisk(cfs, executionController); try { @@ -697,7 +694,6 @@ public class SinglePartitionReadCommand extends ReadCommand implements SinglePar for (Memtable memtable : view.memtables) { - @SuppressWarnings("resource") // 'iter' is added to iterators which is closed on exception, or through the closing of the final merged iterator UnfilteredRowIterator iter = memtable.rowIterator(partitionKey(), filter.getSlices(metadata()), columnFilter(), filter.isReversed(), metricsCollector); if (iter == null) continue; @@ -761,7 +757,6 @@ public class SinglePartitionReadCommand extends ReadCommand implements SinglePar controller.updateMinOldestUnrepairedTombstone(sstable.getMinLocalDeletionTime()); // 'iter' is added to iterators which is closed on exception, or through the closing of the final merged iterator - @SuppressWarnings("resource") UnfilteredRowIterator iter = intersects ? makeRowIteratorWithLowerBound(cfs, sstable, metricsCollector) : makeRowIteratorWithSkippedNonStaticContent(cfs, sstable, metricsCollector); @@ -779,7 +774,6 @@ public class SinglePartitionReadCommand extends ReadCommand implements SinglePar // an iterator figure out that (see `StatsMetadata.hasPartitionLevelDeletions`) // 'iter' is added to iterators which is closed on exception, or through the closing of the final merged iterator - @SuppressWarnings("resource") UnfilteredRowIterator iter = makeRowIteratorWithSkippedNonStaticContent(cfs, sstable, metricsCollector); // if the sstable contains a partition delete, then we must include it regardless of whether it @@ -877,12 +871,10 @@ public class SinglePartitionReadCommand extends ReadCommand implements SinglePar * Note that we cannot use the Transformations framework because they greedily get the static row, which * would cause all iterators to be initialized and hence all sstables to be accessed. */ - @SuppressWarnings("resource") private UnfilteredRowIterator withSSTablesIterated(List iterators, TableMetrics metrics, SSTableReadMetricsCollector metricsCollector) { - @SuppressWarnings("resource") // Closed through the closing of the result of the caller method. UnfilteredRowIterator merged = UnfilteredRowIterators.merge(iterators); if (!merged.isEmpty()) @@ -1380,7 +1372,6 @@ public class SinglePartitionReadCommand extends ReadCommand implements SinglePar } @Override - @SuppressWarnings("resource") public UnfilteredPartitionIterator executeLocally(ReadExecutionController executionController) { VirtualTable view = VirtualKeyspaceRegistry.instance.getTableNullable(metadata().id); diff --git a/src/java/org/apache/cassandra/db/SizeEstimatesRecorder.java b/src/java/org/apache/cassandra/db/SizeEstimatesRecorder.java index dfd52c5f38..f9233bf904 100644 --- a/src/java/org/apache/cassandra/db/SizeEstimatesRecorder.java +++ b/src/java/org/apache/cassandra/db/SizeEstimatesRecorder.java @@ -116,7 +116,6 @@ public class SizeEstimatesRecorder implements SchemaChangeListener, Runnable } } - @SuppressWarnings("resource") private static Map, Pair> computeSizeEstimates(ColumnFamilyStore table, Collection> ranges) { // for each local primary range, estimate (crudely) mean partition size and partitions count. diff --git a/src/java/org/apache/cassandra/db/commitlog/CommitLogSegment.java b/src/java/org/apache/cassandra/db/commitlog/CommitLogSegment.java index 97a032a8b0..04a2c2c336 100644 --- a/src/java/org/apache/cassandra/db/commitlog/CommitLogSegment.java +++ b/src/java/org/apache/cassandra/db/commitlog/CommitLogSegment.java @@ -213,7 +213,6 @@ public abstract class CommitLogSegment * Allocate space in this buffer for the provided mutation, and return the allocated Allocation object. * Returns null if there is not enough space in this segment, and a new segment is needed. */ - @SuppressWarnings("resource") //we pass the op order around Allocation allocate(Mutation mutation, int size) { final OpOrder.Group opGroup = appendOrder.start(); diff --git a/src/java/org/apache/cassandra/db/commitlog/CommitLogSegmentReader.java b/src/java/org/apache/cassandra/db/commitlog/CommitLogSegmentReader.java index 964fe49754..b2dc9a51e2 100644 --- a/src/java/org/apache/cassandra/db/commitlog/CommitLogSegmentReader.java +++ b/src/java/org/apache/cassandra/db/commitlog/CommitLogSegmentReader.java @@ -301,7 +301,6 @@ public class CommitLogSegmentReader implements Iterable sstables, Collection> ranges) { ArrayList scanners = new ArrayList<>(); @@ -365,7 +364,6 @@ public abstract class AbstractCompactionStrategy for (int i=0, isize=scanners.size(); i scanners, AbstractCompactionController controller, @@ -223,7 +222,6 @@ public class CompactionIterator extends CompactionInfo.Holder implements Unfilte int merged = 0; for (int i=0, isize=versions.size(); i> submitMaximal(final ColumnFamilyStore cfStore, final long gcBefore, boolean splitOutput) { return submitMaximal(cfStore, gcBefore, splitOutput, OperationType.MAJOR_COMPACTION); } - @SuppressWarnings("resource") public List> submitMaximal(final ColumnFamilyStore cfStore, final long gcBefore, boolean splitOutput, OperationType operationType) { // here we compute the task off the compaction executor, so having that present doesn't diff --git a/src/java/org/apache/cassandra/db/compaction/CompactionStrategyHolder.java b/src/java/org/apache/cassandra/db/compaction/CompactionStrategyHolder.java index 9b7f4a68e2..62a3b6ffdf 100644 --- a/src/java/org/apache/cassandra/db/compaction/CompactionStrategyHolder.java +++ b/src/java/org/apache/cassandra/db/compaction/CompactionStrategyHolder.java @@ -183,7 +183,6 @@ public class CompactionStrategyHolder extends AbstractStrategyHolder } @Override - @SuppressWarnings("resource") public List getScanners(GroupedSSTableContainer sstables, Collection> ranges) { List scanners = new ArrayList<>(strategies.size()); diff --git a/src/java/org/apache/cassandra/db/compaction/CompactionStrategyManager.java b/src/java/org/apache/cassandra/db/compaction/CompactionStrategyManager.java index c082a1a2b2..dfcd9aee4e 100644 --- a/src/java/org/apache/cassandra/db/compaction/CompactionStrategyManager.java +++ b/src/java/org/apache/cassandra/db/compaction/CompactionStrategyManager.java @@ -243,7 +243,6 @@ public class CompactionStrategyManager implements INotificationConsumer * @return */ @VisibleForTesting - @SuppressWarnings("resource") // transaction is closed by AbstractCompactionTask::execute AbstractCompactionTask findUpgradeSSTableTask() { if (!isEnabled() || !DatabaseDescriptor.automaticSSTableUpgrade()) @@ -951,7 +950,6 @@ public class CompactionStrategyManager implements INotificationConsumer * @param ranges * @return */ - @SuppressWarnings("resource") public AbstractCompactionStrategy.ScannerList maybeGetScanners(Collection sstables, Collection> ranges) { maybeReloadDiskBoundaries(); diff --git a/src/java/org/apache/cassandra/db/compaction/CompactionTasks.java b/src/java/org/apache/cassandra/db/compaction/CompactionTasks.java index af0dbd06fa..2ab85352d2 100644 --- a/src/java/org/apache/cassandra/db/compaction/CompactionTasks.java +++ b/src/java/org/apache/cassandra/db/compaction/CompactionTasks.java @@ -28,7 +28,6 @@ import org.apache.cassandra.utils.FBUtilities; public class CompactionTasks extends AbstractCollection implements AutoCloseable { - @SuppressWarnings("resource") private static final CompactionTasks EMPTY = new CompactionTasks(Collections.emptyList()); private final Collection tasks; diff --git a/src/java/org/apache/cassandra/db/compaction/LeveledCompactionStrategy.java b/src/java/org/apache/cassandra/db/compaction/LeveledCompactionStrategy.java index 3493674efc..58166630bc 100644 --- a/src/java/org/apache/cassandra/db/compaction/LeveledCompactionStrategy.java +++ b/src/java/org/apache/cassandra/db/compaction/LeveledCompactionStrategy.java @@ -126,7 +126,6 @@ public class LeveledCompactionStrategy extends AbstractCompactionStrategy * the only difference between background and maximal in LCS is that maximal is still allowed * (by explicit user request) even when compaction is disabled. */ - @SuppressWarnings("resource") // transaction is closed by AbstractCompactionTask::execute public AbstractCompactionTask getNextBackgroundTask(long gcBefore) { Collection previousCandidate = null; @@ -179,7 +178,6 @@ public class LeveledCompactionStrategy extends AbstractCompactionStrategy } } - @SuppressWarnings("resource") // transaction is closed by AbstractCompactionTask::execute public synchronized Collection getMaximalTask(long gcBefore, boolean splitOutput) { Iterable sstables = manifest.getSSTables(); @@ -195,7 +193,6 @@ public class LeveledCompactionStrategy extends AbstractCompactionStrategy } @Override - @SuppressWarnings("resource") // transaction is closed by AbstractCompactionTask::execute public AbstractCompactionTask getUserDefinedTask(Collection sstables, long gcBefore) { @@ -337,7 +334,6 @@ public class LeveledCompactionStrategy extends AbstractCompactionStrategy Collection intersecting = LeveledScanner.intersecting(byLevel.get(level), ranges); if (!intersecting.isEmpty()) { - @SuppressWarnings("resource") // The ScannerList will be in charge of closing (and we close properly on errors) ISSTableScanner scanner = new LeveledScanner(cfs.metadata(), intersecting, ranges); scanners.add(scanner); } diff --git a/src/java/org/apache/cassandra/db/compaction/PendingRepairManager.java b/src/java/org/apache/cassandra/db/compaction/PendingRepairManager.java index 2ddfab7060..94f29dc271 100644 --- a/src/java/org/apache/cassandra/db/compaction/PendingRepairManager.java +++ b/src/java/org/apache/cassandra/db/compaction/PendingRepairManager.java @@ -264,7 +264,6 @@ class PendingRepairManager return tasks; } - @SuppressWarnings("resource") private RepairFinishedCompactionTask getRepairFinishedCompactionTask(TimeUUID sessionID) { Preconditions.checkState(canCleanup(sessionID)); @@ -429,7 +428,6 @@ class PendingRepairManager return !ActiveRepairService.instance().consistent.local.isSessionInProgress(sessionID); } - @SuppressWarnings("resource") synchronized Set getScanners(Collection sstables, Collection> ranges) { if (sstables.isEmpty()) diff --git a/src/java/org/apache/cassandra/db/compaction/SizeTieredCompactionStrategy.java b/src/java/org/apache/cassandra/db/compaction/SizeTieredCompactionStrategy.java index 10b540e4cc..74a96ca211 100644 --- a/src/java/org/apache/cassandra/db/compaction/SizeTieredCompactionStrategy.java +++ b/src/java/org/apache/cassandra/db/compaction/SizeTieredCompactionStrategy.java @@ -175,7 +175,6 @@ public class SizeTieredCompactionStrategy extends AbstractCompactionStrategy return sstr.getReadMeter() == null ? 0.0 : sstr.getReadMeter().twoHourRate() / sstr.estimatedKeys(); } - @SuppressWarnings("resource") public AbstractCompactionTask getNextBackgroundTask(long gcBefore) { List previousCandidate = null; @@ -203,7 +202,6 @@ public class SizeTieredCompactionStrategy extends AbstractCompactionStrategy } } - @SuppressWarnings("resource") public synchronized Collection getMaximalTask(final long gcBefore, boolean splitOutput) { Iterable filteredSSTables = filterSuspectSSTables(sstables); @@ -217,7 +215,6 @@ public class SizeTieredCompactionStrategy extends AbstractCompactionStrategy return Arrays.asList(new CompactionTask(cfs, txn, gcBefore)); } - @SuppressWarnings("resource") public AbstractCompactionTask getUserDefinedTask(Collection sstables, final long gcBefore) { assert !sstables.isEmpty(); // checked for by CM.submitUserDefined diff --git a/src/java/org/apache/cassandra/db/compaction/TimeWindowCompactionStrategy.java b/src/java/org/apache/cassandra/db/compaction/TimeWindowCompactionStrategy.java index 9f64a64e40..2709d43ae5 100644 --- a/src/java/org/apache/cassandra/db/compaction/TimeWindowCompactionStrategy.java +++ b/src/java/org/apache/cassandra/db/compaction/TimeWindowCompactionStrategy.java @@ -80,7 +80,6 @@ public class TimeWindowCompactionStrategy extends AbstractCompactionStrategy } @Override - @SuppressWarnings("resource") // transaction is closed by AbstractCompactionTask::execute public AbstractCompactionTask getNextBackgroundTask(long gcBefore) { List previousCandidate = null; @@ -380,7 +379,6 @@ public class TimeWindowCompactionStrategy extends AbstractCompactionStrategy } @Override - @SuppressWarnings("resource") // transaction is closed by AbstractCompactionTask::execute public synchronized Collection getMaximalTask(long gcBefore, boolean splitOutput) { Iterable filteredSSTables = filterSuspectSSTables(sstables); @@ -407,7 +405,6 @@ public class TimeWindowCompactionStrategy extends AbstractCompactionStrategy } @Override - @SuppressWarnings("resource") // transaction is closed by AbstractCompactionTask::execute public synchronized AbstractCompactionTask getUserDefinedTask(Collection sstables, long gcBefore) { assert !sstables.isEmpty(); // checked for by CM.submitUserDefined diff --git a/src/java/org/apache/cassandra/db/compaction/UnifiedCompactionStrategy.java b/src/java/org/apache/cassandra/db/compaction/UnifiedCompactionStrategy.java index c410bf1e1b..2539c21b8e 100644 --- a/src/java/org/apache/cassandra/db/compaction/UnifiedCompactionStrategy.java +++ b/src/java/org/apache/cassandra/db/compaction/UnifiedCompactionStrategy.java @@ -157,7 +157,6 @@ public class UnifiedCompactionStrategy extends AbstractCompactionStrategy List> nonOverlapping = splitInNonOverlappingSets(filterSuspectSSTables(getSSTables())); for (Set set : nonOverlapping) { - @SuppressWarnings("resource") // closed by the returned task LifecycleTransaction txn = cfs.getTracker().tryModify(set, OperationType.COMPACTION); if (txn != null) tasks.add(createCompactionTask(txn, gcBefore)); @@ -194,7 +193,6 @@ public class UnifiedCompactionStrategy extends AbstractCompactionStrategy } @Override - @SuppressWarnings("resource") // transaction closed by the returned task public AbstractCompactionTask getUserDefinedTask(Collection sstables, final long gcBefore) { assert !sstables.isEmpty(); // checked for by CM.submitUserDefined @@ -231,7 +229,6 @@ public class UnifiedCompactionStrategy extends AbstractCompactionStrategy } } - @SuppressWarnings("resource") // transaction closed by the returned task private UnifiedCompactionTask createCompactionTask(CompactionPick pick, long gcBefore) { Preconditions.checkNotNull(pick); diff --git a/src/java/org/apache/cassandra/db/compaction/unified/ShardedCompactionWriter.java b/src/java/org/apache/cassandra/db/compaction/unified/ShardedCompactionWriter.java index bede6d2efe..ca5e99749c 100644 --- a/src/java/org/apache/cassandra/db/compaction/unified/ShardedCompactionWriter.java +++ b/src/java/org/apache/cassandra/db/compaction/unified/ShardedCompactionWriter.java @@ -82,7 +82,6 @@ public class ShardedCompactionWriter extends CompactionAwareWriter } @Override - @SuppressWarnings("resource") protected SSTableWriter sstableWriter(Directories.DataDirectory directory, DecoratedKey nextKey) { if (nextKey != null) diff --git a/src/java/org/apache/cassandra/db/compaction/writers/CompactionAwareWriter.java b/src/java/org/apache/cassandra/db/compaction/writers/CompactionAwareWriter.java index 64055bba5c..145163a39c 100644 --- a/src/java/org/apache/cassandra/db/compaction/writers/CompactionAwareWriter.java +++ b/src/java/org/apache/cassandra/db/compaction/writers/CompactionAwareWriter.java @@ -223,7 +223,6 @@ public abstract class CompactionAwareWriter extends Transactional.AbstractTransa sstableWriter.switchWriter(sstableWriter(directory, nextKey)); } - @SuppressWarnings("resource") protected SSTableWriter sstableWriter(Directories.DataDirectory directory, DecoratedKey nextKey) { Descriptor descriptor = cfs.newSSTableDescriptor(getDirectories().getLocationForDisk(directory)); diff --git a/src/java/org/apache/cassandra/db/compaction/writers/DefaultCompactionWriter.java b/src/java/org/apache/cassandra/db/compaction/writers/DefaultCompactionWriter.java index 4f64ff776e..fbb0e27a99 100644 --- a/src/java/org/apache/cassandra/db/compaction/writers/DefaultCompactionWriter.java +++ b/src/java/org/apache/cassandra/db/compaction/writers/DefaultCompactionWriter.java @@ -42,7 +42,6 @@ public class DefaultCompactionWriter extends CompactionAwareWriter this(cfs, directories, txn, nonExpiredSSTables, false, 0); } - @SuppressWarnings({ "resource", "RedundantSuppression" }) public DefaultCompactionWriter(ColumnFamilyStore cfs, Directories directories, LifecycleTransaction txn, Set nonExpiredSSTables, boolean keepOriginals, int sstableLevel) { super(cfs, directories, txn, nonExpiredSSTables, keepOriginals); diff --git a/src/java/org/apache/cassandra/db/compaction/writers/MajorLeveledCompactionWriter.java b/src/java/org/apache/cassandra/db/compaction/writers/MajorLeveledCompactionWriter.java index 0c31cbf5cd..09263df853 100644 --- a/src/java/org/apache/cassandra/db/compaction/writers/MajorLeveledCompactionWriter.java +++ b/src/java/org/apache/cassandra/db/compaction/writers/MajorLeveledCompactionWriter.java @@ -47,7 +47,6 @@ public class MajorLeveledCompactionWriter extends CompactionAwareWriter this(cfs, directories, txn, nonExpiredSSTables, maxSSTableSize, false); } - @SuppressWarnings({ "resource", "RedundantSuppression" }) public MajorLeveledCompactionWriter(ColumnFamilyStore cfs, Directories directories, LifecycleTransaction txn, diff --git a/src/java/org/apache/cassandra/db/filter/RowFilter.java b/src/java/org/apache/cassandra/db/filter/RowFilter.java index 1269c9995b..cefd941622 100644 --- a/src/java/org/apache/cassandra/db/filter/RowFilter.java +++ b/src/java/org/apache/cassandra/db/filter/RowFilter.java @@ -340,7 +340,6 @@ public abstract class RowFilter implements Iterable { DecoratedKey pk; - @SuppressWarnings("resource") protected BaseRowIterator applyToPartition(BaseRowIterator partition) { pk = partition.partitionKey(); diff --git a/src/java/org/apache/cassandra/db/lifecycle/LifecycleTransaction.java b/src/java/org/apache/cassandra/db/lifecycle/LifecycleTransaction.java index 7cff57da25..20e1d92eaf 100644 --- a/src/java/org/apache/cassandra/db/lifecycle/LifecycleTransaction.java +++ b/src/java/org/apache/cassandra/db/lifecycle/LifecycleTransaction.java @@ -173,14 +173,12 @@ public class LifecycleTransaction extends Transactional.AbstractTransactional im /** * construct an empty Transaction with no existing readers */ - @SuppressWarnings("resource") // log closed during postCleanup public static LifecycleTransaction offline(OperationType operationType) { Tracker dummy = Tracker.newDummyTracker(); return new LifecycleTransaction(dummy, new LogTransaction(operationType, dummy), Collections.emptyList()); } - @SuppressWarnings("resource") // log closed during postCleanup LifecycleTransaction(Tracker tracker, OperationType operationType, Iterable readers) { this(tracker, new LogTransaction(operationType, tracker), readers); diff --git a/src/java/org/apache/cassandra/db/lifecycle/LogReplicaSet.java b/src/java/org/apache/cassandra/db/lifecycle/LogReplicaSet.java index 316e4b628d..1e0e0c1153 100644 --- a/src/java/org/apache/cassandra/db/lifecycle/LogReplicaSet.java +++ b/src/java/org/apache/cassandra/db/lifecycle/LogReplicaSet.java @@ -83,7 +83,6 @@ public class LogReplicaSet implements AutoCloseable try { - @SuppressWarnings("resource") // LogReplicas are closed in LogReplicaSet::close final LogReplica replica = LogReplica.create(directory, fileName); records.forEach(replica::append); replicasByFile.put(directory, replica); diff --git a/src/java/org/apache/cassandra/db/memtable/Flushing.java b/src/java/org/apache/cassandra/db/memtable/Flushing.java index 6e269515c7..3fc8568582 100644 --- a/src/java/org/apache/cassandra/db/memtable/Flushing.java +++ b/src/java/org/apache/cassandra/db/memtable/Flushing.java @@ -95,7 +95,6 @@ public class Flushing } } - @SuppressWarnings("resource") // writer owned by runnable, to be closed or aborted by its caller static FlushRunnable flushRunnable(ColumnFamilyStore cfs, Memtable memtable, PartitionPosition from, diff --git a/src/java/org/apache/cassandra/db/partitions/PartitionIterators.java b/src/java/org/apache/cassandra/db/partitions/PartitionIterators.java index fd69646007..b8a86d5a1a 100644 --- a/src/java/org/apache/cassandra/db/partitions/PartitionIterators.java +++ b/src/java/org/apache/cassandra/db/partitions/PartitionIterators.java @@ -31,7 +31,6 @@ public abstract class PartitionIterators { private PartitionIterators() {} - @SuppressWarnings("resource") // The created resources are returned right away public static RowIterator getOnlyElement(final PartitionIterator iter, SinglePartitionReadQuery query) { // If the query has no results, we'll get an empty iterator, but we still @@ -58,7 +57,6 @@ public abstract class PartitionIterators return Transformation.apply(toReturn, new Close()); } - @SuppressWarnings("resource") // The created resources are returned right away public static PartitionIterator concat(final List iterators) { if (iterators.size() == 1) @@ -116,7 +114,6 @@ public abstract class PartitionIterators * Note that this is only meant for debugging as this can log a very large amount of * logging at INFO. */ - @SuppressWarnings("resource") // The created resources are returned right away public static PartitionIterator loggingIterator(PartitionIterator iterator, final String id) { class Logger extends Transformation diff --git a/src/java/org/apache/cassandra/db/partitions/PartitionUpdate.java b/src/java/org/apache/cassandra/db/partitions/PartitionUpdate.java index 94494d3072..1047fc0a70 100644 --- a/src/java/org/apache/cassandra/db/partitions/PartitionUpdate.java +++ b/src/java/org/apache/cassandra/db/partitions/PartitionUpdate.java @@ -186,7 +186,6 @@ public class PartitionUpdate extends AbstractBTreePartition * Warning: this method does not close the provided iterator, it is up to * the caller to close it. */ - @SuppressWarnings("resource") public static PartitionUpdate fromIterator(UnfilteredRowIterator iterator, ColumnFilter filter) { iterator = UnfilteredRowIterators.withOnlyQueriedData(iterator, filter); @@ -206,7 +205,6 @@ public class PartitionUpdate extends AbstractBTreePartition * Warning: this method does not close the provided iterator, it is up to * the caller to close it. */ - @SuppressWarnings("resource") public static PartitionUpdate fromIterator(RowIterator iterator, ColumnFilter filter) { iterator = RowIterators.withOnlyQueriedData(iterator, filter); @@ -242,7 +240,6 @@ public class PartitionUpdate extends AbstractBTreePartition * * @return the deserialized update or {@code null} if {@code bytes == null}. */ - @SuppressWarnings("resource") public static PartitionUpdate fromBytes(ByteBuffer bytes, int version) { if (bytes == null) diff --git a/src/java/org/apache/cassandra/db/partitions/PurgeFunction.java b/src/java/org/apache/cassandra/db/partitions/PurgeFunction.java index e5d7c3deac..41e5607566 100644 --- a/src/java/org/apache/cassandra/db/partitions/PurgeFunction.java +++ b/src/java/org/apache/cassandra/db/partitions/PurgeFunction.java @@ -74,7 +74,6 @@ public abstract class PurgeFunction extends Transformation iterators, final MergeListener listener) { assert !iterators.isEmpty(); @@ -154,7 +152,6 @@ public abstract class UnfilteredPartitionIterators } } - @SuppressWarnings("resource") protected UnfilteredRowIterator getReduced() { UnfilteredRowIterators.MergeListener rowListener = listener == null @@ -220,7 +217,6 @@ public abstract class UnfilteredPartitionIterators }; } - @SuppressWarnings("resource") public static UnfilteredPartitionIterator mergeLazily(final List iterators) { assert !iterators.isEmpty(); diff --git a/src/java/org/apache/cassandra/db/repair/PendingAntiCompaction.java b/src/java/org/apache/cassandra/db/repair/PendingAntiCompaction.java index 2711ace7da..c39a667be9 100644 --- a/src/java/org/apache/cassandra/db/repair/PendingAntiCompaction.java +++ b/src/java/org/apache/cassandra/db/repair/PendingAntiCompaction.java @@ -189,7 +189,6 @@ public class PendingAntiCompaction this.acquireSleepMillis = acquireSleepMillis; } - @SuppressWarnings("resource") private AcquireResult acquireTuple() { // this method runs with compactions stopped & disabled diff --git a/src/java/org/apache/cassandra/db/rows/Row.java b/src/java/org/apache/cassandra/db/rows/Row.java index 4889ddaf13..5e0bbaf6ed 100644 --- a/src/java/org/apache/cassandra/db/rows/Row.java +++ b/src/java/org/apache/cassandra/db/rows/Row.java @@ -727,7 +727,6 @@ public interface Row extends Unfiltered, Iterable, IMeasurableMemory lastRowSet = i; } - @SuppressWarnings("resource") public Row merge(DeletionTime activeDeletion) { // If for this clustering we have only one row version and have no activeDeletion (i.e. nothing to filter out), @@ -836,7 +835,6 @@ public interface Row extends Unfiltered, Iterable, IMeasurableMemory return ColumnMetadataVersionComparator.INSTANCE.compare(column, dataColumn) < 0; } - @SuppressWarnings("resource") protected ColumnData getReduced() { if (column.isSimple()) diff --git a/src/java/org/apache/cassandra/db/rows/Rows.java b/src/java/org/apache/cassandra/db/rows/Rows.java index 8a8de612af..df9ff5e281 100644 --- a/src/java/org/apache/cassandra/db/rows/Rows.java +++ b/src/java/org/apache/cassandra/db/rows/Rows.java @@ -123,7 +123,6 @@ public abstract class Rows * @param merged the result of merging {@code inputs}. * @param inputs the inputs whose merge yielded {@code merged}. */ - @SuppressWarnings("resource") public static void diff(RowDiffListener diffListener, Row merged, Row...inputs) { Clustering clustering = merged.clustering(); diff --git a/src/java/org/apache/cassandra/db/rows/UnfilteredRowIteratorWithLowerBound.java b/src/java/org/apache/cassandra/db/rows/UnfilteredRowIteratorWithLowerBound.java index fba163f60a..53a3ba37cb 100644 --- a/src/java/org/apache/cassandra/db/rows/UnfilteredRowIteratorWithLowerBound.java +++ b/src/java/org/apache/cassandra/db/rows/UnfilteredRowIteratorWithLowerBound.java @@ -118,7 +118,6 @@ public class UnfilteredRowIteratorWithLowerBound extends LazilyInitializedUnfilt @Override protected UnfilteredRowIterator initializeIterator() { - @SuppressWarnings("resource") // 'iter' is added to iterators which is closed on exception, or through the closing of the final merged iterator UnfilteredRowIterator iter = RTBoundValidator.validate(sstable.rowIterator(partitionKey(), slices, selectedColumns, isReverseOrder, listener), RTBoundValidator.Stage.SSTABLE, false); return iter; diff --git a/src/java/org/apache/cassandra/db/rows/UnfilteredRowIterators.java b/src/java/org/apache/cassandra/db/rows/UnfilteredRowIterators.java index 4399b487c3..099a47eafd 100644 --- a/src/java/org/apache/cassandra/db/rows/UnfilteredRowIterators.java +++ b/src/java/org/apache/cassandra/db/rows/UnfilteredRowIterators.java @@ -451,7 +451,6 @@ public abstract class UnfilteredRowIterators } } - @SuppressWarnings("resource") // We're not really creating any resource here private static void checkForInvalidInput(List iterators) { if (iterators.isEmpty()) @@ -467,7 +466,6 @@ public abstract class UnfilteredRowIterators } } - @SuppressWarnings("resource") // We're not really creating any resource here private static DeletionTime collectPartitionLevelDeletion(List iterators, MergeListener listener) { DeletionTime[] versions = listener == null ? null : new DeletionTime[iterators.size()]; diff --git a/src/java/org/apache/cassandra/db/streaming/CassandraCompressedStreamReader.java b/src/java/org/apache/cassandra/db/streaming/CassandraCompressedStreamReader.java index d63af3fe34..0e0fcaa960 100644 --- a/src/java/org/apache/cassandra/db/streaming/CassandraCompressedStreamReader.java +++ b/src/java/org/apache/cassandra/db/streaming/CassandraCompressedStreamReader.java @@ -53,7 +53,6 @@ public class CassandraCompressedStreamReader extends CassandraStreamReader * @throws java.io.IOException if reading the remote sstable fails. Will throw an RTE if local write fails. */ @Override - @SuppressWarnings("resource") // input needs to remain open, streams on top of it can't be closed public SSTableMultiWriter read(DataInputPlus inputPlus) throws Throwable { long totalSize = totalSize(); diff --git a/src/java/org/apache/cassandra/db/streaming/CassandraEntireSSTableStreamReader.java b/src/java/org/apache/cassandra/db/streaming/CassandraEntireSSTableStreamReader.java index 98e2b6f7ef..97c3b2d4f9 100644 --- a/src/java/org/apache/cassandra/db/streaming/CassandraEntireSSTableStreamReader.java +++ b/src/java/org/apache/cassandra/db/streaming/CassandraEntireSSTableStreamReader.java @@ -82,7 +82,6 @@ public class CassandraEntireSSTableStreamReader implements IStreamReader * @return SSTable transferred * @throws IOException if reading the remote sstable fails. Will throw an RTE if local write fails. */ - @SuppressWarnings("resource") // input needs to remain open, streams on top of it can't be closed @Override public SSTableMultiWriter read(DataInputPlus in) throws IOException { @@ -168,7 +167,6 @@ public class CassandraEntireSSTableStreamReader implements IStreamReader return dir; } - @SuppressWarnings("resource") protected SSTableZeroCopyWriter createWriter(ColumnFamilyStore cfs, long totalSize, Collection components) throws IOException { File dataDir = getDataDir(cfs, totalSize); diff --git a/src/java/org/apache/cassandra/db/streaming/CassandraEntireSSTableStreamWriter.java b/src/java/org/apache/cassandra/db/streaming/CassandraEntireSSTableStreamWriter.java index 54fec4990f..124e9e7579 100644 --- a/src/java/org/apache/cassandra/db/streaming/CassandraEntireSSTableStreamWriter.java +++ b/src/java/org/apache/cassandra/db/streaming/CassandraEntireSSTableStreamWriter.java @@ -88,7 +88,6 @@ public class CassandraEntireSSTableStreamWriter component, prettyPrintMemory(length)); - @SuppressWarnings("resource") // this is closed after the file is transferred by AsyncChannelOutputPlus FileChannel channel = context.channel(sstable.descriptor, component, length); long bytesWritten = out.writeFileToChannel(channel, limiter); progress += bytesWritten; diff --git a/src/java/org/apache/cassandra/db/streaming/CassandraStreamManager.java b/src/java/org/apache/cassandra/db/streaming/CassandraStreamManager.java index 8ca7ac5dac..d122c9c788 100644 --- a/src/java/org/apache/cassandra/db/streaming/CassandraStreamManager.java +++ b/src/java/org/apache/cassandra/db/streaming/CassandraStreamManager.java @@ -82,7 +82,6 @@ public class CassandraStreamManager implements TableStreamManager return new CassandraStreamReceiver(cfs, session, totalStreams); } - @SuppressWarnings("resource") // references placed onto returned collection or closed on error @Override public Collection createOutgoingStreams(StreamSession session, RangesAtEndpoint replicas, TimeUUID pendingRepair, PreviewKind previewKind) { diff --git a/src/java/org/apache/cassandra/db/streaming/CassandraStreamReader.java b/src/java/org/apache/cassandra/db/streaming/CassandraStreamReader.java index 749277b1ca..9819d4cf27 100644 --- a/src/java/org/apache/cassandra/db/streaming/CassandraStreamReader.java +++ b/src/java/org/apache/cassandra/db/streaming/CassandraStreamReader.java @@ -102,7 +102,6 @@ public class CassandraStreamReader implements IStreamReader * @return SSTable transferred * @throws IOException if reading the remote sstable fails. Will throw an RTE if local write fails. */ - @SuppressWarnings("resource") // input needs to remain open, streams on top of it can't be closed @Override public SSTableMultiWriter read(DataInputPlus inputPlus) throws Throwable { @@ -154,7 +153,6 @@ public class CassandraStreamReader implements IStreamReader { return header != null? header.toHeader(metadata) : null; //pre-3.0 sstable have no SerializationHeader } - @SuppressWarnings("resource") protected SSTableMultiWriter createWriter(ColumnFamilyStore cfs, long totalSize, long repairedAt, TimeUUID pendingRepair, SSTableFormat format) throws IOException { Directories.DataDirectory localDir = cfs.getDirectories().getWriteableLocation(totalSize); diff --git a/src/java/org/apache/cassandra/db/streaming/CassandraStreamReceiver.java b/src/java/org/apache/cassandra/db/streaming/CassandraStreamReceiver.java index 5721d0b2e4..cfb1909329 100644 --- a/src/java/org/apache/cassandra/db/streaming/CassandraStreamReceiver.java +++ b/src/java/org/apache/cassandra/db/streaming/CassandraStreamReceiver.java @@ -99,7 +99,6 @@ public class CassandraStreamReceiver implements StreamReceiver } @Override - @SuppressWarnings("resource") public synchronized void received(IncomingStream stream) { CassandraIncomingFile file = getFile(stream); diff --git a/src/java/org/apache/cassandra/db/transform/BasePartitions.java b/src/java/org/apache/cassandra/db/transform/BasePartitions.java index 79e89529e2..2daae2cbb9 100644 --- a/src/java/org/apache/cassandra/db/transform/BasePartitions.java +++ b/src/java/org/apache/cassandra/db/transform/BasePartitions.java @@ -75,7 +75,6 @@ implements BasePartitionIterator return fail; } - @SuppressWarnings("resource") public final boolean hasNext() { BaseRowIterator next = null; diff --git a/src/java/org/apache/cassandra/db/transform/Filter.java b/src/java/org/apache/cassandra/db/transform/Filter.java index e2495e0499..e927adf48b 100644 --- a/src/java/org/apache/cassandra/db/transform/Filter.java +++ b/src/java/org/apache/cassandra/db/transform/Filter.java @@ -35,7 +35,6 @@ public final class Filter extends Transformation } @Override - @SuppressWarnings("resource") protected RowIterator applyToPartition(BaseRowIterator iterator) { return iterator instanceof UnfilteredRows diff --git a/src/java/org/apache/cassandra/db/transform/FilteredPartitions.java b/src/java/org/apache/cassandra/db/transform/FilteredPartitions.java index 4ddab50528..0e6934f76e 100644 --- a/src/java/org/apache/cassandra/db/transform/FilteredPartitions.java +++ b/src/java/org/apache/cassandra/db/transform/FilteredPartitions.java @@ -50,14 +50,12 @@ public final class FilteredPartitions extends BasePartitions this.rateLimiter = rateLimiter; } - @SuppressWarnings("resource") // HintsReader owns input static HintsReader open(File file, RateLimiter rateLimiter) { ChecksummedDataInput reader = ChecksummedDataInput.open(file); @@ -148,7 +147,6 @@ class HintsReader implements AutoCloseable, Iterable final class PagesIterator extends AbstractIterator { - @SuppressWarnings("resource") protected Page computeNext() { input.tryUncacheRead(); diff --git a/src/java/org/apache/cassandra/hints/HintsWriteExecutor.java b/src/java/org/apache/cassandra/hints/HintsWriteExecutor.java index 9d64e4add7..156fbfc018 100644 --- a/src/java/org/apache/cassandra/hints/HintsWriteExecutor.java +++ b/src/java/org/apache/cassandra/hints/HintsWriteExecutor.java @@ -255,7 +255,6 @@ final class HintsWriteExecutor } } - @SuppressWarnings("resource") // writer not closed here private void flushInternal(Iterator iterator, HintsStore store) { long maxHintsFileSize = DatabaseDescriptor.getMaxHintsFileSize(); diff --git a/src/java/org/apache/cassandra/hints/HintsWriter.java b/src/java/org/apache/cassandra/hints/HintsWriter.java index 591e03d256..54816abf06 100644 --- a/src/java/org/apache/cassandra/hints/HintsWriter.java +++ b/src/java/org/apache/cassandra/hints/HintsWriter.java @@ -65,7 +65,6 @@ class HintsWriter implements AutoCloseable this.globalCRC = globalCRC; } - @SuppressWarnings("resource") // HintsWriter owns channel static HintsWriter create(File directory, HintsDescriptor descriptor) throws IOException { File file = descriptor.file(directory); diff --git a/src/java/org/apache/cassandra/index/Index.java b/src/java/org/apache/cassandra/index/Index.java index 8eb27a3dc3..bc7057a0fb 100644 --- a/src/java/org/apache/cassandra/index/Index.java +++ b/src/java/org/apache/cassandra/index/Index.java @@ -194,7 +194,6 @@ public interface Index */ public static class CollatedViewIndexBuildingSupport implements IndexBuildingSupport { - @SuppressWarnings({"resource", "RedundantSuppression"}) public SecondaryIndexBuilder getIndexBuildTask(ColumnFamilyStore cfs, Set indexes, Collection sstables, boolean isFullRebuild) { return new CollatedViewIndexBuilder(cfs, indexes, new ReducingKeyIterator(sstables), sstables); diff --git a/src/java/org/apache/cassandra/index/internal/CassandraIndex.java b/src/java/org/apache/cassandra/index/internal/CassandraIndex.java index 2979e41581..125c6e9dbd 100644 --- a/src/java/org/apache/cassandra/index/internal/CassandraIndex.java +++ b/src/java/org/apache/cassandra/index/internal/CassandraIndex.java @@ -676,7 +676,6 @@ public abstract class CassandraIndex implements Index }; } - @SuppressWarnings("resource") private void buildBlocking() { baseCfs.forceBlockingFlush(ColumnFamilyStore.FlushReason.INDEX_BUILD_STARTED); diff --git a/src/java/org/apache/cassandra/index/internal/CassandraIndexSearcher.java b/src/java/org/apache/cassandra/index/internal/CassandraIndexSearcher.java index 720de13c40..55bbab65b2 100644 --- a/src/java/org/apache/cassandra/index/internal/CassandraIndexSearcher.java +++ b/src/java/org/apache/cassandra/index/internal/CassandraIndexSearcher.java @@ -60,7 +60,6 @@ public abstract class CassandraIndexSearcher implements Index.Searcher return command; } - @SuppressWarnings("resource") // Both the OpOrder and 'indexIter' are closed on exception, or through the closing of the result // of this method. public UnfilteredPartitionIterator search(ReadExecutionController executionController) { diff --git a/src/java/org/apache/cassandra/index/internal/composites/CompositesSearcher.java b/src/java/org/apache/cassandra/index/internal/composites/CompositesSearcher.java index 23dd489bbe..8f357027e9 100644 --- a/src/java/org/apache/cassandra/index/internal/composites/CompositesSearcher.java +++ b/src/java/org/apache/cassandra/index/internal/composites/CompositesSearcher.java @@ -162,7 +162,6 @@ public class CompositesSearcher extends CassandraIndexSearcher null); } - @SuppressWarnings("resource") // We close right away if empty, and if it's assign to next it will be called either // by the next caller of next, or through closing this iterator is this come before. UnfilteredRowIterator dataIter = filterStaleEntries(dataCmd.queryMemtableAndDisk(index.baseCfs, executionController), @@ -206,7 +205,6 @@ public class CompositesSearcher extends CassandraIndexSearcher } // We assume all rows in dataIter belong to the same partition. - @SuppressWarnings("resource") private UnfilteredRowIterator filterStaleEntries(UnfilteredRowIterator dataIter, final ByteBuffer indexValue, final List entries, diff --git a/src/java/org/apache/cassandra/index/internal/keys/KeysSearcher.java b/src/java/org/apache/cassandra/index/internal/keys/KeysSearcher.java index 3af7185e6c..9baa6f6f47 100644 --- a/src/java/org/apache/cassandra/index/internal/keys/KeysSearcher.java +++ b/src/java/org/apache/cassandra/index/internal/keys/KeysSearcher.java @@ -93,7 +93,6 @@ public class KeysSearcher extends CassandraIndexSearcher command.clusteringIndexFilter(key), null); - @SuppressWarnings("resource") // filterIfStale closes it's iterator if either it materialize it or if it returns null. // Otherwise, we close right away if empty, and if it's assigned to next it will be called either // by the next caller of next, or through closing this iterator is this come before. UnfilteredRowIterator dataIter = filterIfStale(dataCmd.queryMemtableAndDisk(index.baseCfs, executionController), diff --git a/src/java/org/apache/cassandra/index/sai/SSTableContext.java b/src/java/org/apache/cassandra/index/sai/SSTableContext.java index 3d76b08a9e..d9aa49e276 100644 --- a/src/java/org/apache/cassandra/index/sai/SSTableContext.java +++ b/src/java/org/apache/cassandra/index/sai/SSTableContext.java @@ -63,7 +63,6 @@ public class SSTableContext extends SharedCloseableImpl this.primaryKeyMapFactory = copy.primaryKeyMapFactory; } - @SuppressWarnings({"resource", "RedundantSuppression"}) public static SSTableContext create(SSTableReader sstable) { Ref sstableRef = null; diff --git a/src/java/org/apache/cassandra/index/sai/disk/IndexSearchResultIterator.java b/src/java/org/apache/cassandra/index/sai/disk/IndexSearchResultIterator.java index 04e21401d4..3e8bc4aa0d 100644 --- a/src/java/org/apache/cassandra/index/sai/disk/IndexSearchResultIterator.java +++ b/src/java/org/apache/cassandra/index/sai/disk/IndexSearchResultIterator.java @@ -58,7 +58,6 @@ public class IndexSearchResultIterator extends KeyRangeIterator * Builds a new {@link IndexSearchResultIterator} that wraps a {@link KeyRangeUnionIterator} over the * results of searching the {@link org.apache.cassandra.index.sai.memory.MemtableIndex} and the {@link SSTableIndex}es. */ - @SuppressWarnings({"resource", "RedundantSuppression"}) public static IndexSearchResultIterator build(Expression expression, Collection sstableIndexes, AbstractBounds keyRange, diff --git a/src/java/org/apache/cassandra/index/sai/disk/io/IndexFileUtils.java b/src/java/org/apache/cassandra/index/sai/disk/io/IndexFileUtils.java index 592ff2adca..2c203bdbce 100644 --- a/src/java/org/apache/cassandra/index/sai/disk/io/IndexFileUtils.java +++ b/src/java/org/apache/cassandra/index/sai/disk/io/IndexFileUtils.java @@ -57,7 +57,6 @@ public class IndexFileUtils this.writerOption = writerOption; } - @SuppressWarnings({"resource", "RedundantSuppression"}) public IndexOutputWriter openOutput(File file) { assert writerOption.finishOnClose() : "IndexOutputWriter relies on close() to sync with disk."; @@ -81,7 +80,6 @@ public class IndexFileUtils return IndexInputReader.create(handle); } - @SuppressWarnings({"resource", "RedundantSuppression"}) public IndexInput openBlockingInput(File file) { FileHandle fileHandle = new FileHandle.Builder(file).complete(); diff --git a/src/java/org/apache/cassandra/index/sai/disk/io/IndexInputReader.java b/src/java/org/apache/cassandra/index/sai/disk/io/IndexInputReader.java index e3b7a2121a..b97c727c6a 100644 --- a/src/java/org/apache/cassandra/index/sai/disk/io/IndexInputReader.java +++ b/src/java/org/apache/cassandra/index/sai/disk/io/IndexInputReader.java @@ -58,7 +58,6 @@ public class IndexInputReader extends IndexInput return new IndexInputReader(input, doOnClose); } - @SuppressWarnings({"resource", "RedundantSuppression"}) public static IndexInputReader create(FileHandle handle) { RandomAccessReader reader = handle.createReader(); diff --git a/src/java/org/apache/cassandra/index/sai/disk/v1/PerColumnIndexFiles.java b/src/java/org/apache/cassandra/index/sai/disk/v1/PerColumnIndexFiles.java index 4a2717bdeb..02832d937f 100644 --- a/src/java/org/apache/cassandra/index/sai/disk/v1/PerColumnIndexFiles.java +++ b/src/java/org/apache/cassandra/index/sai/disk/v1/PerColumnIndexFiles.java @@ -72,7 +72,6 @@ public class PerColumnIndexFiles implements Closeable return getFile(IndexComponent.COMPRESSED_VECTORS); } - @SuppressWarnings({"resource", "RedundantSuppression"}) private FileHandle getFile(IndexComponent indexComponent) { FileHandle file = files.get(indexComponent); diff --git a/src/java/org/apache/cassandra/index/sai/disk/v1/SSTableComponentsWriter.java b/src/java/org/apache/cassandra/index/sai/disk/v1/SSTableComponentsWriter.java index 88acb07004..63670c8f17 100644 --- a/src/java/org/apache/cassandra/index/sai/disk/v1/SSTableComponentsWriter.java +++ b/src/java/org/apache/cassandra/index/sai/disk/v1/SSTableComponentsWriter.java @@ -48,7 +48,6 @@ public class SSTableComponentsWriter implements PerSSTableIndexWriter private long partitionId = -1; - @SuppressWarnings({"resource", "RedundantSuppression"}) public SSTableComponentsWriter(IndexDescriptor indexDescriptor) throws IOException { this.indexDescriptor = indexDescriptor; diff --git a/src/java/org/apache/cassandra/index/sai/disk/v1/SkinnyPrimaryKeyMap.java b/src/java/org/apache/cassandra/index/sai/disk/v1/SkinnyPrimaryKeyMap.java index e6b4c60381..35c9f2f9f8 100644 --- a/src/java/org/apache/cassandra/index/sai/disk/v1/SkinnyPrimaryKeyMap.java +++ b/src/java/org/apache/cassandra/index/sai/disk/v1/SkinnyPrimaryKeyMap.java @@ -98,7 +98,7 @@ public class SkinnyPrimaryKeyMap implements PrimaryKeyMap } @Override - @SuppressWarnings({"resource", "RedundantSuppression"}) + @SuppressWarnings({"resource", "RedundantSuppression"}) // rowIdToToken, rowIdToPartitionId and cursor are closed by the SkinnyPrimaryKeyMap#close method public PrimaryKeyMap newPerSSTablePrimaryKeyMap() throws IOException { LongArray rowIdToToken = new LongArray.DeferredLongArray(tokenReaderFactory::open); diff --git a/src/java/org/apache/cassandra/index/sai/disk/v1/WidePrimaryKeyMap.java b/src/java/org/apache/cassandra/index/sai/disk/v1/WidePrimaryKeyMap.java index 9c0d62f080..8e570058b4 100644 --- a/src/java/org/apache/cassandra/index/sai/disk/v1/WidePrimaryKeyMap.java +++ b/src/java/org/apache/cassandra/index/sai/disk/v1/WidePrimaryKeyMap.java @@ -82,7 +82,7 @@ public class WidePrimaryKeyMap extends SkinnyPrimaryKeyMap } @Override - @SuppressWarnings({ "resource", "RedundantSuppression" }) + @SuppressWarnings({ "resource", "RedundantSuppression" }) // deferred long arrays and cursors are closed in the WidePrimaryKeyMap#close method public PrimaryKeyMap newPerSSTablePrimaryKeyMap() throws IOException { LongArray rowIdToToken = new LongArray.DeferredLongArray(tokenReaderFactory::open); diff --git a/src/java/org/apache/cassandra/index/sai/disk/v1/bbtree/BlockBalancedTreeReader.java b/src/java/org/apache/cassandra/index/sai/disk/v1/bbtree/BlockBalancedTreeReader.java index 53cac195e0..39c313df54 100644 --- a/src/java/org/apache/cassandra/index/sai/disk/v1/bbtree/BlockBalancedTreeReader.java +++ b/src/java/org/apache/cassandra/index/sai/disk/v1/bbtree/BlockBalancedTreeReader.java @@ -98,7 +98,6 @@ public class BlockBalancedTreeReader extends BlockBalancedTreeWalker implements FileUtils.closeQuietly(postingsFile); } - @SuppressWarnings({"resource", "RedundantSuppression"}) public PostingList intersect(IntersectVisitor visitor, QueryEventListener.BalancedTreeEventListener listener, QueryContext context) { Relation relation = visitor.compare(minPackedValue, maxPackedValue); @@ -229,7 +228,6 @@ public class BlockBalancedTreeReader extends BlockBalancedTreeWalker implements state.pop(); } - @SuppressWarnings({"resource", "RedundantSuppression"}) private PeekablePostingList initPostingReader(long offset) throws IOException { final PostingsReader.BlocksSummary summary = new PostingsReader.BlocksSummary(postingsSummaryInput, offset); @@ -336,7 +334,6 @@ public class BlockBalancedTreeReader extends BlockBalancedTreeWalker implements state.pop(); } - @SuppressWarnings({"resource", "RedundantSuppression"}) private PeekablePostingList initFilteringPostingReader(long offset, FixedBitSet filter) throws IOException { final PostingsReader.BlocksSummary summary = new PostingsReader.BlocksSummary(postingsSummaryInput, offset); diff --git a/src/java/org/apache/cassandra/index/sai/disk/v1/bitpack/BlockPackedReader.java b/src/java/org/apache/cassandra/index/sai/disk/v1/bitpack/BlockPackedReader.java index 75669068b8..50ce53d56c 100644 --- a/src/java/org/apache/cassandra/index/sai/disk/v1/bitpack/BlockPackedReader.java +++ b/src/java/org/apache/cassandra/index/sai/disk/v1/bitpack/BlockPackedReader.java @@ -96,7 +96,6 @@ public class BlockPackedReader implements LongArray.Factory } @Override - @SuppressWarnings({"resource", "RedundantSuppression"}) public LongArray open() { IndexInput indexInput = IndexFileUtils.instance.openInput(file); diff --git a/src/java/org/apache/cassandra/index/sai/disk/v1/bitpack/MonotonicBlockPackedReader.java b/src/java/org/apache/cassandra/index/sai/disk/v1/bitpack/MonotonicBlockPackedReader.java index 828fe5c3ed..f566778cae 100644 --- a/src/java/org/apache/cassandra/index/sai/disk/v1/bitpack/MonotonicBlockPackedReader.java +++ b/src/java/org/apache/cassandra/index/sai/disk/v1/bitpack/MonotonicBlockPackedReader.java @@ -82,7 +82,6 @@ public class MonotonicBlockPackedReader implements LongArray.Factory } @Override - @SuppressWarnings({"resource", "RedundantSuppression"}) public LongArray open() { final IndexInput indexInput = IndexFileUtils.instance.openInput(file); diff --git a/src/java/org/apache/cassandra/index/sai/disk/v1/postings/MergePostingList.java b/src/java/org/apache/cassandra/index/sai/disk/v1/postings/MergePostingList.java index d8b691a3f9..39516d8f6b 100644 --- a/src/java/org/apache/cassandra/index/sai/disk/v1/postings/MergePostingList.java +++ b/src/java/org/apache/cassandra/index/sai/disk/v1/postings/MergePostingList.java @@ -96,7 +96,6 @@ public class MergePostingList implements PostingList return maximum; } - @SuppressWarnings({ "resource", "RedundantSuppression"}) @Override public long nextPosting() throws IOException { @@ -126,7 +125,6 @@ public class MergePostingList implements PostingList return PostingList.END_OF_STREAM; } - @SuppressWarnings({"resource", "RedundantSuppression"}) @Override public long advance(long targetRowID) throws IOException { diff --git a/src/java/org/apache/cassandra/index/sai/disk/v1/segment/IndexSegmentSearcher.java b/src/java/org/apache/cassandra/index/sai/disk/v1/segment/IndexSegmentSearcher.java index b437893fca..36369728ec 100644 --- a/src/java/org/apache/cassandra/index/sai/disk/v1/segment/IndexSegmentSearcher.java +++ b/src/java/org/apache/cassandra/index/sai/disk/v1/segment/IndexSegmentSearcher.java @@ -56,7 +56,6 @@ public abstract class IndexSegmentSearcher implements SegmentOrdering, Closeable this.indexContext = indexContext; } - @SuppressWarnings({"resource", "RedundantSuppression"}) public static IndexSegmentSearcher open(PrimaryKeyMap.Factory primaryKeyMapFactory, PerColumnIndexFiles indexFiles, SegmentMetadata segmentMetadata, diff --git a/src/java/org/apache/cassandra/index/sai/disk/v1/segment/LiteralIndexSegmentSearcher.java b/src/java/org/apache/cassandra/index/sai/disk/v1/segment/LiteralIndexSegmentSearcher.java index 9228925280..17ac4b43e0 100644 --- a/src/java/org/apache/cassandra/index/sai/disk/v1/segment/LiteralIndexSegmentSearcher.java +++ b/src/java/org/apache/cassandra/index/sai/disk/v1/segment/LiteralIndexSegmentSearcher.java @@ -79,7 +79,6 @@ public class LiteralIndexSegmentSearcher extends IndexSegmentSearcher } @Override - @SuppressWarnings({"resource", "RedundantSuppression"}) public KeyRangeIterator search(Expression expression, AbstractBounds keyRange, QueryContext queryContext) throws IOException { if (logger.isTraceEnabled()) diff --git a/src/java/org/apache/cassandra/index/sai/disk/v1/segment/NumericIndexSegmentSearcher.java b/src/java/org/apache/cassandra/index/sai/disk/v1/segment/NumericIndexSegmentSearcher.java index 4bc2915ea2..fabf6408b0 100644 --- a/src/java/org/apache/cassandra/index/sai/disk/v1/segment/NumericIndexSegmentSearcher.java +++ b/src/java/org/apache/cassandra/index/sai/disk/v1/segment/NumericIndexSegmentSearcher.java @@ -79,7 +79,6 @@ public class NumericIndexSegmentSearcher extends IndexSegmentSearcher } @Override - @SuppressWarnings({"resource", "RedundantSuppression"}) public KeyRangeIterator search(Expression exp, AbstractBounds keyRange, QueryContext context) throws IOException { if (logger.isTraceEnabled()) diff --git a/src/java/org/apache/cassandra/index/sai/disk/v1/segment/SegmentMetadata.java b/src/java/org/apache/cassandra/index/sai/disk/v1/segment/SegmentMetadata.java index 99203601ea..3ae1bd55d4 100644 --- a/src/java/org/apache/cassandra/index/sai/disk/v1/segment/SegmentMetadata.java +++ b/src/java/org/apache/cassandra/index/sai/disk/v1/segment/SegmentMetadata.java @@ -133,7 +133,6 @@ public class SegmentMetadata return Math.toIntExact(sstableRowId - rowIdOffset); } - @SuppressWarnings({"resource", "RedundantSuppression"}) public static List load(MetadataSource source, PrimaryKey.Factory primaryKeyFactory) throws IOException { DataInput input = source.get(NAME); diff --git a/src/java/org/apache/cassandra/index/sai/iterators/KeyRangeConcatIterator.java b/src/java/org/apache/cassandra/index/sai/iterators/KeyRangeConcatIterator.java index b7e586e469..c4220b4eff 100644 --- a/src/java/org/apache/cassandra/index/sai/iterators/KeyRangeConcatIterator.java +++ b/src/java/org/apache/cassandra/index/sai/iterators/KeyRangeConcatIterator.java @@ -53,7 +53,6 @@ public class KeyRangeConcatIterator extends KeyRangeIterator } @Override - @SuppressWarnings({"resource", "RedundantSuppression"}) protected void performSkipTo(PrimaryKey nextKey) { while (!ranges.isEmpty()) @@ -80,7 +79,6 @@ public class KeyRangeConcatIterator extends KeyRangeIterator } @Override - @SuppressWarnings({"resource", "RedundantSuppression"}) protected PrimaryKey computeNext() { while (!ranges.isEmpty()) diff --git a/src/java/org/apache/cassandra/index/sai/iterators/KeyRangeIntersectionIterator.java b/src/java/org/apache/cassandra/index/sai/iterators/KeyRangeIntersectionIterator.java index 63f273a2a5..6e297b338c 100644 --- a/src/java/org/apache/cassandra/index/sai/iterators/KeyRangeIntersectionIterator.java +++ b/src/java/org/apache/cassandra/index/sai/iterators/KeyRangeIntersectionIterator.java @@ -36,7 +36,6 @@ import org.apache.cassandra.tracing.Tracing; * initially sorting the ranges. This implementation also supports an intersection limit which limits * the number of ranges that will be included in the intersection. This currently defaults to 2. */ -@SuppressWarnings({"resource", "RedundantSuppression"}) public class KeyRangeIntersectionIterator extends KeyRangeIterator { private static final Logger logger = LoggerFactory.getLogger(KeyRangeIntersectionIterator.class); diff --git a/src/java/org/apache/cassandra/index/sai/iterators/KeyRangeUnionIterator.java b/src/java/org/apache/cassandra/index/sai/iterators/KeyRangeUnionIterator.java index 909de45d7e..f2db621692 100644 --- a/src/java/org/apache/cassandra/index/sai/iterators/KeyRangeUnionIterator.java +++ b/src/java/org/apache/cassandra/index/sai/iterators/KeyRangeUnionIterator.java @@ -28,7 +28,6 @@ import org.apache.cassandra.io.util.FileUtils; /** * Range Union Iterator is used to return sorted stream of elements from multiple RangeIterator instances. */ -@SuppressWarnings({"resource", "RedundantSuppression"}) public class KeyRangeUnionIterator extends KeyRangeIterator { private final List ranges; diff --git a/src/java/org/apache/cassandra/index/sai/plan/QueryController.java b/src/java/org/apache/cassandra/index/sai/plan/QueryController.java index 61101cabf6..eee85f016e 100644 --- a/src/java/org/apache/cassandra/index/sai/plan/QueryController.java +++ b/src/java/org/apache/cassandra/index/sai/plan/QueryController.java @@ -203,7 +203,6 @@ public class QueryController { for (Pair> queryViewPair : queryView.view) { - @SuppressWarnings({"resource", "RedundantSuppression"}) // RangeIterators are closed by releaseIndexes KeyRangeIterator indexIterator = IndexSearchResultIterator.build(queryViewPair.left, queryViewPair.right, mergeRange, queryContext); builder.add(indexIterator); diff --git a/src/java/org/apache/cassandra/index/sai/plan/StorageAttachedIndexSearcher.java b/src/java/org/apache/cassandra/index/sai/plan/StorageAttachedIndexSearcher.java index 40bc1d1197..251e79d088 100644 --- a/src/java/org/apache/cassandra/index/sai/plan/StorageAttachedIndexSearcher.java +++ b/src/java/org/apache/cassandra/index/sai/plan/StorageAttachedIndexSearcher.java @@ -160,7 +160,6 @@ public class StorageAttachedIndexSearcher implements Index.Searcher } @Override - @SuppressWarnings({"resource", "RedundantSuppression"}) // The iterator produced here has a nop close operation public UnfilteredRowIterator computeNext() { // IMPORTANT: The correctness of the entire query pipeline relies on the fact that we consume a token @@ -478,7 +477,6 @@ public class StorageAttachedIndexSearcher implements Index.Searcher * Used by {@link StorageAttachedIndexSearcher#filterReplicaFilteringProtection} to filter rows for columns that * have transformations so won't get handled correctly by the row filter. */ - @SuppressWarnings({"resource", "RedundantSuppression"}) private static PartitionIterator applyIndexFilter(PartitionIterator response, FilterTree tree, QueryContext queryContext) { return new PartitionIterator() diff --git a/src/java/org/apache/cassandra/index/sasi/TermIterator.java b/src/java/org/apache/cassandra/index/sasi/TermIterator.java index d65b386112..a180ac3478 100644 --- a/src/java/org/apache/cassandra/index/sasi/TermIterator.java +++ b/src/java/org/apache/cassandra/index/sasi/TermIterator.java @@ -76,7 +76,6 @@ public class TermIterator extends RangeIterator this.referencedIndexes = referencedIndexes; } - @SuppressWarnings("resource") public static TermIterator build(final Expression e, Set perSSTableIndexes) { final List> tokens = new CopyOnWriteArrayList<>(); diff --git a/src/java/org/apache/cassandra/index/sasi/disk/OnDiskBlock.java b/src/java/org/apache/cassandra/index/sasi/disk/OnDiskBlock.java index e335b50fd5..32cda53d7e 100644 --- a/src/java/org/apache/cassandra/index/sasi/disk/OnDiskBlock.java +++ b/src/java/org/apache/cassandra/index/sasi/disk/OnDiskBlock.java @@ -81,7 +81,6 @@ public abstract class OnDiskBlock return new SearchResult<>(element, cmp, middle); } - @SuppressWarnings("resource") protected T getTerm(int index) { MappedBuffer dup = blockIndex.duplicate(); diff --git a/src/java/org/apache/cassandra/index/sasi/disk/OnDiskIndex.java b/src/java/org/apache/cassandra/index/sasi/disk/OnDiskIndex.java index d76145fd05..0eab229556 100644 --- a/src/java/org/apache/cassandra/index/sasi/disk/OnDiskIndex.java +++ b/src/java/org/apache/cassandra/index/sasi/disk/OnDiskIndex.java @@ -125,7 +125,6 @@ public class OnDiskIndex implements Iterable, Closeable protected final ByteBuffer minTerm, maxTerm, minKey, maxKey; - @SuppressWarnings("resource") public OnDiskIndex(File index, AbstractType cmp, Function keyReader) { keyFetcher = keyReader; @@ -277,7 +276,6 @@ public class OnDiskIndex implements Iterable, Closeable RangeUnionIterator.Builder builder = RangeUnionIterator.builder(); for (Expression e : ranges) { - @SuppressWarnings("resource") RangeIterator range = searchRange(e); if (range != null) builder.add(range); diff --git a/src/java/org/apache/cassandra/index/sasi/disk/OnDiskIndexBuilder.java b/src/java/org/apache/cassandra/index/sasi/disk/OnDiskIndexBuilder.java index a6faa04820..9071e10884 100644 --- a/src/java/org/apache/cassandra/index/sasi/disk/OnDiskIndexBuilder.java +++ b/src/java/org/apache/cassandra/index/sasi/disk/OnDiskIndexBuilder.java @@ -261,7 +261,6 @@ public class OnDiskIndexBuilder return true; } - @SuppressWarnings("resource") protected void finish(Descriptor descriptor, Pair range, File file, TermIterator terms) { SequentialWriter out = null; diff --git a/src/java/org/apache/cassandra/index/sasi/disk/PerSSTableIndexWriter.java b/src/java/org/apache/cassandra/index/sasi/disk/PerSSTableIndexWriter.java index f6ace2e1b5..5b01cad124 100644 --- a/src/java/org/apache/cassandra/index/sasi/disk/PerSSTableIndexWriter.java +++ b/src/java/org/apache/cassandra/index/sasi/disk/PerSSTableIndexWriter.java @@ -299,7 +299,6 @@ public class PerSSTableIndexWriter implements SSTableFlushObserver // parts are present but there is something still in memory, let's flush that inline if (!currentBuilder.isEmpty()) { - @SuppressWarnings({ "resource", "RedundantSuppression" }) OnDiskIndex last = scheduleSegmentFlush(false).call(); segments.add(ImmediateFuture.success(last)); } @@ -309,7 +308,6 @@ public class PerSSTableIndexWriter implements SSTableFlushObserver for (Future f : segments) { - @SuppressWarnings({ "resource", "RedundantSuppression" }) OnDiskIndex part = f.get(); if (part == null) continue; @@ -335,7 +333,6 @@ public class PerSSTableIndexWriter implements SSTableFlushObserver for (int segment = 0; segment < segmentNumber; segment++) { - @SuppressWarnings({ "resource", "RedundantSuppression" }) OnDiskIndex part = parts[segment]; if (part != null) diff --git a/src/java/org/apache/cassandra/index/sasi/disk/StaticTokenTreeBuilder.java b/src/java/org/apache/cassandra/index/sasi/disk/StaticTokenTreeBuilder.java index 6e64c563a0..7a41b38d7a 100644 --- a/src/java/org/apache/cassandra/index/sasi/disk/StaticTokenTreeBuilder.java +++ b/src/java/org/apache/cassandra/index/sasi/disk/StaticTokenTreeBuilder.java @@ -53,7 +53,6 @@ import com.google.common.collect.Iterators; * * See https://issues.apache.org/jira/browse/CASSANDRA-11383 for more details. */ -@SuppressWarnings("resource") public class StaticTokenTreeBuilder extends AbstractTokenTreeBuilder { private final CombinedTerm combinedTerm; diff --git a/src/java/org/apache/cassandra/index/sasi/memory/SkipListMemIndex.java b/src/java/org/apache/cassandra/index/sasi/memory/SkipListMemIndex.java index b2cb83fbda..9e44344f12 100644 --- a/src/java/org/apache/cassandra/index/sasi/memory/SkipListMemIndex.java +++ b/src/java/org/apache/cassandra/index/sasi/memory/SkipListMemIndex.java @@ -63,7 +63,6 @@ public class SkipListMemIndex extends MemIndex return overhead; } - @SuppressWarnings("resource") public RangeIterator search(Expression expression) { ByteBuffer min = expression.lower == null ? null : expression.lower.value; diff --git a/src/java/org/apache/cassandra/index/sasi/memory/TrieMemIndex.java b/src/java/org/apache/cassandra/index/sasi/memory/TrieMemIndex.java index cbdb6b7fc3..cebd68f08c 100644 --- a/src/java/org/apache/cassandra/index/sasi/memory/TrieMemIndex.java +++ b/src/java/org/apache/cassandra/index/sasi/memory/TrieMemIndex.java @@ -137,7 +137,6 @@ public class TrieMemIndex extends MemIndex return overhead; } - @SuppressWarnings("resource") public RangeIterator search(Expression expression) { ByteBuffer prefix = expression.lower == null ? null : expression.lower.value; diff --git a/src/java/org/apache/cassandra/index/sasi/plan/Operation.java b/src/java/org/apache/cassandra/index/sasi/plan/Operation.java index 7b421d596b..5b7f433282 100644 --- a/src/java/org/apache/cassandra/index/sasi/plan/Operation.java +++ b/src/java/org/apache/cassandra/index/sasi/plan/Operation.java @@ -40,7 +40,6 @@ import com.google.common.collect.*; import org.apache.cassandra.utils.FBUtilities; -@SuppressWarnings("resource") public class Operation extends RangeIterator { public enum OperationType diff --git a/src/java/org/apache/cassandra/index/sasi/plan/QueryController.java b/src/java/org/apache/cassandra/index/sasi/plan/QueryController.java index 37d254f59c..78fecd8f31 100644 --- a/src/java/org/apache/cassandra/index/sasi/plan/QueryController.java +++ b/src/java/org/apache/cassandra/index/sasi/plan/QueryController.java @@ -143,7 +143,6 @@ public class QueryController for (Map.Entry> e : view) { - @SuppressWarnings("resource") // RangeIterators are closed by releaseIndexes RangeIterator index = TermIterator.build(e.getKey(), e.getValue()); builder.add(index); diff --git a/src/java/org/apache/cassandra/index/sasi/utils/CombinedTermIterator.java b/src/java/org/apache/cassandra/index/sasi/utils/CombinedTermIterator.java index 4b004e027b..683ca7adec 100644 --- a/src/java/org/apache/cassandra/index/sasi/utils/CombinedTermIterator.java +++ b/src/java/org/apache/cassandra/index/sasi/utils/CombinedTermIterator.java @@ -27,7 +27,6 @@ import org.apache.cassandra.index.sasi.sa.TermIterator; import org.apache.cassandra.db.marshal.AbstractType; import org.apache.cassandra.utils.Pair; -@SuppressWarnings("resource") public class CombinedTermIterator extends TermIterator { final Descriptor descriptor; diff --git a/src/java/org/apache/cassandra/index/sasi/utils/RangeIntersectionIterator.java b/src/java/org/apache/cassandra/index/sasi/utils/RangeIntersectionIterator.java index 4d751da03d..331f4edff3 100644 --- a/src/java/org/apache/cassandra/index/sasi/utils/RangeIntersectionIterator.java +++ b/src/java/org/apache/cassandra/index/sasi/utils/RangeIntersectionIterator.java @@ -28,7 +28,6 @@ import org.apache.cassandra.io.util.FileUtils; import com.google.common.annotations.VisibleForTesting; -@SuppressWarnings("resource") public class RangeIntersectionIterator { protected enum Strategy diff --git a/src/java/org/apache/cassandra/index/sasi/utils/RangeUnionIterator.java b/src/java/org/apache/cassandra/index/sasi/utils/RangeUnionIterator.java index 599de071dd..f229569970 100644 --- a/src/java/org/apache/cassandra/index/sasi/utils/RangeUnionIterator.java +++ b/src/java/org/apache/cassandra/index/sasi/utils/RangeUnionIterator.java @@ -36,7 +36,6 @@ import org.apache.cassandra.io.util.FileUtils; * @param The type used to sort ranges. * @param The container type which is going to be returned by {@link Iterator#next()}. */ -@SuppressWarnings("resource") public class RangeUnionIterator, D extends CombinedValue> extends RangeIterator { private final PriorityQueue> ranges; diff --git a/src/java/org/apache/cassandra/io/compress/CompressionMetadata.java b/src/java/org/apache/cassandra/io/compress/CompressionMetadata.java index d2fab3031d..96b4ce8418 100644 --- a/src/java/org/apache/cassandra/io/compress/CompressionMetadata.java +++ b/src/java/org/apache/cassandra/io/compress/CompressionMetadata.java @@ -67,7 +67,6 @@ public class CompressionMetadata extends WrappedSharedCloseable public final CompressionParams parameters; @VisibleForTesting - @SuppressWarnings("resource") public static CompressionMetadata open(File chunksIndexFile, long compressedLength, boolean hasMaxCompressedSize) { CompressionParams parameters; @@ -200,7 +199,6 @@ public class CompressionMetadata extends WrappedSharedCloseable throw new FSReadError(e, input.file); } - @SuppressWarnings("resource") Memory offsets = Memory.allocate(chunkCount * 8L); int i = 0; try @@ -441,7 +439,6 @@ public class CompressionMetadata extends WrappedSharedCloseable } } - @SuppressWarnings("resource") public CompressionMetadata open(long dataLength, long compressedLength) { SafeMemory tOffsets = this.offsets.sharedCopy(); diff --git a/src/java/org/apache/cassandra/io/sstable/AbstractSSTableIterator.java b/src/java/org/apache/cassandra/io/sstable/AbstractSSTableIterator.java index 2690be69d7..e6fbad882e 100644 --- a/src/java/org/apache/cassandra/io/sstable/AbstractSSTableIterator.java +++ b/src/java/org/apache/cassandra/io/sstable/AbstractSSTableIterator.java @@ -72,7 +72,6 @@ public abstract class AbstractSSTableIterator protected final Slices slices; - @SuppressWarnings("resource") // We need this because the analysis is not able to determine that we do close // file on every path where we created it. protected AbstractSSTableIterator(SSTableReader sstable, FileDataInput file, diff --git a/src/java/org/apache/cassandra/io/sstable/CQLSSTableWriter.java b/src/java/org/apache/cassandra/io/sstable/CQLSSTableWriter.java index e19fd52ba5..3b83314fbc 100644 --- a/src/java/org/apache/cassandra/io/sstable/CQLSSTableWriter.java +++ b/src/java/org/apache/cassandra/io/sstable/CQLSSTableWriter.java @@ -554,7 +554,6 @@ public class CQLSSTableWriter implements Closeable return this; } - @SuppressWarnings("resource") public CQLSSTableWriter build() { if (directory == null) diff --git a/src/java/org/apache/cassandra/io/sstable/SSTableIdentityIterator.java b/src/java/org/apache/cassandra/io/sstable/SSTableIdentityIterator.java index 789bc4bd5f..cc201b4125 100644 --- a/src/java/org/apache/cassandra/io/sstable/SSTableIdentityIterator.java +++ b/src/java/org/apache/cassandra/io/sstable/SSTableIdentityIterator.java @@ -59,7 +59,6 @@ public class SSTableIdentityIterator implements Comparable openSSTables(final Map>> ranges) { outputHandler.output("Opening sstables and calculating sections to stream"); diff --git a/src/java/org/apache/cassandra/io/sstable/SSTableTxnWriter.java b/src/java/org/apache/cassandra/io/sstable/SSTableTxnWriter.java index de9d4f6200..76fb83e913 100644 --- a/src/java/org/apache/cassandra/io/sstable/SSTableTxnWriter.java +++ b/src/java/org/apache/cassandra/io/sstable/SSTableTxnWriter.java @@ -104,8 +104,6 @@ public class SSTableTxnWriter extends Transactional.AbstractTransactional implem return new SSTableTxnWriter(txn, writer); } - - @SuppressWarnings({"resource", "RedundantSuppression"}) // log and writer closed during doPostCleanup public static SSTableTxnWriter createRangeAware(TableMetadataRef metadata, long keyCount, long repairedAt, diff --git a/src/java/org/apache/cassandra/io/sstable/SSTableZeroCopyWriter.java b/src/java/org/apache/cassandra/io/sstable/SSTableZeroCopyWriter.java index 56c96e76ea..3bf21f1155 100644 --- a/src/java/org/apache/cassandra/io/sstable/SSTableZeroCopyWriter.java +++ b/src/java/org/apache/cassandra/io/sstable/SSTableZeroCopyWriter.java @@ -199,7 +199,6 @@ public class SSTableZeroCopyWriter extends SSTable implements SSTableMultiWriter public void writeComponent(Component component, DataInputPlus in, long size) throws ClosedChannelException { - @SuppressWarnings({"resource", "RedundantSuppression"}) // all writers are closed in close() SequentialWriter writer = componentWriters.get(component.name); logger.info("Writing component {} to {} length {}", component, writer.getPath(), prettyPrintMemory(size)); diff --git a/src/java/org/apache/cassandra/io/sstable/SimpleSSTableMultiWriter.java b/src/java/org/apache/cassandra/io/sstable/SimpleSSTableMultiWriter.java index 5ace39b501..99406dba31 100644 --- a/src/java/org/apache/cassandra/io/sstable/SimpleSSTableMultiWriter.java +++ b/src/java/org/apache/cassandra/io/sstable/SimpleSSTableMultiWriter.java @@ -106,7 +106,6 @@ public class SimpleSSTableMultiWriter implements SSTableMultiWriter writer.close(); } - @SuppressWarnings({"resource", "RedundantSuppression"}) // SimpleSSTableMultiWriter closes writer public static SSTableMultiWriter create(Descriptor descriptor, long keyCount, long repairedAt, 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 21a71cae79..4f622be5a5 100644 --- a/src/java/org/apache/cassandra/io/sstable/format/SSTableReader.java +++ b/src/java/org/apache/cassandra/io/sstable/format/SSTableReader.java @@ -1544,7 +1544,6 @@ public abstract class SSTableReader extends SSTable implements UnfilteredSource, } // get a new reference to the shared GlobalTidy for this sstable - @SuppressWarnings("resource") public static Ref get(SSTableReader sstable) { Descriptor descriptor = sstable.descriptor; diff --git a/src/java/org/apache/cassandra/io/sstable/format/big/BigSSTableReaderLoadingBuilder.java b/src/java/org/apache/cassandra/io/sstable/format/big/BigSSTableReaderLoadingBuilder.java index f4fce8d131..84e02217d5 100644 --- a/src/java/org/apache/cassandra/io/sstable/format/big/BigSSTableReaderLoadingBuilder.java +++ b/src/java/org/apache/cassandra/io/sstable/format/big/BigSSTableReaderLoadingBuilder.java @@ -185,7 +185,6 @@ public class BigSSTableReaderLoadingBuilder extends SortedTableReaderLoadingBuil * @param rebuildSummary true if index summary, first and last keys should be rebuilt * @return a pair of created filter and index summary component (or nulls if some of them were not created) */ - @SuppressWarnings("resource") private Pair buildSummaryAndBloomFilter(FileHandle indexFile, SerializationHeader serializationHeader, boolean rebuildFilter, diff --git a/src/java/org/apache/cassandra/io/sstable/format/big/BigTableKeyReader.java b/src/java/org/apache/cassandra/io/sstable/format/big/BigTableKeyReader.java index 06c4e63788..e0b965057f 100644 --- a/src/java/org/apache/cassandra/io/sstable/format/big/BigTableKeyReader.java +++ b/src/java/org/apache/cassandra/io/sstable/format/big/BigTableKeyReader.java @@ -66,7 +66,7 @@ public class BigTableKeyReader implements KeyReader } } - @SuppressWarnings({ "resource" }) + @SuppressWarnings({ "resource", "RedundantSuppression" }) // iFile and reader are closed in the BigTableKeyReader#close method public static BigTableKeyReader create(FileHandle indexFile, IndexSerializer serializer) throws IOException { FileHandle iFile = null; diff --git a/src/java/org/apache/cassandra/io/sstable/format/big/BigTableReader.java b/src/java/org/apache/cassandra/io/sstable/format/big/BigTableReader.java index 667e2cd904..b58dbc532e 100644 --- a/src/java/org/apache/cassandra/io/sstable/format/big/BigTableReader.java +++ b/src/java/org/apache/cassandra/io/sstable/format/big/BigTableReader.java @@ -621,7 +621,6 @@ public class BigTableReader extends SSTableReaderWithFilter implements IndexSumm * @param samplingLevel the desired sampling level for the index summary on the new SSTableReader * @return a new SSTableReader */ - @SuppressWarnings("resource") public BigTableReader cloneWithNewSummarySamplingLevel(ColumnFamilyStore parent, int samplingLevel) throws IOException { assert openReason != OpenReason.EARLY; diff --git a/src/java/org/apache/cassandra/io/sstable/format/big/BigTableWriter.java b/src/java/org/apache/cassandra/io/sstable/format/big/BigTableWriter.java index 37c6f6119c..bf8bb79ce2 100644 --- a/src/java/org/apache/cassandra/io/sstable/format/big/BigTableWriter.java +++ b/src/java/org/apache/cassandra/io/sstable/format/big/BigTableWriter.java @@ -127,7 +127,6 @@ public class BigTableWriter extends SortedTableWriter 0 && boundary.dataLength > 0); diff --git a/src/java/org/apache/cassandra/io/sstable/format/big/IndexSummaryComponent.java b/src/java/org/apache/cassandra/io/sstable/format/big/IndexSummaryComponent.java index b3a40cbafe..a137d78284 100644 --- a/src/java/org/apache/cassandra/io/sstable/format/big/IndexSummaryComponent.java +++ b/src/java/org/apache/cassandra/io/sstable/format/big/IndexSummaryComponent.java @@ -69,7 +69,6 @@ public class IndexSummaryComponent * if loaded index summary has different index interval from current value stored in schema, * then Summary.db file will be deleted and need to be rebuilt. */ - @SuppressWarnings("resource") public static IndexSummaryComponent load(File summaryFile, TableMetadata metadata) throws IOException { if (!summaryFile.exists()) diff --git a/src/java/org/apache/cassandra/io/sstable/format/big/SSTableIterator.java b/src/java/org/apache/cassandra/io/sstable/format/big/SSTableIterator.java index d5d4f2e751..61d6527f5c 100644 --- a/src/java/org/apache/cassandra/io/sstable/format/big/SSTableIterator.java +++ b/src/java/org/apache/cassandra/io/sstable/format/big/SSTableIterator.java @@ -53,7 +53,6 @@ public class SSTableIterator extends AbstractSSTableIterator super(sstable, file, key, indexEntry, slices, columns, ifile); } - @SuppressWarnings("resource") // caller to close protected Reader createReaderInternal(RowIndexEntry indexEntry, FileDataInput file, boolean shouldCloseFile, Version version) { return indexEntry.isIndexed() diff --git a/src/java/org/apache/cassandra/io/sstable/format/big/SSTableReversedIterator.java b/src/java/org/apache/cassandra/io/sstable/format/big/SSTableReversedIterator.java index 90927329cf..b44c0797ce 100644 --- a/src/java/org/apache/cassandra/io/sstable/format/big/SSTableReversedIterator.java +++ b/src/java/org/apache/cassandra/io/sstable/format/big/SSTableReversedIterator.java @@ -68,7 +68,6 @@ public class SSTableReversedIterator extends AbstractSSTableIterator partitionIndexSupplier) { IFilter filter = null; @@ -145,7 +145,6 @@ public class BtiTableWriter extends SortedTableWriter IndexSummary deserialize(T in, IPartitioner partitioner, int expectedMinIndexInterval, int maxIndexInterval) throws IOException { int minIndexInterval = in.readInt(); diff --git a/src/java/org/apache/cassandra/io/sstable/indexsummary/IndexSummaryBuilder.java b/src/java/org/apache/cassandra/io/sstable/indexsummary/IndexSummaryBuilder.java index 862df0fb88..f9e1d45eb5 100644 --- a/src/java/org/apache/cassandra/io/sstable/indexsummary/IndexSummaryBuilder.java +++ b/src/java/org/apache/cassandra/io/sstable/indexsummary/IndexSummaryBuilder.java @@ -321,7 +321,6 @@ public class IndexSummaryBuilder implements AutoCloseable * @param partitioner the partitioner used for the index summary * @return a new IndexSummary */ - @SuppressWarnings("resource") public static IndexSummary downsample(IndexSummary existing, int newSamplingLevel, int minIndexInterval, IPartitioner partitioner) { // To downsample the old index summary, we'll go through (potentially) several rounds of downsampling. diff --git a/src/java/org/apache/cassandra/io/sstable/indexsummary/IndexSummaryManager.java b/src/java/org/apache/cassandra/io/sstable/indexsummary/IndexSummaryManager.java index 6fbdad3ef3..7de33ba2f1 100644 --- a/src/java/org/apache/cassandra/io/sstable/indexsummary/IndexSummaryManager.java +++ b/src/java/org/apache/cassandra/io/sstable/indexsummary/IndexSummaryManager.java @@ -205,7 +205,6 @@ public class IndexSummaryManager> getRestributionTransactions() { List allCompacting = new ArrayList<>(); diff --git a/src/java/org/apache/cassandra/io/sstable/indexsummary/IndexSummaryRedistribution.java b/src/java/org/apache/cassandra/io/sstable/indexsummary/IndexSummaryRedistribution.java index 17d1f96888..d27969719a 100644 --- a/src/java/org/apache/cassandra/io/sstable/indexsummary/IndexSummaryRedistribution.java +++ b/src/java/org/apache/cassandra/io/sstable/indexsummary/IndexSummaryRedistribution.java @@ -297,7 +297,6 @@ public class IndexSummaryRedistribution extends CompactionInfo.Holder /** * Add hooks to correctly update the storage load metrics once the transaction is closed/aborted */ - @SuppressWarnings("resource") // Transactions are closed in finally outside of this method private void addHooks(ColumnFamilyStore cfs, Map transactions, long oldSize, long newSize, long oldSizeUncompressed, long newSizeUncompressed) { LifecycleTransaction txn = transactions.get(cfs.metadata.id); diff --git a/src/java/org/apache/cassandra/io/util/ChecksummedRandomAccessReader.java b/src/java/org/apache/cassandra/io/util/ChecksummedRandomAccessReader.java index 62927f5eea..8f0206e2a0 100644 --- a/src/java/org/apache/cassandra/io/util/ChecksummedRandomAccessReader.java +++ b/src/java/org/apache/cassandra/io/util/ChecksummedRandomAccessReader.java @@ -23,7 +23,7 @@ import org.apache.cassandra.utils.ChecksumType; public final class ChecksummedRandomAccessReader { - @SuppressWarnings("resource") // The Rebufferer owns both the channel and the validator and handles closing both. + @SuppressWarnings({ "resource", "RedundantSuppression" }) // The Rebufferer owns both the channel and the validator and handles closing both. public static RandomAccessReader open(File file, File crcFile) throws IOException { ChannelProxy channel = new ChannelProxy(file); diff --git a/src/java/org/apache/cassandra/io/util/ChecksummedRebufferer.java b/src/java/org/apache/cassandra/io/util/ChecksummedRebufferer.java index 99091d90c6..bc8695fd24 100644 --- a/src/java/org/apache/cassandra/io/util/ChecksummedRebufferer.java +++ b/src/java/org/apache/cassandra/io/util/ChecksummedRebufferer.java @@ -27,7 +27,6 @@ class ChecksummedRebufferer extends BufferManagingRebufferer { private final DataIntegrityMetadata.ChecksumValidator validator; - @SuppressWarnings("resource") // chunk reader is closed by super::close() ChecksummedRebufferer(ChannelProxy channel, DataIntegrityMetadata.ChecksumValidator validator) { super(new SimpleChunkReader(channel, channel.size(), BufferType.ON_HEAP, validator.chunkSize)); diff --git a/src/java/org/apache/cassandra/io/util/FileHandle.java b/src/java/org/apache/cassandra/io/util/FileHandle.java index 360f0af5cc..943355d01d 100644 --- a/src/java/org/apache/cassandra/io/util/FileHandle.java +++ b/src/java/org/apache/cassandra/io/util/FileHandle.java @@ -369,7 +369,6 @@ public class FileHandle extends SharedCloseableImpl } @VisibleForTesting - @SuppressWarnings("resource") public FileHandle complete(Function channelProxyFactory) { ChannelProxy channel = null; diff --git a/src/java/org/apache/cassandra/io/util/FileReader.java b/src/java/org/apache/cassandra/io/util/FileReader.java index 86d0388399..5b43b9a726 100644 --- a/src/java/org/apache/cassandra/io/util/FileReader.java +++ b/src/java/org/apache/cassandra/io/util/FileReader.java @@ -23,13 +23,11 @@ import java.io.InputStreamReader; public class FileReader extends InputStreamReader { - @SuppressWarnings("resource") // FISP is closed by ISR::close public FileReader(String file) throws IOException { super(new FileInputStreamPlus(file)); } - @SuppressWarnings("resource") // FISP is closed by ISR::close public FileReader(File file) throws IOException { super(new FileInputStreamPlus(file)); diff --git a/src/java/org/apache/cassandra/io/util/FileWriter.java b/src/java/org/apache/cassandra/io/util/FileWriter.java index bbfb595431..ede963ad4a 100644 --- a/src/java/org/apache/cassandra/io/util/FileWriter.java +++ b/src/java/org/apache/cassandra/io/util/FileWriter.java @@ -25,13 +25,11 @@ import org.apache.cassandra.io.util.File.WriteMode; public class FileWriter extends OutputStreamWriter { - @SuppressWarnings("resource") // FOSP is closed by OSW::close public FileWriter(File file) throws IOException { super(new FileOutputStreamPlus(file)); } - @SuppressWarnings("resource") // FOSP is closed by OSW::close public FileWriter(File file, WriteMode mode) throws IOException { super(new FileOutputStreamPlus(file, mode)); diff --git a/src/java/org/apache/cassandra/io/util/MmappedRegionsCache.java b/src/java/org/apache/cassandra/io/util/MmappedRegionsCache.java index 9e687ac4a5..dff9561f4f 100644 --- a/src/java/org/apache/cassandra/io/util/MmappedRegionsCache.java +++ b/src/java/org/apache/cassandra/io/util/MmappedRegionsCache.java @@ -45,7 +45,6 @@ public class MmappedRegionsCache implements AutoCloseable * @param length length of the file * @return a shared copy of the cached mmapped regions */ - @SuppressWarnings("resource") public MmappedRegions getOrCreate(ChannelProxy channel, long length) { Preconditions.checkState(!closed); @@ -63,7 +62,6 @@ public class MmappedRegionsCache implements AutoCloseable * @param metadata compression metadata of the file * @return a shared copy of the cached mmapped regions */ - @SuppressWarnings("resource") public MmappedRegions getOrCreate(ChannelProxy channel, CompressionMetadata metadata) { Preconditions.checkState(!closed); @@ -74,7 +72,6 @@ public class MmappedRegionsCache implements AutoCloseable } @Override - @SuppressWarnings("resource") public void close() { closed = true; diff --git a/src/java/org/apache/cassandra/io/util/RandomAccessReader.java b/src/java/org/apache/cassandra/io/util/RandomAccessReader.java index aab324f675..3ce1a2eb08 100644 --- a/src/java/org/apache/cassandra/io/util/RandomAccessReader.java +++ b/src/java/org/apache/cassandra/io/util/RandomAccessReader.java @@ -325,7 +325,7 @@ public class RandomAccessReader extends RebufferingInputStream implements FileDa * @param file File to open for reading * @return new RandomAccessReader that owns the channel opened in this method. */ - @SuppressWarnings("resource") + @SuppressWarnings({ "resource", "RedundantSuppression" }) // reader is closed along with the returned RandomAccessReader instance public static RandomAccessReader open(File file) { ChannelProxy channel = new ChannelProxy(file); diff --git a/src/java/org/apache/cassandra/io/util/SafeMemoryWriter.java b/src/java/org/apache/cassandra/io/util/SafeMemoryWriter.java index a2b8f20048..28314c82d3 100644 --- a/src/java/org/apache/cassandra/io/util/SafeMemoryWriter.java +++ b/src/java/org/apache/cassandra/io/util/SafeMemoryWriter.java @@ -25,7 +25,6 @@ public class SafeMemoryWriter extends DataOutputBuffer { private SafeMemory memory; - @SuppressWarnings("resource") public SafeMemoryWriter(long initialCapacity) { this(new SafeMemory(initialCapacity)); diff --git a/src/java/org/apache/cassandra/metrics/TableMetrics.java b/src/java/org/apache/cassandra/metrics/TableMetrics.java index a061f8cdb6..b02cf1237e 100644 --- a/src/java/org/apache/cassandra/metrics/TableMetrics.java +++ b/src/java/org/apache/cassandra/metrics/TableMetrics.java @@ -1030,7 +1030,6 @@ public class TableMetrics // using SSTableSet.CANONICAL. assert sstable.openReason != SSTableReader.OpenReason.EARLY; - @SuppressWarnings("resource") CompressionMetadata compressionMetadata = sstable.getCompressionMetadata(); compressedLengthSum += compressionMetadata.compressedFileLength; dataLengthSum += compressionMetadata.dataLength; diff --git a/src/java/org/apache/cassandra/net/OutboundConnection.java b/src/java/org/apache/cassandra/net/OutboundConnection.java index ee023821f3..cfb9f1ffc0 100644 --- a/src/java/org/apache/cassandra/net/OutboundConnection.java +++ b/src/java/org/apache/cassandra/net/OutboundConnection.java @@ -754,7 +754,6 @@ public class OutboundConnection * * If there is more work to be done, we submit ourselves for execution once the eventLoop has time. */ - @SuppressWarnings("resource") boolean doRun(Established established) { if (!isWritable) @@ -965,7 +964,6 @@ public class OutboundConnection } } - @SuppressWarnings({ "resource", "RedundantSuppression" }) // make eclipse warnings go away boolean doRun(Established established) { Message send = queue.tryPoll(approxTime.now(), this::execute); diff --git a/src/java/org/apache/cassandra/repair/ValidationManager.java b/src/java/org/apache/cassandra/repair/ValidationManager.java index cc796c5f5b..e3598cd38f 100644 --- a/src/java/org/apache/cassandra/repair/ValidationManager.java +++ b/src/java/org/apache/cassandra/repair/ValidationManager.java @@ -97,7 +97,6 @@ public class ValidationManager implements IValidationManager * Performs a readonly "compaction" of all sstables in order to validate complete rows, * but without writing the merge result */ - @SuppressWarnings("resource") public static void doValidation(ColumnFamilyStore cfs, Validator validator) throws IOException, NoSuchRepairSessionException { SharedContext ctx = validator.ctx; diff --git a/src/java/org/apache/cassandra/security/EncryptionUtils.java b/src/java/org/apache/cassandra/security/EncryptionUtils.java index 855e2a9671..d5300b5012 100644 --- a/src/java/org/apache/cassandra/security/EncryptionUtils.java +++ b/src/java/org/apache/cassandra/security/EncryptionUtils.java @@ -115,7 +115,6 @@ public class EncryptionUtils return outputBuffer; } - @SuppressWarnings("resource") public static ByteBuffer encrypt(ByteBuffer inputBuffer, ByteBuffer outputBuffer, boolean allowBufferResize, Cipher cipher) throws IOException { Preconditions.checkNotNull(outputBuffer, "output buffer may not be null"); @@ -167,7 +166,6 @@ public class EncryptionUtils } // path used when decrypting commit log files - @SuppressWarnings("resource") public static ByteBuffer decrypt(FileDataInput fileDataInput, ByteBuffer outputBuffer, boolean allowBufferResize, Cipher cipher) throws IOException { return decrypt(new DataInputReadChannel(fileDataInput), outputBuffer, allowBufferResize, cipher); diff --git a/src/java/org/apache/cassandra/service/ClientWarn.java b/src/java/org/apache/cassandra/service/ClientWarn.java index 6e2d3fcdb1..1769425c63 100644 --- a/src/java/org/apache/cassandra/service/ClientWarn.java +++ b/src/java/org/apache/cassandra/service/ClientWarn.java @@ -23,7 +23,6 @@ import java.util.List; import org.apache.cassandra.concurrent.ExecutorLocals; import org.apache.cassandra.utils.FBUtilities; -@SuppressWarnings("resource") public class ClientWarn extends ExecutorLocals.Impl { private static final String TRUNCATED = " [truncated]"; diff --git a/src/java/org/apache/cassandra/service/StorageProxy.java b/src/java/org/apache/cassandra/service/StorageProxy.java index 8d94cec924..e842ba7495 100644 --- a/src/java/org/apache/cassandra/service/StorageProxy.java +++ b/src/java/org/apache/cassandra/service/StorageProxy.java @@ -1985,7 +1985,6 @@ public class StorageProxy implements StorageProxyMBean return result; } - @SuppressWarnings("resource") private static PartitionIterator readRegular(SinglePartitionReadCommand.Group group, ConsistencyLevel consistencyLevel, long queryStartNanoTime) throws UnavailableException, ReadFailureException, ReadTimeoutException { diff --git a/src/java/org/apache/cassandra/service/pager/MultiPartitionPager.java b/src/java/org/apache/cassandra/service/pager/MultiPartitionPager.java index 7f8442a13f..dc6fcba0c7 100644 --- a/src/java/org/apache/cassandra/service/pager/MultiPartitionPager.java +++ b/src/java/org/apache/cassandra/service/pager/MultiPartitionPager.java @@ -149,14 +149,12 @@ public class MultiPartitionPager implements throw new AssertionError("Shouldn't be called on an exhausted pager"); } - @SuppressWarnings("resource") // iter closed via countingIter public PartitionIterator fetchPage(int pageSize, ConsistencyLevel consistency, ClientState clientState, long queryStartNanoTime) throws RequestValidationException, RequestExecutionException { int toQuery = Math.min(remaining, pageSize); return new PagersIterator(toQuery, consistency, clientState, null, queryStartNanoTime); } - @SuppressWarnings("resource") // iter closed via countingIter public PartitionIterator fetchPageInternal(int pageSize, ReadExecutionController executionController) throws RequestValidationException, RequestExecutionException { int toQuery = Math.min(remaining, pageSize); diff --git a/src/java/org/apache/cassandra/service/pager/PagingState.java b/src/java/org/apache/cassandra/service/pager/PagingState.java index b207d0b769..627f958ff3 100644 --- a/src/java/org/apache/cassandra/service/pager/PagingState.java +++ b/src/java/org/apache/cassandra/service/pager/PagingState.java @@ -123,7 +123,6 @@ public class PagingState * Modern serde (> VERSION_3) */ - @SuppressWarnings({ "resource", "RedundantSuppression" }) private ByteBuffer modernSerialize() throws IOException { DataOutputBuffer out = new DataOutputBufferFixed(modernSerializedSize()); @@ -196,7 +195,6 @@ public class PagingState return (int)value; } - @SuppressWarnings({ "resource", "RedundantSuppression" }) private static PagingState modernDeserialize(ByteBuffer bytes, ProtocolVersion protocolVersion) throws IOException { if (protocolVersion.isSmallerThan(ProtocolVersion.V4)) @@ -231,7 +229,6 @@ public class PagingState */ @VisibleForTesting - @SuppressWarnings({ "resource", "RedundantSuppression" }) ByteBuffer legacySerialize(boolean withRemainingInPartition) throws IOException { DataOutputBuffer out = new DataOutputBufferFixed(legacySerializedSize(withRemainingInPartition)); @@ -282,7 +279,6 @@ public class PagingState return false; } - @SuppressWarnings({ "resource", "RedundantSuppression" }) private static PagingState legacyDeserialize(ByteBuffer bytes, ProtocolVersion protocolVersion) throws IOException { if (protocolVersion.isGreaterThan(ProtocolVersion.V3)) diff --git a/src/java/org/apache/cassandra/service/paxos/Paxos.java b/src/java/org/apache/cassandra/service/paxos/Paxos.java index acc6267161..3b87ffb545 100644 --- a/src/java/org/apache/cassandra/service/paxos/Paxos.java +++ b/src/java/org/apache/cassandra/service/paxos/Paxos.java @@ -951,7 +951,6 @@ public class Paxos * @return the Paxos ballot promised by the replicas if no in-progress requests were seen and a quorum of * nodes have seen the mostRecentCommit. Otherwise, return null. */ - @SuppressWarnings("resource") private static BeginResult begin(long deadline, SinglePartitionReadCommand query, ConsistencyLevel consistencyForConsensus, diff --git a/src/java/org/apache/cassandra/service/paxos/PaxosState.java b/src/java/org/apache/cassandra/service/paxos/PaxosState.java index ad0866b4e0..a3f019e4bf 100644 --- a/src/java/org/apache/cassandra/service/paxos/PaxosState.java +++ b/src/java/org/apache/cassandra/service/paxos/PaxosState.java @@ -812,7 +812,6 @@ public class PaxosState implements PaxosOperationLock ballotTracker().truncate(); } - @SuppressWarnings("resource") public static Snapshot unsafeGetIfPresent(DecoratedKey partitionKey, TableMetadata metadata) { Key key = new Key(partitionKey, metadata); diff --git a/src/java/org/apache/cassandra/service/paxos/cleanup/PaxosCleanupLocalCoordinator.java b/src/java/org/apache/cassandra/service/paxos/cleanup/PaxosCleanupLocalCoordinator.java index 7b882768fa..3378714a0c 100644 --- a/src/java/org/apache/cassandra/service/paxos/cleanup/PaxosCleanupLocalCoordinator.java +++ b/src/java/org/apache/cassandra/service/paxos/cleanup/PaxosCleanupLocalCoordinator.java @@ -91,14 +91,12 @@ public class PaxosCleanupLocalCoordinator extends AsyncFuture iterator = PaxosState.uncommittedTracker().uncommittedKeyIterator(request.tableId, request.ranges); return new PaxosCleanupLocalCoordinator(request.session, request.tableId, request.ranges, iterator); } - @SuppressWarnings("resource") public static PaxosCleanupLocalCoordinator createForAutoRepair(TableId tableId, Collection> ranges) { CloseableIterator iterator = PaxosState.uncommittedTracker().uncommittedKeyIterator(tableId, ranges); diff --git a/src/java/org/apache/cassandra/service/paxos/uncommitted/PaxosStateTracker.java b/src/java/org/apache/cassandra/service/paxos/uncommitted/PaxosStateTracker.java index 514ce15a34..1b5f6a07fe 100644 --- a/src/java/org/apache/cassandra/service/paxos/uncommitted/PaxosStateTracker.java +++ b/src/java/org/apache/cassandra/service/paxos/uncommitted/PaxosStateTracker.java @@ -160,7 +160,6 @@ public class PaxosStateTracker return create(dataDirectories.getAllDirectories().stream().map(d -> d.location).toArray(File[]::new)); } - @SuppressWarnings("resource") private void rebuildUncommittedData() throws IOException { logger.info("Beginning uncommitted paxos data rebuild. Set -D{}=true and restart to skip", SKIP_PAXOS_STATE_REBUILD.getKey()); diff --git a/src/java/org/apache/cassandra/service/paxos/uncommitted/PaxosUncommittedTracker.java b/src/java/org/apache/cassandra/service/paxos/uncommitted/PaxosUncommittedTracker.java index ae4662f3d2..adbd537930 100644 --- a/src/java/org/apache/cassandra/service/paxos/uncommitted/PaxosUncommittedTracker.java +++ b/src/java/org/apache/cassandra/service/paxos/uncommitted/PaxosUncommittedTracker.java @@ -189,7 +189,6 @@ public class PaxosUncommittedTracker return tableStates.get(tableId); } - @SuppressWarnings("resource") public CloseableIterator uncommittedKeyIterator(TableId tableId, Collection> ranges) { ranges = (ranges == null || ranges.isEmpty()) ? Collections.singleton(FULL_RANGE) : Range.normalize(ranges); diff --git a/src/java/org/apache/cassandra/service/paxos/uncommitted/UncommittedTableData.java b/src/java/org/apache/cassandra/service/paxos/uncommitted/UncommittedTableData.java index 9e2ae9eeb1..744dd4d07d 100644 --- a/src/java/org/apache/cassandra/service/paxos/uncommitted/UncommittedTableData.java +++ b/src/java/org/apache/cassandra/service/paxos/uncommitted/UncommittedTableData.java @@ -245,7 +245,6 @@ public class UncommittedTableData } } - @SuppressWarnings("resource") private static CloseableIterator merge(Collection files, Collection> ranges) { List> iterators = new ArrayList<>(files.size()); diff --git a/src/java/org/apache/cassandra/service/reads/DataResolver.java b/src/java/org/apache/cassandra/service/reads/DataResolver.java index 3868918453..2c44160fcd 100644 --- a/src/java/org/apache/cassandra/service/reads/DataResolver.java +++ b/src/java/org/apache/cassandra/service/reads/DataResolver.java @@ -224,7 +224,6 @@ public class DataResolver, P extends ReplicaPlan.ForRead< return resolveInternal(context, listener, responseProvider, preCountFilter); } - @SuppressWarnings("resource") private PartitionIterator resolveWithReplicaFilteringProtection(E replicas, RepairedDataTracker repairedDataTracker) { // Protecting against inconsistent replica filtering (some replica returning a row that is outdated but that @@ -280,7 +279,6 @@ public class DataResolver, P extends ReplicaPlan.ForRead< }; } - @SuppressWarnings("resource") private PartitionIterator resolveInternal(ResolveContext context, UnfilteredPartitionIterators.MergeListener mergeListener, ResponseProvider responseProvider, diff --git a/src/java/org/apache/cassandra/service/reads/ShortReadProtection.java b/src/java/org/apache/cassandra/service/reads/ShortReadProtection.java index 8bf877fa12..e38a828e4f 100644 --- a/src/java/org/apache/cassandra/service/reads/ShortReadProtection.java +++ b/src/java/org/apache/cassandra/service/reads/ShortReadProtection.java @@ -38,7 +38,6 @@ import org.apache.cassandra.locator.Replica; */ public class ShortReadProtection { - @SuppressWarnings("resource") public static UnfilteredPartitionIterator extend(Replica source, Runnable preFetchCallback, UnfilteredPartitionIterator partitions, diff --git a/src/java/org/apache/cassandra/service/reads/range/RangeCommandIterator.java b/src/java/org/apache/cassandra/service/reads/range/RangeCommandIterator.java index 7c2ec1337e..c258ef7939 100644 --- a/src/java/org/apache/cassandra/service/reads/range/RangeCommandIterator.java +++ b/src/java/org/apache/cassandra/service/reads/range/RangeCommandIterator.java @@ -231,7 +231,6 @@ public class RangeCommandIterator extends AbstractIterator implemen { ReplicaPlan.ForRangeRead replicaPlan = replicaPlans.next(); - @SuppressWarnings("resource") // response will be closed by concatAndBlockOnRepair, or in the catch block below SingleRangeResponse response = query(replicaPlan, i == 0); concurrentQueries.add(response); readRepairs.add(response.getReadRepair()); diff --git a/src/java/org/apache/cassandra/service/reads/range/RangeCommands.java b/src/java/org/apache/cassandra/service/reads/range/RangeCommands.java index a51281fe27..d4ff07ecda 100644 --- a/src/java/org/apache/cassandra/service/reads/range/RangeCommands.java +++ b/src/java/org/apache/cassandra/service/reads/range/RangeCommands.java @@ -52,7 +52,6 @@ public class RangeCommands */ private static final int MAX_CONCURRENT_RANGE_REQUESTS = Math.max(1, CassandraRelevantProperties.MAX_CONCURRENT_RANGE_REQUESTS.getInt(FBUtilities.getAvailableProcessors() * 10)); - @SuppressWarnings("resource") // created iterators will be closed in CQL layer through the chain of transformations public static PartitionIterator partitions(PartitionRangeReadCommand command, ConsistencyLevel consistencyLevel, long queryStartNanoTime) @@ -66,7 +65,6 @@ public class RangeCommands } @VisibleForTesting - @SuppressWarnings("resource") // created iterators will be closed in CQL layer through the chain of transformations static RangeCommandIterator rangeCommandIterator(PartitionRangeReadCommand command, ConsistencyLevel consistencyLevel, long queryStartNanoTime) diff --git a/src/java/org/apache/cassandra/streaming/StreamDeserializingTask.java b/src/java/org/apache/cassandra/streaming/StreamDeserializingTask.java index 3785249430..22d44d5ed0 100644 --- a/src/java/org/apache/cassandra/streaming/StreamDeserializingTask.java +++ b/src/java/org/apache/cassandra/streaming/StreamDeserializingTask.java @@ -51,7 +51,6 @@ public class StreamDeserializingTask implements Runnable @Override public void run() { - @SuppressWarnings("resource") // closed in finally StreamingDataInputPlus input = channel.in(); try { diff --git a/src/java/org/apache/cassandra/streaming/messages/ReceivedMessage.java b/src/java/org/apache/cassandra/streaming/messages/ReceivedMessage.java index 134e2cf9d7..378f72f896 100644 --- a/src/java/org/apache/cassandra/streaming/messages/ReceivedMessage.java +++ b/src/java/org/apache/cassandra/streaming/messages/ReceivedMessage.java @@ -28,7 +28,6 @@ public class ReceivedMessage extends StreamMessage { public static Serializer serializer = new Serializer() { - @SuppressWarnings("resource") // Not closing constructed DataInputPlus's as the channel needs to remain open. public ReceivedMessage deserialize(DataInputPlus input, int version) throws IOException { return new ReceivedMessage(TableId.deserialize(input), input.readInt()); diff --git a/src/java/org/apache/cassandra/tools/JMXTool.java b/src/java/org/apache/cassandra/tools/JMXTool.java index c3e7981c5a..8cf5748a2e 100644 --- a/src/java/org/apache/cassandra/tools/JMXTool.java +++ b/src/java/org/apache/cassandra/tools/JMXTool.java @@ -132,7 +132,6 @@ public class JMXTool { void dump(OutputStream output, Map map) { - @SuppressWarnings("resource") // output should be released by caller PrintStream out = toPrintStream(output); for (Map.Entry e : map.entrySet()) diff --git a/src/java/org/apache/cassandra/tools/SSTableExport.java b/src/java/org/apache/cassandra/tools/SSTableExport.java index d807e0cde9..4eaec602f1 100644 --- a/src/java/org/apache/cassandra/tools/SSTableExport.java +++ b/src/java/org/apache/cassandra/tools/SSTableExport.java @@ -107,7 +107,6 @@ public class SSTableExport * @throws ConfigurationException * on configuration failure (wrong params given) */ - @SuppressWarnings("resource") public static void main(String[] args) throws ConfigurationException { CommandLineParser parser = new PosixParser(); diff --git a/src/java/org/apache/cassandra/tracing/Tracing.java b/src/java/org/apache/cassandra/tracing/Tracing.java index 73cf2ebb0c..f1c5b54b94 100644 --- a/src/java/org/apache/cassandra/tracing/Tracing.java +++ b/src/java/org/apache/cassandra/tracing/Tracing.java @@ -229,7 +229,6 @@ public abstract class Tracing extends ExecutorLocals.Impl public void set(TraceState tls) { - @SuppressWarnings("resource") ExecutorLocals current = ExecutorLocals.current(); ExecutorLocals.Impl.set(tls, current.clientWarnState); } diff --git a/src/java/org/apache/cassandra/transport/Client.java b/src/java/org/apache/cassandra/transport/Client.java index 76f710e5ee..45f5e1f2fa 100644 --- a/src/java/org/apache/cassandra/transport/Client.java +++ b/src/java/org/apache/cassandra/transport/Client.java @@ -260,7 +260,10 @@ public class Client extends SimpleClient EncryptionOptions encryptionOptions = new EncryptionOptions().applyConfig(); System.out.println("CQL binary protocol console " + host + "@" + port + " using native protocol version " + version); - new Client(host, port, version, encryptionOptions).run(); + try (Client client = new Client(host, port, version, encryptionOptions)) + { + client.run(); + } System.exit(0); } } diff --git a/src/java/org/apache/cassandra/utils/BloomFilterSerializer.java b/src/java/org/apache/cassandra/utils/BloomFilterSerializer.java index e4b34a49d7..91ec13f53c 100644 --- a/src/java/org/apache/cassandra/utils/BloomFilterSerializer.java +++ b/src/java/org/apache/cassandra/utils/BloomFilterSerializer.java @@ -70,7 +70,6 @@ public final class BloomFilterSerializer implements IGenericSerializer extends AbstractIterator implem this.reducer = reducer; } - @SuppressWarnings("resource") public static MergeIterator get(List> sources, Comparator comparator, Reducer reducer) diff --git a/src/java/org/apache/cassandra/utils/MerkleTree.java b/src/java/org/apache/cassandra/utils/MerkleTree.java index 9820ada297..2646057c04 100644 --- a/src/java/org/apache/cassandra/utils/MerkleTree.java +++ b/src/java/org/apache/cassandra/utils/MerkleTree.java @@ -464,31 +464,40 @@ public class MerkleTree EstimatedHistogram histogramOfRowSizePerLeaf() { HistogramBuilder histbuild = new HistogramBuilder(); - for (TreeRange range : new TreeRangeIterator(this)) + try (TreeRangeIterator trIter = new TreeRangeIterator(this)) { - histbuild.add(range.node.sizeOfRange()); + for (TreeRange range : trIter) + { + histbuild.add(range.node.sizeOfRange()); + } + return histbuild.buildWithStdevRangesAroundMean(); } - return histbuild.buildWithStdevRangesAroundMean(); } EstimatedHistogram histogramOfRowCountPerLeaf() { HistogramBuilder histbuild = new HistogramBuilder(); - for (TreeRange range : new TreeRangeIterator(this)) + try (TreeRangeIterator trIter = new TreeRangeIterator(this)) { - histbuild.add(range.node.partitionsInRange()); + for (TreeRange range : trIter) + { + histbuild.add(range.node.partitionsInRange()); + } + return histbuild.buildWithStdevRangesAroundMean(); } - return histbuild.buildWithStdevRangesAroundMean(); } public long rowCount() { long count = 0; - for (TreeRange range : new TreeRangeIterator(this)) + try (TreeRangeIterator trIter = new TreeRangeIterator(this)) { - count += range.node.partitionsInRange(); + for (TreeRange range : trIter) + { + count += range.node.partitionsInRange(); + } + return count; } - return count; } @Override diff --git a/src/java/org/apache/cassandra/utils/WithResources.java b/src/java/org/apache/cassandra/utils/WithResources.java index 0c0bb92f3e..9d2283b2a3 100644 --- a/src/java/org/apache/cassandra/utils/WithResources.java +++ b/src/java/org/apache/cassandra/utils/WithResources.java @@ -66,7 +66,6 @@ public interface WithResources } static WithResources none() { return None.INSTANCE; } - @SuppressWarnings("resource") public static WithResources and(WithResources first, WithResources second) { if (second.isNoOp()) return first; diff --git a/src/java/org/apache/cassandra/utils/obs/OffHeapBitSet.java b/src/java/org/apache/cassandra/utils/obs/OffHeapBitSet.java index ae89594fc6..be0ecf556f 100644 --- a/src/java/org/apache/cassandra/utils/obs/OffHeapBitSet.java +++ b/src/java/org/apache/cassandra/utils/obs/OffHeapBitSet.java @@ -141,7 +141,6 @@ public class OffHeapBitSet implements IBitSet return TypeSizes.sizeof((int) bytes.size()) + bytes.size(); } - @SuppressWarnings("resource") public static OffHeapBitSet deserialize(I in, boolean oldBfFormat) throws IOException { long byteCount = in.readInt() * 8L; diff --git a/test/burn/org/apache/cassandra/transport/SimpleClientPerfTest.java b/test/burn/org/apache/cassandra/transport/SimpleClientPerfTest.java index e6046979ff..d15c4e56a7 100644 --- a/test/burn/org/apache/cassandra/transport/SimpleClientPerfTest.java +++ b/test/burn/org/apache/cassandra/transport/SimpleClientPerfTest.java @@ -95,7 +95,6 @@ public class SimpleClientPerfTest } } - @SuppressWarnings({"IOResourceOpenedButNotSafelyClosed", "resource"}) @Test public void measureSmall() throws Throwable { @@ -108,7 +107,6 @@ public class SimpleClientPerfTest version); } - @SuppressWarnings({"IOResourceOpenedButNotSafelyClosed", "resource"}) @Test public void measureSmallWithCompression() throws Throwable { @@ -121,7 +119,6 @@ public class SimpleClientPerfTest version); } - @SuppressWarnings({"IOResourceOpenedButNotSafelyClosed", "resource"}) @Test public void measureLarge() throws Throwable { @@ -134,7 +131,6 @@ public class SimpleClientPerfTest version); } - @SuppressWarnings({"IOResourceOpenedButNotSafelyClosed", "resource"}) @Test public void measureLargeWithCompression() throws Throwable { diff --git a/test/distributed/org/apache/cassandra/distributed/impl/Instance.java b/test/distributed/org/apache/cassandra/distributed/impl/Instance.java index b5e143a9bb..28a633f256 100644 --- a/test/distributed/org/apache/cassandra/distributed/impl/Instance.java +++ b/test/distributed/org/apache/cassandra/distributed/impl/Instance.java @@ -1029,9 +1029,7 @@ public class Instance extends IsolatedExecutor implements IInvokableInstance private static class CapturingOutput implements Closeable { - @SuppressWarnings("resource") private final ByteArrayOutputStream outBase = new ByteArrayOutputStream(); - @SuppressWarnings("resource") private final ByteArrayOutputStream errBase = new ByteArrayOutputStream(); public final PrintStream out; diff --git a/test/distributed/org/apache/cassandra/distributed/test/sai/ImportIndexedSSTablesTest.java b/test/distributed/org/apache/cassandra/distributed/test/sai/ImportIndexedSSTablesTest.java index 6ce6bb579e..1b9997aeee 100644 --- a/test/distributed/org/apache/cassandra/distributed/test/sai/ImportIndexedSSTablesTest.java +++ b/test/distributed/org/apache/cassandra/distributed/test/sai/ImportIndexedSSTablesTest.java @@ -232,7 +232,6 @@ public class ImportIndexedSSTablesTest extends TestBaseImpl static volatile boolean interruptBuild = false; static volatile boolean failValidation = false; - @SuppressWarnings("resource") static void installErrors(ClassLoader loader, int node) { new ByteBuddy().rebase(StorageAttachedIndexBuilder.class) diff --git a/test/distributed/org/apache/cassandra/distributed/test/sai/IndexStreamingFailureTest.java b/test/distributed/org/apache/cassandra/distributed/test/sai/IndexStreamingFailureTest.java index c3ff4a528f..00ca972826 100644 --- a/test/distributed/org/apache/cassandra/distributed/test/sai/IndexStreamingFailureTest.java +++ b/test/distributed/org/apache/cassandra/distributed/test/sai/IndexStreamingFailureTest.java @@ -145,7 +145,6 @@ public class IndexStreamingFailureTest extends TestBaseImpl volatile static boolean failFlush = false; volatile static boolean failValidation = false; - @SuppressWarnings("resource") static void installErrors(ClassLoader loader, int node) { if (node == 2) diff --git a/test/unit/org/apache/cassandra/AbstractSerializationsTester.java b/test/unit/org/apache/cassandra/AbstractSerializationsTester.java index 3792d211ce..d1a96298bf 100644 --- a/test/unit/org/apache/cassandra/AbstractSerializationsTester.java +++ b/test/unit/org/apache/cassandra/AbstractSerializationsTester.java @@ -66,13 +66,11 @@ public class AbstractSerializationsTester return new FileInputStreamPlus(f); } - @SuppressWarnings("resource") protected static DataOutputStreamPlus getOutput(String name) throws IOException { return getOutput(CUR_VER, name); } - @SuppressWarnings("resource") protected static DataOutputStreamPlus getOutput(String version, String name) throws IOException { File f = new File("test/data/serialization/" + version + '/' + name); diff --git a/test/unit/org/apache/cassandra/ConsoleAppender.java b/test/unit/org/apache/cassandra/ConsoleAppender.java index aa8af1e2d7..5021515dbb 100644 --- a/test/unit/org/apache/cassandra/ConsoleAppender.java +++ b/test/unit/org/apache/cassandra/ConsoleAppender.java @@ -49,7 +49,6 @@ public class ConsoleAppender extends OutputStreamAppender @Override public void start() { - @SuppressWarnings("resource") final PrintStream targetStream = target.equals("System.out") ? LogbackStatusListener.originalOut : LogbackStatusListener.originalErr; setOutputStream(new OutputStream() { @Override diff --git a/test/unit/org/apache/cassandra/cql3/functions/masking/ColumnMaskTest.java b/test/unit/org/apache/cassandra/cql3/functions/masking/ColumnMaskTest.java index 0dd134aa01..0f42a6a643 100644 --- a/test/unit/org/apache/cassandra/cql3/functions/masking/ColumnMaskTest.java +++ b/test/unit/org/apache/cassandra/cql3/functions/masking/ColumnMaskTest.java @@ -213,7 +213,6 @@ public class ColumnMaskTest extends ColumnMaskTester } @Test - @SuppressWarnings("resource") public void testPreparedStatement() throws Throwable { createTable("CREATE TABLE %s (k int PRIMARY KEY, v text MASKED WITH DEFAULT)"); @@ -251,7 +250,6 @@ public class ColumnMaskTest extends ColumnMaskTester } @Test - @SuppressWarnings("resource") public void testPreparedStatementOnView() throws Throwable { createTable("CREATE TABLE %s (k int, c int, v text MASKED WITH DEFAULT, PRIMARY KEY (k, c))"); diff --git a/test/unit/org/apache/cassandra/cql3/functions/masking/ColumnMaskWithUDFTest.java b/test/unit/org/apache/cassandra/cql3/functions/masking/ColumnMaskWithUDFTest.java index 3b26a56857..61c2496599 100644 --- a/test/unit/org/apache/cassandra/cql3/functions/masking/ColumnMaskWithUDFTest.java +++ b/test/unit/org/apache/cassandra/cql3/functions/masking/ColumnMaskWithUDFTest.java @@ -34,7 +34,6 @@ import static org.junit.Assert.assertNull; public class ColumnMaskWithUDFTest extends ColumnMaskTester { @Test - @SuppressWarnings("resource") public void testUDF() throws Throwable { // create a table masked with a UDF and with a materialized view diff --git a/test/unit/org/apache/cassandra/cql3/validation/entities/UFVerifierTest.java b/test/unit/org/apache/cassandra/cql3/validation/entities/UFVerifierTest.java index 15a5070ce7..542db5c788 100644 --- a/test/unit/org/apache/cassandra/cql3/validation/entities/UFVerifierTest.java +++ b/test/unit/org/apache/cassandra/cql3/validation/entities/UFVerifierTest.java @@ -184,7 +184,6 @@ public class UFVerifierTest extends CQLTester return new UDFByteCodeVerifier().addDisallowedPackage(disallowedPkg).verify(cls.getName(), readClass(cls)); } - @SuppressWarnings("resource") private static byte[] readClass(Class clazz) { ByteArrayOutputStream out = new ByteArrayOutputStream(); diff --git a/test/unit/org/apache/cassandra/db/NativeCellTest.java b/test/unit/org/apache/cassandra/db/NativeCellTest.java index 67e18ea202..d93dea42fe 100644 --- a/test/unit/org/apache/cassandra/db/NativeCellTest.java +++ b/test/unit/org/apache/cassandra/db/NativeCellTest.java @@ -50,7 +50,6 @@ public class NativeCellTest extends CQLTester Integer.MAX_VALUE, 1f, () -> ImmediateFuture.success(true)).newAllocator(null); - @SuppressWarnings("resource") private static final OpOrder.Group group = new OpOrder().start(); private static Random rand; diff --git a/test/unit/org/apache/cassandra/db/commitlog/CommitLogTest.java b/test/unit/org/apache/cassandra/db/commitlog/CommitLogTest.java index d53c1d46d2..f5712cad2f 100644 --- a/test/unit/org/apache/cassandra/db/commitlog/CommitLogTest.java +++ b/test/unit/org/apache/cassandra/db/commitlog/CommitLogTest.java @@ -1050,7 +1050,6 @@ public abstract class CommitLogTest this.metadata = metadata; } - @SuppressWarnings("resource") @Override public void handleMutation(Mutation m, int size, int entryLocation, CommitLogDescriptor desc) { diff --git a/test/unit/org/apache/cassandra/hints/HintsBufferTest.java b/test/unit/org/apache/cassandra/hints/HintsBufferTest.java index 42daebf872..8ca0b03967 100644 --- a/test/unit/org/apache/cassandra/hints/HintsBufferTest.java +++ b/test/unit/org/apache/cassandra/hints/HintsBufferTest.java @@ -72,7 +72,6 @@ public class HintsBufferTest } @Test - @SuppressWarnings("resource") public void testOverlyLargeAllocation() { // create a small, 128 bytes buffer diff --git a/test/unit/org/apache/cassandra/index/sai/disk/v1/SAICodecUtilsTest.java b/test/unit/org/apache/cassandra/index/sai/disk/v1/SAICodecUtilsTest.java index 127bfa07ea..060eabb206 100644 --- a/test/unit/org/apache/cassandra/index/sai/disk/v1/SAICodecUtilsTest.java +++ b/test/unit/org/apache/cassandra/index/sai/disk/v1/SAICodecUtilsTest.java @@ -343,7 +343,6 @@ public class SAICodecUtilsTest extends SAIRandomizedTester } @Test - @SuppressWarnings({"resource", "RedundantSuppression"}) public void writeCRCFailsWithInvalidCRC() throws Exception { IndexOutput indexOutput = Mockito.mock(IndexOutput.class); diff --git a/test/unit/org/apache/cassandra/index/sai/disk/v1/TermsScanner.java b/test/unit/org/apache/cassandra/index/sai/disk/v1/TermsScanner.java index 2512343aa8..dfd589c495 100644 --- a/test/unit/org/apache/cassandra/index/sai/disk/v1/TermsScanner.java +++ b/test/unit/org/apache/cassandra/index/sai/disk/v1/TermsScanner.java @@ -51,7 +51,6 @@ public class TermsScanner implements TermsIterator } @Override - @SuppressWarnings({"resource", "RedundantSuppression"}) public PostingList postings() { assert entry != null; diff --git a/test/unit/org/apache/cassandra/index/sai/iterators/KeyRangeConcatIteratorTest.java b/test/unit/org/apache/cassandra/index/sai/iterators/KeyRangeConcatIteratorTest.java index 821942588e..a866d322a4 100644 --- a/test/unit/org/apache/cassandra/index/sai/iterators/KeyRangeConcatIteratorTest.java +++ b/test/unit/org/apache/cassandra/index/sai/iterators/KeyRangeConcatIteratorTest.java @@ -185,7 +185,6 @@ public class KeyRangeConcatIteratorTest extends AbstractKeyRangeIteratorTester } @Test - @SuppressWarnings("resource") public void testEmptyThenManyNonEmpty() { final KeyRangeIterator.Builder builder = getConcatBuilder(); @@ -201,7 +200,6 @@ public class KeyRangeConcatIteratorTest extends AbstractKeyRangeIteratorTester } @Test - @SuppressWarnings("resource") public void testEmptyThenSingleNonEmpty() { KeyRangeIterator.Builder builder = getConcatBuilder(); @@ -217,7 +215,6 @@ public class KeyRangeConcatIteratorTest extends AbstractKeyRangeIteratorTester } @Test - @SuppressWarnings("resource") public void testManyNonEmptyThenEmpty() { final KeyRangeIterator.Builder builder = getConcatBuilder(); @@ -233,7 +230,6 @@ public class KeyRangeConcatIteratorTest extends AbstractKeyRangeIteratorTester } @Test - @SuppressWarnings("resource") public void testSingleNonEmptyThenEmpty() { KeyRangeIterator.Builder builder = getConcatBuilder(); @@ -249,7 +245,6 @@ public class KeyRangeConcatIteratorTest extends AbstractKeyRangeIteratorTester } @Test - @SuppressWarnings("resource") public void testEmptyNonEmptyEmpty() { final KeyRangeIterator.Builder builder = getConcatBuilder(); @@ -266,7 +261,6 @@ public class KeyRangeConcatIteratorTest extends AbstractKeyRangeIteratorTester } @Test - @SuppressWarnings("resource") public void testNonEmptyEmptyNonEmpty() { final KeyRangeIterator.Builder builder = getConcatBuilder(); diff --git a/test/unit/org/apache/cassandra/index/sai/iterators/KeyRangeUnionIteratorTest.java b/test/unit/org/apache/cassandra/index/sai/iterators/KeyRangeUnionIteratorTest.java index fb121bf1cc..bb094ef1fc 100644 --- a/test/unit/org/apache/cassandra/index/sai/iterators/KeyRangeUnionIteratorTest.java +++ b/test/unit/org/apache/cassandra/index/sai/iterators/KeyRangeUnionIteratorTest.java @@ -307,7 +307,6 @@ public class KeyRangeUnionIteratorTest extends AbstractKeyRangeIteratorTester } @Test - @SuppressWarnings("resource") public void emptyRangeTest() { KeyRangeIterator.Builder builder; diff --git a/test/unit/org/apache/cassandra/io/sstable/format/big/RowIndexEntryTest.java b/test/unit/org/apache/cassandra/io/sstable/format/big/RowIndexEntryTest.java index 9a5673dc6e..a4b56f1765 100644 --- a/test/unit/org/apache/cassandra/io/sstable/format/big/RowIndexEntryTest.java +++ b/test/unit/org/apache/cassandra/io/sstable/format/big/RowIndexEntryTest.java @@ -185,9 +185,7 @@ public class RowIndexEntryTest extends CQLTester RowIndexEntry.IndexSerializer rieSerializer = new RowIndexEntry.Serializer(version, header, null); Pre_C_11206_RowIndexEntry.Serializer oldSerializer = new Pre_C_11206_RowIndexEntry.Serializer(metadata, version, header); - @SuppressWarnings({ "resource", "IOResourceOpenedButNotSafelyClosed" }) final DataOutputBuffer rieOutput = new DataOutputBuffer(1024); - @SuppressWarnings({ "resource", "IOResourceOpenedButNotSafelyClosed" }) final DataOutputBuffer oldOutput = new DataOutputBuffer(1024); final SequentialWriter dataWriterNew; diff --git a/test/unit/org/apache/cassandra/io/util/BufferedDataOutputStreamTest.java b/test/unit/org/apache/cassandra/io/util/BufferedDataOutputStreamTest.java index 3b14ce433e..466552469e 100644 --- a/test/unit/org/apache/cassandra/io/util/BufferedDataOutputStreamTest.java +++ b/test/unit/org/apache/cassandra/io/util/BufferedDataOutputStreamTest.java @@ -104,14 +104,12 @@ public class BufferedDataOutputStreamTest BufferedDataOutputStreamPlus fakeStream = new BufferedDataOutputStreamPlus(adapter, 8); - @SuppressWarnings("resource") @Test(expected = NullPointerException.class) public void testNullChannel() { new BufferedDataOutputStreamPlus((WritableByteChannel)null, 8); } - @SuppressWarnings("resource") @Test(expected = IllegalArgumentException.class) public void testTooSmallBuffer() { diff --git a/test/unit/org/apache/cassandra/io/util/DataOutputTest.java b/test/unit/org/apache/cassandra/io/util/DataOutputTest.java index 83e2cbd831..4b61b051c5 100644 --- a/test/unit/org/apache/cassandra/io/util/DataOutputTest.java +++ b/test/unit/org/apache/cassandra/io/util/DataOutputTest.java @@ -362,7 +362,6 @@ public class DataOutputTest File file = FileUtils.createTempFile("dataoutput", "test"); try { - @SuppressWarnings("resource") DataOutputStreamPlus write = new BufferedDataOutputStreamPlus(file.newReadWriteChannel()); DataInput canon = testWrite(write); write.close(); diff --git a/test/unit/org/apache/cassandra/io/util/NIODataInputStreamTest.java b/test/unit/org/apache/cassandra/io/util/NIODataInputStreamTest.java index 1468ef06be..73bf1adf10 100644 --- a/test/unit/org/apache/cassandra/io/util/NIODataInputStreamTest.java +++ b/test/unit/org/apache/cassandra/io/util/NIODataInputStreamTest.java @@ -193,14 +193,12 @@ public class NIODataInputStreamTest assertFalse(fakeStream.markSupported()); } - @SuppressWarnings("resource") @Test(expected = NullPointerException.class) public void testNullRBC() throws Exception { new NIODataInputStream(null, 9); } - @SuppressWarnings("resource") @Test public void testAvailable() throws Exception { @@ -261,7 +259,6 @@ public class NIODataInputStreamTest }; } - @SuppressWarnings("resource") @Test public void testReadUTF() throws Exception { @@ -287,7 +284,6 @@ public class NIODataInputStreamTest assertEquals(BufferedDataOutputStreamTest.fourByte, is.readUTF()); } - @SuppressWarnings("resource") @Test public void testReadVInt() throws Exception { final ByteArrayOutputStream baos = new ByteArrayOutputStream(); @@ -323,7 +319,6 @@ public class NIODataInputStreamTest assertTrue(threw); } - @SuppressWarnings("resource") @Test public void testReadUnsignedVInt() throws Exception { final ByteArrayOutputStream baos = new ByteArrayOutputStream(); @@ -385,7 +380,7 @@ public class NIODataInputStreamTest DataInputStream dis; - @SuppressWarnings({ "resource", "unused" }) + @SuppressWarnings("unused") void fuzzOnce() throws Exception { init(); @@ -755,7 +750,6 @@ public class NIODataInputStreamTest @Test - @SuppressWarnings({ "resource"}) public void testVIntRemainingBytes() throws Exception { for(int ii = 0; ii < 10; ii++) @@ -784,7 +778,6 @@ public class NIODataInputStreamTest } @Test - @SuppressWarnings({ "resource"}) public void testVIntSmallBuffer() throws Exception { for(int ii = 0; ii < 10; ii++) @@ -817,7 +810,6 @@ public class NIODataInputStreamTest } @Test - @SuppressWarnings({ "resource"}) public void testVIntTruncationEOF() throws Exception { for(int ii = 0; ii < 10; ii++) diff --git a/test/unit/org/apache/cassandra/service/reads/repair/AbstractReadRepairTest.java b/test/unit/org/apache/cassandra/service/reads/repair/AbstractReadRepairTest.java index bb10c67f1c..1d97aeff67 100644 --- a/test/unit/org/apache/cassandra/service/reads/repair/AbstractReadRepairTest.java +++ b/test/unit/org/apache/cassandra/service/reads/repair/AbstractReadRepairTest.java @@ -188,7 +188,6 @@ public abstract class AbstractReadRepairTest return new Mutation(update(cells)); } - @SuppressWarnings("resource") static Message msg(InetAddressAndPort from, Cell... cells) { UnfilteredPartitionIterator iter = new SingletonUnfilteredPartitionIterator(update(cells).unfilteredIterator()); diff --git a/test/unit/org/apache/cassandra/tools/ToolRunner.java b/test/unit/org/apache/cassandra/tools/ToolRunner.java index 812377c53e..ad1f80e812 100644 --- a/test/unit/org/apache/cassandra/tools/ToolRunner.java +++ b/test/unit/org/apache/cassandra/tools/ToolRunner.java @@ -601,11 +601,8 @@ public class ToolRunner private static final class ForkedObservableTool implements ObservableTool { - @SuppressWarnings("resource") private final ByteArrayOutputStream err = new ByteArrayOutputStream(); - @SuppressWarnings("resource") private final ByteArrayOutputStream out = new ByteArrayOutputStream(); - @SuppressWarnings("resource") private final InputStream stdin; private final Process process; private final Thread[] ioWatchers; diff --git a/test/unit/org/apache/cassandra/tools/ToolsEnvsConfigsTest.java b/test/unit/org/apache/cassandra/tools/ToolsEnvsConfigsTest.java index fd399011c1..6e593ccb9b 100644 --- a/test/unit/org/apache/cassandra/tools/ToolsEnvsConfigsTest.java +++ b/test/unit/org/apache/cassandra/tools/ToolsEnvsConfigsTest.java @@ -32,7 +32,6 @@ import static org.junit.Assert.assertTrue; public class ToolsEnvsConfigsTest { //Some JDK can output env info on stdout/err. Check we can clean them - @SuppressWarnings("resource") @Test public void testJDKEnvInfoDefaultCleaners() { diff --git a/test/unit/org/apache/cassandra/transport/ClientResourceLimitsTest.java b/test/unit/org/apache/cassandra/transport/ClientResourceLimitsTest.java index 8e94997239..10e1be1147 100644 --- a/test/unit/org/apache/cassandra/transport/ClientResourceLimitsTest.java +++ b/test/unit/org/apache/cassandra/transport/ClientResourceLimitsTest.java @@ -102,7 +102,6 @@ public class ClientResourceLimitsTest extends CQLTester } } - @SuppressWarnings("resource") private SimpleClient client(boolean throwOnOverload) { try @@ -119,7 +118,7 @@ public class ClientResourceLimitsTest extends CQLTester } } - @SuppressWarnings({"resource", "SameParameterValue"}) + @SuppressWarnings("SameParameterValue") private SimpleClient client(boolean throwOnOverload, int largeMessageThreshold) { try diff --git a/tools/stress/src/resources/org/apache/cassandra/stress/graph/graph.html b/tools/stress/resources/org/apache/cassandra/stress/graph/graph.html similarity index 100% rename from tools/stress/src/resources/org/apache/cassandra/stress/graph/graph.html rename to tools/stress/resources/org/apache/cassandra/stress/graph/graph.html diff --git a/tools/stress/src/org/apache/cassandra/io/sstable/StressCQLSSTableWriter.java b/tools/stress/src/org/apache/cassandra/io/sstable/StressCQLSSTableWriter.java index 30497fd687..e25f95e2c5 100644 --- a/tools/stress/src/org/apache/cassandra/io/sstable/StressCQLSSTableWriter.java +++ b/tools/stress/src/org/apache/cassandra/io/sstable/StressCQLSSTableWriter.java @@ -567,7 +567,6 @@ public class StressCQLSSTableWriter implements Closeable return this; } - @SuppressWarnings("resource") public StressCQLSSTableWriter build() { if (directoryList.isEmpty() && cfs == null) diff --git a/tools/stress/src/org/apache/cassandra/stress/StressAction.java b/tools/stress/src/org/apache/cassandra/stress/StressAction.java index f9912acf52..5cf429bcdc 100644 --- a/tools/stress/src/org/apache/cassandra/stress/StressAction.java +++ b/tools/stress/src/org/apache/cassandra/stress/StressAction.java @@ -102,7 +102,6 @@ public class StressAction implements Runnable } // type provided separately to support recursive call for mixed command with each command type it is performing - @SuppressWarnings("resource") // warmupOutput doesn't need closing private void warmup(OpDistributionFactory operations) { // do 25% of iterations as warmup but no more than 50k (by default hotspot compiles methods after 10k invocations)