From 0ca9f97ea8ac6891cc00ab41dbe1b1c141b053ad Mon Sep 17 00:00:00 2001
From: omniCoder77 <rishabhsaraswat17@gmail.com>
Date: Sun, 8 Mar 2026 10:05:59 +0530
Subject: [PATCH 1/6] CEP-59: Add graceful disconnect configuration properties

---
 conf/cassandra.yaml                           | 23 ++++++++
 .../org/apache/cassandra/config/Config.java   |  6 ++
 .../cassandra/config/DatabaseDescriptor.java  | 36 ++++++++++++
 .../cassandra/service/StorageService.java     | 42 ++++++++++++++
 .../service/StorageServiceMBean.java          |  8 +++
 .../config/DatabaseDescriptorTest.java        | 28 +++++++++
 .../cassandra/service/StorageServiceTest.java | 57 +++++++++++++++++++
 7 files changed, 200 insertions(+)

diff --git a/conf/cassandra.yaml b/conf/cassandra.yaml
index af65d54b4bb4..1ec5257212d3 100644
--- a/conf/cassandra.yaml
+++ b/conf/cassandra.yaml
@@ -1083,6 +1083,29 @@ native_transport_allow_older_protocols: true
 # native_transport_rate_limiting_enabled: false
 # native_transport_max_requests_per_second: 1000000
 
+# When enabled, nodes will signal connected clients before shutting down,
+# allowing in-flight requests to complete without client-visible timeouts.
+# This applies to intentional shutdowns (nodetool drain, rolling restarts,
+# controlled JVM shutdown). Clients must subscribe to the GRACEFUL_DISCONNECT
+# event via REGISTER to benefit from this behavior.
+#
+# Requires driver support for the GRACEFUL_DISCONNECT event type.
+# See: https://cwiki.apache.org/confluence/pages/viewpage.action?pageId=406619103
+
+# Enable or disable graceful disconnect. When false, shutdown behavior is
+# unchanged from previous versions.
+# graceful_disconnect_enabled: false
+
+# Time given to clients to stop sending new requests after the
+# GRACEFUL_DISCONNECT event is emitted. Must not exceed graceful_disconnect_max_drain_ms.
+# graceful_disconnect_grace_period_ms: 5000
+
+# Hard timeout for draining connections. Once this limit is reached,
+# remaining connections are force-closed regardless of in-flight requests.
+# Must be greater than 0 when graceful_disconnect_enabled is true.
+# graceful_disconnect_max_drain_ms: 30000
+
+
 # The address or interface to bind the native transport server to.
 #
 # Set rpc_address OR rpc_interface, not both.
diff --git a/src/java/org/apache/cassandra/config/Config.java b/src/java/org/apache/cassandra/config/Config.java
index dd75d910c830..1902d5ab2049 100644
--- a/src/java/org/apache/cassandra/config/Config.java
+++ b/src/java/org/apache/cassandra/config/Config.java
@@ -167,6 +167,12 @@ public static Set<String> splitCommaDelimited(String src)
 
     public volatile DurationSpec.LongMillisecondsBound accord_preaccept_timeout = new DurationSpec.LongMillisecondsBound("1s");
 
+    public boolean graceful_disconnect_enabled = false;
+
+    public volatile DurationSpec.LongMillisecondsBound graceful_disconnect_grace_period_ms = new  DurationSpec.LongMillisecondsBound("5s");
+
+    public volatile DurationSpec.LongMillisecondsBound graceful_disconnect_max_drain_ms = new  DurationSpec.LongMillisecondsBound("30s");
+
     @Replaces(oldName = "truncate_request_timeout_in_ms", converter = Converters.MILLIS_DURATION_LONG, deprecated = true)
     public volatile DurationSpec.LongMillisecondsBound truncate_request_timeout = new DurationSpec.LongMillisecondsBound("60000ms");
 
diff --git a/src/java/org/apache/cassandra/config/DatabaseDescriptor.java b/src/java/org/apache/cassandra/config/DatabaseDescriptor.java
index bafe1715e752..29386f347347 100644
--- a/src/java/org/apache/cassandra/config/DatabaseDescriptor.java
+++ b/src/java/org/apache/cassandra/config/DatabaseDescriptor.java
@@ -685,6 +685,17 @@ else if (DiskAccessMode.direct == conf.compaction_read_disk_access_mode)
             throw new ConfigurationException("phi_convict_threshold must be between 5 and 16, but was " + conf.phi_convict_threshold, false);
         }
 
+        if (conf.graceful_disconnect_enabled && conf.graceful_disconnect_max_drain_ms.toMilliseconds() <= 0)
+        {
+            throw new ConfigurationException("graceful_disconnect_max_drain_ms must be greater than 0 when graceful_disconnect_enabled is set to true.", false);
+        }
+
+        if (conf.graceful_disconnect_enabled &&
+            conf.graceful_disconnect_grace_period_ms.toMilliseconds() > conf.graceful_disconnect_max_drain_ms.toMilliseconds())
+        {
+            throw new ConfigurationException("graceful_disconnect_grace_period_ms cannot exceed graceful_disconnect_max_drain_ms.", false);
+        }
+
         /* Thread per pool */
         if (conf.concurrent_reads < 2)
         {
@@ -2634,6 +2645,31 @@ public static void setRpcTimeout(long timeOutInMillis)
         conf.request_timeout = new DurationSpec.LongMillisecondsBound(timeOutInMillis);
     }
 
+    public static long getGracefulDisconnectGracePeriodMs()
+    {
+        return conf.graceful_disconnect_grace_period_ms.toMilliseconds();
+    }
+
+    public static void setGracefulDisconnectGracePeriodMs(long gracefulDisconnectGracePeriodMs)
+    {
+        conf.graceful_disconnect_grace_period_ms = new DurationSpec.LongMillisecondsBound(gracefulDisconnectGracePeriodMs);
+    }
+
+    public static long getGracefulDisconnectMaxDrainMs()
+    {
+        return conf.graceful_disconnect_max_drain_ms.toMilliseconds();
+    }
+
+    public static void setGracefulDisconnectMaxDrainMs(long gracefulDisconnectMaxDrainMs)
+    {
+        conf.graceful_disconnect_max_drain_ms = new DurationSpec.LongMillisecondsBound(gracefulDisconnectMaxDrainMs);
+    }
+
+    public static boolean getGracefulDisconnectEnabled()
+    {
+        return conf.graceful_disconnect_enabled;
+    }
+
     public static long getReadRpcTimeout(TimeUnit unit)
     {
         return conf.read_request_timeout.to(unit);
diff --git a/src/java/org/apache/cassandra/service/StorageService.java b/src/java/org/apache/cassandra/service/StorageService.java
index b7460b1be50e..6b13ed7a2e28 100644
--- a/src/java/org/apache/cassandra/service/StorageService.java
+++ b/src/java/org/apache/cassandra/service/StorageService.java
@@ -1201,6 +1201,48 @@ public long getRpcTimeout()
         return DatabaseDescriptor.getRpcTimeout(MILLISECONDS);
     }
 
