larry-zy commented on code in PR #1615:
URL: https://github.com/apache/dubbo-admin/pull/1615#discussion_r4440264173
##########
ai/store/gorm/store.go:
##########
@@ -75,9 +106,183 @@ func (s *GormStore) Migrate(ctx context.Context) error {
if err := s.checkContext(ctx); err != nil {
return err
}
- return s.db.WithContext(normalizeContext(ctx)).AutoMigrate(
- &SessionModel{}, &TurnModel{}, &MessageModel{},
- )
+ db := s.db.WithContext(normalizeContext(ctx))
+ if err := db.AutoMigrate(
+ &MemoryLedgerModel{},
+ &HistoryEntryModel{}, &SummaryModel{},
+ &ToolBatchModel{},
+ &SessionModel{}, &TurnModel{}, &MessageModel{},
&InteractionModel{},
+ &DerivedArtifactModel{}, &CleanupJobModel{},
&OutboxEventModel{}, &TenantUsageModel{},
+ &UsageEventModel{}, &AuditEventModel{}, &EventCapacityModel{},
+ ); err != nil {
+ return err
+ }
+ return db.Transaction(func(tx *gorm.DB) error {
+ for _, entry := range []struct {
+ kind string
+ model any
+ }{{"usage", &UsageEventModel{}}, {"audit", &AuditEventModel{}}}
{
+ // Only initialize a missing counter. Never recount
over a live counter:
+ // existing writers may be reserving capacity in other
processes.
+ result := tx.Clauses(clause.OnConflict{DoNothing:
true}).Create(&EventCapacityModel{Kind: entry.kind, EventCount: -1})
+ if result.Error != nil {
+ return result.Error
+ }
+ // Lock before examining the initialization sentinel.
Do not infer
+ // insertion from RowsAffected: MySQL clientFoundRows
changes its meaning.
+ if err := tx.Model(&EventCapacityModel{}).Where("kind =
?", entry.kind).
+ Update("event_count", gorm.Expr("event_count +
0")).Error; err != nil {
+ return err
+ }
+ var capacity EventCapacityModel
+ if err := tx.First(&capacity, "kind = ?",
entry.kind).Error; err != nil {
+ return err
+ }
+ if capacity.EventCount < 0 {
+ var count int64
+ if err :=
tx.Model(entry.model).Count(&count).Error; err != nil {
+ return err
+ }
+ if err :=
tx.Model(&EventCapacityModel{}).Where("kind = ?",
entry.kind).Update("event_count", count).Error; err != nil {
+ return err
+ }
+ }
+ }
+ var artifacts []DerivedArtifactModel
+ if err := tx.Where("source_session_id = ?",
"").Find(&artifacts).Error; err != nil {
+ return err
+ }
+ for i := range artifacts {
+ sessionID, err :=
conversationstore.SessionIDFromCanonicalSource(artifacts[i].CanonicalSourceID)
+ if err != nil {
+ continue
+ }
+ if err := tx.Model(&DerivedArtifactModel{}).Where("id =
?", artifacts[i].ID).Update("source_session_id", sessionID).Error; err != nil {
+ return err
+ }
+ }
+ // Pre-PR3 active Turns have no durable Interaction or lease
and cannot be
+ // resumed safely after deployment.
+ var orphaned []TurnModel
+ if err := tx.Where("completed_at IS NULL AND (interaction_id IS
NULL OR interaction_id = ?)", "").Find(&orphaned).Error; err != nil {
+ return err
+ }
+ for i := range orphaned {
+ if err := tx.Where("turn_id = ?",
orphaned[i].ID).Delete(&MessageModel{}).Error; err != nil {
+ return err
+ }
+ }
+ if err := tx.Where("completed_at IS NULL AND (interaction_id IS
NULL OR interaction_id = ?)", "").Delete(&TurnModel{}).Error; err != nil {
+ return err
+ }
+ if err := tx.Model(&TurnModel{}).Where("completed_at IS NOT
NULL").Update("status", conversationstore.InteractionStatusCompleted).Error;
err != nil {
+ return err
+ }
+ // Backfill metadata only, preserving the old completed-at/id
ordering.
+ var legacy []TurnModel
+ if err := tx.Where("completed_at IS NOT NULL AND NOT EXISTS
(SELECT 1 FROM ai_history_entries h WHERE h.session_id = ai_turns.session_id
AND h.turn_id = ai_turns.id)").Order("completed_at ASC").Order("id
ASC").Find(&legacy).Error; err != nil {
+ return err
+ }
+ for _, t := range legacy {
+ if err := recordSummaryHistory(tx, t.SessionID, t.ID,
conversationstore.InteractionStatusCompleted); err != nil {
+ return err
+ }
+ }
+ var released []ToolBatchModel
+ if err := tx.Select("session_id, turn_id").Where("NOT EXISTS
(SELECT 1 FROM ai_turns t WHERE t.id = ai_tool_batches.turn_id) AND NOT EXISTS
(SELECT 1 FROM ai_history_entries h WHERE h.session_id =
ai_tool_batches.session_id AND h.turn_id =
ai_tool_batches.turn_id)").Group("session_id, turn_id").Order("turn_id
ASC").Find(&released).Error; err != nil {
+ return err
+ }
+ for _, b := range released {
+ if err := recordSummaryHistory(tx, b.SessionID,
b.TurnID, conversationstore.InteractionStatusFailed); err != nil {
+ return err
+ }
+ }
+ var sessions []SessionModel
+ if err := tx.Find(&sessions).Error; err != nil {
+ return err
+ }
+ type usage struct{ sessions, bytes int64 }
+ byTenant := make(map[string]usage)
+ for i := range sessions {
+ if sessions[i].ExpiresAt == nil {
+ expiresAt :=
sessions[i].UpdatedAt.Add(s.lifecycle.Retention)
+ if err := tx.Model(&SessionModel{}).Where("id =
?", sessions[i].ID).Update("expires_at", expiresAt).Error; err != nil {
+ return err
+ }
+ sessions[i].ExpiresAt = &expiresAt
+ }
+ var messageBytes, resultBytes int64
+ if err :=
tx.Table("ai_messages").Select("COALESCE(SUM(LENGTH(ai_messages.payload) + CASE
WHEN ai_messages.summary_checked_rule IS NOT NULL AND
ai_messages.summary_checked_rule <> '' THEN ? ELSE 0 END), 0)",
conversationstore.SummaryInspectionBytes).Joins("JOIN ai_turns ON ai_turns.id =
ai_messages.turn_id").Where("ai_turns.session_id = ?",
sessions[i].ID).Scan(&messageBytes).Error; err != nil {
+ return err
+ }
+ if err :=
tx.Model(&InteractionModel{}).Select("COALESCE(SUM(LENGTH(result)),
0)").Where("session_id = ?", sessions[i].ID).Scan(&resultBytes).Error; err !=
nil {
+ return err
+ }
+ var toolBytes int64
+ if err :=
tx.Model(&ToolBatchModel{}).Select("COALESCE(SUM(LENGTH(payload) + CASE WHEN
summary_checked_rule IS NOT NULL AND summary_checked_rule <> '' THEN ? ELSE 0
END), 0)", conversationstore.SummaryInspectionBytes).Where("session_id = ?",
sessions[i].ID).Scan(&toolBytes).Error; err != nil {
+ return err
+ }
+ var summaryBytes int64
+ if err :=
tx.Model(&SummaryModel{}).Select("COALESCE(SUM(LENGTH(payload)),0)").Where("session_id
= ?", sessions[i].ID).Scan(&summaryBytes).Error; err != nil {
+ return err
+ }
+ var turnDependencyBytes, journalDependencyBytes int64
+ if err :=
tx.Model(&TurnModel{}).Select("COALESCE(SUM(LENGTH(dependencies)),0)").Where("session_id
= ?", sessions[i].ID).Scan(&turnDependencyBytes).Error; err != nil {
+ return err
+ }
+ if err :=
tx.Model(&HistoryEntryModel{}).Select("COALESCE(SUM(LENGTH(dependencies)),0)").Where("session_id
= ?", sessions[i].ID).Scan(&journalDependencyBytes).Error; err != nil {
+ return err
+ }
+ // Active Turns prepay their future terminal-journal
copy.
+ var activeDependencyBytes int64
+ if err :=
tx.Model(&TurnModel{}).Select("COALESCE(SUM(LENGTH(dependencies)),0)").Where("session_id
= ? AND completed_at IS NULL",
sessions[i].ID).Scan(&activeDependencyBytes).Error; err != nil {
+ return err
+ }
+ storedBytes := messageBytes + resultBytes + toolBytes +
summaryBytes + turnDependencyBytes + journalDependencyBytes +
activeDependencyBytes
+ if sessions[i].Status ==
conversationstore.SessionStatusDeleted {
+ storedBytes = 0
+ }
+ if err := tx.Model(&SessionModel{}).Where("id = ?",
sessions[i].ID).Update("stored_bytes", storedBytes).Error; err != nil {
+ return err
+ }
+ current := byTenant[sessions[i].TenantID]
+ if sessions[i].Status !=
conversationstore.SessionStatusDeleted {
+ current.sessions++
+ }
+ current.bytes += storedBytes
+ byTenant[sessions[i].TenantID] = current
+ }
+ var memories []MemoryLedgerModel
+ if err := tx.Select("tenant_id,
payload").Find(&memories).Error; err != nil {
Review Comment:
[P2] Load ledger IDs before rebuilding their byte reservations
This projection loads only `tenant_id` and `payload`, but the loop below
updates each ledger using `Where("id = ?", row.ID)`. Every `row.ID` is
therefore empty, so those updates silently match no records while the tenant
total is rebuilt from the new content sizes. When an existing ledger
reservation needs recalculation, the two accounting levels diverge. In a SQLite
migration regression seeded with whole-ledger accounting, the ledger remains at
634 bytes while the tenant is rebuilt to 525; deleting the only Memory then
leaves the tenant counter at -109, allowing subsequent writes to undercount
capacity. Please include `id` in the projection and verify that the per-ledger
reservation and tenant total are rebuilt together, including a mutation after
migration.
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: [email protected]
For queries about this service, please contact Infrastructure at:
[email protected]
---------------------------------------------------------------------
To unsubscribe, e-mail: [email protected]
For additional commands, e-mail: [email protected]