stella-ops.org/git.stella-ops.org
1
0
Fork 0
Code Issues Pull Requests Actions 2 Releases Wiki Activity

Search/AdvisoryAI and DAL conversion to EF finishes up. Preparation for microservices consolidation.

Browse Source
This commit is contained in:
master
2026-02-25 18:19:22 +02:00
parent 4db038123b
commit 63c70a6d37
447 changed files with 52257 additions and 2636 deletions
Download Patch File Download Diff File Expand all files Collapse all files

12
src/Concelier/__Libraries/StellaOps.Concelier.Persistence/Postgres/Repositories/AdvisoryCanonicalRepository.cs
View File

@@ -20,10 +20,12 @@ namespace StellaOps.Concelier.Persistence.Postgres.Repositories;
public sealed class AdvisoryCanonicalRepository : RepositoryBase<ConcelierDataSource>, IAdvisoryCanonicalRepository
{
private const string SystemTenantId = "_system";
private readonly TimeProvider _timeProvider;
public AdvisoryCanonicalRepository(ConcelierDataSource dataSource, ILogger<AdvisoryCanonicalRepository> logger)
public AdvisoryCanonicalRepository(ConcelierDataSource dataSource, ILogger<AdvisoryCanonicalRepository> logger, TimeProvider? timeProvider = null)
: base(dataSource, logger)
{
_timeProvider = timeProvider ?? TimeProvider.System;
}
#region Canonical Advisory Operations
@@ -145,11 +147,12 @@ public sealed class AdvisoryCanonicalRepository : RepositoryBase<ConcelierDataSo
exploit_known = EXCLUDED.exploit_known OR vuln.advisory_canonical.exploit_known,
title = COALESCE(EXCLUDED.title, vuln.advisory_canonical.title),
summary = COALESCE(EXCLUDED.summary, vuln.advisory_canonical.summary),
updated_at = NOW()
updated_at = @now
RETURNING id
""";
var id = entity.Id == Guid.Empty ? Guid.NewGuid() : entity.Id;
var now = _timeProvider.GetUtcNow();
return await ExecuteScalarAsync<Guid>(
SystemTenantId,
@@ -168,6 +171,7 @@ public sealed class AdvisoryCanonicalRepository : RepositoryBase<ConcelierDataSo
AddParameter(cmd, "exploit_known", entity.ExploitKnown);
AddParameter(cmd, "title", entity.Title);
AddParameter(cmd, "summary", entity.Summary);
AddParameter(cmd, "now", now);
},
ct).ConfigureAwait(false);
}
@@ -176,10 +180,11 @@ public sealed class AdvisoryCanonicalRepository : RepositoryBase<ConcelierDataSo
{
const string sql = """
UPDATE vuln.advisory_canonical
SET status = @status, updated_at = NOW()
SET status = @status, updated_at = @now
WHERE id = @id
""";
var now = _timeProvider.GetUtcNow();
await ExecuteAsync(
SystemTenantId,
sql,
@@ -187,6 +192,7 @@ public sealed class AdvisoryCanonicalRepository : RepositoryBase<ConcelierDataSo
{
AddParameter(cmd, "id", id);
AddParameter(cmd, "status", status);
AddParameter(cmd, "now", now);
},
ct).ConfigureAwait(false);
}

7
src/Concelier/__Libraries/StellaOps.Concelier.Persistence/Postgres/Repositories/AdvisoryRepository.cs
View File

@@ -15,13 +15,15 @@ namespace StellaOps.Concelier.Persistence.Postgres.Repositories;
public sealed class AdvisoryRepository : RepositoryBase<ConcelierDataSource>, IAdvisoryRepository
{
private const string SystemTenantId = "_system";
private readonly TimeProvider _timeProvider;
/// <summary>
/// Creates a new advisory repository.
/// </summary>
public AdvisoryRepository(ConcelierDataSource dataSource, ILogger<AdvisoryRepository> logger)
public AdvisoryRepository(ConcelierDataSource dataSource, ILogger<AdvisoryRepository> logger, TimeProvider? timeProvider = null)
: base(dataSource, logger)
{
_timeProvider = timeProvider ?? TimeProvider.System;
}
/// <inheritdoc />
@@ -409,7 +411,7 @@ public sealed class AdvisoryRepository : RepositoryBase<ConcelierDataSource>, IA
withdrawn_at = EXCLUDED.withdrawn_at,
provenance = vuln.advisories.provenance || EXCLUDED.provenance,
raw_payload = EXCLUDED.raw_payload,
updated_at = NOW()
updated_at = @now
RETURNING id, advisory_key, primary_vuln_id, source_id, title, summary, description,
severity, published_at, modified_at, withdrawn_at, provenance::text, raw_Payload::text,
created_at, updated_at
@@ -435,6 +437,7 @@ public sealed class AdvisoryRepository : RepositoryBase<ConcelierDataSource>, IA
AddParameter(command, "withdrawn_at", advisory.WithdrawnAt);
AddJsonbParameter(command, "provenance", advisory.Provenance);
AddJsonbParameter(command, "raw_payload", advisory.RawPayload);
AddParameter(command, "now", _timeProvider.GetUtcNow());
await using var reader = await command.ExecuteReaderAsync(cancellationToken).ConfigureAwait(false);
await reader.ReadAsync(cancellationToken).ConfigureAwait(false);

31
src/Concelier/__Libraries/StellaOps.Concelier.Persistence/Postgres/Repositories/AdvisorySourceReadRepository.cs
View File

@@ -10,12 +10,15 @@ namespace StellaOps.Concelier.Persistence.Postgres.Repositories;
public sealed class AdvisorySourceReadRepository : RepositoryBase<ConcelierDataSource>, IAdvisorySourceReadRepository
{
private const string SystemTenantId = "_system";
private readonly TimeProvider _timeProvider;
public AdvisorySourceReadRepository(
ConcelierDataSource dataSource,
ILogger<AdvisorySourceReadRepository> logger)
ILogger<AdvisorySourceReadRepository> logger,
TimeProvider? timeProvider = null)
: base(dataSource, logger)
{
_timeProvider = timeProvider ?? TimeProvider.System;
}
public Task<IReadOnlyList<AdvisorySourceFreshnessRecord>> ListAsync(
@@ -67,12 +70,12 @@ public sealed class AdvisorySourceReadRepository : RepositoryBase<ConcelierDataS
warning_ratio,
CAST(
EXTRACT(EPOCH FROM (
NOW() - COALESCE(last_success_at, last_sync_at, NOW())
@now - COALESCE(last_success_at, last_sync_at, @now)
)) AS BIGINT) AS freshness_age_seconds,
CASE
WHEN last_success_at IS NULL THEN 'unavailable'
WHEN EXTRACT(EPOCH FROM (NOW() - last_success_at)) > freshness_sla_seconds THEN 'stale'
WHEN EXTRACT(EPOCH FROM (NOW() - last_success_at)) > (freshness_sla_seconds * warning_ratio) THEN 'warning'
WHEN EXTRACT(EPOCH FROM (@now - last_success_at)) > freshness_sla_seconds THEN 'stale'
WHEN EXTRACT(EPOCH FROM (@now - last_success_at)) > (freshness_sla_seconds * warning_ratio) THEN 'warning'
ELSE 'healthy'
END AS freshness_status,
signature_status,
@@ -84,10 +87,15 @@ public sealed class AdvisorySourceReadRepository : RepositoryBase<ConcelierDataS
ORDER BY enabled DESC, priority DESC, key
""";
var now = _timeProvider.GetUtcNow();
return QueryAsync(
SystemTenantId,
sql,
cmd => AddParameter(cmd, "include_disabled", includeDisabled),
cmd =>
{
AddParameter(cmd, "include_disabled", includeDisabled);
AddParameter(cmd, "now", now);
},
MapRecord,
cancellationToken);
}
@@ -141,12 +149,12 @@ public sealed class AdvisorySourceReadRepository : RepositoryBase<ConcelierDataS
warning_ratio,
CAST(
EXTRACT(EPOCH FROM (
NOW() - COALESCE(last_success_at, last_sync_at, NOW())
@now - COALESCE(last_success_at, last_sync_at, @now)
)) AS BIGINT) AS freshness_age_seconds,
CASE
WHEN last_success_at IS NULL THEN 'unavailable'
WHEN EXTRACT(EPOCH FROM (NOW() - last_success_at)) > freshness_sla_seconds THEN 'stale'
WHEN EXTRACT(EPOCH FROM (NOW() - last_success_at)) > (freshness_sla_seconds * warning_ratio) THEN 'warning'
WHEN EXTRACT(EPOCH FROM (@now - last_success_at)) > freshness_sla_seconds THEN 'stale'
WHEN EXTRACT(EPOCH FROM (@now - last_success_at)) > (freshness_sla_seconds * warning_ratio) THEN 'warning'
ELSE 'healthy'
END AS freshness_status,
signature_status,
@@ -157,10 +165,15 @@ public sealed class AdvisorySourceReadRepository : RepositoryBase<ConcelierDataS
FROM source_projection
""";
var now = _timeProvider.GetUtcNow();
return QuerySingleOrDefaultAsync(
SystemTenantId,
sql,
cmd => AddParameter(cmd, "source_id", sourceId),
cmd =>
{
AddParameter(cmd, "source_id", sourceId);
AddParameter(cmd, "now", now);
},
MapRecord,
cancellationToken);
}

9
src/Concelier/__Libraries/StellaOps.Concelier.Persistence/Postgres/Repositories/DocumentRepository.cs
View File

@@ -18,11 +18,13 @@ public sealed class DocumentRepository : IDocumentRepository
{
private readonly ConcelierDataSource _dataSource;
private readonly ILogger<DocumentRepository> _logger;
private readonly TimeProvider _timeProvider;
public DocumentRepository(ConcelierDataSource dataSource, ILogger<DocumentRepository> logger)
public DocumentRepository(ConcelierDataSource dataSource, ILogger<DocumentRepository> logger, TimeProvider? timeProvider = null)
{
_dataSource = dataSource ?? throw new ArgumentNullException(nameof(dataSource));
_logger = logger ?? throw new ArgumentNullException(nameof(logger));
_timeProvider = timeProvider ?? TimeProvider.System;
}
public async Task<DocumentRecordEntity?> FindAsync(Guid id, CancellationToken cancellationToken)
@@ -119,9 +121,10 @@ public sealed class DocumentRepository : IDocumentRepository
await using var connection = await _dataSource.OpenSystemConnectionAsync(cancellationToken);
await using var context = ConcelierDbContextFactory.Create(connection, 30, _dataSource.SchemaName);
var now = _timeProvider.GetUtcNow();
await context.Database.ExecuteSqlRawAsync(
"UPDATE concelier.source_documents SET status = {0}, updated_at = NOW() WHERE id = {1}",
[status, id],
"UPDATE concelier.source_documents SET status = {0}, updated_at = {1} WHERE id = {2}",
[status, now, id],
cancellationToken);
}

14
src/Concelier/__Libraries/StellaOps.Concelier.Persistence/Postgres/Repositories/ProvenanceScopeRepository.cs
View File

@@ -20,10 +20,12 @@ namespace StellaOps.Concelier.Persistence.Postgres.Repositories;
public sealed class ProvenanceScopeRepository : RepositoryBase<ConcelierDataSource>, IProvenanceScopeRepository
{
private const string SystemTenantId = "_system";
private readonly TimeProvider _timeProvider;
public ProvenanceScopeRepository(ConcelierDataSource dataSource, ILogger<ProvenanceScopeRepository> logger)
public ProvenanceScopeRepository(ConcelierDataSource dataSource, ILogger<ProvenanceScopeRepository> logger, TimeProvider? timeProvider = null)
: base(dataSource, logger)
{
_timeProvider = timeProvider ?? TimeProvider.System;
}
#region CRUD Operations
@@ -138,7 +140,7 @@ public sealed class ProvenanceScopeRepository : RepositoryBase<ConcelierDataSour
)
VALUES (
@id, @canonical_id, @distro_release, @backport_semver, @patch_id,
@patch_origin, @evidence_ref, @confidence, NOW(), NOW()
@patch_origin, @evidence_ref, @confidence, @now, @now
)
ON CONFLICT (canonical_id, distro_release)
DO UPDATE SET
@@ -147,11 +149,12 @@ public sealed class ProvenanceScopeRepository : RepositoryBase<ConcelierDataSour
patch_origin = EXCLUDED.patch_origin,
evidence_ref = EXCLUDED.evidence_ref,
confidence = EXCLUDED.confidence,
updated_at = NOW()
updated_at = @now
RETURNING id
""";
var id = entity.Id == Guid.Empty ? Guid.NewGuid() : entity.Id;
var now = _timeProvider.GetUtcNow();
var result = await ExecuteScalarAsync<Guid>(
SystemTenantId,
@@ -166,6 +169,7 @@ public sealed class ProvenanceScopeRepository : RepositoryBase<ConcelierDataSour
AddParameter(cmd, "patch_origin", entity.PatchOrigin);
AddParameter(cmd, "evidence_ref", entity.EvidenceRef);
AddParameter(cmd, "confidence", entity.Confidence);
AddParameter(cmd, "now", now);
},
ct);
@@ -181,10 +185,11 @@ public sealed class ProvenanceScopeRepository : RepositoryBase<ConcelierDataSour
patch_origin = @patch_origin,
evidence_ref = @evidence_ref,
confidence = @confidence,
updated_at = NOW()
updated_at = @now
WHERE id = @id
""";
var now = _timeProvider.GetUtcNow();
return ExecuteAsync(
SystemTenantId,
sql,
@@ -196,6 +201,7 @@ public sealed class ProvenanceScopeRepository : RepositoryBase<ConcelierDataSour
AddParameter(cmd, "patch_origin", entity.PatchOrigin);
AddParameter(cmd, "evidence_ref", entity.EvidenceRef);
AddParameter(cmd, "confidence", entity.Confidence);
AddParameter(cmd, "now", now);
},
ct);
}

10
src/Concelier/__Libraries/StellaOps.Concelier.Persistence/Postgres/Repositories/SourceRepository.cs
View File

@@ -12,11 +12,13 @@ public sealed class SourceRepository : ISourceRepository
{
private readonly ConcelierDataSource _dataSource;
private readonly ILogger<SourceRepository> _logger;
private readonly TimeProvider _timeProvider;
public SourceRepository(ConcelierDataSource dataSource, ILogger<SourceRepository> logger)
public SourceRepository(ConcelierDataSource dataSource, ILogger<SourceRepository> logger, TimeProvider? timeProvider = null)
{
_dataSource = dataSource ?? throw new ArgumentNullException(nameof(dataSource));
_logger = logger ?? throw new ArgumentNullException(nameof(logger));
_timeProvider = timeProvider ?? TimeProvider.System;
}
public async Task<SourceEntity> UpsertAsync(SourceEntity source, CancellationToken cancellationToken = default)
@@ -35,7 +37,7 @@ public sealed class SourceRepository : ISourceRepository
enabled = EXCLUDED.enabled,
config = EXCLUDED.config,
metadata = EXCLUDED.metadata,
updated_at = NOW()
updated_at = {9}
RETURNING id, key, name, source_type, url, priority, enabled,
config::text, metadata::text, created_at, updated_at
""";
@@ -43,6 +45,7 @@ public sealed class SourceRepository : ISourceRepository
await using var connection = await _dataSource.OpenSystemConnectionAsync(cancellationToken);
await using var context = ConcelierDbContextFactory.Create(connection, 30, _dataSource.SchemaName);
var now = _timeProvider.GetUtcNow();
var rows = await context.Database.SqlQueryRaw<SourceRawResult>(
sql,
source.Id,
@@ -53,7 +56,8 @@ public sealed class SourceRepository : ISourceRepository
source.Priority,
source.Enabled,
source.Config,
source.Metadata)
source.Metadata,
now)
.ToListAsync(cancellationToken);
var row = rows.SingleOrDefault() ?? throw new InvalidOperationException("Upsert returned null");

