Qiao-yq commented on code in PR #1615:
URL: https://github.com/apache/dubbo-admin/pull/1615#discussion_r4453827136


##########
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:
   Thanks for catching this. Fixed in 5f66187: `Migrate` now selects `id, 
tenant_id, payload`, so the per-ledger update matches and the ledger 
reservation and tenant total are rebuilt together.
   
   Added `TestMigrateRebuildsMemoryLedgerReservation`, which seeds legacy 
whole-ledger accounting, runs `Migrate`, then deletes the only Memory. Without 
the fix it fails with ledger=640 / tenant=531; with the fix both are rebuilt to 
the content size and the tenant counter returns to 0 after the delete. Full AI 
module tests pass on SQLite.



-- 
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]

Reply via email to