IGNITE-12824 .NET: Add BinaryConfiguration.TimestampConverter (#8568)

Co-authored-by: Pavel Tupitsyn <[email protected]>

Author: nizhikov

modules/core/src/test/java/org/apache/ignite/platform/PlatformDeployServiceTask.java

@@ -18,6 +18,8 @@
 package org.apache.ignite.platform;
 
 import java.sql.Timestamp;
+import java.time.ZoneId;
+import java.time.ZonedDateTime;
 import java.util.ArrayList;
 import java.util.Calendar;
 import java.util.Collection;
@@ -530,6 +532,24 @@ public void testUTCDateFromCache() {
             assertEquals(new Timestamp(new Date(91, Calendar.OCTOBER, 1, 0, 0, 0).getTime()), cache.get(2));
         }
 
+        /** */
+        public void testLocalDateFromCache() {
+            IgniteCache<Integer, Timestamp> cache = ignite.cache("net-dates");
+
+            ZoneId msk = ZoneId.of("Europe/Moscow");
+
+            //This Date in Europe/Moscow have offset +4.
+            Timestamp ts1 = new Timestamp(ZonedDateTime.of(1982, 4, 1, 1, 0, 0, 0, msk).toInstant().toEpochMilli());
+            //This Date in Europe/Moscow have offset +3.
+            Timestamp ts2 = new Timestamp(ZonedDateTime.of(1982, 3, 31, 22, 0, 0, 0, msk).toInstant().toEpochMilli());
+
+            assertEquals(ts1, cache.get(5));
+            assertEquals(ts2, cache.get(6));
+
+            cache.put(7, ts1);
+            cache.put(8, ts2);
+        }
+
         /** */
         public void sleep(long delayMs) {
             try {

modules/platforms/dotnet/Apache.Ignite.Core.Tests/Binary/BinaryDateTimeTest.cs

@@ -21,13 +21,24 @@ namespace Apache.Ignite.Core.Tests.Binary
     using System.Linq;
     using Apache.Ignite.Core.Binary;
     using Apache.Ignite.Core.Cache.Configuration;
+    using Apache.Ignite.Core.Impl.Binary;
     using NUnit.Framework;
 
     /// <summary>
     /// DateTime binary serialization tests.
     /// </summary>
     public class BinaryDateTimeTest
     {
+        /** */
+        internal const String FromErrMsg = "FromJavaTicks Error!";
+
+        /** */
+        internal const String ToErrMsg = "ToJavaTicks Error!";
+
+        /** */
+        private const String NotUtcDate =
+            "DateTime is not UTC. Only UTC DateTime can be used for interop with other platforms.";
+
         /// <summary>
         /// Sets up the test fixture.
         /// </summary>
@@ -80,7 +91,7 @@ public void TestSerializerForceTimestamp()
                 .Select(x => x.Serializer)
                 .OfType<BinaryReflectiveSerializer>()
                 .Single();
-            
+
             Assert.IsTrue(ser.ForceTimestamp);
 
             AssertTimestampField<DateTimeObj2>((o, d) => o.Value = d, o => o.Value, "Value");
@@ -110,6 +121,152 @@ public void TestClassAttributes()
             AssertTimestampField<DateTimeClassAttribute2>((o, d) => o.Value = d, o => o.Value, "Value");
         }
 
+        /// <summary>
+        /// Tests custom timestamp converter that modifies the values by adding one year on write and read.
+        /// This test verifies that actual converted values are used by Ignite.
+        /// </summary>
+        [Test]
+        public void TestAddYearTimestampConverter()
+        {
+            var cfg =  new IgniteConfiguration(TestUtils.GetTestConfiguration())
+            {
+                AutoGenerateIgniteInstanceName = true,
+                BinaryConfiguration = new BinaryConfiguration
+                {
+                    ForceTimestamp = true, 
+                    TimestampConverter = new AddYearTimestampConverter()
+                }
+            };
+
+            var ignite = Ignition.Start(cfg);
+
+            var dt = DateTime.UtcNow;
+            var expected = dt.AddYears(2);
+
+            // Key & value.
+            var cache = ignite.GetOrCreateCache<DateTime, DateTime>(TestUtils.TestName);
+            cache[dt] = dt;
+
+            var resEntry = cache.Single();
+            
+            Assert.AreEqual(expected, resEntry.Key);
+            Assert.AreEqual(expected, resEntry.Value);
+            
+            // Key & value array.
+            
+            // Object field.
+            var cache2 = ignite.GetOrCreateCache<DateTimePropertyAttribute, DateTimePropertyAttribute>(
+                TestUtils.TestName);
+            
+            cache2.RemoveAll();
+            
+            var obj = new DateTimePropertyAttribute {Value = dt};
+            cache2[obj] = obj;
+
+            var resEntry2 = cache2.Single();
+            Assert.AreEqual(expected, resEntry2.Key.Value);
+            Assert.AreEqual(expected, resEntry2.Value.Value);
+            
+            // Object array field.
+            var cache3 = ignite.GetOrCreateCache<DateTimeArr, DateTimeArr>(TestUtils.TestName);
+            cache3.RemoveAll();
+            
+            var obj2 = new DateTimeArr {Value = new[]{dt}};
+            cache3[obj2] = obj2;
+            cache3[obj2] = obj2;
+
+            var resEntry3 = cache3.Single();
+            Assert.AreEqual(expected, resEntry3.Key.Value.Single());
+            Assert.AreEqual(expected, resEntry3.Value.Value.Single());
+        }
+
+        /// <summary>
+        /// Tests custom timestamp converter.
+        /// </summary>
+        [Test]
+        public void TestCustomTimestampConverter()
+        {
+            var cfg =  new IgniteConfiguration(TestUtils.GetTestConfiguration(name: "ignite-1"))
+            {
+                BinaryConfiguration = new BinaryConfiguration
+                {
+                    ForceTimestamp = true, 
+                    TimestampConverter = new TimestampConverter()
+                }
+            };
+
+            var ignite = Ignition.Start(cfg);
+            var binary = ignite.GetBinary();
+ 
+            // Check config.
+            Assert.NotNull(ignite.GetConfiguration().BinaryConfiguration.TimestampConverter);
+
+            AssertTimestampField<DateTimeObj2>((o, d) => o.Value = d, o => o.Value, "Value", ignite);
+
+            var dt1 = new DateTime(1997, 8, 29, 0, 0, 0, DateTimeKind.Utc);
+
+            var ex = Assert.Throws<BinaryObjectException>(() => binary.ToBinary<DateTime>(dt1));
+            Assert.AreEqual(ToErrMsg, ex.Message);
+
+            ex = Assert.Throws<BinaryObjectException>(() => binary.ToBinary<DateTime?[]>(new DateTime?[] {dt1}));
+            Assert.AreEqual(ToErrMsg, ex.Message);
+
+            var dt2 = new DateTime(1997, 8, 4, 0, 0, 0, DateTimeKind.Utc);
+
+            ex = Assert.Throws<BinaryObjectException>(() => binary.ToBinary<DateTime>(dt2));
+            Assert.AreEqual(FromErrMsg, ex.Message);
+
+            ex = Assert.Throws<BinaryObjectException>(() => binary.ToBinary<DateTime?[]>(new DateTime?[] {dt2}));
+            Assert.AreEqual(FromErrMsg, ex.Message);
+
+            var datesCache = ignite.CreateCache<DateTime, DateTime>("dates");
+
+            var check = new Action<DateTime, DateTime, String>((date1, date2, errMsg) =>
+            {
+                ex = Assert.Throws<BinaryObjectException>(() => datesCache.Put(date1, date2), "Timestamp fields should throw an error on non-UTC values");
+
+                Assert.AreEqual(errMsg, ex.Message);
+            });
+
+            check.Invoke(DateTime.Now, DateTime.UtcNow, NotUtcDate);
+            check.Invoke(DateTime.UtcNow, DateTime.Now, NotUtcDate);
+            check.Invoke(dt1, DateTime.UtcNow, ToErrMsg);
+            check.Invoke(DateTime.UtcNow, dt1, ToErrMsg);
+
+            var now = DateTime.UtcNow;
+
+            datesCache.Put(now, dt2);
+            ex = Assert.Throws<BinaryObjectException>(() => datesCache.Get(now), "Timestamp fields should throw an error on non-UTC values");
+            Assert.AreEqual(FromErrMsg, ex.Message);
+            
+            datesCache.Put(now, now);
+            Assert.AreEqual(now, datesCache.Get(now));
+
+            var datesObjCache = ignite.CreateCache<DateTimeObj, DateTimeObj>("datesObj");
+
+            check = (date1, date2, errMsg) =>
+            {
+                ex = Assert.Throws<BinaryObjectException>(() => datesObjCache.Put(new DateTimeObj {Value = date1}, new DateTimeObj {Value = date2}),
+                    "Timestamp fields should throw an error on non-UTC values");
+
+                Assert.AreEqual(errMsg, ex.Message);
+            };
+
+            check.Invoke(DateTime.Now, DateTime.UtcNow, NotUtcDate);
+            check.Invoke(DateTime.UtcNow, DateTime.Now, NotUtcDate);
+            check.Invoke(dt1, DateTime.UtcNow, ToErrMsg);
+            check.Invoke(DateTime.UtcNow, dt1, ToErrMsg);
+
+            var nowObj = new DateTimeObj {Value = now};
+
+            datesObjCache.Put(nowObj, new DateTimeObj {Value = dt2});
+            ex = Assert.Throws<BinaryObjectException>(() => datesObjCache.Get(nowObj), "Timestamp fields should throw an error on non-UTC values");
+            Assert.AreEqual(FromErrMsg, ex.Message);
+            
+            datesObjCache.Put(nowObj, nowObj);
+            Assert.AreEqual(nowObj.Value, datesObjCache.Get(nowObj).Value);
+        }
+
         /// <summary>
         /// Asserts that specified field is serialized as DateTime object.
         /// </summary>
@@ -136,10 +293,10 @@ private static void AssertDateTimeField<T>(Action<T, DateTime> setValue,
         /// Asserts that specified field is serialized as Timestamp.
         /// </summary>
         private static void AssertTimestampField<T>(Action<T, DateTime> setValue,
-            Func<T, DateTime> getValue, string fieldName) where T : new()
+            Func<T, DateTime> getValue, string fieldName, IIgnite ignite = null) where T : new()
         {
             // Non-UTC DateTime throws.
-            var binary = Ignition.GetIgnite().GetBinary();
+            var binary = ignite != null ? ignite.GetBinary() : Ignition.GetIgnite().GetBinary();
 
             var obj = new T();
 
@@ -148,8 +305,7 @@ private static void AssertTimestampField<T>(Action<T, DateTime> setValue,
             var ex = Assert.Throws<BinaryObjectException>(() => binary.ToBinary<IBinaryObject>(obj), 
                 "Timestamp fields should throw an error on non-UTC values");
 
-            Assert.AreEqual("DateTime is not UTC. Only UTC DateTime can be used for interop with other platforms.",
-                ex.Message);
+            Assert.AreEqual(NotUtcDate, ex.Message);
 
             // UTC DateTime works.
             setValue(obj, DateTime.UtcNow);
@@ -171,6 +327,11 @@ private class DateTimeObj2
             public DateTime Value { get; set; }
         }
 
+        private class DateTimeArr
+        {
+            public DateTime[] Value { get; set; }
+        }
+
         private class DateTimePropertyAttribute
         {
             [Timestamp]
@@ -200,5 +361,47 @@ private class DateTimeClassAttribute2
         {
             public DateTime Value;
         }
+        
+        private class TimestampConverter : ITimestampConverter
+        {
+            /** <inheritdoc /> */
+            public void ToJavaTicks(DateTime date, out long high, out int low)
+            {
+                if (date.Year == 1997 && date.Month == 8 && date.Day == 29)
+                    throw new BinaryObjectException(BinaryDateTimeTest.ToErrMsg);
+
+                BinaryUtils.ToJavaDate(date, out high, out low);
+            }
+
+            /** <inheritdoc /> */
+            public DateTime FromJavaTicks(long high, int low)
+            {
+                var date = new DateTime(BinaryUtils.JavaDateTicks + high * TimeSpan.TicksPerMillisecond + low / 100,
+                    DateTimeKind.Utc);
+
+                if (date.Year == 1997 && date.Month == 8 && date.Day == 4)
+                    throw new BinaryObjectException(BinaryDateTimeTest.FromErrMsg);
+
+                return date;
+            }
+        }
+        
+        private class AddYearTimestampConverter : ITimestampConverter
+        {
+            /** <inheritdoc /> */
+            public void ToJavaTicks(DateTime date, out long high, out int low)
+            {
+                BinaryUtils.ToJavaDate(date.AddYears(1), out high, out low);
+            }
+
+            /** <inheritdoc /> */
+            public DateTime FromJavaTicks(long high, int low)
+            {
+                var date = new DateTime(BinaryUtils.JavaDateTicks + high * TimeSpan.TicksPerMillisecond + low / 100,
+                    DateTimeKind.Utc);
+
+                return date.AddYears(1);
+            }
+        }
     }
 }

modules/platforms/dotnet/Apache.Ignite.Core.Tests/Services/IJavaService.cs

@@ -186,6 +186,9 @@ public interface IJavaService
         /** */
         void testUTCDateFromCache();
 
+        /** */
+        void testLocalDateFromCache();
+
         /** */
         void sleep(long delayMs);
     }

modules/platforms/dotnet/Apache.Ignite.Core.Tests/Services/JavaServiceDynamicProxy.cs

@@ -349,6 +349,12 @@ public void testUTCDateFromCache()
             _svc.testDateFromCache();
         }
 
+        /** <inheritDoc /> */
+        public void testLocalDateFromCache()
+        {
+            _svc.testLocalDateFromCache();
+        }
+
         /** <inheritDoc /> */
         public void sleep(long delayMs)
         {