Implement WORKER directive.

Author: sharpjs

PSql.Deploy.Engine.Tests/Seeds/LoadedSeedTests.cs

@@ -29,7 +29,7 @@ public void Seed_Get()
     public void Modules_Get()
     {
         var seed    = new Seed("a", "b");
-        var modules = ImmutableArray.Create(new SeedModule("c", false, default, default, default));
+        var modules = ImmutableArray.Create(new SeedModule("c", 0, default, default, default));
 
         var loadedSeed = new LoadedSeed(seed, modules);
 

PSql.Deploy.Engine.Tests/Seeds/SeedApplicatorTests.cs

@@ -251,7 +251,7 @@ private static SeedModule MakeModule(
 
         return new(
             name,
-            allWorkers,
+            allWorkers ? -1 : 0, // workerId
             batches .ToImmutableArray(),
             provides.ToImmutableArray(),
             requires.ToImmutableArray()

PSql.Deploy.Engine.Tests/Seeds/SeedModuleTests.cs

@@ -11,34 +11,32 @@ public void Construct_NullName()
     {
         Should.Throw<ArgumentNullException>(() =>
         {
-            _ = new SeedModule(null!, false, default, default, default);
+            _ = new SeedModule(null!, 0, default, default, default);
         });
     }
 
     [Test]
     public void Name_Get()
     {
-        var module = new SeedModule("a", false, default, default, default);
+        var module = new SeedModule("a", 0, default, default, default);
 
         module.Name.ShouldBe("a");
     }
 
     [Test]
-    [TestCase(false)]
-    [TestCase(true )]
-    public void AllWorkers_Get(bool value)
+    public void WorkerId_Get()
     {
-        var module = new SeedModule("a", value, default, default, default);
+        var module = new SeedModule("a", 3, default, default, default);
 
-        module.AllWorkers.ShouldBe(value);
+        module.WorkerId.ShouldBe(3);
     }
 
     [Test]
     public void Batches_Get()
     {
         var items = ImmutableArray.Create("b");
 
-        var module = new SeedModule("a", false, items, default, default);
+        var module = new SeedModule("a", 0, items, default, default);
 
         module.Batches.ShouldBe(items);
     }
@@ -48,7 +46,7 @@ public void Provides_Get()
     {
         var items = ImmutableArray.Create("b");
 
-        var module = new SeedModule("a", false, default, items, default);
+        var module = new SeedModule("a", 0, default, items, default);
 
         module.Provides.ShouldBe(items);
     }
@@ -58,7 +56,7 @@ public void Requires_Get()
     {
         var items = ImmutableArray.Create("b");
 
-        var module = new SeedModule("a", false, default, default, items);
+        var module = new SeedModule("a", 0, default, default, items);
 
         module.Requires.ShouldBe(items);
     }

PSql.Deploy.Engine/Seeds/SeedApplicator.cs

@@ -161,14 +161,28 @@ private void Populate(DependencyQueue<SeedModule> queue)
 
         foreach (var module in Seed.Modules)
         {
-            builder
-                .NewEntry(module.Name, module)
-                .AddProvides(module.Provides)
-                .AddRequires(module.Requires)
-                .Enqueue();
+            if (module.WorkerId is -1)
+                for (var i = 1; i <= MaxParallelism; i++)
+                    Populate(builder, Clone(module, workerId: i));
+            else
+                Populate(builder, module);
         }
     }
 
+    private static void Populate(DependencyQueueEntryBuilder<SeedModule> builder, SeedModule module)
+    {
+        builder
+            .NewEntry(module.Name, module)
+            .AddProvides(module.Provides)
+            .AddRequires(module.Requires)
+            .Enqueue();
+    }
+
+    private static SeedModule Clone(SeedModule module, int workerId)
+    {
+        return new(module.Name, workerId, module.Batches, module.Provides, module.Requires);
+    }
+
     private void Validate(DependencyQueue<SeedModule> queue)
     {
         var errors = queue.Validate();
@@ -185,7 +199,11 @@ private async Task SeedWorkerMainAsync(QueueContext context)
 
         await PrepareAsync(connection, context);
 
-        while (await context.GetNextEntryAsync() is { Value: var module })
+        bool CanTake(SeedModule module)
+            => module.WorkerId == 0
+            || module.WorkerId == context.WorkerId;
+
+        while (await context.GetNextEntryAsync(CanTake) is { Value: var module })
             await ExecuteAsync(module, connection, context);
     }
 

PSql.Deploy.Engine/Seeds/SeedLoader.cs

@@ -205,7 +205,7 @@ private void EndModule()
     {
         _modules.Add(new(
             _moduleName,
-            _allWorkers,
+            _allWorkers ? -1 : 0, // workerId // TODO: constants or a custom struct
             _batches .ToImmutable(),
             _provides.ToImmutableArray(),
             _requires.ToImmutableArray()

PSql.Deploy.Engine/Seeds/SeedModule.cs

@@ -14,11 +14,12 @@ public class SeedModule
     /// <param name="name">
     ///   The name of the module.
     /// </param>
-    /// <param name="allWorkers">
-    ///   Whether the module should run on every worker thread in a seed
-    ///   application (<see langword="true"/>) or singly on any one available
-    ///   worker thread (<see langword="false"/>).  The usual case is
-    ///   <see langword="false"/>.
+    /// <param name="workerId">
+    ///   A value that determines which worker threads can apply the module.
+    ///   A positive value nominates a specific worker by that worker's ordinal
+    ///   ID.  The default value, <c>0</c>, indicates that any worker can apply
+    ///   the module.  The special value <c>-1</c> indicates that <b>every</b>
+    ///   worker must apply the module.
     /// </param>
     /// <param name="batches">
     ///   The SQL batches to be executed when the module runs.
@@ -34,21 +35,26 @@ public class SeedModule
     /// <exception cref="ArgumentNullException">
     ///   <paramref name="name"/> is <see langword="null"/>.
     /// </exception>
+    /// <exception cref="ArgumentOutOfRangeException">
+    ///   <paramref name="workerId"/> is less than <c>-1</c>.
+    /// </exception>
     public SeedModule(
         string                 name,
-        bool                   allWorkers,
+        int                    workerId,
         ImmutableArray<string> batches,
         ImmutableArray<string> provides,
         ImmutableArray<string> requires)
     {
         if (name is null)
             throw new ArgumentNullException(nameof(name));
+        if (workerId < -1)
+            throw new ArgumentOutOfRangeException(nameof(workerId));
 
-        Name       = name;
-        AllWorkers = allWorkers;
-        Batches    = batches;
-        Provides   = provides;
-        Requires   = requires;
+        Name     = name;
+        WorkerId = workerId;
+        Batches  = batches;
+        Provides = provides;
+        Requires = requires;
     }
 
     /// <summary>
@@ -57,12 +63,13 @@ public SeedModule(
     public string Name { get; }
 
     /// <summary>
-    ///   Gets whether the module must run for each worker thread in a a seed
-    ///   application (<see langword="true"/>) or singly on any one available
-    ///   worker thread (<see langword="false"/>).  The usual case is
-    ///   <see langword="false"/>.
+    ///   Gets a value that determines which worker threads can apply the
+    ///   module.  A positive value nominates a specific worker by that
+    ///   worker's ordinal ID.  The default value, <c>0</c>, indicates that any
+    ///   worker can apply the module.  The special value <c>-1</c> indicates
+    ///   that <b>every</b> worker must apply the module.
     /// </summary>
-    public bool AllWorkers { get; }
+    public int WorkerId { get; }
 
     /// <summary>
     ///   Gets the SQL batches to be executed when the module runs.