Merge pull request #259 from datalust/dev

2022.1 Maintenance Release

Author: nblumhardt

dockerfiles/seqcli/linux-arm64.Dockerfile

@@ -1,6 +1,6 @@
 # based on: https://github.com/dotnet/dotnet-docker/blob/master/2.0/runtime-deps/jessie/amd64/Dockerfile
 
-FROM --platform=linux/arm64 ubuntu:20.04
+FROM --platform=linux/arm/v8 ubuntu:20.04
 
 RUN apt-get update \
     && apt-get install -y --no-install-recommends \

global.json

@@ -1,5 +1,5 @@
 {
   "sdk": {
-    "version": "6.0.301"
+    "version": "6.0.402"
   }
 }

src/SeqCli/Templates/Export/TemplateSetExporter.cs

@@ -43,6 +43,7 @@ public async Task ExportTemplateSet()
             templateValueMap.MapAsReferenceList<WorkspaceContentPart>(nameof(WorkspaceContentPart.DashboardIds));
             templateValueMap.MapAsReferenceList<WorkspaceContentPart>(nameof(WorkspaceContentPart.QueryIds));
             templateValueMap.MapAsReferenceList<WorkspaceContentPart>(nameof(WorkspaceContentPart.SignalIds));
+            templateValueMap.Ignore<AlertEntity>(nameof(AlertEntity.Activity));
 
             await ExportTemplates<SignalEntity>(
                 id => _connection.Signals.FindAsync(id),

src/SeqCli/Templates/Export/TemplateValueMap.cs

@@ -14,6 +14,7 @@ class TemplateValueMap
         readonly HashSet<PropertyInfo> _referenceProperties = new();
         readonly HashSet<PropertyInfo> _referenceListProperties = new();
         readonly Dictionary<PropertyInfo, string> _argProperties = new();
+        readonly HashSet<PropertyInfo> _ignoredProperties = new();
 
         static PropertyInfo GetProperty<T>(string propertyName) =>
             typeof(T).GetProperty(propertyName) ??
@@ -39,6 +40,11 @@ public void AddReferencedTemplate(string entityId, string name)
             _idToReferenceName.Add(entityId, name);
         }
 
