15238419529

Committed 25 May 2025 01:32PM UTC coverage: 72.019% (-3.7%) from 75.704%

Build # 15238419529

Build Type

push

github

Committed by

HDT3213

Commit Message

update github actions go version

Run Details

1 of 1 new or added line in 1 file covered. (100.0%)

1149 existing lines in 29 files now uncovered.

8473 of 11765 relevant lines covered (72.02%)

0.8 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

95.7

/database/persistence.go

package database

import (
        "fmt"
        "os"
        "sync/atomic"

        "github.com/hdt3213/godis/aof"
        "github.com/hdt3213/godis/config"
        "github.com/hdt3213/godis/datastruct/dict"
        List "github.com/hdt3213/godis/datastruct/list"
        HashSet "github.com/hdt3213/godis/datastruct/set"
        SortedSet "github.com/hdt3213/godis/datastruct/sortedset"
        "github.com/hdt3213/godis/interface/database"
        "github.com/hdt3213/rdb/core"
        rdb "github.com/hdt3213/rdb/parser"
)

// loadRdbFile loads rdb file from disk
func (server *Server) loadRdbFile() error {
        rdbFile, err := os.Open(config.Properties.RDBFilename)
        if err != nil {
                return fmt.Errorf("open rdb file failed " + err.Error())
        }
        defer func() {
                _ = rdbFile.Close()
        }()
        decoder := rdb.NewDecoder(rdbFile)
        err = server.LoadRDB(decoder)
        if err != nil {
                return fmt.Errorf("load rdb file failed " + err.Error())
        }
        return nil
}

// LoadRDB real implementation of loading rdb file
func (server *Server) LoadRDB(dec *core.Decoder) error {
        return dec.Parse(func(o rdb.RedisObject) bool {
                db := server.mustSelectDB(o.GetDBIndex())
                var entity *database.DataEntity
                switch o.GetType() {
                case rdb.StringType:
                        str := o.(*rdb.StringObject)
                        entity = &database.DataEntity{
                                Data: str.Value,
                        }
                case rdb.ListType:
                        listObj := o.(*rdb.ListObject)
                        list := List.NewQuickList()
                        for _, v := range listObj.Values {
                                list.Add(v)
                        }
                        entity = &database.DataEntity{
                                Data: list,
                        }
                case rdb.HashType:
                        hashObj := o.(*rdb.HashObject)
                        hash := dict.MakeSimple()
                        for k, v := range hashObj.Hash {
                                hash.Put(k, v)
                        }
                        entity = &database.DataEntity{
                                Data: hash,
                        }
                case rdb.SetType:
                        setObj := o.(*rdb.SetObject)
                        set := HashSet.Make()
                        for _, mem := range setObj.Members {
                                set.Add(string(mem))
                        }
                        entity = &database.DataEntity{
                                Data: set,
                        }
                case rdb.ZSetType:
                        zsetObj := o.(*rdb.ZSetObject)
                        zSet := SortedSet.Make()
                        for _, e := range zsetObj.Entries {
                                zSet.Add(e.Member, e.Score)
                        }
                        entity = &database.DataEntity{
                                Data: zSet,
                        }
                }
                if entity != nil {
                        db.PutEntity(o.GetKey(), entity)
                        if o.GetExpiration() != nil {
                                db.Expire(o.GetKey(), *o.GetExpiration())
                        }
                        // add to aof
                        db.addAof(aof.EntityToCmd(o.GetKey(), entity).Args)
                }
                return true
        })
}

func NewPersister(db database.DBEngine, filename string, load bool, fsync string) (*aof.Persister, error) {
        return aof.NewPersister(db, filename, load, fsync, func() database.DBEngine {
                return MakeAuxiliaryServer()
        })
}

func (server *Server) AddAof(dbIndex int, cmdLine CmdLine) {
        if server.persister != nil {
                server.persister.SaveCmdLine(dbIndex, cmdLine)
        }
}

func (server *Server) bindPersister(persister *aof.Persister) {
        server.persister = persister
        // bind SaveCmdLine
        for _, db := range server.dbSet {
                singleDB := db.Load().(*DB)
                singleDB.addAof = func(line CmdLine) {
                        if config.Properties.AppendOnly { // config may be changed during runtime
                                server.persister.SaveCmdLine(singleDB.index, line)
                        }
                }
        }
}

// MakeAuxiliaryServer create a Server only with basic capabilities for aof rewrite and other usages
func MakeAuxiliaryServer() *Server {
        mdb := &Server{}
        mdb.dbSet = make([]*atomic.Value, config.Properties.Databases)
        for i := range mdb.dbSet {
                holder := &atomic.Value{}
                holder.Store(makeBasicDB())
                mdb.dbSet[i] = holder
        }
        return mdb
}

