implement IWritableTransport

src/Speckle.Sdk/Api/Operations/Operations.Send.cs

@@ -14,7 +14,7 @@ public partial class Operations
   /// Sends a Speckle Object to the provided <paramref name="transport"/> and (optionally) the default local cache
   /// </summary>
   /// <remarks/>
-  /// <inheritdoc cref="Send(Base, IReadOnlyCollection{ITransport}, Action{ConcurrentBag{ProgressArgs}}?, CancellationToken)"/>
+  /// <inheritdoc cref="Send(Base, IReadOnlyCollection{IWritableTransport}, Action{ConcurrentBag{ProgressArgs}}?, CancellationToken)"/>
   /// <param name="useDefaultCache">When <see langword="true"/>, an additional <see cref="SQLiteTransport"/> will be included</param>
   /// <exception cref="ArgumentNullException">The <paramref name="transport"/> or <paramref name="value"/> was <see langword="null"/></exception>
   /// <example><code>
@@ -23,7 +23,7 @@ public partial class Operations
   /// </code></example>
   public async Task<(string rootObjId, IReadOnlyDictionary<string, ObjectReference> convertedReferences)> Send(
     Base value,
-    ITransport transport,
+    IWritableTransport transport,
     bool useDefaultCache,
     Action<ConcurrentBag<ProgressArgs>>? onProgressAction = null,
     CancellationToken cancellationToken = default
@@ -34,7 +34,7 @@ public partial class Operations
       throw new ArgumentNullException(nameof(transport), "Expected a transport to be explicitly specified");
     }
 
-    List<ITransport> transports = new() { transport };
+    List<IWritableTransport> transports = new() { transport };
     using SQLiteTransport? localCache = useDefaultCache ? new SQLiteTransport { TransportName = "LC" } : null;
     if (localCache is not null)
     {
@@ -60,7 +60,7 @@ public partial class Operations
   /// <exception cref="OperationCanceledException">The <paramref name="cancellationToken"/> requested cancellation</exception>
   public async Task<(string rootObjId, IReadOnlyDictionary<string, ObjectReference> convertedReferences)> Send(
     Base value,
-    IReadOnlyCollection<ITransport> transports,
+    IReadOnlyCollection<IWritableTransport> transports,
     Action<ConcurrentBag<ProgressArgs>>? onProgressAction = null,
     CancellationToken cancellationToken = default
   )
@@ -92,7 +92,7 @@ public partial class Operations
       {
         t.OnProgressAction = internalProgressAction;
         t.CancellationToken = cancellationToken;
-        t.BeginWrite();
+        await t.BeginWrite().ConfigureAwait(false);
       }
 
       try
@@ -128,13 +128,13 @@ public partial class Operations
       {
         foreach (var t in transports)
         {
-          t.EndWrite();
+          await t.EndWrite().ConfigureAwait(false);
         }
       }
     }
   }
 