10
src/Concelier/__Libraries/StellaOps.Concelier.Persistence/Postgres/Repositories/SourceStateRepository.cs
View File

@@ -12,11 +12,13 @@ public sealed class SourceStateRepository : ISourceStateRepository
{
private readonly ConcelierDataSource _dataSource;
private readonly ILogger<SourceStateRepository> _logger;
private readonly TimeProvider _timeProvider;
public SourceStateRepository(ConcelierDataSource dataSource, ILogger<SourceStateRepository> logger)
public SourceStateRepository(ConcelierDataSource dataSource, ILogger<SourceStateRepository> logger, TimeProvider? timeProvider = null)
{
_dataSource = dataSource ?? throw new ArgumentNullException(nameof(dataSource));
_logger = logger ?? throw new ArgumentNullException(nameof(logger));
_timeProvider = timeProvider ?? TimeProvider.System;
}
public async Task<SourceStateEntity> UpsertAsync(SourceStateEntity state, CancellationToken cancellationToken = default)
@@ -37,7 +39,7 @@ public sealed class SourceStateRepository : ISourceStateRepository
sync_count = EXCLUDED.sync_count,
error_count = EXCLUDED.error_count,
metadata = EXCLUDED.metadata,
updated_at = NOW()
updated_at = {9}
RETURNING id, source_id, cursor, last_sync_at, last_success_at, last_error,
sync_count, error_count, metadata::text, updated_at
""";
@@ -45,6 +47,7 @@ public sealed class SourceStateRepository : ISourceStateRepository
await using var connection = await _dataSource.OpenSystemConnectionAsync(cancellationToken);
await using var context = ConcelierDbContextFactory.Create(connection, 30, _dataSource.SchemaName);
var now = _timeProvider.GetUtcNow();
var rows = await context.Database.SqlQueryRaw<SourceStateRawResult>(
sql,
state.Id,
@@ -55,7 +58,8 @@ public sealed class SourceStateRepository : ISourceStateRepository
state.LastError ?? (object)DBNull.Value,
state.SyncCount,
state.ErrorCount,
state.Metadata)
state.Metadata,
now)
.ToListAsync(cancellationToken);
var row = rows.SingleOrDefault() ?? throw new InvalidOperationException("Upsert returned null");

4
src/Concelier/__Libraries/StellaOps.Concelier.Persistence/Postgres/Repositories/SyncLedgerRepository.cs
View File

@@ -222,9 +222,10 @@ public sealed class SyncLedgerRepository : RepositoryBase<ConcelierDataSource>,
require_signature = EXCLUDED.require_signature,
allowed_signers = EXCLUDED.allowed_signers,
enabled = EXCLUDED.enabled,
updated_at = NOW()
updated_at = @now
""";
var now = _timeProvider.GetUtcNow();
await ExecuteAsync(
SystemTenantId,
sql,
@@ -240,6 +241,7 @@ public sealed class SyncLedgerRepository : RepositoryBase<ConcelierDataSource>,
AddParameter(cmd, "require_signature", policy.RequireSignature);
AddTextArrayParameter(cmd, "allowed_signers", policy.AllowedSigners);
AddParameter(cmd, "enabled", policy.Enabled);
AddParameter(cmd, "now", now);
},
ct).ConfigureAwait(false);
}

