You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@cassandra.apache.org by bl...@apache.org on 2021/02/15 13:46:51 UTC
[cassandra] branch trunk updated (7cddbd4 -> e8a9d42)
This is an automated email from the ASF dual-hosted git repository.
blerer pushed a change to branch trunk
in repository https://gitbox.apache.org/repos/asf/cassandra.git.
from 7cddbd4 Merge branch 'cassandra-3.11' into trunk
add 1f686fd Avoid pushing schema mutations when setting up distributed system keyspaces locally
add db6f6c9 Merge branch cassandra-3.0 into cassandra-3.11
new e8a9d42 Merge branch cassandra-3.11 into trunk
The 1 revisions listed above as "new" are entirely new to this
repository and will be described in separate emails. The revisions
listed as "add" were already present in the repository and have only
been added to this reference.
Summary of changes:
CHANGES.txt | 1 +
.../apache/cassandra/schema/MigrationManager.java | 7 ++++++-
.../apache/cassandra/service/StorageService.java | 13 +++++-------
.../distributed/impl/AbstractCluster.java | 4 ++++
.../test/InternodeEncryptionEnforcementTest.java | 24 ++++++++++++++++++++++
5 files changed, 40 insertions(+), 9 deletions(-)
---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@cassandra.apache.org
For additional commands, e-mail: commits-help@cassandra.apache.org
[cassandra] 01/01: Merge branch cassandra-3.11 into trunk
Posted by bl...@apache.org.
This is an automated email from the ASF dual-hosted git repository.
blerer pushed a commit to branch trunk
in repository https://gitbox.apache.org/repos/asf/cassandra.git
commit e8a9d4203c81e622fc2418d2faf2593e2123161e
Merge: 7cddbd4 db6f6c9
Author: Benjamin Lerer <b....@gmail.com>
AuthorDate: Mon Feb 15 14:35:56 2021 +0100
Merge branch cassandra-3.11 into trunk
CHANGES.txt | 1 +
.../apache/cassandra/schema/MigrationManager.java | 7 ++++++-
.../apache/cassandra/service/StorageService.java | 13 +++++-------
.../distributed/impl/AbstractCluster.java | 4 ++++
.../test/InternodeEncryptionEnforcementTest.java | 24 ++++++++++++++++++++++
5 files changed, 40 insertions(+), 9 deletions(-)
diff --cc CHANGES.txt
index 7b6a9f1,2387b1d..1f5cb1b
--- a/CHANGES.txt
+++ b/CHANGES.txt
@@@ -23,47 -8,14 +23,48 @@@ Merged from 3.11
* Fix digest computation for queries with fetched but non queried columns (CASSANDRA-15962)
* Reduce amount of allocations during batch statement execution (CASSANDRA-16201)
* Update jflex-1.6.0.jar to match upstream (CASSANDRA-16393)
- * Fix DecimalDeserializer#toString OOM (CASSANDRA-14925)
- * Rate limit validation compactions using compaction_throughput_mb_per_sec (CASSANDRA-16161)
- * SASI's `max_compaction_flush_memory_in_mb` settings over 100GB revert to default of 1GB (CASSANDRA-16071)
Merged from 3.0:
++ * Avoid pushing schema mutations when setting up distributed system keyspaces locally (CASSANDRA-16387)
* Prevent unbounded number of pending flushing tasks (CASSANDRA-16261)
* Improve empty hint file handling during startup (CASSANDRA-16162)
- * Allow empty string in collections with COPY FROM in cqlsh (CASSANDRA-16372)
* Fix skipping on pre-3.0 created compact storage sstables due to missing primary key liveness (CASSANDRA-16226)
+ * Allow empty string in collections with COPY FROM in cqlsh (CASSANDRA-16372)
+Merged from 2.2:
+ * Make TokenMetadata's ring version increments atomic (CASSANDRA-16286)
+
+4.0-beta4
+ * DROP COMPACT STORAGE should invalidate prepared statements still using CompactTableMetadata (CASSANDRA-16361)
+ * Update default num_tokens to 16 and allocate_tokens_for_local_replication_factor to 3 (CASSANDRA-13701)
+ * Remove use of String.intern() (CASSANDRA-15810)
+ * Fix the missing bb position in ByteBufferAccessor.getUnsignedShort (CASSANDRA-16249)
+ * Make sure OOM errors are rethrown on truncation failure (CASSANDRA-16254)
+ * Send back client warnings when creating too many tables/keyspaces (CASSANDRA-16309)
+ * Add dedicated tcp user timeout for streaming connection (CASSANDRA-16143)
+ * Add generatetokens script for offline token allocation strategy generation (CASSANDRA-16205)
+ * Remove Windows scripts (CASSANDRA-16171)
+ * Improve checksumming and compression in protocol V5 (CASSANDRA-15299)
+ * Optimised repair streaming improvements (CASSANDRA-16274)
+ * Update jctools dependency to 3.1.0 (CASSANDRA-16255)
+ * 'SSLEngine closed already' exception on failed outbound connection (CASSANDRA-16277)
+ * Drain and/or shutdown might throw because of slow messaging service shutdown (CASSANDRA-16276)
+ * Upgrade JNA to 5.6.0, dropping support for <=glibc-2.6 systems (CASSANDRA-16212)
+ * Add saved Host IDs to TokenMetadata at startup (CASSANDRA-16246)
+ * Ensure that CacheMetrics.requests is picked up by the metric reporter (CASSANDRA-16228)
+ * Add a ratelimiter to snapshot creation and deletion (CASSANDRA-13019)
+ * Produce consistent tombstone for reads to avoid digest mistmatch (CASSANDRA-15369)
+ * Fix SSTableloader issue when restoring a table named backups (CASSANDRA-16235)
+ * Invalid serialized size for responses caused by increasing message time by 1ms which caused extra bytes in size calculation (CASSANDRA-16103)
+ * Throw BufferOverflowException from DataOutputBuffer for better visibility (CASSANDRA-16214)
+ * TLS connections to the storage port on a node without server encryption configured causes java.io.IOException accessing missing keystore (CASSANDRA-16144)
+ * Internode messaging catches OOMs and does not rethrow (CASSANDRA-15214)
+ * When a table attempts to clean up metrics, it was cleaning up all global table metrics (CASSANDRA-16095)
+ * Bring back the accepted encryption protocols list as configurable option (CASSANDRA-13325)
+ * DigestResolver.getData throws AssertionError since dataResponse is null (CASSANDRA-16097)
+ * Cannot replace_address /X because it doesn't exist in gossip (CASSANDRA-16213)
+ * cqlsh row_id resets on page boundaries (CASSANDRA-16160)
+Merged from 3.11:
+ * SASI's `max_compaction_flush_memory_in_mb` settings over 100GB revert to default of 1GB (CASSANDRA-16071)
+Merged from 3.0:
* Extend the exclusion of replica filtering protection to other indices instead of just SASI (CASSANDRA-16311)
* Synchronize transaction logs for JBOD (CASSANDRA-16225)
* Fix the counting of cells per partition (CASSANDRA-16259)
diff --cc src/java/org/apache/cassandra/schema/MigrationManager.java
index c2ec511,0000000..87fb603
mode 100644,000000..100644
--- a/src/java/org/apache/cassandra/schema/MigrationManager.java
+++ b/src/java/org/apache/cassandra/schema/MigrationManager.java
@@@ -1,360 -1,0 +1,365 @@@
+/*
+ * 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.
+ */
+package org.apache.cassandra.schema;
+
+import java.io.IOException;
+import java.util.*;
+import java.util.concurrent.*;
+import java.lang.management.ManagementFactory;
+import java.util.function.LongSupplier;
+
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.util.concurrent.Futures;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import org.apache.cassandra.db.*;
+import org.apache.cassandra.exceptions.AlreadyExistsException;
+import org.apache.cassandra.exceptions.ConfigurationException;
+import org.apache.cassandra.gms.*;
+import org.apache.cassandra.io.IVersionedSerializer;
+import org.apache.cassandra.io.util.DataInputPlus;
+import org.apache.cassandra.io.util.DataOutputPlus;
+import org.apache.cassandra.locator.InetAddressAndPort;
+import org.apache.cassandra.net.Message;
+import org.apache.cassandra.net.MessagingService;
+import org.apache.cassandra.schema.Keyspaces.KeyspacesDiff;
+import org.apache.cassandra.utils.FBUtilities;
+
+import static org.apache.cassandra.concurrent.Stage.MIGRATION;
+import static org.apache.cassandra.net.Verb.SCHEMA_PUSH_REQ;
+
+public class MigrationManager
+{
+ private static final Logger logger = LoggerFactory.getLogger(MigrationManager.class);
+
+ public static final MigrationManager instance = new MigrationManager();
+
+ private static LongSupplier getUptimeFn = () -> ManagementFactory.getRuntimeMXBean().getUptime();
+
+ @VisibleForTesting
+ public static void setUptimeFn(LongSupplier supplier)
+ {
+ getUptimeFn = supplier;
+ }
+
+ private static final int MIGRATION_DELAY_IN_MS = 60000;
+
+ private static final int MIGRATION_TASK_WAIT_IN_SECONDS = Integer.parseInt(System.getProperty("cassandra.migration_task_wait_in_seconds", "1"));
+
+ private MigrationManager() {}
+
+ private static boolean shouldPushSchemaTo(InetAddressAndPort endpoint)
+ {
+ // only push schema to nodes with known and equal versions
+ return !endpoint.equals(FBUtilities.getBroadcastAddressAndPort())
+ && MessagingService.instance().versions.knows(endpoint)
+ && MessagingService.instance().versions.getRaw(endpoint) == MessagingService.current_version;
+ }
+
+ public static void announceNewKeyspace(KeyspaceMetadata ksm) throws ConfigurationException
+ {
+ announceNewKeyspace(ksm, false);
+ }
+
+ public static void announceNewKeyspace(KeyspaceMetadata ksm, boolean announceLocally) throws ConfigurationException
+ {
+ announceNewKeyspace(ksm, FBUtilities.timestampMicros(), announceLocally);
+ }
+
+ public static void announceNewKeyspace(KeyspaceMetadata ksm, long timestamp, boolean announceLocally) throws ConfigurationException
+ {
+ ksm.validate();
+
+ if (Schema.instance.getKeyspaceMetadata(ksm.name) != null)
+ throw new AlreadyExistsException(ksm.name);
+
+ logger.info("Create new Keyspace: {}", ksm);
+ announce(SchemaKeyspace.makeCreateKeyspaceMutation(ksm, timestamp), announceLocally);
+ }
+
+ public static void announceNewTable(TableMetadata cfm)
+ {
+ announceNewTable(cfm, true, FBUtilities.timestampMicros());
+ }
+
+ private static void announceNewTable(TableMetadata cfm, boolean throwOnDuplicate, long timestamp)
+ {
+ cfm.validate();
+
+ KeyspaceMetadata ksm = Schema.instance.getKeyspaceMetadata(cfm.keyspace);
+ if (ksm == null)
+ throw new ConfigurationException(String.format("Cannot add table '%s' to non existing keyspace '%s'.", cfm.name, cfm.keyspace));
+ // If we have a table or a view which has the same name, we can't add a new one
+ else if (throwOnDuplicate && ksm.getTableOrViewNullable(cfm.name) != null)
+ throw new AlreadyExistsException(cfm.keyspace, cfm.name);
+
+ logger.info("Create new table: {}", cfm);
+ announce(SchemaKeyspace.makeCreateTableMutation(ksm, cfm, timestamp), false);
+ }
+
+ static void announceKeyspaceUpdate(KeyspaceMetadata ksm)
+ {
+ ksm.validate();
+
+ KeyspaceMetadata oldKsm = Schema.instance.getKeyspaceMetadata(ksm.name);
+ if (oldKsm == null)
+ throw new ConfigurationException(String.format("Cannot update non existing keyspace '%s'.", ksm.name));
+
+ logger.info("Update Keyspace '{}' From {} To {}", ksm.name, oldKsm, ksm);
+ announce(SchemaKeyspace.makeCreateKeyspaceMutation(ksm.name, ksm.params, FBUtilities.timestampMicros()), false);
+ }
+
+ public static void announceTableUpdate(TableMetadata tm)
+ {
+ announceTableUpdate(tm, false);
+ }
+
+ public static void announceTableUpdate(TableMetadata updated, boolean announceLocally)
+ {
+ updated.validate();
+
+ TableMetadata current = Schema.instance.getTableMetadata(updated.keyspace, updated.name);
+ if (current == null)
+ throw new ConfigurationException(String.format("Cannot update non existing table '%s' in keyspace '%s'.", updated.name, updated.keyspace));
+ KeyspaceMetadata ksm = Schema.instance.getKeyspaceMetadata(current.keyspace);
+
+ updated.validateCompatibility(current);
+
+ long timestamp = FBUtilities.timestampMicros();
+
+ logger.info("Update table '{}/{}' From {} To {}", current.keyspace, current.name, current, updated);
+ Mutation.SimpleBuilder builder = SchemaKeyspace.makeUpdateTableMutation(ksm, current, updated, timestamp);
+
+ announce(builder, announceLocally);
+ }
+
+ static void announceKeyspaceDrop(String ksName)
+ {
+ KeyspaceMetadata oldKsm = Schema.instance.getKeyspaceMetadata(ksName);
+ if (oldKsm == null)
+ throw new ConfigurationException(String.format("Cannot drop non existing keyspace '%s'.", ksName));
+
+ logger.info("Drop Keyspace '{}'", oldKsm.name);
+ announce(SchemaKeyspace.makeDropKeyspaceMutation(oldKsm, FBUtilities.timestampMicros()), false);
+ }
+
+ public static void announceTableDrop(String ksName, String cfName, boolean announceLocally)
+ {
+ TableMetadata tm = Schema.instance.getTableMetadata(ksName, cfName);
+ if (tm == null)
+ throw new ConfigurationException(String.format("Cannot drop non existing table '%s' in keyspace '%s'.", cfName, ksName));
+ KeyspaceMetadata ksm = Schema.instance.getKeyspaceMetadata(ksName);
+
+ logger.info("Drop table '{}/{}'", tm.keyspace, tm.name);
+ announce(SchemaKeyspace.makeDropTableMutation(ksm, tm, FBUtilities.timestampMicros()), announceLocally);
+ }
+
+ /**
+ * actively announce a new version to active hosts via rpc
+ * @param schema The schema mutation to be applied
+ */
+ private static void announce(Mutation.SimpleBuilder schema, boolean announceLocally)
+ {
+ List<Mutation> mutations = Collections.singletonList(schema.build());
+
+ if (announceLocally)
+ Schema.instance.merge(mutations);
+ else
+ announce(mutations);
+ }
+
+ public static void announce(Mutation change)
+ {
+ announce(Collections.singleton(change));
+ }
+
+ public static void announce(Collection<Mutation> schema)
+ {
- Future<?> f = MIGRATION.submit(() -> Schema.instance.mergeAndAnnounceVersion(schema));
++ Future<?> f = announceWithoutPush(schema);
+
+ Set<InetAddressAndPort> schemaDestinationEndpoints = new HashSet<>();
+ Set<InetAddressAndPort> schemaEndpointsIgnored = new HashSet<>();
+ Message<Collection<Mutation>> message = Message.out(SCHEMA_PUSH_REQ, schema);
+ for (InetAddressAndPort endpoint : Gossiper.instance.getLiveMembers())
+ {
+ if (shouldPushSchemaTo(endpoint))
+ {
+ MessagingService.instance().send(message, endpoint);
+ schemaDestinationEndpoints.add(endpoint);
+ }
+ else
+ {
+ schemaEndpointsIgnored.add(endpoint);
+ }
+ }
+
+ SchemaAnnouncementDiagnostics.schemaMutationsAnnounced(schemaDestinationEndpoints, schemaEndpointsIgnored);
+ FBUtilities.waitOnFuture(f);
+ }
+
++ public static Future<?> announceWithoutPush(Collection<Mutation> schema)
++ {
++ return MIGRATION.submit(() -> Schema.instance.mergeAndAnnounceVersion(schema));
++ }
++
+ public static KeyspacesDiff announce(SchemaTransformation transformation, boolean locally)
+ {
+ long now = FBUtilities.timestampMicros();
+
+ Future<Schema.TransformationResult> future =
+ MIGRATION.submit(() -> Schema.instance.transform(transformation, locally, now));
+
+ Schema.TransformationResult result = Futures.getUnchecked(future);
+ if (!result.success)
+ throw result.exception;
+
+ if (locally || result.diff.isEmpty())
+ return result.diff;
+
+ Set<InetAddressAndPort> schemaDestinationEndpoints = new HashSet<>();
+ Set<InetAddressAndPort> schemaEndpointsIgnored = new HashSet<>();
+ Message<Collection<Mutation>> message = Message.out(SCHEMA_PUSH_REQ, result.mutations);
+ for (InetAddressAndPort endpoint : Gossiper.instance.getLiveMembers())
+ {
+ if (shouldPushSchemaTo(endpoint))
+ {
+ MessagingService.instance().send(message, endpoint);
+ schemaDestinationEndpoints.add(endpoint);
+ }
+ else
+ {
+ schemaEndpointsIgnored.add(endpoint);
+ }
+ }
+
+ SchemaAnnouncementDiagnostics.schemaTransformationAnnounced(schemaDestinationEndpoints, schemaEndpointsIgnored,
+ transformation);
+
+ return result.diff;
+ }
+
+ /**
+ * Clear all locally stored schema information and reset schema to initial state.
+ * Called by user (via JMX) who wants to get rid of schema disagreement.
+ */
+ public static void resetLocalSchema()
+ {
+ logger.info("Starting local schema reset...");
+
+ logger.debug("Truncating schema tables...");
+
+ SchemaMigrationDiagnostics.resetLocalSchema();
+
+ SchemaKeyspace.truncate();
+
+ logger.debug("Clearing local schema keyspace definitions...");
+
+ Schema.instance.clear();
+
+ Set<InetAddressAndPort> liveEndpoints = Gossiper.instance.getLiveMembers();
+ liveEndpoints.remove(FBUtilities.getBroadcastAddressAndPort());
+
+ // force migration if there are nodes around
+ for (InetAddressAndPort node : liveEndpoints)
+ {
+ EndpointState state = Gossiper.instance.getEndpointStateForEndpoint(node);
+ Future<Void> pull = MigrationCoordinator.instance.reportEndpointVersion(node, state);
+ if (pull != null)
+ FBUtilities.waitOnFuture(pull);
+ }
+
+ logger.info("Local schema reset is complete.");
+ }
+
+ /**
+ * We have a set of non-local, distributed system keyspaces, e.g. system_traces, system_auth, etc.
+ * (see {@link SchemaConstants#REPLICATED_SYSTEM_KEYSPACE_NAMES}), that need to be created on cluster initialisation,
+ * and later evolved on major upgrades (sometimes minor too). This method compares the current known definitions
+ * of the tables (if the keyspace exists) to the expected, most modern ones expected by the running version of C*;
+ * if any changes have been detected, a schema Mutation will be created which, when applied, should make
+ * cluster's view of that keyspace aligned with the expected modern definition.
+ *
+ * @param keyspace the expected modern definition of the keyspace
+ * @param generation timestamp to use for the table changes in the schema mutation
+ *
+ * @return empty Optional if the current definition is up to date, or an Optional with the Mutation that would
+ * bring the schema in line with the expected definition.
+ */
+ public static Optional<Mutation> evolveSystemKeyspace(KeyspaceMetadata keyspace, long generation)
+ {
+ Mutation.SimpleBuilder builder = null;
+
+ KeyspaceMetadata definedKeyspace = Schema.instance.getKeyspaceMetadata(keyspace.name);
+ Tables definedTables = null == definedKeyspace ? Tables.none() : definedKeyspace.tables;
+
+ for (TableMetadata table : keyspace.tables)
+ {
+ if (table.equals(definedTables.getNullable(table.name)))
+ continue;
+
+ if (null == builder)
+ {
+ // for the keyspace definition itself (name, replication, durability) always use generation 0;
+ // this ensures that any changes made to replication by the user will never be overwritten.
+ builder = SchemaKeyspace.makeCreateKeyspaceMutation(keyspace.name, keyspace.params, 0);
+
+ // now set the timestamp to generation, so the tables have the expected timestamp
+ builder.timestamp(generation);
+ }
+
+ // for table definitions always use the provided generation; these tables, unlike their containing
+ // keyspaces, are *NOT* meant to be altered by the user; if their definitions need to change,
+ // the schema must be updated in code, and the appropriate generation must be bumped.
+ SchemaKeyspace.addTableToSchemaMutation(table, true, builder);
+ }
+
+ return builder == null ? Optional.empty() : Optional.of(builder.build());
+ }
+
+ public static class MigrationsSerializer implements IVersionedSerializer<Collection<Mutation>>
+ {
+ public static MigrationsSerializer instance = new MigrationsSerializer();
+
+ public void serialize(Collection<Mutation> schema, DataOutputPlus out, int version) throws IOException
+ {
+ out.writeInt(schema.size());
+ for (Mutation mutation : schema)
+ Mutation.serializer.serialize(mutation, out, version);
+ }
+
+ public Collection<Mutation> deserialize(DataInputPlus in, int version) throws IOException
+ {
+ int count = in.readInt();
+ Collection<Mutation> schema = new ArrayList<>(count);
+
+ for (int i = 0; i < count; i++)
+ schema.add(Mutation.serializer.deserialize(in, version));
+
+ return schema;
+ }
+
+ public long serializedSize(Collection<Mutation> schema, int version)
+ {
+ int size = TypeSizes.sizeof(schema.size());
+ for (Mutation mutation : schema)
+ size += mutation.serializedSize(version);
+ return size;
+ }
+ }
+}
diff --cc src/java/org/apache/cassandra/service/StorageService.java
index 661b1a0,395d824..4328a6a
--- a/src/java/org/apache/cassandra/service/StorageService.java
+++ b/src/java/org/apache/cassandra/service/StorageService.java
@@@ -1078,16 -1111,17 +1078,10 @@@ public class StorageService extends Not
}
}
-- @VisibleForTesting
-- public void ensureTraceKeyspace()
-- {
- evolveSystemKeyspace(TraceKeyspace.metadata(), TraceKeyspace.GENERATION).ifPresent(MigrationManager::announce);
- Optional<Mutation> mutation = evolveSystemKeyspace(TraceKeyspace.metadata(), TraceKeyspace.GENERATION);
- mutation.ifPresent(value -> FBUtilities.waitOnFuture(MigrationManager.announceWithoutPush(Collections.singleton(value))));
-- }
--
public static boolean isReplacingSameAddress()
{
- InetAddress replaceAddress = DatabaseDescriptor.getReplaceAddress();
- return replaceAddress != null && replaceAddress.equals(FBUtilities.getBroadcastAddress());
+ InetAddressAndPort replaceAddress = DatabaseDescriptor.getReplaceAddress();
+ return replaceAddress != null && replaceAddress.equals(FBUtilities.getBroadcastAddressAndPort());
}
public void gossipSnitchInfo()
diff --cc test/distributed/org/apache/cassandra/distributed/test/InternodeEncryptionEnforcementTest.java
index 86a7c99,c51bf7b..969f372
--- a/test/distributed/org/apache/cassandra/distributed/test/InternodeEncryptionEnforcementTest.java
+++ b/test/distributed/org/apache/cassandra/distributed/test/InternodeEncryptionEnforcementTest.java
@@@ -26,14 -27,14 +26,17 @@@ import org.apache.cassandra.distributed
import org.apache.cassandra.distributed.api.Feature;
import org.apache.cassandra.distributed.api.IIsolatedExecutor.SerializableRunnable;
import org.apache.cassandra.distributed.shared.NetworkTopology;
+import org.apache.cassandra.net.InboundMessageHandlers;
import org.apache.cassandra.net.MessagingService;
+import org.apache.cassandra.net.OutboundConnections;
import static com.google.common.collect.Iterables.getOnlyElement;
++import static org.hamcrest.Matchers.containsString;
import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+ import static org.junit.Assert.assertThat;
import static org.junit.Assert.assertTrue;
+ import static org.junit.Assert.fail;
-import static org.junit.matchers.JUnitMatchers.containsString;
public final class InternodeEncryptionEnforcementTest extends TestBaseImpl
{
---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@cassandra.apache.org
For additional commands, e-mail: commits-help@cassandra.apache.org