启动项目的电脑环境

启动项目电脑系统：windows10 / 64位 go版本：go version go1.17.7 windows/386

执行的操作

在clone项目之后，进入到目录cmd命令行，执行以下命令

go mod tidy

安装依赖之后在目录下执行：

go run main.go

报以下错误：

# github.com/hdt3213/rdb/core
D:\Code\golang\go\pkg\mod\github.com\hdt3213\[email protected]\core\list.go:283:21: constant 4294967295 overflows int

这个问题只在 Windows10 操作系统出现，我另外一台 Ubuntu 20.04 操作系统的电脑项目正常运行。 那请问如何在 Windows10 操作系统电脑上运行项目代码呢？

在阅读主从同步相关代码的时候，saleof命令执行后，会异步与master进行连接建立，并且会对master发送 REPLCONF listening-port命令，但是我好像并没有在代码中找到这个REPLCONF的实现。是目前不支持嘛？

我又用redis-cli直接执行了 REPLCONF 得到： (error) ERR unknown command 'replconf'

想知道为啥会这样呢？

aof重写步骤为：

1. 开始rewrite，对应startRewrite方法

   1. 获取写锁，暂停aof写入

   2. 获取aof文件大小

   3. 创建rewriteBuffer channel（带缓冲channel）

   4. 生成临时文件

   5. 释放写锁，恢复aof写入

2. 读取aof文件内容，加载内容到临时DB对象

3. 根据临时DB对象的数据，生成命令写入临时文件

4. 结束rewrite

   1. 获取写锁，暂停aof写入

   2. 读取rewriteBuffer，写入aof临时文件

   3. 关闭rewriteBuffer，并设置为nil

   4. 重命名临时文件为aof文件

   5. open 新的aof文件，并设置为db.aofFile

   6. 释放写锁，恢复aof写入

而主程序，在第一步与第四步之间，一直可以写入aof chan，在处理aof chan中的数据时，同步写入一份到rewriteBuffer chan中，此时会存在一个问题： 程序写入aof时命令较多，超过了rewriteBuffer的缓冲大小，此时会出现 handleAof方法获取到了读锁，但是在写入rewriteBuffer时，阻塞住了，无法释放读锁

而 finishRewrite 方法，在结束rewrite时，需要先获取到写锁，才会接收 rewriteBuffer chan的数据，就会出现锁已被 handleAof占用，finishRewrite方法获取不到锁的情况，从而导致死锁

fix: random number & dead-loop problems & perf: slightly optimize the value`s type of map

• problem random: uses the provided seed value to initialize the function rand, for fixing the generation of the same int in the case of multiple executions.
• problem dead-loop: in the case of the whole dict has few data(ex. 2 items), the function "RandomKeys" or "RandomDistinctKeys" is executed. When "RandomKeys" or "RandomDistinctKeys" has not completed execution and all data is cleared, it will be stuck in an endless loop. I`m not sure whether my solution meets your expectation, it needs you to judge, if not I will close this PR. My solution is as follow: when the number of cycles is an integer multiple of "limit * 2", recheck whether "limit >= dict.Len()"

