kern/v4/lev2/kmonolit/kmonolit.go

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

import (
	"fmt"
	"sync"

	mL0 "gitp78su.ipnodns.ru/svi/kern/v4/lev0"
	mKd "gitp78su.ipnodns.ru/svi/kern/v4/lev0/defs"
	mKh "gitp78su.ipnodns.ru/svi/kern/v4/lev0/helpers"
	mKs "gitp78su.ipnodns.ru/svi/kern/v4/lev0/kspec"
	mL1 "gitp78su.ipnodns.ru/svi/kern/v4/lev1"
	"gitp78su.ipnodns.ru/svi/kern/v4/lev2/kctx"
)

// kMonolit -- объект модульного монолита.
type kMonolit struct {
	kCtx    mKs.IKernelCtx
	lCtx    mKs.ILocalCtx
	log     mKs.ILogBuf
	name    string
	isLocal bool
	isWork  mKs.ISafeBool
	isEnd   mKs.ISafeBool
	dict    map[*mKd.ModuleName]mKs.IKernelModule // Словарь модулей монолита
}

var (
	mon   *kMonolit
	block sync.Mutex
)

// GetMonolit -- возвращает монолит.
func GetMonolit(name string) *kMonolit {
	block.Lock()
	defer block.Unlock()
	if mon != nil {
		return mon
	}
	mKh.Hassert(name != "", "NewMonolit(): name is empty")
	kCtx := kctx.GetKernelCtx()
	opt := kCtx.Get("isLocal")
	opt.Hassert("GetMonolit(): in get from kernCtx isLocal -- not found")
	isLocalCtx := opt.Some()
	isLocal := isLocalCtx.Val().(bool)
	lCtx := mL1.NewLocalCtx(kCtx.Ctx())
	sf := &kMonolit{
		kCtx:    kCtx,
		lCtx:    lCtx,
		name:    name,
		dict:    map[*mKd.ModuleName]mKs.IKernelModule{},
		isWork:  mL1.NewSafeBool(),
		isEnd:   mL1.NewSafeBool(),
		isLocal: isLocal,
	}
	sf.log = sf.lCtx.Log()
	sf.kCtx.Set("monolitName", name, "name of monolit")
	sf.kCtx.Set("monolit", sf, "monolit-app")
	mon = sf
	_ = mKs.IKernelMonolit(sf)
	return sf
}

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

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

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

// Add -- добавляет модуль в монолит.
func (sf *kMonolit) Add(module mKs.IKernelModule) {
	sf.kCtx.RLock()
	defer sf.kCtx.RUnlock()
	mL0.Hassert(module != nil, "kMonolit.Add(): module==nil")
	_, isOk := sf.dict[module.Name()]
	mL0.Hassert(!isOk, "kMonolit.Add(): module(%v) already exists", module.Name())
	sf.dict[module.Name()] = 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 := fmt.Sprintf("module_%v", len(sf.dict))
	moduleName := module.Name()
	sf.lCtx.Set(key, module, "kMonolit.Add(): module="+moduleName.Get())
}

// Run -- запускает монолит в работу.
func (sf *kMonolit) 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 *kMonolit) IsLocal() bool {
	return sf.isLocal
}

// IsWork -- возвращает признак работы монолита.
func (sf *kMonolit) IsWork() bool {
	return sf.isWork.Get()
}

// Ожидание завершения работы монолита.
func (sf *kMonolit) 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")
}