+    @Override
+    public void setGracefulDisconnectGracePeriodMs(long value)
+    {
+        if (value > DatabaseDescriptor.getGracefulDisconnectMaxDrainMs())
+            throw new IllegalArgumentException("graceful_disconnect_grace_period_ms cannot exceed graceful_disconnect_max_drain_ms.");
+
+        DatabaseDescriptor.setGracefulDisconnectGracePeriodMs(value);
+        logger.info("set graceful disconnect grace period to {} ms", value);
+    }
+
+    @Override
+    public long getGracefulDisconnectGracePeriodMs()
+    {
+        return DatabaseDescriptor.getGracefulDisconnectGracePeriodMs();
+    }
+
+    @Override
+    public void setGracefulDisconnectMaxDrainMs(long value)
+    {
+        if (value <= 0)
+            throw new IllegalArgumentException("graceful_disconnect_max_drain_ms must be greater than 0 when graceful_disconnect_enabled is set to true.");
+
+        if (value < DatabaseDescriptor.getGracefulDisconnectGracePeriodMs())
+            throw new IllegalArgumentException("graceful_disconnect_max_drain_ms cannot be less than graceful_disconnect_grace_period_ms.");
+
+        DatabaseDescriptor.setGracefulDisconnectMaxDrainMs(value);
+        logger.info("set graceful disconnect max drain to {} ms", value);
+    }
+
+
+    @Override
+    public long getGracefulDisconnectMaxDrainMs()
+    {
+        return DatabaseDescriptor.getGracefulDisconnectMaxDrainMs();
+    }
+
+    @Override
+    public boolean getGracefulDisconnectEnabled()
+    {
+        return DatabaseDescriptor.getGracefulDisconnectEnabled();
+    }
+
     public void setReadRpcTimeout(long value)
     {
         DatabaseDescriptor.setReadRpcTimeout(value);
diff --git a/src/java/org/apache/cassandra/service/StorageServiceMBean.java b/src/java/org/apache/cassandra/service/StorageServiceMBean.java
index b9f47b3b2dd6..878abd7bdbf1 100644
--- a/src/java/org/apache/cassandra/service/StorageServiceMBean.java
+++ b/src/java/org/apache/cassandra/service/StorageServiceMBean.java
@@ -773,6 +773,14 @@ default int upgradeSSTables(String keyspaceName, boolean excludeCurrentVersion,
     public void setRpcTimeout(long value);
     public long getRpcTimeout();
 
+    void setGracefulDisconnectGracePeriodMs(long value);
+    long getGracefulDisconnectGracePeriodMs();
+
+    void setGracefulDisconnectMaxDrainMs(long value);
+    long getGracefulDisconnectMaxDrainMs();
+
+    boolean getGracefulDisconnectEnabled();
+
     public void setReadRpcTimeout(long value);
     public long getReadRpcTimeout();
 
diff --git a/test/unit/org/apache/cassandra/config/DatabaseDescriptorTest.java b/test/unit/org/apache/cassandra/config/DatabaseDescriptorTest.java
index 2a44e763e007..b4167768418f 100644
--- a/test/unit/org/apache/cassandra/config/DatabaseDescriptorTest.java
+++ b/test/unit/org/apache/cassandra/config/DatabaseDescriptorTest.java
@@ -791,6 +791,34 @@ public void testRowIndexSizeWarnEnabledAbortDisabled()
         DatabaseDescriptor.applyThresholdsValidations(conf);
     }
 
+    @Test
+    public void testGracefulDisconnectEnabled()
+    {
+        Config config = new Config();
+        boolean originalValue = config.graceful_disconnect_enabled;
+        Assert.assertFalse("Default value of graceful_disconnect_enabled must be false", originalValue);
+    }
+
+    @Test
+    public void testGracefulDisconnectGracePeriodMs()
+    {
+        long originalValue = DatabaseDescriptor.getGracefulDisconnectGracePeriodMs();
+        Assert.assertEquals("Default value of graceful_disconnect_grace_period_ms must be 5000", 5000, originalValue);
+        DatabaseDescriptor.setGracefulDisconnectGracePeriodMs(3000);
+        Assert.assertEquals("graceful_disconnect_grace_period_ms should be updated to 3000", 3000, DatabaseDescriptor.getGracefulDisconnectGracePeriodMs());
+        DatabaseDescriptor.setGracefulDisconnectGracePeriodMs(originalValue);
+    }
+
+    @Test
+    public void testGracefulDisconnectMaxDrainMs()
+    {
+        long originalValue = DatabaseDescriptor.getGracefulDisconnectMaxDrainMs();
+        Assert.assertEquals("Default value of graceful_disconnect_max_drain_ms must be 30000", 30000, originalValue);
+        DatabaseDescriptor.setGracefulDisconnectMaxDrainMs(45000);
+        Assert.assertEquals("graceful_disconnect_max_drain_ms should be updated to 45000", 45000, DatabaseDescriptor.getGracefulDisconnectMaxDrainMs());
+        DatabaseDescriptor.setGracefulDisconnectMaxDrainMs(originalValue);
+    }
+
     @Test
     public void testRowIndexSizeAbortEnabledWarnDisabled()
     {
diff --git a/test/unit/org/apache/cassandra/service/StorageServiceTest.java b/test/unit/org/apache/cassandra/service/StorageServiceTest.java
index 8742cdac2395..3224175754e0 100644
--- a/test/unit/org/apache/cassandra/service/StorageServiceTest.java
+++ b/test/unit/org/apache/cassandra/service/StorageServiceTest.java
@@ -201,6 +201,63 @@ public void testColumnIndexSizeInKiB()
         }
     }
 
