// 表明使用的sol版本 
pragma solidity 0.8.7;

// Solidity 合约类似于面向对象语言中的类。合约中有用于数据持久化的状态变量，和可以修改状态变量的函数。 调用另一个合约实例的函数时，会执行一个 EVM 函数调用，这个操作会切换执行时的上下文，这样，前一个合约的状态变量就不能访问了。
contract VendingMachine {

    // Declare state variables of the contract
    address public owner; // owner变量
    mapping (address => uint) public cupcakeBalances; // cupcakeBalances变量

    // 创建合约时，合约的构造函数会执行一次。构造函数是可选的。只允许有一个构造函数，这意味着不支持重载。
    // When 'VendingMachine' contract is deployed:
    // 1. set the deploying address as the owner of the contract
    // 2. set the deployed smart contract's cupcake balance to 100
    constructor() {
        owner = msg.sender; // 设置部署本合约的地址为合约所有者

        // address(this)是将this转型为地址吗？
        // this不是代表合约对象吗，还能转为address？
        cupcakeBalances[address(this)] = 100; // 设置蛋糕余量
    }

    // Allow the owner to increase the smart contract's cupcake balance
    function refill(uint amount) public { // public表示方法可导出
        require(msg.sender == owner, "Only the owner can refill."); // 如果前面的条件不成立，则报错，后面为内容；此处要求消息的发送者必须是本合约所有者
        cupcakeBalances[address(this)] += amount; // 补充蛋糕
    }

    // Allow anyone to purchase cupcakes
    function purchase(uint amount) public payable { // payable表示方法含有支付逻辑
        require(msg.value >= amount * 1 ether, "You must pay at least 1 ETH per cupcake"); // 此处要求每个蛋糕最少支付一个eth
        require(cupcakeBalances[address(this)] >= amount, "Not enough cupcakes in stock to complete this purchase"); // 此处要求蛋糕余量不小于需要的数量
        cupcakeBalances[address(this)] -= amount; // 本合约所有者减少蛋糕
        cupcakeBalances[msg.sender] += amount; // 消息发送者添加蛋糕
    }
}

// 所有代码都需要放到包里
package color

// 导入其它包
import (
	"context"
	"fmt"
	"strconv"
	"sync"
	"time"
)

// 枚举
type Color int

// 常量
const (
	Red   Color = 1 // 红
	Blue  Color = 2 // 蓝
	Green Color = 3 // 绿
)

// 函数
func NewCar(
	name string,
	rate int,
) *Car {
	return &Car{
		name: name,
		rate: rate,
	}
}

// 类型
type Car struct {
	// 类型字段
	name string // 首字母小写，非导出，只能包内使用
	rate int
}

// 类型方法
func (car *Car) String() string { // 首字母大写，导出，可供其它包使用
	return "[Car] name: " + car.name + ", rate: " + strconv.Itoa(car.rate) + "."
}

func (car *Car) Run(
	ctx context.Context, // 使用ctx实现超时控制
) {
	// 定时器，每隔rate秒执行一次
	ticker := time.NewTicker(time.Duration(car.rate) * time.Second)
	defer ticker.Stop() // defer语句，在方法退出前执行，做收尾工作

	// for range ticker.C { // 循环，遍历chan
	// 	fmt.Printf("%s\n", car)
	// }

	for {
		select {
		case <-ticker.C:
			{ // 代码块，让逻辑更聚合，更清晰
				timesMutex.Lock()
				count := 1
				if v, ok := times[car.name]; ok {
					count = v + 1
				}
				times[car.name] = count
				timesMutex.Unlock()
			}

			fmt.Printf("%s\n", car)

		case <-ctx.Done():
			return
		}
	}
}

// 接口
type Runner interface {
	Run(ctx context.Context)
}

// 变量
var (
	// 确保*Car实现了Runner接口
	_ Runner = (*Car)(nil)

	timesMutex = new(sync.RWMutex)       // 读写锁，唯一写，多个读，读时无写
	times      = make(map[string]int, 2) // 记录Car Run的次数；在声明时初始化，并配置容量
)

package color

import (
	"context"
	"fmt"
	"sync"
	"testing"
	"time"
)

func TestCar(t *testing.T) {
	// 超时控制
	ctx, cancel := context.WithTimeout(context.Background(), time.Second*10)
	defer cancel()

	// 并发执行
	wg := new(sync.WaitGroup)

	for _, car := range []Runner{ // 遍历切片
		NewCar("lanbo", 2),
		NewCar("boshi", 3),
	} {
		wg.Add(1) // 记录一个
		go func(car Runner) {
			defer wg.Done() // 完成一个

			t.Run(car.(*Car).name, func(t *testing.T) { // 对接口断言，获得具体类型
				car.Run(ctx)
			})
		}(car)
	}

	// 等上面均完成
	wg.Wait()

	timesMutex.RLock()
	fmt.Printf("times: %+v\n", times)
	timesMutex.RUnlock()
}

