kern/v4/lev2/kmonolit/kmonolit.go

// package kmonolit -- модульный монолит на основе ядра.
package kmonolit

import (
	"sync"

	"gitp78su.ipnodns.ru/svi/kern/v4/lev0"
	"gitp78su.ipnodns.ru/svi/kern/v4/lev1"
	"gitp78su.ipnodns.ru/svi/kern/v4/lev2"
	"gitp78su.ipnodns.ru/svi/kern/v4/lev3/mod_ent"
	"gitp78su.ipnodns.ru/svi/kern/v4/lev3/mod_spec"
)

// LModMonolit -- объект модульного монолита.
type LModMonolit struct {
	kCtx    *lev2.KernCtx
	lCtx    *lev1.LocalCtx
	log     *lev1.LogBuf
	name    mod_ent.AModuleName
	isLocal *lev0.LBool
	isWork  *lev0.MSafeBool
	isEnd   *lev0.MSafeBool
	dict    map[mod_ent.AModuleName]mod_spec.IKernelModule // Словарь модулей монолита
}

var (
	mon   *LModMonolit
	block sync.Mutex
)

var (
	txtIsLocal = lev0.LetTxt("isLocal")
)

// LetModMonolit -- возвращает синглтон модуля-монолита.
func LetModMonolit(name mod_ent.AModuleName) *LModMonolit {
	block.Lock()
	defer block.Unlock()
	if mon != nil {
		return mon
	}
	lev0.If(name == "").Hassert("NewMonolit(): name is empty")
	kCtx := lev2.GetKernCtx()
	opt := kCtx.Get(txtIsLocal)
	opt.Hassert("GetMonolit(): in get from kernCtx isLocal -- not found")
	isLocalCtx := opt.Some()
	isLocal := isLocalCtx.Val().(lev0.Bool)
	lCtx := lev1.NewLocalCtx(kCtx.SelfCtx())
	sf := &LModMonolit{
		kCtx:    kCtx,
		lCtx:    lCtx,
		name:    name,
		dict:    map[mod_ent.AModuleName]mod_spec.IKernelModule{},
		isWork:  lev0.MutSafeBool(false),
		isEnd:   lev0.MutSafeBool(false),
		isLocal: lev0.LetBool(isLocal),
	}
	sf.log = sf.lCtx.Log()
	sf.kCtx.Set(lev0.LetTxt("monolitName"), name, "name of monolit")
	sf.kCtx.Set(lev0.LetTxt("monolit"), sf, "monolit-app")
	mon = sf
	_ = mod_spec.IKernelMonolit(sf)
	return sf
}

// Ctx -- возвращает контекст монолита.
func (sf *LModMonolit) Ctx() *lev1.LocalCtx {
	return sf.lCtx
}

// Log -- возвращает лог монолита.
func (sf *LModMonolit) Log() *lev1.LogBuf {
	return sf.lCtx.Log()
}

// Name -- возвращает имя монолита.
func (sf *LModMonolit) Name() mod_ent.AModuleName {
	return sf.name
}

// Add -- добавляет модуль в монолит.
func (sf *LModMonolit) Add(module mod_spec.IKernelModule) {
	sf.kCtx.RLock()
	defer sf.kCtx.RUnlock()
	lev0.If(module == nil).Hassert("kMonolit.Add(): module==nil", []any{})
	_, isOk := sf.dict[module.Name().Get()]
	lev0.If(lev0.Bool(isOk)).Hassert("kMonolit.Add(): module(%v) already exists", []any{module.Name()})
	sf.dict[module.Name().Get()] = module
	sf.log.Debug("kMonolit.Add(): module='%v'", module.Name())
	if sf.isWork.Get() {
		go module.Run()
		sf.log.Debug("kMonolit.Add(): module='%v' is run", module.Name())
	}
	key := lev0.LetTxt("module_%v", len(sf.dict))
	moduleName := module.Name()
	comment := lev0.LetTxt("kMonolit.Add(): module=" + moduleName.Txt())
	sf.lCtx.Set(key, module, comment.Get())
}

// Run -- запускает монолит в работу.
func (sf *LModMonolit) Run() {
	sf.kCtx.RLock()
	defer sf.kCtx.RUnlock()
	if sf.isEnd.Get() {
		return
	}
	if sf.isWork.Get() {
		return
	}
	sf.isWork.Set()
	for _, module := range sf.dict {
		go module.Run()
	}
	sf.log.Debug("kMonolit.Run()")
}

// IsLocal -- возвращает признак локальной шины.
func (sf *LModMonolit) IsLocal() *lev0.LBool {
	return sf.isLocal
}

// IsWork -- возвращает признак работы монолита.
func (sf *LModMonolit) IsWork() *lev0.LBool {
	res := sf.isWork.Get()
	return lev0.LetBool(res)
}

// Ожидание завершения работы монолита.
func (sf *LModMonolit) Wait() {
	sf.kCtx.Wait()
	sf.kCtx.Wg().Wait()
	sf.kCtx.Lock()
	defer sf.kCtx.Unlock()
	sf.isWork.Reset()
	sf.isEnd.Set()
	sf.log.Debug("kMonolit.close(): end")
}