+    @Test
+    public void testGracefulDisconnectMaxDrainMs()
+    {
+        StorageService storageService = StorageService.instance;
+        long originalMaxDrainMs = storageService.getGracefulDisconnectMaxDrainMs();
+        long originalGracePeriodMs = storageService.getGracefulDisconnectGracePeriodMs();
+        try
+        {
+            storageService.setGracefulDisconnectGracePeriodMs(1000);
+
+            storageService.setGracefulDisconnectMaxDrainMs(10000);
+            assertEquals(10000, storageService.getGracefulDisconnectMaxDrainMs());
+            try
+            {
+                storageService.setGracefulDisconnectMaxDrainMs(0);
+                fail("Should have received an IllegalArgumentException for max_drain_ms of 0");
+            }
+            catch (IllegalArgumentException ignored)
+            {
+            }
+            assertEquals(10000, storageService.getGracefulDisconnectMaxDrainMs());
+        }
+        finally
+        {
+            storageService.setGracefulDisconnectMaxDrainMs(originalMaxDrainMs);
+            storageService.setGracefulDisconnectGracePeriodMs(originalGracePeriodMs);
+        }
+    }
+
+    @Test
+    public void testGracefulDisconnectGracePeriodMs()
+    {
+        StorageService storageService = StorageService.instance;
+        long originalMaxDrainMs = storageService.getGracefulDisconnectMaxDrainMs();
+        long originalGracePeriodMs = storageService.getGracefulDisconnectGracePeriodMs();
+        try
+        {
+            storageService.setGracefulDisconnectMaxDrainMs(20000);
+
+            storageService.setGracefulDisconnectGracePeriodMs(5000);
+            assertEquals(5000, storageService.getGracefulDisconnectGracePeriodMs());
+
+            try
+            {
+                storageService.setGracefulDisconnectGracePeriodMs(30000);
+                fail("Should have received an IllegalArgumentException when grace_period_ms exceeds max_drain_ms");
+            }
+            catch (IllegalArgumentException ignored) {}
+            assertEquals(5000, storageService.getGracefulDisconnectGracePeriodMs());
+        }
+        finally
+        {
+            storageService.setGracefulDisconnectMaxDrainMs(originalMaxDrainMs);
+            storageService.setGracefulDisconnectGracePeriodMs(originalGracePeriodMs);
+        }
+    }
+
     @Test
     public void testColumnIndexCacheSizeInKiB()
     {

From 5e539c17b209397e56701da37547e32b3d85ea74 Mon Sep 17 00:00:00 2001
From: omniCoder77 <rishabhsaraswat17@gmail.com>
Date: Tue, 17 Mar 2026 20:28:30 +0530
Subject: [PATCH 2/6] Expose graceful disconnect metrics in StorageServiceMBean

Explicitly set public visibility for graceful disconnect getter and
setter methods in StorageServiceMBean to ensure consistent JMX
accessibility.
---
 .../apache/cassandra/service/StorageServiceMBean.java  | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/src/java/org/apache/cassandra/service/StorageServiceMBean.java b/src/java/org/apache/cassandra/service/StorageServiceMBean.java
index 878abd7bdbf1..ad8303d24f36 100644
--- a/src/java/org/apache/cassandra/service/StorageServiceMBean.java
+++ b/src/java/org/apache/cassandra/service/StorageServiceMBean.java
@@ -773,13 +773,13 @@ default int upgradeSSTables(String keyspaceName, boolean excludeCurrentVersion,
     public void setRpcTimeout(long value);
     public long getRpcTimeout();
 
-    void setGracefulDisconnectGracePeriodMs(long value);
-    long getGracefulDisconnectGracePeriodMs();
+    public void setGracefulDisconnectGracePeriodMs(long value);
+    public long getGracefulDisconnectGracePeriodMs();
 
-    void setGracefulDisconnectMaxDrainMs(long value);
-    long getGracefulDisconnectMaxDrainMs();
+    public void setGracefulDisconnectMaxDrainMs(long value);
+    public long getGracefulDisconnectMaxDrainMs();
 
-    boolean getGracefulDisconnectEnabled();
+    public boolean getGracefulDisconnectEnabled();
 
     public void setReadRpcTimeout(long value);
     public long getReadRpcTimeout();

From 6b527b9e1d8b94b52dd2d047434ba790447a310f Mon Sep 17 00:00:00 2001
From: omniCoder77 <rishabhsaraswat17@gmail.com>
Date: Thu, 19 Mar 2026 03:07:03 +0530
Subject: [PATCH 3/6] removed _ms from flags

---
 conf/cassandra.yaml                           |  6 +--
 .../org/apache/cassandra/config/Config.java   |  4 +-
 .../cassandra/config/DatabaseDescriptor.java  | 24 +++++-----
 .../cassandra/service/StorageService.java     | 26 +++++------
 .../service/StorageServiceMBean.java          |  8 ++--
 .../config/DatabaseDescriptorTest.java        | 24 +++++-----
 .../cassandra/service/StorageServiceTest.java | 44 +++++++++----------
 7 files changed, 68 insertions(+), 68 deletions(-)

diff --git a/conf/cassandra.yaml b/conf/cassandra.yaml
index 1ec5257212d3..ddb941b3880a 100644
--- a/conf/cassandra.yaml
+++ b/conf/cassandra.yaml
@@ -1097,13 +1097,13 @@ native_transport_allow_older_protocols: true
 # graceful_disconnect_enabled: false
 
 # Time given to clients to stop sending new requests after the
-# GRACEFUL_DISCONNECT event is emitted. Must not exceed graceful_disconnect_max_drain_ms.
-# graceful_disconnect_grace_period_ms: 5000
+# GRACEFUL_DISCONNECT event is emitted. Must not exceed graceful_disconnect_max_drain.
+# graceful_disconnect_grace_period: 5000
 
 # Hard timeout for draining connections. Once this limit is reached,
 # remaining connections are force-closed regardless of in-flight requests.
 # Must be greater than 0 when graceful_disconnect_enabled is true.
-# graceful_disconnect_max_drain_ms: 30000
+# graceful_disconnect_max_drain: 30000
 
 
 # The address or interface to bind the native transport server to.
diff --git a/src/java/org/apache/cassandra/config/Config.java b/src/java/org/apache/cassandra/config/Config.java
index 1902d5ab2049..20235cb6d678 100644
--- a/src/java/org/apache/cassandra/config/Config.java
+++ b/src/java/org/apache/cassandra/config/Config.java
@@ -169,9 +169,9 @@ public static Set<String> splitCommaDelimited(String src)
 
     public boolean graceful_disconnect_enabled = false;
 
-    public volatile DurationSpec.LongMillisecondsBound graceful_disconnect_grace_period_ms = new  DurationSpec.LongMillisecondsBound("5s");
+    public volatile DurationSpec.LongMillisecondsBound graceful_disconnect_grace_period = new  DurationSpec.LongMillisecondsBound("5s");
 
-    public volatile DurationSpec.LongMillisecondsBound graceful_disconnect_max_drain_ms = new  DurationSpec.LongMillisecondsBound("30s");
+    public volatile DurationSpec.LongMillisecondsBound graceful_disconnect_max_drain = new  DurationSpec.LongMillisecondsBound("30s");
 
     @Replaces(oldName = "truncate_request_timeout_in_ms", converter = Converters.MILLIS_DURATION_LONG, deprecated = true)
     public volatile DurationSpec.LongMillisecondsBound truncate_request_timeout = new DurationSpec.LongMillisecondsBound("60000ms");
diff --git a/src/java/org/apache/cassandra/config/DatabaseDescriptor.java b/src/java/org/apache/cassandra/config/DatabaseDescriptor.java
index 29386f347347..d2ad7d5067a4 100644
--- a/src/java/org/apache/cassandra/config/DatabaseDescriptor.java
+++ b/src/java/org/apache/cassandra/config/DatabaseDescriptor.java
@@ -685,15 +685,15 @@ else if (DiskAccessMode.direct == conf.compaction_read_disk_access_mode)
             throw new ConfigurationException("phi_convict_threshold must be between 5 and 16, but was " + conf.phi_convict_threshold, false);
         }
 
-        if (conf.graceful_disconnect_enabled && conf.graceful_disconnect_max_drain_ms.toMilliseconds() <= 0)
+        if (conf.graceful_disconnect_enabled && conf.graceful_disconnect_max_drain.toMilliseconds() <= 0)
         {
-            throw new ConfigurationException("graceful_disconnect_max_drain_ms must be greater than 0 when graceful_disconnect_enabled is set to true.", false);
+            throw new ConfigurationException("graceful_disconnect_max_drain must be greater than 0 when graceful_disconnect_enabled is set to true.", false);
         }
 
         if (conf.graceful_disconnect_enabled &&
-            conf.graceful_disconnect_grace_period_ms.toMilliseconds() > conf.graceful_disconnect_max_drain_ms.toMilliseconds())
+            conf.graceful_disconnect_grace_period.toMilliseconds() > conf.graceful_disconnect_max_drain.toMilliseconds())
         {
-            throw new ConfigurationException("graceful_disconnect_grace_period_ms cannot exceed graceful_disconnect_max_drain_ms.", false);
+            throw new ConfigurationException("graceful_disconnect_grace_period cannot exceed graceful_disconnect_max_drain.", false);
         }
 
         /* Thread per pool */
