qb/database/database.go

package database

import (
	"errors"
	"fmt"
	"log"
	"net"
	"os"
	"sync"
	"time"

	"gordenko.dev/dima/qb"
	"gordenko.dev/dima/qb/atree"
	"gordenko.dev/dima/qb/inbox"
	"gordenko.dev/dima/qb/recovery"
	"gordenko.dev/dima/qb/storage"
	"gordenko.dev/dima/qb/worker"
)

type Database struct {
	mutex        sync.Mutex
	dir          string
	databaseName string
	workerInbox  *inbox.Inbox
	worker       *worker.Worker
	storage      *storage.Writer
	atree        *atree.Atree
	tcpPort      int
	logfile      *os.File
	logger       *log.Logger
	exitCh       chan struct{}
	waitGroup    *sync.WaitGroup
}

type Options struct {
	TCPPort      int
	Dir          string
	DatabaseName string
	Logfile      *os.File
	ExitCh       chan struct{}
	WaitGroup    *sync.WaitGroup
}

func New(opt Options) (_ *Database, err error) {
	if opt.TCPPort <= 0 {
		return nil, errors.New("TCPPort option is required")
	}
	if opt.Dir == "" {
		return nil, errors.New("Dir option is required")
	}
	if opt.DatabaseName == "" {
		return nil, errors.New("DatabaseName option is required")
	}
	if opt.Logfile == nil {
		return nil, errors.New("Logfile option is required")
	}
	if opt.ExitCh == nil {
		return nil, errors.New("ExitCh option is required")
	}
	if opt.WaitGroup == nil {
		return nil, errors.New("WaitGroup option is required")
	}

	s := &Database{
		dir:          opt.Dir,
		databaseName: opt.DatabaseName,
		tcpPort:      opt.TCPPort,
		logfile:      opt.Logfile,
		logger:       log.New(opt.Logfile, "", log.LstdFlags),
		exitCh:       opt.ExitCh,
		waitGroup:    opt.WaitGroup,
	}

	recoveryReport, err := recovery.Recovery(s.dir, s.databaseName)
	if err != nil {
		return nil, fmt.Errorf("recovery.Recovery: %s", err)
	}

	fmt.Printf("%#v\n", recoveryReport)

	storageInbox := inbox.New()
	s.workerInbox = inbox.New()

	// create separately, because needed for page cache
	dataFile, err := os.OpenFile(
		qb.GetDataFilePath(opt.Dir, opt.DatabaseName),
		os.O_CREATE|os.O_RDWR,
		0666,
	)
	if err != nil {
		return nil, err
	}

	indexFile, err := os.OpenFile(
		qb.GetIndexFilePath(opt.Dir, opt.DatabaseName),
		os.O_CREATE|os.O_RDWR,
		0666,
	)
	if err != nil {
		return nil, err
	}

	s.storage, err = storage.NewWriter(storage.WriterOptions{
		Inbox:         storageInbox,
		WorkerInbox:   s.workerInbox,
		Dir:           s.dir,
		DatabaseName:  s.databaseName,
		WAL:           recoveryReport.WAL,
		IndexFreeList: recoveryReport.IndexFreeList,
		DataFreeList:  recoveryReport.DataFreeList,
		DataFile:      dataFile,
		IndexFile:     indexFile,
		ExitCh:        s.exitCh,
		WaitGroup:     s.waitGroup,
	})
	if err != nil {
		return nil, fmt.Errorf("storage.NewWriter: %s", err)
	}

	s.worker = worker.New(worker.Options{
		Inbox:         s.workerInbox,
		StorageInbox:  storageInbox,
		ReplayMetrics: recoveryReport.ReplayMetrics,
		Dir:           opt.Dir,
		DatabaseName:  opt.DatabaseName,
		ExitCh:        opt.ExitCh,
		WaitGroup:     opt.WaitGroup,
	})

	s.atree, err = atree.New(atree.Options{
		DataFile:  dataFile,
		IndexFile: indexFile,
	})
	if err != nil {
		return nil, fmt.Errorf("atree.New: %s", err)
	}
	return s, nil
}

func (s *Database) ListenAndServe() (err error) {
	listener, err := net.Listen("tcp", fmt.Sprintf(":%d", s.tcpPort))
	if err != nil {
		return fmt.Errorf("net.Listen: %s; port=%d", err, s.tcpPort)
	}

	//s.waitGroup.Add(1)
	go s.storage.Run()

	// s.atree.Run()

	s.waitGroup.Add(1)
	go s.worker.Run()

	s.logger.Println("database started")
	for {
		// Listen for an incoming connection.
		conn, err := listener.Accept()
		if err != nil {
			s.logger.Printf("listener.Accept: %s\n", err)
			time.Sleep(time.Second)
		} else {
			go s.handleTCPConn(conn)
		}
	}
}

//

// зробити object?

// func (s *Database) replayChanges(snapshotNumber int) (err error) {
// 	snapshot, err := readSnapshot(JoinSnapshotFileName(s.dir, snapshotNumber))
// 	if err != nil {
// 		return
// 	}

// 	return nil
// }

//func (s *Database) verifySnapshot(fileName string) (_ bool, err error) {
// 	file, err := os.Open(fileName)
// 	if err != nil {
// 		return
// 	}
// 	defer file.Close()

// 	stat, err := file.Stat()
// 	if err != nil {
// 		return
// 	}

// 	if stat.Size() <= 4 {
// 		return false, nil
// 	}

// 	var (
// 		payloadSize = stat.Size() - 4
// 		hash        = crc32.NewIEEE()
// 	)

// 	_, err = io.CopyN(hash, file, payloadSize)
// 	if err != nil {
// 		return
// 	}
// 	calculatedCRC := hash.Sum32()

// 	storedCRC, err := bin.ReadUint32(file)
// 	if err != nil {
// 		return
// 	}
// 	if storedCRC != calculatedCRC {
// 		return false, fmt.Errorf("strored CRC %d not equal calculated CRC %d",
// 			storedCRC, calculatedCRC)
// 	}
// 	return true, nil
// }