perf: slightly optimize the value`s type of map to save memory space at datastruct/dict/concurrent.go

Have a nice day~

Limited ability, make it better~

i read from here https://www.cnblogs.com/Finley/p/14028402.html i am confused that i think pipeline seems doesn't work that way.

1. pipeline mode should send many command in one time, it should be not only asynchronous but also batch operation
2. pipeline mode should be started by user explicitly not by default

refactor: replace "if else" by "switch" && compact code "if else"

• replace "if else" by "switch" in the file cluster/cluster.go
• compact code "if else" in the file redis/client/client.go

Limited ability, make it better~

// Exec executes command within one database
func (db *DB) Exec(c redis.Connection, cmdLine [][]byte) redis.Reply {
	// transaction control commands and other commands which cannot execute within transaction
	cmdName := strings.ToLower(string(cmdLine[0]))
	if cmdName == "multi" {
		if len(cmdLine) != 1 {
			return protocol.MakeArgNumErrReply(cmdName)
		}
		return StartMulti(c)
	} else if cmdName == "discard" {
		if len(cmdLine) != 1 {
			return protocol.MakeArgNumErrReply(cmdName)
		}
		return DiscardMulti(c)
	} else if cmdName == "exec" {
		if len(cmdLine) != 1 {
			return protocol.MakeArgNumErrReply(cmdName)
		}
		return execMulti(db, c)
	} else if cmdName == "watch" {
		if !validateArity(-2, cmdLine) {
			return protocol.MakeArgNumErrReply(cmdName)
		}
		return Watch(db, c, cmdLine[1:])
	}
	if c != nil && c.InMultiState() {
		EnqueueCmd(c, cmdLine)
		return protocol.MakeQueuedReply()
	}

	return db.execNormalCommand(cmdLine)
}

在开启事务后，后续的命令貌似不管语法出错还是正确都是返回的protocol.MakeQueuedReply()

// EnqueueCmd puts command line into `multi` pending queue
func EnqueueCmd(conn redis.Connection, cmdLine [][]byte) redis.Reply {
	cmdName := strings.ToLower(string(cmdLine[0]))
	cmd, ok := cmdTable[cmdName]
	if !ok {
		return protocol.MakeErrReply("ERR unknown command '" + cmdName + "'")
	}
	if cmd.prepare == nil {
		return protocol.MakeErrReply("ERR command '" + cmdName + "' cannot be used in MULTI")
	}
	if !validateArity(cmd.arity, cmdLine) {
		// difference with redis: we won't enqueue command line with wrong arity
		return protocol.MakeArgNumErrReply(cmdName)
	}
	conn.EnqueueCmd(cmdLine)
	return protocol.MakeQueuedReply()
}

区别在于如果命令不被识别或者参数个数不对的话是不会被加入的conn里的queue的 所以如果命令有语法错误的话，是不会终止整个事务的，只是后续在遇到exec命令的时候不会被执行？ 如果这个事务中的其他的命令在运行时没有错误的话，这个事务就变成可以正常提交，那感觉好像不太合理？

// ExecMulti executes multi commands transaction Atomically and Isolated
func (db *DB) ExecMulti(conn redis.Connection, watching map[string]uint32, cmdLines []CmdLine) redis.Reply {
	// prepare
	writeKeys := make([]string, 0) // may contains duplicate
	readKeys := make([]string, 0)
	for _, cmdLine := range cmdLines {
		cmdName := strings.ToLower(string(cmdLine[0]))
		cmd := cmdTable[cmdName]
		prepare := cmd.prepare
		write, read := prepare(cmdLine[1:])
		writeKeys = append(writeKeys, write...)
		readKeys = append(readKeys, read...)
	}
	// set watch
	watchingKeys := make([]string, 0, len(watching))
	for key := range watching {
		watchingKeys = append(watchingKeys, key)
	}
	readKeys = append(readKeys, watchingKeys...)
	db.RWLocks(writeKeys, readKeys)
	defer db.RWUnLocks(writeKeys, readKeys)

	if isWatchingChanged(db, watching) { // watching keys changed, abort
		return protocol.MakeEmptyMultiBulkReply()
	}
	// execute
	results := make([]redis.Reply, 0, len(cmdLines))
	aborted := false
	undoCmdLines := make([][]CmdLine, 0, len(cmdLines))
	for _, cmdLine := range cmdLines {
		undoCmdLines = append(undoCmdLines, db.GetUndoLogs(cmdLine))
		result := db.execWithLock(cmdLine)
		if protocol.IsErrorReply(result) {
			aborted = true
			// don't rollback failed commands
			undoCmdLines = undoCmdLines[:len(undoCmdLines)-1]
			break
		}
		results = append(results, result)
	}
	if !aborted { //success
		db.addVersion(writeKeys...)
		return protocol.MakeMultiRawReply(results)
	}
	// undo if aborted
	size := len(undoCmdLines)
	for i := size - 1; i >= 0; i-- {
		curCmdLines := undoCmdLines[i]
		if len(curCmdLines) == 0 {
			continue
		}
		for _, cmdLine := range curCmdLines {
			db.execWithLock(cmdLine)
		}
	}
	return protocol.MakeErrReply("EXECABORT Transaction discarded because of previous errors.")

你好，看到项目中 这个Echohandler Close 有点疑惑，他的本意应该是调用该函数时，关闭所有Conn 并给每个 Conn 一个优雅关闭的超时时间（10s），但在实现上，关闭每个Conn时都是阻塞住，这样子有两个疑问：

1. 优雅关闭的本意是每个连接给一个超时时间，但 同步去关闭每个Conn，后续关闭的Conn 超过10s了？
2. 在遍历sync.Map的时候，钩子函数都要阻塞10s(极端情况)，这样子 Sync.Map这段时间，其他协程访问它时，均被阻塞了？ https://github.com/HDT3213/godis/blob/1459f3de013ead725691a849688089ae4f34a3c9/tcp/echo.go#L82-L86

感谢~

// Write sends response to client over tcp connection
func (c *Connection) Write(b []byte) error {
	if len(b) == 0 {
		return nil
	}
	c.mu.Lock()
	c.waitingReply.Add(1)
	defer func() {
		c.waitingReply.Done()
		c.mu.Unlock()
	}()

	_, err := c.conn.Write(b)
	return err
}

perf: slightly optimize config/config.go

• Exclude the struct tag is space
• Exclude configuration file comment, which is starting with space

fix: in the case of panic unexpected happened in the method parse0 of parser/parser.go, closing of the channel is needed to prevent the program from getting stuck~

Limited ability, hope to make it better~

版本：发布版本1.2.8 redis.conf配置如下 ` bind 0.0.0.0 port 6399 maxclients 128

appendonly no appendfilename appendonly.aof dbfilename test.rdb ` 当前目录没有生成 appendonly.aof 和 test.rdb 文件

当我启动aof功能，并执行rewriteaof命令时，aof重写会因为rename失败而失败 原因如下： 我通过打断点发现rename处无法执行

同时，观察err发现，tmpAof文件直接写到了C盘的Temp目录下，而不是在项目路径下 我使用的是golang1.19，原本创建tmpFile的命令被遗弃了，新的命令直接是创建在C盘缓存下的

我修改了一下代码，让tmpFile文件直接放在项目路径下：

	tmpFile, err := os.Create("tmpAofFile.aof")
	if err != nil {
		logger.Warn("create temp file failed")
		return nil, err
	}

但是依旧还是会出现无法rename的问题：

[WARN][rewrite.go:169] 2022/11/24 17:14:07 [update aof file failed: rename tmpAofFile.aof appendonly.aof: The process cannot access th
e file because it is being used by another process.]