use crossbeam_channel::unbounded;

let (s, r) = unbounded();

s.send("Hello, world!").unwrap();

assert_eq!(r.recv(), Ok("Hello, world!"));

package cache

// 缓存，一般先将数据从磁盘读出来写到内存里，供用户高速访问，减少读磁盘 -- 快取
// 另有缓冲，将数据先写到内存里，待装满后一次性写入磁盘，可以少写很多次 -- 缓冲
//
// 不难看出，无论快取还是缓冲，都涉及到内存和磁盘的读写。
//
// 首先，对于缓存，目前使用较多的中间件是redis、memcached等，当然也有自己在程序中内置map充当缓存的。
// 那么，下面来看下如何在内存和磁盘之间同步数据：

type Cache interface {
	// exp表示当前时间后的exp秒后过期，传0则无过期
	Set(key, value string, exp int) error
	Del(key string) error
	Get(key string) (value string, err error)
}

type Store interface {
	Create(key, value string, exp int) error
	Delete(key string) error
	Update(key, value string, exp int) error
	Get(key string) (vlaue string, err error)
}

// 用户 有增删改查四个操作，在操作时，对应的缓存和磁盘如何变化呢？
type Client struct {
	cache Cache
	store Store
}

func NewClient(
	cache Cache,
	store Store,
) *Client {
	return &Client{
		cache: cache,
		store: store,
	}
}

const (
	defExp = 300
)

// Add 先写磁盘还是缓存呢？
func (client *Client) Add(key, value string) {
	// 会不会已经在Store里存在了呢？
	// 先从Store Get一次？
	// 一般来说，key都是唯一的：
	// 此时，必须请求一次Store，确认数据不存在；如果此时数据存在，直接返回错误
	if v, err := client.store.Get(key); err == nil && v != "" {
		return
	}

	// 缓存里会不会也有呢？
	// 先从Cache里读一次？
	// 如果能通过业务检查，正常来说，缓存里是没有的；

	// 写磁盘
	client.store.Create(key, value, defExp)

	// 1. 写缓存
	// client.cache.Set(key, value, defExp)
	// 2. 不写，等获取时从磁盘取
}

func (client *Client) Mod(key, value string) {
	// 更新磁盘
	client.store.Update(key, value, defExp)

	// 1. 更新缓存
	// client.cache.Set(key, value, defExp)
	// 2. 不更新，删掉缓存，等获取时从磁盘取 -- Cache Aside Pattern(旁路缓存方案): 一个 lazy 计算的思想，不要每次都重新做复杂的计算，而是让它到需要被使用的时候再重新计算
	client.cache.Del(key)
}

func (client *Client) Del(key string) {
	// 从磁盘删除
	client.store.Delete(key)

	// 1. 从缓存删除
	client.cache.Del(key)
}

func (client *Client) Get(key string) (string, error) {
	// 从Cache获取
	v, err := client.cache.Get(key)
	if err != nil {
		return "", err
	}
	if v == "" {
		// 以SingleFlight方式从Store读:
		// https://pkg.go.dev/golang.org/x/sync/singleflight
		// 这个库的主要作用就是将一组相同的请求合并成一个请求，实际上只会去请求一次，然后对所有的请求返回相同的结果。
		// 在一个请求的时间周期内实际上只会向底层的数据库发起一次请求大大减少对数据库的压力。
		{
			valueFromStore, err := client.store.Get(key)
			if err != nil {
				return "", err
			}
			v = valueFromStore
		}

		// 设置Cache
		client.cache.Set(key, v, defExp)
	}

	return v, nil
}

// For description of different message types, see:
// https://pkg.go.dev/go.etcd.io/etcd/raft/v3#hdr-MessageType
type MessageType int32