@@ -2645,24 +2645,24 @@ public static void setRpcTimeout(long timeOutInMillis)
         conf.request_timeout = new DurationSpec.LongMillisecondsBound(timeOutInMillis);
     }
 
-    public static long getGracefulDisconnectGracePeriodMs()
+    public static long getGracefulDisconnectGracePeriod()
     {
-        return conf.graceful_disconnect_grace_period_ms.toMilliseconds();
+        return conf.graceful_disconnect_grace_period.toMilliseconds();
     }
 
-    public static void setGracefulDisconnectGracePeriodMs(long gracefulDisconnectGracePeriodMs)
+    public static void setGracefulDisconnectGracePeriod(long gracefulDisconnectGracePeriod)
     {
-        conf.graceful_disconnect_grace_period_ms = new DurationSpec.LongMillisecondsBound(gracefulDisconnectGracePeriodMs);
+        conf.graceful_disconnect_grace_period = new DurationSpec.LongMillisecondsBound(gracefulDisconnectGracePeriod);
     }
 
-    public static long getGracefulDisconnectMaxDrainMs()
+    public static long getGracefulDisconnectMaxDrain()
     {
-        return conf.graceful_disconnect_max_drain_ms.toMilliseconds();
+        return conf.graceful_disconnect_max_drain.toMilliseconds();
     }
 
-    public static void setGracefulDisconnectMaxDrainMs(long gracefulDisconnectMaxDrainMs)
+    public static void setGracefulDisconnectMaxDrain(long gracefulDisconnectMaxDrain)
     {
-        conf.graceful_disconnect_max_drain_ms = new DurationSpec.LongMillisecondsBound(gracefulDisconnectMaxDrainMs);
+        conf.graceful_disconnect_max_drain = new DurationSpec.LongMillisecondsBound(gracefulDisconnectMaxDrain);
     }
 
     public static boolean getGracefulDisconnectEnabled()
diff --git a/src/java/org/apache/cassandra/service/StorageService.java b/src/java/org/apache/cassandra/service/StorageService.java
index 6b13ed7a2e28..7638799a8075 100644
--- a/src/java/org/apache/cassandra/service/StorageService.java
+++ b/src/java/org/apache/cassandra/service/StorageService.java
@@ -1202,39 +1202,39 @@ public long getRpcTimeout()
     }
 
     @Override
-    public void setGracefulDisconnectGracePeriodMs(long value)
+    public void setGracefulDisconnectGracePeriod(long value)
     {
-        if (value > DatabaseDescriptor.getGracefulDisconnectMaxDrainMs())
-            throw new IllegalArgumentException("graceful_disconnect_grace_period_ms cannot exceed graceful_disconnect_max_drain_ms.");
+        if (value > DatabaseDescriptor.getGracefulDisconnectMaxDrain())
+            throw new IllegalArgumentException("graceful_disconnect_grace_period cannot exceed graceful_disconnect_max_drain.");
 
-        DatabaseDescriptor.setGracefulDisconnectGracePeriodMs(value);
+        DatabaseDescriptor.setGracefulDisconnectGracePeriod(value);
         logger.info("set graceful disconnect grace period to {} ms", value);
     }
 
     @Override
-    public long getGracefulDisconnectGracePeriodMs()
+    public long getGracefulDisconnectGracePeriod()
     {
-        return DatabaseDescriptor.getGracefulDisconnectGracePeriodMs();
+        return DatabaseDescriptor.getGracefulDisconnectGracePeriod();
     }
 
     @Override
-    public void setGracefulDisconnectMaxDrainMs(long value)
+    public void setGracefulDisconnectMaxDrain(long value)
     {
         if (value <= 0)
-            throw new IllegalArgumentException("graceful_disconnect_max_drain_ms must be greater than 0 when graceful_disconnect_enabled is set to true.");
+            throw new IllegalArgumentException("graceful_disconnect_max_drain must be greater than 0 when graceful_disconnect_enabled is set to true.");
 
-        if (value < DatabaseDescriptor.getGracefulDisconnectGracePeriodMs())
-            throw new IllegalArgumentException("graceful_disconnect_max_drain_ms cannot be less than graceful_disconnect_grace_period_ms.");
+        if (value < DatabaseDescriptor.getGracefulDisconnectGracePeriod())
+            throw new IllegalArgumentException("graceful_disconnect_max_drain cannot be less than graceful_disconnect_grace_period.");
 
-        DatabaseDescriptor.setGracefulDisconnectMaxDrainMs(value);
+        DatabaseDescriptor.setGracefulDisconnectMaxDrain(value);
         logger.info("set graceful disconnect max drain to {} ms", value);
     }
 
 
     @Override
-    public long getGracefulDisconnectMaxDrainMs()
+    public long getGracefulDisconnectMaxDrain()
     {
-        return DatabaseDescriptor.getGracefulDisconnectMaxDrainMs();
+        return DatabaseDescriptor.getGracefulDisconnectMaxDrain();
     }
 
     @Override
diff --git a/src/java/org/apache/cassandra/service/StorageServiceMBean.java b/src/java/org/apache/cassandra/service/StorageServiceMBean.java
index ad8303d24f36..74fd37d71299 100644
--- a/src/java/org/apache/cassandra/service/StorageServiceMBean.java
+++ b/src/java/org/apache/cassandra/service/StorageServiceMBean.java
@@ -773,11 +773,11 @@ default int upgradeSSTables(String keyspaceName, boolean excludeCurrentVersion,
     public void setRpcTimeout(long value);
     public long getRpcTimeout();
 
-    public void setGracefulDisconnectGracePeriodMs(long value);
-    public long getGracefulDisconnectGracePeriodMs();
+    public void setGracefulDisconnectGracePeriod(long value);
+    public long getGracefulDisconnectGracePeriod();
 
-    public void setGracefulDisconnectMaxDrainMs(long value);
-    public long getGracefulDisconnectMaxDrainMs();
+    public void setGracefulDisconnectMaxDrain(long value);
+    public long getGracefulDisconnectMaxDrain();
 
     public boolean getGracefulDisconnectEnabled();
 
diff --git a/test/unit/org/apache/cassandra/config/DatabaseDescriptorTest.java b/test/unit/org/apache/cassandra/config/DatabaseDescriptorTest.java
index b4167768418f..f8c07b458228 100644
--- a/test/unit/org/apache/cassandra/config/DatabaseDescriptorTest.java
+++ b/test/unit/org/apache/cassandra/config/DatabaseDescriptorTest.java
@@ -800,23 +800,23 @@ public void testGracefulDisconnectEnabled()
     }
 
     @Test
