internal/api/kernel.go - master - domoi/Tcon

internal/api/kernel.go
180 строк4 KB
domoi
fix: wrong default chunk size, and fix return error type/del unnessesary code
26 май 2026, 14:08
26 май 2026, 14:08a90c826
package api

import (
	"context"
	"fmt"
	"os"
	"os/signal"
	"syscall"
	"testPrj/internal/config"
	"testPrj/internal/cryptopcg"
	"testPrj/internal/mdns"
	"testPrj/internal/service/logger"
	"testPrj/internal/transfer"
	"time"
)

type Kernel struct {
	Cr            *cryptopcg.CryptKey
	devices       *mdns.Devices
	ctx           context.Context
	cancelCtx     context.CancelFunc
	ctxMdns       context.Context
	cancelCtxMdns context.CancelFunc
	running       bool

	serverPort int
}

func NewKernel() *Kernel {
	krnl := &Kernel{
		Cr: &cryptopcg.CryptKey{},
	}
	krnl.ctx, krnl.cancelCtx = context.WithCancel(context.Background())
	return krnl
}

func (k *Kernel) Init() error {

	err := config.LoadGlobalConfig("")
	if err != nil {
		return err
	}

	err = logger.Init()
	if err != nil {
		return err
	}
	return nil
}

func (k *Kernel) StartServer(readyChan chan int) error {
	logger.Info("Попытка запуска TCP-сервера...")

	if k.running == true {
		logger.Error("Попытка не удалась, сервер уже запущен.")
		return fmt.Errorf("Сервер уже запущен")
	} else {
		k.running = true
	}
	errChan := make(chan error, 1)

	if k.ctx.Err() != nil {
		k.ctx, k.cancelCtx = context.WithCancel(context.Background())
	}

	private, public, err := cryptopcg.NewKeyPair()
	if err != nil {
		return err
	}
	k.Cr.Private = private
	k.Cr.Public = public

	go func() {
		err := transfer.TCPServer(readyChan, k.ctx, k.Cr)
		if err != nil {
			errChan <- err
		}
	}()
	select {
	case port := <-readyChan: // получаем порт
		k.serverPort = port // сохраняем в структуру Kernel
		logger.Info(fmt.Sprintf("Сервер готов к подключениям на порту %d", port))
		return nil
	case err := <-errChan:
		logger.Error(fmt.Sprintf("Ошибка запуска сервера %v", err))
		return fmt.Errorf("таймаут запуска сервера: %v", err)

	case <-time.After(10 * time.Second):
		return fmt.Errorf("таймаут запуска сервера")
	}
}

func (k *Kernel) StopServer() {
	if k.cancelCtx != nil {
		k.cancelCtx()
	}
	k.running = false
	logger.Info("Сервер получил команду на остановку")
}

func (k *Kernel) StartClient(ip string, port int, path string) error {
	logger.Info("Запускаем клиент")

	private, public, err := cryptopcg.NewKeyPair()
	if err != nil {
		return err
	}
	if private == nil {
		logger.Error("private is nil")
	}
	if public == nil {
		logger.Error("public is nil")
	}
	k.Cr.Private = private
	k.Cr.Public = public

	err = transfer.HandleConnection(k.ctx, k.Cr, ip, port, path)
	if err != nil {
		return err
	}

	return nil
}

func (k *Kernel) StopClient() {
	if k.cancelCtx != nil {
		k.cancelCtx()
	}
	logger.Info("Клиент получил команду на остановку")
}

func (k *Kernel) StartMdnsSearch() []mdns.Devices {
	res := k.devices.DiscoverServices()
	return res
}

func (k *Kernel) RegisterMdnsUser(name string) error {
	if k.ctxMdns != nil {
		return fmt.Errorf("MDNS уже существует")
	}

	//создать проверку на порт сервера. чтобы mdns отображал корректный порт
	if k.serverPort == 0 {
		return fmt.Errorf("Сервер не инициализирован.")
	}
	k.ctxMdns, k.cancelCtxMdns = context.WithCancel(context.Background())
	if err := k.devices.RegisterUser(k.ctxMdns, name, k.serverPort); err != nil {
		return err
	}
	return nil
}

func (k *Kernel) DelMdnsUser() error {
	if k.ctxMdns == nil {
		return fmt.Errorf("Mdns profile does not exists")
	}
	k.cancelCtxMdns()
	k.ctxMdns = nil
	logger.Debug("Mdns profile has been deleted")
	return nil
}

func (k *Kernel) WaitForShutdown() {
	sigChan := make(chan os.Signal, 1)
	signal.Notify(sigChan, syscall.SIGINT, syscall.SIGTERM)

	<-sigChan //Ctrl+C
	logger.Info("Получен сигнал завершения, останавливаем ядро...")

	if k.cancelCtx != nil {
		k.cancelCtx() // отменяем ВСЕ контексты
	}
	if k.cancelCtxMdns != nil {
		k.cancelCtxMdns()
	}

	// мб убрать
	time.Sleep(2 * time.Second)
	logger.Info("Ядро успешно завершило работу.")
}