Add TokenCacheSerializer (Azure#18601)

Author: christothes

sdk/identity/Azure.Identity/api/Azure.Identity.netstandard2.0.cs

@@ -229,10 +229,13 @@ public partial class TokenCache
     {
         public TokenCache() { }
         public event System.Func<Azure.Identity.TokenCacheUpdatedArgs, System.Threading.Tasks.Task> Updated { add { } remove { } }
+    }
+    public static partial class TokenCacheSerializer
+    {
         public static Azure.Identity.TokenCache Deserialize(System.IO.Stream stream, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) { throw null; }
         public static System.Threading.Tasks.Task<Azure.Identity.TokenCache> DeserializeAsync(System.IO.Stream stream, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) { throw null; }
-        public void Serialize(System.IO.Stream stream, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) { }
-        public System.Threading.Tasks.Task SerializeAsync(System.IO.Stream stream, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) { throw null; }
+        public static void Serialize(Azure.Identity.TokenCache tokenCache, System.IO.Stream stream, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) { }
+        public static System.Threading.Tasks.Task SerializeAsync(Azure.Identity.TokenCache tokenCache, System.IO.Stream stream, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) { throw null; }
     }
     public partial class TokenCacheUpdatedArgs
     {

sdk/identity/Azure.Identity/samples/TokenCache.md

@@ -60,7 +60,7 @@ private const string TOKEN_CACHE_PATH = "./tokencache.bin";
 ```C# Snippet:Identity_TokenCache_CustomPersistence_Write
 using (var cacheStream = new FileStream(TOKEN_CACHE_PATH, FileMode.Create, FileAccess.Write))
 {
-    await tokenCache.SerializeAsync(cacheStream);
+    await TokenCacheSerializer.SerializeAsync(tokenCache, cacheStream);
 }
 ```
 
@@ -71,7 +71,7 @@ TokenCache tokenCache;
 
 using (var cacheStream = new FileStream(TOKEN_CACHE_PATH, FileMode.OpenOrCreate, FileAccess.Read))
 {
-    tokenCache = await TokenCache.DeserializeAsync(cacheStream);
+    tokenCache = await TokenCacheSerializer.DeserializeAsync(cacheStream);
 }
 ```
 
@@ -84,7 +84,7 @@ public static async Task<TokenCache> ReadTokenCacheAsync()
 
     using (var cacheStream = new FileStream(TOKEN_CACHE_PATH, FileMode.OpenOrCreate, FileAccess.Read))
     {
-        tokenCache = await TokenCache.DeserializeAsync(cacheStream);
+        tokenCache = await TokenCacheSerializer.DeserializeAsync(cacheStream);
         tokenCache.Updated += WriteCacheOnUpdateAsync;
     }
 
@@ -95,7 +95,7 @@ public static async Task WriteCacheOnUpdateAsync(TokenCacheUpdatedArgs args)
 {
     using (var cacheStream = new FileStream(TOKEN_CACHE_PATH, FileMode.Create, FileAccess.Write))
     {
-        await args.Cache.SerializeAsync(cacheStream);
+        await TokenCacheSerializer.SerializeAsync(args.Cache, cacheStream);
     }
 }
 

sdk/identity/Azure.Identity/src/TokenCache.cs

@@ -19,10 +19,15 @@ namespace Azure.Identity
     public class TokenCache
 #pragma warning restore CA1001 // Types that own disposable fields should be disposable
     {
-        private SemaphoreSlim _lock = new SemaphoreSlim(1,1);
-        private byte[] _data;
+        private readonly SemaphoreSlim _lock = new SemaphoreSlim(1, 1);
         private DateTimeOffset _lastUpdated;
         private ConditionalWeakTable<object, CacheTimestamp> _cacheAccessMap;
+        internal Func<IPublicClientApplication> _publicClientApplicationFactory;
+
+        /// <summary>
+        /// The internal state of the cache.
+        /// </summary>
+        internal byte[] Data { get; private set; }
 
         private class CacheTimestamp
         {
@@ -33,9 +38,10 @@ public CacheTimestamp()
                 Update();
             }
 
-            public void Update()
+            public DateTimeOffset Update()
             {
                 _timestamp = DateTimeOffset.UtcNow;
+                return _timestamp;
             }
 
             public DateTimeOffset Value { get { return _timestamp; } }
@@ -49,98 +55,19 @@ public TokenCache()
         {
         }
 
-        internal TokenCache(byte[] data)
+        internal TokenCache(byte[] data, Func<IPublicClientApplication> publicApplicationFactory = null)
         {
-            _data = data;
+            Data = data;
             _lastUpdated = DateTimeOffset.UtcNow;
             _cacheAccessMap = new ConditionalWeakTable<object, CacheTimestamp>();
+            _publicClientApplicationFactory = publicApplicationFactory ?? new (() => PublicClientApplicationBuilder.Create(Guid.NewGuid().ToString()).Build());
         }
 
         /// <summary>
         /// An event notifying the subscriber that the underlying <see cref="TokenCache"/> has been updated. This event can be handled to persist the updated cache data.
         /// </summary>
         public event Func<TokenCacheUpdatedArgs, Task> Updated;
 
-        /// <summary>
-        /// Serializes the <see cref="TokenCache"/> to the specified <see cref="Stream"/>.
-        /// </summary>
-        /// <param name="stream">The <see cref="Stream"/> which the serialized <see cref="TokenCache"/> will be written to.</param>
-        /// <param name="cancellationToken">A <see cref="CancellationToken"/> controlling the request lifetime.</param>
-        public void Serialize(Stream stream, CancellationToken cancellationToken = default)
-        {
-            if (stream is null)
-                throw new ArgumentNullException(nameof(stream));
-
-            SerializeAsync(stream, false, cancellationToken).EnsureCompleted();
-        }
-
-        /// <summary>
-        /// Serializes the <see cref="TokenCache"/> to the specified <see cref="Stream"/>.
-        /// </summary>
-        /// <param name="stream">The <see cref="Stream"/> to which the serialized <see cref="TokenCache"/> will be written.</param>
-        /// <param name="cancellationToken">A <see cref="CancellationToken"/> controlling the request lifetime.</param>
-        public async Task SerializeAsync(Stream stream, CancellationToken cancellationToken = default)
-        {
-            if (stream is null)
-                throw new ArgumentNullException(nameof(stream));
-
-            await SerializeAsync(stream, true, cancellationToken).ConfigureAwait(false);
-        }
-
-        /// <summary>
-        /// Deserializes the <see cref="TokenCache"/> from the specified <see cref="Stream"/>.
-        /// </summary>
-        /// <param name="stream">The <see cref="Stream"/> from which the serialized <see cref="TokenCache"/> will be read.</param>
-        /// <param name="cancellationToken">A <see cref="CancellationToken"/> controlling the request lifetime.</param>
-        public static TokenCache Deserialize(Stream stream, CancellationToken cancellationToken = default)
-        {
-            if (stream is null)
-                throw new ArgumentNullException(nameof(stream));
-
-            return DeserializeAsync(stream, false, cancellationToken).EnsureCompleted();
-        }
-
-        /// <summary>
-        /// Deserializes the <see cref="TokenCache"/> from the specified <see cref="Stream"/>.
-        /// </summary>
-        /// <param name="stream">The <see cref="Stream"/> from which the serialized <see cref="TokenCache"/> will be read.</param>
-        /// <param name="cancellationToken">A <see cref="CancellationToken"/> controlling the request lifetime.</param>
-        public static async Task<TokenCache> DeserializeAsync(Stream stream, CancellationToken cancellationToken = default)
-        {
-            if (stream is null)
-                throw new ArgumentNullException(nameof(stream));
-
-            return await DeserializeAsync(stream, true, cancellationToken).ConfigureAwait(false);
-        }
-
-        private async Task SerializeAsync(Stream stream, bool async, CancellationToken cancellationToken)
-        {
-            if (async)
-            {
-                await stream.WriteAsync(_data, 0, _data.Length, cancellationToken).ConfigureAwait(false);
-            }
-            else
-            {
-                stream.Write(_data, 0, _data.Length);
-            }
-        }
-
-        private static async Task<TokenCache> DeserializeAsync(Stream stream, bool async, CancellationToken cancellationToken)
-        {
-            var data = new byte[stream.Length - stream.Position];
-
-            if (async)
-            {
-                await stream.ReadAsync(data, 0, data.Length, cancellationToken).ConfigureAwait(false);
-            }
-            else
-            {
-                stream.Read(data, 0, data.Length);
-            }
-
-            return new TokenCache(data);
-        }
-
         internal virtual async Task RegisterCache(bool async, ITokenCache tokenCache, CancellationToken cancellationToken)
         {
             if (async)
@@ -175,7 +102,7 @@ private async Task OnBeforeCacheAccessAsync(TokenCacheNotificationArgs args)
 
             try
             {
-                args.TokenCache.DeserializeMsalV3(_data, true);
+                args.TokenCache.DeserializeMsalV3(Data, true);
 
                 _cacheAccessMap.GetOrCreateValue(args.TokenCache).Update();
             }
@@ -201,16 +128,14 @@ private async Task UpdateCacheDataAsync(ITokenCacheSerializer tokenCache)
             {
                 if (!_cacheAccessMap.TryGetValue(tokenCache, out CacheTimestamp lastRead) || lastRead.Value < _lastUpdated)
                 {
-                    _data = await MergeCacheData(_data, tokenCache.SerializeMsalV3()).ConfigureAwait(false);
+                    Data = await MergeCacheData(Data, tokenCache.SerializeMsalV3()).ConfigureAwait(false);
                 }
                 else
                 {
-                    _data = tokenCache.SerializeMsalV3();
+                    Data = tokenCache.SerializeMsalV3();
                 }
 
-                _cacheAccessMap.GetOrCreateValue(tokenCache).Update();
-
-                _lastUpdated = DateTime.UtcNow;
+                _lastUpdated = _cacheAccessMap.GetOrCreateValue(tokenCache).Update();
             }
             finally
             {
@@ -226,11 +151,11 @@ private async Task UpdateCacheDataAsync(ITokenCacheSerializer tokenCache)
             }
         }
 
-        private static async Task<byte[]> MergeCacheData(byte[] cacheA, byte[] cacheB)
+        private async Task<byte[]> MergeCacheData(byte[] cacheA, byte[] cacheB)
         {
             byte[] merged = null;
 
-            var client = PublicClientApplicationBuilder.Create(Guid.NewGuid().ToString()).Build();
+            IPublicClientApplication client = _publicClientApplicationFactory();
 
             client.UserTokenCache.SetBeforeAccess(args => args.TokenCache.DeserializeMsalV3(cacheA));
 

sdk/identity/Azure.Identity/src/TokenCacheSerializer.cs

@@ -0,0 +1,98 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+using System;
+using System.IO;
+using System.Threading;
+using System.Threading.Tasks;
+using Azure.Core.Pipeline;
+using Azure.Core;
+
+namespace Azure.Identity
+{
+    /// <summary>
+    /// A cache for Tokens.
+    /// </summary>
+    public static class TokenCacheSerializer
+    {
+        /// <summary>
+        /// Serializes the <see cref="TokenCache"/> to the specified <see cref="Stream"/>.
+        /// </summary>
+        /// <param name="tokenCache">The <see cref="TokenCache"/> to serialize.</param>
+        /// <param name="stream">The <see cref="Stream"/> which the serialized <see cref="TokenCache"/> will be written to.</param>
+        /// <param name="cancellationToken">A <see cref="CancellationToken"/> controlling the request lifetime.</param>
+        public static void Serialize(TokenCache tokenCache, Stream stream, CancellationToken cancellationToken = default)
+        {
+            Argument.AssertNotNull(tokenCache, nameof(tokenCache));
+            Argument.AssertNotNull(stream, nameof(stream));
+
+            SerializeAsync(tokenCache, stream, false, cancellationToken).EnsureCompleted();
+        }
+
+        /// <summary>
+        /// Serializes the <see cref="TokenCache"/> to the specified <see cref="Stream"/>.
+        /// </summary>
+        /// <param name="tokenCache">The <see cref="TokenCache"/> to serialize.</param>
+        /// <param name="stream">The <see cref="Stream"/> to which the serialized <see cref="TokenCache"/> will be written.</param>
+        /// <param name="cancellationToken">A <see cref="CancellationToken"/> controlling the request lifetime.</param>
+        public static async Task SerializeAsync(TokenCache tokenCache, Stream stream, CancellationToken cancellationToken = default)
+        {
+            Argument.AssertNotNull(tokenCache, nameof(tokenCache));
+            Argument.AssertNotNull(stream, nameof(stream));
+
+            await SerializeAsync(tokenCache, stream, true, cancellationToken).ConfigureAwait(false);
+        }
+
+        /// <summary>
+        /// Deserializes the <see cref="TokenCache"/> from the specified <see cref="Stream"/>.
+        /// </summary>
+        /// <param name="stream">The <see cref="Stream"/> from which the serialized <see cref="TokenCache"/> will be read.</param>
+        /// <param name="cancellationToken">A <see cref="CancellationToken"/> controlling the request lifetime.</param>
+        public static TokenCache Deserialize(Stream stream, CancellationToken cancellationToken = default)
+        {
+            Argument.AssertNotNull(stream, nameof(stream));
+
+            return DeserializeAsync(stream, false, cancellationToken).EnsureCompleted();
+        }
+
+        /// <summary>
+        /// Deserializes the <see cref="TokenCache"/> from the specified <see cref="Stream"/>.
+        /// </summary>
+        /// <param name="stream">The <see cref="Stream"/> from which the serialized <see cref="TokenCache"/> will be read.</param>
+        /// <param name="cancellationToken">A <see cref="CancellationToken"/> controlling the request lifetime.</param>
+        public static async Task<TokenCache> DeserializeAsync(Stream stream, CancellationToken cancellationToken = default)
+        {
+            Argument.AssertNotNull(stream, nameof(stream));
+
+            return await DeserializeAsync(stream, true, cancellationToken).ConfigureAwait(false);
+        }
+
+        private static async Task SerializeAsync(TokenCache tokenCache, Stream stream, bool async, CancellationToken cancellationToken)
+        {
+            if (async)
+            {
+                await stream.WriteAsync(tokenCache.Data, 0, tokenCache.Data.Length, cancellationToken).ConfigureAwait(false);
+            }
+            else
+            {
+                stream.Write(tokenCache.Data, 0, tokenCache.Data.Length);
+            }
+        }
+
+        private static async Task<TokenCache> DeserializeAsync(Stream stream, bool async, CancellationToken cancellationToken)
+        {
+            var data = new byte[stream.Length - stream.Position];
+
+            if (async)
+            {
+                await stream.ReadAsync(data, 0, data.Length, cancellationToken).ConfigureAwait(false);
+            }
+            else
+            {
+                stream.Read(data, 0, data.Length);
+            }
+
+            return new TokenCache(data);
+        }
+    }
+}