203
src/Concelier/__Libraries/StellaOps.Concelier.ProofService.Postgres/EfCore/CompiledModels/BinaryFingerprintEntityEntityType.cs Normal file
View File

@@ -0,0 +1,203 @@
// <auto-generated />
using System;
using System.Reflection;
using Microsoft.EntityFrameworkCore.Infrastructure;
using Microsoft.EntityFrameworkCore.Metadata;
using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
using StellaOps.Concelier.ProofService.Postgres.EfCore.Models;
#pragma warning disable 219, 612, 618
#nullable disable
namespace StellaOps.Concelier.ProofService.Postgres.EfCore.CompiledModels
{
[EntityFrameworkInternal]
public partial class BinaryFingerprintEntityEntityType
{
public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType baseEntityType = null)
{
var runtimeEntityType = model.AddEntityType(
"StellaOps.Concelier.ProofService.Postgres.EfCore.Models.BinaryFingerprintEntity",
typeof(BinaryFingerprintEntity),
baseEntityType,
propertyCount: 16,
namedIndexCount: 4,
keyCount: 1);
var fingerprintId = runtimeEntityType.AddProperty(
"FingerprintId",
typeof(string),
propertyInfo: typeof(BinaryFingerprintEntity).GetProperty("FingerprintId", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly),
fieldInfo: typeof(BinaryFingerprintEntity).GetField("<FingerprintId>k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly),
afterSaveBehavior: PropertySaveBehavior.Throw);
fingerprintId.AddAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.None);
fingerprintId.AddAnnotation("Relational:ColumnName", "fingerprint_id");
var architecture = runtimeEntityType.AddProperty(
"Architecture",
typeof(string),
propertyInfo: typeof(BinaryFingerprintEntity).GetProperty("Architecture", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly),
fieldInfo: typeof(BinaryFingerprintEntity).GetField("<Architecture>k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly));
architecture.AddAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.None);
architecture.AddAnnotation("Relational:ColumnName", "architecture");
var compiler = runtimeEntityType.AddProperty(
"Compiler",
typeof(string),
propertyInfo: typeof(BinaryFingerprintEntity).GetProperty("Compiler", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly),
fieldInfo: typeof(BinaryFingerprintEntity).GetField("<Compiler>k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly),
nullable: true);
compiler.AddAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.None);
compiler.AddAnnotation("Relational:ColumnName", "compiler");
var createdAt = runtimeEntityType.AddProperty(
"CreatedAt",
typeof(DateTimeOffset),
propertyInfo: typeof(BinaryFingerprintEntity).GetProperty("CreatedAt", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly),
fieldInfo: typeof(BinaryFingerprintEntity).GetField("<CreatedAt>k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly),
valueGenerated: ValueGenerated.OnAdd,
sentinel: new DateTimeOffset(new DateTime(1, 1, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)));
createdAt.AddAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.None);
createdAt.AddAnnotation("Relational:ColumnName", "created_at");
createdAt.AddAnnotation("Relational:DefaultValueSql", "now()");
var cveId = runtimeEntityType.AddProperty(
"CveId",
typeof(string),
propertyInfo: typeof(BinaryFingerprintEntity).GetProperty("CveId", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly),
fieldInfo: typeof(BinaryFingerprintEntity).GetField("<CveId>k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly));
cveId.AddAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.None);
cveId.AddAnnotation("Relational:ColumnName", "cve_id");
var extractedAt = runtimeEntityType.AddProperty(
"ExtractedAt",
typeof(DateTimeOffset),
propertyInfo: typeof(BinaryFingerprintEntity).GetProperty("ExtractedAt", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly),
fieldInfo: typeof(BinaryFingerprintEntity).GetField("<ExtractedAt>k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly),
sentinel: new DateTimeOffset(new DateTime(1, 1, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)));
extractedAt.AddAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.None);
extractedAt.AddAnnotation("Relational:ColumnName", "extracted_at");
var extractorVersion = runtimeEntityType.AddProperty(
"ExtractorVersion",
typeof(string),
propertyInfo: typeof(BinaryFingerprintEntity).GetProperty("ExtractorVersion", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly),
fieldInfo: typeof(BinaryFingerprintEntity).GetField("<ExtractorVersion>k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly));
extractorVersion.AddAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.None);
extractorVersion.AddAnnotation("Relational:ColumnName", "extractor_version");
var fileOffset = runtimeEntityType.AddProperty(
"FileOffset",
typeof(long?),
propertyInfo: typeof(BinaryFingerprintEntity).GetProperty("FileOffset", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly),
fieldInfo: typeof(BinaryFingerprintEntity).GetField("<FileOffset>k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly),
nullable: true);
fileOffset.AddAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.None);
fileOffset.AddAnnotation("Relational:ColumnName", "file_offset");
var fingerprintValue = runtimeEntityType.AddProperty(
"FingerprintValue",
typeof(string),
propertyInfo: typeof(BinaryFingerprintEntity).GetProperty("FingerprintValue", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly),
fieldInfo: typeof(BinaryFingerprintEntity).GetField("<FingerprintValue>k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly));
fingerprintValue.AddAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.None);
fingerprintValue.AddAnnotation("Relational:ColumnName", "fingerprint_value");
var format = runtimeEntityType.AddProperty(
"Format",
typeof(string),
propertyInfo: typeof(BinaryFingerprintEntity).GetProperty("Format", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly),
fieldInfo: typeof(BinaryFingerprintEntity).GetField("<Format>k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly));
format.AddAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.None);
format.AddAnnotation("Relational:ColumnName", "format");
var hasDebugSymbols = runtimeEntityType.AddProperty(
"HasDebugSymbols",
typeof(bool),
propertyInfo: typeof(BinaryFingerprintEntity).GetProperty("HasDebugSymbols", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly),
fieldInfo: typeof(BinaryFingerprintEntity).GetField("<HasDebugSymbols>k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly),
sentinel: false);
hasDebugSymbols.AddAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.None);
hasDebugSymbols.AddAnnotation("Relational:ColumnName", "has_debug_symbols");
var method = runtimeEntityType.AddProperty(
"Method",
typeof(string),
propertyInfo: typeof(BinaryFingerprintEntity).GetProperty("Method", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly),
fieldInfo: typeof(BinaryFingerprintEntity).GetField("<Method>k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly));
method.AddAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.None);
method.AddAnnotation("Relational:ColumnName", "method");
var optimizationLevel = runtimeEntityType.AddProperty(
"OptimizationLevel",
typeof(string),
propertyInfo: typeof(BinaryFingerprintEntity).GetProperty("OptimizationLevel", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly),
fieldInfo: typeof(BinaryFingerprintEntity).GetField("<OptimizationLevel>k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly),
nullable: true);
optimizationLevel.AddAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.None);
optimizationLevel.AddAnnotation("Relational:ColumnName", "optimization_level");
var regionSize = runtimeEntityType.AddProperty(
"RegionSize",
typeof(long?),
propertyInfo: typeof(BinaryFingerprintEntity).GetProperty("RegionSize", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly),
fieldInfo: typeof(BinaryFingerprintEntity).GetField("<RegionSize>k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly),
nullable: true);
regionSize.AddAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.None);
regionSize.AddAnnotation("Relational:ColumnName", "region_size");
var targetBinary = runtimeEntityType.AddProperty(
"TargetBinary",
typeof(string),
propertyInfo: typeof(BinaryFingerprintEntity).GetProperty("TargetBinary", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly),
fieldInfo: typeof(BinaryFingerprintEntity).GetField("<TargetBinary>k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly));
targetBinary.AddAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.None);
targetBinary.AddAnnotation("Relational:ColumnName", "target_binary");
var targetFunction = runtimeEntityType.AddProperty(
"TargetFunction",
typeof(string),
propertyInfo: typeof(BinaryFingerprintEntity).GetProperty("TargetFunction", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly),
fieldInfo: typeof(BinaryFingerprintEntity).GetField("<TargetFunction>k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly),
nullable: true);
targetFunction.AddAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.None);
targetFunction.AddAnnotation("Relational:ColumnName", "target_function");
var key = runtimeEntityType.AddKey(
new[] { fingerprintId });
runtimeEntityType.SetPrimaryKey(key);
var idx_binary_fingerprints_arch = runtimeEntityType.AddIndex(
new[] { architecture, format },
name: "idx_binary_fingerprints_arch");
var idx_binary_fingerprints_cve = runtimeEntityType.AddIndex(
new[] { cveId, method },
name: "idx_binary_fingerprints_cve");
var idx_binary_fingerprints_method = runtimeEntityType.AddIndex(
new[] { method, extractedAt },
name: "idx_binary_fingerprints_method");
var idx_binary_fingerprints_target = runtimeEntityType.AddIndex(
new[] { targetBinary, targetFunction },
name: "idx_binary_fingerprints_target");
return runtimeEntityType;
}
public static void CreateAnnotations(RuntimeEntityType runtimeEntityType)
{
runtimeEntityType.AddAnnotation("Relational:FunctionName", null);
runtimeEntityType.AddAnnotation("Relational:Schema", "feedser");
runtimeEntityType.AddAnnotation("Relational:SqlQuery", null);
runtimeEntityType.AddAnnotation("Relational:TableName", "binary_fingerprints");
runtimeEntityType.AddAnnotation("Relational:ViewName", null);
runtimeEntityType.AddAnnotation("Relational:ViewSchema", null);
Customize(runtimeEntityType);
}
static partial void Customize(RuntimeEntityType runtimeEntityType);
}
}

123
src/Concelier/__Libraries/StellaOps.Concelier.ProofService.Postgres/EfCore/CompiledModels/ChangelogEvidenceEntityEntityType.cs Normal file
View File

@@ -0,0 +1,123 @@
// <auto-generated />
using System;
using System.Reflection;
using Microsoft.EntityFrameworkCore.Infrastructure;
using Microsoft.EntityFrameworkCore.Metadata;
using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
using StellaOps.Concelier.ProofService.Postgres.EfCore.Models;
#pragma warning disable 219, 612, 618
#nullable disable
namespace StellaOps.Concelier.ProofService.Postgres.EfCore.CompiledModels
{
[EntityFrameworkInternal]
public partial class ChangelogEvidenceEntityEntityType
{
public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType baseEntityType = null)
{
var runtimeEntityType = model.AddEntityType(
"StellaOps.Concelier.ProofService.Postgres.EfCore.Models.ChangelogEvidenceEntity",
typeof(ChangelogEvidenceEntity),
baseEntityType,
propertyCount: 8,
namedIndexCount: 1,
keyCount: 1);
var changelogId = runtimeEntityType.AddProperty(
"ChangelogId",
typeof(string),
propertyInfo: typeof(ChangelogEvidenceEntity).GetProperty("ChangelogId", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly),
fieldInfo: typeof(ChangelogEvidenceEntity).GetField("<ChangelogId>k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly),
afterSaveBehavior: PropertySaveBehavior.Throw);
changelogId.AddAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.None);
changelogId.AddAnnotation("Relational:ColumnName", "changelog_id");
var createdAt = runtimeEntityType.AddProperty(
"CreatedAt",
typeof(DateTimeOffset),
propertyInfo: typeof(ChangelogEvidenceEntity).GetProperty("CreatedAt", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly),
fieldInfo: typeof(ChangelogEvidenceEntity).GetField("<CreatedAt>k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly),
valueGenerated: ValueGenerated.OnAdd,
sentinel: new DateTimeOffset(new DateTime(1, 1, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)));
createdAt.AddAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.None);
createdAt.AddAnnotation("Relational:ColumnName", "created_at");
createdAt.AddAnnotation("Relational:DefaultValueSql", "now()");
var cveIds = runtimeEntityType.AddProperty(
"CveIds",
typeof(string[]),
propertyInfo: typeof(ChangelogEvidenceEntity).GetProperty("CveIds", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly),
fieldInfo: typeof(ChangelogEvidenceEntity).GetField("<CveIds>k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly));
var cveIdsElementType = cveIds.SetElementType(typeof(string));
cveIds.AddAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.None);
cveIds.AddAnnotation("Relational:ColumnName", "cve_ids");
var date = runtimeEntityType.AddProperty(
"Date",
typeof(DateTimeOffset),
propertyInfo: typeof(ChangelogEvidenceEntity).GetProperty("Date", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly),
fieldInfo: typeof(ChangelogEvidenceEntity).GetField("<Date>k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly),
sentinel: new DateTimeOffset(new DateTime(1, 1, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)));
date.AddAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.None);
date.AddAnnotation("Relational:ColumnName", "date");
var format = runtimeEntityType.AddProperty(
"Format",
typeof(string),
propertyInfo: typeof(ChangelogEvidenceEntity).GetProperty("Format", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly),
fieldInfo: typeof(ChangelogEvidenceEntity).GetField("<Format>k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly));
format.AddAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.None);
format.AddAnnotation("Relational:ColumnName", "format");
var packagePurl = runtimeEntityType.AddProperty(
"PackagePurl",
typeof(string),
propertyInfo: typeof(ChangelogEvidenceEntity).GetProperty("PackagePurl", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly),
fieldInfo: typeof(ChangelogEvidenceEntity).GetField("<PackagePurl>k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly));
packagePurl.AddAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.None);
packagePurl.AddAnnotation("Relational:ColumnName", "package_purl");
var payload = runtimeEntityType.AddProperty(
"Payload",
typeof(string),
propertyInfo: typeof(ChangelogEvidenceEntity).GetProperty("Payload", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly),
fieldInfo: typeof(ChangelogEvidenceEntity).GetField("<Payload>k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly));
payload.AddAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.None);
payload.AddAnnotation("Relational:ColumnName", "payload");
payload.AddAnnotation("Relational:ColumnType", "jsonb");
var version = runtimeEntityType.AddProperty(
"Version",
typeof(string),
propertyInfo: typeof(ChangelogEvidenceEntity).GetProperty("Version", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly),
fieldInfo: typeof(ChangelogEvidenceEntity).GetField("<Version>k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly));
version.AddAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.None);
version.AddAnnotation("Relational:ColumnName", "version");
var key = runtimeEntityType.AddKey(
new[] { changelogId });
runtimeEntityType.SetPrimaryKey(key);
var idx_changelog_evidence_pkg_date = runtimeEntityType.AddIndex(
new[] { packagePurl, date },
name: "idx_changelog_evidence_pkg_date");
return runtimeEntityType;
}
public static void CreateAnnotations(RuntimeEntityType runtimeEntityType)
{
runtimeEntityType.AddAnnotation("Relational:FunctionName", null);
runtimeEntityType.AddAnnotation("Relational:Schema", "vuln");
runtimeEntityType.AddAnnotation("Relational:SqlQuery", null);
runtimeEntityType.AddAnnotation("Relational:TableName", "changelog_evidence");
runtimeEntityType.AddAnnotation("Relational:ViewName", null);
runtimeEntityType.AddAnnotation("Relational:ViewSchema", null);
Customize(runtimeEntityType);
}
static partial void Customize(RuntimeEntityType runtimeEntityType);
}
}

150
src/Concelier/__Libraries/StellaOps.Concelier.ProofService.Postgres/EfCore/CompiledModels/DistroAdvisoryEntityEntityType.cs Normal file
View File

@@ -0,0 +1,150 @@
// <auto-generated />
using System;
using System.Reflection;
using Microsoft.EntityFrameworkCore.Infrastructure;
using Microsoft.EntityFrameworkCore.Metadata;
using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
using StellaOps.Concelier.ProofService.Postgres.EfCore.Models;
#pragma warning disable 219, 612, 618
#nullable disable
namespace StellaOps.Concelier.ProofService.Postgres.EfCore.CompiledModels
{
[EntityFrameworkInternal]
public partial class DistroAdvisoryEntityEntityType
{
public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType baseEntityType = null)
{
var runtimeEntityType = model.AddEntityType(
"StellaOps.Concelier.ProofService.Postgres.EfCore.Models.DistroAdvisoryEntity",
typeof(DistroAdvisoryEntity),
baseEntityType,
propertyCount: 10,
namedIndexCount: 3,
keyCount: 1);
var advisoryId = runtimeEntityType.AddProperty(
"AdvisoryId",
typeof(string),
propertyInfo: typeof(DistroAdvisoryEntity).GetProperty("AdvisoryId", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly),
fieldInfo: typeof(DistroAdvisoryEntity).GetField("<AdvisoryId>k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly),
afterSaveBehavior: PropertySaveBehavior.Throw);
advisoryId.AddAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.None);
advisoryId.AddAnnotation("Relational:ColumnName", "advisory_id");
var createdAt = runtimeEntityType.AddProperty(
"CreatedAt",
typeof(DateTimeOffset),
propertyInfo: typeof(DistroAdvisoryEntity).GetProperty("CreatedAt", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly),
fieldInfo: typeof(DistroAdvisoryEntity).GetField("<CreatedAt>k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly),
valueGenerated: ValueGenerated.OnAdd,
sentinel: new DateTimeOffset(new DateTime(1, 1, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)));
createdAt.AddAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.None);
createdAt.AddAnnotation("Relational:ColumnName", "created_at");
createdAt.AddAnnotation("Relational:DefaultValueSql", "now()");
var cveId = runtimeEntityType.AddProperty(
"CveId",
typeof(string),
propertyInfo: typeof(DistroAdvisoryEntity).GetProperty("CveId", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly),
fieldInfo: typeof(DistroAdvisoryEntity).GetField("<CveId>k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly));
cveId.AddAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.None);
cveId.AddAnnotation("Relational:ColumnName", "cve_id");
var distroName = runtimeEntityType.AddProperty(
"DistroName",
typeof(string),
propertyInfo: typeof(DistroAdvisoryEntity).GetProperty("DistroName", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly),
fieldInfo: typeof(DistroAdvisoryEntity).GetField("<DistroName>k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly));
distroName.AddAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.None);
distroName.AddAnnotation("Relational:ColumnName", "distro_name");
var fixedVersion = runtimeEntityType.AddProperty(
"FixedVersion",
typeof(string),
propertyInfo: typeof(DistroAdvisoryEntity).GetProperty("FixedVersion", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly),
fieldInfo: typeof(DistroAdvisoryEntity).GetField("<FixedVersion>k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly),
nullable: true);
fixedVersion.AddAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.None);
fixedVersion.AddAnnotation("Relational:ColumnName", "fixed_version");
var packagePurl = runtimeEntityType.AddProperty(
"PackagePurl",
typeof(string),
propertyInfo: typeof(DistroAdvisoryEntity).GetProperty("PackagePurl", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly),
fieldInfo: typeof(DistroAdvisoryEntity).GetField("<PackagePurl>k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly));
packagePurl.AddAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.None);
packagePurl.AddAnnotation("Relational:ColumnName", "package_purl");
var payload = runtimeEntityType.AddProperty(
"Payload",
typeof(string),
propertyInfo: typeof(DistroAdvisoryEntity).GetProperty("Payload", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly),
fieldInfo: typeof(DistroAdvisoryEntity).GetField("<Payload>k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly));
payload.AddAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.None);
payload.AddAnnotation("Relational:ColumnName", "payload");
payload.AddAnnotation("Relational:ColumnType", "jsonb");
var publishedAt = runtimeEntityType.AddProperty(
"PublishedAt",
typeof(DateTimeOffset),
propertyInfo: typeof(DistroAdvisoryEntity).GetProperty("PublishedAt", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly),
fieldInfo: typeof(DistroAdvisoryEntity).GetField("<PublishedAt>k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly),
sentinel: new DateTimeOffset(new DateTime(1, 1, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)));
publishedAt.AddAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.None);
publishedAt.AddAnnotation("Relational:ColumnName", "published_at");
var status = runtimeEntityType.AddProperty(
"Status",
typeof(string),
propertyInfo: typeof(DistroAdvisoryEntity).GetProperty("Status", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly),
fieldInfo: typeof(DistroAdvisoryEntity).GetField("<Status>k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly));
status.AddAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.None);
status.AddAnnotation("Relational:ColumnName", "status");
var updatedAt = runtimeEntityType.AddProperty(
"UpdatedAt",
typeof(DateTimeOffset),
propertyInfo: typeof(DistroAdvisoryEntity).GetProperty("UpdatedAt", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly),
fieldInfo: typeof(DistroAdvisoryEntity).GetField("<UpdatedAt>k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly),
valueGenerated: ValueGenerated.OnAdd,
sentinel: new DateTimeOffset(new DateTime(1, 1, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)));
updatedAt.AddAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.None);
updatedAt.AddAnnotation("Relational:ColumnName", "updated_at");
updatedAt.AddAnnotation("Relational:DefaultValueSql", "now()");
var key = runtimeEntityType.AddKey(
new[] { advisoryId });
runtimeEntityType.SetPrimaryKey(key);
var idx_distro_advisories_cve_pkg = runtimeEntityType.AddIndex(
new[] { cveId, packagePurl },
name: "idx_distro_advisories_cve_pkg");
var idx_distro_advisories_distro = runtimeEntityType.AddIndex(
new[] { distroName, publishedAt },
name: "idx_distro_advisories_distro");
var idx_distro_advisories_published = runtimeEntityType.AddIndex(
new[] { publishedAt },
name: "idx_distro_advisories_published");
return runtimeEntityType;
}
public static void CreateAnnotations(RuntimeEntityType runtimeEntityType)
{
runtimeEntityType.AddAnnotation("Relational:FunctionName", null);
runtimeEntityType.AddAnnotation("Relational:Schema", "vuln");
runtimeEntityType.AddAnnotation("Relational:SqlQuery", null);
runtimeEntityType.AddAnnotation("Relational:TableName", "distro_advisories");
runtimeEntityType.AddAnnotation("Relational:ViewName", null);
runtimeEntityType.AddAnnotation("Relational:ViewSchema", null);
Customize(runtimeEntityType);
}
static partial void Customize(RuntimeEntityType runtimeEntityType);
}
}

116
src/Concelier/__Libraries/StellaOps.Concelier.ProofService.Postgres/EfCore/CompiledModels/PatchEvidenceEntityEntityType.cs Normal file
View File

@@ -0,0 +1,116 @@
// <auto-generated />
using System;
using System.Reflection;
using Microsoft.EntityFrameworkCore.Infrastructure;
using Microsoft.EntityFrameworkCore.Metadata;
using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
using StellaOps.Concelier.ProofService.Postgres.EfCore.Models;
#pragma warning disable 219, 612, 618
#nullable disable
namespace StellaOps.Concelier.ProofService.Postgres.EfCore.CompiledModels
{
[EntityFrameworkInternal]
public partial class PatchEvidenceEntityEntityType
{
public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType baseEntityType = null)
{
var runtimeEntityType = model.AddEntityType(
"StellaOps.Concelier.ProofService.Postgres.EfCore.Models.PatchEvidenceEntity",
typeof(PatchEvidenceEntity),
baseEntityType,
propertyCount: 7,
namedIndexCount: 1,
keyCount: 1);
var patchId = runtimeEntityType.AddProperty(
"PatchId",
typeof(string),
propertyInfo: typeof(PatchEvidenceEntity).GetProperty("PatchId", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly),
fieldInfo: typeof(PatchEvidenceEntity).GetField("<PatchId>k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly),
afterSaveBehavior: PropertySaveBehavior.Throw);
patchId.AddAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.None);
patchId.AddAnnotation("Relational:ColumnName", "patch_id");
var createdAt = runtimeEntityType.AddProperty(
"CreatedAt",
typeof(DateTimeOffset),
propertyInfo: typeof(PatchEvidenceEntity).GetProperty("CreatedAt", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly),
fieldInfo: typeof(PatchEvidenceEntity).GetField("<CreatedAt>k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly),
valueGenerated: ValueGenerated.OnAdd,
sentinel: new DateTimeOffset(new DateTime(1, 1, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)));
createdAt.AddAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.None);
createdAt.AddAnnotation("Relational:ColumnName", "created_at");
createdAt.AddAnnotation("Relational:DefaultValueSql", "now()");
var cveIds = runtimeEntityType.AddProperty(
"CveIds",
typeof(string[]),
propertyInfo: typeof(PatchEvidenceEntity).GetProperty("CveIds", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly),
fieldInfo: typeof(PatchEvidenceEntity).GetField("<CveIds>k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly));
var cveIdsElementType = cveIds.SetElementType(typeof(string));
cveIds.AddAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.None);
cveIds.AddAnnotation("Relational:ColumnName", "cve_ids");
var origin = runtimeEntityType.AddProperty(
"Origin",
typeof(string),
propertyInfo: typeof(PatchEvidenceEntity).GetProperty("Origin", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly),
fieldInfo: typeof(PatchEvidenceEntity).GetField("<Origin>k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly),
nullable: true);
origin.AddAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.None);
origin.AddAnnotation("Relational:ColumnName", "origin");
var parsedAt = runtimeEntityType.AddProperty(
"ParsedAt",
typeof(DateTimeOffset),
propertyInfo: typeof(PatchEvidenceEntity).GetProperty("ParsedAt", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly),
fieldInfo: typeof(PatchEvidenceEntity).GetField("<ParsedAt>k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly),
sentinel: new DateTimeOffset(new DateTime(1, 1, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)));
parsedAt.AddAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.None);
parsedAt.AddAnnotation("Relational:ColumnName", "parsed_at");
var patchFilePath = runtimeEntityType.AddProperty(
"PatchFilePath",
typeof(string),
propertyInfo: typeof(PatchEvidenceEntity).GetProperty("PatchFilePath", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly),
fieldInfo: typeof(PatchEvidenceEntity).GetField("<PatchFilePath>k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly));
patchFilePath.AddAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.None);
patchFilePath.AddAnnotation("Relational:ColumnName", "patch_file_path");
var payload = runtimeEntityType.AddProperty(
"Payload",
typeof(string),
propertyInfo: typeof(PatchEvidenceEntity).GetProperty("Payload", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly),
fieldInfo: typeof(PatchEvidenceEntity).GetField("<Payload>k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly));
payload.AddAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.None);
payload.AddAnnotation("Relational:ColumnName", "payload");
payload.AddAnnotation("Relational:ColumnType", "jsonb");
var key = runtimeEntityType.AddKey(
new[] { patchId });
runtimeEntityType.SetPrimaryKey(key);
var idx_patch_evidence_origin = runtimeEntityType.AddIndex(
new[] { origin, parsedAt },
name: "idx_patch_evidence_origin");
return runtimeEntityType;
}
public static void CreateAnnotations(RuntimeEntityType runtimeEntityType)
{
runtimeEntityType.AddAnnotation("Relational:FunctionName", null);
runtimeEntityType.AddAnnotation("Relational:Schema", "vuln");
runtimeEntityType.AddAnnotation("Relational:SqlQuery", null);
runtimeEntityType.AddAnnotation("Relational:TableName", "patch_evidence");
runtimeEntityType.AddAnnotation("Relational:ViewName", null);
runtimeEntityType.AddAnnotation("Relational:ViewSchema", null);
Customize(runtimeEntityType);
}
static partial void Customize(RuntimeEntityType runtimeEntityType);
}
}

130
src/Concelier/__Libraries/StellaOps.Concelier.ProofService.Postgres/EfCore/CompiledModels/PatchSignatureEntityEntityType.cs Normal file
View File

@@ -0,0 +1,130 @@
// <auto-generated />
using System;
using System.Reflection;
using Microsoft.EntityFrameworkCore.Infrastructure;
using Microsoft.EntityFrameworkCore.Metadata;
using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
using StellaOps.Concelier.ProofService.Postgres.EfCore.Models;
#pragma warning disable 219, 612, 618
#nullable disable
namespace StellaOps.Concelier.ProofService.Postgres.EfCore.CompiledModels
{
[EntityFrameworkInternal]
public partial class PatchSignatureEntityEntityType
{
public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType baseEntityType = null)
{
var runtimeEntityType = model.AddEntityType(
"StellaOps.Concelier.ProofService.Postgres.EfCore.Models.PatchSignatureEntity",
typeof(PatchSignatureEntity),
baseEntityType,
propertyCount: 8,
namedIndexCount: 3,
keyCount: 1);
var signatureId = runtimeEntityType.AddProperty(
"SignatureId",
typeof(string),
propertyInfo: typeof(PatchSignatureEntity).GetProperty("SignatureId", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly),
fieldInfo: typeof(PatchSignatureEntity).GetField("<SignatureId>k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly),
afterSaveBehavior: PropertySaveBehavior.Throw);
signatureId.AddAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.None);
signatureId.AddAnnotation("Relational:ColumnName", "signature_id");
var commitSha = runtimeEntityType.AddProperty(
"CommitSha",
typeof(string),
propertyInfo: typeof(PatchSignatureEntity).GetProperty("CommitSha", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly),
fieldInfo: typeof(PatchSignatureEntity).GetField("<CommitSha>k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly));
commitSha.AddAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.None);
commitSha.AddAnnotation("Relational:ColumnName", "commit_sha");
var createdAt = runtimeEntityType.AddProperty(
"CreatedAt",
typeof(DateTimeOffset),
propertyInfo: typeof(PatchSignatureEntity).GetProperty("CreatedAt", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly),
fieldInfo: typeof(PatchSignatureEntity).GetField("<CreatedAt>k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly),
valueGenerated: ValueGenerated.OnAdd,
sentinel: new DateTimeOffset(new DateTime(1, 1, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)));
createdAt.AddAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.None);
createdAt.AddAnnotation("Relational:ColumnName", "created_at");
createdAt.AddAnnotation("Relational:DefaultValueSql", "now()");
var cveId = runtimeEntityType.AddProperty(
"CveId",
typeof(string),
propertyInfo: typeof(PatchSignatureEntity).GetProperty("CveId", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly),
fieldInfo: typeof(PatchSignatureEntity).GetField("<CveId>k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly));
cveId.AddAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.None);
cveId.AddAnnotation("Relational:ColumnName", "cve_id");
var extractedAt = runtimeEntityType.AddProperty(
"ExtractedAt",
typeof(DateTimeOffset),
propertyInfo: typeof(PatchSignatureEntity).GetProperty("ExtractedAt", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly),
fieldInfo: typeof(PatchSignatureEntity).GetField("<ExtractedAt>k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly),
sentinel: new DateTimeOffset(new DateTime(1, 1, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)));
extractedAt.AddAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.None);
extractedAt.AddAnnotation("Relational:ColumnName", "extracted_at");
var hunkHash = runtimeEntityType.AddProperty(
"HunkHash",
typeof(string),
propertyInfo: typeof(PatchSignatureEntity).GetProperty("HunkHash", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly),
fieldInfo: typeof(PatchSignatureEntity).GetField("<HunkHash>k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly));
hunkHash.AddAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.None);
hunkHash.AddAnnotation("Relational:ColumnName", "hunk_hash");
var payload = runtimeEntityType.AddProperty(
"Payload",
typeof(string),
propertyInfo: typeof(PatchSignatureEntity).GetProperty("Payload", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly),
fieldInfo: typeof(PatchSignatureEntity).GetField("<Payload>k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly));
payload.AddAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.None);
payload.AddAnnotation("Relational:ColumnName", "payload");
payload.AddAnnotation("Relational:ColumnType", "jsonb");
var upstreamRepo = runtimeEntityType.AddProperty(
"UpstreamRepo",
typeof(string),
propertyInfo: typeof(PatchSignatureEntity).GetProperty("UpstreamRepo", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly),
fieldInfo: typeof(PatchSignatureEntity).GetField("<UpstreamRepo>k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly));
upstreamRepo.AddAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.None);
upstreamRepo.AddAnnotation("Relational:ColumnName", "upstream_repo");
var key = runtimeEntityType.AddKey(
new[] { signatureId });
runtimeEntityType.SetPrimaryKey(key);
var idx_patch_signatures_cve = runtimeEntityType.AddIndex(
new[] { cveId },
name: "idx_patch_signatures_cve");
var idx_patch_signatures_hunk = runtimeEntityType.AddIndex(
new[] { hunkHash },
name: "idx_patch_signatures_hunk");
var idx_patch_signatures_repo = runtimeEntityType.AddIndex(
new[] { upstreamRepo, extractedAt },
name: "idx_patch_signatures_repo");
return runtimeEntityType;
}
public static void CreateAnnotations(RuntimeEntityType runtimeEntityType)
{
runtimeEntityType.AddAnnotation("Relational:FunctionName", null);
runtimeEntityType.AddAnnotation("Relational:Schema", "vuln");
runtimeEntityType.AddAnnotation("Relational:SqlQuery", null);
runtimeEntityType.AddAnnotation("Relational:TableName", "patch_signatures");
runtimeEntityType.AddAnnotation("Relational:ViewName", null);
runtimeEntityType.AddAnnotation("Relational:ViewSchema", null);
Customize(runtimeEntityType);
}
static partial void Customize(RuntimeEntityType runtimeEntityType);
}
}

9
src/Concelier/__Libraries/StellaOps.Concelier.ProofService.Postgres/EfCore/CompiledModels/ProofServiceDbContextAssemblyAttributes.cs Normal file
View File

@@ -0,0 +1,9 @@
// <auto-generated />
using Microsoft.EntityFrameworkCore.Infrastructure;
using StellaOps.Concelier.ProofService.Postgres.EfCore.CompiledModels;
using StellaOps.Concelier.ProofService.Postgres.EfCore.Context;
#pragma warning disable 219, 612, 618
#nullable disable
[assembly: DbContextModel(typeof(ProofServiceDbContext), typeof(ProofServiceDbContextModel))]

48
src/Concelier/__Libraries/StellaOps.Concelier.ProofService.Postgres/EfCore/CompiledModels/ProofServiceDbContextModel.cs Normal file
View File

@@ -0,0 +1,48 @@
// <auto-generated />
using Microsoft.EntityFrameworkCore.Infrastructure;
using Microsoft.EntityFrameworkCore.Metadata;
using StellaOps.Concelier.ProofService.Postgres.EfCore.Context;
#pragma warning disable 219, 612, 618
#nullable disable
namespace StellaOps.Concelier.ProofService.Postgres.EfCore.CompiledModels
{
[DbContext(typeof(ProofServiceDbContext))]
public partial class ProofServiceDbContextModel : RuntimeModel
{
private static readonly bool _useOldBehavior31751 =
System.AppContext.TryGetSwitch("Microsoft.EntityFrameworkCore.Issue31751", out var enabled31751) && enabled31751;
static ProofServiceDbContextModel()
{
var model = new ProofServiceDbContextModel();
if (_useOldBehavior31751)
{
model.Initialize();
}
else
{
var thread = new System.Threading.Thread(RunInitialization, 10 * 1024 * 1024);
thread.Start();
thread.Join();
void RunInitialization()
{
model.Initialize();
}
}
model.Customize();
_instance = (ProofServiceDbContextModel)model.FinalizeModel();
}
private static ProofServiceDbContextModel _instance;
public static IModel Instance => _instance;
partial void Initialize();
partial void Customize();
}
}

38
src/Concelier/__Libraries/StellaOps.Concelier.ProofService.Postgres/EfCore/CompiledModels/ProofServiceDbContextModelBuilder.cs Normal file
View File

@@ -0,0 +1,38 @@
// <auto-generated />
using System;
using Microsoft.EntityFrameworkCore.Infrastructure;
using Microsoft.EntityFrameworkCore.Metadata;
using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
#pragma warning disable 219, 612, 618
#nullable disable
namespace StellaOps.Concelier.ProofService.Postgres.EfCore.CompiledModels
{
public partial class ProofServiceDbContextModel
{
private ProofServiceDbContextModel()
: base(skipDetectChanges: false, modelId: new Guid("965b8cfb-1cb9-4c6d-97b3-bab3e732ca9d"), entityTypeCount: 5)
{
}
partial void Initialize()
{
var binaryFingerprintEntity = BinaryFingerprintEntityEntityType.Create(this);
var changelogEvidenceEntity = ChangelogEvidenceEntityEntityType.Create(this);
var distroAdvisoryEntity = DistroAdvisoryEntityEntityType.Create(this);
var patchEvidenceEntity = PatchEvidenceEntityEntityType.Create(this);
var patchSignatureEntity = PatchSignatureEntityEntityType.Create(this);
BinaryFingerprintEntityEntityType.CreateAnnotations(binaryFingerprintEntity);
ChangelogEvidenceEntityEntityType.CreateAnnotations(changelogEvidenceEntity);
DistroAdvisoryEntityEntityType.CreateAnnotations(distroAdvisoryEntity);
PatchEvidenceEntityEntityType.CreateAnnotations(patchEvidenceEntity);
PatchSignatureEntityEntityType.CreateAnnotations(patchSignatureEntity);
AddAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn);
AddAnnotation("ProductVersion", "10.0.0");
AddAnnotation("Relational:MaxIdentifierLength", 63);
}
}
}

37
src/Concelier/__Libraries/StellaOps.Concelier.ProofService.Postgres/Postgres/ProofServiceDbContextFactory.cs Normal file
View File

@@ -0,0 +1,37 @@
using Microsoft.EntityFrameworkCore;
using Npgsql;
using StellaOps.Concelier.ProofService.Postgres.EfCore.CompiledModels;
using StellaOps.Concelier.ProofService.Postgres.EfCore.Context;
namespace StellaOps.Concelier.ProofService.Postgres;
internal static class ProofServiceDbContextFactory
{
public const string DefaultVulnSchema = "vuln";
public const string DefaultFeedserSchema = "feedser";
public static ProofServiceDbContext Create(
NpgsqlConnection connection,
int commandTimeoutSeconds,
string? vulnSchema = null,
string? feedserSchema = null)
{
var normalizedVuln = string.IsNullOrWhiteSpace(vulnSchema)
? DefaultVulnSchema
: vulnSchema.Trim();
var normalizedFeedser = string.IsNullOrWhiteSpace(feedserSchema)
? DefaultFeedserSchema
: feedserSchema.Trim();
var optionsBuilder = new DbContextOptionsBuilder<ProofServiceDbContext>()
.UseNpgsql(connection, npgsql => npgsql.CommandTimeout(commandTimeoutSeconds));
if (string.Equals(normalizedVuln, DefaultVulnSchema, StringComparison.Ordinal) &&
string.Equals(normalizedFeedser, DefaultFeedserSchema, StringComparison.Ordinal))
{
optionsBuilder.UseModel(ProofServiceDbContextModel.Instance);
}
return new ProofServiceDbContext(optionsBuilder.Options, normalizedVuln, normalizedFeedser);
}
}

5
src/Concelier/__Libraries/StellaOps.Concelier.ProofService.Postgres/StellaOps.Concelier.ProofService.Postgres.csproj
View File

@@ -20,6 +20,11 @@
<EmbeddedResource Include="Migrations\*.sql" />
</ItemGroup>
<ItemGroup>
<!-- Prevent automatic compiled-model binding so non-default schemas can build runtime models. -->
<Compile Remove="EfCore\CompiledModels\ProofServiceDbContextAssemblyAttributes.cs" />
</ItemGroup>
<ItemGroup>
<ProjectReference Include="..\StellaOps.Concelier.ProofService\StellaOps.Concelier.ProofService.csproj" />
<ProjectReference Include="..\..\..\Feedser\StellaOps.Feedser.BinaryAnalysis\StellaOps.Feedser.BinaryAnalysis.csproj" />