Admin UI: Add message queue to admin UI (#6958)

* add a menu item "Message Queue"

* add a menu item "Message Queue"
  * move the "brokers" link under it.
  * add "topics", "subscribers". Add pages for them.

* refactor

* show topic details

* admin display publisher and subscriber info

* remove publisher and subscribers from the topic row pull down

* collecting more stats from publishers and subscribers

* fix layout

* fix publisher name

* add local listeners for mq broker and agent

* render consumer group offsets

* remove subscribers from left menu

* topic with retention

* support editing topic retention

* show retention when listing topics

* create bucket

* Update s3_buckets_templ.go

* embed the static assets into the binary

fix https://github.com/seaweedfs/seaweedfs/issues/6964

weed/mq/topic/local_partition_subscribers.go

@@ -1,24 +1,70 @@
 package topic
 
-import "sync"
+import (
+	"sync"
+	"sync/atomic"
+	"time"
+)
 
 type LocalPartitionSubscribers struct {
 	Subscribers     map[string]*LocalSubscriber
 	SubscribersLock sync.RWMutex
 }
 type LocalSubscriber struct {
-	stopCh chan struct{}
+	connectTimeNs      int64 // accessed atomically
+	lastSeenTimeNs     int64 // accessed atomically
+	lastReceivedOffset int64 // accessed atomically - offset of last message received
+	lastAckedOffset    int64 // accessed atomically - offset of last message acknowledged
+	stopCh             chan struct{}
 }
 
 func NewLocalSubscriber() *LocalSubscriber {
-	return &LocalSubscriber{
+	now := time.Now().UnixNano()
+	subscriber := &LocalSubscriber{
 		stopCh: make(chan struct{}, 1),
 	}
+	atomic.StoreInt64(&subscriber.connectTimeNs, now)
+	atomic.StoreInt64(&subscriber.lastSeenTimeNs, now)
+	atomic.StoreInt64(&subscriber.lastReceivedOffset, 0)
+	atomic.StoreInt64(&subscriber.lastAckedOffset, 0)
+	return subscriber
 }
 func (p *LocalSubscriber) SignalShutdown() {
 	close(p.stopCh)
 }
 
+// UpdateLastSeen updates the last activity time for this subscriber
+func (p *LocalSubscriber) UpdateLastSeen() {
+	atomic.StoreInt64(&p.lastSeenTimeNs, time.Now().UnixNano())
+}
+
+// UpdateReceivedOffset updates the offset of the last message received by this subscriber
+func (p *LocalSubscriber) UpdateReceivedOffset(offset int64) {
+	atomic.StoreInt64(&p.lastReceivedOffset, offset)
+	atomic.StoreInt64(&p.lastSeenTimeNs, time.Now().UnixNano())
+}
+
+// UpdateAckedOffset updates the offset of the last message acknowledged by this subscriber
+func (p *LocalSubscriber) UpdateAckedOffset(offset int64) {
+	atomic.StoreInt64(&p.lastAckedOffset, offset)
+	atomic.StoreInt64(&p.lastSeenTimeNs, time.Now().UnixNano())
+}
+
+// GetTimestamps returns the connect and last seen timestamps safely
+func (p *LocalSubscriber) GetTimestamps() (connectTimeNs, lastSeenTimeNs int64) {
+	return atomic.LoadInt64(&p.connectTimeNs), atomic.LoadInt64(&p.lastSeenTimeNs)
+}
+
+// GetOffsets returns the received and acknowledged offsets safely
+func (p *LocalSubscriber) GetOffsets() (lastReceivedOffset, lastAckedOffset int64) {
+	return atomic.LoadInt64(&p.lastReceivedOffset), atomic.LoadInt64(&p.lastAckedOffset)
+}
+
+// GetCurrentOffset returns the acknowledged offset (for compatibility)
+func (p *LocalSubscriber) GetCurrentOffset() int64 {
+	return atomic.LoadInt64(&p.lastAckedOffset)
+}
+
 func NewLocalPartitionSubscribers() *LocalPartitionSubscribers {
 	return &LocalPartitionSubscribers{
 		Subscribers: make(map[string]*LocalSubscriber),
@@ -54,3 +100,25 @@ func (p *LocalPartitionSubscribers) Size() int {
 
 	return len(p.Subscribers)
 }
+
+// GetSubscriberNames returns the names of all subscribers
+func (p *LocalPartitionSubscribers) GetSubscriberNames() []string {
+	p.SubscribersLock.RLock()
+	defer p.SubscribersLock.RUnlock()
+
+	names := make([]string, 0, len(p.Subscribers))
+	for name := range p.Subscribers {
+		names = append(names, name)
+	}
+	return names
+}
+
+// ForEachSubscriber iterates over all subscribers
+func (p *LocalPartitionSubscribers) ForEachSubscriber(fn func(name string, subscriber *LocalSubscriber)) {
+	p.SubscribersLock.RLock()
+	defer p.SubscribersLock.RUnlock()
+
+	for name, subscriber := range p.Subscribers {
+		fn(name, subscriber)
+	}
+}