+        public void Ignore<T>(string propertyName)
+        {
+            _ignoredProperties.Add(GetProperty<T>(propertyName));
+        }
+
         public bool TryGetRawValue(PropertyInfo pi, object? value, [MaybeNullWhen(false)] out string raw)
         {
             if (value is string s && _referenceProperties.Contains(pi) &&
@@ -72,6 +78,8 @@ public bool TryGetRawElement(PropertyInfo pi, object? elementValue, [MaybeNullWh
             return false;
         }
 
+        public bool IsIgnored(PropertyInfo pi) => _ignoredProperties.Contains(pi);
+
         static string FormatReference(string name)
         {
             var jsonStringName = JsonConvert.SerializeObject(name);

src/SeqCli/Templates/Export/TemplateWriter.cs

@@ -30,13 +30,14 @@ public static async Task WriteTemplateAsync(TextWriter writer, Entity entity, Te
             await WriteObjectAsync(jw, entity, templateValueMap, annotateAsResource: true);
         }
 
-        static async Task WriteValueAsync(JsonWriter jw, object? v, TemplateValueMap templateValueMap)
+        static async Task WriteValueAsync(JsonWriter jw, object? v, TemplateValueMap templateValueMap, PropertyInfo? enclosingProperty = null)
         {
             await (v switch
             {
                 null => jw.WriteNullAsync(),
                 string s => jw.WriteValueAsync(s),
-                IEnumerable a => WriteArrayAsync(jw, a, templateValueMap),
+                IReadOnlyDictionary<string, string> ds => WriteDictionaryAsync(jw, ds, templateValueMap, enclosingProperty),
+                IEnumerable a => WriteArrayAsync(jw, a, templateValueMap, enclosingProperty),
                 var o when o.GetType().IsClass => WriteObjectAsync(jw, o, templateValueMap),
                 var e when e.GetType().IsEnum => jw.WriteValueAsync(e.ToString()),
                 _ => jw.WriteValueAsync(v)
@@ -63,10 +64,31 @@ static async Task WriteArrayAsync(JsonWriter jw, object a, TemplateValueMap temp
             await jw.WriteEndArrayAsync();
         }
 
-        static async Task WriteObjectAsync(JsonWriter jw, object o, TemplateValueMap templateValueMap, bool annotateAsResource = false)
+        static async Task WriteDictionaryAsync(JsonWriter jw, IReadOnlyDictionary<string, string> ds, TemplateValueMap templateValueMap, PropertyInfo? enclosingProperty = null)
         {
             await jw.WriteStartObjectAsync();
 
+            foreach (var (k, v) in ds)
+            {
+                await jw.WritePropertyNameAsync(k);
+
+                if (enclosingProperty != null &&
+                    templateValueMap.TryGetRawElement(enclosingProperty, v, out var raw))
+                {
+                    await jw.WriteRawValueAsync(raw);
+                }
+                else
+                {
+                    await WriteValueAsync(jw, v, templateValueMap);
+                }
+            }
+            
+            await jw.WriteEndObjectAsync();
+        }
+
+        static async Task WriteObjectAsync(JsonWriter jw, object o, TemplateValueMap templateValueMap, bool annotateAsResource = false)
+        {
+            await jw.WriteStartObjectAsync();
 
             if (annotateAsResource)
             {
@@ -76,6 +98,9 @@ static async Task WriteObjectAsync(JsonWriter jw, object o, TemplateValueMap tem
 
             foreach (var (pi, v) in GetTemplateProperties(o))
             {
+                if (templateValueMap.IsIgnored(pi))
+                    continue;
+                
                 var pa = pi.GetCustomAttribute<JsonPropertyAttribute>();
                 if (pa?.DefaultValueHandling == DefaultValueHandling.Ignore &&
                     v == null || v as int? == 0 || v as decimal? == 0m || v as uint? == 0)
@@ -87,10 +112,8 @@ static async Task WriteObjectAsync(JsonWriter jw, object o, TemplateValueMap tem
 
                 if (templateValueMap.TryGetRawValue(pi, v, out var raw))
                     await jw.WriteRawValueAsync(raw);
-                else if (v is not string && v is IEnumerable)
-                    await WriteArrayAsync(jw, v, templateValueMap, pi);
                 else
-                    await WriteValueAsync(jw, v, templateValueMap);
+                    await WriteValueAsync(jw, v, templateValueMap, pi);
             }
 
             await jw.WriteEndObjectAsync();

src/SeqCli/Templates/Import/TemplateSetImporter.cs

@@ -41,7 +41,7 @@ static class TemplateSetImporter
             bool merge)
         {
             var ordering = new[] {"users", "signals", "apps", "appinstances",
-                "dashboards", "sqlqueries", "workspaces", "retentionpolicies"}.ToList();
+                "dashboards", "sqlqueries", "workspaces", "retentionpolicies", "alerts"}.ToList();
 
             var sorted = templates.OrderBy(t => ordering.IndexOf(t.ResourceGroup));
 

test/SeqCli.Tests/Templates/TemplateWriterTests.cs

@@ -15,6 +15,8 @@ class TestEntity : Entity
         public string Name { get; set; }
         public string ReferencedId { get; set; }
         public List<int> Numbers { get; set; }
+        public List<string> Strings { get; set; }
+        public Dictionary<string, string> Dictionary { get; set; }
     }
 
     public class TemplateWriterTests
@@ -27,14 +29,17 @@ public async Task WritesTemplates()
                 Id = "test-stuff",
                 Name = "Test Stuff",
                 ReferencedId = "test-ref",
-                Numbers = new List<int> { 1, 2, 3 }
+                Numbers = new List<int> { 1, 2, 3 },
+                Strings = new List<string> { "test" },
+                Dictionary = new Dictionary<string, string>{ ["First"] = "a" }
             };
 
             const string referencedTemplateName = "Referenced";
 
             var tvm = new TemplateValueMap();
             tvm.AddReferencedTemplate(entity.ReferencedId, referencedTemplateName);
             tvm.MapAsReference<TestEntity>(nameof(TestEntity.ReferencedId));
+            tvm.Ignore<TestEntity>(nameof(TestEntity.Strings));
 
             var content = new StringWriter();
             await TemplateWriter.WriteTemplateAsync(content, entity, tvm);

test/SeqCli.Tests/Templates/test-Expected.template

@@ -6,5 +6,8 @@
     1,
     2,
     3
-  ]
+  ],
+  "Dictionary": {
+    "First": "a"
+  }
 }