mirror of
https://github.com/iamxvbaba/gramsrv.git
synced 2026-11-19 21:27:47 +03:00
b551a239f5
Translate all natural-language comments, log/diagnostic messages, SQL comments and config/doc prose from Chinese (and Russian) to English across the codebase (~840 files). Rebased on upstream main; upstream's newly added files are translated too. Locale resources and functional non-English data are left intact: language packs, admin/grammystore i18n bundles, localized docs, the officialBrandRE regex, seeded Russian premium-bot text, user-facing Russian bot strings and asserted Unicode test fixtures. A new internal/translation guard test fails if CJK/Cyrillic reappears in source outside that allowlist. No code, identifiers, struct tags or behavior changed (verified with an AST-level comment/string audit). go build ./..., go vet ./... and the guard pass.
239 lines
5.2 KiB
Go
239 lines
5.2 KiB
Go
package langpack
|
|
|
|
import (
|
|
"container/list"
|
|
"sync"
|
|
|
|
"telesrv/internal/domain"
|
|
)
|
|
|
|
const (
|
|
defaultLangPackCacheMaxBytes = int64(128 << 20)
|
|
defaultLangPackCacheMaxEntries = 256
|
|
defaultLanguageListCacheMaxEntries = 32
|
|
langPackStringValueHeaderBytes = int64(144)
|
|
langPackFixedHeaderBytes = int64(80)
|
|
)
|
|
|
|
type langPackCacheKind uint8
|
|
|
|
const (
|
|
langPackCacheRaw langPackCacheKind = iota
|
|
langPackCacheEffective
|
|
)
|
|
|
|
type langPackCacheKey struct {
|
|
pack string
|
|
code string
|
|
kind langPackCacheKind
|
|
}
|
|
|
|
func (k langPackCacheKey) singleflightKey() string {
|
|
return string(rune(k.kind)) + "\x00" + k.pack + "\x00" + k.code
|
|
}
|
|
|
|
type langPackCache struct {
|
|
mu sync.Mutex
|
|
maxBytes int64
|
|
maxEntries int
|
|
usedBytes int64
|
|
epoch uint64
|
|
ll *list.List
|
|
items map[langPackCacheKey]*list.Element
|
|
}
|
|
|
|
type langPackCacheEntry struct {
|
|
key langPackCacheKey
|
|
pack domain.LangPack
|
|
size int64
|
|
}
|
|
|
|
func newLangPackCache(maxBytes int64, maxEntries int) *langPackCache {
|
|
if maxBytes <= 0 || maxEntries <= 0 {
|
|
return nil
|
|
}
|
|
return &langPackCache{
|
|
maxBytes: maxBytes,
|
|
maxEntries: maxEntries,
|
|
ll: list.New(),
|
|
items: make(map[langPackCacheKey]*list.Element),
|
|
}
|
|
}
|
|
|
|
func (c *langPackCache) get(key langPackCacheKey) (domain.LangPack, bool) {
|
|
if c == nil {
|
|
return domain.LangPack{}, false
|
|
}
|
|
c.mu.Lock()
|
|
defer c.mu.Unlock()
|
|
element, ok := c.items[key]
|
|
if !ok {
|
|
return domain.LangPack{}, false
|
|
}
|
|
c.ll.MoveToFront(element)
|
|
return cloneLangPack(element.Value.(*langPackCacheEntry).pack), true
|
|
}
|
|
|
|
func (c *langPackCache) loadEpoch() uint64 {
|
|
if c == nil {
|
|
return 0
|
|
}
|
|
c.mu.Lock()
|
|
epoch := c.epoch
|
|
c.mu.Unlock()
|
|
return epoch
|
|
}
|
|
|
|
// putIfEpoch returns false only when a flush happened during load; the caller must reload.
|
|
// An oversized item is not cached but can still be safely returned to the current request, so it returns true.
|
|
func (c *langPackCache) putIfEpoch(key langPackCacheKey, pack domain.LangPack, loadEpoch uint64) bool {
|
|
if c == nil {
|
|
return true
|
|
}
|
|
size := estimateLangPackBytes(pack)
|
|
c.mu.Lock()
|
|
defer c.mu.Unlock()
|
|
if c.epoch != loadEpoch {
|
|
return false
|
|
}
|
|
if existing, ok := c.items[key]; ok {
|
|
c.remove(existing)
|
|
}
|
|
if size > c.maxBytes {
|
|
return true
|
|
}
|
|
entry := &langPackCacheEntry{key: key, pack: cloneLangPack(pack), size: size}
|
|
c.items[key] = c.ll.PushFront(entry)
|
|
c.usedBytes += size
|
|
for c.usedBytes > c.maxBytes || c.ll.Len() > c.maxEntries {
|
|
oldest := c.ll.Back()
|
|
if oldest == nil {
|
|
break
|
|
}
|
|
c.remove(oldest)
|
|
}
|
|
return true
|
|
}
|
|
|
|
func (c *langPackCache) flush() {
|
|
if c == nil {
|
|
return
|
|
}
|
|
c.mu.Lock()
|
|
c.epoch++
|
|
c.usedBytes = 0
|
|
c.ll.Init()
|
|
clear(c.items)
|
|
c.mu.Unlock()
|
|
}
|
|
|
|
func (c *langPackCache) remove(element *list.Element) {
|
|
entry := element.Value.(*langPackCacheEntry)
|
|
delete(c.items, entry.key)
|
|
c.ll.Remove(element)
|
|
c.usedBytes -= entry.size
|
|
}
|
|
|
|
func estimateLangPackBytes(pack domain.LangPack) int64 {
|
|
size := langPackFixedHeaderBytes + int64(len(pack.LangPack)+len(pack.LangCode))
|
|
size += int64(len(pack.Strings)) * langPackStringValueHeaderBytes
|
|
for _, item := range pack.Strings {
|
|
size += int64(len(item.Key) + len(item.Value) + len(item.ZeroValue) + len(item.OneValue) +
|
|
len(item.TwoValue) + len(item.FewValue) + len(item.ManyValue) + len(item.OtherValue))
|
|
}
|
|
return size
|
|
}
|
|
|
|
func cloneLangPack(pack domain.LangPack) domain.LangPack {
|
|
pack.Strings = append([]domain.LangPackString(nil), pack.Strings...)
|
|
return pack
|
|
}
|
|
|
|
type languageListCache struct {
|
|
mu sync.Mutex
|
|
maxEntries int
|
|
epoch uint64
|
|
ll *list.List
|
|
items map[string]*list.Element
|
|
}
|
|
|
|
type languageListCacheEntry struct {
|
|
pack string
|
|
languages []domain.LangPackLanguage
|
|
}
|
|
|
|
func newLanguageListCache(maxEntries int) *languageListCache {
|
|
if maxEntries <= 0 {
|
|
return nil
|
|
}
|
|
return &languageListCache{
|
|
maxEntries: maxEntries,
|
|
ll: list.New(),
|
|
items: make(map[string]*list.Element),
|
|
}
|
|
}
|
|
|
|
func (c *languageListCache) get(pack string) ([]domain.LangPackLanguage, bool) {
|
|
if c == nil {
|
|
return nil, false
|
|
}
|
|
c.mu.Lock()
|
|
defer c.mu.Unlock()
|
|
element, ok := c.items[pack]
|
|
if !ok {
|
|
return nil, false
|
|
}
|
|
c.ll.MoveToFront(element)
|
|
return cloneLanguages(element.Value.(*languageListCacheEntry).languages), true
|
|
}
|
|
|
|
func (c *languageListCache) loadEpoch() uint64 {
|
|
if c == nil {
|
|
return 0
|
|
}
|
|
c.mu.Lock()
|
|
epoch := c.epoch
|
|
c.mu.Unlock()
|
|
return epoch
|
|
}
|
|
|
|
func (c *languageListCache) putIfEpoch(pack string, languages []domain.LangPackLanguage, loadEpoch uint64) bool {
|
|
if c == nil {
|
|
return true
|
|
}
|
|
c.mu.Lock()
|
|
defer c.mu.Unlock()
|
|
if c.epoch != loadEpoch {
|
|
return false
|
|
}
|
|
if existing, ok := c.items[pack]; ok {
|
|
c.ll.Remove(existing)
|
|
delete(c.items, pack)
|
|
}
|
|
entry := &languageListCacheEntry{pack: pack, languages: cloneLanguages(languages)}
|
|
c.items[pack] = c.ll.PushFront(entry)
|
|
if c.ll.Len() > c.maxEntries {
|
|
oldest := c.ll.Back()
|
|
if oldest != nil {
|
|
delete(c.items, oldest.Value.(*languageListCacheEntry).pack)
|
|
c.ll.Remove(oldest)
|
|
}
|
|
}
|
|
return true
|
|
}
|
|
|
|
func (c *languageListCache) flush() {
|
|
if c == nil {
|
|
return
|
|
}
|
|
c.mu.Lock()
|
|
c.epoch++
|
|
c.ll.Init()
|
|
clear(c.items)
|
|
c.mu.Unlock()
|
|
}
|
|
|
|
func cloneLanguages(languages []domain.LangPackLanguage) []domain.LangPackLanguage {
|
|
return append([]domain.LangPackLanguage(nil), languages...)
|
|
}
|