From fbb30f31e86bea8bfa5a791fe504c44732f037cd Mon Sep 17 00:00:00 2001 From: Dima Gordenko <1.e4.kc6@gmail.com> Date: Tue, 3 Jun 2025 05:04:18 +0300 Subject: [PATCH] rc1 --- README.md | 132 ++++ atree/aggregate.go | 325 ++++++++ atree/atree.go | 497 ++++++++++++ atree/cursor.go | 187 +++++ atree/io.go | 430 ++++++++++ atree/misc.go | 214 +++++ atree/redo/reader.go | 96 +++ atree/redo/writer.go | 207 +++++ atree/select.go | 619 +++++++++++++++ atree/writers.go | 306 ++++++++ bin/bin.go | 621 +++++++++++++++ bufreader/bufreader.go | 138 ++++ chunkenc/chunckenc.go | 3 + chunkenc/cumdelta.go | 330 ++++++++ chunkenc/insdelta.go | 345 ++++++++ chunkenc/time_delta_delta.go | 374 +++++++++ client/client.go | 755 ++++++++++++++++++ conbuf/conbuf.go | 459 +++++++++++ database.ini | 4 + database/api.go | 1058 +++++++++++++++++++++++++ database/database.go | 460 +++++++++++ database/helpers.go | 50 ++ database/metric.go | 71 ++ database/proc.go | 1736 +++++++++++++++++++++++++++++++++++++++++ database/snapshot.go | 287 +++++++ database_linux | Bin 0 -> 4755144 bytes database_windows | Bin 0 -> 4890112 bytes diploma.go | 88 +++ enc/cumdelta.go | 102 +++ enc/enc.go | 3 + enc/insdelta.go | 130 +++ enc/time_delta_delta.go | 145 ++++ examples/database/main.go | 135 ++++ examples/loadtest/loadtest.go | 377 +++++++++ examples/loadtest/main.go | 261 +++++++ examples/requests/generate.go | 81 ++ examples/requests/main.go | 90 +++ examples/requests/requests.go | 361 +++++++++ freelist/freelist.go | 72 ++ go.mod | 13 + go.sum | 20 + linux_build.sh | 11 + loadtest.ini | 9 + loadtest_linux | Bin 0 -> 4337534 bytes loadtest_windows | Bin 0 -> 4506112 bytes proto/proto.go | 473 +++++++++++ recovery/advisor.go | 255 ++++++ requests.ini | 1 + requests_linux | Bin 0 -> 3825404 bytes requests_windows | Bin 0 -> 3998208 bytes timeutil/timeutil.go | 39 + txlog/reader.go | 346 ++++++++ txlog/writer.go | 507 ++++++++++++ windows_build.sh | 11 + 54 files changed, 13234 insertions(+) create mode 100644 atree/aggregate.go create mode 100644 atree/atree.go create mode 100644 atree/cursor.go create mode 100644 atree/io.go create mode 100644 atree/misc.go create mode 100644 atree/redo/reader.go create mode 100644 atree/redo/writer.go create mode 100644 atree/select.go create mode 100644 atree/writers.go create mode 100644 bin/bin.go create mode 100644 bufreader/bufreader.go create mode 100644 chunkenc/chunckenc.go create mode 100644 chunkenc/cumdelta.go create mode 100644 chunkenc/insdelta.go create mode 100644 chunkenc/time_delta_delta.go create mode 100644 client/client.go create mode 100644 conbuf/conbuf.go create mode 100644 database.ini create mode 100644 database/api.go create mode 100644 database/database.go create mode 100644 database/helpers.go create mode 100644 database/metric.go create mode 100644 database/proc.go create mode 100644 database/snapshot.go create mode 100755 database_linux create mode 100755 database_windows create mode 100644 diploma.go create mode 100644 enc/cumdelta.go create mode 100644 enc/enc.go create mode 100644 enc/insdelta.go create mode 100644 enc/time_delta_delta.go create mode 100644 examples/database/main.go create mode 100644 examples/loadtest/loadtest.go create mode 100644 examples/loadtest/main.go create mode 100644 examples/requests/generate.go create mode 100644 examples/requests/main.go create mode 100644 examples/requests/requests.go create mode 100644 freelist/freelist.go create mode 100644 go.mod create mode 100644 go.sum create mode 100755 linux_build.sh create mode 100644 loadtest.ini create mode 100755 loadtest_linux create mode 100755 loadtest_windows create mode 100644 proto/proto.go create mode 100644 recovery/advisor.go create mode 100644 requests.ini create mode 100755 requests_linux create mode 100755 requests_windows create mode 100644 timeutil/timeutil.go create mode 100644 txlog/reader.go create mode 100644 txlog/writer.go create mode 100755 windows_build.sh diff --git a/README.md b/README.md index e69de29..fb142fc 100644 --- a/README.md +++ b/README.md @@ -0,0 +1,132 @@ +1. Zip-архів із базою даних на 841 млн показань (791 МБ) можна скачати за посиланням https://drive.google.com/file/d/18oks6STkVpg4-TT2WyCIBBpCgRyF29L2 + +В архіві 5 файлів: +2.changes +2.snapshot +test.data +test.index +metrics.info + +Після розпаковки їх необхідно перемістити в директорію testdir. + + +2. Якщо є бажання експериментувати з пустою базою даних, краще створити нову. Наприклад, назвемо її "x": створюємо директорію xdir, створюємо файл x.ini із такими налаштуваннями: +tcpPort = 12345 +dir = xdir +redoDir = xdir +databaseName = x + +Запускаємо СУБД із термінала: +./database_linux -c x.ini + +Всі операції виконуємо в кореневій директорії проєкту. + +3. Файли *.ini: +database.ini - налаштування СУБД (database); +loadtest.ini - налаштування навантажувального тесту (loadtest); +requests.ini - налаштування прикладів запитів (requests). + + +4. Скомпільоване ПО для Linux (64-бітна архітектура): +database_linux - СУБД; +loadtest_linux - навантажувального тест; +requests_linux - приклади запитів. + + +5. Скомпільоване ПО для Windows (64-бітна архітектура): +database_windows - СУБД; +loadtest_windows - навантажувального тест; +requests_windows - приклади запитів. + + +6. Директорія examples має три вкладені директорії із вихідними кодами: +database - запуску СУБД; +loadtest - навантажувального тесту; +requests - різних типів запитів, що підтримуються СУБД. + + +7. Якщо на комп'ютері встановлено компілятор Go, можна скомпілювати згадані вище програми за допомогою bash-скриптів: + +./linux_build.sh +./windows_build.sh + +Скомпільовані версії програм опиняться в кореневій директорії проєкту. + + +8. Файли з даними розміщуються в директорії datadir. В базі даних вже записано 841 млн. показань. Сумарний розмір трохи більше 1.3 GB. + + +9. Налаштування навантажувального тесту можна змінити, відредагувавши файл loadtest.ini. +Опція connections - це кількість одночасно відкритих підключень до СУБД. +Опція requestsPerConn - це кількість запитів, які відправляє потік через одне відкрите підключення. + +Звіт виглядає наступним чином: + +TEST RESULTS: +Time: 2 seconds +Connections: 100 +Requests per conn: 500 +Total requests: 50000 +AVG request time: 3.121022ms +RPS: 26891 + +listCumulativeMeasures: 3099 (6.2%), AVG request time: 3.785916ms +listCumulativePeriods: 12055 (24.1%), AVG request time: 2.726391ms +listInstantMeasures: 1974 (3.9%), AVG request time: 6.726605ms +listInstantPeriods: 7710 (15.4%), AVG request time: 2.9808ms +listCurrentValues: 25162 (50.3%), AVG request time: 2.988301ms + +last day: 20382 (82.1%), AVG request time: 2.954718ms +last week: 2993 (12.1%), AVG request time: 4.050662ms +last month: 708 (2.9%), AVG request time: 8.248486ms +random time range: 755 (3.0%), AVG request time: 3.540239ms + +Навантажувальний тест відправляє випадкові запити до випадкових метрик. Оскільки на реальному проєкті запити та часові діапазони мають різну ймовірність - я реалізував це в навантажувальному тесті. + +Приклад 1: +listCurrentValues: 25162 (50.3%) , AVG request time: 2.988301ms +означає що відправлено 25162 запитів listCurrentValues, що склало 50.3% від загальної кількості запитів. Середній час виконання (Latency) запитів listCurrentValues склав 2.99 міллісекунди. + +Приклад 2: +last month: 708 (2.9%), AVG request time: 8.248486ms +означає що відправлено 708 запитів на отримання даних за останній місяць, що склало 2.9% від загальної кількості. Середній час виконання (Latency) таких запитів склав 8.25 міллісекунди. Часовий діапазон задається для всіх запитів окрім listCurrentValues. + +10. Запуск навантажувального тесту: +Виконуємо пункт 1. + +Запускаємо СУБД із термінала: +./database_linux + +Запускаємо тест із іншого термінала: +./loadtest_linux + +Чекаємо завершення. Звіт буде надруковано у терміналі після завершення тесту. + +Команди для Windows: +./database_windows +./loadtest_windows + +11. Запуск прикладів запитів: +Можна запускати на пустій базі даних (без скачування Zip-архіва із показаннями). + +Запускаємо СУБД із термінала: +./database_linux + +Запускаємо тест із іншого термінала: +./requests_linux + +Результат виконання запитів друкується у терміналі. + +Команди для Windows: +./database_windows +./requests_windows + + +12. Подивитись HELP: +./database_linux -h +./loadtest_linux -h +./requests_linux -h + + +13. Зупинити СУБД, перервати навантажувальний тест: +Ctrl + C diff --git a/atree/aggregate.go b/atree/aggregate.go new file mode 100644 index 0000000..c4081ab --- /dev/null +++ b/atree/aggregate.go @@ -0,0 +1,325 @@ +package atree + +import ( + "fmt" + "time" + + "gordenko.dev/dima/diploma" + "gordenko.dev/dima/diploma/timeutil" +) + +// AGGREGATE + +type InstantAggregator struct { + firstHourOfDay int + lastDayOfMonth int + time2period func(uint32) uint32 + currentPeriod uint32 + since uint32 + until uint32 + min float64 + max float64 + total float64 + entries int +} + +type InstantAggregatorOptions struct { + GroupBy diploma.GroupBy + FirstHourOfDay int + LastDayOfMonth int +} + +func NewInstantAggregator(opt InstantAggregatorOptions) (*InstantAggregator, error) { + s := &InstantAggregator{ + firstHourOfDay: opt.FirstHourOfDay, + lastDayOfMonth: opt.LastDayOfMonth, + } + + switch opt.GroupBy { + case diploma.GroupByHour: + s.time2period = groupByHour + + case diploma.GroupByDay: + if s.firstHourOfDay > 0 { + s.time2period = s.groupByDayUsingFHD + } else { + s.time2period = groupByDay + } + + case diploma.GroupByMonth: + if s.firstHourOfDay > 0 { + if s.lastDayOfMonth > 0 { + s.time2period = s.groupByMonthUsingFHDAndLDM + } else { + s.time2period = s.groupByMonthUsingFHD + } + } else { + if s.lastDayOfMonth > 0 { + s.time2period = s.groupByMonthUsingLDM + } else { + s.time2period = groupByMonth + } + } + + default: + return nil, fmt.Errorf("unknown groupBy %d option", opt.GroupBy) + } + + return s, nil +} + +// Приходят данные от свежих к старым, тоесть сперва получаю Until. +// return period complete flag +func (s *InstantAggregator) Feed(timestamp uint32, value float64, p *InstantPeriod) bool { + period := s.time2period(timestamp) + //fmt.Printf("feed: %s %v, period: %s\n", time.Unix(int64(timestamp), 0), value, time.Unix(int64(period), 0)) + if s.entries == 0 { + s.currentPeriod = period + s.since = timestamp + s.until = timestamp + s.min = value + s.max = value + s.total = value + s.entries = 1 + return false + } + + if period != s.currentPeriod { + // готовый период + s.FillPeriod(timestamp, p) + s.currentPeriod = period + s.since = timestamp + s.until = timestamp + s.min = value + s.max = value + s.total = value + s.entries = 1 + return true + } + + if value < s.min { + s.min = value + } else if value > s.max { + s.max = value + } + // для подсчета AVG + s.total += value + s.entries++ + // начало периода + s.since = timestamp + return false +} + +func (s *InstantAggregator) FillPeriod(prevTimestamp uint32, p *InstantPeriod) bool { + if s.entries == 0 { + return false + } + + //fmt.Printf("FillPeriod: %s, prevTimestamp: %s\n", time.Unix(int64(s.currentPeriod), 0), time.Unix(int64(prevTimestamp), 0)) + p.Period = s.currentPeriod + if prevTimestamp > 0 { + p.Since = prevTimestamp + } else { + p.Since = s.since + } + p.Until = s.until + p.Min = s.min + p.Max = s.max + p.Avg = s.total / float64(s.entries) + return true +} + +func (s *InstantAggregator) groupByDayUsingFHD(timestamp uint32) uint32 { + tm := timeutil.FirstSecondInPeriod(time.Unix(int64(timestamp), 0), "d") + if tm.Hour() < s.firstHourOfDay { + tm = tm.AddDate(0, 0, -1) + } + return uint32(tm.Unix()) +} + +func (s *InstantAggregator) groupByMonthUsingFHD(timestamp uint32) uint32 { + tm := timeutil.FirstSecondInPeriod(time.Unix(int64(timestamp), 0), "m") + if tm.Hour() < s.firstHourOfDay { + tm = tm.AddDate(0, 0, -1) + } + return uint32(tm.Unix()) +} + +func (s *InstantAggregator) groupByMonthUsingLDM(timestamp uint32) uint32 { + tm := timeutil.FirstSecondInPeriod(time.Unix(int64(timestamp), 0), "m") + if tm.Day() > s.lastDayOfMonth { + tm = tm.AddDate(0, 1, 0) + } + return uint32(tm.Unix()) +} + +func (s *InstantAggregator) groupByMonthUsingFHDAndLDM(timestamp uint32) uint32 { + // ВАЖНО! + // Сперва проверяю время. + tm := timeutil.FirstSecondInPeriod(time.Unix(int64(timestamp), 0), "m") + if tm.Hour() < s.firstHourOfDay { + tm = tm.AddDate(0, 0, -1) + } + if tm.Day() > s.lastDayOfMonth { + tm = tm.AddDate(0, 1, 0) + } + return uint32(tm.Unix()) +} + +// CUMULATIVE + +type CumulativeAggregator struct { + firstHourOfDay int + lastDayOfMonth int + time2period func(uint32) uint32 + currentPeriod uint32 + since uint32 + until uint32 + sinceValue float64 + untilValue float64 + entries int +} + +type CumulativeAggregatorOptions struct { + GroupBy diploma.GroupBy + FirstHourOfDay int + LastDayOfMonth int +} + +func NewCumulativeAggregator(opt CumulativeAggregatorOptions) (*CumulativeAggregator, error) { + s := &CumulativeAggregator{ + firstHourOfDay: opt.FirstHourOfDay, + lastDayOfMonth: opt.LastDayOfMonth, + } + + switch opt.GroupBy { + case diploma.GroupByHour: + s.time2period = groupByHour + + case diploma.GroupByDay: + if s.firstHourOfDay > 0 { + s.time2period = s.groupByDayUsingFHD + } else { + s.time2period = groupByDay + } + + case diploma.GroupByMonth: + if s.firstHourOfDay > 0 { + if s.lastDayOfMonth > 0 { + s.time2period = s.groupByMonthUsingFHDAndLDM + } else { + s.time2period = s.groupByMonthUsingFHD + } + } else { + if s.lastDayOfMonth > 0 { + s.time2period = s.groupByMonthUsingLDM + } else { + s.time2period = groupByMonth + } + } + + default: + return nil, fmt.Errorf("unknown groupBy %d option", opt.GroupBy) + } + + return s, nil +} + +// return period complete flag +func (s *CumulativeAggregator) Feed(timestamp uint32, value float64, p *CumulativePeriod) bool { + period := s.time2period(timestamp) + if s.entries == 0 { + s.currentPeriod = period + s.since = timestamp + s.until = timestamp + s.sinceValue = value + s.untilValue = value + s.entries = 1 + return false + } + + if period != s.currentPeriod { + // готовый период + s.FillPeriod(timestamp, value, p) + s.currentPeriod = period + s.since = timestamp + s.until = timestamp + s.sinceValue = value + s.untilValue = value + s.entries = 1 + return true + } + + // начало периода + s.since = timestamp + s.sinceValue = value + s.entries++ + return false +} + +func (s *CumulativeAggregator) FillPeriod(prevTimestamp uint32, value float64, p *CumulativePeriod) bool { + if s.entries == 0 { + return false + } + p.Period = s.currentPeriod + if prevTimestamp > 0 { + p.Since = prevTimestamp + p.Total = s.untilValue - value + } else { + p.Since = s.since + p.Total = s.untilValue - s.sinceValue + } + p.Until = s.until + p.EndValue = s.untilValue + + return true +} + +func (s *CumulativeAggregator) groupByDayUsingFHD(timestamp uint32) uint32 { + tm := timeutil.FirstSecondInPeriod(time.Unix(int64(timestamp), 0), "d") + if tm.Hour() < s.firstHourOfDay { + tm = tm.AddDate(0, 0, -1) + } + return uint32(tm.Unix()) +} + +func (s *CumulativeAggregator) groupByMonthUsingFHD(timestamp uint32) uint32 { + tm := timeutil.FirstSecondInPeriod(time.Unix(int64(timestamp), 0), "m") + if tm.Hour() < s.firstHourOfDay { + tm = tm.AddDate(0, 0, -1) + } + return uint32(tm.Unix()) +} + +func (s *CumulativeAggregator) groupByMonthUsingLDM(timestamp uint32) uint32 { + tm := timeutil.FirstSecondInPeriod(time.Unix(int64(timestamp), 0), "m") + if tm.Day() > s.lastDayOfMonth { + tm = tm.AddDate(0, 1, 0) + } + return uint32(tm.Unix()) +} + +func (s *CumulativeAggregator) groupByMonthUsingFHDAndLDM(timestamp uint32) uint32 { + // ВАЖНО! + // Сперва проверяю время. + tm := timeutil.FirstSecondInPeriod(time.Unix(int64(timestamp), 0), "m") + if tm.Hour() < s.firstHourOfDay { + tm = tm.AddDate(0, 0, -1) + } + if tm.Day() > s.lastDayOfMonth { + tm = tm.AddDate(0, 1, 0) + } + return uint32(tm.Unix()) +} + +func groupByHour(timestamp uint32) uint32 { + return uint32(timeutil.FirstSecondInPeriod(time.Unix(int64(timestamp), 0), "h").Unix()) +} + +func groupByDay(timestamp uint32) uint32 { + return uint32(timeutil.FirstSecondInPeriod(time.Unix(int64(timestamp), 0), "d").Unix()) +} + +func groupByMonth(timestamp uint32) uint32 { + return uint32(timeutil.FirstSecondInPeriod(time.Unix(int64(timestamp), 0), "m").Unix()) +} diff --git a/atree/atree.go b/atree/atree.go new file mode 100644 index 0000000..d554f91 --- /dev/null +++ b/atree/atree.go @@ -0,0 +1,497 @@ +package atree + +import ( + "errors" + "fmt" + "os" + "path/filepath" + "sync" + + "gordenko.dev/dima/diploma" + "gordenko.dev/dima/diploma/atree/redo" + "gordenko.dev/dima/diploma/bin" +) + +const ( + filePerm = 0770 + + // index page + indexRecordsQtyIdx = IndexPageSize - 7 + isDataPageNumbersIdx = IndexPageSize - 5 + indexCRC32Idx = IndexPageSize - 4 + + // data page + timestampsSizeIdx = DataPageSize - 12 + valuesSizeIdx = DataPageSize - 10 + prevPageIdx = DataPageSize - 8 + dataCRC32Idx = DataPageSize - 4 + + timestampSize = 4 + pairSize = timestampSize + PageNoSize + indexFooterIdx = indexRecordsQtyIdx + dataFooterIdx = timestampsSizeIdx + + DataPageSize = 8192 + IndexPageSize = 1024 + PageNoSize = 4 + // + DataPagePayloadSize int = dataFooterIdx +) + +type FreeList interface { + ReservePage() uint32 +} + +type _page struct { + PageNo uint32 + Buf []byte + ReferenceCount int +} + +type Atree struct { + redoDir string + indexFreelist FreeList + dataFreelist FreeList + dataFile *os.File + indexFile *os.File + mutex sync.Mutex + allocatedIndexPagesQty uint32 + allocatedDataPagesQty uint32 + indexPages map[uint32]*_page + dataPages map[uint32]*_page + indexWaits map[uint32][]chan readResult + dataWaits map[uint32][]chan readResult + indexPagesToRead []uint32 + dataPagesToRead []uint32 + readSignalCh chan struct{} + writeSignalCh chan struct{} + writeTasksQueue []WriteTask +} + +type Options struct { + Dir string + RedoDir string + DatabaseName string + DataFreeList FreeList + IndexFreeList FreeList +} + +func New(opt Options) (*Atree, error) { + if opt.Dir == "" { + return nil, errors.New("Dir option is required") + } + if opt.RedoDir == "" { + return nil, errors.New("RedoDir option is required") + } + if opt.DatabaseName == "" { + return nil, errors.New("DatabaseName option is required") + } + if opt.DataFreeList == nil { + return nil, errors.New("DataFreeList option is required") + } + if opt.IndexFreeList == nil { + return nil, errors.New("IndexFreeList option is required") + } + // открываю или создаю dbName.data и dbName.index файлы + var ( + indexFileName = filepath.Join(opt.Dir, opt.DatabaseName+".index") + dataFileName = filepath.Join(opt.Dir, opt.DatabaseName+".data") + + indexFile *os.File + dataFile *os.File + allocatedIndexPagesQty uint32 + allocatedDataPagesQty uint32 + ) + + // При создании data файла сразу создается индекс, поэтому корректное + // состояние БД: либо оба файла есть, либо ни одного файла нет. + isIndexExist, err := isFileExist(indexFileName) + if err != nil { + return nil, fmt.Errorf("check index file is exist: %s", err) + } + + isDataExist, err := isFileExist(dataFileName) + if err != nil { + return nil, fmt.Errorf("check data file is exist: %s", err) + } + + if isIndexExist { + if isDataExist { + // открываю оба файла + indexFile, allocatedIndexPagesQty, err = openFile(indexFileName, IndexPageSize) + if err != nil { + return nil, fmt.Errorf("open index file: %s", err) + } + + dataFile, allocatedDataPagesQty, err = openFile(dataFileName, DataPageSize) + if err != nil { + return nil, fmt.Errorf("open data file: %s", err) + } + } else { + // нет data файла + return nil, errors.New("not found data file") + } + } else { + if isDataExist { + // index файла нет + return nil, errors.New("not found index file") + } else { + // нет обоих файлов + indexFile, err = os.OpenFile(indexFileName, os.O_CREATE|os.O_RDWR, filePerm) + if err != nil { + return nil, err + } + + dataFile, err = os.OpenFile(dataFileName, os.O_CREATE|os.O_RDWR, filePerm) + if err != nil { + return nil, err + } + } + } + + tree := &Atree{ + redoDir: opt.RedoDir, + indexFreelist: opt.IndexFreeList, + dataFreelist: opt.DataFreeList, + indexFile: indexFile, + dataFile: dataFile, + allocatedIndexPagesQty: allocatedIndexPagesQty, + allocatedDataPagesQty: allocatedDataPagesQty, + indexPages: make(map[uint32]*_page), + dataPages: make(map[uint32]*_page), + indexWaits: make(map[uint32][]chan readResult), + dataWaits: make(map[uint32][]chan readResult), + readSignalCh: make(chan struct{}, 1), + writeSignalCh: make(chan struct{}, 1), + } + + return tree, nil +} + +func (s *Atree) Run() { + go s.pageWriter() + go s.pageReader() +} + +// FIND + +func (s *Atree) findDataPage(rootPageNo uint32, timestamp uint32) (uint32, []byte, error) { + indexPageNo := rootPageNo + for { + buf, err := s.fetchIndexPage(indexPageNo) + if err != nil { + return 0, nil, fmt.Errorf("fetchIndexPage(%d): %s", indexPageNo, err) + } + + foundPageNo := findPageNo(buf, timestamp) + s.releaseIndexPage(indexPageNo) + + if buf[isDataPageNumbersIdx] == 1 { + buf, err := s.fetchDataPage(foundPageNo) + if err != nil { + return 0, nil, fmt.Errorf("fetchDataPage(%d): %s", foundPageNo, err) + } + return foundPageNo, buf, nil + } + // вглубь + indexPageNo = foundPageNo + } +} + +type pathLeg struct { + PageNo uint32 + Data []byte +} + +type pathToDataPage struct { + Legs []pathLeg + LastPageNo uint32 +} + +func (s *Atree) findPathToLastPage(rootPageNo uint32) (_ pathToDataPage, err error) { + var ( + pageNo = rootPageNo + legs []pathLeg + ) + + for { + var buf []byte + buf, err = s.fetchIndexPage(pageNo) + if err != nil { + err = fmt.Errorf("FetchIndexPage(%d): %s", pageNo, err) + return + } + + legs = append(legs, pathLeg{ + PageNo: pageNo, + Data: buf, + // childIdx не нужен + }) + + foundPageNo := getLastPageNo(buf) + + if buf[isDataPageNumbersIdx] == 1 { + return pathToDataPage{ + Legs: legs, + LastPageNo: foundPageNo, + }, nil + } + // вглубь + pageNo = foundPageNo + } +} + +// APPEND DATA PAGE + +type AppendDataPageReq struct { + MetricID uint32 + Timestamp uint32 + Value float64 + Since uint32 + RootPageNo uint32 + PrevPageNo uint32 + TimestampsChunks [][]byte + TimestampsSize uint16 + ValuesChunks [][]byte + ValuesSize uint16 +} + +func (s *Atree) AppendDataPage(req AppendDataPageReq) (_ redo.Report, err error) { + var ( + flags byte + dataPagesToRelease []uint32 + indexPagesToRelease []uint32 + ) + + newDataPage := s.allocDataPage() + dataPagesToRelease = append(dataPagesToRelease, newDataPage.PageNo) + + chunksToDataPage(newDataPage.Data, chunksToDataPageReq{ + PrevPageNo: req.PrevPageNo, + TimestampsChunks: req.TimestampsChunks, + TimestampsSize: req.TimestampsSize, + ValuesChunks: req.ValuesChunks, + ValuesSize: req.ValuesSize, + }) + + redoWriter, err := redo.NewWriter(redo.WriterOptions{ + Dir: s.redoDir, + MetricID: req.MetricID, + Timestamp: req.Timestamp, + Value: req.Value, + IsDataPageReused: newDataPage.IsReused, + DataPageNo: newDataPage.PageNo, + Page: newDataPage.Data, + }) + if err != nil { + return + } + + if req.RootPageNo > 0 { + var path pathToDataPage + path, err = s.findPathToLastPage(req.RootPageNo) + if err != nil { + return + } + for _, leg := range path.Legs { + indexPagesToRelease = append(indexPagesToRelease, leg.PageNo) + } + + if path.LastPageNo != req.PrevPageNo { + diploma.Abort( + diploma.WrongPrevPageNo, + fmt.Errorf("bug: last pageNo %d in tree != prev pageNo %d in _metric", + path.LastPageNo, req.PrevPageNo), + ) + } + + newPageNo := newDataPage.PageNo + lastIdx := len(path.Legs) - 1 + + for legIdx := lastIdx; legIdx >= 0; legIdx-- { + leg := path.Legs[legIdx] + + ok := appendPair(leg.Data, req.Since, newPageNo) + if ok { + err = redoWriter.AppendIndexPage(leg.PageNo, leg.Data, 0) + if err != nil { + return + } + break + } + + newIndexPage := s.allocIndexPage() + indexPagesToRelease = append(indexPagesToRelease, newIndexPage.PageNo) + appendPair(newIndexPage.Data, req.Since, newPageNo) + // ставлю мітку що всі pageNo на сторінці - це data pageNo + if legIdx == lastIdx { + newIndexPage.Data[isDataPageNumbersIdx] = 1 + } + + flags = 0 + if newIndexPage.IsReused { + flags |= redo.FlagReused + } + err = redoWriter.AppendIndexPage(newIndexPage.PageNo, newIndexPage.Data, flags) + if err != nil { + return + } + // + newPageNo = newIndexPage.PageNo + + if legIdx == 0 { + newRoot := s.allocIndexPage() + indexPagesToRelease = append(indexPagesToRelease, newRoot.PageNo) + appendPair(newRoot.Data, getSince(leg.Data), leg.PageNo) // old rootPageNo + appendPair(newRoot.Data, req.Since, newIndexPage.PageNo) + + // Фиксирую новый root в REDO логе + flags = redo.FlagNewRoot + if newRoot.IsReused { + flags |= redo.FlagReused + } + err = redoWriter.AppendIndexPage(newRoot.PageNo, newRoot.Data, flags) + if err != nil { + return + } + break + } + } + } else { + newRoot := s.allocIndexPage() + indexPagesToRelease = append(indexPagesToRelease, newRoot.PageNo) + newRoot.Data[isDataPageNumbersIdx] = 1 + appendPair(newRoot.Data, req.Since, newDataPage.PageNo) + + flags = redo.FlagNewRoot + if newRoot.IsReused { + flags |= redo.FlagReused + } + err = redoWriter.AppendIndexPage(newRoot.PageNo, newRoot.Data, flags) + if err != nil { + return + } + } + + err = redoWriter.Close() + if err != nil { + return + } + + // На данний момен схема - наступна. Всі сторінки - data та index - зафіксовані в кеші. + // Отже запис на диск пройде максимально швидко. Після цього ReferenceCount кожної + // сторінки зменшиться на 1. Оскільки на метрику утримується XLock, сторінки мають + // ReferenceCount = 1 (немає інших читачів). + waitCh := make(chan struct{}) + + task := WriteTask{ + WaitCh: waitCh, + DataPage: redo.PageToWrite{ + PageNo: newDataPage.PageNo, + Data: newDataPage.Data, + }, + IndexPages: redoWriter.IndexPagesToWrite(), + } + + s.appendWriteTaskToQueue(task) + + <-waitCh + + for _, pageNo := range dataPagesToRelease { + s.releaseDataPage(pageNo) + } + for _, pageNo := range indexPagesToRelease { + s.releaseIndexPage(pageNo) + } + return redoWriter.GetReport(), nil +} + +// DELETE + +type PageLists struct { + DataPages []uint32 + IndexPages []uint32 +} + +type Level struct { + PageNo uint32 + PageData []byte + Idx int + ChildQty int +} + +func (s *Atree) GetAllPages(rootPageNo uint32) (_ PageLists, err error) { + var ( + dataPages []uint32 + indexPages []uint32 + levels []*Level + ) + + buf, err := s.fetchIndexPage(rootPageNo) + if err != nil { + err = fmt.Errorf("fetchIndexPage(%d): %s", rootPageNo, err) + return + } + indexPages = append(indexPages, rootPageNo) + + if buf[isDataPageNumbersIdx] == 1 { + pageNumbers := listPageNumbers(buf) + dataPages = append(dataPages, pageNumbers...) + + s.releaseIndexPage(rootPageNo) + + return PageLists{ + DataPages: dataPages, + IndexPages: indexPages, + }, nil + } + + levels = append(levels, &Level{ + PageNo: rootPageNo, + PageData: buf, + Idx: 0, + ChildQty: bin.GetUint16AsInt(buf[indexRecordsQtyIdx:]), + }) + + for { + if len(levels) == 0 { + return PageLists{ + DataPages: dataPages, + IndexPages: indexPages, + }, nil + } + + lastIdx := len(levels) - 1 + level := levels[lastIdx] + + if level.Idx < level.ChildQty { + pageNo := getPageNo(level.PageData, level.Idx) + level.Idx++ + + var buf []byte + buf, err = s.fetchIndexPage(pageNo) + if err != nil { + err = fmt.Errorf("fetchIndexPage(%d): %s", pageNo, err) + return + } + indexPages = append(indexPages, pageNo) + + if buf[isDataPageNumbersIdx] == 1 { + pageNumbers := listPageNumbers(buf) + dataPages = append(dataPages, pageNumbers...) + + s.releaseIndexPage(pageNo) + } else { + levels = append(levels, &Level{ + PageNo: pageNo, + PageData: buf, + Idx: 0, + ChildQty: bin.GetUint16AsInt(buf[indexRecordsQtyIdx:]), + }) + } + } else { + s.releaseIndexPage(level.PageNo) + levels = levels[:lastIdx] + } + } +} diff --git a/atree/cursor.go b/atree/cursor.go new file mode 100644 index 0000000..fe69a63 --- /dev/null +++ b/atree/cursor.go @@ -0,0 +1,187 @@ +package atree + +import ( + "errors" + "fmt" + + octopus "gordenko.dev/dima/diploma" + "gordenko.dev/dima/diploma/bin" + "gordenko.dev/dima/diploma/enc" +) + +type BackwardCursor struct { + metricType octopus.MetricType + fracDigits byte + atree *Atree + pageNo uint32 + pageData []byte + timestampDecompressor octopus.TimestampDecompressor + valueDecompressor octopus.ValueDecompressor +} + +type BackwardCursorOptions struct { + MetricType octopus.MetricType + FracDigits byte + PageNo uint32 + PageData []byte + Atree *Atree +} + +func NewBackwardCursor(opt BackwardCursorOptions) (*BackwardCursor, error) { + switch opt.MetricType { + case octopus.Instant, octopus.Cumulative: + // ok + default: + return nil, fmt.Errorf("MetricType option has wrong value: %d", opt.MetricType) + } + if opt.FracDigits > octopus.MaxFracDigits { + return nil, errors.New("FracDigits option is required") + } + if opt.Atree == nil { + return nil, errors.New("Atree option is required") + } + if opt.PageNo == 0 { + return nil, errors.New("PageNo option is required") + } + if len(opt.PageData) == 0 { + return nil, errors.New("PageData option is required") + } + + s := &BackwardCursor{ + metricType: opt.MetricType, + fracDigits: opt.FracDigits, + atree: opt.Atree, + pageNo: opt.PageNo, + pageData: opt.PageData, + } + err := s.makeDecompressors() + if err != nil { + return nil, err + } + return s, nil +} + +// timestamp, value, done, error +func (s *BackwardCursor) Prev() (uint32, float64, bool, error) { + var ( + timestamp uint32 + value float64 + done bool + err error + ) + + timestamp, done = s.timestampDecompressor.NextValue() + if !done { + value, done = s.valueDecompressor.NextValue() + if done { + return 0, 0, false, + fmt.Errorf("corrupted data page %d: has timestamp, no value", + s.pageNo) + } + return timestamp, value, false, nil + } + + prevPageNo := bin.GetUint32(s.pageData[prevPageIdx:]) + if prevPageNo == 0 { + return 0, 0, true, nil + } + s.atree.releaseDataPage(s.pageNo) + + s.pageNo = prevPageNo + s.pageData, err = s.atree.fetchDataPage(s.pageNo) + if err != nil { + return 0, 0, false, fmt.Errorf("atree.fetchDataPage(%d): %s", s.pageNo, err) + } + + err = s.makeDecompressors() + if err != nil { + return 0, 0, false, err + } + + timestamp, done = s.timestampDecompressor.NextValue() + if done { + return 0, 0, false, + fmt.Errorf("corrupted data page %d: no timestamps", + s.pageNo) + } + value, done = s.valueDecompressor.NextValue() + if done { + return 0, 0, false, + fmt.Errorf("corrupted data page %d: no values", + s.pageNo) + } + return timestamp, value, false, nil +} + +func (s *BackwardCursor) Close() { + s.atree.releaseDataPage(s.pageNo) +} + +// HELPER + +func (s *BackwardCursor) makeDecompressors() error { + timestampsPayloadSize := bin.GetUint16(s.pageData[timestampsSizeIdx:]) + valuesPayloadSize := bin.GetUint16(s.pageData[valuesSizeIdx:]) + + payloadSize := timestampsPayloadSize + valuesPayloadSize + + if payloadSize > dataFooterIdx { + return fmt.Errorf("corrupted data page %d: timestamps + values size %d gt payload size", + s.pageNo, payloadSize) + } + + s.timestampDecompressor = enc.NewReverseTimeDeltaOfDeltaDecompressor( + s.pageData[:timestampsPayloadSize], + ) + + vbuf := s.pageData[timestampsPayloadSize : timestampsPayloadSize+valuesPayloadSize] + + switch s.metricType { + case octopus.Instant: + s.valueDecompressor = enc.NewReverseInstantDeltaDecompressor( + vbuf, s.fracDigits) + + case octopus.Cumulative: + s.valueDecompressor = enc.NewReverseCumulativeDeltaDecompressor( + vbuf, s.fracDigits) + + default: + return fmt.Errorf("bug: wrong metricType %d", s.metricType) + } + return nil +} + +func makeDecompressors(pageData []byte, metricType octopus.MetricType, fracDigits byte) ( + octopus.TimestampDecompressor, octopus.ValueDecompressor, error, +) { + timestampsPayloadSize := bin.GetUint16(pageData[timestampsSizeIdx:]) + valuesPayloadSize := bin.GetUint16(pageData[valuesSizeIdx:]) + + payloadSize := timestampsPayloadSize + valuesPayloadSize + + if payloadSize > dataFooterIdx { + return nil, nil, fmt.Errorf("corrupted: timestamps + values size %d > payload size", + payloadSize) + } + + timestampDecompressor := enc.NewReverseTimeDeltaOfDeltaDecompressor( + pageData[:timestampsPayloadSize], + ) + + vbuf := pageData[timestampsPayloadSize : timestampsPayloadSize+valuesPayloadSize] + + var valueDecompressor octopus.ValueDecompressor + switch metricType { + case octopus.Instant: + valueDecompressor = enc.NewReverseInstantDeltaDecompressor( + vbuf, fracDigits) + + case octopus.Cumulative: + valueDecompressor = enc.NewReverseCumulativeDeltaDecompressor( + vbuf, fracDigits) + + default: + return nil, nil, fmt.Errorf("bug: wrong metricType %d", metricType) + } + return timestampDecompressor, valueDecompressor, nil +} diff --git a/atree/io.go b/atree/io.go new file mode 100644 index 0000000..5bb4492 --- /dev/null +++ b/atree/io.go @@ -0,0 +1,430 @@ +package atree + +import ( + "errors" + "fmt" + "hash/crc32" + "io/fs" + "math" + "os" + + octopus "gordenko.dev/dima/diploma" + "gordenko.dev/dima/diploma/atree/redo" + "gordenko.dev/dima/diploma/bin" +) + +type AllocatedPage struct { + PageNo uint32 + Data []byte + IsReused bool +} + +type readResult struct { + Data []byte + Err error +} + +// INDEX PAGES + +func (s *Atree) DeleteIndexPages(pageNumbers []uint32) { + s.mutex.Lock() + for _, pageNo := range pageNumbers { + delete(s.indexPages, pageNo) + } + s.mutex.Unlock() +} + +func (s *Atree) fetchIndexPage(pageNo uint32) ([]byte, error) { + s.mutex.Lock() + p, ok := s.indexPages[pageNo] + if ok { + p.ReferenceCount++ + s.mutex.Unlock() + return p.Buf, nil + } + + resultCh := make(chan readResult, 1) + s.indexWaits[pageNo] = append(s.indexWaits[pageNo], resultCh) + if len(s.indexWaits[pageNo]) == 1 { + s.indexPagesToRead = append(s.indexPagesToRead, pageNo) + s.mutex.Unlock() + + select { + case s.readSignalCh <- struct{}{}: + default: + } + } else { + s.mutex.Unlock() + } + + result := <-resultCh + if result.Err == nil { + result.Err = s.verifyCRC(result.Data, IndexPageSize) + } + return result.Data, result.Err +} + +func (s *Atree) releaseIndexPage(pageNo uint32) { + s.mutex.Lock() + defer s.mutex.Unlock() + + p, ok := s.indexPages[pageNo] + if ok { + if p.ReferenceCount > 0 { + p.ReferenceCount-- + return + } else { + octopus.Abort( + octopus.ReferenceCountBug, + fmt.Errorf("call releaseIndexPage on page %d with reference count = %d", + pageNo, p.ReferenceCount), + ) + } + } +} + +func (s *Atree) allocIndexPage() AllocatedPage { + var ( + allocated = AllocatedPage{ + Data: make([]byte, IndexPageSize), + } + ) + + allocated.PageNo = s.indexFreelist.ReservePage() + if allocated.PageNo > 0 { + allocated.IsReused = true + + s.mutex.Lock() + } else { + s.mutex.Lock() + if s.allocatedIndexPagesQty == math.MaxUint32 { + octopus.Abort(octopus.MaxAtreeSizeExceeded, + errors.New("no space in Atree index")) + } + s.allocatedIndexPagesQty++ + allocated.PageNo = s.allocatedIndexPagesQty + } + + s.indexPages[allocated.PageNo] = &_page{ + PageNo: allocated.PageNo, + Buf: allocated.Data, + ReferenceCount: 1, + } + s.mutex.Unlock() + return allocated +} + +// DATA PAGES + +func (s *Atree) DeleteDataPages(pageNumbers []uint32) { + s.mutex.Lock() + for _, pageNo := range pageNumbers { + delete(s.dataPages, pageNo) + } + s.mutex.Unlock() +} + +func (s *Atree) fetchDataPage(pageNo uint32) ([]byte, error) { + s.mutex.Lock() + p, ok := s.dataPages[pageNo] + if ok { + p.ReferenceCount++ + s.mutex.Unlock() + return p.Buf, nil + } + + resultCh := make(chan readResult, 1) + s.dataWaits[pageNo] = append(s.dataWaits[pageNo], resultCh) + if len(s.dataWaits[pageNo]) == 1 { + s.dataPagesToRead = append(s.dataPagesToRead, pageNo) + s.mutex.Unlock() + + select { + case s.readSignalCh <- struct{}{}: + default: + } + } else { + s.mutex.Unlock() + } + result := <-resultCh + if result.Err == nil { + result.Err = s.verifyCRC(result.Data, DataPageSize) + } + return result.Data, result.Err +} + +func (s *Atree) releaseDataPage(pageNo uint32) { + s.mutex.Lock() + defer s.mutex.Unlock() + + p, ok := s.dataPages[pageNo] + if ok { + if p.ReferenceCount > 0 { + p.ReferenceCount-- + return + } else { + octopus.Abort( + octopus.ReferenceCountBug, + fmt.Errorf("call releaseDataPage on page %d with reference count = %d", + pageNo, p.ReferenceCount), + ) + } + } +} + +func (s *Atree) allocDataPage() AllocatedPage { + var ( + allocated = AllocatedPage{ + Data: make([]byte, DataPageSize), + } + ) + + allocated.PageNo = s.dataFreelist.ReservePage() + if allocated.PageNo > 0 { + allocated.IsReused = true + s.mutex.Lock() + } else { + s.mutex.Lock() + if s.allocatedDataPagesQty == math.MaxUint32 { + octopus.Abort(octopus.MaxAtreeSizeExceeded, + errors.New("no space in Atree index")) + } + s.allocatedDataPagesQty++ + allocated.PageNo = s.allocatedDataPagesQty + } + + s.dataPages[allocated.PageNo] = &_page{ + PageNo: allocated.PageNo, + Buf: allocated.Data, + ReferenceCount: 1, + } + s.mutex.Unlock() + return allocated +} + +// READ + +func (s *Atree) pageReader() { + for { + select { + case <-s.readSignalCh: + s.readPages() + } + } +} + +func (s *Atree) readPages() { + s.mutex.Lock() + if len(s.indexPagesToRead) == 0 && len(s.dataPagesToRead) == 0 { + s.mutex.Unlock() + return + } + indexPagesToRead := s.indexPagesToRead + s.indexPagesToRead = nil + dataPagesToRead := s.dataPagesToRead + s.dataPagesToRead = nil + s.mutex.Unlock() + + for _, pageNo := range dataPagesToRead { + buf := make([]byte, DataPageSize) + off := (pageNo - 1) * DataPageSize + n, err := s.dataFile.ReadAt(buf, int64(off)) + if n != DataPageSize { + err = fmt.Errorf("read %d instead of %d", n, DataPageSize) + } + + s.mutex.Lock() + resultChannels := s.dataWaits[pageNo] + delete(s.dataWaits, pageNo) + + if err != nil { + s.mutex.Unlock() + for _, resultCh := range resultChannels { + resultCh <- readResult{ + Err: err, + } + } + } else { + s.dataPages[pageNo] = &_page{ + PageNo: pageNo, + Buf: buf, + ReferenceCount: len(resultChannels), + } + s.mutex.Unlock() + for _, resultCh := range resultChannels { + resultCh <- readResult{ + Data: buf, + } + } + } + } + + for _, pageNo := range indexPagesToRead { + buf := make([]byte, IndexPageSize) + off := (pageNo - 1) * IndexPageSize + n, err := s.indexFile.ReadAt(buf, int64(off)) + if n != IndexPageSize { + err = fmt.Errorf("read %d instead of %d", n, IndexPageSize) + } + + s.mutex.Lock() + resultChannels := s.indexWaits[pageNo] + delete(s.indexWaits, pageNo) + + if err != nil { + s.mutex.Unlock() + for _, resultCh := range resultChannels { + resultCh <- readResult{ + Err: err, + } + } + } else { + s.indexPages[pageNo] = &_page{ + PageNo: pageNo, + Buf: buf, + ReferenceCount: len(resultChannels), + } + s.mutex.Unlock() + for _, resultCh := range resultChannels { + resultCh <- readResult{ + Data: buf, + } + } + } + + } +} + +// WRITE + +func (s *Atree) pageWriter() { + for { + select { + case <-s.writeSignalCh: + err := s.writeTasks() + if err != nil { + octopus.Abort(octopus.WriteToAtreeFailed, err) + } + } + } +} + +type WriteTask struct { + WaitCh chan struct{} + DataPage redo.PageToWrite + IndexPages []redo.PageToWrite +} + +func (s *Atree) appendWriteTaskToQueue(task WriteTask) { + s.mutex.Lock() + s.writeTasksQueue = append(s.writeTasksQueue, task) + s.mutex.Unlock() + + select { + case s.writeSignalCh <- struct{}{}: + default: + } +} + +func (s *Atree) writeTasks() error { + s.mutex.Lock() + tasks := s.writeTasksQueue + s.writeTasksQueue = nil + s.mutex.Unlock() + + for _, task := range tasks { + // data page + p := task.DataPage + if len(p.Data) != DataPageSize { + return fmt.Errorf("wrong data page %d size: %d", + p.PageNo, len(p.Data)) + } + off := (p.PageNo - 1) * DataPageSize + n, err := s.dataFile.WriteAt(p.Data, int64(off)) + if err != nil { + return err + } + if n != len(p.Data) { + return fmt.Errorf("write %d instead of %d", n, len(p.Data)) + } + + // index pages + for _, p := range task.IndexPages { + if len(p.Data) != IndexPageSize { + return fmt.Errorf("wrong index page %d size: %d", + p.PageNo, len(p.Data)) + } + bin.PutUint32(p.Data[indexCRC32Idx:], crc32.ChecksumIEEE(p.Data[:indexCRC32Idx])) + + off := (p.PageNo - 1) * IndexPageSize + n, err := s.indexFile.WriteAt(p.Data, int64(off)) + if err != nil { + return err + } + if n != len(p.Data) { + return fmt.Errorf("write %d instead of %d", n, len(p.Data)) + } + } + close(task.WaitCh) + } + return nil +} + +// IO + +func isFileExist(fileName string) (bool, error) { + _, err := os.Stat(fileName) + if err != nil { + if errors.Is(err, fs.ErrNotExist) { + return false, nil + } else { + return false, err + } + } else { + return true, nil + } +} + +func openFile(fileName string, pageSize int) (_ *os.File, _ uint32, err error) { + file, err := os.OpenFile(fileName, os.O_RDWR, filePerm) + if err != nil { + return + } + fi, err := file.Stat() + if err != nil { + return + } + fileSize := fi.Size() + + if (fileSize % int64(pageSize)) > 0 { + err = fmt.Errorf("the file size %d is not a multiple of the page size %d", + fileSize, pageSize) + return + } + + allocatedPagesQty := fileSize / int64(pageSize) + if allocatedPagesQty > math.MaxUint32 { + err = fmt.Errorf("allocated pages %d is > max pages %d", + allocatedPagesQty, math.MaxUint32) + return + } + + return file, uint32(allocatedPagesQty), nil +} + +func (s *Atree) ApplyREDO(task WriteTask) { + s.appendWriteTaskToQueue(task) +} + +func (s *Atree) verifyCRC(data []byte, pageSize int) error { + var ( + pos = pageSize - 4 + calculatedCRC = crc32.ChecksumIEEE(data[:pos]) + storedCRC = bin.GetUint32(data[pos:]) + ) + if calculatedCRC != storedCRC { + return fmt.Errorf("calculatedCRC %d not equal storedCRC %d", + calculatedCRC, storedCRC) + } + return nil +} diff --git a/atree/misc.go b/atree/misc.go new file mode 100644 index 0000000..4ccb434 --- /dev/null +++ b/atree/misc.go @@ -0,0 +1,214 @@ +package atree + +import ( + "hash/crc32" + + "gordenko.dev/dima/diploma/bin" +) + +type ValueAtComparator struct { + buf []byte + timestamp uint32 +} + +func (s ValueAtComparator) CompareTo(elemIdx int) int { + var ( + pos = elemIdx * timestampSize + elem = bin.GetUint32(s.buf[pos:]) + ) + + if s.timestamp < elem { + return -1 + } else if s.timestamp > elem { + return 1 + } else { + return 0 + } +} + +func BinarySearch(qty int, keyComparator bin.KeyComparator) (elemIdx int, isFound bool) { + if qty == 0 { + return + } + a := 0 + b := qty - 1 + for { + var ( + elemIdx = (b-a)/2 + a + code = keyComparator.CompareTo(elemIdx) + ) + if code == 1 { + a = elemIdx + 1 + if a > b { + return elemIdx, false // +1 + } + } else if code == -1 { + b = elemIdx - 1 + if b < a { + if elemIdx == 0 { + return 0, false + } else { + return elemIdx - 1, false + } + } + } else { + return elemIdx, true + } + } +} + +type chunksToDataPageReq struct { + PrevPageNo uint32 + TimestampsChunks [][]byte + TimestampsSize uint16 + ValuesChunks [][]byte + ValuesSize uint16 +} + +func chunksToDataPage(buf []byte, req chunksToDataPageReq) { + bin.PutUint32(buf[prevPageIdx:], req.PrevPageNo) + bin.PutUint16(buf[timestampsSizeIdx:], req.TimestampsSize) + bin.PutUint16(buf[valuesSizeIdx:], req.ValuesSize) + + var ( + remainingSize = int(req.TimestampsSize) + pos = 0 + ) + for _, chunk := range req.TimestampsChunks { + if remainingSize >= len(chunk) { + copy(buf[pos:], chunk) + remainingSize -= len(chunk) + pos += len(chunk) + } else { + copy(buf[pos:], chunk[:remainingSize]) + break + } + } + + remainingSize = int(req.ValuesSize) + pos = int(req.TimestampsSize) + + for _, chunk := range req.ValuesChunks { + if remainingSize >= len(chunk) { + copy(buf[pos:], chunk) + remainingSize -= len(chunk) + pos += len(chunk) + } else { + copy(buf[pos:], chunk[:remainingSize]) + break + } + } + bin.PutUint32(buf[dataCRC32Idx:], crc32.ChecksumIEEE(buf[:dataCRC32Idx])) +} + +func setPrevPageNo(buf []byte, pageNo uint32) { + bin.PutUint32(buf[prevPageIdx:], pageNo) +} + +func getPrevPageNo(buf []byte) uint32 { + return bin.GetUint32(buf[prevPageIdx:]) +} + +func findPageNo(buf []byte, timestamp uint32) (pageNo uint32) { + var ( + qty = bin.GetUint16AsInt(buf[indexRecordsQtyIdx:]) + comparator = ValueAtComparator{ + buf: buf, + timestamp: timestamp, + } + ) + elemIdx, _ := BinarySearch(qty, comparator) + pos := indexFooterIdx - (elemIdx+1)*PageNoSize + return bin.GetUint32(buf[pos:]) +} + +func findPageNoIdx(buf []byte, timestamp uint32) (idx int) { + var ( + qty = bin.GetUint16AsInt(buf[indexRecordsQtyIdx:]) + comparator = ValueAtComparator{ + buf: buf, + timestamp: timestamp, + } + ) + elemIdx, _ := BinarySearch(qty, comparator) + return elemIdx +} + +func findPageNoForDeleteSince(buf []byte, since uint32) (uint32, int, int) { + var ( + qty = bin.GetUint16AsInt(buf[indexRecordsQtyIdx:]) + comparator = ValueAtComparator{ + buf: buf, + timestamp: since, + } + ) + elemIdx, _ := BinarySearch(qty, comparator) + pos := elemIdx * timestampSize + timestamp := bin.GetUint32(buf[pos:]) + + if timestamp == since { + if elemIdx == 0 { + return 0, qty, -1 + } + elemIdx-- + } + pos = indexFooterIdx - (elemIdx+1)*PageNoSize + return bin.GetUint32(buf[pos:]), qty, elemIdx +} + +func getLastPageNo(buf []byte) (pageNo uint32) { + qty := bin.GetUint16AsInt(buf[indexRecordsQtyIdx:]) + pos := indexFooterIdx - qty*PageNoSize + return bin.GetUint32(buf[pos:]) +} + +func getPageNo(buf []byte, idx int) (pageNo uint32) { + pos := indexFooterIdx - (idx+1)*PageNoSize + return bin.GetUint32(buf[pos:]) +} + +func listPageNumbers(buf []byte) (pageNumbers []uint32) { + qty := bin.GetUint16AsInt(buf[indexRecordsQtyIdx:]) + pos := indexFooterIdx - PageNoSize + for range qty { + pageNumbers = append(pageNumbers, bin.GetUint32(buf[pos:])) + pos -= PageNoSize + } + return +} + +// include since timestamp +func listPageNumbersSince(buf []byte, timestamp uint32) (pageNumbers []uint32) { + var ( + qty = bin.GetUint16AsInt(buf[indexRecordsQtyIdx:]) + comparator = ValueAtComparator{ + buf: buf, + timestamp: timestamp, + } + ) + elemIdx, _ := BinarySearch(qty, comparator) + pos := indexFooterIdx - (elemIdx+1)*PageNoSize + for range qty { + pageNumbers = append(pageNumbers, bin.GetUint32(buf[pos:])) + pos -= PageNoSize + } + return +} + +func getSince(buf []byte) uint32 { + return bin.GetUint32(buf[0:]) +} + +func appendPair(buf []byte, timestamp uint32, pageNo uint32) bool { + qty := bin.GetUint16AsInt(buf[indexRecordsQtyIdx:]) + free := indexFooterIdx - qty*pairSize + if free < pairSize { + return false + } + pos := qty * timestampSize + bin.PutUint32(buf[pos:], timestamp) + pos = indexFooterIdx - (qty+1)*PageNoSize + bin.PutUint32(buf[pos:], pageNo) + bin.PutIntAsUint16(buf[indexRecordsQtyIdx:], qty+1) + return true +} diff --git a/atree/redo/reader.go b/atree/redo/reader.go new file mode 100644 index 0000000..c114937 --- /dev/null +++ b/atree/redo/reader.go @@ -0,0 +1,96 @@ +package redo + +import ( + "fmt" + "hash/crc32" + "io" + "os" + + "gordenko.dev/dima/diploma/bin" +) + +type REDOFile struct { + MetricID uint32 + Timestamp uint32 + Value float64 + IsDataPageReused bool + DataPage PageToWrite + IsRootChanged bool + RootPageNo uint32 + ReusedIndexPages []uint32 + IndexPages []PageToWrite +} + +type ReadREDOFileReq struct { + FileName string + DataPageSize int + IndexPageSize int +} + +func ReadREDOFile(req ReadREDOFileReq) (*REDOFile, error) { + buf, err := os.ReadFile(req.FileName) + if err != nil { + return nil, err + } + + if len(buf) < 25 { + return nil, io.EOF + } + + var ( + end = len(buf) - 4 + payload = buf[:end] + checksum = bin.GetUint32(buf[end:]) + calculatedChecksum = crc32.ChecksumIEEE(payload) + ) + + // Помилка чексуми означає що файл або недописаний, або пошкодженний + if checksum != calculatedChecksum { + return nil, fmt.Errorf("written checksum %d not equal calculated checksum %d", + checksum, calculatedChecksum) + } + + var ( + redoLog = REDOFile{ + MetricID: bin.GetUint32(buf[0:]), + Timestamp: bin.GetUint32(buf[4:]), + Value: bin.GetFloat64(buf[8:]), + IsDataPageReused: buf[16] == 1, + DataPage: PageToWrite{ + PageNo: bin.GetUint32(buf[17:]), + Data: buf[21 : 21+req.DataPageSize], + }, + } + pos = 21 + req.DataPageSize + ) + + for { + if pos == len(payload) { + return &redoLog, nil + } + + if pos > len(payload) { + return nil, io.EOF + } + + flags := buf[pos] + + item := PageToWrite{ + PageNo: bin.GetUint32(buf[pos+1:]), + } + pos += 5 // flags + pageNo + item.Data = buf[pos : pos+req.IndexPageSize] + pos += req.IndexPageSize + + redoLog.IndexPages = append(redoLog.IndexPages, item) + + if (flags & FlagReused) == FlagReused { + redoLog.ReusedIndexPages = append(redoLog.ReusedIndexPages, item.PageNo) + } + + if (flags & FlagNewRoot) == FlagNewRoot { + redoLog.IsRootChanged = true + redoLog.RootPageNo = item.PageNo + } + } +} diff --git a/atree/redo/writer.go b/atree/redo/writer.go new file mode 100644 index 0000000..1515bc9 --- /dev/null +++ b/atree/redo/writer.go @@ -0,0 +1,207 @@ +package redo + +import ( + "errors" + "fmt" + "hash" + "hash/crc32" + "os" + "path/filepath" + + "gordenko.dev/dima/diploma/bin" +) + +const ( + FlagReused byte = 1 // сторінка із FreeList + FlagNewRoot byte = 2 // новая страница +) + +type PageToWrite struct { + PageNo uint32 + Data []byte +} + +type Writer struct { + metricID uint32 + timestamp uint32 + value float64 + tmp []byte + fileName string + file *os.File + hasher hash.Hash32 + isDataPageReused bool + dataPageNo uint32 + isRootChanged bool + newRootPageNo uint32 + indexPages []uint32 + reusedIndexPages []uint32 + indexPagesToWrite []PageToWrite +} + +type WriterOptions struct { + Dir string + MetricID uint32 + Value float64 + Timestamp uint32 + IsDataPageReused bool + DataPageNo uint32 + Page []byte +} + +// dataPage можно записати 1 раз. Щоб не заплутувати інтерфейс - передаю data сторінку +// через Options. Index сторінок може бути від 1 до N, тому виділяю окремий метод +func NewWriter(opt WriterOptions) (*Writer, error) { + if opt.Dir == "" { + return nil, errors.New("Dir option is required") + } + if opt.MetricID == 0 { + return nil, errors.New("MetricID option is required") + } + if opt.DataPageNo == 0 { + return nil, errors.New("DataPageNo option is required") + } + // if len(opt.Page) != octopus.DataPageSize { + // return nil, fmt.Errorf("bug: wrong data page size %d", len(opt.Page)) + // } + + s := &Writer{ + fileName: JoinREDOFileName(opt.Dir, opt.MetricID), + metricID: opt.MetricID, + timestamp: opt.Timestamp, + value: opt.Value, + tmp: make([]byte, 21), + isDataPageReused: opt.IsDataPageReused, + dataPageNo: opt.DataPageNo, + hasher: crc32.NewIEEE(), + } + + var err error + s.file, err = os.OpenFile(s.fileName, os.O_CREATE|os.O_WRONLY, 0770) + if err != nil { + return nil, err + } + + err = s.init(opt.Page) + if err != nil { + return nil, err + } + return s, nil +} + +/* +Формат: +4b metricID +8b value +4b timestamp +1b flags (reused) +4b dataPageNo +8KB dataPage +*/ +func (s *Writer) init(dataPage []byte) error { + bin.PutUint32(s.tmp[0:], s.metricID) + bin.PutUint32(s.tmp[4:], s.timestamp) + bin.PutFloat64(s.tmp[8:], s.value) + if s.isDataPageReused { + s.tmp[16] = 1 + } + bin.PutUint32(s.tmp[17:], s.dataPageNo) + + _, err := s.file.Write(s.tmp) + if err != nil { + return err + } + + _, err = s.file.Write(dataPage) + if err != nil { + return err + } + + s.hasher.Write(s.tmp) + s.hasher.Write(dataPage) + return nil +} + +/* +Формат +1b index page flags +4b indexPageNo +Nb indexPage +*/ +func (s *Writer) AppendIndexPage(indexPageNo uint32, indexPage []byte, flags byte) error { + s.tmp[0] = flags + bin.PutUint32(s.tmp[1:], indexPageNo) + _, err := s.file.Write(s.tmp[:5]) + if err != nil { + return err + } + _, err = s.file.Write(indexPage) + if err != nil { + return err + } + + s.hasher.Write(s.tmp[:5]) + s.hasher.Write(indexPage) + + s.indexPages = append(s.indexPages, indexPageNo) + + if (flags & FlagReused) == FlagReused { + s.reusedIndexPages = append(s.reusedIndexPages, indexPageNo) + } + + if (flags & FlagNewRoot) == FlagNewRoot { + s.newRootPageNo = indexPageNo + s.isRootChanged = true + } + + s.indexPagesToWrite = append(s.indexPagesToWrite, + PageToWrite{ + PageNo: indexPageNo, + Data: indexPage, + }) + return nil +} + +func (s *Writer) IndexPagesToWrite() []PageToWrite { + return s.indexPagesToWrite +} + +func (s *Writer) Close() (err error) { + // финализирую запись + bin.PutUint32(s.tmp, s.hasher.Sum32()) + _, err = s.file.Write(s.tmp[:4]) + if err != nil { + return err + } + err = s.file.Sync() + if err != nil { + return + } + return s.file.Close() +} + +type Report struct { + FileName string + IsDataPageReused bool + DataPageNo uint32 + IsRootChanged bool + NewRootPageNo uint32 + ReusedIndexPages []uint32 +} + +func (s *Writer) GetReport() Report { + return Report{ + FileName: s.fileName, + IsDataPageReused: s.isDataPageReused, + DataPageNo: s.dataPageNo, + //IndexPages: s.indexPages, + IsRootChanged: s.isRootChanged, + NewRootPageNo: s.newRootPageNo, + ReusedIndexPages: s.reusedIndexPages, + } +} + +// HELPERS + +func JoinREDOFileName(dir string, metricID uint32) string { + return filepath.Join(dir, fmt.Sprintf("m%d.redo", metricID)) +} diff --git a/atree/select.go b/atree/select.go new file mode 100644 index 0000000..ef002bc --- /dev/null +++ b/atree/select.go @@ -0,0 +1,619 @@ +package atree + +import ( + "fmt" + + octopus "gordenko.dev/dima/diploma" +) + +type IterateAllCumulativeByTreeCursorReq struct { + FracDigits byte + PageNo uint32 + EndTimestamp uint32 + EndValue float64 + ResponseWriter *CumulativeMeasureWriter +} + +func (s *Atree) IterateAllCumulativeByTreeCursor(req IterateAllCumulativeByTreeCursorReq) error { + buf, err := s.fetchDataPage(req.PageNo) + if err != nil { + return err + } + + treeCursor, err := NewBackwardCursor(BackwardCursorOptions{ + PageNo: req.PageNo, + PageData: buf, + Atree: s, + FracDigits: req.FracDigits, + MetricType: octopus.Cumulative, + }) + if err != nil { + return err + } + defer treeCursor.Close() + + var ( + endTimestamp = req.EndTimestamp + endValue = req.EndValue + ) + + for { + timestamp, value, done, err := treeCursor.Prev() + if err != nil { + return err + } + + if done { + err := req.ResponseWriter.WriteMeasure(CumulativeMeasure{ + Timestamp: endTimestamp, + Value: endValue, + Total: endValue, + }) + if err != nil { + return err + } + return nil + } + err = req.ResponseWriter.WriteMeasure(CumulativeMeasure{ + Timestamp: endTimestamp, + Value: endValue, + Total: endValue - value, + }) + if err != nil { + return err + } + endTimestamp = timestamp + endValue = value + } +} + +type ContinueIterateCumulativeByTreeCursorReq struct { + FracDigits byte + Since uint32 + Until uint32 + LastPageNo uint32 + EndTimestamp uint32 + EndValue float64 + ResponseWriter *CumulativeMeasureWriter +} + +func (s *Atree) ContinueIterateCumulativeByTreeCursor(req ContinueIterateCumulativeByTreeCursorReq) error { + buf, err := s.fetchDataPage(req.LastPageNo) + if err != nil { + return fmt.Errorf("fetchDataPage(%d): %s", req.LastPageNo, err) + } + + treeCursor, err := NewBackwardCursor(BackwardCursorOptions{ + PageNo: req.LastPageNo, + PageData: buf, + Atree: s, + FracDigits: req.FracDigits, + MetricType: octopus.Cumulative, + }) + if err != nil { + return err + } + defer treeCursor.Close() + + var ( + endTimestamp = req.EndTimestamp + endValue = req.EndValue + ) + + for { + timestamp, value, done, err := treeCursor.Prev() + if err != nil { + return err + } + + if done { + err := req.ResponseWriter.WriteMeasure(CumulativeMeasure{ + Timestamp: endTimestamp, + Value: endValue, + Total: endValue, + }) + if err != nil { + return err + } + return nil + } + + if timestamp <= req.Until { + err := req.ResponseWriter.WriteMeasure(CumulativeMeasure{ + Timestamp: endTimestamp, + Value: endValue, + Total: endValue - value, + }) + if err != nil { + return err + } + if timestamp < req.Since { + return nil + } + } else { + // bug panic + panic("continue cumulative but timestamp > req.Until") + } + } +} + +type FindAndIterateCumulativeByTreeCursorReq struct { + FracDigits byte + Since uint32 + Until uint32 + RootPageNo uint32 + ResponseWriter *CumulativeMeasureWriter +} + +func (s *Atree) FindAndIterateCumulativeByTreeCursor(req FindAndIterateCumulativeByTreeCursorReq) error { + pageNo, buf, err := s.findDataPage(req.RootPageNo, req.Until) + if err != nil { + return err + } + + treeCursor, err := NewBackwardCursor(BackwardCursorOptions{ + PageNo: pageNo, + PageData: buf, + Atree: s, + FracDigits: req.FracDigits, + MetricType: octopus.Cumulative, + }) + if err != nil { + return err + } + defer treeCursor.Close() + + var ( + endTimestamp uint32 + endValue float64 + ) + + for { + timestamp, value, done, err := treeCursor.Prev() + if err != nil { + return err + } + + if done { + if endTimestamp > 0 { + err := req.ResponseWriter.WriteMeasure(CumulativeMeasure{ + Timestamp: endTimestamp, + Value: endValue, + Total: endValue, + }) + if err != nil { + return err + } + } + return nil + } + + if timestamp > req.Until { + continue + } + + if endTimestamp > 0 { + err := req.ResponseWriter.WriteMeasure(CumulativeMeasure{ + Timestamp: endTimestamp, + Value: endValue, + Total: endValue - value, + }) + if err != nil { + return err + } + } + endTimestamp = timestamp + endValue = value + + if timestamp < req.Since { + return nil + } + } +} + +type IterateAllInstantByTreeCursorReq struct { + FracDigits byte + PageNo uint32 + ResponseWriter *InstantMeasureWriter +} + +func (s *Atree) IterateAllInstantByTreeCursor(req IterateAllInstantByTreeCursorReq) error { + buf, err := s.fetchDataPage(req.PageNo) + if err != nil { + return err + } + + treeCursor, err := NewBackwardCursor(BackwardCursorOptions{ + PageNo: req.PageNo, + PageData: buf, + Atree: s, + FracDigits: req.FracDigits, + MetricType: octopus.Instant, + }) + if err != nil { + return err + } + defer treeCursor.Close() + + for { + timestamp, value, done, err := treeCursor.Prev() + if err != nil { + return err + } + + if done { + return nil + } + + err = req.ResponseWriter.WriteMeasure(InstantMeasure{ + Timestamp: timestamp, + Value: value, + }) + if err != nil { + return err + } + } +} + +type ContinueIterateInstantByTreeCursorReq struct { + FracDigits byte + Since uint32 + Until uint32 + LastPageNo uint32 + ResponseWriter *InstantMeasureWriter +} + +func (s *Atree) ContinueIterateInstantByTreeCursor(req ContinueIterateInstantByTreeCursorReq) error { + buf, err := s.fetchDataPage(req.LastPageNo) + if err != nil { + return fmt.Errorf("fetchDataPage(%d): %s", req.LastPageNo, err) + } + + treeCursor, err := NewBackwardCursor(BackwardCursorOptions{ + PageNo: req.LastPageNo, + PageData: buf, + Atree: s, + FracDigits: req.FracDigits, + MetricType: octopus.Instant, + }) + if err != nil { + return err + } + defer treeCursor.Close() + + for { + timestamp, value, done, err := treeCursor.Prev() + if err != nil { + return err + } + + if done { + // - записи закончились; + return nil + } + + if timestamp > req.Until { + panic("continue instant timestamp > req.Until") + } + + if timestamp < req.Since { + return nil + } + + err = req.ResponseWriter.WriteMeasure(InstantMeasure{ + Timestamp: timestamp, + Value: value, + }) + if err != nil { + return err + } + } +} + +type FindAndIterateInstantByTreeCursorReq struct { + FracDigits byte + Since uint32 + Until uint32 + RootPageNo uint32 + ResponseWriter *InstantMeasureWriter +} + +func (s *Atree) FindAndIterateInstantByTreeCursor(req FindAndIterateInstantByTreeCursorReq) error { + pageNo, buf, err := s.findDataPage(req.RootPageNo, req.Until) + if err != nil { + return err + } + + treeCursor, err := NewBackwardCursor(BackwardCursorOptions{ + PageNo: pageNo, + PageData: buf, + Atree: s, + FracDigits: req.FracDigits, + MetricType: octopus.Instant, + }) + if err != nil { + return err + } + defer treeCursor.Close() + + for { + timestamp, value, done, err := treeCursor.Prev() + if err != nil { + return err + } + + if done { + return nil + } + + if timestamp > req.Until { + continue + } + + if timestamp < req.Since { + return nil + } + + err = req.ResponseWriter.WriteMeasure(InstantMeasure{ + Timestamp: timestamp, + Value: value, + }) + if err != nil { + return err + } + } +} + +type ContinueCollectInstantPeriodsReq struct { + FracDigits byte + Aggregator *InstantAggregator + ResponseWriter *InstantPeriodsWriter + LastPageNo uint32 + Since uint32 + Until uint32 +} + +func (s *Atree) ContinueCollectInstantPeriods(req ContinueCollectInstantPeriodsReq) error { + buf, err := s.fetchDataPage(req.LastPageNo) + if err != nil { + return fmt.Errorf("fetchDataPage(%d): %s", req.LastPageNo, err) + } + + treeCursor, err := NewBackwardCursor(BackwardCursorOptions{ + PageNo: req.LastPageNo, + PageData: buf, + Atree: s, + FracDigits: req.FracDigits, + MetricType: octopus.Instant, + }) + if err != nil { + return err + } + defer treeCursor.Close() + + var period InstantPeriod + + for { + timestamp, value, done, err := treeCursor.Prev() + if err != nil { + return err + } + + if done || timestamp < req.Since { + isCompleted := req.Aggregator.FillPeriod(timestamp, &period) + if isCompleted { + err := req.ResponseWriter.WritePeriod(period) + if err != nil { + return err + } + } + return nil + } + + if timestamp <= req.Until { + isCompleted := req.Aggregator.Feed(timestamp, value, &period) + if isCompleted { + err := req.ResponseWriter.WritePeriod(period) + if err != nil { + return err + } + } + } + } +} + +type FindInstantPeriodsReq struct { + FracDigits byte + ResponseWriter *InstantPeriodsWriter + RootPageNo uint32 + Since uint32 + Until uint32 + GroupBy octopus.GroupBy + FirstHourOfDay int + LastDayOfMonth int +} + +func (s *Atree) FindInstantPeriods(req FindInstantPeriodsReq) error { + pageNo, buf, err := s.findDataPage(req.RootPageNo, req.Until) + if err != nil { + return err + } + + aggregator, err := NewInstantAggregator(InstantAggregatorOptions{ + GroupBy: req.GroupBy, + FirstHourOfDay: req.FirstHourOfDay, + LastDayOfMonth: req.LastDayOfMonth, + }) + if err != nil { + return err + } + + cursor, err := NewBackwardCursor(BackwardCursorOptions{ + PageNo: pageNo, + PageData: buf, + Atree: s, + FracDigits: req.FracDigits, + MetricType: octopus.Instant, + }) + if err != nil { + return err + } + defer cursor.Close() + + var period InstantPeriod + + for { + timestamp, value, done, err := cursor.Prev() + if err != nil { + return err + } + + if done || timestamp < req.Since { + isCompleted := aggregator.FillPeriod(timestamp, &period) + if isCompleted { + err := req.ResponseWriter.WritePeriod(period) + if err != nil { + return err + } + } + return nil + } + + if timestamp <= req.Until { + isCompleted := aggregator.Feed(timestamp, value, &period) + if isCompleted { + err := req.ResponseWriter.WritePeriod(period) + if err != nil { + return err + } + } + } + } +} + +type FindCumulativePeriodsReq struct { + FracDigits byte + ResponseWriter *CumulativePeriodsWriter + RootPageNo uint32 + Since uint32 + Until uint32 + GroupBy octopus.GroupBy + FirstHourOfDay int + LastDayOfMonth int +} + +func (s *Atree) FindCumulativePeriods(req FindCumulativePeriodsReq) error { + pageNo, buf, err := s.findDataPage(req.RootPageNo, req.Until) + if err != nil { + return err + } + + aggregator, err := NewCumulativeAggregator(CumulativeAggregatorOptions{ + GroupBy: req.GroupBy, + FirstHourOfDay: req.FirstHourOfDay, + LastDayOfMonth: req.LastDayOfMonth, + }) + if err != nil { + return err + } + + cursor, err := NewBackwardCursor(BackwardCursorOptions{ + PageNo: pageNo, + PageData: buf, + Atree: s, + FracDigits: req.FracDigits, + MetricType: octopus.Cumulative, + }) + if err != nil { + return err + } + defer cursor.Close() + + var period CumulativePeriod + + for { + timestamp, value, done, err := cursor.Prev() + if err != nil { + return err + } + + if done || timestamp < req.Since { + isCompleted := aggregator.FillPeriod(timestamp, value, &period) + if isCompleted { + err := req.ResponseWriter.WritePeriod(period) + if err != nil { + return err + } + } + return nil + } + + if timestamp <= req.Until { + isCompleted := aggregator.Feed(timestamp, value, &period) + if isCompleted { + err := req.ResponseWriter.WritePeriod(period) + if err != nil { + return err + } + } + } + } +} + +type ContinueCollectCumulativePeriodsReq struct { + FracDigits byte + Aggregator *CumulativeAggregator + ResponseWriter *CumulativePeriodsWriter + LastPageNo uint32 + Since uint32 + Until uint32 +} + +func (s *Atree) ContinueCollectCumulativePeriods(req ContinueCollectCumulativePeriodsReq) error { + buf, err := s.fetchDataPage(req.LastPageNo) + if err != nil { + return fmt.Errorf("fetchDataPage(%d): %s", req.LastPageNo, err) + } + + treeCursor, err := NewBackwardCursor(BackwardCursorOptions{ + PageNo: req.LastPageNo, + PageData: buf, + Atree: s, + FracDigits: req.FracDigits, + MetricType: octopus.Cumulative, + }) + if err != nil { + return err + } + defer treeCursor.Close() + + var period CumulativePeriod + + for { + timestamp, value, done, err := treeCursor.Prev() + if err != nil { + return err + } + + if done || timestamp < req.Since { + isCompleted := req.Aggregator.FillPeriod(timestamp, value, &period) + if isCompleted { + err := req.ResponseWriter.WritePeriod(period) + if err != nil { + return err + } + } + return nil + } + + if timestamp <= req.Until { + isCompleted := req.Aggregator.Feed(timestamp, value, &period) + if isCompleted { + err := req.ResponseWriter.WritePeriod(period) + if err != nil { + return err + } + } + } + } +} diff --git a/atree/writers.go b/atree/writers.go new file mode 100644 index 0000000..06b59ae --- /dev/null +++ b/atree/writers.go @@ -0,0 +1,306 @@ +package atree + +import ( + "bytes" + "fmt" + "io" + + octopus "gordenko.dev/dima/diploma" + "gordenko.dev/dima/diploma/bin" + "gordenko.dev/dima/diploma/proto" +) + +// CURRENT VALUE WRITER + +type CurrentValue struct { + MetricID uint32 + Timestamp uint32 + Value float64 +} + +type CurrentValueWriter struct { + arr []byte + responder *ChunkedResponder +} + +func NewCurrentValueWriter(dst io.Writer) *CurrentValueWriter { + return &CurrentValueWriter{ + arr: make([]byte, 16), + responder: NewChunkedResponder(dst), + } +} + +func (s *CurrentValueWriter) BufferValue(m CurrentValue) { + bin.PutUint32(s.arr[0:], m.MetricID) + bin.PutUint32(s.arr[4:], m.Timestamp) + bin.PutFloat64(s.arr[8:], m.Value) + s.responder.BufferRecord(s.arr) +} + +func (s *CurrentValueWriter) Close() error { + return s.responder.Flush() +} + +// INSTANT MEASURE WRITER + +type InstantMeasure struct { + Timestamp uint32 + Value float64 +} + +type InstantMeasureWriter struct { + arr []byte + responder *ChunkedResponder +} + +func NewInstantMeasureWriter(dst io.Writer) *InstantMeasureWriter { + return &InstantMeasureWriter{ + arr: make([]byte, 12), + responder: NewChunkedResponder(dst), + } +} + +func (s *InstantMeasureWriter) BufferMeasure(m InstantMeasure) { + bin.PutUint32(s.arr[0:], m.Timestamp) + bin.PutFloat64(s.arr[4:], m.Value) + s.responder.BufferRecord(s.arr) +} + +func (s *InstantMeasureWriter) WriteMeasure(m InstantMeasure) error { + bin.PutUint32(s.arr[0:], m.Timestamp) + bin.PutFloat64(s.arr[4:], m.Value) + return s.responder.AppendRecord(s.arr) +} + +func (s *InstantMeasureWriter) Close() error { + return s.responder.Flush() +} + +// CUMULATIVE MEASURE WRITER + +type CumulativeMeasure struct { + Timestamp uint32 + Value float64 + Total float64 +} + +type CumulativeMeasureWriter struct { + arr []byte + responder *ChunkedResponder +} + +func NewCumulativeMeasureWriter(dst io.Writer) *CumulativeMeasureWriter { + return &CumulativeMeasureWriter{ + arr: make([]byte, 20), + responder: NewChunkedResponder(dst), + } +} + +func (s *CumulativeMeasureWriter) BufferMeasure(m CumulativeMeasure) { + bin.PutUint32(s.arr[0:], m.Timestamp) + bin.PutFloat64(s.arr[4:], m.Value) + bin.PutFloat64(s.arr[12:], m.Total) + s.responder.BufferRecord(s.arr) +} + +func (s *CumulativeMeasureWriter) WriteMeasure(m CumulativeMeasure) error { + bin.PutUint32(s.arr[0:], m.Timestamp) + bin.PutFloat64(s.arr[4:], m.Value) + bin.PutFloat64(s.arr[12:], m.Total) + return s.responder.AppendRecord(s.arr) +} + +func (s *CumulativeMeasureWriter) Close() error { + return s.responder.Flush() +} + +// INSTANT AGGREGATE WRITER + +type InstantPeriodsWriter struct { + aggregateFuncs byte + arr []byte + responder *ChunkedResponder +} + +func NewInstantPeriodsWriter(dst io.Writer, aggregateFuncs byte) *InstantPeriodsWriter { + var q int + if (aggregateFuncs & octopus.AggregateMin) == octopus.AggregateMin { + q++ + } + if (aggregateFuncs & octopus.AggregateMax) == octopus.AggregateMax { + q++ + } + if (aggregateFuncs & octopus.AggregateAvg) == octopus.AggregateAvg { + q++ + } + return &InstantPeriodsWriter{ + aggregateFuncs: aggregateFuncs, + arr: make([]byte, 12+q*8), + responder: NewChunkedResponder(dst), + } +} + +type InstantPeriod struct { + Period uint32 + Since uint32 + Until uint32 + Min float64 + Max float64 + Avg float64 +} + +func (s *InstantPeriodsWriter) BufferMeasure(p InstantPeriod) { + s.pack(p) + s.responder.BufferRecord(s.arr) +} + +func (s *InstantPeriodsWriter) WritePeriod(p InstantPeriod) error { + s.pack(p) + return s.responder.AppendRecord(s.arr) +} + +func (s *InstantPeriodsWriter) Close() error { + return s.responder.Flush() +} + +func (s *InstantPeriodsWriter) pack(p InstantPeriod) { + bin.PutUint32(s.arr[0:], p.Period) + bin.PutUint32(s.arr[4:], p.Since) + bin.PutUint32(s.arr[8:], p.Until) + + pos := 12 + if (s.aggregateFuncs & octopus.AggregateMin) == octopus.AggregateMin { + bin.PutFloat64(s.arr[pos:], p.Min) + pos += 8 + } + if (s.aggregateFuncs & octopus.AggregateMax) == octopus.AggregateMax { + bin.PutFloat64(s.arr[pos:], p.Max) + pos += 8 + } + if (s.aggregateFuncs & octopus.AggregateAvg) == octopus.AggregateAvg { + bin.PutFloat64(s.arr[pos:], p.Avg) + } +} + +// CUMULATIVE AGGREGATE WRITER + +type CumulativePeriodsWriter struct { + arr []byte + responder *ChunkedResponder +} + +func NewCumulativePeriodsWriter(dst io.Writer) *CumulativePeriodsWriter { + return &CumulativePeriodsWriter{ + arr: make([]byte, 28), + responder: NewChunkedResponder(dst), + } +} + +type CumulativePeriod struct { + Period uint32 + Since uint32 + Until uint32 + EndValue float64 + Total float64 +} + +func (s *CumulativePeriodsWriter) BufferMeasure(p CumulativePeriod) { + s.pack(p) + s.responder.BufferRecord(s.arr) +} + +func (s *CumulativePeriodsWriter) WritePeriod(p CumulativePeriod) error { + s.pack(p) + return s.responder.AppendRecord(s.arr) +} + +func (s *CumulativePeriodsWriter) Close() error { + return s.responder.Flush() +} + +func (s *CumulativePeriodsWriter) pack(p CumulativePeriod) { + bin.PutUint32(s.arr[0:], p.Period) + bin.PutUint32(s.arr[4:], p.Since) + bin.PutUint32(s.arr[8:], p.Until) + bin.PutFloat64(s.arr[12:], p.EndValue) + bin.PutFloat64(s.arr[20:], p.Total) +} + +// CHUNKED RESPONDER + +//const headerSize = 3 + +var endMsg = []byte{ + proto.RespEndOfValue, // end of stream +} + +type ChunkedResponder struct { + recordsQty int + buf *bytes.Buffer + dst io.Writer +} + +func NewChunkedResponder(dst io.Writer) *ChunkedResponder { + s := &ChunkedResponder{ + recordsQty: 0, + buf: bytes.NewBuffer(nil), + dst: dst, + } + + s.buf.Write([]byte{ + proto.RespPartOfValue, // message type + 0, 0, 0, 0, // records qty + }) + return s +} + +func (s *ChunkedResponder) BufferRecord(rec []byte) { + s.buf.Write(rec) + s.recordsQty++ +} + +func (s *ChunkedResponder) AppendRecord(rec []byte) error { + s.buf.Write(rec) + s.recordsQty++ + + if s.buf.Len() < 1500 { + return nil + } + + if err := s.sendBuffered(); err != nil { + return err + } + + s.buf.Write([]byte{ + proto.RespPartOfValue, // message type + 0, 0, 0, 0, // records qty + }) + s.recordsQty = 0 + return nil +} + +func (s *ChunkedResponder) Flush() error { + if s.recordsQty > 0 { + if err := s.sendBuffered(); err != nil { + return err + } + } + if _, err := s.dst.Write(endMsg); err != nil { + return err + } + return nil +} + +func (s *ChunkedResponder) sendBuffered() (err error) { + msg := s.buf.Bytes() + bin.PutUint32(msg[1:], uint32(s.recordsQty)) + n, err := s.dst.Write(msg) + if err != nil { + return + } + if n != len(msg) { + return fmt.Errorf("incomplete write %d bytes instead of %d", n, len(msg)) + } + s.buf.Reset() + return +} diff --git a/bin/bin.go b/bin/bin.go new file mode 100644 index 0000000..1d14836 --- /dev/null +++ b/bin/bin.go @@ -0,0 +1,621 @@ +package bin + +import ( + "errors" + "fmt" + "io" + "math" +) + +const ( + varInt64SignFlag = 0b01000000 + maxReadAttempts = 5 +) + +var ( + ErrNoSpace = errors.New("no space") + ErrIncompleteWrite = errors.New("incomplete write") + + ErrReadOverflow = errors.New("bin: reader returned 'n' > bufsize") + // ErrNegativeReadCount shows 100% bug in the source reader + ErrNegativeReadCount = errors.New("bin: reader returned negative 'n'") +) + +// READ + +func ReadUint16(src io.Reader) (num uint16, err error) { + var ( + q = 2 + arr = make([]byte, q) + ) + n, err := src.Read(arr) + if err != nil { + return + } + if n != q { + return 0, fmt.Errorf("read %d bytes only", n) + } + return GetUint16(arr), nil +} + +func ReadUint24AsInt(src io.Reader) (num int, err error) { + var ( + q = 3 + arr = make([]byte, q) + ) + n, err := src.Read(arr) + if err != nil { + return + } + if n != q { + return 0, fmt.Errorf("read %d bytes only", n) + } + return GetUint24AsInt(arr), nil +} + +func ReadUint32(src io.Reader) (num uint32, err error) { + var ( + q = 4 + arr = make([]byte, q) + ) + n, err := src.Read(arr) + if err != nil { + return + } + if n != q { + return 0, fmt.Errorf("read %d bytes only", n) + } + return GetUint32(arr), nil +} + +func ReadUint64(src io.Reader) (num uint64, err error) { + var ( + q = 8 + arr = make([]byte, q) + ) + n, err := src.Read(arr) + if err != nil { + return + } + if n != q { + return 0, fmt.Errorf("read %d bytes only", n) + } + return GetUint64(arr), nil +} + +func ReadFloat64(src io.Reader) (num float64, err error) { + var ( + q = 8 + arr = make([]byte, q) + ) + n, err := src.Read(arr) + if err != nil { + return + } + if n != q { + return 0, fmt.Errorf("read %d bytes only", n) + } + return GetFloat64(arr), nil +} + +func ReadUnixtime(src io.Reader) (num int64, err error) { + var ( + q = 8 + arr = make([]byte, q) + ) + n, err := src.Read(arr) + if err != nil { + return + } + if n != q { + return 0, fmt.Errorf("read %d bytes only", n) + } + return int64(GetUint64(arr)), nil +} + +// READ VAR + +func ReadVarUint64(src io.Reader) (num uint64, n int, err error) { + var ( + p = make([]byte, 1) + b byte + ) + for i := range 8 { + _, err = src.Read(p) + if err != nil { + return + } + n++ + b = p[0] + if b >= 128 { + num |= uint64(b&127) << uint(i*7) + return + } + num |= uint64(b) << uint(i*7) + } + _, err = src.Read(p) + if err != nil { + return + } + n++ + num |= uint64(p[0]) << 56 + return +} + +// GET + +func GetUint16(arr []byte) uint16 { + return uint16(arr[0]) | (uint16(arr[1]) << 8) +} + +func GetUint16AsInt(arr []byte) int { + return int(arr[0]) | (int(arr[1]) << 8) +} + +func GetUint24AsInt(arr []byte) int { + return int(arr[0]) | (int(arr[1]) << 8) | (int(arr[2]) << 16) +} + +func GetUint32(arr []byte) uint32 { + return uint32(arr[0]) | (uint32(arr[1]) << 8) | + (uint32(arr[2]) << 16) | (uint32(arr[3]) << 24) +} + +func GetUint32AsInt64(arr []byte) int64 { + u32 := uint32(arr[0]) | (uint32(arr[1]) << 8) | + (uint32(arr[2]) << 16) | (uint32(arr[3]) << 24) + return int64(u32) +} + +func GetUint40(arr []byte) uint64 { + return uint64(arr[0]) | (uint64(arr[1]) << 8) | + (uint64(arr[2]) << 16) | (uint64(arr[3]) << 24) | + (uint64(arr[4]) << 32) +} + +func GetUint48(arr []byte) uint64 { + return uint64(arr[0]) | (uint64(arr[1]) << 8) | + (uint64(arr[2]) << 16) | (uint64(arr[3]) << 24) | + (uint64(arr[4]) << 32) | (uint64(arr[5]) << 40) +} + +func GetUint64(arr []byte) uint64 { + return uint64(arr[0]) | (uint64(arr[1]) << 8) | + (uint64(arr[2]) << 16) | (uint64(arr[3]) << 24) | + (uint64(arr[4]) << 32) | (uint64(arr[5]) << 40) | + (uint64(arr[6]) << 48) | (uint64(arr[7]) << 56) +} + +func GetFloat32(arr []byte) float32 { + return math.Float32frombits(GetUint32(arr)) +} + +func GetFloat64(arr []byte) float64 { + return math.Float64frombits(GetUint64(arr)) +} + +func GetUnixtime(arr []byte) int64 { + u32 := uint32(arr[0]) | (uint32(arr[1]) << 8) | + (uint32(arr[2]) << 16) | (uint32(arr[3]) << 24) + return int64(u32) +} + +func GetVarUint64(arr []byte) (num uint64, n int, err error) { + var b byte + for i := range 8 { + if i >= len(arr) { + return 0, 0, io.EOF + } + b = arr[i] + if b >= 128 { + num |= uint64(b&127) << uint(i*7) + return num, i + 1, nil + } + num |= uint64(b) << uint(i*7) + } + if len(arr) < 9 { + return 0, 0, io.EOF + } + return num | uint64(arr[8])<<56, 9, nil +} + +func ReverseGetVarUint64(arr []byte) (num uint64, n int, err error) { + var ( + b byte + j = len(arr) - 1 + ) + for i := range 8 { + if j < 0 { + return 0, 0, io.EOF + } + b = arr[j] + if b >= 128 { + num |= uint64(b&127) << uint(i*7) + return num, i + 1, nil + } + num |= uint64(b) << uint(i*7) + j-- + } + if j < 0 { + return 0, 0, io.EOF + } + return num | uint64(arr[j])<<56, 9, nil +} + +func GetVarInt64(arr []byte) (num int64, n int, err error) { + u64, n, err := GetVarUint64(arr) + if err != nil { + return + } + return DecodeZigZag(u64), n, nil +} + +func ReverseGetVarInt64(arr []byte) (num int64, n int, err error) { + u64, n, err := ReverseGetVarUint64(arr) + if err != nil { + return + } + return DecodeZigZag(u64), n, nil +} + +// PUT + +func PutUint16(arr []byte, num uint16) { + arr[0] = byte(num) + arr[1] = byte(num >> 8) +} + +func PutIntAsUint16(arr []byte, num int) { + arr[0] = byte(num) + arr[1] = byte(num >> 8) +} + +func PutIntAsUint24(arr []byte, num int) { + arr[0] = byte(num) + arr[1] = byte(num >> 8) + arr[2] = byte(num >> 16) +} + +func PutUint32(arr []byte, num uint32) { + arr[0] = byte(num) + arr[1] = byte(num >> 8) + arr[2] = byte(num >> 16) + arr[3] = byte(num >> 24) +} + +func PutInt64AsUint32(arr []byte, num int64) { + arr[0] = byte(num) + arr[1] = byte(num >> 8) + arr[2] = byte(num >> 16) + arr[3] = byte(num >> 24) +} + +func PutUint40(arr []byte, num uint64) { + arr[0] = byte(num) + arr[1] = byte(num >> 8) + arr[2] = byte(num >> 16) + arr[3] = byte(num >> 24) + arr[4] = byte(num >> 32) +} + +func PutUint48(arr []byte, num uint64) { + arr[0] = byte(num) + arr[1] = byte(num >> 8) + arr[2] = byte(num >> 16) + arr[3] = byte(num >> 24) + arr[4] = byte(num >> 32) + arr[5] = byte(num >> 40) +} + +func PutUint64(arr []byte, num uint64) { + arr[0] = byte(num) + arr[1] = byte(num >> 8) + arr[2] = byte(num >> 16) + arr[3] = byte(num >> 24) + arr[4] = byte(num >> 32) + arr[5] = byte(num >> 40) + arr[6] = byte(num >> 48) + arr[7] = byte(num >> 56) +} + +func PutFloat32(arr []byte, num float32) { + PutUint32(arr, math.Float32bits(num)) +} + +func PutFloat64(arr []byte, num float64) { + PutUint64(arr, math.Float64bits(num)) +} + +// WRITE + +func WriteUint16(dst io.Writer, num uint16) error { + arr := []byte{ + byte(num), + byte(num >> 8), + } + n, err := dst.Write(arr) + if err != nil { + return err + } + if n != 2 { + return ErrIncompleteWrite + } + return err +} + +func WriteUint32(dst io.Writer, num uint32) error { + arr := []byte{ + byte(num), + byte(num >> 8), + byte(num >> 16), + byte(num >> 24), + } + n, err := dst.Write(arr) + if err != nil { + return err + } + if n != 4 { + return ErrIncompleteWrite + } + return err +} + +func WriteFloat64(dst io.Writer, num float64) error { + arr := make([]byte, 8) + PutUint64(arr, math.Float64bits(num)) + n, err := dst.Write(arr) + if err != nil { + return err + } + if n != 2 { + return ErrIncompleteWrite + } + return err +} + +// WRITE VAR + +func WriteVarUint64(dst io.Writer, num uint64) (int, error) { + arr := make([]byte, 9) + for i := range 8 { + arr[i] = byte(num & 127) + num >>= 7 + if num == 0 { + arr[i] |= 128 + size := i + 1 + n, err := dst.Write(arr[:size]) + if err != nil { + return n, err + } + if n != size { + return n, ErrIncompleteWrite + } + return size, nil + } + } + arr[8] = byte(num) + n, err := dst.Write(arr) + if err != nil { + return n, err + } + if n != 9 { + return n, ErrIncompleteWrite + } + return 9, nil +} + +func PutVarUint64(arr []byte, num uint64) (int, error) { + for i := range 8 { + if i >= len(arr) { + return 0, ErrNoSpace + } + arr[i] = byte(num & 127) + num >>= 7 + if num == 0 { + arr[i] |= 128 + return i + 1, nil + } + } + if len(arr) < 9 { + return 0, ErrNoSpace + } + arr[8] = byte(num) + return 9, nil +} + +func ReversePutVarUint64(arr []byte, num uint64) (int, error) { + var tmp [9]byte + for i := range 8 { + tmp[i] = byte(num & 127) + num >>= 7 + if num == 0 { + tmp[i] |= 128 + n := i + 1 + if len(arr) < n { + return 0, ErrNoSpace + } + for j := i; j >= 0; j-- { + arr[i-j] = tmp[j] + } + return n, nil + } + } + tmp[8] = byte(num) + n := 9 + if len(arr) < n { + return 0, ErrNoSpace + } + for j := 8; j >= 0; j-- { + arr[8-j] = tmp[j] + } + return n, nil +} + +func PutVarUint64AtEnd(arr []byte, num uint64) (int, error) { + var ( + tmp [9]byte + n int + ) + for i := range 8 { + tmp[i] = byte(num & 127) + num >>= 7 + if num == 0 { + tmp[i] |= 128 + n = i + 1 + break + } + } + if n == 0 { + tmp[8] = byte(num) + n = 9 + } + if len(arr) < n { + return 0, ErrNoSpace + } + j := len(arr) - n + for i := range n { + arr[j] = tmp[i] + j++ + } + return n, nil +} + +func PutVarInt64(arr []byte, x int64) (int, error) { + return PutVarUint64(arr, EncodeZigZag(x)) +} + +func PutVarInt64AtEnd(arr []byte, x int64) (int, error) { + return PutVarUint64AtEnd(arr, EncodeZigZag(x)) +} + +func ReversePutVarInt64(arr []byte, x int64) (int, error) { + return ReversePutVarUint64(arr, EncodeZigZag(x)) +} + +type KeyComparator interface { + CompareTo(int) int +} + +func BinarySearch(qty int, keyComparator KeyComparator) (elemIdx int, isFound bool) { + if qty == 0 { + return + } + a := 0 + b := qty - 1 + for { + var ( + elemIdx = (b-a)/2 + a + code = keyComparator.CompareTo(elemIdx) + ) + + if code == 1 { + a = elemIdx + 1 + if a > b { + return elemIdx + 1, false + } + } else if code == -1 { + b = elemIdx - 1 + if b < a { + return elemIdx, false + } + } else { + return elemIdx, true + } + } +} + +func DeleteReverseArrElem(arr []byte, qty int, elemSize int, idx int) { + dstIdx := len(arr) - idx*elemSize - 1 + srcIdx := dstIdx - elemSize + + end := len(arr) - qty*elemSize + + for ; srcIdx >= end; srcIdx-- { + arr[dstIdx] = arr[srcIdx] + dstIdx-- + } + + for i := end; i < end+elemSize; i++ { + arr[i] = 0 + } +} + +// ZigZag + +// ZigZag encoding: int64 -> uint64 +func EncodeZigZag(x int64) uint64 { + return uint64(x<<1) ^ uint64(x>>63) +} + +// ZigZag decoding: uint64 -> int64 +func DecodeZigZag(u uint64) int64 { + return int64(u>>1) ^ -(int64(u & 1)) +} + +func ReadN(r io.Reader, n int) (_ []byte, err error) { + if n < 0 { + err = fmt.Errorf("wrong n=%d", n) + return + } + buf := make([]byte, n) + err = ReadNInto(r, buf) + if err != nil { + return + } + return buf, nil +} + +func ReadNInto(r io.Reader, buf []byte) (err error) { + if len(buf) == 0 { + return + } + + var q, total, readAttempts int + + for readAttempts < maxReadAttempts { + bufsize := len(buf) - total + q, err = r.Read(buf[total:]) + if q == bufsize { + return nil + } + if err != nil { + return + } + if q > bufsize { + err = ErrReadOverflow + return + } + if q < 0 { + err = ErrNegativeReadCount + return + } + if q == 0 { + readAttempts++ + } else { + total += q + } + } + err = io.ErrNoProgress + return +} + +func CalcVarUint64Length(num uint64) int { + for i := range 8 { + num >>= 7 + if num == 0 { + return i + 1 + } + } + return 9 +} + +func CalcVarInt64Length(num int64) int { + u64 := EncodeZigZag(num) + for i := range 8 { + u64 >>= 7 + if u64 == 0 { + return i + 1 + } + } + return 9 +} diff --git a/bufreader/bufreader.go b/bufreader/bufreader.go new file mode 100644 index 0000000..684a326 --- /dev/null +++ b/bufreader/bufreader.go @@ -0,0 +1,138 @@ +package bufreader + +import ( + "errors" + "io" +) + +const ( + maxReadAttempts = 5 + defaultBufSize = 1024 +) + +var ( + // ErrReadOverflow shows 100% bug in the source reader + ErrReadOverflow = errors.New("bufreader: reader returned 'n' > bufsize") + // ErrNegativeReadCount shows 100% bug in the source reader + ErrNegativeReadCount = errors.New("bufreader: reader returned negative 'n'") +) + +type BufferedReader struct { + r io.Reader + buf []byte + idx int + end int + totalRead int +} + +func New(r io.Reader, bufsize int) *BufferedReader { + if bufsize == 0 { + bufsize = defaultBufSize + } + return &BufferedReader{ + r: r, + buf: make([]byte, bufsize), + } +} + +func (s *BufferedReader) safeRead(buf []byte) (n int, err error) { + readAttempts := 0 + for readAttempts < maxReadAttempts { + n, err = s.r.Read(buf) + + if n > 0 { + if n > len(buf) { + return 0, ErrReadOverflow + } + if err == io.EOF { + err = nil + } + return + } + + if n < 0 { + return 0, ErrNegativeReadCount + } + + // n == 0 + if err != nil { + return + } + readAttempts++ + } + return 0, io.ErrNoProgress +} + +func (s *BufferedReader) fill() error { + n, err := s.safeRead(s.buf) + s.idx = 0 + s.end = n + return err +} + +func (s *BufferedReader) ReadByte() (b byte, err error) { + if s.idx == s.end { + if err = s.fill(); err != nil { + return + } + } + b = s.buf[s.idx] + s.idx++ + s.totalRead++ + return +} + +func (s *BufferedReader) Read(buf []byte) (int, error) { + size := len(buf) + + buffered := s.end - s.idx + if size <= buffered { + for i, b := range s.buf[s.idx : s.idx+size] { + buf[i] = b + } + s.idx += size + s.totalRead += len(buf) + return size, nil + } + for i, b := range s.buf[s.idx:s.end] { + buf[i] = b + } + s.idx = 0 + s.end = 0 + + n := buffered + rbuf := buf[buffered:] + + var ( + q int + err error + ) + for n < size { + q, err = s.safeRead(rbuf) + n += q + rbuf = rbuf[q:] + + if err != nil { + if err == io.EOF && n == size { + s.totalRead += len(buf) + return n, nil + } + break + } + } + s.totalRead += len(buf[:n]) + return n, err +} + +func (s *BufferedReader) ReadN(size int) ([]byte, error) { + buf := make([]byte, size) + _, err := s.Read(buf) + if err != nil { + return nil, err + } + return buf, nil +} + +func (s *BufferedReader) TotalRead() int { + return s.totalRead +} diff --git a/chunkenc/chunckenc.go b/chunkenc/chunckenc.go new file mode 100644 index 0000000..3973ca9 --- /dev/null +++ b/chunkenc/chunckenc.go @@ -0,0 +1,3 @@ +package chunkenc + +const eps = 0.000001 diff --git a/chunkenc/cumdelta.go b/chunkenc/cumdelta.go new file mode 100644 index 0000000..1afcc46 --- /dev/null +++ b/chunkenc/cumdelta.go @@ -0,0 +1,330 @@ +package chunkenc + +import ( + "fmt" + "math" + + "gordenko.dev/dima/diploma/bin" + "gordenko.dev/dima/diploma/conbuf" +) + +// REVERSE + +type ReverseCumulativeDeltaCompressor struct { + buf *conbuf.ContinuousBuffer + coef float64 + pos int + firstValue float64 + lastDelta uint64 + length uint16 + numIdx int +} + +func NewReverseCumulativeDeltaCompressor(buf *conbuf.ContinuousBuffer, size int, fracDigits byte) *ReverseCumulativeDeltaCompressor { + var coef float64 = 1 + if fracDigits > 0 { + coef = math.Pow(10, float64(fracDigits)) + } + s := &ReverseCumulativeDeltaCompressor{ + buf: buf, + pos: size, + coef: coef, + } + if size > 0 { + s.restoreState() + } + return s +} + +func (s *ReverseCumulativeDeltaCompressor) restoreState() { + u64, n, err := s.buf.GetVarUint64(0) + if err != nil { + panic(fmt.Sprintf("bug: get first value: %s", err)) + } + s.firstValue = float64(u64) / s.coef + + if s.pos > n { + pos := s.pos - 1 + idxOf8 := uint(8 - s.buf.GetByte(pos)) + pos-- + s8 := s.buf.GetByte(pos) + pos-- + + var n int + s.lastDelta, n, err = s.buf.ReverseGetVarUint64(pos) + if err != nil { + panic(fmt.Sprintf("bug: get last delta: %s", err)) + } + pos -= n + s.numIdx = pos + 1 + + var flag byte = 1 << idxOf8 + if (s8 & flag) == flag { + s.length, _ = s.buf.DecodeRunLength(pos) + } + } +} + +func (s *ReverseCumulativeDeltaCompressor) Size() int { + return s.pos +} + +func (s *ReverseCumulativeDeltaCompressor) CalcRequiredSpace(value float64) int { + if s.pos == 0 { + n := bin.CalcVarUint64Length(uint64(value * s.coef)) + return n + 3 + } + delta := uint64((value-s.firstValue)*s.coef + eps) + if delta == s.lastDelta { + if s.length == 0 { + return 1 + } else { + newLength := s.length + 1 + if newLength < 130 { + return 0 + } else if newLength == 130 { + return 1 + } else { + if newLength < 32769 { + return 0 + } else { + n := bin.CalcVarUint64Length(delta) + n += 2 + s8q := s.buf.GetByte(s.pos - 1) + if s8q == 8 { + n -= 1 + } else { + n -= 2 + } + return n + } + } + } + } else { + n := bin.CalcVarUint64Length(delta) + n += 2 + s8q := s.buf.GetByte(s.pos - 1) + if s8q == 8 { + n -= 1 + } else { + n -= 2 + } + return n + } +} + +func (s *ReverseCumulativeDeltaCompressor) Append(value float64) { + if s.pos == 0 { + n := s.buf.PutVarUint64(s.pos, uint64(value*s.coef)) + s.pos += n + s.firstValue = value + s.encodeNewDelta(0, 0, 1) + } else { + delta := uint64((value-s.firstValue)*s.coef + eps) + if delta == s.lastDelta { + if s.length == 0 { + s.length = 2 + s.shiftOnePosToRight() + s.buf.SetByte(s.numIdx-1, 0) + s8q := s.buf.GetByte(s.pos - 1) + s.buf.SetFlag(s.pos-2, 1<<(8-s8q)) + } else { + s.length++ + if s.length < 130 { + s.buf.SetByte(s.numIdx-1, byte(s.length-2)) + } else if s.length == 130 { + s.shiftOnePosToRight() + s.encode2bLength() + } else { + if s.length < 32769 { + s.encode2bLength() + } else { + s.appendNewDelta(delta) + } + } + } + } else { + s.appendNewDelta(delta) + } + } +} + +func (s *ReverseCumulativeDeltaCompressor) appendNewDelta(delta uint64) { + s.length = 0 + + s8 := s.buf.GetByte(s.pos - 2) + s8q := s.buf.GetByte(s.pos - 1) + + if s8q == 8 { + s.pos -= 1 + s8 = 0 + s8q = 1 + } else { + s.pos -= 2 + s8q++ + } + + s.encodeNewDelta(delta, s8, s8q) +} + +func (s *ReverseCumulativeDeltaCompressor) encodeNewDelta(delta uint64, s8 byte, s8q byte) { + s.lastDelta = delta + s.numIdx = s.pos + n := s.buf.ReversePutVarUint64(s.pos, s.lastDelta) + s.pos += n + s.buf.SetByte(s.pos, s8) + s.pos++ + s.buf.SetByte(s.pos, s8q) + s.pos++ +} + +func (s *ReverseCumulativeDeltaCompressor) shiftOnePosToRight() { + s.buf.ShiftOnePosToRight(s.numIdx, s.pos) + s.pos++ + s.numIdx++ +} + +func (s *ReverseCumulativeDeltaCompressor) encode2bLength() { + num := s.length - 2 + s.buf.SetByte(s.numIdx-1, byte(num&127)|128) + s.buf.SetByte(s.numIdx-2, byte(num>>7)) +} + +func (s *ReverseCumulativeDeltaCompressor) DeleteLast() { + var ( + s8q = s.buf.GetByte(s.pos - 1) + s8 = s.buf.GetByte(s.pos - 2) + flag byte = 1 << uint(8-s8q) + ) + + if s.length > 0 { + if s.length == 2 { + s.length = 0 + s.buf.UnsetFlag(s.pos-2, flag) + s.buf.ShiftOnePosToLeft(s.numIdx, s.pos) + s.numIdx-- + s.pos-- + } else if s.length < 130 { + s.length-- + s.buf.SetByte(s.numIdx-1, byte(s.length)-2) + } else if s.length == 130 { + s.length-- + s.buf.ShiftOnePosToLeft(s.numIdx, s.pos) + s.numIdx-- + s.pos-- + s.buf.SetByte(s.numIdx-1, byte(s.length)-2) + } else { + s.length-- + s.encode2bLength() + } + } else { + if s8q > 1 { + s8q-- + flag = 1 << uint(8-s8q) + s.pos = s.numIdx + 2 + s.buf.SetByte(s.pos-2, s8) + s.buf.SetByte(s.pos-1, s8q) + } else { + s.pos = s.numIdx + 1 + s.buf.SetByte(s.pos-1, 8) + s8 = s.buf.GetByte(s.pos - 2) + flag = 1 + } + var ( + pos = s.pos - 3 + n int + err error + ) + s.lastDelta, n, err = s.buf.ReverseGetVarUint64(pos) + if err != nil { + panic(err) + } + s.numIdx = pos - n + if (s8 & flag) == flag { + s.length, _ = s.buf.DecodeRunLength(s.numIdx - 1) + } + } +} + +type ReverseCumulativeDeltaDecompressor struct { + buf *conbuf.ContinuousBuffer + pos int + bound int + firstValue float64 + lastValue float64 + length uint16 + coef float64 + idxOf8 uint + s8 byte + step byte +} + +func NewReverseCumulativeDeltaDecompressor(buf *conbuf.ContinuousBuffer, size int, fracDigits byte) *ReverseCumulativeDeltaDecompressor { + var coef float64 = 1 + if fracDigits > 0 { + coef = math.Pow(10, float64(fracDigits)) + } + return &ReverseCumulativeDeltaDecompressor{ + buf: buf, + coef: coef, + pos: size, + } +} + +func (s *ReverseCumulativeDeltaDecompressor) NextValue() (value float64, done bool) { + if s.step > 0 { + if s.length > 0 { + s.length-- + return s.lastValue, false + } + if s.pos < s.bound { + return 0, true + } + if s.idxOf8 == 0 { + s.s8 = s.buf.GetByte(s.pos) + s.pos-- + } + s.readVar() + if s.length > 0 { + s.length-- + } + return s.lastValue, false + } + u64, n, err := s.buf.GetVarUint64(0) + if err != nil { + panic(err) + } + s.firstValue = float64(u64) / s.coef + s.bound = n + s.pos-- + s.idxOf8 = uint(8 - s.buf.GetByte(s.pos)) + s.pos-- + s.s8 = s.buf.GetByte(s.pos) + s.pos-- + s.readVar() + if s.length > 0 { + s.length-- + } + s.step = 1 + return s.lastValue, false +} + +func (s *ReverseCumulativeDeltaDecompressor) readVar() { + u64, n, err := s.buf.ReverseGetVarUint64(s.pos) + if err != nil { + panic(err) + } + s.pos -= n + s.lastValue = s.firstValue + float64(u64)/s.coef + + var flag byte = 1 << s.idxOf8 + if (s.s8 & flag) == flag { + s.length, n = s.buf.DecodeRunLength(s.pos) + s.pos -= n + } + if s.idxOf8 == 7 { + s.idxOf8 = 0 + } else { + s.idxOf8++ + } +} diff --git a/chunkenc/insdelta.go b/chunkenc/insdelta.go new file mode 100644 index 0000000..30c1903 --- /dev/null +++ b/chunkenc/insdelta.go @@ -0,0 +1,345 @@ +package chunkenc + +import ( + "fmt" + "math" + + "gordenko.dev/dima/diploma/bin" + "gordenko.dev/dima/diploma/conbuf" +) + +// REVERSE + +type ReverseInstantDeltaCompressor struct { + buf *conbuf.ContinuousBuffer + coef float64 + pos int + firstValue float64 + lastDelta int64 + length uint16 + numIdx int +} + +func NewReverseInstantDeltaCompressor(buf *conbuf.ContinuousBuffer, size int, fracDigits byte) *ReverseInstantDeltaCompressor { + var coef float64 = 1 + if fracDigits > 0 { + coef = math.Pow(10, float64(fracDigits)) + } + s := &ReverseInstantDeltaCompressor{ + buf: buf, + pos: size, + coef: coef, + } + if size > 0 { + s.restoreState() + } + return s +} + +func (s *ReverseInstantDeltaCompressor) restoreState() { + i64, n, err := s.buf.GetVarInt64(0) + if err != nil { + panic(fmt.Sprintf("bug: get first value: %s", err)) + } + s.firstValue = float64(i64) / s.coef + + if s.pos > n { + pos := s.pos - 1 + idxOf8 := uint(8 - s.buf.GetByte(pos)) + pos-- + s8 := s.buf.GetByte(pos) + pos-- + + var n int + s.lastDelta, n, err = s.buf.ReverseGetVarInt64(pos) + if err != nil { + panic(fmt.Sprintf("bug: get last delta: %s", err)) + } + pos -= n + s.numIdx = pos + 1 + var flag byte = 1 << idxOf8 + if (s8 & flag) == flag { + s.length, _ = s.buf.DecodeRunLength(pos) + } + } +} + +func (s *ReverseInstantDeltaCompressor) Size() int { + return s.pos +} + +func (s *ReverseInstantDeltaCompressor) CalcRequiredSpace(value float64) int { + if s.pos == 0 { + n := bin.CalcVarInt64Length(int64(value * s.coef)) + return n + 3 + } + + tmp := (value - s.firstValue) * s.coef + if tmp > 0 { + tmp += eps + } else { + tmp -= eps + } + delta := int64(tmp) + + if delta == s.lastDelta { + if s.length == 0 { + return 1 + } else { + newLength := s.length + 1 + if newLength < 130 { + return 0 + } else if newLength == 130 { + return 1 + } else { + if newLength < 32769 { + return 0 + } else { + n := bin.CalcVarInt64Length(delta) + n += 2 + s8q := s.buf.GetByte(s.pos - 1) + if s8q == 8 { + n -= 1 + } else { + n -= 2 + } + return n + } + } + } + } else { + n := bin.CalcVarInt64Length(delta) + n += 2 + s8q := s.buf.GetByte(s.pos - 1) + if s8q == 8 { + n -= 1 + } else { + n -= 2 + } + return n + } +} + +// В начале буфера кодирую базовое значение. +func (s *ReverseInstantDeltaCompressor) Append(value float64) { + if s.pos == 0 { + n := s.buf.PutVarInt64(s.pos, int64(value*s.coef)) + s.pos += n + s.firstValue = value + s.encodeNewDelta(0, 0, 1) + } else { + tmp := (value - s.firstValue) * s.coef + if tmp > 0 { + tmp += eps + } else { + tmp -= eps + } + delta := int64(tmp) + + if delta == s.lastDelta { + if s.length == 0 { + s.length = 2 + s.shiftOnePosToRight() + s.buf.SetByte(s.numIdx-1, 0) + s8q := s.buf.GetByte(s.pos - 1) + s.buf.SetFlag(s.pos-2, 1<<(8-s8q)) + } else { + s.length++ + if s.length < 130 { + s.buf.SetByte(s.numIdx-1, byte(s.length-2)) + } else if s.length == 130 { + s.shiftOnePosToRight() + s.encode2bLength() + } else { + if s.length < 32769 { + s.encode2bLength() + } else { + s.appendNewDelta(delta) + } + } + } + } else { + s.appendNewDelta(delta) + } + } +} + +func (s *ReverseInstantDeltaCompressor) appendNewDelta(delta int64) { + s.length = 0 + + s8 := s.buf.GetByte(s.pos - 2) + s8q := s.buf.GetByte(s.pos - 1) + + if s8q == 8 { + s.pos -= 1 + s8 = 0 + s8q = 1 + } else { + s.pos -= 2 + s8q++ + } + s.encodeNewDelta(delta, s8, s8q) +} + +func (s *ReverseInstantDeltaCompressor) encodeNewDelta(delta int64, s8 byte, s8q byte) { + s.lastDelta = delta + s.numIdx = s.pos + n := s.buf.ReversePutVarInt64(s.pos, s.lastDelta) + s.pos += n + s.buf.SetByte(s.pos, s8) + s.pos++ + s.buf.SetByte(s.pos, s8q) + s.pos++ +} + +func (s *ReverseInstantDeltaCompressor) shiftOnePosToRight() { + s.buf.ShiftOnePosToRight(s.numIdx, s.pos) + s.pos++ + s.numIdx++ +} + +func (s *ReverseInstantDeltaCompressor) encode2bLength() { + num := s.length - 2 + s.buf.SetByte(s.numIdx-1, byte(num&127)|128) + s.buf.SetByte(s.numIdx-2, byte(num>>7)) +} + +func (s *ReverseInstantDeltaCompressor) DeleteLast() { + var ( + s8q = s.buf.GetByte(s.pos - 1) + s8 = s.buf.GetByte(s.pos - 2) + flag byte = 1 << uint(8-s8q) + ) + + if s.length > 0 { + if s.length == 2 { + s.length = 0 + s.buf.UnsetFlag(s.pos-2, flag) + s.buf.ShiftOnePosToLeft(s.numIdx, s.pos) + s.numIdx-- + s.pos-- + } else if s.length < 130 { + s.length-- + s.buf.SetByte(s.numIdx-1, byte(s.length)-2) + } else if s.length == 130 { + s.length-- + s.buf.ShiftOnePosToLeft(s.numIdx, s.pos) + s.numIdx-- + s.pos-- + s.buf.SetByte(s.numIdx-1, byte(s.length)-2) + } else { + s.length-- + s.encode2bLength() + } + } else { + if s8q > 1 { + s8q-- + flag = 1 << uint(8-s8q) + s.pos = s.numIdx + 2 + s.buf.SetByte(s.pos-2, s8) + s.buf.SetByte(s.pos-1, s8q) + } else { + s.pos = s.numIdx + 1 + s.buf.SetByte(s.pos-1, 8) + s8 = s.buf.GetByte(s.pos - 2) + flag = 1 + } + var ( + pos = s.pos - 3 + n int + err error + ) + s.lastDelta, n, err = s.buf.ReverseGetVarInt64(pos) + if err != nil { + panic(err) + } + s.numIdx = pos - n + if (s8 & flag) == flag { + s.length, _ = s.buf.DecodeRunLength(s.numIdx - 1) + } + } +} + +type ReverseInstantDeltaDecompressor struct { + step byte + buf *conbuf.ContinuousBuffer + pos int + bound int + firstValue float64 + lastValue float64 + length uint16 + coef float64 + idxOf8 uint + s8 byte +} + +func NewReverseInstantDeltaDecompressor(buf *conbuf.ContinuousBuffer, size int, fracDigits byte) *ReverseInstantDeltaDecompressor { + var coef float64 = 1 + if fracDigits > 0 { + coef = math.Pow(10, float64(fracDigits)) + } + return &ReverseInstantDeltaDecompressor{ + buf: buf, + coef: coef, + pos: size, + } +} + +func (s *ReverseInstantDeltaDecompressor) NextValue() (value float64, done bool) { + if s.step > 0 { + if s.length > 0 { + s.length-- + return s.lastValue, false + } + if s.pos < s.bound { + return 0, true + } + + if s.idxOf8 == 0 { + s.s8 = s.buf.GetByte(s.pos) + s.pos-- + } + s.readVar() + if s.length > 0 { + s.length-- + } + return s.lastValue, false + } + i64, n, err := s.buf.GetVarInt64(0) + if err != nil { + panic(err) + } + s.firstValue = float64(i64) / s.coef + s.bound = n + s.pos-- + s.idxOf8 = uint(8 - s.buf.GetByte(s.pos)) + s.pos-- + s.s8 = s.buf.GetByte(s.pos) + s.pos-- + s.readVar() + if s.length > 0 { + s.length-- + } + s.step = 1 + return s.lastValue, false +} + +func (s *ReverseInstantDeltaDecompressor) readVar() { + i64, n, err := s.buf.ReverseGetVarInt64(s.pos) + if err != nil { + panic(err) + } + s.pos -= n + s.lastValue = s.firstValue + float64(i64)/s.coef + + var flag byte = 1 << s.idxOf8 + if (s.s8 & flag) == flag { + s.length, n = s.buf.DecodeRunLength(s.pos) + s.pos -= n + } + if s.idxOf8 == 7 { + s.idxOf8 = 0 + } else { + s.idxOf8++ + } +} diff --git a/chunkenc/time_delta_delta.go b/chunkenc/time_delta_delta.go new file mode 100644 index 0000000..c458408 --- /dev/null +++ b/chunkenc/time_delta_delta.go @@ -0,0 +1,374 @@ +package chunkenc + +import ( + "fmt" + + "gordenko.dev/dima/diploma/bin" + "gordenko.dev/dima/diploma/conbuf" +) + +// REVERSE + +const ( + lastUnixtimeIdx = 0 + baseDeltaIdx = 4 +) + +type ReverseTimeDeltaOfDeltaCompressor struct { + buf *conbuf.ContinuousBuffer + pos int + baseDelta uint32 + lastUnixtime uint32 + lastDeltaOfDelta int64 + length uint16 + numIdx int +} + +func NewReverseTimeDeltaOfDeltaCompressor(buf *conbuf.ContinuousBuffer, size int) *ReverseTimeDeltaOfDeltaCompressor { + s := &ReverseTimeDeltaOfDeltaCompressor{ + buf: buf, + pos: size, + } + if size > 0 { + s.restoreState() + } + return s +} + +func (s *ReverseTimeDeltaOfDeltaCompressor) restoreState() { + s.lastUnixtime = s.buf.GetUint32(lastUnixtimeIdx) + if s.pos > 4 { + u64, _, err := s.buf.GetVarUint64(baseDeltaIdx) + if err != nil { + panic(fmt.Sprintf("bug: get base delta: %s", err)) + } + s.baseDelta = uint32(u64) + + pos := s.pos - 1 + idxOf8 := uint(8 - s.buf.GetByte(pos)) + pos-- + s8 := s.buf.GetByte(pos) + pos-- + + var n int + s.lastDeltaOfDelta, n, err = s.buf.ReverseGetVarInt64(pos) + if err != nil { + panic(err) + } + pos -= n + s.numIdx = pos + 1 + var flag byte = 1 << idxOf8 + if (s8 & flag) == flag { + s.length, _ = s.buf.DecodeRunLength(pos) + } + } +} + +func (s *ReverseTimeDeltaOfDeltaCompressor) Size() int { + return s.pos +} + +func (s *ReverseTimeDeltaOfDeltaCompressor) CalcRequiredSpace(unixtime uint32) int { + if s.pos == 0 { + return 4 + } + + if s.baseDelta == 0 { + baseDelta := unixtime - s.lastUnixtime + n := bin.CalcVarUint64Length(uint64(baseDelta)) + return n + 3 + } + + deltaOfDelta := int64(unixtime-s.lastUnixtime) - int64(s.baseDelta) + if deltaOfDelta == s.lastDeltaOfDelta { + if s.length == 0 { + return 1 + } else { + newLength := s.length + 1 + if newLength < 130 { + return 0 + } else if newLength == 130 { + return 1 + } else { + if newLength < 32769 { + return 0 + } else { + n := bin.CalcVarInt64Length(deltaOfDelta) + n += 2 + s8q := s.buf.GetByte(s.pos - 1) + if s8q == 8 { + n -= 1 + } else { + n -= 2 + } + return n + } + } + } + } else { + n := bin.CalcVarInt64Length(deltaOfDelta) + n += 2 + s8q := s.buf.GetByte(s.pos - 1) + if s8q == 8 { + n -= 1 + } else { + n -= 2 + } + return n + } +} + +func (s *ReverseTimeDeltaOfDeltaCompressor) Append(unixtime uint32) { + if s.pos == 0 { + s.lastUnixtime = unixtime + s.buf.PutUint32(lastUnixtimeIdx, unixtime) + s.pos += 4 + return + } + + if s.baseDelta == 0 { + s.baseDelta = unixtime - s.lastUnixtime + s.lastDeltaOfDelta = 0 + s.lastUnixtime = unixtime + s.buf.PutUint32(lastUnixtimeIdx, unixtime) + + n := s.buf.PutVarUint64(s.pos, uint64(s.baseDelta)) + s.pos += n + s.encodeNewDeltaOfDelta(0, 0, 1) + return + } + + deltaOfDelta := int64(unixtime-s.lastUnixtime) - int64(s.baseDelta) + s.lastUnixtime = unixtime + s.buf.PutUint32(lastUnixtimeIdx, unixtime) + + if deltaOfDelta == s.lastDeltaOfDelta { + if s.length == 0 { + s.length = 2 + s.shiftOnePosToRight() + s.buf.SetByte(s.numIdx-1, 0) + s8q := s.buf.GetByte(s.pos - 1) + s.buf.SetFlag(s.pos-2, 1<<(8-s8q)) + } else { + s.length++ + if s.length < 130 { + s.buf.SetByte(s.numIdx-1, byte(s.length-2)) + } else if s.length == 130 { + s.shiftOnePosToRight() + s.encode2bLength() + } else { + if s.length < 32769 { + s.encode2bLength() + } else { + s.appendNewDeltaOfDelta(deltaOfDelta) + } + } + } + } else { + s.appendNewDeltaOfDelta(deltaOfDelta) + } +} + +func (s *ReverseTimeDeltaOfDeltaCompressor) appendNewDeltaOfDelta(deltaOfDelta int64) { + s.length = 0 + s8 := s.buf.GetByte(s.pos - 2) + s8q := s.buf.GetByte(s.pos - 1) + + if s8q == 8 { + s.pos -= 1 + s8 = 0 + s8q = 1 + } else { + s.pos -= 2 + s8q++ + } + + s.encodeNewDeltaOfDelta(deltaOfDelta, s8, s8q) +} + +func (s *ReverseTimeDeltaOfDeltaCompressor) encodeNewDeltaOfDelta(deltaOfDelta int64, s8 byte, s8q byte) { + s.lastDeltaOfDelta = deltaOfDelta + s.numIdx = s.pos + n := s.buf.ReversePutVarInt64(s.pos, deltaOfDelta) + s.pos += n + s.buf.SetByte(s.pos, s8) + s.pos++ + s.buf.SetByte(s.pos, s8q) + s.pos++ +} + +func (s *ReverseTimeDeltaOfDeltaCompressor) shiftOnePosToRight() { + s.buf.ShiftOnePosToRight(s.numIdx, s.pos) + s.pos++ + s.numIdx++ +} + +func (s *ReverseTimeDeltaOfDeltaCompressor) encode2bLength() { + num := s.length - 2 + s.buf.SetByte(s.numIdx-1, byte(num&127)|128) + s.buf.SetByte(s.numIdx-2, byte(num>>7)) +} + +func (s *ReverseTimeDeltaOfDeltaCompressor) DeleteLast() { + var ( + s8q = s.buf.GetByte(s.pos - 1) + s8 = s.buf.GetByte(s.pos - 2) + flag byte = 1 << uint(8-s8q) + ) + + if s.length > 0 { + if s.length == 2 { + s.length = 0 + s.buf.UnsetFlag(s.pos-2, flag) + s.buf.ShiftOnePosToLeft(s.numIdx, s.pos) + s.numIdx-- + s.pos-- + } else if s.length < 130 { + s.length-- + s.buf.SetByte(s.numIdx-1, byte(s.length)-2) + } else if s.length == 130 { + s.length-- + s.buf.ShiftOnePosToLeft(s.numIdx, s.pos) + s.numIdx-- + s.pos-- + s.buf.SetByte(s.numIdx-1, byte(s.length)-2) + } else { + s.length-- + s.encode2bLength() + } + } else { + if s8q > 1 { + s8q-- + flag = 1 << uint(8-s8q) + s.pos = s.numIdx + 2 + s.buf.SetByte(s.pos-2, s8) + s.buf.SetByte(s.pos-1, s8q) + } else { + s.pos = s.numIdx + 1 + s.buf.SetByte(s.pos-1, 8) + s8 = s.buf.GetByte(s.pos - 2) + flag = 1 + } + var ( + pos = s.pos - 3 + n int + err error + ) + s.lastDeltaOfDelta, n, err = s.buf.ReverseGetVarInt64(pos) + if err != nil { + panic(err) + } + s.numIdx = pos - n + if (s8 & flag) == flag { + s.length, _ = s.buf.DecodeRunLength(s.numIdx - 1) + } + } + + delta := int64(s.baseDelta) + s.lastDeltaOfDelta + s.lastUnixtime = uint32(int64(s.lastUnixtime) - delta) + s.buf.PutUint32(lastUnixtimeIdx, s.lastUnixtime) +} + +type ReverseTimeDeltaOfDeltaDecompressor struct { + step byte + buf *conbuf.ContinuousBuffer + pos int + bound int + lastUnixtime uint32 + baseDelta uint32 + lastDeltaOfDelta int64 + length uint16 + idxOf8 uint + s8 byte +} + +func NewReverseTimeDeltaOfDeltaDecompressor(buf *conbuf.ContinuousBuffer, size int) *ReverseTimeDeltaOfDeltaDecompressor { + return &ReverseTimeDeltaOfDeltaDecompressor{ + buf: buf, + pos: size, + } +} + +func (s *ReverseTimeDeltaOfDeltaDecompressor) NextValue() (value uint32, done bool) { + if s.step == 0 { + if s.pos == 0 { + return 0, true + } + s.lastUnixtime = s.buf.GetUint32(lastUnixtimeIdx) + s.step = 1 + return s.lastUnixtime, false + } + + if s.step == 1 { + if s.pos == baseDeltaIdx { + return 0, true + } + u64, n, err := s.buf.GetVarUint64(baseDeltaIdx) + if err != nil { + panic("EOF") + } + s.bound = baseDeltaIdx + n + s.baseDelta = uint32(u64) + + s.pos-- + s.idxOf8 = uint(8 - s.buf.GetByte(s.pos)) + s.pos-- + s.s8 = s.buf.GetByte(s.pos) + s.pos-- + + s.readVar() + if s.length > 0 { + s.length-- + } + s.step = 2 + return s.lastUnixtime, false + } + + if s.length > 0 { + s.length-- + delta := int64(s.baseDelta) + s.lastDeltaOfDelta + s.lastUnixtime = uint32(int64(s.lastUnixtime) - delta) + return s.lastUnixtime, false + } + + if s.pos < s.bound { + return 0, true + } + + if s.idxOf8 == 0 { + s.s8 = s.buf.GetByte(s.pos) + s.pos-- + } + s.readVar() + if s.length > 0 { + s.length-- + } + return s.lastUnixtime, false +} + +func (s *ReverseTimeDeltaOfDeltaDecompressor) readVar() { + var ( + n int + err error + ) + + s.lastDeltaOfDelta, n, err = s.buf.ReverseGetVarInt64(s.pos) + if err != nil { + panic(err) + } + s.pos -= n + + delta := int64(s.baseDelta) + s.lastDeltaOfDelta + s.lastUnixtime = uint32(int64(s.lastUnixtime) - delta) + + var flag byte = 1 << s.idxOf8 + if (s.s8 & flag) == flag { + s.length, n = s.buf.DecodeRunLength(s.pos) + s.pos -= n + } + if s.idxOf8 == 7 { + s.idxOf8 = 0 + } else { + s.idxOf8++ + } +} diff --git a/client/client.go b/client/client.go new file mode 100644 index 0000000..ee6fa1f --- /dev/null +++ b/client/client.go @@ -0,0 +1,755 @@ +package client + +import ( + "fmt" + "net" + + "gordenko.dev/dima/diploma" + "gordenko.dev/dima/diploma/bin" + "gordenko.dev/dima/diploma/bufreader" + "gordenko.dev/dima/diploma/proto" +) + +const ( + metricKeySize = 4 +) + +type Error struct { + Code uint16 + Message string +} + +func (s Error) Error() string { + return fmt.Sprintf("%d: %s", s.Code, s.Message) +} + +type Connection struct { + conn net.Conn + src *bufreader.BufferedReader +} + +func Connect(address string) (*Connection, error) { + conn, err := net.Dial("tcp", address) + if err != nil { + return nil, err + } + + return &Connection{ + conn: conn, + src: bufreader.New(conn, 1500), + }, nil +} + +func (s *Connection) String() string { + return s.conn.LocalAddr().String() +} + +func (s *Connection) Close() { + s.conn.Close() +} + +func (s *Connection) mustSuccess(reader *bufreader.BufferedReader) (err error) { + code, err := reader.ReadByte() + if err != nil { + return fmt.Errorf("read response code: %s", err) + } + + switch code { + case proto.RespSuccess: + return nil // ok + + case proto.RespError: + return s.onError() + + default: + return fmt.Errorf("unknown reponse code %d", code) + } +} + +type Metric struct { + MetricID uint32 + MetricType diploma.MetricType + FracDigits byte +} + +func (s *Connection) AddMetric(req Metric) error { + arr := []byte{ + proto.TypeAddMetric, + 0, 0, 0, 0, // + byte(req.MetricType), + byte(req.FracDigits), + } + bin.PutUint32(arr[1:], req.MetricID) + + if _, err := s.conn.Write(arr); err != nil { + return err + } + return s.mustSuccess(s.src) +} + +func (s *Connection) GetMetric(metricID uint32) (*Metric, error) { + arr := []byte{ + proto.TypeGetMetric, + 0, 0, 0, 0, + } + bin.PutUint32(arr[1:], metricID) + + if _, err := s.conn.Write(arr); err != nil { + return nil, err + } + + code, err := s.src.ReadByte() + if err != nil { + return nil, fmt.Errorf("read response code: %s", err) + } + + switch code { + case proto.RespValue: + arr, err := s.src.ReadN(6) + if err != nil { + return nil, fmt.Errorf("read body: %s", err) + } + + return &Metric{ + MetricID: bin.GetUint32(arr), + MetricType: diploma.MetricType(arr[4]), + FracDigits: arr[5], + }, nil + + case proto.RespError: + return nil, s.onMaybeError() + + default: + return nil, fmt.Errorf("unknown reponse code %d", code) + } +} + +func (s *Connection) DeleteMetric(metricID uint32) error { + arr := []byte{ + proto.TypeDeleteMetric, + 0, 0, 0, 0, // + } + bin.PutUint32(arr[1:], metricID) + + if _, err := s.conn.Write(arr); err != nil { + return err + } + return s.mustSuccess(s.src) +} + +type AppendMeasureReq struct { + MetricID uint32 + Timestamp uint32 + Value float64 +} + +func (s *Connection) AppendMeasure(req AppendMeasureReq) (err error) { + arr := []byte{ + proto.TypeAppendMeasure, + 0, 0, 0, 0, // metricID + 0, 0, 0, 0, // timestamp + 0, 0, 0, 0, 0, 0, 0, 0, // value + } + bin.PutUint32(arr[1:], req.MetricID) + bin.PutUint32(arr[5:], req.Timestamp) + bin.PutFloat64(arr[9:], req.Value) + + if _, err := s.conn.Write(arr); err != nil { + return err + } + return s.mustSuccess(s.src) +} + +type AppendMeasuresReq struct { + MetricID uint32 + Measures []Measure +} + +type Measure struct { + Timestamp uint32 + Value float64 +} + +func (s *Connection) AppendMeasures(req AppendMeasuresReq) (err error) { + if len(req.Measures) > 65535 { + return fmt.Errorf("wrong measures qty: %d", len(req.Measures)) + } + var ( + prefixSize = 7 + recordSize = 12 + arr = make([]byte, prefixSize+len(req.Measures)*recordSize) + ) + arr[0] = proto.TypeAppendMeasures + bin.PutUint32(arr[1:], req.MetricID) + bin.PutUint16(arr[5:], uint16(len(req.Measures))) + pos := prefixSize + for _, measure := range req.Measures { + bin.PutUint32(arr[pos:], measure.Timestamp) + bin.PutFloat64(arr[pos+4:], measure.Value) + pos += recordSize + } + if _, err := s.conn.Write(arr); err != nil { + return err + } + return s.mustSuccess(s.src) +} + +type InstantMeasure struct { + Timestamp uint32 + Value float64 +} + +func (s *Connection) ListAllInstantMeasures(metricID uint32) ([]InstantMeasure, error) { + arr := []byte{ + proto.TypeListAllInstantMeasures, + 0, 0, 0, 0, // metricID + } + bin.PutUint32(arr[1:], metricID) + + if _, err := s.conn.Write(arr); err != nil { + return nil, err + } + + var ( + result []InstantMeasure + tmp = make([]byte, 12) + ) + + for { + code, err := s.src.ReadByte() + if err != nil { + return nil, fmt.Errorf("read response code: %s", err) + } + + switch code { + case proto.RespPartOfValue: + q, err := bin.ReadUint32(s.src) + if err != nil { + return nil, fmt.Errorf("read records qty: %s", err) + } + + for i := range int(q) { + err = bin.ReadNInto(s.src, tmp) + if err != nil { + return nil, fmt.Errorf("read record #%d: %s", i, err) + } + + result = append(result, InstantMeasure{ + Timestamp: bin.GetUint32(tmp), + Value: bin.GetFloat64(tmp[4:]), + }) + } + + case proto.RespEndOfValue: + return result, nil + + case proto.RespError: + return nil, s.onError() + + default: + return nil, fmt.Errorf("unknown reponse code %d", code) + } + } +} + +func (s *Connection) ListInstantMeasures(req proto.ListInstantMeasuresReq) ([]InstantMeasure, error) { + arr := []byte{ + proto.TypeListInstantMeasures, + 0, 0, 0, 0, // metricID + 0, 0, 0, 0, // since + 0, 0, 0, 0, // until + byte(req.FirstHourOfDay), + } + bin.PutUint32(arr[1:], req.MetricID) + bin.PutUint32(arr[5:], req.Since) + bin.PutUint32(arr[9:], req.Until) + + if _, err := s.conn.Write(arr); err != nil { + return nil, err + } + + var ( + result []InstantMeasure + tmp = make([]byte, 12) + ) + + for { + code, err := s.src.ReadByte() + if err != nil { + return nil, fmt.Errorf("read response code: %s", err) + } + + switch code { + case proto.RespPartOfValue: + q, err := bin.ReadUint32(s.src) + if err != nil { + return nil, fmt.Errorf("read records qty: %s", err) + } + + for i := range int(q) { + err = bin.ReadNInto(s.src, tmp) + if err != nil { + return nil, fmt.Errorf("read record #%d: %s", i, err) + } + + result = append(result, InstantMeasure{ + Timestamp: bin.GetUint32(tmp), + Value: bin.GetFloat64(tmp[4:]), + }) + } + + case proto.RespEndOfValue: + return result, nil + + case proto.RespError: + return nil, s.onError() + + default: + return nil, fmt.Errorf("unknown reponse code %d", code) + } + } +} + +type CumulativeMeasure struct { + Timestamp uint32 + Value float64 + Total float64 +} + +func (s *Connection) ListAllCumulativeMeasures(metricID uint32) ([]CumulativeMeasure, error) { + arr := []byte{ + proto.TypeListAllCumulativeMeasures, + 0, 0, 0, 0, // metricID + } + bin.PutUint32(arr[1:], metricID) + + if _, err := s.conn.Write(arr); err != nil { + return nil, err + } + + var ( + result []CumulativeMeasure + tmp = make([]byte, 20) + ) + + for { + code, err := s.src.ReadByte() + if err != nil { + return nil, fmt.Errorf("read response code: %s", err) + } + + switch code { + case proto.RespPartOfValue: + q, err := bin.ReadUint32(s.src) + if err != nil { + return nil, fmt.Errorf("read records qty: %s", err) + } + + for i := range int(q) { + err = bin.ReadNInto(s.src, tmp) + if err != nil { + return nil, fmt.Errorf("read record #%d: %s", i, err) + } + + result = append(result, CumulativeMeasure{ + Timestamp: bin.GetUint32(tmp), + Value: bin.GetFloat64(tmp[4:]), + Total: bin.GetFloat64(tmp[12:]), + }) + } + + case proto.RespEndOfValue: + return result, nil + + case proto.RespError: + return nil, s.onError() + + default: + return nil, fmt.Errorf("unknown reponse code %d", code) + } + } +} + +func (s *Connection) ListCumulativeMeasures(req proto.ListCumulativeMeasuresReq) ([]CumulativeMeasure, error) { + arr := []byte{ + proto.TypeListCumulativeMeasures, + 0, 0, 0, 0, // metricID + 0, 0, 0, 0, // since + 0, 0, 0, 0, // until + byte(req.FirstHourOfDay), + } + bin.PutUint32(arr[1:], req.MetricID) + bin.PutUint32(arr[5:], req.Since) + bin.PutUint32(arr[9:], req.Until) + + if _, err := s.conn.Write(arr); err != nil { + return nil, err + } + + var ( + result []CumulativeMeasure + tmp = make([]byte, 20) + ) + + for { + code, err := s.src.ReadByte() + if err != nil { + return nil, fmt.Errorf("read response code: %s", err) + } + + switch code { + case proto.RespPartOfValue: + q, err := bin.ReadUint32(s.src) + if err != nil { + return nil, fmt.Errorf("read records qty: %s", err) + } + + for i := range int(q) { + err = bin.ReadNInto(s.src, tmp) + if err != nil { + return nil, fmt.Errorf("read record #%d: %s", i, err) + } + + result = append(result, CumulativeMeasure{ + Timestamp: bin.GetUint32(tmp), + Value: bin.GetFloat64(tmp[4:]), + Total: bin.GetFloat64(tmp[12:]), + }) + } + + case proto.RespEndOfValue: + return result, nil + + case proto.RespError: + return nil, s.onError() + + default: + return nil, fmt.Errorf("unknown reponse code %d", code) + } + } +} + +type InstantPeriod struct { + Period uint32 + Since uint32 + Until uint32 + Min float64 + Max float64 + Avg float64 +} + +func (s *Connection) ListInstantPeriods(req proto.ListInstantPeriodsReq) ([]InstantPeriod, error) { + arr := []byte{ + proto.TypeListInstantPeriods, + 0, 0, 0, 0, // metricID + 0, 0, 0, 0, // since + 0, 0, 0, 0, // until + byte(req.GroupBy), + req.AggregateFuncs, + byte(req.FirstHourOfDay), + byte(req.LastDayOfMonth), + } + bin.PutUint32(arr[1:], req.MetricID) + bin.PutUint32(arr[5:], req.Since) + bin.PutUint32(arr[9:], req.Until) + + if _, err := s.conn.Write(arr); err != nil { + return nil, err + } + + var q int + if (req.AggregateFuncs & diploma.AggregateMin) == diploma.AggregateMin { + q++ + } + if (req.AggregateFuncs & diploma.AggregateMax) == diploma.AggregateMax { + q++ + } + if (req.AggregateFuncs & diploma.AggregateAvg) == diploma.AggregateAvg { + q++ + } + + var ( + result []InstantPeriod + // 12 bytes - period, since, until + // q * 8 bytes - min, max, avg + tmp = make([]byte, 12+q*8) + ) + + for { + code, err := s.src.ReadByte() + if err != nil { + return nil, fmt.Errorf("read response code: %s", err) + } + + switch code { + case proto.RespPartOfValue: + q, err := bin.ReadUint32(s.src) + if err != nil { + return nil, fmt.Errorf("read records qty: %s", err) + } + + for i := range int(q) { + err = bin.ReadNInto(s.src, tmp) + if err != nil { + return nil, fmt.Errorf("read record #%d: %s", i, err) + } + + var ( + p = InstantPeriod{ + Period: bin.GetUint32(tmp[0:]), + Since: bin.GetUint32(tmp[4:]), + Until: bin.GetUint32(tmp[8:]), + } + // 12 bytes - period, since, until + pos = 12 + ) + + if (req.AggregateFuncs & diploma.AggregateMin) == diploma.AggregateMin { + p.Min = bin.GetFloat64(tmp[pos:]) + pos += 8 + } + if (req.AggregateFuncs & diploma.AggregateMax) == diploma.AggregateMax { + p.Max = bin.GetFloat64(tmp[pos:]) + pos += 8 + } + if (req.AggregateFuncs & diploma.AggregateAvg) == diploma.AggregateAvg { + p.Avg = bin.GetFloat64(tmp[pos:]) + } + result = append(result, p) + } + + case proto.RespEndOfValue: + return result, nil + + case proto.RespError: + return nil, s.onError() + + default: + return nil, fmt.Errorf("unknown reponse code %d", code) + } + } +} + +type CumulativePeriod struct { + Period uint32 + Since uint32 + Until uint32 + EndValue float64 + Total float64 +} + +func (s *Connection) ListCumulativePeriods(req proto.ListCumulativePeriodsReq) ([]CumulativePeriod, error) { + arr := []byte{ + proto.TypeListCumulativePeriods, + 0, 0, 0, 0, // metricID + 0, 0, 0, 0, // since + 0, 0, 0, 0, // until + byte(req.GroupBy), + byte(req.FirstHourOfDay), + byte(req.LastDayOfMonth), + } + bin.PutUint32(arr[1:], req.MetricID) + bin.PutUint32(arr[5:], req.Since) + bin.PutUint32(arr[9:], req.Until) + + if _, err := s.conn.Write(arr); err != nil { + return nil, err + } + + var ( + result []CumulativePeriod + tmp = make([]byte, 28) + ) + + for { + code, err := s.src.ReadByte() + if err != nil { + return nil, fmt.Errorf("read response code: %s", err) + } + + switch code { + case proto.RespPartOfValue: + q, err := bin.ReadUint32(s.src) + if err != nil { + return nil, fmt.Errorf("read records qty: %s", err) + } + + for i := range int(q) { + err = bin.ReadNInto(s.src, tmp) + if err != nil { + return nil, fmt.Errorf("read record #%d: %s", i, err) + } + result = append(result, CumulativePeriod{ + Period: bin.GetUint32(tmp[0:]), + Since: bin.GetUint32(tmp[4:]), + Until: bin.GetUint32(tmp[8:]), + EndValue: bin.GetFloat64(tmp[12:]), + Total: bin.GetFloat64(tmp[20:]), + }) + } + + case proto.RespEndOfValue: + return result, nil + + case proto.RespError: + return nil, s.onError() + + default: + return nil, fmt.Errorf("unknown reponse code %d", code) + } + } +} + +type CurrentValue struct { + MetricID uint32 + Timestamp uint32 + Value float64 +} + +func (s *Connection) ListCurrentValues(metricIDs []uint32) ([]CurrentValue, error) { + arr := make([]byte, 3+metricKeySize*len(metricIDs)) + arr[0] = proto.TypeListCurrentValues + + bin.PutUint16(arr[1:], uint16(len(metricIDs))) + + off := 3 + for _, metricID := range metricIDs { + bin.PutUint32(arr[off:], metricID) + off += metricKeySize + } + + if _, err := s.conn.Write(arr); err != nil { + return nil, err + } + + var ( + result []CurrentValue + tmp = make([]byte, 16) + ) + + for { + code, err := s.src.ReadByte() + if err != nil { + return nil, fmt.Errorf("read response code: %s", err) + } + + switch code { + case proto.RespPartOfValue: + q, err := bin.ReadUint32(s.src) + if err != nil { + return nil, fmt.Errorf("read records qty: %s", err) + } + + for i := range int(q) { + err = bin.ReadNInto(s.src, tmp) + if err != nil { + return nil, fmt.Errorf("read record #%d: %s", i, err) + } + + result = append(result, CurrentValue{ + MetricID: bin.GetUint32(tmp), + Timestamp: bin.GetUint32(tmp[4:]), + Value: bin.GetFloat64(tmp[8:]), + }) + } + + case proto.RespEndOfValue: + return result, nil + + case proto.RespError: + return nil, s.onError() + + default: + return nil, fmt.Errorf("unknown reponse code %d", code) + } + } +} + +func (s *Connection) DeleteMeasures(req proto.DeleteMeasuresReq) (err error) { + arr := []byte{ + proto.TypeDeleteMeasures, + 0, 0, 0, 0, // metricID + 0, 0, 0, 0, // since + } + bin.PutUint32(arr[1:], req.MetricID) + bin.PutUint32(arr[5:], req.Since) + + if _, err := s.conn.Write(arr); err != nil { + return err + } + return s.mustSuccess(s.src) +} + +type RangeTotalResp struct { + Since uint32 + SinceValue float64 + Until uint32 + UntilValue float64 +} + +func (s *Connection) RangeTotal(req proto.RangeTotalReq) (*RangeTotalResp, error) { + arr := []byte{ + proto.TypeGetMetric, + 0, 0, 0, 0, + 0, 0, 0, 0, + 0, 0, 0, 0, + } + bin.PutUint32(arr[1:], req.MetricID) + bin.PutUint32(arr[5:], req.Since) + bin.PutUint32(arr[9:], req.MetricID) + + if _, err := s.conn.Write(arr); err != nil { + return nil, err + } + + code, err := s.src.ReadByte() + if err != nil { + return nil, fmt.Errorf("read response code: %s", err) + } + + switch code { + case proto.RespValue: + arr, err := s.src.ReadN(24) + if err != nil { + return nil, fmt.Errorf("read body: %s", err) + } + + return &RangeTotalResp{ + Since: bin.GetUint32(arr), + SinceValue: bin.GetFloat64(arr[4:]), + Until: bin.GetUint32(arr[12:]), + UntilValue: bin.GetFloat64(arr[16:]), + }, nil + + case proto.RespError: + return nil, s.onError() + + default: + return nil, fmt.Errorf("unknown reponse code %d", code) + } +} + +func (s *Connection) onError() error { + errorCode, err := bin.ReadUint16(s.src) + if err != nil { + return fmt.Errorf("read error code: %s", err) + } + return Error{ + Code: errorCode, + Message: proto.ErrorCodeToText(errorCode), + } +} + +func (s *Connection) onMaybeError() error { + errorCode, err := bin.ReadUint16(s.src) + if err != nil { + return fmt.Errorf("read error code: %s", err) + } + if errorCode == proto.ErrNoMetric { + return nil + } + return Error{ + Code: errorCode, + Message: proto.ErrorCodeToText(errorCode), + } +} diff --git a/conbuf/conbuf.go b/conbuf/conbuf.go new file mode 100644 index 0000000..d6f85f2 --- /dev/null +++ b/conbuf/conbuf.go @@ -0,0 +1,459 @@ +package conbuf + +import ( + "errors" + "fmt" + "io" + + "gordenko.dev/dima/diploma/bin" +) + +const chunkSize = 512 + +var ( + ErrOutOfRange = errors.New("out of range") +) + +type ContinuousBuffer struct { + chunks [][]byte +} + +func NewFromBuffer(buf []byte) *ContinuousBuffer { + var ( + chunks [][]byte + copied = 0 + ) + + for copied < len(buf) { + chunk := make([]byte, chunkSize) + end := min(copied+chunkSize, len(buf)) + copy(chunk, buf[copied:end]) + chunks = append(chunks, chunk) + copied += end - copied + } + + return &ContinuousBuffer{ + chunks: chunks, + } +} + +func New(chunks [][]byte) *ContinuousBuffer { + for i, chunk := range chunks { + if len(chunk) != chunkSize { + panic(fmt.Sprintf("wrong chunk #%d size %d", i, len(chunk))) + } + } + return &ContinuousBuffer{ + chunks: chunks, + } +} + +func (s *ContinuousBuffer) Chunks() [][]byte { + return s.chunks +} + +// [0, pos) +func (s *ContinuousBuffer) GetByte(idx int) byte { + chunkIdx := idx / chunkSize + if chunkIdx >= len(s.chunks) { + panic(ErrOutOfRange) + } + byteIdx := idx % chunkSize + return s.chunks[chunkIdx][byteIdx] +} + +func (s *ContinuousBuffer) SetByte(idx int, b byte) { + chunkIdx := idx / chunkSize + if chunkIdx > len(s.chunks) { + panic(ErrOutOfRange) + } + if chunkIdx == len(s.chunks) { + s.chunks = append(s.chunks, make([]byte, chunkSize)) + } + byteIdx := idx % chunkSize + s.chunks[chunkIdx][byteIdx] = b +} + +func (s *ContinuousBuffer) SetFlag(idx int, flag byte) { + chunkIdx := idx / chunkSize + if chunkIdx > len(s.chunks) { + panic(ErrOutOfRange) + } + if chunkIdx == len(s.chunks) { + s.chunks = append(s.chunks, make([]byte, chunkSize)) + } + byteIdx := idx % chunkSize + s.chunks[chunkIdx][byteIdx] |= flag +} + +func (s *ContinuousBuffer) UnsetFlag(idx int, flag byte) { + chunkIdx := idx / chunkSize + if chunkIdx > len(s.chunks) { + panic(ErrOutOfRange) + } + if chunkIdx == len(s.chunks) { + s.chunks = append(s.chunks, make([]byte, chunkSize)) + } + byteIdx := idx % chunkSize + s.chunks[chunkIdx][byteIdx] &^= flag +} + +// [since, until) +func (s *ContinuousBuffer) ShiftOnePosToRight(since int, until int) { + if since < 0 { + panic("since < 0") + } + if since >= until { + panic("since >= until") + } + + chunkIdx := until / chunkSize + byteIdx := until % chunkSize + + if chunkIdx > len(s.chunks) { + panic(ErrOutOfRange) + } + + if chunkIdx == len(s.chunks) { + if byteIdx == 0 { + s.chunks = append(s.chunks, make([]byte, chunkSize)) + } else { + panic(ErrOutOfRange) + } + } + + var ( + qty = until - since + prevChunkIdx int + prevByteIdx int + ) + + for range qty { + prevChunkIdx = chunkIdx + prevByteIdx = byteIdx - 1 + if prevByteIdx < 0 { + prevChunkIdx = chunkIdx - 1 + prevByteIdx = chunkSize - 1 + } + + s.chunks[chunkIdx][byteIdx] = s.chunks[prevChunkIdx][prevByteIdx] + + if byteIdx > 0 { + byteIdx-- + } else { + chunkIdx-- + byteIdx = chunkSize - 1 + } + } +} + +// [since, until) +func (s *ContinuousBuffer) ShiftOnePosToLeft(since int, until int) { + if since <= 0 { + panic("since <= 0") + } + if since >= until { + panic("since >= until") + } + + chunkIdx := since / chunkSize + byteIdx := since % chunkSize + + if until > len(s.chunks)*chunkSize { + panic(ErrOutOfRange) + } + + var ( + qty = until - since + prevChunkIdx int + prevByteIdx int + ) + + for range qty { + prevChunkIdx = chunkIdx + prevByteIdx = byteIdx - 1 + if prevByteIdx < 0 { + prevChunkIdx = chunkIdx - 1 + prevByteIdx = chunkSize - 1 + } + + s.chunks[prevChunkIdx][prevByteIdx] = s.chunks[chunkIdx][byteIdx] + + byteIdx++ + if byteIdx == chunkSize { + chunkIdx++ + byteIdx = 0 + } + } +} + +func (s *ContinuousBuffer) PutUint32(pos int, num uint32) { + s.CopyTo(pos, + []byte{ + byte(num), + byte(num >> 8), + byte(num >> 16), + byte(num >> 24), + }) +} + +func (s *ContinuousBuffer) GetUint32(pos int) uint32 { + arr := s.Slice(pos, pos+4) + return uint32(arr[0]) | (uint32(arr[1]) << 8) | + (uint32(arr[2]) << 16) | (uint32(arr[3]) << 24) +} + +func (s *ContinuousBuffer) ReversePutVarUint64(pos int, num uint64) int { + var tmp [9]byte + for i := range 8 { + tmp[i] = byte(num & 127) + num >>= 7 + if num == 0 { + tmp[i] |= 128 + n := i + 1 + s.ReverseCopyTo(pos, tmp[:n]) + return n + } + } + tmp[8] = byte(num) + n := 9 + s.ReverseCopyTo(pos, tmp[:]) + return n +} + +func (s *ContinuousBuffer) ReverseGetVarUint64(idx int) (num uint64, n int, err error) { + chunkIdx := idx / chunkSize + if chunkIdx >= len(s.chunks) { + panic(ErrOutOfRange) + } + + var ( + byteIdx = idx % chunkSize + chunk = s.chunks[chunkIdx] + b byte + ) + + for i := range 8 { + b = chunk[byteIdx] + if b >= 128 { + num |= uint64(b&127) << uint(i*7) + return num, i + 1, nil + } + num |= uint64(b) << uint(i*7) + + if byteIdx > 0 { + byteIdx-- + } else { + if chunkIdx == 0 { + return 0, 0, io.EOF + } else { + chunkIdx-- + chunk = s.chunks[chunkIdx] + byteIdx = chunkSize - 1 + } + } + } + return num | uint64(chunk[byteIdx])<<56, 9, nil +} + +func (s *ContinuousBuffer) ReversePutVarInt64(pos int, x int64) int { + return s.ReversePutVarUint64(pos, bin.EncodeZigZag(x)) +} + +func (s *ContinuousBuffer) ReverseGetVarInt64(idx int) (int64, int, error) { + u64, n, err := s.ReverseGetVarUint64(idx) + if err != nil { + return 0, 0, err + } + return bin.DecodeZigZag(u64), n, nil +} + +func (s *ContinuousBuffer) PutVarUint64(pos int, num uint64) int { + var tmp [9]byte + for i := range 8 { + tmp[i] = byte(num & 127) + num >>= 7 + if num == 0 { + tmp[i] |= 128 + n := i + 1 + s.CopyTo(pos, tmp[:n]) + return n + } + } + tmp[8] = byte(num) + s.CopyTo(pos, tmp[:]) + return 9 +} + +func (s *ContinuousBuffer) GetVarUint64(idx int) (num uint64, n int, err error) { + chunkIdx := idx / chunkSize + if chunkIdx >= len(s.chunks) { + panic(ErrOutOfRange) + } + + var ( + byteIdx = idx % chunkSize + chunk = s.chunks[chunkIdx] + b byte + ) + + for i := range 8 { + b = chunk[byteIdx] + if b >= 128 { + num |= uint64(b&127) << uint(i*7) + return num, i + 1, nil + } + num |= uint64(b) << uint(i*7) + + byteIdx++ + if byteIdx == chunkSize { + chunkIdx++ + if chunkIdx == len(s.chunks) { + return 0, 0, io.EOF + } + chunk = s.chunks[chunkIdx] + byteIdx = 0 + } + } + return num | uint64(chunk[byteIdx])<<56, 9, nil +} + +func (s *ContinuousBuffer) PutVarInt64(idx int, x int64) int { + return s.PutVarUint64(idx, bin.EncodeZigZag(x)) +} + +func (s *ContinuousBuffer) GetVarInt64(idx int) (int64, int, error) { + u64, n, err := s.GetVarUint64(idx) + if err != nil { + return 0, 0, err + } + return bin.DecodeZigZag(u64), n, nil +} + +func (s *ContinuousBuffer) CopyTo(idx int, data []byte) { + chunkIdx := idx / chunkSize + if chunkIdx > len(s.chunks) { + panic(ErrOutOfRange) + } + if chunkIdx == len(s.chunks) { + s.chunks = append(s.chunks, make([]byte, chunkSize)) + } + byteIdx := idx % chunkSize + chunk := s.chunks[chunkIdx] + copied := 0 + + for _, b := range data { + chunk[byteIdx] = b + copied++ + byteIdx++ + if byteIdx == chunkSize { + byteIdx = 0 + chunkIdx++ + if chunkIdx == len(s.chunks) { + if copied == len(data) { + return + } + s.chunks = append(s.chunks, make([]byte, chunkSize)) + } + chunk = s.chunks[chunkIdx] + } + } +} + +func (s *ContinuousBuffer) ReverseCopyTo(idx int, data []byte) { + chunkIdx := idx / chunkSize + if chunkIdx > len(s.chunks) { + panic(ErrOutOfRange) + } + if chunkIdx == len(s.chunks) { + s.chunks = append(s.chunks, make([]byte, chunkSize)) + } + byteIdx := idx % chunkSize + chunk := s.chunks[chunkIdx] + copied := 0 + + for i := len(data) - 1; i >= 0; i-- { + chunk[byteIdx] = data[i] + copied++ + byteIdx++ + if byteIdx == chunkSize { + byteIdx = 0 + chunkIdx++ + if chunkIdx == len(s.chunks) { + if copied == len(data) { + return + } + s.chunks = append(s.chunks, make([]byte, chunkSize)) + } + chunk = s.chunks[chunkIdx] + } + } +} + +// [since, until) +func (s *ContinuousBuffer) Slice(since int, until int) []byte { + if since >= until { + return nil + } + size := len(s.chunks) * chunkSize + if until >= size { + panic(ErrOutOfRange) + } + + data := make([]byte, until-since) + + chunkIdx := since / chunkSize + byteIdx := since % chunkSize + chunk := s.chunks[chunkIdx] + + for i := range len(data) { + data[i] = chunk[byteIdx] + byteIdx++ + if byteIdx == chunkSize { + byteIdx = 0 + chunkIdx++ + chunk = s.chunks[chunkIdx] + } + } + return data +} + +func (s *ContinuousBuffer) DecodeRunLength(pos int) (length uint16, n int) { + b1 := s.GetByte(pos) + pos-- + if b1 < 128 { + length = uint16(b1) + n = 1 + } else { + b2 := s.GetByte(pos) + length = uint16(b1&127) | (uint16(b2) << 7) + n = 2 + } + length += 2 + return +} + +func (s *ContinuousBuffer) Copy() *ContinuousBuffer { + var copies [][]byte + for _, chunk := range s.chunks { + buf := make([]byte, chunkSize) + copy(buf, chunk) + copies = append(copies, buf) + } + return New(copies) +} + +// size to copy +func (s *ContinuousBuffer) CopyChunksToOneBuffer(dst []byte, size int) { + pos := 0 + for _, chunk := range s.chunks { + if size >= len(chunk) { + copy(dst[pos:], chunk) + size -= len(chunk) + pos += len(chunk) + } else { + copy(dst[pos:], chunk[:size]) + return + } + } +} diff --git a/database.ini b/database.ini new file mode 100644 index 0000000..80e15ab --- /dev/null +++ b/database.ini @@ -0,0 +1,4 @@ +tcpPort = 12345 +dir = testdir +redoDir = testdir +databaseName = test diff --git a/database/api.go b/database/api.go new file mode 100644 index 0000000..70782a5 --- /dev/null +++ b/database/api.go @@ -0,0 +1,1058 @@ +package database + +import ( + "errors" + "fmt" + "io" + "net" + + "gordenko.dev/dima/diploma" + "gordenko.dev/dima/diploma/atree" + "gordenko.dev/dima/diploma/bin" + "gordenko.dev/dima/diploma/bufreader" + "gordenko.dev/dima/diploma/chunkenc" + "gordenko.dev/dima/diploma/conbuf" + "gordenko.dev/dima/diploma/proto" + "gordenko.dev/dima/diploma/txlog" +) + +var ( + ErrNoValueBug = errors.New("has timestamp but no value") + ErrWrongResultCodeBug = errors.New("bug: wrong result code") + + successMsg = []byte{ + proto.RespSuccess, + } +) + +func reply(conn io.Writer, errcode uint16) { + var answer []byte + if errcode == 0 { + answer = successMsg + } else { + answer = []byte{ + proto.RespError, + 0, 0, + } + bin.PutUint16(answer[1:], errcode) + } + + _, err := conn.Write(answer) + if err != nil { + return + } +} + +func (s *Database) handleTCPConn(conn net.Conn) { + defer conn.Close() + + r := bufreader.New(conn, 128) + + for { + err := s.processRequest(conn, r) + if err != nil { + if err != io.EOF { + s.logger.Println(err) + } + return + } + } +} + +func (s *Database) processRequest(conn net.Conn, r *bufreader.BufferedReader) (err error) { + messageType, err := r.ReadByte() + if err != nil { + if err != io.EOF { + return fmt.Errorf("read messageType: %s", err) + } else { + return err + } + } + + switch messageType { + case proto.TypeGetMetric: + req, err := proto.ReadGetMetricReq(r) + if err != nil { + return fmt.Errorf("proto.ReadGetMetricReq: %s", err) + } + if err = s.GetMetric(conn, req); err != nil { + return fmt.Errorf("GetMetric: %s", err) + } + + case proto.TypeAddMetric: + req, err := proto.ReadAddMetricReq(r) + if err != nil { + return fmt.Errorf("proto.ReadAddMetricReq: %s", err) + } + reply(conn, s.AddMetric(req)) + + case proto.TypeDeleteMetric: + req, err := proto.ReadDeleteMetricReq(r) + if err != nil { + return fmt.Errorf("proto.ReadDeleteMetricReq: %s", err) + } + reply(conn, s.DeleteMetric(req)) + + case proto.TypeAppendMeasure: + req, err := proto.ReadAppendMeasureReq(r) + if err != nil { + return fmt.Errorf("proto.ReadAppendMeasureReq: %s", err) + } + //fmt.Println("append measure", req.MetricID, conn.RemoteAddr().String()) + reply(conn, s.AppendMeasure(req)) + + case proto.TypeAppendMeasures: + req, err := proto.ReadAppendMeasuresReq(r) + if err != nil { + return fmt.Errorf("proto.ReadAppendMeasuresReq: %s", err) + } + //fmt.Println("append measure", req.MetricID, conn.RemoteAddr().String()) + reply(conn, s.AppendMeasures(req)) + + case proto.TypeListInstantMeasures: + req, err := proto.ReadListInstantMeasuresReq(r) + if err != nil { + return fmt.Errorf("proto.ReadListInstantMeasuresReq: %s", err) + } + if err = s.ListInstantMeasures(conn, req); err != nil { + return fmt.Errorf("ListInstantMeasures: %s", err) + } + + case proto.TypeListCumulativeMeasures: + req, err := proto.ReadListCumulativeMeasuresReq(r) + if err != nil { + return fmt.Errorf("proto.ReadListCumulativeMeasuresReq: %s", err) + } + if err = s.ListCumulativeMeasures(conn, req); err != nil { + return fmt.Errorf("ListCumulativeMeasures: %s", err) + } + + case proto.TypeListInstantPeriods: + req, err := proto.ReadListInstantPeriodsReq(r) + if err != nil { + return fmt.Errorf("proto.ReadListInstantPeriodsReq: %s", err) + } + if err = s.ListInstantPeriods(conn, req); err != nil { + return fmt.Errorf("ListInstantPeriods: %s", err) + } + + case proto.TypeListCumulativePeriods: + req, err := proto.ReadListCumulativePeriodsReq(r) + if err != nil { + return fmt.Errorf("proto.ReadListCumulativePeriodsReq: %s", err) + } + if err = s.ListCumulativePeriods(conn, req); err != nil { + return fmt.Errorf("ListCumulativePeriods: %s", err) + } + + case proto.TypeListCurrentValues: + req, err := proto.ReadListCurrentValuesReq(r) + if err != nil { + return fmt.Errorf("proto.ListCurrentValuesReq: %s", err) + } + if err = s.ListCurrentValues(conn, req); err != nil { + return fmt.Errorf("ListCurrentValues: %s", err) + } + + case proto.TypeDeleteMeasures: + req, err := proto.ReadDeleteMeasuresReq(r) + if err != nil { + return fmt.Errorf("proto.ReadDeleteMeasuresReq: %s", err) + } + reply(conn, s.DeleteMeasures(req)) + + case proto.TypeListAllInstantMeasures: + req, err := proto.ReadListAllInstantMeasuresReq(r) + if err != nil { + return fmt.Errorf("proto.ReadListAllInstantMeasuresReq: %s", err) + } + if err = s.ListAllInstantMeasures(conn, req); err != nil { + return fmt.Errorf("ListAllInstantMeasures: %s", err) + } + + case proto.TypeListAllCumulativeMeasures: + req, err := proto.ReadListAllCumulativeMeasuresReq(r) + if err != nil { + return fmt.Errorf("proto.ReadListAllCumulativeMeasuresReq: %s", err) + } + + if err = s.ListAllCumulativeMeasures(conn, req); err != nil { + return fmt.Errorf("ListAllCumulativeMeasures: %s", err) + } + + default: + return fmt.Errorf("unknown messageType: %d", messageType) + } + return +} + +// API + +func (s *Database) AddMetric(req proto.AddMetricReq) uint16 { + // Валидация + if req.MetricID == 0 { + return proto.ErrEmptyMetricID + } + if byte(req.FracDigits) > diploma.MaxFracDigits { + return proto.ErrWrongFracDigits + } + switch req.MetricType { + case diploma.Cumulative, diploma.Instant: + // ok + default: + return proto.ErrWrongMetricType + } + + resultCh := make(chan byte, 1) + + s.appendJobToWorkerQueue(tryAddMetricReq{ + MetricID: req.MetricID, + ResultCh: resultCh, + }) + + resultCode := <-resultCh + + switch resultCode { + case Succeed: + waitCh := s.txlog.WriteAddedMetric(txlog.AddedMetric{ + MetricID: req.MetricID, + MetricType: req.MetricType, + FracDigits: req.FracDigits, + }) + <-waitCh + + case MetricDuplicate: + return proto.ErrDuplicate + + default: + diploma.Abort(diploma.WrongResultCodeBug, ErrWrongResultCodeBug) + } + return 0 +} + +type Metric struct { + MetricType diploma.MetricType + FracDigits byte + ResultCode byte +} + +func (s *Database) GetMetric(conn io.Writer, req proto.GetMetricReq) error { + resultCh := make(chan Metric, 1) + + s.appendJobToWorkerQueue(tryGetMetricReq{ + MetricID: req.MetricID, + ResultCh: resultCh, + }) + + result := <-resultCh + + switch result.ResultCode { + case Succeed: + answer := []byte{ + proto.RespValue, + 0, 0, 0, 0, // metricID + byte(result.MetricType), + result.FracDigits, + } + bin.PutUint32(answer[1:], req.MetricID) + + _, err := conn.Write(answer) + if err != nil { + return err + } + + case NoMetric: + reply(conn, proto.ErrNoMetric) + + default: + diploma.Abort(diploma.WrongResultCodeBug, ErrWrongResultCodeBug) + } + return nil +} + +type tryDeleteMetricResult struct { + ResultCode byte + RootPageNo uint32 +} + +func (s *Database) DeleteMetric(req proto.DeleteMetricReq) uint16 { + resultCh := make(chan tryDeleteMetricResult, 1) + + s.appendJobToWorkerQueue(tryDeleteMetricReq{ + MetricID: req.MetricID, + ResultCh: resultCh, + }) + + result := <-resultCh + + switch result.ResultCode { + case Succeed: + var ( + freeDataPages []uint32 + freeIndexPages []uint32 + ) + if result.RootPageNo > 0 { + pageLists, err := s.atree.GetAllPages(result.RootPageNo) + if err != nil { + diploma.Abort(diploma.FailedAtreeRequest, err) + } + freeDataPages = pageLists.DataPages + freeIndexPages = pageLists.IndexPages + } + waitCh := s.txlog.WriteDeletedMetric(txlog.DeletedMetric{ + MetricID: req.MetricID, + FreeDataPages: freeDataPages, + FreeIndexPages: freeIndexPages, + }) + <-waitCh + + case NoMetric: + return proto.ErrNoMetric + + default: + diploma.Abort(diploma.WrongResultCodeBug, ErrWrongResultCodeBug) + } + return 0 +} + +type FilledPage struct { + Since uint32 + RootPageNo uint32 + PrevPageNo uint32 + TimestampsChunks [][]byte + TimestampsSize uint16 + ValuesChunks [][]byte + ValuesSize uint16 +} + +type tryAppendMeasureResult struct { + FilledPage *FilledPage + ResultCode byte +} + +func (s *Database) AppendMeasure(req proto.AppendMeasureReq) uint16 { + resultCh := make(chan tryAppendMeasureResult, 1) + + s.appendJobToWorkerQueue(tryAppendMeasureReq{ + MetricID: req.MetricID, + Timestamp: req.Timestamp, + Value: req.Value, + ResultCh: resultCh, + }) + + result := <-resultCh + + switch result.ResultCode { + case CanAppend: + waitCh := s.txlog.WriteAppendMeasure(txlog.AppendedMeasure{ + MetricID: req.MetricID, + Timestamp: req.Timestamp, + Value: req.Value, + }) + <-waitCh + + case NewPage: + filled := result.FilledPage + report, err := s.atree.AppendDataPage(atree.AppendDataPageReq{ + MetricID: req.MetricID, + Timestamp: req.Timestamp, + Value: req.Value, + Since: filled.Since, + RootPageNo: filled.RootPageNo, + PrevPageNo: filled.PrevPageNo, + TimestampsChunks: filled.TimestampsChunks, + TimestampsSize: filled.TimestampsSize, + ValuesChunks: filled.ValuesChunks, + ValuesSize: filled.ValuesSize, + }) + if err != nil { + diploma.Abort(diploma.WriteToAtreeFailed, err) + } + waitCh := s.txlog.WriteAppendedMeasureWithOverflow( + txlog.AppendedMeasureWithOverflow{ + MetricID: req.MetricID, + Timestamp: req.Timestamp, + Value: req.Value, + IsDataPageReused: report.IsDataPageReused, + DataPageNo: report.DataPageNo, + IsRootChanged: report.IsRootChanged, + RootPageNo: report.NewRootPageNo, + ReusedIndexPages: report.ReusedIndexPages, + }, + report.FileName, + false, + ) + <-waitCh + + case NoMetric: + return proto.ErrNoMetric + + case ExpiredMeasure: + return proto.ErrExpiredMeasure + + case NonMonotonicValue: + return proto.ErrNonMonotonicValue + + default: + diploma.Abort(diploma.WrongResultCodeBug, ErrWrongResultCodeBug) + } + return 0 +} + +type tryAppendMeasuresResult struct { + ResultCode byte + MetricType diploma.MetricType + FracDigits byte + Since uint32 + Until uint32 + UntilValue float64 + RootPageNo uint32 + PrevPageNo uint32 + TimestampsBuf *conbuf.ContinuousBuffer + ValuesBuf *conbuf.ContinuousBuffer + Timestamps diploma.TimestampCompressor + Values diploma.ValueCompressor +} + +func (s *Database) AppendMeasures(req proto.AppendMeasuresReq) uint16 { + resultCh := make(chan tryAppendMeasuresResult, 1) + + s.appendJobToWorkerQueue(tryAppendMeasuresReq{ + MetricID: req.MetricID, + ResultCh: resultCh, + }) + + result := <-resultCh + + switch result.ResultCode { + case CanAppend: + var ( + rootPageNo = result.RootPageNo + prevPageNo = result.PrevPageNo + timestampsBuf = result.TimestampsBuf + valuesBuf = result.ValuesBuf + timestamps = result.Timestamps + values = result.Values + since = result.Since + until = result.Until + untilValue = result.UntilValue + // + toAppendMeasures []proto.Measure + ) + + for idx, measure := range req.Measures { + //fmt.Printf("%d %v\n", measure.Timestamp, measure.Value) + if since == 0 { + since = measure.Timestamp + } else { + if measure.Timestamp <= until { + if len(toAppendMeasures) > 0 { + waitCh := s.txlog.WriteAppendMeasures( + txlog.AppendedMeasures{ + MetricID: req.MetricID, + Measures: toAppendMeasures, + }, + false, + ) + <-waitCh + } + return proto.ErrExpiredMeasure + } + + if result.MetricType == diploma.Cumulative && measure.Value < untilValue { + if len(toAppendMeasures) > 0 { + waitCh := s.txlog.WriteAppendMeasures( + txlog.AppendedMeasures{ + MetricID: req.MetricID, + Measures: toAppendMeasures, + }, + false, + ) + <-waitCh + } + //fmt.Printf("m.Value: %v < untilValue: %v\n", measure.Value, untilValue) + return proto.ErrNonMonotonicValue + } + } + + extraSpace := timestamps.CalcRequiredSpace(measure.Timestamp) + + values.CalcRequiredSpace(measure.Value) + + totalSpace := timestamps.Size() + values.Size() + extraSpace + + if totalSpace <= atree.DataPagePayloadSize { + timestamps.Append(measure.Timestamp) + values.Append(measure.Value) + toAppendMeasures = append(toAppendMeasures, measure) + } else { + if len(toAppendMeasures) > 0 { + waitCh := s.txlog.WriteAppendMeasures( + txlog.AppendedMeasures{ + MetricID: req.MetricID, + Measures: toAppendMeasures, + }, + true, + ) + <-waitCh + + toAppendMeasures = nil + } + report, err := s.atree.AppendDataPage(atree.AppendDataPageReq{ + MetricID: req.MetricID, + Timestamp: until, + Value: untilValue, + Since: since, + RootPageNo: rootPageNo, + PrevPageNo: prevPageNo, + TimestampsChunks: timestampsBuf.Chunks(), + TimestampsSize: uint16(timestamps.Size()), + ValuesChunks: valuesBuf.Chunks(), + ValuesSize: uint16(values.Size()), + }) + if err != nil { + diploma.Abort(diploma.WriteToAtreeFailed, err) + } + + prevPageNo = report.DataPageNo + if report.IsRootChanged { + rootPageNo = report.NewRootPageNo + } + waitCh := s.txlog.WriteAppendedMeasureWithOverflow( + txlog.AppendedMeasureWithOverflow{ + MetricID: req.MetricID, + Timestamp: measure.Timestamp, + Value: measure.Value, + IsDataPageReused: report.IsDataPageReused, + DataPageNo: report.DataPageNo, + IsRootChanged: report.IsRootChanged, + RootPageNo: report.NewRootPageNo, + ReusedIndexPages: report.ReusedIndexPages, + }, + report.FileName, + (idx+1) < len(req.Measures), + ) + <-waitCh + + timestampsBuf = conbuf.New(nil) + valuesBuf = conbuf.New(nil) + + timestamps = chunkenc.NewReverseTimeDeltaOfDeltaCompressor( + timestampsBuf, 0) + if result.MetricType == diploma.Cumulative { + values = chunkenc.NewReverseCumulativeDeltaCompressor( + valuesBuf, 0, result.FracDigits) + } else { + values = chunkenc.NewReverseInstantDeltaCompressor( + valuesBuf, 0, result.FracDigits) + } + + timestamps.Append(measure.Timestamp) + values.Append(measure.Value) + + since = measure.Timestamp + } + + until = measure.Timestamp + untilValue = measure.Value + } + + if len(toAppendMeasures) > 0 { + waitCh := s.txlog.WriteAppendMeasures( + txlog.AppendedMeasures{ + MetricID: req.MetricID, + Measures: toAppendMeasures, + }, + false, + ) + <-waitCh + } + + case NoMetric: + return proto.ErrNoMetric + + default: + diploma.Abort(diploma.WrongResultCodeBug, ErrWrongResultCodeBug) + } + return 0 +} + +type tryDeleteMeasuresResult struct { + ResultCode byte + RootPageNo uint32 +} + +func (s *Database) DeleteMeasures(req proto.DeleteMeasuresReq) uint16 { + resultCh := make(chan tryDeleteMeasuresResult, 1) + + s.appendJobToWorkerQueue(tryDeleteMeasuresReq{ + MetricID: req.MetricID, + Since: req.Since, + ResultCh: resultCh, + }) + + result := <-resultCh + + switch result.ResultCode { + case Succeed: + var ( + freeDataPages []uint32 + freeIndexPages []uint32 + ) + if result.RootPageNo > 0 { + pageLists, err := s.atree.GetAllPages(result.RootPageNo) + if err != nil { + diploma.Abort(diploma.FailedAtreeRequest, err) + } + freeDataPages = pageLists.DataPages + freeIndexPages = pageLists.IndexPages + } + waitCh := s.txlog.WriteDeletedMeasures(txlog.DeletedMeasures{ + MetricID: req.MetricID, + FreeDataPages: freeDataPages, + FreeIndexPages: freeIndexPages, + }) + <-waitCh + + case NoMetric: + return proto.ErrNoMetric + + default: + diploma.Abort(diploma.WrongResultCodeBug, ErrWrongResultCodeBug) + } + return 0 +} + +// SELECT + +type instantMeasuresResult struct { + ResultCode byte + FracDigits byte + PageNo uint32 +} + +func (s *Database) ListAllInstantMeasures(conn net.Conn, req proto.ListAllInstantMetricMeasuresReq) error { + resultCh := make(chan instantMeasuresResult, 1) + + responseWriter := atree.NewInstantMeasureWriter(conn) + + s.appendJobToWorkerQueue(tryListAllInstantMeasuresReq{ + MetricID: req.MetricID, + ResponseWriter: responseWriter, + ResultCh: resultCh, + }) + + result := <-resultCh + + switch result.ResultCode { + case QueryDone: + responseWriter.Close() + + case UntilFound: + err := s.atree.IterateAllInstantByTreeCursor(atree.IterateAllInstantByTreeCursorReq{ + FracDigits: result.FracDigits, + PageNo: result.PageNo, + ResponseWriter: responseWriter, + }) + s.metricRUnlock(req.MetricID) + + if err != nil { + reply(conn, proto.ErrUnexpected) + } else { + responseWriter.Close() + } + + case NoMetric: + reply(conn, proto.ErrNoMetric) + + case WrongMetricType: + reply(conn, proto.ErrWrongMetricType) + + default: + diploma.Abort(diploma.WrongResultCodeBug, ErrWrongResultCodeBug) + } + return nil +} + +func (s *Database) ListAllCumulativeMeasures(conn io.Writer, req proto.ListAllCumulativeMeasuresReq) error { + resultCh := make(chan cumulativeMeasuresResult, 1) + + responseWriter := atree.NewCumulativeMeasureWriter(conn) + + s.appendJobToWorkerQueue(tryListAllCumulativeMeasuresReq{ + MetricID: req.MetricID, + ResponseWriter: responseWriter, + ResultCh: resultCh, + }) + + result := <-resultCh + + switch result.ResultCode { + case QueryDone: + responseWriter.Close() + + case UntilFound: + err := s.atree.IterateAllCumulativeByTreeCursor(atree.IterateAllCumulativeByTreeCursorReq{ + FracDigits: result.FracDigits, + PageNo: result.PageNo, + EndTimestamp: result.EndTimestamp, + EndValue: result.EndValue, + ResponseWriter: responseWriter, + }) + s.metricRUnlock(req.MetricID) + + if err != nil { + reply(conn, proto.ErrUnexpected) + } else { + responseWriter.Close() + } + + case NoMetric: + reply(conn, proto.ErrNoMetric) + + case WrongMetricType: + reply(conn, proto.ErrWrongMetricType) + + default: + diploma.Abort(diploma.WrongResultCodeBug, ErrWrongResultCodeBug) + } + return nil +} + +func (s *Database) ListInstantMeasures(conn net.Conn, req proto.ListInstantMeasuresReq) error { + if req.Since > req.Until { + reply(conn, proto.ErrInvalidRange) + return nil + } + + var since, until uint32 + if req.FirstHourOfDay > 0 { + since, until = correctToFHD(req.Since, req.Until, req.FirstHourOfDay) + } else { + since = req.Since + until = req.Until + } + + resultCh := make(chan instantMeasuresResult, 1) + responseWriter := atree.NewInstantMeasureWriter(conn) + + s.appendJobToWorkerQueue(tryListInstantMeasuresReq{ + MetricID: req.MetricID, + Since: since, + Until: until, + ResponseWriter: responseWriter, + ResultCh: resultCh, + }) + + result := <-resultCh + + switch result.ResultCode { + case QueryDone: + responseWriter.Close() + + case UntilFound: + err := s.atree.ContinueIterateInstantByTreeCursor(atree.ContinueIterateInstantByTreeCursorReq{ + FracDigits: result.FracDigits, + Since: since, + Until: until, + LastPageNo: result.PageNo, + ResponseWriter: responseWriter, + }) + s.metricRUnlock(req.MetricID) + if err != nil { + reply(conn, proto.ErrUnexpected) + } else { + responseWriter.Close() + } + + case UntilNotFound: + err := s.atree.FindAndIterateInstantByTreeCursor(atree.FindAndIterateInstantByTreeCursorReq{ + FracDigits: result.FracDigits, + Since: since, + Until: until, + RootPageNo: result.PageNo, + ResponseWriter: responseWriter, + }) + s.metricRUnlock(req.MetricID) + if err != nil { + reply(conn, proto.ErrUnexpected) + } else { + responseWriter.Close() + } + + case NoMetric: + reply(conn, proto.ErrNoMetric) + + case WrongMetricType: + reply(conn, proto.ErrWrongMetricType) + + default: + diploma.Abort(diploma.WrongResultCodeBug, ErrWrongResultCodeBug) + } + return nil +} + +type cumulativeMeasuresResult struct { + ResultCode byte + FracDigits byte + PageNo uint32 + EndTimestamp uint32 + EndValue float64 +} + +func (s *Database) ListCumulativeMeasures(conn net.Conn, req proto.ListCumulativeMeasuresReq) error { + resultCh := make(chan cumulativeMeasuresResult, 1) + responseWriter := atree.NewCumulativeMeasureWriter(conn) + + s.appendJobToWorkerQueue(tryListCumulativeMeasuresReq{ + MetricID: req.MetricID, + Since: req.Since, + Until: req.Until, + ResponseWriter: responseWriter, + ResultCh: resultCh, + }) + + result := <-resultCh + + switch result.ResultCode { + case QueryDone: + responseWriter.Close() + + case UntilFound: + err := s.atree.ContinueIterateCumulativeByTreeCursor(atree.ContinueIterateCumulativeByTreeCursorReq{ + FracDigits: result.FracDigits, + Since: req.Since, + Until: req.Until, + LastPageNo: result.PageNo, + EndTimestamp: result.EndTimestamp, + EndValue: result.EndValue, + ResponseWriter: responseWriter, + }) + s.metricRUnlock(req.MetricID) + if err != nil { + reply(conn, proto.ErrUnexpected) + } else { + responseWriter.Close() + } + + case UntilNotFound: + err := s.atree.FindAndIterateCumulativeByTreeCursor(atree.FindAndIterateCumulativeByTreeCursorReq{ + FracDigits: result.FracDigits, + Since: req.Since, + Until: req.Until, + RootPageNo: result.PageNo, + ResponseWriter: responseWriter, + }) + s.metricRUnlock(req.MetricID) + if err != nil { + reply(conn, proto.ErrUnexpected) + } else { + responseWriter.Close() + } + + case NoMetric: + reply(conn, proto.ErrNoMetric) + + case WrongMetricType: + reply(conn, proto.ErrWrongMetricType) + + default: + diploma.Abort(diploma.WrongResultCodeBug, ErrWrongResultCodeBug) + } + return nil +} + +type instantPeriodsResult struct { + ResultCode byte + FracDigits byte + PageNo uint32 +} + +func (s *Database) ListInstantPeriods(conn net.Conn, req proto.ListInstantPeriodsReq) error { + var ( + since = req.Since + until = req.Until + ) + if req.FirstHourOfDay > 0 { + since, until = correctToFHD(since, until, req.FirstHourOfDay) + } + + if req.LastDayOfMonth > 0 { + // fix + } + + resultCh := make(chan instantPeriodsResult, 1) + + aggregator, err := atree.NewInstantAggregator(atree.InstantAggregatorOptions{ + GroupBy: req.GroupBy, + FirstHourOfDay: req.FirstHourOfDay, + LastDayOfMonth: req.LastDayOfMonth, + }) + if err != nil { + reply(conn, proto.ErrUnexpected) + return nil + } + + responseWriter := atree.NewInstantPeriodsWriter(conn, req.AggregateFuncs) + + s.appendJobToWorkerQueue(tryListInstantPeriodsReq{ + MetricID: req.MetricID, + Since: req.Since, + Until: req.Until, + Aggregator: aggregator, + ResponseWriter: responseWriter, + ResultCh: resultCh, + }) + + result := <-resultCh + + switch result.ResultCode { + case QueryDone: + responseWriter.Close() + + case UntilFound: + err := s.atree.ContinueCollectInstantPeriods(atree.ContinueCollectInstantPeriodsReq{ + FracDigits: result.FracDigits, + Aggregator: aggregator, + ResponseWriter: responseWriter, + LastPageNo: result.PageNo, + Since: req.Since, + Until: req.Until, + }) + s.metricRUnlock(req.MetricID) + + if err != nil { + reply(conn, proto.ErrUnexpected) + } else { + responseWriter.Close() + } + + case UntilNotFound: + err := s.atree.FindInstantPeriods(atree.FindInstantPeriodsReq{ + FracDigits: result.FracDigits, + ResponseWriter: responseWriter, + RootPageNo: result.PageNo, + Since: req.Since, + Until: req.Until, + GroupBy: req.GroupBy, + FirstHourOfDay: req.FirstHourOfDay, + LastDayOfMonth: req.LastDayOfMonth, + }) + s.metricRUnlock(req.MetricID) + + if err != nil { + reply(conn, proto.ErrUnexpected) + } else { + responseWriter.Close() + } + + case NoMetric: + reply(conn, proto.ErrNoMetric) + + case WrongMetricType: + reply(conn, proto.ErrWrongMetricType) + + default: + diploma.Abort(diploma.WrongResultCodeBug, ErrWrongResultCodeBug) + } + return nil +} + +type cumulativePeriodsResult struct { + ResultCode byte + FracDigits byte + PageNo uint32 +} + +func (s *Database) ListCumulativePeriods(conn net.Conn, req proto.ListCumulativePeriodsReq) error { + resultCh := make(chan cumulativePeriodsResult, 1) + + aggregator, err := atree.NewCumulativeAggregator(atree.CumulativeAggregatorOptions{ + GroupBy: req.GroupBy, + FirstHourOfDay: req.FirstHourOfDay, + LastDayOfMonth: req.LastDayOfMonth, + }) + if err != nil { + reply(conn, proto.ErrUnexpected) + return nil + } + + responseWriter := atree.NewCumulativePeriodsWriter(conn) + + s.appendJobToWorkerQueue(tryListCumulativePeriodsReq{ + MetricID: req.MetricID, + Since: req.Since, + Until: req.Until, + Aggregator: aggregator, + ResponseWriter: responseWriter, + ResultCh: resultCh, + }) + + result := <-resultCh + + switch result.ResultCode { + case QueryDone: + responseWriter.Close() + + case UntilFound: + err := s.atree.ContinueCollectCumulativePeriods(atree.ContinueCollectCumulativePeriodsReq{ + FracDigits: result.FracDigits, + Aggregator: aggregator, + ResponseWriter: responseWriter, + LastPageNo: result.PageNo, + Since: req.Since, + Until: req.Until, + }) + s.metricRUnlock(req.MetricID) + + if err != nil { + reply(conn, proto.ErrUnexpected) + } else { + responseWriter.Close() + } + + case UntilNotFound: + err := s.atree.FindCumulativePeriods(atree.FindCumulativePeriodsReq{ + FracDigits: result.FracDigits, + ResponseWriter: responseWriter, + RootPageNo: result.PageNo, + Since: req.Since, + Until: req.Until, + GroupBy: req.GroupBy, + FirstHourOfDay: req.FirstHourOfDay, + LastDayOfMonth: req.LastDayOfMonth, + }) + s.metricRUnlock(req.MetricID) + + if err != nil { + reply(conn, proto.ErrUnexpected) + } else { + responseWriter.Close() + } + + case NoMetric: + reply(conn, proto.ErrNoMetric) + + case WrongMetricType: + reply(conn, proto.ErrWrongMetricType) + + default: + diploma.Abort(diploma.WrongResultCodeBug, ErrWrongResultCodeBug) + } + return nil +} + +func (s *Database) ListCurrentValues(conn net.Conn, req proto.ListCurrentValuesReq) error { + responseWriter := atree.NewCurrentValueWriter(conn) + defer responseWriter.Close() + + resultCh := make(chan struct{}) + + s.appendJobToWorkerQueue(tryListCurrentValuesReq{ + MetricIDs: req.MetricIDs, + ResponseWriter: responseWriter, + ResultCh: resultCh, + }) + + <-resultCh + return nil +} diff --git a/database/database.go b/database/database.go new file mode 100644 index 0000000..fedbf09 --- /dev/null +++ b/database/database.go @@ -0,0 +1,460 @@ +package database + +import ( + "errors" + "fmt" + "hash/crc32" + "io" + "log" + "net" + "os" + "path/filepath" + "regexp" + "sync" + "time" + + "gordenko.dev/dima/diploma" + "gordenko.dev/dima/diploma/atree" + "gordenko.dev/dima/diploma/atree/redo" + "gordenko.dev/dima/diploma/bin" + "gordenko.dev/dima/diploma/chunkenc" + "gordenko.dev/dima/diploma/conbuf" + "gordenko.dev/dima/diploma/freelist" + "gordenko.dev/dima/diploma/recovery" + "gordenko.dev/dima/diploma/txlog" +) + +func JoinSnapshotFileName(dir string, logNumber int) string { + return filepath.Join(dir, fmt.Sprintf("%d.snapshot", logNumber)) +} + +type metricLockEntry struct { + XLock bool + RLocks int + WaitQueue []any +} + +type Database struct { + mutex sync.Mutex + workerSignalCh chan struct{} + workerQueue []any + rLocksToRelease []uint32 + metrics map[uint32]*_metric + metricLockEntries map[uint32]*metricLockEntry + dataFreeList *freelist.FreeList + indexFreeList *freelist.FreeList + dir string + databaseName string + redoDir string + txlog *txlog.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 + RedoDir 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.RedoDir == "" { + return nil, errors.New("RedoDir 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{ + workerSignalCh: make(chan struct{}, 1), + dir: opt.Dir, + databaseName: opt.DatabaseName, + redoDir: opt.RedoDir, + metrics: make(map[uint32]*_metric), + metricLockEntries: make(map[uint32]*metricLockEntry), + dataFreeList: freelist.New(), + indexFreeList: freelist.New(), + tcpPort: opt.TCPPort, + logfile: opt.Logfile, + logger: log.New(opt.Logfile, "", log.LstdFlags), + exitCh: opt.ExitCh, + waitGroup: opt.WaitGroup, + } + 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.atree, err = atree.New(atree.Options{ + Dir: s.dir, + DatabaseName: s.databaseName, + RedoDir: s.redoDir, + DataFreeList: s.dataFreeList, + IndexFreeList: s.indexFreeList, + }) + if err != nil { + return fmt.Errorf("atree.New: %s", err) + } + s.atree.Run() + + go s.worker() + + s.recovery() + + 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) + } + } +} + +func (s *Database) recovery() { + advisor, err := recovery.NewRecoveryAdvisor(recovery.RecoveryAdvisorOptions{ + Dir: s.dir, + VerifySnapshot: s.verifySnapshot, + }) + if err != nil { + panic(err) + } + + recipe, err := advisor.GetRecipe() + if err != nil { + diploma.Abort(diploma.GetRecoveryRecipeFailed, err) + } + + var logNumber int + + if recipe != nil { + if recipe.Snapshot != "" { + err = s.loadSnapshot(recipe.Snapshot) + if err != nil { + diploma.Abort(diploma.LoadSnapshotFailed, err) + } + } + for _, changesFileName := range recipe.Changes { + err = s.replayChanges(changesFileName) + if err != nil { + diploma.Abort(diploma.ReplayChangesFailed, err) + } + } + logNumber = recipe.LogNumber + } + + s.txlog, err = txlog.NewWriter(txlog.WriterOptions{ + Dir: s.dir, + LogNumber: logNumber, + AppendToWorkerQueue: s.appendJobToWorkerQueue, + ExitCh: s.exitCh, + WaitGroup: s.waitGroup, + }) + if err != nil { + diploma.Abort(diploma.CreateChangesWriterFailed, err) + + } + go s.txlog.Run() + + fileNames, err := s.searchREDOFiles() + if err != nil { + diploma.Abort(diploma.SearchREDOFilesFailed, err) + } + + if len(fileNames) > 0 { + for _, fileName := range fileNames { + err = s.replayREDOFile(fileName) + if err != nil { + diploma.Abort(diploma.ReplayREDOFileFailed, err) + } + } + + for _, fileName := range fileNames { + err = os.Remove(fileName) + if err != nil { + diploma.Abort(diploma.RemoveREDOFileFailed, err) + } + } + } + + if recipe != nil { + if recipe.CompleteSnapshot { + err = s.dumpSnapshot(logNumber) + if err != nil { + diploma.Abort(diploma.DumpSnapshotFailed, err) + } + } + + for _, fileName := range recipe.ToDelete { + err = os.Remove(fileName) + if err != nil { + diploma.Abort(diploma.RemoveRecipeFileFailed, err) + } + } + } +} + +func (s *Database) searchREDOFiles() ([]string, error) { + var ( + reREDO = regexp.MustCompile(`a\d+\.redo`) + fileNames []string + ) + + entries, err := os.ReadDir(s.redoDir) + if err != nil { + return nil, err + } + + for _, entry := range entries { + if entry.Type().IsRegular() { + baseName := entry.Name() + if reREDO.MatchString(baseName) { + fileNames = append(fileNames, filepath.Join(s.redoDir, baseName)) + } + } + } + return fileNames, nil +} + +func (s *Database) replayREDOFile(fileName string) error { + redoFile, err := redo.ReadREDOFile(redo.ReadREDOFileReq{ + FileName: fileName, + DataPageSize: atree.DataPageSize, + IndexPageSize: atree.IndexPageSize, + }) + if err != nil { + return fmt.Errorf("can't read REDO file %s: %s", fileName, err) + } + + metric, ok := s.metrics[redoFile.MetricID] + if !ok { + return fmt.Errorf("has REDOFile, metric %d not found", redoFile.MetricID) + } + + if metric.Until < redoFile.Timestamp { + waitCh := make(chan struct{}) + s.atree.ApplyREDO(atree.WriteTask{ + DataPage: redoFile.DataPage, + IndexPages: redoFile.IndexPages, + }) + <-waitCh + + waitCh = s.txlog.WriteAppendedMeasureWithOverflow( + txlog.AppendedMeasureWithOverflow{ + MetricID: redoFile.MetricID, + Timestamp: redoFile.Timestamp, + Value: redoFile.Value, + IsDataPageReused: redoFile.IsDataPageReused, + DataPageNo: redoFile.DataPage.PageNo, + IsRootChanged: redoFile.IsRootChanged, + RootPageNo: redoFile.RootPageNo, + ReusedIndexPages: redoFile.ReusedIndexPages, + }, + fileName, + false, + ) + <-waitCh + } + 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 +} + +func (s *Database) replayChanges(fileName string) error { + walReader, err := txlog.NewReader(txlog.ReaderOptions{ + FileName: fileName, + BufferSize: 1024 * 1024, + }) + if err != nil { + return err + } + + for { + lsn, records, done, err := walReader.ReadPacket() + if err != nil { + return err + } + _ = lsn + + if done { + return nil + } + + for _, record := range records { + if err = s.replayChangesRecord(record); err != nil { + return err + } + } + } +} + +func (s *Database) replayChangesRecord(untyped any) error { + switch rec := untyped.(type) { + case txlog.AddedMetric: + var ( + values diploma.ValueCompressor + timestampsBuf = conbuf.New(nil) + valuesBuf = conbuf.New(nil) + ) + + if rec.MetricType == diploma.Cumulative { + values = chunkenc.NewReverseCumulativeDeltaCompressor( + valuesBuf, 0, byte(rec.FracDigits)) + } else { + values = chunkenc.NewReverseInstantDeltaCompressor( + valuesBuf, 0, byte(rec.FracDigits)) + } + + s.metrics[rec.MetricID] = &_metric{ + MetricType: rec.MetricType, + FracDigits: byte(rec.FracDigits), + TimestampsBuf: timestampsBuf, + ValuesBuf: valuesBuf, + Timestamps: chunkenc.NewReverseTimeDeltaOfDeltaCompressor(timestampsBuf, 0), + Values: values, + } + + case txlog.DeletedMetric: + delete(s.metrics, rec.MetricID) + if len(rec.FreeDataPages) > 0 { + s.dataFreeList.AddPages(rec.FreeDataPages) + } + if len(rec.FreeIndexPages) > 0 { + s.indexFreeList.AddPages(rec.FreeIndexPages) + } + + case txlog.AppendedMeasure: + metric, ok := s.metrics[rec.MetricID] + if ok { + metric.Timestamps.Append(rec.Timestamp) + metric.Values.Append(rec.Value) + + if metric.Since == 0 { + metric.Since = rec.Timestamp + metric.SinceValue = rec.Value + } + + metric.Until = rec.Timestamp + metric.UntilValue = rec.Value + } + + case txlog.AppendedMeasures: + metric, ok := s.metrics[rec.MetricID] + if ok { + for _, measure := range rec.Measures { + metric.Timestamps.Append(measure.Timestamp) + metric.Values.Append(measure.Value) + + if metric.Since == 0 { + metric.Since = measure.Timestamp + metric.SinceValue = measure.Value + } + + metric.Until = measure.Timestamp + metric.UntilValue = measure.Value + } + } + + case txlog.AppendedMeasureWithOverflow: + metric, ok := s.metrics[rec.MetricID] + if ok { + metric.ReinitBy(rec.Timestamp, rec.Value) + if rec.IsRootChanged { + metric.RootPageNo = rec.RootPageNo + } + metric.LastPageNo = rec.DataPageNo + // delete free pages + if rec.IsDataPageReused { + s.dataFreeList.DeletePages([]uint32{ + rec.DataPageNo, + }) + } + if len(rec.ReusedIndexPages) > 0 { + s.indexFreeList.DeletePages(rec.ReusedIndexPages) + } + } + + case txlog.DeletedMeasures: + metric, ok := s.metrics[rec.MetricID] + if ok { + metric.DeleteMeasures() + if len(rec.FreeDataPages) > 0 { + s.dataFreeList.AddPages(rec.FreeDataPages) + } + if len(rec.FreeDataPages) > 0 { + s.indexFreeList.AddPages(rec.FreeIndexPages) + } + } + + default: + diploma.Abort(diploma.UnknownTxLogRecordTypeBug, + fmt.Errorf("bug: unknown record type %T in TransactionLog", rec)) + } + return nil +} diff --git a/database/helpers.go b/database/helpers.go new file mode 100644 index 0000000..8fbcf89 --- /dev/null +++ b/database/helpers.go @@ -0,0 +1,50 @@ +package database + +import ( + "errors" + "io/fs" + "os" + "time" +) + +func isFileExist(fileName string) (bool, error) { + _, err := os.Stat(fileName) + if err != nil { + if errors.Is(err, fs.ErrNotExist) { + return false, nil + } else { + return false, err + } + } else { + return true, nil + } +} + +func (s *Database) appendJobToWorkerQueue(job any) { + s.mutex.Lock() + s.workerQueue = append(s.workerQueue, job) + s.mutex.Unlock() + + select { + case s.workerSignalCh <- struct{}{}: + default: + } +} + +func (s *Database) metricRUnlock(metricID uint32) { + s.mutex.Lock() + s.rLocksToRelease = append(s.rLocksToRelease, metricID) + s.mutex.Unlock() + + select { + case s.workerSignalCh <- struct{}{}: + default: + } +} + +func correctToFHD(since, until uint32, firstHourOfDay int) (uint32, uint32) { + duration := time.Duration(firstHourOfDay) * time.Hour + since = uint32(time.Unix(int64(since), 0).Add(duration).Unix()) + until = uint32(time.Unix(int64(until), 0).Add(duration).Unix()) + return since, until +} diff --git a/database/metric.go b/database/metric.go new file mode 100644 index 0000000..2b4293a --- /dev/null +++ b/database/metric.go @@ -0,0 +1,71 @@ +package database + +import ( + octopus "gordenko.dev/dima/diploma" + "gordenko.dev/dima/diploma/chunkenc" + "gordenko.dev/dima/diploma/conbuf" +) + +// METRIC + +type _metric struct { + MetricType octopus.MetricType + FracDigits byte + RootPageNo uint32 + LastPageNo uint32 + SinceValue float64 + Since uint32 + UntilValue float64 + Until uint32 + TimestampsBuf *conbuf.ContinuousBuffer + ValuesBuf *conbuf.ContinuousBuffer + Timestamps octopus.TimestampCompressor + Values octopus.ValueCompressor +} + +func (s *_metric) ReinitBy(timestamp uint32, value float64) { + s.TimestampsBuf = conbuf.New(nil) + s.ValuesBuf = conbuf.New(nil) + // + s.Timestamps = chunkenc.NewReverseTimeDeltaOfDeltaCompressor( + s.TimestampsBuf, 0) + + if s.MetricType == octopus.Cumulative { + s.Values = chunkenc.NewReverseCumulativeDeltaCompressor( + s.ValuesBuf, 0, s.FracDigits) + } else { + s.Values = chunkenc.NewReverseInstantDeltaCompressor( + s.ValuesBuf, 0, s.FracDigits) + } + + s.Timestamps.Append(timestamp) + s.Values.Append(value) + + s.Since = timestamp + s.SinceValue = value + s.Until = timestamp + s.UntilValue = value +} + +func (s *_metric) DeleteMeasures() { + s.TimestampsBuf = conbuf.New(nil) + s.ValuesBuf = conbuf.New(nil) + // + s.Timestamps = chunkenc.NewReverseTimeDeltaOfDeltaCompressor( + s.TimestampsBuf, 0) + + if s.MetricType == octopus.Cumulative { + s.Values = chunkenc.NewReverseCumulativeDeltaCompressor( + s.ValuesBuf, 0, s.FracDigits) + } else { + s.Values = chunkenc.NewReverseInstantDeltaCompressor( + s.ValuesBuf, 0, s.FracDigits) + } + + s.RootPageNo = 0 + s.LastPageNo = 0 + s.Since = 0 + s.SinceValue = 0 + s.Until = 0 + s.UntilValue = 0 +} diff --git a/database/proc.go b/database/proc.go new file mode 100644 index 0000000..5d7e330 --- /dev/null +++ b/database/proc.go @@ -0,0 +1,1736 @@ +package database + +import ( + "fmt" + + "gordenko.dev/dima/diploma" + "gordenko.dev/dima/diploma/atree" + "gordenko.dev/dima/diploma/chunkenc" + "gordenko.dev/dima/diploma/conbuf" + "gordenko.dev/dima/diploma/enc" + "gordenko.dev/dima/diploma/txlog" +) + +const ( + QueryDone = 1 + UntilFound = 2 + UntilNotFound = 3 + NoMetric = 4 + MetricDuplicate = 5 + Succeed = 6 + NewPage = 7 + ExpiredMeasure = 8 + NonMonotonicValue = 9 + CanAppend = 10 + WrongMetricType = 11 +) + +func (s *Database) worker() { + for { + select { + case <-s.workerSignalCh: + s.DoWork() + } + } +} + +func (s *Database) DoWork() { + s.mutex.Lock() + rLocksToRelease := s.rLocksToRelease + workerQueue := s.workerQueue + s.rLocksToRelease = nil + s.workerQueue = nil + s.mutex.Unlock() + + for _, metricID := range rLocksToRelease { + lockEntry, ok := s.metricLockEntries[metricID] + if !ok { + diploma.Abort(diploma.NoLockEntryBug, + fmt.Errorf("drainQueues: lockEntry not found for the metric %d", + metricID)) + } + + if lockEntry.XLock { + diploma.Abort(diploma.XLockBug, + fmt.Errorf("drainQueues: xlock is set for the metric %d", + metricID)) + } + + if lockEntry.RLocks <= 0 { + diploma.Abort(diploma.NoRLockBug, + fmt.Errorf("drainQueues: rlock not set for the metric %d", + metricID)) + } + + lockEntry.RLocks-- + + if len(lockEntry.WaitQueue) > 0 { + metric, ok := s.metrics[metricID] + if !ok { + diploma.Abort(diploma.NoMetricBug, + fmt.Errorf("drainQueues: metric %d not found", metricID)) + } + s.processMetricQueue(metricID, metric, lockEntry) + } else { + if lockEntry.RLocks == 0 { + delete(s.metricLockEntries, metricID) + } + } + } + + for _, untyped := range workerQueue { + switch req := untyped.(type) { + case tryAppendMeasureReq: + s.tryAppendMeasure(req) + + case tryAppendMeasuresReq: + s.tryAppendMeasures(req) + + case txlog.Changes: + s.applyChanges(req) // all metrics only + + case tryListCurrentValuesReq: + s.tryListCurrentValues(req) // all metrics only + + case tryListCumulativePeriodsReq: + s.tryListCumulativePeriods(req) + + case tryListInstantPeriodsReq: + s.tryListInstantPeriods(req) + + case tryListCumulativeMeasuresReq: + s.tryListCumulativeMeasures(req) + + case tryListInstantMeasuresReq: + s.tryListInstantMeasures(req) + + case tryListAllInstantMeasuresReq: + s.tryListAllInstantMeasures(req) + + case tryListAllCumulativeMeasuresReq: + s.tryListAllCumulativeMeasures(req) + + case tryAddMetricReq: + s.tryAddMetric(req) + + case tryDeleteMetricReq: + s.tryDeleteMetric(req) + + case tryDeleteMeasuresReq: + s.tryDeleteMeasures(req) + + case tryGetMetricReq: + s.tryGetMetric(req) + + default: + diploma.Abort(diploma.UnknownWorkerQueueItemBug, + fmt.Errorf("bug: unknown worker queue item type %T", req)) + } + } +} + +func (s *Database) processMetricQueue(metricID uint32, metric *_metric, lockEntry *metricLockEntry) { + if len(lockEntry.WaitQueue) == 0 { + return + } + + var modificationReqs []any + + for _, untyped := range lockEntry.WaitQueue { + var rLockRequired bool + switch req := untyped.(type) { + case tryListCumulativePeriodsReq: + rLockRequired = s.startListCumulativePeriods(metric, req) + + case tryListInstantPeriodsReq: + rLockRequired = s.startListInstantPeriods(metric, req) + + case tryListCumulativeMeasuresReq: + rLockRequired = s.startListCumulativeMeasures(metric, req) + + case tryListInstantMeasuresReq: + rLockRequired = s.startListInstantMeasures(metric, req) + + case tryListAllInstantMeasuresReq: + rLockRequired = s.startListAllInstantMeasures(metric, req) + + case tryListAllCumulativeMeasuresReq: + rLockRequired = s.startListAllCumulativeMeasures(metric, req) + + case tryGetMetricReq: + s.tryGetMetric(req) + + default: + modificationReqs = append(modificationReqs, untyped) + } + + if rLockRequired { + lockEntry.RLocks++ + } + } + + lockEntry.WaitQueue = nil + + if lockEntry.RLocks > 0 { + lockEntry.WaitQueue = modificationReqs + } else { + for idx, untyped := range modificationReqs { + switch req := untyped.(type) { + case tryAppendMeasureReq: + s.startAppendMeasure(metric, req, nil) + + case tryAppendMeasuresReq: + s.startAppendMeasures(metric, req, nil) + + case tryDeleteMetricReq: + s.startDeleteMetric(metric, req) + + case tryDeleteMeasuresReq: + s.startDeleteMeasures(metric, req) + + default: + diploma.Abort(diploma.UnknownMetricWaitQueueItemBug, + fmt.Errorf("bug: unknown metric wait queue item type %T", req)) + } + + lockEntry, ok := s.metricLockEntries[metricID] + if ok { + start := idx + 1 + if start < len(modificationReqs) { + lockEntry.WaitQueue = append(lockEntry.WaitQueue, modificationReqs[start:]...) + } + break + } + } + } +} + +type tryAddMetricReq struct { + MetricID uint32 + ResultCh chan byte +} + +func (s *Database) tryAddMetric(req tryAddMetricReq) { + _, ok := s.metrics[req.MetricID] + if ok { + req.ResultCh <- MetricDuplicate + return + } + + lockEntry, ok := s.metricLockEntries[req.MetricID] + if ok { + lockEntry.WaitQueue = append(lockEntry.WaitQueue, req) + } else { + s.metricLockEntries[req.MetricID] = &metricLockEntry{ + XLock: true, + } + req.ResultCh <- Succeed + } +} + +func (s *Database) processTryAddMetricReqsImmediatelyAfterDelete(reqs []tryAddMetricReq) { + if len(reqs) == 0 { + return + } + var ( + req = reqs[0] + waitQueue []any + ) + if len(reqs) > 1 { + for _, req := range reqs[1:] { + waitQueue = append(waitQueue, req) + } + } + s.metricLockEntries[req.MetricID] = &metricLockEntry{ + XLock: true, + WaitQueue: waitQueue, + } + req.ResultCh <- Succeed +} + +type tryGetMetricReq struct { + MetricID uint32 + ResultCh chan Metric +} + +func (s *Database) tryGetMetric(req tryGetMetricReq) { + metric, ok := s.metrics[req.MetricID] + if ok { + req.ResultCh <- Metric{ + ResultCode: Succeed, + MetricType: metric.MetricType, + FracDigits: metric.FracDigits, + } + } else { + req.ResultCh <- Metric{ + ResultCode: NoMetric, + } + } +} + +type tryDeleteMetricReq struct { + MetricID uint32 + ResultCh chan tryDeleteMetricResult +} + +func (s *Database) tryDeleteMetric(req tryDeleteMetricReq) { + metric, ok := s.metrics[req.MetricID] + if !ok { + req.ResultCh <- tryDeleteMetricResult{ + ResultCode: NoMetric, + } + return + } + + lockEntry, ok := s.metricLockEntries[req.MetricID] + if ok { + lockEntry.WaitQueue = append(lockEntry.WaitQueue, req) + } else { + s.startDeleteMetric(metric, req) + } +} + +func (s *Database) startDeleteMetric(metric *_metric, req tryDeleteMetricReq) { + s.metricLockEntries[req.MetricID] = &metricLockEntry{ + XLock: true, + } + req.ResultCh <- tryDeleteMetricResult{ + ResultCode: Succeed, + RootPageNo: metric.RootPageNo, + } +} + +type tryDeleteMeasuresReq struct { + MetricID uint32 + Since uint32 + ResultCh chan tryDeleteMeasuresResult +} + +func (s *Database) tryDeleteMeasures(req tryDeleteMeasuresReq) { + metric, ok := s.metrics[req.MetricID] + if !ok { + req.ResultCh <- tryDeleteMeasuresResult{ + ResultCode: NoMetric, + } + return + } + + lockEntry, ok := s.metricLockEntries[req.MetricID] + if ok { + lockEntry.WaitQueue = append(lockEntry.WaitQueue, req) + } else { + s.startDeleteMeasures(metric, req) + } +} + +func (s *Database) startDeleteMeasures(metric *_metric, req tryDeleteMeasuresReq) { + s.metricLockEntries[req.MetricID] = &metricLockEntry{ + XLock: true, + } + req.ResultCh <- tryDeleteMeasuresResult{ + ResultCode: Succeed, + RootPageNo: metric.RootPageNo, + } +} + +// SELECT + +type tryListAllInstantMeasuresReq struct { + MetricID uint32 + ResponseWriter *atree.InstantMeasureWriter + ResultCh chan instantMeasuresResult +} + +func (s *Database) tryListAllInstantMeasures(req tryListAllInstantMeasuresReq) { + metric, ok := s.metrics[req.MetricID] + if !ok { + req.ResultCh <- instantMeasuresResult{ + ResultCode: NoMetric, + } + return + } + + if metric.MetricType != diploma.Instant { + req.ResultCh <- instantMeasuresResult{ + ResultCode: WrongMetricType, + } + return + } + + lockEntry, ok := s.metricLockEntries[req.MetricID] + if ok { + if lockEntry.XLock { + lockEntry.WaitQueue = append(lockEntry.WaitQueue, req) + return + } + } + + if s.startListAllInstantMeasures(metric, req) { + if lockEntry != nil { + lockEntry.RLocks++ + } else { + s.metricLockEntries[req.MetricID] = &metricLockEntry{ + RLocks: 1, + } + } + } +} + +func (s *Database) startListAllInstantMeasures(metric *_metric, req tryListAllInstantMeasuresReq) bool { + if metric.Since == 0 { + req.ResultCh <- instantMeasuresResult{ + ResultCode: QueryDone, + } + return false + } + + timestampDecompressor := chunkenc.NewReverseTimeDeltaOfDeltaDecompressor( + metric.TimestampsBuf, + metric.Timestamps.Size(), + ) + + valueDecompressor := chunkenc.NewReverseInstantDeltaDecompressor( + metric.ValuesBuf, + metric.Values.Size(), + metric.FracDigits, + ) + + var ( + value float64 + timestamp uint32 + done bool + + buffered int + ) + + for { + timestamp, done = timestampDecompressor.NextValue() + if done { + break + } + + value, done = valueDecompressor.NextValue() + if done { + diploma.Abort(diploma.HasTimestampNoValueBug, ErrNoValueBug) + } + + req.ResponseWriter.BufferMeasure(atree.InstantMeasure{ + Timestamp: timestamp, + Value: value, + }) + + buffered++ + } + + if metric.LastPageNo > 0 { + req.ResultCh <- instantMeasuresResult{ + ResultCode: UntilFound, + PageNo: metric.LastPageNo, + FracDigits: metric.FracDigits, + } + return true + } else { + req.ResultCh <- instantMeasuresResult{ + ResultCode: QueryDone, + } + return false + } +} + +type tryListInstantMeasuresReq struct { + MetricID uint32 + Since uint32 + Until uint32 + ResponseWriter *atree.InstantMeasureWriter + ResultCh chan instantMeasuresResult +} + +func (s *Database) tryListInstantMeasures(req tryListInstantMeasuresReq) { + metric, ok := s.metrics[req.MetricID] + if !ok { + req.ResultCh <- instantMeasuresResult{ + ResultCode: NoMetric, + } + return + } + + if metric.MetricType != diploma.Instant { + req.ResultCh <- instantMeasuresResult{ + ResultCode: WrongMetricType, + } + return + } + + lockEntry, ok := s.metricLockEntries[req.MetricID] + if ok { + if lockEntry.XLock { + lockEntry.WaitQueue = append(lockEntry.WaitQueue, req) + return + } + } + if s.startListInstantMeasures(metric, req) { + if lockEntry != nil { + lockEntry.RLocks++ + } else { + s.metricLockEntries[req.MetricID] = &metricLockEntry{ + RLocks: 1, + } + } + } +} + +func (s *Database) startListInstantMeasures(metric *_metric, req tryListInstantMeasuresReq) bool { + if metric.Since == 0 { + req.ResultCh <- instantMeasuresResult{ + ResultCode: QueryDone, + } + return false + } + + if req.Since > metric.Until { + req.ResultCh <- instantMeasuresResult{ + ResultCode: QueryDone, + } + return false + } + + if req.Until < metric.Since { + if metric.RootPageNo > 0 { + req.ResultCh <- instantMeasuresResult{ + ResultCode: UntilNotFound, + PageNo: metric.RootPageNo, + FracDigits: metric.FracDigits, + } + return true + } else { + req.ResultCh <- instantMeasuresResult{ + ResultCode: QueryDone, + } + return false + } + } + + timestampDecompressor := chunkenc.NewReverseTimeDeltaOfDeltaDecompressor( + metric.TimestampsBuf, + metric.Timestamps.Size(), + ) + + valueDecompressor := chunkenc.NewReverseInstantDeltaDecompressor( + metric.ValuesBuf, + metric.Values.Size(), + metric.FracDigits, + ) + + var ( + value float64 + timestamp uint32 + done bool + ) + + for { + timestamp, done = timestampDecompressor.NextValue() + if done { + break + } + + value, done = valueDecompressor.NextValue() + if done { + diploma.Abort(diploma.HasTimestampNoValueBug, ErrNoValueBug) + } + + if timestamp <= req.Until { + if timestamp < req.Since { + req.ResultCh <- instantMeasuresResult{ + ResultCode: QueryDone, + } + return false + } + + req.ResponseWriter.BufferMeasure(atree.InstantMeasure{ + Timestamp: timestamp, + Value: value, + }) + + if timestamp == req.Since { + req.ResultCh <- instantMeasuresResult{ + ResultCode: QueryDone, + } + return false + } + } + } + + if metric.LastPageNo > 0 { + req.ResultCh <- instantMeasuresResult{ + ResultCode: UntilFound, + PageNo: metric.LastPageNo, + FracDigits: metric.FracDigits, + } + return true + } else { + req.ResultCh <- instantMeasuresResult{ + ResultCode: QueryDone, + } + return false + } +} + +// CUMULATIVE + +type tryListAllCumulativeMeasuresReq struct { + MetricID uint32 + ResponseWriter *atree.CumulativeMeasureWriter + ResultCh chan cumulativeMeasuresResult +} + +func (s *Database) tryListAllCumulativeMeasures(req tryListAllCumulativeMeasuresReq) { + metric, ok := s.metrics[req.MetricID] + if !ok { + req.ResultCh <- cumulativeMeasuresResult{ + ResultCode: NoMetric, + } + return + } + if metric.MetricType != diploma.Cumulative { + req.ResultCh <- cumulativeMeasuresResult{ + ResultCode: WrongMetricType, + } + return + } + + lockEntry, ok := s.metricLockEntries[req.MetricID] + if ok { + if lockEntry.XLock { + lockEntry.WaitQueue = append(lockEntry.WaitQueue, req) + return + } + } + if s.startListAllCumulativeMeasures(metric, req) { + if lockEntry != nil { + lockEntry.RLocks++ + } else { + s.metricLockEntries[req.MetricID] = &metricLockEntry{ + RLocks: 1, + } + } + } +} + +func (s *Database) startListAllCumulativeMeasures(metric *_metric, req tryListAllCumulativeMeasuresReq) bool { + if metric.Since == 0 { + req.ResultCh <- cumulativeMeasuresResult{ + ResultCode: QueryDone, + } + return false + } + + timestampDecompressor := chunkenc.NewReverseTimeDeltaOfDeltaDecompressor( + metric.TimestampsBuf, + metric.Timestamps.Size(), + ) + + valueDecompressor := chunkenc.NewReverseCumulativeDeltaDecompressor( + metric.ValuesBuf, + metric.Values.Size(), + metric.FracDigits, + ) + + endTimestamp, done := timestampDecompressor.NextValue() + if done { + req.ResultCh <- cumulativeMeasuresResult{ + ResultCode: QueryDone, + } + return false + } + + endValue, done := valueDecompressor.NextValue() + if done { + diploma.Abort(diploma.HasTimestampNoValueBug, ErrNoValueBug) + } + + for { + timestamp, done := timestampDecompressor.NextValue() + if done { + break + } + + value, done := valueDecompressor.NextValue() + if done { + diploma.Abort(diploma.HasTimestampNoValueBug, ErrNoValueBug) + } + + req.ResponseWriter.WriteMeasure(atree.CumulativeMeasure{ + Timestamp: endTimestamp, + Value: endValue, + Total: endValue - value, + }) + endTimestamp = timestamp + endValue = value + } + + if metric.LastPageNo > 0 { + req.ResultCh <- cumulativeMeasuresResult{ + ResultCode: UntilFound, + PageNo: metric.LastPageNo, + FracDigits: metric.FracDigits, + EndTimestamp: endTimestamp, + EndValue: endValue, + } + return true + } else { + req.ResponseWriter.WriteMeasure(atree.CumulativeMeasure{ + Timestamp: endTimestamp, + Value: endValue, + Total: endValue, + }) + req.ResultCh <- cumulativeMeasuresResult{ + ResultCode: QueryDone, + } + return false + } +} + +type tryListCumulativeMeasuresReq struct { + MetricID uint32 + Since uint32 + Until uint32 + ResponseWriter *atree.CumulativeMeasureWriter + ResultCh chan cumulativeMeasuresResult +} + +func (s *Database) tryListCumulativeMeasures(req tryListCumulativeMeasuresReq) { + metric, ok := s.metrics[req.MetricID] + if !ok { + req.ResultCh <- cumulativeMeasuresResult{ + ResultCode: NoMetric, + } + return + } + if metric.MetricType != diploma.Cumulative { + req.ResultCh <- cumulativeMeasuresResult{ + ResultCode: WrongMetricType, + } + return + } + + lockEntry, ok := s.metricLockEntries[req.MetricID] + if ok { + if lockEntry.XLock { + lockEntry.WaitQueue = append(lockEntry.WaitQueue, req) + return + } + } + + if s.startListCumulativeMeasures(metric, req) { + if lockEntry != nil { + lockEntry.RLocks++ + } else { + s.metricLockEntries[req.MetricID] = &metricLockEntry{ + RLocks: 1, + } + } + } +} + +func (s *Database) startListCumulativeMeasures(metric *_metric, req tryListCumulativeMeasuresReq) bool { + if metric.Since == 0 { + req.ResultCh <- cumulativeMeasuresResult{ + ResultCode: QueryDone, + } + return false + } + + if req.Since > metric.Until { + req.ResultCh <- cumulativeMeasuresResult{ + ResultCode: QueryDone, + } + return false + } + + if req.Until < metric.Since { + // search in tree + if metric.RootPageNo > 0 { + req.ResultCh <- cumulativeMeasuresResult{ + ResultCode: UntilNotFound, + PageNo: metric.RootPageNo, + FracDigits: metric.FracDigits, + } + return true + } else { + req.ResultCh <- cumulativeMeasuresResult{ + ResultCode: QueryDone, + } + return false + } + } + + timestampDecompressor := chunkenc.NewReverseTimeDeltaOfDeltaDecompressor( + metric.TimestampsBuf, + metric.Timestamps.Size(), + ) + + valueDecompressor := chunkenc.NewReverseCumulativeDeltaDecompressor( + metric.ValuesBuf, + metric.Values.Size(), + metric.FracDigits, + ) + + var ( + endTimestamp uint32 + endValue float64 + ) + + for { + timestamp, done := timestampDecompressor.NextValue() + if done { + break + } + + value, done := valueDecompressor.NextValue() + if done { + diploma.Abort(diploma.HasTimestampNoValueBug, ErrNoValueBug) + } + + if timestamp > req.Until { + continue + } + + if timestamp < req.Since { + req.ResponseWriter.WriteMeasure(atree.CumulativeMeasure{ + Timestamp: endTimestamp, + Value: endValue, + Total: endValue - value, + }) + req.ResultCh <- cumulativeMeasuresResult{ + ResultCode: QueryDone, + } + return false + } + + if endTimestamp > 0 { + req.ResponseWriter.WriteMeasure(atree.CumulativeMeasure{ + Timestamp: endTimestamp, + Value: endValue, + Total: endValue - value, + }) + } + endTimestamp = timestamp + endValue = value + } + + if metric.LastPageNo > 0 { + req.ResultCh <- cumulativeMeasuresResult{ + ResultCode: UntilFound, + PageNo: metric.LastPageNo, + FracDigits: metric.FracDigits, + EndTimestamp: endTimestamp, + EndValue: endValue, + } + return true + } else { + req.ResponseWriter.WriteMeasure(atree.CumulativeMeasure{ + Timestamp: endTimestamp, + Value: endValue, + Total: endValue, + }) + req.ResultCh <- cumulativeMeasuresResult{ + ResultCode: QueryDone, + } + return false + } +} + +type tryAppendMeasureReq struct { + MetricID uint32 + Timestamp uint32 + Value float64 + ResultCh chan tryAppendMeasureResult +} + +func (s *Database) tryAppendMeasure(req tryAppendMeasureReq) { + metric, ok := s.metrics[req.MetricID] + if !ok { + req.ResultCh <- tryAppendMeasureResult{ + ResultCode: NoMetric, + } + return + } + + lockEntry, ok := s.metricLockEntries[req.MetricID] + if ok { + if lockEntry.XLock { + lockEntry.WaitQueue = append(lockEntry.WaitQueue, req) + return + } + } + s.startAppendMeasure(metric, req, lockEntry) +} + +func (s *Database) startAppendMeasure(metric *_metric, req tryAppendMeasureReq, lockEntry *metricLockEntry) { + if req.Timestamp <= metric.Until { + req.ResultCh <- tryAppendMeasureResult{ + ResultCode: ExpiredMeasure, + } + return + } + + if metric.MetricType == diploma.Cumulative && req.Value < metric.UntilValue { + req.ResultCh <- tryAppendMeasureResult{ + ResultCode: NonMonotonicValue, + } + return + } + + extraSpace := metric.Timestamps.CalcRequiredSpace(req.Timestamp) + + metric.Values.CalcRequiredSpace(req.Value) + + totalSpace := metric.Timestamps.Size() + metric.Values.Size() + extraSpace + + if totalSpace <= atree.DataPagePayloadSize { + if lockEntry != nil { + lockEntry.RLocks++ + } else { + s.metricLockEntries[req.MetricID] = &metricLockEntry{ + RLocks: 1, + } + } + req.ResultCh <- tryAppendMeasureResult{ + ResultCode: CanAppend, + } + } else { + if lockEntry != nil { + if lockEntry.RLocks > 0 { + lockEntry.WaitQueue = append(lockEntry.WaitQueue, req) + return + } + lockEntry.XLock = true + } else { + s.metricLockEntries[req.MetricID] = &metricLockEntry{ + XLock: true, + } + } + + req.ResultCh <- tryAppendMeasureResult{ + ResultCode: NewPage, + FilledPage: &FilledPage{ + Since: metric.Since, + RootPageNo: metric.RootPageNo, + PrevPageNo: metric.LastPageNo, + TimestampsChunks: metric.TimestampsBuf.Chunks(), + TimestampsSize: uint16(metric.Timestamps.Size()), + ValuesChunks: metric.ValuesBuf.Chunks(), + ValuesSize: uint16(metric.Values.Size()), + }, + } + } +} + +func (s *Database) appendMeasure(rec txlog.AppendedMeasure) { + metric, ok := s.metrics[rec.MetricID] + if !ok { + diploma.Abort(diploma.NoMetricBug, + fmt.Errorf("appendMeasure: metric %d not found", + rec.MetricID)) + } + + lockEntry, ok := s.metricLockEntries[rec.MetricID] + if !ok { + diploma.Abort(diploma.NoLockEntryBug, + fmt.Errorf("appendMeasure: lockEntry not found for the metric %d", + rec.MetricID)) + } + + if lockEntry.XLock { + diploma.Abort(diploma.XLockBug, + fmt.Errorf("appendMeasure: xlock is set for the metric %d", + rec.MetricID)) + } + + if lockEntry.RLocks <= 0 { + diploma.Abort(diploma.NoRLockBug, + fmt.Errorf("appendMeasure: rlock not set for the metric %d", + rec.MetricID)) + } + + if metric.Since == 0 { + metric.Since = rec.Timestamp + metric.SinceValue = rec.Value + } + + metric.Timestamps.Append(rec.Timestamp) + metric.Values.Append(rec.Value) + + metric.Until = rec.Timestamp + metric.UntilValue = rec.Value + + lockEntry.RLocks-- + if len(lockEntry.WaitQueue) > 0 { + s.processMetricQueue(rec.MetricID, metric, lockEntry) + } else { + if lockEntry.RLocks == 0 { + delete(s.metricLockEntries, rec.MetricID) + } + } +} + +func (s *Database) appendMeasures(extended txlog.AppendedMeasuresExtended) { + rec := extended.Record + metric, ok := s.metrics[rec.MetricID] + if !ok { + diploma.Abort(diploma.NoMetricBug, + fmt.Errorf("appendMeasureAfterOverflow: metric %d not found", + rec.MetricID)) + } + + lockEntry, ok := s.metricLockEntries[rec.MetricID] + if !ok { + diploma.Abort(diploma.NoLockEntryBug, + fmt.Errorf("appendMeasureAfterOverflow: lockEntry not found for the metric %d", + rec.MetricID)) + } + + if !lockEntry.XLock { + diploma.Abort(diploma.NoXLockBug, + fmt.Errorf("appendMeasureAfterOverflow: xlock not set for the metric %d", + rec.MetricID)) + } + + for _, measure := range rec.Measures { + if metric.Since == 0 { + metric.Since = measure.Timestamp + metric.SinceValue = measure.Value + } + + metric.Timestamps.Append(measure.Timestamp) + metric.Values.Append(measure.Value) + + metric.Until = measure.Timestamp + metric.UntilValue = measure.Value + } + + if !extended.HoldLock { + lockEntry.XLock = false + s.doAfterReleaseXLock(rec.MetricID, metric, lockEntry) + } +} + +func (s *Database) appendMeasureAfterOverflow(extended txlog.AppendedMeasureWithOverflowExtended) { + rec := extended.Record + metric, ok := s.metrics[rec.MetricID] + if !ok { + diploma.Abort(diploma.NoMetricBug, + fmt.Errorf("appendMeasureAfterOverflow: metric %d not found", + rec.MetricID)) + } + + lockEntry, ok := s.metricLockEntries[rec.MetricID] + if !ok { + diploma.Abort(diploma.NoLockEntryBug, + fmt.Errorf("appendMeasureAfterOverflow: lockEntry not found for the metric %d", + rec.MetricID)) + } + + if !lockEntry.XLock { + diploma.Abort(diploma.NoXLockBug, + fmt.Errorf("appendMeasureAfterOverflow: xlock not set for the metric %d", + rec.MetricID)) + } + + metric.ReinitBy(rec.Timestamp, rec.Value) + if rec.IsRootChanged { + metric.RootPageNo = rec.RootPageNo + } + metric.LastPageNo = rec.DataPageNo + + // delete free pages + if rec.IsDataPageReused { + s.dataFreeList.DeletePages([]uint32{ + rec.DataPageNo, + }) + } + + if len(rec.ReusedIndexPages) > 0 { + s.indexFreeList.DeletePages(rec.ReusedIndexPages) + } + + if !extended.HoldLock { + lockEntry.XLock = false + s.doAfterReleaseXLock(rec.MetricID, metric, lockEntry) + } +} + +type tryAppendMeasuresReq struct { + MetricID uint32 + ResultCh chan tryAppendMeasuresResult +} + +func (s *Database) tryAppendMeasures(req tryAppendMeasuresReq) { + metric, ok := s.metrics[req.MetricID] + if !ok { + req.ResultCh <- tryAppendMeasuresResult{ + ResultCode: NoMetric, + } + return + } + + lockEntry, ok := s.metricLockEntries[req.MetricID] + if ok { + if lockEntry.XLock { + lockEntry.WaitQueue = append(lockEntry.WaitQueue, req) + return + } + } + s.startAppendMeasures(metric, req, lockEntry) +} + +func (s *Database) startAppendMeasures(metric *_metric, req tryAppendMeasuresReq, lockEntry *metricLockEntry) { + if lockEntry != nil { + if lockEntry.RLocks > 0 { + lockEntry.WaitQueue = append(lockEntry.WaitQueue, req) + return + } + lockEntry.XLock = true + } else { + s.metricLockEntries[req.MetricID] = &metricLockEntry{ + XLock: true, + } + } + + var ( + timestampsBuf *conbuf.ContinuousBuffer + valuesBuf *conbuf.ContinuousBuffer + timestamps diploma.TimestampCompressor + values diploma.ValueCompressor + ) + + if metric.Since > 0 { + timestampsBuf = metric.TimestampsBuf.Copy() + valuesBuf = metric.ValuesBuf.Copy() + + timestamps = chunkenc.NewReverseTimeDeltaOfDeltaCompressor( + timestampsBuf, metric.Timestamps.Size()) + + if metric.MetricType == diploma.Cumulative { + values = chunkenc.NewReverseCumulativeDeltaCompressor( + valuesBuf, metric.Values.Size(), metric.FracDigits) + } else { + values = chunkenc.NewReverseInstantDeltaCompressor( + valuesBuf, metric.Values.Size(), metric.FracDigits) + } + } else { + timestampsBuf = conbuf.New(nil) + valuesBuf = conbuf.New(nil) + timestamps = chunkenc.NewReverseTimeDeltaOfDeltaCompressor( + timestampsBuf, 0) + if metric.MetricType == diploma.Cumulative { + values = chunkenc.NewReverseCumulativeDeltaCompressor( + valuesBuf, 0, metric.FracDigits) + } else { + values = chunkenc.NewReverseInstantDeltaCompressor( + valuesBuf, 0, metric.FracDigits) + } + } + + req.ResultCh <- tryAppendMeasuresResult{ + ResultCode: CanAppend, + MetricType: metric.MetricType, + FracDigits: metric.FracDigits, + Since: metric.Since, + Until: metric.Until, + UntilValue: metric.UntilValue, + RootPageNo: metric.RootPageNo, + PrevPageNo: metric.LastPageNo, + TimestampsBuf: timestampsBuf, + ValuesBuf: valuesBuf, + Timestamps: timestamps, + Values: values, + } +} + +type tryListCumulativePeriodsReq struct { + MetricID uint32 + Since uint32 + Until uint32 + Aggregator *atree.CumulativeAggregator + ResponseWriter *atree.CumulativePeriodsWriter + ResultCh chan cumulativePeriodsResult +} + +func (s *Database) tryListCumulativePeriods(req tryListCumulativePeriodsReq) { + metric, ok := s.metrics[req.MetricID] + if !ok { + req.ResultCh <- cumulativePeriodsResult{ + ResultCode: NoMetric, + } + return + } + if metric.MetricType != diploma.Cumulative { + req.ResultCh <- cumulativePeriodsResult{ + ResultCode: WrongMetricType, + } + return + } + + lockEntry, ok := s.metricLockEntries[req.MetricID] + if ok { + if lockEntry.XLock { + lockEntry.WaitQueue = append(lockEntry.WaitQueue, req) + return + } + } + + if s.startListCumulativePeriods(metric, req) { + if lockEntry != nil { + lockEntry.RLocks++ + } else { + s.metricLockEntries[req.MetricID] = &metricLockEntry{ + RLocks: 1, + } + } + } +} + +func (s *Database) startListCumulativePeriods(metric *_metric, req tryListCumulativePeriodsReq) bool { + if metric.Since == 0 { + req.ResultCh <- cumulativePeriodsResult{ + ResultCode: QueryDone, + } + return false + } + + if req.Since > metric.Until { + req.ResultCh <- cumulativePeriodsResult{ + ResultCode: QueryDone, + } + return false + } + + if req.Until < metric.Since { + if metric.RootPageNo > 0 { + req.ResultCh <- cumulativePeriodsResult{ + ResultCode: UntilNotFound, + PageNo: metric.RootPageNo, + FracDigits: metric.FracDigits, + } + return true + } else { + req.ResultCh <- cumulativePeriodsResult{ + ResultCode: QueryDone, + } + return false + } + } + + timestampDecompressor := chunkenc.NewReverseTimeDeltaOfDeltaDecompressor( + metric.TimestampsBuf, + metric.Timestamps.Size(), + ) + + valueDecompressor := chunkenc.NewReverseCumulativeDeltaDecompressor( + metric.ValuesBuf, + metric.Values.Size(), + metric.FracDigits, + ) + + var period atree.CumulativePeriod + + for { + timestamp, done := timestampDecompressor.NextValue() + if done { + break + } + + value, done := valueDecompressor.NextValue() + if done { + diploma.Abort(diploma.HasTimestampNoValueBug, ErrNoValueBug) + } + + if timestamp > req.Until { + continue + } + + if timestamp < req.Since { + isCompleted := req.Aggregator.FillPeriod(timestamp, value, &period) + if isCompleted { + req.ResponseWriter.WritePeriod(period) + } + req.ResultCh <- cumulativePeriodsResult{ + ResultCode: QueryDone, + } + return false + } + + if timestamp <= req.Until { + isCompleted := req.Aggregator.Feed(timestamp, value, &period) + if isCompleted { + req.ResponseWriter.WritePeriod(period) + } + } + } + + if metric.LastPageNo > 0 { + req.ResultCh <- cumulativePeriodsResult{ + ResultCode: UntilFound, + PageNo: metric.LastPageNo, + FracDigits: metric.FracDigits, + } + return true + } else { + isCompleted := req.Aggregator.FillPeriod(metric.Since, metric.SinceValue, &period) + if isCompleted { + req.ResponseWriter.WritePeriod(period) + } + req.ResultCh <- cumulativePeriodsResult{ + ResultCode: QueryDone, + } + return false + } +} + +type tryListInstantPeriodsReq struct { + MetricID uint32 + Since uint32 + Until uint32 + Aggregator *atree.InstantAggregator + ResponseWriter *atree.InstantPeriodsWriter + ResultCh chan instantPeriodsResult +} + +func (s *Database) tryListInstantPeriods(req tryListInstantPeriodsReq) { + metric, ok := s.metrics[req.MetricID] + if !ok { + req.ResultCh <- instantPeriodsResult{ + ResultCode: NoMetric, + } + return + } + if metric.MetricType != diploma.Instant { + req.ResultCh <- instantPeriodsResult{ + ResultCode: WrongMetricType, + } + return + } + + lockEntry, ok := s.metricLockEntries[req.MetricID] + if ok { + if lockEntry.XLock { + lockEntry.WaitQueue = append(lockEntry.WaitQueue, req) + return + } + } + if s.startListInstantPeriods(metric, req) { + if lockEntry != nil { + lockEntry.RLocks++ + } else { + s.metricLockEntries[req.MetricID] = &metricLockEntry{ + RLocks: 1, + } + } + } +} + +func (*Database) startListInstantPeriods(metric *_metric, req tryListInstantPeriodsReq) bool { + if metric.Since == 0 { + req.ResultCh <- instantPeriodsResult{ + ResultCode: QueryDone, + } + return false + } + + if req.Since > metric.Until { + req.ResultCh <- instantPeriodsResult{ + ResultCode: QueryDone, + } + return false + } + + if req.Until < metric.Since { + // search in tree + if metric.RootPageNo > 0 { + req.ResultCh <- instantPeriodsResult{ + ResultCode: UntilNotFound, + PageNo: metric.RootPageNo, + FracDigits: metric.FracDigits, + } + return true + } else { + req.ResultCh <- instantPeriodsResult{ + ResultCode: QueryDone, + } + return false + } + } + + timestampDecompressor := chunkenc.NewReverseTimeDeltaOfDeltaDecompressor( + metric.TimestampsBuf, + metric.Timestamps.Size(), + ) + + valueDecompressor := chunkenc.NewReverseInstantDeltaDecompressor( + metric.ValuesBuf, + metric.Values.Size(), + metric.FracDigits, + ) + + var period atree.InstantPeriod + + for { + timestamp, done := timestampDecompressor.NextValue() + if done { + break + } + + value, done := valueDecompressor.NextValue() + if done { + diploma.Abort(diploma.HasTimestampNoValueBug, ErrNoValueBug) + } + + if timestamp <= req.Until { + if timestamp < req.Since { + isCompleted := req.Aggregator.FillPeriod(timestamp, &period) + if isCompleted { + req.ResponseWriter.WritePeriod(period) + } + req.ResultCh <- instantPeriodsResult{ + ResultCode: QueryDone, + } + return false + } + + isCompleted := req.Aggregator.Feed(timestamp, value, &period) + if isCompleted { + req.ResponseWriter.WritePeriod(period) + } + } + } + + if metric.LastPageNo > 0 { + req.ResultCh <- instantPeriodsResult{ + ResultCode: UntilFound, + PageNo: metric.LastPageNo, + FracDigits: metric.FracDigits, + } + return true + } else { + isCompleted := req.Aggregator.FillPeriod(metric.Since, &period) + if isCompleted { + req.ResponseWriter.WritePeriod(period) + } + req.ResultCh <- instantPeriodsResult{ + ResultCode: QueryDone, + } + return false + } +} + +type tryListCurrentValuesReq struct { + MetricIDs []uint32 + ResponseWriter *atree.CurrentValueWriter + ResultCh chan struct{} +} + +func (s *Database) tryListCurrentValues(req tryListCurrentValuesReq) { + for _, metricID := range req.MetricIDs { + metric, ok := s.metrics[metricID] + if ok { + req.ResponseWriter.BufferValue(atree.CurrentValue{ + MetricID: metricID, + Timestamp: metric.Until, + Value: metric.UntilValue, + }) + } + } + req.ResultCh <- struct{}{} +} + +func (s *Database) applyChanges(req txlog.Changes) { + for _, untyped := range req.Records { + switch rec := untyped.(type) { + case txlog.AddedMetric: + s.addMetric(rec) + + case txlog.DeletedMetric: + s.deleteMetric(rec) + + case txlog.AppendedMeasure: + s.appendMeasure(rec) + + case txlog.AppendedMeasuresExtended: + s.appendMeasures(rec) + + case txlog.AppendedMeasureWithOverflowExtended: + s.appendMeasureAfterOverflow(rec) + + case txlog.DeletedMeasures: + s.deleteMeasures(rec) + + case txlog.DeletedMeasuresSince: + s.deleteMeasuresSince(rec) + } + } + + if req.ForceSnapshot || req.ExitWaitGroup != nil { + s.dumpSnapshot(req.LogNumber) + } + + close(req.WaitCh) + + if req.ExitWaitGroup != nil { + req.ExitWaitGroup.Done() + } +} + +func (s *Database) addMetric(rec txlog.AddedMetric) { + _, ok := s.metrics[rec.MetricID] + if ok { + diploma.Abort(diploma.MetricAddedBug, + fmt.Errorf("addMetric: metric %d already added", + rec.MetricID)) + } + + lockEntry, ok := s.metricLockEntries[rec.MetricID] + if !ok { + diploma.Abort(diploma.NoLockEntryBug, + fmt.Errorf("addMetric: lockEntry not found for the metric %d", + rec.MetricID)) + } + + if !lockEntry.XLock { + diploma.Abort(diploma.NoXLockBug, + fmt.Errorf("addMetric: xlock not set for the metric %d", + rec.MetricID)) + } + + var ( + values diploma.ValueCompressor + timestampsBuf = conbuf.New(nil) + valuesBuf = conbuf.New(nil) + ) + + if rec.MetricType == diploma.Cumulative { + values = chunkenc.NewReverseCumulativeDeltaCompressor( + valuesBuf, 0, byte(rec.FracDigits)) + } else { + values = chunkenc.NewReverseInstantDeltaCompressor( + valuesBuf, 0, byte(rec.FracDigits)) + } + + s.metrics[rec.MetricID] = &_metric{ + MetricType: rec.MetricType, + FracDigits: byte(rec.FracDigits), + TimestampsBuf: timestampsBuf, + ValuesBuf: valuesBuf, + Timestamps: chunkenc.NewReverseTimeDeltaOfDeltaCompressor(timestampsBuf, 0), + Values: values, + } + + lockEntry.XLock = false + delete(s.metricLockEntries, rec.MetricID) +} + +func (s *Database) deleteMetric(rec txlog.DeletedMetric) { + _, ok := s.metrics[rec.MetricID] + if !ok { + diploma.Abort(diploma.NoMetricBug, + fmt.Errorf("deleteMetric: metric %d not found", + rec.MetricID)) + } + + lockEntry, ok := s.metricLockEntries[rec.MetricID] + if !ok { + diploma.Abort(diploma.NoLockEntryBug, + fmt.Errorf("deleteMetric: lockEntry not found for the metric %d", + rec.MetricID)) + } + + if !lockEntry.XLock { + diploma.Abort(diploma.NoXLockBug, + fmt.Errorf("deleteMetric: xlock not set for the metric %d", + rec.MetricID)) + } + + var addMetricReqs []tryAddMetricReq + + if len(lockEntry.WaitQueue) > 0 { + for _, untyped := range lockEntry.WaitQueue { + switch req := untyped.(type) { + case tryAppendMeasureReq: + req.ResultCh <- tryAppendMeasureResult{ + ResultCode: NoMetric, + } + + case tryListCumulativePeriodsReq: + req.ResultCh <- cumulativePeriodsResult{ + ResultCode: NoMetric, + } + + case tryListInstantPeriodsReq: + req.ResultCh <- instantPeriodsResult{ + ResultCode: NoMetric, + } + + case tryListCumulativeMeasuresReq: + req.ResultCh <- cumulativeMeasuresResult{ + ResultCode: NoMetric, + } + + case tryListInstantMeasuresReq: + req.ResultCh <- instantMeasuresResult{ + ResultCode: NoMetric, + } + + case tryListAllCumulativeMeasuresReq: + req.ResultCh <- cumulativeMeasuresResult{ + ResultCode: NoMetric, + } + + case tryListAllInstantMeasuresReq: + req.ResultCh <- instantMeasuresResult{ + ResultCode: NoMetric, + } + + case tryAddMetricReq: + addMetricReqs = append(addMetricReqs, req) + + case tryDeleteMetricReq: + req.ResultCh <- tryDeleteMetricResult{ + ResultCode: NoMetric, + } + + case tryDeleteMeasuresReq: + req.ResultCh <- tryDeleteMeasuresResult{ + ResultCode: NoMetric, + } + + case tryGetMetricReq: + req.ResultCh <- Metric{ + ResultCode: NoMetric, + } + + default: + diploma.Abort(diploma.UnknownMetricWaitQueueItemBug, + fmt.Errorf("bug: unknown metric wait queue item type %T", req)) + } + } + } + delete(s.metrics, rec.MetricID) + delete(s.metricLockEntries, rec.MetricID) + + if len(rec.FreeDataPages) > 0 { + s.dataFreeList.AddPages(rec.FreeDataPages) + s.atree.DeleteDataPages(rec.FreeDataPages) + } + if len(rec.FreeIndexPages) > 0 { + s.indexFreeList.AddPages(rec.FreeIndexPages) + s.atree.DeleteIndexPages(rec.FreeIndexPages) + } + + if len(addMetricReqs) > 0 { + s.processTryAddMetricReqsImmediatelyAfterDelete(addMetricReqs) + } +} + +func (s *Database) deleteMeasures(rec txlog.DeletedMeasures) { + metric, ok := s.metrics[rec.MetricID] + if !ok { + diploma.Abort(diploma.NoMetricBug, + fmt.Errorf("deleteMeasures: metric %d not found", + rec.MetricID)) + } + + lockEntry, ok := s.metricLockEntries[rec.MetricID] + if !ok { + diploma.Abort(diploma.NoLockEntryBug, + fmt.Errorf("deleteMeasures: lockEntry not found for the metric %d", + rec.MetricID)) + } + + if !lockEntry.XLock { + diploma.Abort(diploma.NoXLockBug, + fmt.Errorf("deleteMeasures: xlock not set for the metric %d", + rec.MetricID)) + } + + metric.DeleteMeasures() + lockEntry.XLock = false + // + if len(rec.FreeDataPages) > 0 { + s.dataFreeList.AddPages(rec.FreeDataPages) + s.atree.DeleteDataPages(rec.FreeDataPages) + } + if len(rec.FreeDataPages) > 0 { + s.indexFreeList.AddPages(rec.FreeIndexPages) + s.atree.DeleteIndexPages(rec.FreeIndexPages) + } + s.doAfterReleaseXLock(rec.MetricID, metric, lockEntry) +} + +func (s *Database) deleteMeasuresSince(rec txlog.DeletedMeasuresSince) { + metric, ok := s.metrics[rec.MetricID] + if !ok { + diploma.Abort(diploma.NoMetricBug, + fmt.Errorf("deleteMeasuresSince: metric %d not found", + rec.MetricID)) + } + + lockEntry, ok := s.metricLockEntries[rec.MetricID] + if !ok { + diploma.Abort(diploma.NoLockEntryBug, + fmt.Errorf("deleteMeasuresSince: lockEntry not found for the metric %d", + rec.MetricID)) + } + + if !lockEntry.XLock { + diploma.Abort(diploma.NoXLockBug, + fmt.Errorf("deleteMeasuresSince: xlock not set for the metric %d", + rec.MetricID)) + } + + if rec.IsRootChanged && rec.RootPageNo == 0 { + metric.DeleteMeasures() + } else { + metric.TimestampsBuf = conbuf.NewFromBuffer(rec.TimestampsBuf) + metric.ValuesBuf = conbuf.NewFromBuffer(rec.ValuesBuf) + + metric.Timestamps = chunkenc.NewReverseTimeDeltaOfDeltaCompressor( + metric.TimestampsBuf, len(rec.TimestampsBuf)) + + if metric.MetricType == diploma.Cumulative { + metric.Values = chunkenc.NewReverseCumulativeDeltaCompressor( + metric.ValuesBuf, len(rec.ValuesBuf), metric.FracDigits) + } else { + metric.Values = chunkenc.NewReverseInstantDeltaCompressor( + metric.ValuesBuf, len(rec.ValuesBuf), metric.FracDigits) + } + + metric.Since, metric.Until = enc.GetTimeRange(rec.TimestampsBuf) + metric.SinceValue, metric.UntilValue = enc.GetValueBounds( + rec.ValuesBuf, metric.MetricType, metric.FracDigits, + ) + + if rec.IsRootChanged { + metric.RootPageNo = rec.RootPageNo + } + metric.LastPageNo = rec.LastPageNo + } + + lockEntry.XLock = false + + if len(rec.FreeDataPages) > 0 { + s.dataFreeList.AddPages(rec.FreeDataPages) + s.atree.DeleteDataPages(rec.FreeDataPages) + } + if len(rec.FreeDataPages) > 0 { + s.indexFreeList.AddPages(rec.FreeIndexPages) + s.atree.DeleteIndexPages(rec.FreeIndexPages) + } + s.doAfterReleaseXLock(rec.MetricID, metric, lockEntry) +} + +func (s *Database) doAfterReleaseXLock(metricID uint32, metric *_metric, lockEntry *metricLockEntry) { + if len(lockEntry.WaitQueue) == 0 { + delete(s.metricLockEntries, metricID) + } else { + s.processMetricQueue(metricID, metric, lockEntry) + } +} diff --git a/database/snapshot.go b/database/snapshot.go new file mode 100644 index 0000000..3911eb9 --- /dev/null +++ b/database/snapshot.go @@ -0,0 +1,287 @@ +package database + +import ( + "fmt" + "hash/crc32" + "io" + "os" + "path/filepath" + + octopus "gordenko.dev/dima/diploma" + "gordenko.dev/dima/diploma/atree" + "gordenko.dev/dima/diploma/bin" + "gordenko.dev/dima/diploma/chunkenc" + "gordenko.dev/dima/diploma/conbuf" + "gordenko.dev/dima/diploma/freelist" +) + +/* +Формат: +//lsn - varuint (останній LSN, що змінив дані у RAM) +metricsQty - varuint +[metric]* +где metric - це: +metricID - 4b +metricType - 1b +fracDigits - 1b +rootPageNo - 4b +lastPageNo - 4b +since - 4b +sinceValue - 8b +until - 4b +untilValue - 8b +timestamps size - 2b +values size - 2b +timestams payload - Nb +values payload - Nb +dataFreeList size - varuint +dataFreeList - Nb +indexFreeList size - varuint +indexFreeList - Nb +CRC32 - 4b +*/ + +const metricHeaderSize = 42 + +func (s *Database) dumpSnapshot(logNumber int) (err error) { + var ( + fileName = filepath.Join(s.dir, fmt.Sprintf("%d.snapshot", logNumber)) + hasher = crc32.NewIEEE() + prefix = make([]byte, metricHeaderSize) + ) + + file, err := os.OpenFile(fileName, os.O_CREATE|os.O_WRONLY, 0770) + if err != nil { + return + } + + dst := io.MultiWriter(file, hasher) + + _, err = bin.WriteVarUint64(dst, uint64(len(s.metrics))) + if err != nil { + return + } + + for metricID, metric := range s.metrics { + tSize := metric.Timestamps.Size() + vSize := metric.Values.Size() + + bin.PutUint32(prefix[0:], metricID) + prefix[4] = byte(metric.MetricType) + prefix[5] = metric.FracDigits + bin.PutUint32(prefix[6:], metric.RootPageNo) + bin.PutUint32(prefix[10:], metric.LastPageNo) + bin.PutUint32(prefix[14:], metric.Since) + bin.PutFloat64(prefix[18:], metric.SinceValue) + bin.PutUint32(prefix[26:], metric.Until) + bin.PutFloat64(prefix[30:], metric.UntilValue) + bin.PutUint16(prefix[38:], uint16(tSize)) + bin.PutUint16(prefix[40:], uint16(vSize)) + + _, err = dst.Write(prefix) + if err != nil { + return + } + // copy timestamps + remaining := tSize + for _, buf := range metric.TimestampsBuf.Chunks() { + if remaining < len(buf) { + buf = buf[:remaining] + } + _, err = dst.Write(buf) + if err != nil { + return + } + remaining -= len(buf) + if remaining == 0 { + break + } + } + // copy values + remaining = vSize + for _, buf := range metric.ValuesBuf.Chunks() { + if remaining < len(buf) { + buf = buf[:remaining] + } + _, err = dst.Write(buf) + if err != nil { + return + } + remaining -= len(buf) + if remaining == 0 { + break + } + } + } + // free data pages + err = freeListWriteTo(s.dataFreeList, dst) + if err != nil { + return + } + // free index pages + err = freeListWriteTo(s.indexFreeList, dst) + if err != nil { + return + } + + bin.WriteUint32(file, hasher.Sum32()) + + err = file.Sync() + if err != nil { + return + } + + err = file.Close() + if err != nil { + return + } + + prevLogNumber := logNumber - 1 + prevChanges := filepath.Join(s.dir, fmt.Sprintf("%d.changes", prevLogNumber)) + prevSnapshot := filepath.Join(s.dir, fmt.Sprintf("%d.snapshot", prevLogNumber)) + + isExist, err := isFileExist(prevChanges) + if err != nil { + return + } + + if isExist { + err = os.Remove(prevChanges) + if err != nil { + octopus.Abort(octopus.DeletePrevChangesFileFailed, err) + } + } + + isExist, err = isFileExist(prevSnapshot) + if err != nil { + return + } + + if isExist { + err = os.Remove(prevSnapshot) + if err != nil { + octopus.Abort(octopus.DeletePrevSnapshotFileFailed, err) + } + } + return +} + +func (s *Database) loadSnapshot(fileName string) (err error) { + var ( + hasher = crc32.NewIEEE() + metricsQty int + header = make([]byte, metricHeaderSize) + body = make([]byte, atree.DataPageSize) + ) + + file, err := os.Open(fileName) + if err != nil { + return + } + + src := io.TeeReader(file, hasher) + u64, _, err := bin.ReadVarUint64(src) + if err != nil { + return + } + metricsQty = int(u64) + + for range metricsQty { + var metric _metric + err = bin.ReadNInto(src, header) + if err != nil { + return + } + + metricID := bin.GetUint32(header[0:]) + metric.MetricType = octopus.MetricType(header[4]) + metric.FracDigits = header[5] + metric.RootPageNo = bin.GetUint32(header[6:]) + metric.LastPageNo = bin.GetUint32(header[10:]) + metric.Since = bin.GetUint32(header[14:]) + metric.SinceValue = bin.GetFloat64(header[18:]) + metric.Until = bin.GetUint32(header[26:]) + metric.UntilValue = bin.GetFloat64(header[30:]) + tSize := bin.GetUint16(header[38:]) + vSize := bin.GetUint16(header[40:]) + + buf := body[:tSize] + err = bin.ReadNInto(src, buf) + if err != nil { + return + } + metric.TimestampsBuf = conbuf.NewFromBuffer(buf) + + buf = body[:vSize] + err = bin.ReadNInto(src, buf) + if err != nil { + return + } + metric.ValuesBuf = conbuf.NewFromBuffer(buf) + + metric.Timestamps = chunkenc.NewReverseTimeDeltaOfDeltaCompressor( + metric.TimestampsBuf, int(tSize)) + + if metric.MetricType == octopus.Cumulative { + metric.Values = chunkenc.NewReverseCumulativeDeltaCompressor( + metric.ValuesBuf, int(vSize), metric.FracDigits) + } else { + metric.Values = chunkenc.NewReverseInstantDeltaCompressor( + metric.ValuesBuf, int(vSize), metric.FracDigits) + } + s.metrics[metricID] = &metric + } + + err = restoreFreeList(s.dataFreeList, src) + if err != nil { + return fmt.Errorf("restore dataFreeList: %s", err) + } + + err = restoreFreeList(s.indexFreeList, src) + if err != nil { + return fmt.Errorf("restore indexFreeList: %s", err) + } + + calculatedChecksum := hasher.Sum32() + + writtenChecksum, err := bin.ReadUint32(file) + if err != nil { + return + } + + if calculatedChecksum != writtenChecksum { + return fmt.Errorf("calculated checksum %d not equal written checksum %d", calculatedChecksum, writtenChecksum) + } + return +} + +// HELPERS + +func freeListWriteTo(freeList *freelist.FreeList, dst io.Writer) error { + serialized, err := freeList.Serialize() + if err != nil { + octopus.Abort(octopus.FailedFreeListSerialize, err) + } + _, err = bin.WriteVarUint64(dst, uint64(len(serialized))) + if err != nil { + return err + } + _, err = dst.Write(serialized) + if err != nil { + return err + } + return nil +} + +func restoreFreeList(freeList *freelist.FreeList, src io.Reader) error { + size, _, err := bin.ReadVarUint64(src) + if err != nil { + return err + } + serialized, err := bin.ReadN(src, int(size)) + if err != nil { + return err + } + freeList.Restore(serialized) + return nil +} diff --git a/database_linux b/database_linux new file mode 100755 index 0000000000000000000000000000000000000000..48bc8f7330b693b875274bf4640e01d69380ce2f GIT binary patch literal 4755144 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

Q=; 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�B|QTwpY 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 YW&kU#wWt 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%0DENmnh5 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�?cUD^ci>OJOF!~hL&74 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

X~DHsr-{t2+2>YZ{)Ypa3X##2}wR7akC7RZ>O{< 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%0DTeNUxH1X%i@?FJq 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%0DLO8hb;L-X6i?XTUM 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 z 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