const (
    // 选举时使用；
    // 如果节点是一个follower或candidate，它在选举超时前没有收到任何心跳，它就回传递MsgHup消息给它自己的Step方法，然后成为（或保持）一个candidate从而开启一个新的选举
	MsgHup            MessageType = 0
    // 一个内部类型，它向leader发送一个类型为“MsgHeartbeat”的心跳信号
    // 如果节点是一个leader，raft里的tick函数将会是“tickHeartbeat”，触发leader周期性地发送“MsgHeartbeat”消息给它的followers
	MsgBeat           MessageType = 1
    // 提议往它的日志条目里追加数据；
    // 这是一个特别的类型，由follower反推提议给leader（正常是leader提议，follower执行）；
    // 发给leader的话，leader调用“appendEntry”方法追加条目到它的日志里，然后调用“bcastAppend”方法发送这些条目给它的远端节点；
    // 发给candidate的话，它们直接丢弃该消息
    // 发给follower的话，follower会将消息存储到它们的信箱里。会把发送者的id一起存储，然后转发给leader。
	MsgProp           MessageType = 2
    // 包含了要复制的日志条目
    // leader调用“bcastAppend”（里面调用“sendAppend”），发送“一会要被复制的日志”消息；
    // 当candidate收到消息后，在它的Step方法里，它马上回退为follower，因为这条消息表明已经存在一个有效leader了。
    // candidate和follower均会返回一条“MsgAppResp”类型消息以作响应。
	MsgApp            MessageType = 3
    // 调用“handlerAppendEntries”方法
	MsgAppResp        MessageType = 4
    // 请求集群中的节点给自己投票；
    // 当节点是follower或candidate，并且它们的Step方法收到了“MsgHup”消息，节点调用“campaign”方法去提议自己成为一个leader。一旦“campaign”方法被调用，节点成为candidate，并发送“MsgVote”给集群中的远端节点请求投票。
    // 当leader或candidate的Step方法收到该消息，并且消息的Term比它们的Term小，“MsgVote”将被拒绝。
    // 当leader或candidate收到的消息的Term要更大时，它会回退为follower。
    // 当follower收到该消息，仅当发送者的最后的term比“MsgVote”的term要大，或发送者的最后term等于“MsgVote”的term（但发送者的最后提交index大于等于follower的），
	MsgVote           MessageType = 5
    // 投票响应；
    // 当candidate收到后，它会统计选票，如果大于majority（quorum），它成为leader并调用“bcastAppend”。如果candidate收到大量的否决票，它将回退到follower
	MsgVoteResp       MessageType = 6
    // 请求安装一个快照消息；
    // 当一个节点刚成为leader，或者leader收到了“MsgProp”消息，它调用“bcastAppend”方法（里面再调用“sendAppend”）方法到每个follower。在“sendAppend”方法里，如果一个leader获取term或条目失败了，leader通过"MsgSnap"消息请求快照。
	MsgSnap           MessageType = 7
    // leader发送心跳；
    // 当candidate收到“MsgHeartbeat”，并且消息的term比candidate的大，candidate回退到follower并且更新它的提交index为这次心跳里的值。然后candidate发送消息到它的信箱。
    // 当消息发送到follower的Step方法，并且消息的term比follower的大，follower更新它的leader id
	MsgHeartbeat      MessageType = 8
    // 心跳响应；
    // leader收到后就知道有哪些follower响应了。
    // 只有当leader的最后提交index比follower的Match index大时，leader执行“sendAppend”方法
	MsgHeartbeatResp  MessageType = 9
    // 表明请求没有被交付；
    // 当“MsgUnreachable”被传送到leader的Step方法，leader发现follower无法到达，很有可能“MsgApp”都丢失了。当follower的进度状态为复制时，leader设置它回probe（哨兵）
	MsgUnreachable    MessageType = 10
    // 表明快照安装消息的结果
    // 当一个follower拒绝了“MsgSnap”，这显示快照请求失败了--因为网络原因；**leader认为follower成为哨兵了**?(Then leader considers follower's progress as probe.)；
    // 当“MsgSnap”没有被拒绝，它表明快照成功了，leader设置follower的进度为哨兵，并恢复它的日志复制
	MsgSnapStatus     MessageType = 11
	MsgCheckQuorum    MessageType = 12
	MsgTransferLeader MessageType = 13
	MsgTimeoutNow     MessageType = 14
	MsgReadIndex      MessageType = 15
	MsgReadIndexResp  MessageType = 16
    // "MsgPreVote"和“MsgPreVoteResp”用在可选的两阶段选举协议上；
    // 当Config.PreVote为true，将会进行一次预选举，除非预选举表明竞争节点会赢，否则没有节点会增加它们的term值。
    // 这最小化了**一个发生了分区的节点重新加入到集群时**会带来的中断/干扰
	MsgPreVote        MessageType = 17
	MsgPreVoteResp    MessageType = 18
)

type Node interface {
    // ...
}

func StartNode(...) Node {
    rn, err := NewRawNode(...)
	if err != nil {
		panic(err)
	}

    n := newNode(rn)
    go n.run()
    return &n
}

func NewRawNode(config *Config) (*RawNode, error) {
    r := newRaft(config)
    rn := &RawNode{
        raft: r,
    }

    ...

    return rn, nil
}

type node struct { // impl Node interface
    ...

    rn *RawNode
}

func newNode(rn *RawNode) node {
    return node{
        ...
    }
}

{
    // ...
   "gopls": {
        "experimentalWorkspaceModule": true
    },
    // ...
}