kern/v4/lev2/kmonolit/kmonolit.go

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

import (
	"fmt"

	mL0 "gitp78su.ipnodns.ru/svi/kern/v4/lev0"
	mKa "gitp78su.ipnodns.ru/svi/kern/v4/lev0/alias"
	mKh "gitp78su.ipnodns.ru/svi/kern/v4/lev0/helpers"
	mKt "gitp78su.ipnodns.ru/svi/kern/v4/lev0/ktypes"
	mL1 "gitp78su.ipnodns.ru/svi/kern/v4/lev1"
	"gitp78su.ipnodns.ru/svi/kern/v4/lev2/kctx"
)

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

var (
	mon *kMonolit
)

// GetMonolit -- возвращает монолит.
func GetMonolit(name string) *mL0.Result[*kMonolit] {
	if mon != nil {
		return mL0.NewRes(mon)
	}
	mKh.Hassert(name != "", "NewMonolit(): name is empty")
	resKernCtx := kctx.GetKernelCtx()
	if resKernCtx.IsErr() {
		err := fmt.Errorf("GetMonolit(): err=\n\t%w", resKernCtx.Err())
		return mL0.NewErr[*kMonolit](err)
	}
	kCtx := resKernCtx.Val()
	res := kCtx.Get("isLocal")
	if res.IsNone() {
		err := fmt.Errorf("GetMonolit(): in get from kernCtx isLocal -- not found")
		return mL0.NewErr[*kMonolit](err)
	}
	isLocalCtx := res.Val()
	isLocal := isLocalCtx.Val().(bool)
	resLocCtx := mL1.NewLocalCtx(kCtx.Ctx())
	if resLocCtx.IsErr() {
		err := fmt.Errorf("GetMonolit(): in new local_ctx, err=\n\t%w", resLocCtx.Err())
		return mL0.NewErr[*kMonolit](err)
	}
	lCtx := resLocCtx.Val()
	sf := &kMonolit{
		kCtx:    kCtx,
		lCtx:    lCtx,
		name:    name,
		dict:    map[*mKa.AModuleName]mKt.IKernelModule{},
		isWork:  mL1.NewSafeBool(),
		isEnd:   mL1.NewSafeBool(),
		isLocal: isLocal,
	}
	sf.log = sf.lCtx.Log()
	resSet := sf.kCtx.Set("monolitName", name, "name of monolit")
	if resSet.IsErr() {
		err := fmt.Errorf("GetMonolit(): in set to kernCtx monolitName, err=\n\t%w", resSet.Err())
		return mL0.NewErr[*kMonolit](err)
	}
	resSet = sf.kCtx.Set("monolit", sf, "monolit-app")
	if resSet.IsErr() {
		err := fmt.Errorf("GetMonolit(): in set to kernCtx monolit-app, err=\n\t%w", resSet.Err())
		return mL0.NewErr[*kMonolit](err)
	}
	mon = sf
	_ = mKt.IKernelMonolit(sf)
	return mL0.NewRes(sf)
}

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

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

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

// Add -- добавляет модуль в монолит.
func (sf *kMonolit) Add(module mKt.IKernelModule) *mL0.Result[bool] {
	sf.kCtx.RLock()
	defer sf.kCtx.RUnlock()
	if module == nil {
		return mL0.NewErr[bool](fmt.Errorf("kMonolit.Add(): module==nil"))
	}
	_, isOk := sf.dict[module.Name()]
	if isOk {
		err := fmt.Errorf("kMonolit.Add(): module(%v) already exists", module.Name())
		return mL0.NewErr[bool](err)
	}
	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()
	resSet := sf.lCtx.Set(key, module, "kMonolit.Add(): module="+moduleName.Get())
	if resSet.IsErr() {
		err := fmt.Errorf("kMonolit.Add(): in set module(%v) to kernel ctx, err=\n\t%w", moduleName, resSet.Err())
		return mL0.NewErr[bool](err)
	}
	return mL0.NewRes(true)
}

// 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")
}