-  /// <returns><inheritdoc cref="Send(Base, IReadOnlyCollection{ITransport}, Action{ConcurrentBag{ProgressArgs}}?, CancellationToken)"/></returns>
+  /// <returns><inheritdoc cref="Send(Base, IReadOnlyCollection{IWritableTransport}, Action{ConcurrentBag{ProgressArgs}}?, CancellationToken)"/></returns>
   internal static async Task<string> SerializerSend(
     Base value,
     SpeckleObjectSerializer serializer,

src/Speckle.Sdk/Api/Operations/Operations.Serialize.cs

@@ -13,7 +13,7 @@ public partial class Operations
   /// <remarks>
   /// If you want to save and persist an object to Speckle Transport or Server,
   /// please use any of the "Send" methods.
-  /// <see cref="Send(Base,Speckle.Sdk.Transports.ITransport,bool,System.Action{System.Collections.Concurrent.ConcurrentBag{ProgressArgs}}?,System.Threading.CancellationToken)"/>
+  /// <see cref="Send(Base,Speckle.Sdk.Transports.IWritableTransport,bool,System.Action{System.Collections.Concurrent.ConcurrentBag{ProgressArgs}}?,System.Threading.CancellationToken)"/>
   /// </remarks>
   /// <param name="value">The object to serialise</param>
   /// <param name="cancellationToken"></param>

src/Speckle.Sdk/Models/Base.cs

@@ -73,7 +73,7 @@ public virtual string speckle_type
   public string GetId(bool decompose = false)
   {
     //TODO remove me
-    var transports = decompose ? [new MemoryTransport()] : Array.Empty<ITransport>();
+    var transports = decompose ? [new MemoryTransport()] : Array.Empty<IWritableTransport>();
     var serializer = new SpeckleObjectSerializer(transports);
 
     string obj = serializer.Serialize(this);

src/Speckle.Sdk/Serialisation/SpeckleObjectSerializer.cs

@@ -33,15 +33,15 @@ public class SpeckleObjectSerializer
   public Dictionary<string, ObjectReference> ObjectReferences { get; } = new();
 
   /// <summary>The sync transport. This transport will be used synchronously.</summary>
-  public IReadOnlyCollection<ITransport> WriteTransports { get; }
+  public IReadOnlyCollection<IWritableTransport> WriteTransports { get; }
 
   public CancellationToken CancellationToken { get; set; }
 
   /// <summary>The current total elapsed time spent serializing</summary>
   public TimeSpan Elapsed => _stopwatch.Elapsed;
 
   public SpeckleObjectSerializer()
-    : this(Array.Empty<ITransport>()) { }
+    : this(Array.Empty<IWritableTransport>()) { }
 
   /// <summary>
   /// Creates a new Serializer instance.
@@ -51,7 +51,7 @@ public SpeckleObjectSerializer()
   /// <param name="trackDetachedChildren">Whether to store all detachable objects while serializing. They can be retrieved via <see cref="ObjectReferences"/> post serialization.</param>
   /// <param name="cancellationToken"></param>
   public SpeckleObjectSerializer(
-    IReadOnlyCollection<ITransport> writeTransports,
+    IReadOnlyCollection<IWritableTransport> writeTransports,
     Action<ProgressArgs>? onProgressAction = null,
     bool trackDetachedChildren = false,
     CancellationToken cancellationToken = default

src/Speckle.Sdk/Transports/ITransport.cs

@@ -109,3 +109,52 @@ public interface IBlobCapableTransport
   // NOTE: not needed, should be implemented in "CopyObjectsAndChildren"
   //public void GetBlob(Blob obj);
 }
+
+public interface IWritableTransport
+{
+
+  /// <summary>
+  ///  Show how much time the transport was busy for.
+  /// </summary>
+  public TimeSpan Elapsed { get; }
+  /// <summary>
+  /// Human readable name for the transport
+  /// </summary>
+  public string TransportName { get; set; }
+
+
+  /// <summary>
+  /// Should be checked often and gracefully stop all in progress sending if requested.
+  /// </summary>
+  public CancellationToken CancellationToken { get; set; }
+
+  /// <summary>
+  /// Used to report progress during the transport's longer operations.
+  /// </summary>
+  public Action<ProgressArgs>? OnProgressAction { get; set; }
+
+  /// <summary>
+  /// Signals to the transport that writes are about to begin.
+  /// </summary>
+  public Task BeginWrite();
+
+  /// <summary>
+  /// Signals to the transport that no more items will need to be written.
+  /// </summary>
+  public Task EndWrite();
+
+  /// <summary>
+  /// Saves an object.
+  /// </summary>
+  /// <param name="id">The hash of the object.</param>
+  /// <param name="serializedObject">The full string representation of the object</param>
+  /// <exception cref="TransportException">Failed to save object</exception>
+  /// <exception cref="OperationCanceledException"><see cref="CancellationToken"/> requested cancel</exception>
+  public Task SaveObject(string id, string serializedObject);
+
+  /// <summary>
+  /// Awaitable method to figure out whether writing is completed.
+  /// </summary>
+  /// <returns></returns>
+  public Task WriteComplete();
+}

src/Speckle.Sdk/Transports/MemoryTransport.cs

@@ -8,7 +8,7 @@ namespace Speckle.Sdk.Transports;
 /// <summary>
 /// An in memory storage of speckle objects.
 /// </summary>
-public sealed class MemoryTransport : ITransport, ICloneable, IBlobCapableTransport
+public sealed class MemoryTransport : ITransport, ICloneable, IBlobCapableTransport, IWritableTransport
 {
   private readonly string _basePath;
   private readonly string _applicationName;
@@ -50,6 +50,23 @@ public object Clone()
     };
   }
 
+  Task IWritableTransport.EndWrite()
+  {
+    EndWrite();
+    return Task.CompletedTask;
+  }
+
+  Task IWritableTransport.SaveObject(string id, string serializedObject)
+  {
+    SaveObject(id, serializedObject);
+    return Task.CompletedTask;
+  }
+  Task IWritableTransport.BeginWrite()
+  {
+    BeginWrite();
+    return Task.CompletedTask;
+  }
+
   public CancellationToken CancellationToken { get; set; }
 
   public string TransportName { get; set; } = "Memory";

src/Speckle.Sdk/Transports/SQLiteTransport.cs

@@ -9,7 +9,7 @@
 
 namespace Speckle.Sdk.Transports;
 
-public sealed class SQLiteTransport : IDisposable, ICloneable, ITransport, IBlobCapableTransport
+public sealed class SQLiteTransport : IDisposable, ICloneable, ITransport, IBlobCapableTransport, IWritableTransport
 {
   private bool _isWriting;
   private const int MAX_TRANSACTION_SIZE = 1000;
@@ -128,6 +128,23 @@ public void BeginWrite()
     SavedObjectCount = 0;
   }
 
+  Task IWritableTransport.EndWrite()
+  {
+    EndWrite();
+    return Task.CompletedTask;
+  }
+
+  Task IWritableTransport.SaveObject(string id, string serializedObject)
+  {
+    SaveObject(id, serializedObject);
+    return Task.CompletedTask;
+  }
+  Task IWritableTransport.BeginWrite()
+  {
+    BeginWrite();
+    return Task.CompletedTask;
+  }
+
   public void EndWrite() { }
 
   public Task<Dictionary<string, bool>> HasObjects(IReadOnlyList<string> objectIds)

src/Speckle.Sdk/Transports/ServerTransport.cs

@@ -9,7 +9,7 @@
 
 namespace Speckle.Sdk.Transports;
 
-public sealed class ServerTransport : IServerTransport
+public sealed class ServerTransport : IServerTransport, IWritableTransport
 {
   private readonly ISpeckleHttp _http;
   private readonly ISdkActivityFactory _activityFactory;
@@ -217,6 +217,18 @@ public async Task<Dictionary<string, bool>> HasObjects(IReadOnlyList<string> obj
     return await Api.HasObjects(StreamId, objectIds).ConfigureAwait(false);
   }
 
+   Task IWritableTransport.EndWrite()
+  {
+    EndWrite();
+    return Task.CompletedTask;
+  }
+
+   Task IWritableTransport.SaveObject(string id, string serializedObject)
+  {
+    SaveObject(id, serializedObject);
+    return Task.CompletedTask;
+  }
+
   public void SaveObject(string id, string serializedObject)
   {
     lock (_sendBufferLock)
@@ -267,6 +279,12 @@ public async Task WriteComplete()
     }
   }
 
+   Task IWritableTransport.BeginWrite()
+  {
+    BeginWrite();
+    return Task.CompletedTask;
+  }
+
   public void EndWrite()
   {
     if (!_shouldSendThreadRun || _sendingThread == null)

tests/Speckle.Sdk.Tests.Performance/Benchmarks/GeneralSerializerTest.cs

@@ -51,7 +51,7 @@ public string RunTest()
   }
 }
 
-public class NullTransport : ITransport
+public class NullTransport : ITransport, IWritableTransport
 {
   public string TransportName { get; set; } = "";
   public Dictionary<string, object> TransportContext { get; } = new();
@@ -69,6 +69,23 @@ public Task WriteComplete()
   {
     return Task.CompletedTask;
   }
+
+  Task IWritableTransport.EndWrite()
+  {
+    EndWrite();
+    return Task.CompletedTask;
+  }
+
+  Task IWritableTransport.SaveObject(string id, string serializedObject)
+  {
+    SaveObject(id, serializedObject);
+    return Task.CompletedTask;
+  }
+  Task IWritableTransport.BeginWrite()
+  {
+    BeginWrite();
+    return Task.CompletedTask;
+  }
 
   public Task<string> GetObject(string id) => throw new NotImplementedException();