-    public void testGracefulDisconnectGracePeriodMs()
+    public void testGracefulDisconnectGracePeriod()
     {
-        long originalValue = DatabaseDescriptor.getGracefulDisconnectGracePeriodMs();
-        Assert.assertEquals("Default value of graceful_disconnect_grace_period_ms must be 5000", 5000, originalValue);
-        DatabaseDescriptor.setGracefulDisconnectGracePeriodMs(3000);
-        Assert.assertEquals("graceful_disconnect_grace_period_ms should be updated to 3000", 3000, DatabaseDescriptor.getGracefulDisconnectGracePeriodMs());
-        DatabaseDescriptor.setGracefulDisconnectGracePeriodMs(originalValue);
+        long originalValue = DatabaseDescriptor.getGracefulDisconnectGracePeriod();
+        Assert.assertEquals("Default value of graceful_disconnect_grace_period must be 5000", 5000, originalValue);
+        DatabaseDescriptor.setGracefulDisconnectGracePeriod(3000);
+        Assert.assertEquals("graceful_disconnect_grace_period should be updated to 3000", 3000, DatabaseDescriptor.getGracefulDisconnectGracePeriod());
+        DatabaseDescriptor.setGracefulDisconnectGracePeriod(originalValue);
     }
 
     @Test
-    public void testGracefulDisconnectMaxDrainMs()
+    public void testGracefulDisconnectMaxDrain()
     {
-        long originalValue = DatabaseDescriptor.getGracefulDisconnectMaxDrainMs();
-        Assert.assertEquals("Default value of graceful_disconnect_max_drain_ms must be 30000", 30000, originalValue);
-        DatabaseDescriptor.setGracefulDisconnectMaxDrainMs(45000);
-        Assert.assertEquals("graceful_disconnect_max_drain_ms should be updated to 45000", 45000, DatabaseDescriptor.getGracefulDisconnectMaxDrainMs());
-        DatabaseDescriptor.setGracefulDisconnectMaxDrainMs(originalValue);
+        long originalValue = DatabaseDescriptor.getGracefulDisconnectMaxDrain();
+        Assert.assertEquals("Default value of graceful_disconnect_max_drain must be 30000", 30000, originalValue);
+        DatabaseDescriptor.setGracefulDisconnectMaxDrain(45000);
+        Assert.assertEquals("graceful_disconnect_max_drain should be updated to 45000", 45000, DatabaseDescriptor.getGracefulDisconnectMaxDrain());
+        DatabaseDescriptor.setGracefulDisconnectMaxDrain(originalValue);
     }
 
     @Test
diff --git a/test/unit/org/apache/cassandra/service/StorageServiceTest.java b/test/unit/org/apache/cassandra/service/StorageServiceTest.java
index 3224175754e0..27074c223cfb 100644
--- a/test/unit/org/apache/cassandra/service/StorageServiceTest.java
+++ b/test/unit/org/apache/cassandra/service/StorageServiceTest.java
@@ -202,59 +202,59 @@ public void testColumnIndexSizeInKiB()
     }
 
     @Test
-    public void testGracefulDisconnectMaxDrainMs()
+    public void testGracefulDisconnectMaxDrain()
     {
         StorageService storageService = StorageService.instance;
-        long originalMaxDrainMs = storageService.getGracefulDisconnectMaxDrainMs();
-        long originalGracePeriodMs = storageService.getGracefulDisconnectGracePeriodMs();
+        long originalMaxDrain = storageService.getGracefulDisconnectMaxDrain();
+        long originalGracePeriod = storageService.getGracefulDisconnectGracePeriod();
         try
         {
-            storageService.setGracefulDisconnectGracePeriodMs(1000);
+            storageService.setGracefulDisconnectGracePeriod(1000);
 
-            storageService.setGracefulDisconnectMaxDrainMs(10000);
-            assertEquals(10000, storageService.getGracefulDisconnectMaxDrainMs());
+            storageService.setGracefulDisconnectMaxDrain(10000);
+            assertEquals(10000, storageService.getGracefulDisconnectMaxDrain());
             try
             {
-                storageService.setGracefulDisconnectMaxDrainMs(0);
-                fail("Should have received an IllegalArgumentException for max_drain_ms of 0");
+                storageService.setGracefulDisconnectMaxDrain(0);
+                fail("Should have received an IllegalArgumentException for max_drain of 0");
             }
             catch (IllegalArgumentException ignored)
             {
             }
-            assertEquals(10000, storageService.getGracefulDisconnectMaxDrainMs());
+            assertEquals(10000, storageService.getGracefulDisconnectMaxDrain());
         }
         finally
         {
-            storageService.setGracefulDisconnectMaxDrainMs(originalMaxDrainMs);
-            storageService.setGracefulDisconnectGracePeriodMs(originalGracePeriodMs);
+            storageService.setGracefulDisconnectMaxDrain(originalMaxDrain);
+            storageService.setGracefulDisconnectGracePeriod(originalGracePeriod);
         }
     }
 
     @Test
-    public void testGracefulDisconnectGracePeriodMs()
+    public void testGracefulDisconnectGracePeriod()
     {
         StorageService storageService = StorageService.instance;
-        long originalMaxDrainMs = storageService.getGracefulDisconnectMaxDrainMs();
-        long originalGracePeriodMs = storageService.getGracefulDisconnectGracePeriodMs();
+        long originalMaxDrain = storageService.getGracefulDisconnectMaxDrain();
+        long originalGracePeriod = storageService.getGracefulDisconnectGracePeriod();
         try
         {
-            storageService.setGracefulDisconnectMaxDrainMs(20000);
+            storageService.setGracefulDisconnectMaxDrain(20000);
 
-            storageService.setGracefulDisconnectGracePeriodMs(5000);
-            assertEquals(5000, storageService.getGracefulDisconnectGracePeriodMs());
+            storageService.setGracefulDisconnectGracePeriod(5000);
+            assertEquals(5000, storageService.getGracefulDisconnectGracePeriod());
 
             try
             {
-                storageService.setGracefulDisconnectGracePeriodMs(30000);
-                fail("Should have received an IllegalArgumentException when grace_period_ms exceeds max_drain_ms");
+                storageService.setGracefulDisconnectGracePeriod(30000);
+                fail("Should have received an IllegalArgumentException when grace_period exceeds max_drain");
             }
             catch (IllegalArgumentException ignored) {}
-            assertEquals(5000, storageService.getGracefulDisconnectGracePeriodMs());
+            assertEquals(5000, storageService.getGracefulDisconnectGracePeriod());
         }
         finally
         {
-            storageService.setGracefulDisconnectMaxDrainMs(originalMaxDrainMs);
-            storageService.setGracefulDisconnectGracePeriodMs(originalGracePeriodMs);
+            storageService.setGracefulDisconnectMaxDrain(originalMaxDrain);
+            storageService.setGracefulDisconnectGracePeriod(originalGracePeriod);
         }
     }
 

From ccfcad19b5666af44cd8c57d080c912cc7b3a20a Mon Sep 17 00:00:00 2001
From: omniCoder77 <rishabhsaraswat17@gmail.com>
Date: Sun, 22 Mar 2026 21:42:55 +0530
Subject: [PATCH 4/6] added flags to cassandra_latest

---
 conf/cassandra_latest.yaml | 22 ++++++++++++++++++++++
 1 file changed, 22 insertions(+)

diff --git a/conf/cassandra_latest.yaml b/conf/cassandra_latest.yaml
index 2599b6e7203f..423dfbc33dbb 100644
--- a/conf/cassandra_latest.yaml
+++ b/conf/cassandra_latest.yaml
@@ -1072,6 +1072,28 @@ native_transport_allow_older_protocols: true
 # native_transport_rate_limiting_enabled: false
 # native_transport_max_requests_per_second: 1000000
 
+# When enabled, nodes will signal connected clients before shutting down,
+# allowing in-flight requests to complete without client-visible timeouts.
+# This applies to intentional shutdowns (nodetool drain, rolling restarts,
+# controlled JVM shutdown). Clients must subscribe to the GRACEFUL_DISCONNECT
+# event via REGISTER to benefit from this behavior.
+#
+# Requires driver support for the GRACEFUL_DISCONNECT event type.
+# See: https://cwiki.apache.org/confluence/pages/viewpage.action?pageId=406619103
+
+# Enable or disable graceful disconnect. When false, shutdown behavior is
+# unchanged from previous versions.
+graceful_disconnect_enabled: true
+
+# Time given to clients to stop sending new requests after the
+# GRACEFUL_DISCONNECT event is emitted. Must not exceed graceful_disconnect_max_drain.
+# graceful_disconnect_grace_period: 5000
+
+# Hard timeout for draining connections. Once this limit is reached,
+# remaining connections are force-closed regardless of in-flight requests.
+# Must be greater than 0 when graceful_disconnect_enabled is true.
+# graceful_disconnect_max_drain: 30000
+
 # The address or interface to bind the native transport server to.
 #
 # Set rpc_address OR rpc_interface, not both.

From 47e312cfa88e7cda4290cc0c786259d2a77146dc Mon Sep 17 00:00:00 2001
From: omniCoder77 <rishabhsaraswat17@gmail.com>
Date: Sun, 22 Mar 2026 21:50:24 +0530
Subject: [PATCH 5/6] removed graceful_disconnect_max_drain flag

---
 conf/cassandra.yaml                           | 11 +----
 conf/cassandra_latest.yaml                    | 10 +---
 .../org/apache/cassandra/config/Config.java   |  4 +-
 .../cassandra/config/DatabaseDescriptor.java  | 21 ---------
 .../cassandra/service/StorageService.java     | 37 ++++-----------
 .../service/StorageServiceMBean.java          |  3 --
 .../config/DatabaseDescriptorTest.java        | 12 +----
 .../cassandra/service/StorageServiceTest.java | 47 +++++--------------
 8 files changed, 25 insertions(+), 120 deletions(-)

diff --git a/conf/cassandra.yaml b/conf/cassandra.yaml
index ddb941b3880a..c45fc05040e6 100644
--- a/conf/cassandra.yaml
+++ b/conf/cassandra.yaml
@@ -1096,15 +1096,8 @@ native_transport_allow_older_protocols: true
 # unchanged from previous versions.
 # graceful_disconnect_enabled: false
 
-# Time given to clients to stop sending new requests after the
-# GRACEFUL_DISCONNECT event is emitted. Must not exceed graceful_disconnect_max_drain.
-# graceful_disconnect_grace_period: 5000
-
-# Hard timeout for draining connections. Once this limit is reached,
-# remaining connections are force-closed regardless of in-flight requests.
-# Must be greater than 0 when graceful_disconnect_enabled is true.
-# graceful_disconnect_max_drain: 30000
-
+# Time given to clients to stop sending new requests after the GRACEFUL_DISCONNECT event is emitted.
+# graceful_disconnect_grace_period: 30000
 
 # The address or interface to bind the native transport server to.
 #
diff --git a/conf/cassandra_latest.yaml b/conf/cassandra_latest.yaml
index 423dfbc33dbb..e867272a52bf 100644
--- a/conf/cassandra_latest.yaml
+++ b/conf/cassandra_latest.yaml
@@ -1085,14 +1085,8 @@ native_transport_allow_older_protocols: true
 # unchanged from previous versions.
 graceful_disconnect_enabled: true
 
-# Time given to clients to stop sending new requests after the
-# GRACEFUL_DISCONNECT event is emitted. Must not exceed graceful_disconnect_max_drain.
-# graceful_disconnect_grace_period: 5000
-
-# Hard timeout for draining connections. Once this limit is reached,
-# remaining connections are force-closed regardless of in-flight requests.
-# Must be greater than 0 when graceful_disconnect_enabled is true.
-# graceful_disconnect_max_drain: 30000
+# Time given to clients to stop sending new requests after the GRACEFUL_DISCONNECT event is emitted.
+# graceful_disconnect_grace_period: 30000
 
 # The address or interface to bind the native transport server to.
 #
diff --git a/src/java/org/apache/cassandra/config/Config.java b/src/java/org/apache/cassandra/config/Config.java
index 20235cb6d678..a90bed8d7db2 100644
--- a/src/java/org/apache/cassandra/config/Config.java
+++ b/src/java/org/apache/cassandra/config/Config.java
@@ -169,9 +169,7 @@ public static Set<String> splitCommaDelimited(String src)
 
     public boolean graceful_disconnect_enabled = false;
 
-    public volatile DurationSpec.LongMillisecondsBound graceful_disconnect_grace_period = new  DurationSpec.LongMillisecondsBound("5s");
-
-    public volatile DurationSpec.LongMillisecondsBound graceful_disconnect_max_drain = new  DurationSpec.LongMillisecondsBound("30s");
+    public volatile DurationSpec.LongMillisecondsBound graceful_disconnect_grace_period = new  DurationSpec.LongMillisecondsBound("30s");
 
     @Replaces(oldName = "truncate_request_timeout_in_ms", converter = Converters.MILLIS_DURATION_LONG, deprecated = true)
     public volatile DurationSpec.LongMillisecondsBound truncate_request_timeout = new DurationSpec.LongMillisecondsBound("60000ms");
diff --git a/src/java/org/apache/cassandra/config/DatabaseDescriptor.java b/src/java/org/apache/cassandra/config/DatabaseDescriptor.java
index d2ad7d5067a4..a3bd1aa78f60 100644
--- a/src/java/org/apache/cassandra/config/DatabaseDescriptor.java
+++ b/src/java/org/apache/cassandra/config/DatabaseDescriptor.java
@@ -685,17 +685,6 @@ else if (DiskAccessMode.direct == conf.compaction_read_disk_access_mode)
             throw new ConfigurationException("phi_convict_threshold must be between 5 and 16, but was " + conf.phi_convict_threshold, false);
         }
 
