Implement UpdateTimeToLive [HZ-5249][API-1789] (#997)

Implemented missing `Map.UpdateTimeToLive` API.

Author: emreyigit

src/Hazelcast.Net.Tests/Remote/ClientMapTest.cs

@@ -13,6 +13,7 @@
 // limitations under the License.
 using System;
 using System.Collections.Generic;
+using System.Diagnostics;
 using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
@@ -1407,5 +1408,57 @@ public async Task TestValuesPredicate()
             Assert.IsTrue(enumerator.MoveNext());
             Assert.AreEqual("value1", enumerator.Current);
         }
+
+        [Test]
+        public async Task TestTTLUpdated()
+        {
+            var map = await Client.GetMapAsync<string, string>(CreateUniqueName());
+            // in seconds
+            var maxTTL = 100;
+            var minTTL = 3;
+            var key = "key1";
+            var latch = new ManualResetEvent(false);
+            
+            var starTime = Stopwatch.StartNew();
+            await map.SetAsync(key, "value1", TimeSpan.FromSeconds(maxTTL));
+
+            // Notify when key removed
+            var parallelCheck = Task.Run(async () =>
+            {
+                await AssertEx.SucceedsEventually(
+                    async () => Assert.False(await map.ContainsKeyAsync(key)),
+                    maxTTL * 1000,
+                    500);
+                latch.Set();
+            });
+
+            // Reduce the TTL
+            Assert.True(await map.SetTTL(key, TimeSpan.FromSeconds(minTTL)));
+
+            await latch.WaitOneAsync();
+            starTime.Stop();
+            var elapsed = starTime.ElapsedMilliseconds;
+
+            // Definitively, less then maxTTL
+            Assert.Less(elapsed, maxTTL * 1000);
+        }
+
+        [Test]
+        public async Task TestTTLReturnsFalseWhenKeyDoesNotExist()
+        {
+            var map = await Client.GetMapAsync<string, string>(CreateUniqueName());
+            Assert.False(await map.SetTTL("non-existing-key", TimeSpan.FromSeconds(10)));
+        }
+        
+        
+        [Test]
+        public async Task TestTTLReturnsFalseWhenKeyAlreadyExpired()
+        {
+            var map = await Client.GetMapAsync<string, string>(CreateUniqueName());
+            var key = "non-existing-key";
+            await map.SetAsync(key, "value1", TimeSpan.FromMilliseconds(10));
+            await Task.Delay(100);
+            Assert.False(await map.SetTTL("non-existing-key", TimeSpan.FromMilliseconds(10)));
+        }
     }
 }

src/Hazelcast.Net/DistributedObjects/IHMap.Setting.cs

@@ -250,8 +250,8 @@ public partial interface IHMap<TKey, TValue> // Setting
         /// <remarks>
         /// <para>The value is automatically expired, evicted and removed after the
         /// <paramref name="timeToLive"/> has elapsed. If <paramref name="timeToLive"/> is infinite (0ms),
-        /// the value is retained indefinitely. If it is -1ms,
-        /// it lives for the duration of the server-configured time-to-live.</para>
+        /// the value is retained indefinitely. If it is negative,
+        /// it lives for the duration of the server-configured (default: forever) time-to-live.</para>
         /// <para>The new time-to-live value is valid starting from the time this operation is invoked,
         /// not since the time the entry was created.</para>
         /// <para>
@@ -265,6 +265,6 @@ public partial interface IHMap<TKey, TValue> // Setting
         /// Time resolution for <paramref name="timeToLive"></paramref> is seconds. The given value is rounded to the next closest second value.
         /// </para>
         /// </remarks>
-        Task<bool> UpdateTimeToLive(TKey key, TimeSpan timeToLive);
+        Task<bool> SetTTL(TKey key, TimeSpan timeToLive);
     }
 }

src/Hazelcast.Net/DistributedObjects/Impl/HMap.Setting.cs

@@ -392,9 +392,15 @@ Task SetTransientAsync(IData keyData, IData valueData, TimeSpan timeToLive, Time
 #endif
         }
 
-        public Task<bool> UpdateTimeToLive(TKey key, TimeSpan timeToLive)
+        public async Task<bool> SetTTL(TKey key, TimeSpan timeToLive)
         {
-            throw new NotImplementedException();
+            var keyData = ToSafeData(key);
+            var millis = Convert.ToInt64(timeToLive.TotalMilliseconds);
+            var requestMessage = MapSetTtlCodec.EncodeRequest(Name, keyData, millis);
+            
+            var result= await Cluster.Messaging.SendToKeyPartitionOwnerAsync(requestMessage, keyData).CfAwait(); 
+            var decoded = MapSetTtlCodec.DecodeResponse(result);
+            return decoded.Response;
         }
     }
 }