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]

Reply via email to