-        if (conf.graceful_disconnect_enabled && conf.graceful_disconnect_max_drain.toMilliseconds() <= 0)
-        {
-            throw new ConfigurationException("graceful_disconnect_max_drain must be greater than 0 when graceful_disconnect_enabled is set to true.", false);
-        }
-
-        if (conf.graceful_disconnect_enabled &&
-            conf.graceful_disconnect_grace_period.toMilliseconds() > conf.graceful_disconnect_max_drain.toMilliseconds())
-        {
-            throw new ConfigurationException("graceful_disconnect_grace_period cannot exceed graceful_disconnect_max_drain.", false);
-        }
-
         /* Thread per pool */
         if (conf.concurrent_reads < 2)
         {
@@ -2655,16 +2644,6 @@ public static void setGracefulDisconnectGracePeriod(long gracefulDisconnectGrace
         conf.graceful_disconnect_grace_period = new DurationSpec.LongMillisecondsBound(gracefulDisconnectGracePeriod);
     }
 
-    public static long getGracefulDisconnectMaxDrain()
-    {
-        return conf.graceful_disconnect_max_drain.toMilliseconds();
-    }
-
-    public static void setGracefulDisconnectMaxDrain(long gracefulDisconnectMaxDrain)
-    {
-        conf.graceful_disconnect_max_drain = new DurationSpec.LongMillisecondsBound(gracefulDisconnectMaxDrain);
-    }
-
     public static boolean getGracefulDisconnectEnabled()
     {
         return conf.graceful_disconnect_enabled;
diff --git a/src/java/org/apache/cassandra/service/StorageService.java b/src/java/org/apache/cassandra/service/StorageService.java
index 7638799a8075..004def707cb9 100644
--- a/src/java/org/apache/cassandra/service/StorageService.java
+++ b/src/java/org/apache/cassandra/service/StorageService.java
@@ -1201,46 +1201,25 @@ public long getRpcTimeout()
         return DatabaseDescriptor.getRpcTimeout(MILLISECONDS);
     }
 
-    @Override
-    public void setGracefulDisconnectGracePeriod(long value)
-    {
-        if (value > DatabaseDescriptor.getGracefulDisconnectMaxDrain())
-            throw new IllegalArgumentException("graceful_disconnect_grace_period cannot exceed graceful_disconnect_max_drain.");
-
-        DatabaseDescriptor.setGracefulDisconnectGracePeriod(value);
-        logger.info("set graceful disconnect grace period to {} ms", value);
-    }
-
-    @Override
-    public long getGracefulDisconnectGracePeriod()
-    {
-        return DatabaseDescriptor.getGracefulDisconnectGracePeriod();
-    }
 
     @Override
-    public void setGracefulDisconnectMaxDrain(long value)
+    public boolean getGracefulDisconnectEnabled()
     {
-        if (value <= 0)
-            throw new IllegalArgumentException("graceful_disconnect_max_drain must be greater than 0 when graceful_disconnect_enabled is set to true.");
-
-        if (value < DatabaseDescriptor.getGracefulDisconnectGracePeriod())
-            throw new IllegalArgumentException("graceful_disconnect_max_drain cannot be less than graceful_disconnect_grace_period.");
-
-        DatabaseDescriptor.setGracefulDisconnectMaxDrain(value);
-        logger.info("set graceful disconnect max drain to {} ms", value);
+        return DatabaseDescriptor.getGracefulDisconnectEnabled();
     }
 
-
     @Override
-    public long getGracefulDisconnectMaxDrain()
+    public void setGracefulDisconnectGracePeriod(long value)
     {
-        return DatabaseDescriptor.getGracefulDisconnectMaxDrain();
+        if (value <= 0 && DatabaseDescriptor.getGracefulDisconnectEnabled())
+            throw new IllegalArgumentException("Graceful disconnect grace period must be positive when graceful disconnect is enabled. Got " + value);
+        DatabaseDescriptor.setGracefulDisconnectGracePeriod(value);
     }
 
     @Override
-    public boolean getGracefulDisconnectEnabled()
+    public long getGracefulDisconnectGracePeriod()
     {
-        return DatabaseDescriptor.getGracefulDisconnectEnabled();
+        return DatabaseDescriptor.getGracefulDisconnectGracePeriod();
     }
 
     public void setReadRpcTimeout(long value)
diff --git a/src/java/org/apache/cassandra/service/StorageServiceMBean.java b/src/java/org/apache/cassandra/service/StorageServiceMBean.java
index 74fd37d71299..e55741c1e2af 100644
--- a/src/java/org/apache/cassandra/service/StorageServiceMBean.java
+++ b/src/java/org/apache/cassandra/service/StorageServiceMBean.java
@@ -776,9 +776,6 @@ default int upgradeSSTables(String keyspaceName, boolean excludeCurrentVersion,
     public void setGracefulDisconnectGracePeriod(long value);
     public long getGracefulDisconnectGracePeriod();
 
-    public void setGracefulDisconnectMaxDrain(long value);
-    public long getGracefulDisconnectMaxDrain();
-
     public boolean getGracefulDisconnectEnabled();
 
     public void setReadRpcTimeout(long value);
diff --git a/test/unit/org/apache/cassandra/config/DatabaseDescriptorTest.java b/test/unit/org/apache/cassandra/config/DatabaseDescriptorTest.java
index f8c07b458228..858ca7624dc2 100644
--- a/test/unit/org/apache/cassandra/config/DatabaseDescriptorTest.java
+++ b/test/unit/org/apache/cassandra/config/DatabaseDescriptorTest.java
@@ -803,22 +803,12 @@ public void testGracefulDisconnectEnabled()
     public void testGracefulDisconnectGracePeriod()
     {
         long originalValue = DatabaseDescriptor.getGracefulDisconnectGracePeriod();
-        Assert.assertEquals("Default value of graceful_disconnect_grace_period must be 5000", 5000, originalValue);
+        Assert.assertEquals("Default value of graceful_disconnect_grace_period must be 30000", 30000, originalValue);
         DatabaseDescriptor.setGracefulDisconnectGracePeriod(3000);
         Assert.assertEquals("graceful_disconnect_grace_period should be updated to 3000", 3000, DatabaseDescriptor.getGracefulDisconnectGracePeriod());
         DatabaseDescriptor.setGracefulDisconnectGracePeriod(originalValue);
     }
 
-    @Test
-    public void testGracefulDisconnectMaxDrain()
-    {
-        long originalValue = DatabaseDescriptor.getGracefulDisconnectMaxDrain();
-        Assert.assertEquals("Default value of graceful_disconnect_max_drain must be 30000", 30000, originalValue);
-        DatabaseDescriptor.setGracefulDisconnectMaxDrain(45000);
-        Assert.assertEquals("graceful_disconnect_max_drain should be updated to 45000", 45000, DatabaseDescriptor.getGracefulDisconnectMaxDrain());
-        DatabaseDescriptor.setGracefulDisconnectMaxDrain(originalValue);
-    }
-
     @Test
     public void testRowIndexSizeAbortEnabledWarnDisabled()
     {
diff --git a/test/unit/org/apache/cassandra/service/StorageServiceTest.java b/test/unit/org/apache/cassandra/service/StorageServiceTest.java
index 27074c223cfb..f1a293a4eaf7 100644
--- a/test/unit/org/apache/cassandra/service/StorageServiceTest.java
+++ b/test/unit/org/apache/cassandra/service/StorageServiceTest.java
@@ -24,6 +24,7 @@
 import org.junit.Before;
 import org.junit.BeforeClass;
 import org.junit.Test;
+import org.junit.jupiter.api.Assertions;
 
 import org.apache.cassandra.ServerTestUtils;
 import org.apache.cassandra.concurrent.ScheduledExecutors;
@@ -202,60 +203,34 @@ public void testColumnIndexSizeInKiB()
     }
 
     @Test
-    public void testGracefulDisconnectMaxDrain()
+    public void testGracefulDisconnectGracePeriod()
     {
         StorageService storageService = StorageService.instance;
-        long originalMaxDrain = storageService.getGracefulDisconnectMaxDrain();
         long originalGracePeriod = storageService.getGracefulDisconnectGracePeriod();
         try
         {
-            storageService.setGracefulDisconnectGracePeriod(1000);
+            storageService.setGracefulDisconnectGracePeriod(3000);
+            Assertions.assertEquals(3000, storageService.getGracefulDisconnectGracePeriod());
 
-            storageService.setGracefulDisconnectMaxDrain(10000);
-            assertEquals(10000, storageService.getGracefulDisconnectMaxDrain());
             try
             {
-                storageService.setGracefulDisconnectMaxDrain(0);
-                fail("Should have received an IllegalArgumentException for max_drain of 0");
-            }
-            catch (IllegalArgumentException ignored)
-            {
+                Assertions.assertThrows(IllegalArgumentException.class, () -> storageService.setGracefulDisconnectGracePeriod(-1));
             }
-            assertEquals(10000, storageService.getGracefulDisconnectMaxDrain());
+            catch (IllegalArgumentException ignored) {}
+
+            Assertions.assertEquals(3000, storageService.getGracefulDisconnectGracePeriod());
         }
         finally
         {
-            storageService.setGracefulDisconnectMaxDrain(originalMaxDrain);
             storageService.setGracefulDisconnectGracePeriod(originalGracePeriod);
         }
     }
 
     @Test
-    public void testGracefulDisconnectGracePeriod()
+    public void testGracefulDisconnectEnabled()
     {
-        StorageService storageService = StorageService.instance;
-        long originalMaxDrain = storageService.getGracefulDisconnectMaxDrain();
-        long originalGracePeriod = storageService.getGracefulDisconnectGracePeriod();
-        try
-        {
-            storageService.setGracefulDisconnectMaxDrain(20000);
-
-            storageService.setGracefulDisconnectGracePeriod(5000);
-            assertEquals(5000, storageService.getGracefulDisconnectGracePeriod());
-
-            try
-            {
-                storageService.setGracefulDisconnectGracePeriod(30000);
-                fail("Should have received an IllegalArgumentException when grace_period exceeds max_drain");
-            }
-            catch (IllegalArgumentException ignored) {}
-            assertEquals(5000, storageService.getGracefulDisconnectGracePeriod());
-        }
-        finally
-        {
-            storageService.setGracefulDisconnectMaxDrain(originalMaxDrain);
-            storageService.setGracefulDisconnectGracePeriod(originalGracePeriod);
-        }
+        Assertions.assertFalse(StorageService.instance.getGracefulDisconnectEnabled(),
+                               "Default value of graceful_disconnect_enabled must be false");
     }
 
     @Test

From a172e61bf346300f19d20dd4f5e63413cf516dcf Mon Sep 17 00:00:00 2001
From: Rishabh Saraswat <rishabh_2024bcse025@gmail.com>
Date: Thu, 16 Apr 2026 20:05:46 +0530
Subject: [PATCH 6/6] updated graceful_disconnect_enabled(earlier false) and
 graceful_disconnect_grace_period(earlier 30s) to true and 5s respectively

---
 conf/cassandra.yaml                                           | 4 ++--
 conf/cassandra_latest.yaml                                    | 2 +-
 src/java/org/apache/cassandra/config/Config.java              | 2 +-
 .../org/apache/cassandra/config/DatabaseDescriptorTest.java   | 4 ++--
 4 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/conf/cassandra.yaml b/conf/cassandra.yaml
index c45fc05040e6..95ab0ace308a 100644
--- a/conf/cassandra.yaml
+++ b/conf/cassandra.yaml
@@ -1094,10 +1094,10 @@ native_transport_allow_older_protocols: true
 
 # Enable or disable graceful disconnect. When false, shutdown behavior is
 # unchanged from previous versions.
-# graceful_disconnect_enabled: false
+# graceful_disconnect_enabled: true
 
 # Time given to clients to stop sending new requests after the GRACEFUL_DISCONNECT event is emitted.
-# graceful_disconnect_grace_period: 30000
+# graceful_disconnect_grace_period: 5000
 
 # The address or interface to bind the native transport server to.
 #
diff --git a/conf/cassandra_latest.yaml b/conf/cassandra_latest.yaml
index e867272a52bf..5022f86e669c 100644
--- a/conf/cassandra_latest.yaml
+++ b/conf/cassandra_latest.yaml
@@ -1086,7 +1086,7 @@ native_transport_allow_older_protocols: true
 graceful_disconnect_enabled: true
 
 # Time given to clients to stop sending new requests after the GRACEFUL_DISCONNECT event is emitted.
-# graceful_disconnect_grace_period: 30000
+# graceful_disconnect_grace_period: 5000
 
 # The address or interface to bind the native transport server to.
 #
diff --git a/src/java/org/apache/cassandra/config/Config.java b/src/java/org/apache/cassandra/config/Config.java
index a90bed8d7db2..0bf7651c3338 100644
--- a/src/java/org/apache/cassandra/config/Config.java
+++ b/src/java/org/apache/cassandra/config/Config.java
@@ -169,7 +169,7 @@ public static Set<String> splitCommaDelimited(String src)
 
     public boolean graceful_disconnect_enabled = false;
 
-    public volatile DurationSpec.LongMillisecondsBound graceful_disconnect_grace_period = new  DurationSpec.LongMillisecondsBound("30s");
+    public volatile DurationSpec.LongMillisecondsBound graceful_disconnect_grace_period = new  DurationSpec.LongMillisecondsBound("5s");
 
     @Replaces(oldName = "truncate_request_timeout_in_ms", converter = Converters.MILLIS_DURATION_LONG, deprecated = true)
     public volatile DurationSpec.LongMillisecondsBound truncate_request_timeout = new DurationSpec.LongMillisecondsBound("60000ms");
diff --git a/test/unit/org/apache/cassandra/config/DatabaseDescriptorTest.java b/test/unit/org/apache/cassandra/config/DatabaseDescriptorTest.java
index 858ca7624dc2..54be2ce3bb7f 100644
--- a/test/unit/org/apache/cassandra/config/DatabaseDescriptorTest.java
+++ b/test/unit/org/apache/cassandra/config/DatabaseDescriptorTest.java
@@ -796,14 +796,14 @@ public void testGracefulDisconnectEnabled()
     {
         Config config = new Config();
         boolean originalValue = config.graceful_disconnect_enabled;
-        Assert.assertFalse("Default value of graceful_disconnect_enabled must be false", originalValue);
+        Assert.assertTrue("Default value of graceful_disconnect_enabled must be true", originalValue);
     }
 
     @Test
     public void testGracefulDisconnectGracePeriod()
     {
         long originalValue = DatabaseDescriptor.getGracefulDisconnectGracePeriod();
-        Assert.assertEquals("Default value of graceful_disconnect_grace_period must be 30000", 30000, originalValue);
+        Assert.assertEquals("Default value of graceful_disconnect_grace_period must be 5000", 5000, originalValue);
         DatabaseDescriptor.setGracefulDisconnectGracePeriod(3000);
         Assert.assertEquals("graceful_disconnect_grace_period should be updated to 3000", 3000, DatabaseDescriptor.getGracefulDisconnectGracePeriod());
         DatabaseDescriptor.setGracefulDisconnectGracePeriod(originalValue);