1	package database
2
3	import (
4	"fmt"
5	"os"
6	"sync/atomic"
7
8	"github.com/hdt3213/godis/aof"
9	"github.com/hdt3213/godis/config"
10	"github.com/hdt3213/godis/datastruct/dict"
11	List "github.com/hdt3213/godis/datastruct/list"
12	HashSet "github.com/hdt3213/godis/datastruct/set"
13	SortedSet "github.com/hdt3213/godis/datastruct/sortedset"
14	"github.com/hdt3213/godis/interface/database"
15	"github.com/hdt3213/rdb/core"
16	rdb "github.com/hdt3213/rdb/parser"
17	)
18
19	// loadRdbFile loads rdb file from disk
20	func (server *Server) loadRdbFile() error {	1✔
21	rdbFile, err := os.Open(config.Properties.RDBFilename)	1✔
22	if err != nil {	2✔
23	return fmt.Errorf("open rdb file failed " + err.Error())	1✔
24	}	1✔
25	defer func() {	2✔
26	_ = rdbFile.Close()	1✔
27	}()	1✔
28	decoder := rdb.NewDecoder(rdbFile)	1✔
29	err = server.LoadRDB(decoder)	1✔
30	if err != nil {	1✔
UNCOV 31	return fmt.Errorf("load rdb file failed " + err.Error())	×
UNCOV 32	}	×
33	return nil	1✔
34	}
35
36	// LoadRDB real implementation of loading rdb file
37	func (server Server) LoadRDB(dec core.Decoder) error {	1✔
38	return dec.Parse(func(o rdb.RedisObject) bool {	2✔
39	db := server.mustSelectDB(o.GetDBIndex())	1✔
40	var entity *database.DataEntity	1✔
41	switch o.GetType() {	1✔
42	case rdb.StringType:	1✔
43	str := o.(*rdb.StringObject)	1✔
44	entity = &database.DataEntity{	1✔
45	Data: str.Value,	1✔
46	}	1✔
47	case rdb.ListType:	1✔
48	listObj := o.(*rdb.ListObject)	1✔
49	list := List.NewQuickList()	1✔
50	for _, v := range listObj.Values {	2✔
51	list.Add(v)	1✔
52	}	1✔
53	entity = &database.DataEntity{	1✔
54	Data: list,	1✔
55	}	1✔
56	case rdb.HashType:	1✔
57	hashObj := o.(*rdb.HashObject)	1✔
58	hash := dict.MakeSimple()	1✔
59	for k, v := range hashObj.Hash {	2✔
60	hash.Put(k, v)	1✔
61	}	1✔
62	entity = &database.DataEntity{	1✔
63	Data: hash,	1✔
64	}	1✔
65	case rdb.SetType:	1✔
66	setObj := o.(*rdb.SetObject)	1✔
67	set := HashSet.Make()	1✔
68	for _, mem := range setObj.Members {	2✔
69	set.Add(string(mem))	1✔
70	}	1✔
71	entity = &database.DataEntity{	1✔
72	Data: set,	1✔
73	}	1✔
74	case rdb.ZSetType:	1✔
75	zsetObj := o.(*rdb.ZSetObject)	1✔
76	zSet := SortedSet.Make()	1✔
77	for _, e := range zsetObj.Entries {	2✔
78	zSet.Add(e.Member, e.Score)	1✔
79	}	1✔
80	entity = &database.DataEntity{	1✔
81	Data: zSet,	1✔
82	}	1✔
83	}
84	if entity != nil {	2✔
85	db.PutEntity(o.GetKey(), entity)	1✔
86	if o.GetExpiration() != nil {	1✔
UNCOV 87	db.Expire(o.GetKey(), *o.GetExpiration())	×
UNCOV 88	}	×
89	// add to aof
90	db.addAof(aof.EntityToCmd(o.GetKey(), entity).Args)	1✔
91	}
92	return true	1✔
93	})
94	}
95
96	func NewPersister(db database.DBEngine, filename string, load bool, fsync string) (*aof.Persister, error) {	1✔
97	return aof.NewPersister(db, filename, load, fsync, func() database.DBEngine {	2✔
98	return MakeAuxiliaryServer()	1✔
99	})	1✔
100	}
101
102	func (server *Server) AddAof(dbIndex int, cmdLine CmdLine) {	1✔
103	if server.persister != nil {	2✔
104	server.persister.SaveCmdLine(dbIndex, cmdLine)	1✔
105	}	1✔
106	}
107
108	func (server Server) bindPersister(persister aof.Persister) {	1✔
109	server.persister = persister	1✔
110	// bind SaveCmdLine	1✔
111	for _, db := range server.dbSet {	2✔
112	singleDB := db.Load().(*DB)	1✔
113	singleDB.addAof = func(line CmdLine) {	2✔
114	if config.Properties.AppendOnly { // config may be changed during runtime	2✔
115	server.persister.SaveCmdLine(singleDB.index, line)	1✔
116	}	1✔
117	}
118	}
119	}
120
121	// MakeAuxiliaryServer create a Server only with basic capabilities for aof rewrite and other usages
122	func MakeAuxiliaryServer() *Server {	1✔
123	mdb := &Server{}	1✔
124	mdb.dbSet = make([]*atomic.Value, config.Properties.Databases)	1✔
125	for i := range mdb.dbSet {	2✔
126	holder := &atomic.Value{}	1✔
127	holder.Store(makeBasicDB())	1✔
128	mdb.dbSet[i] = holder	1✔
129	}	1✔
130	return mdb	1✔
131	}

HDT3213 / godis / 15238419529

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous