Peer启动流程及源码分析

字数统计: 3.5k字   |   阅读时长: 16分
阅读量

本文源码解析主要在peer文件夹，如有特殊文件夹会特别标出

main函数在main.go文件中

一、初始化

1、定义主命令

基于Gobra组件构造主命令

1
2
var mainCmd = &cobra.Command{
	Use: "peer"}
2、注册子命令
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
func main() {
    ...
    // 设置环境变量前缀core
    viper.SetEnvPrefix(common.CmdRoot)
	viper.AutomaticEnv()
	replacer := strings.NewReplacer(".", "_") // 创建替换符
	viper.SetEnvKeyReplacer(replacer) // 设置环境变量替换符

   // 定义命令行选项集合，对所以peer及子命令都有效
	mainFlags := mainCmd.PersistentFlags()
    // 设置version与logging-level选项
	mainFlags.String("logging-level", "", "Legacy logging level flag")
	viper.BindPFlag("logging_level", mainFlags.Lookup("logging-level"))
	mainFlags.MarkHidden("logging-level")
    // 注册子命令
    mainCmd.AddCommand(version.Cmd())
    mainCmd.AddCommand(node.Cmd())
    mainCmd.AddCommand(chaincode.Cmd(nil))
    mainCmd.AddCommand(clilogging.Cmd(nil))
    mainCmd.AddCommand(channel.Cmd(nil))
	...
}

channel通道子命令：创建应用通道、获取区块、Peer节点加入应用通道、获取节点所加入的应用通道列表、更新应用通道配置、签名配置交易文件、获取指定的应用通道信息等，包括create、fetch、join、list、update、signconfigtx、getinfo等子命令

1
2
3
4
5
6
7
channelCmd.AddCommand(createCmd(cf))
channelCmd.AddCommand(fetchCmd(cf))
channelCmd.AddCommand(joinCmd(cf))
channelCmd.AddCommand(listCmd(cf))
channelCmd.AddCommand(updateCmd(cf))
channelCmd.AddCommand(signconfigtxCmd(cf))
channelCmd.AddCommand(getinfoCmd(cf))

chaincode链码子命令:用于安装链码、实例化（部署）链码、调用链码、打包链码、查询链码、签名链码包、升级链码、获取通道链码列表等，包括install、instantiate、invoke、package、query、signpackage、upgrade、list等子命令

node节点子命令：用于管理节点服务进程与查询服务状态，包括start、status等子命令

logging日志子命令: 用于获取、设置与恢复日志级别功能，包括getlevel、setlevel、revertlevels等子命令；

version版本子命令：打印Hyperledger Fabric中的Peer节点服务器版本信息

二、初始化本地MSP组件

在每个子命令中，执行初始化本地MSP组件。

1
2
3
4
5
6
7
8
9
var chaincodeCmd = &cobra.Command{
	Use:   chainFuncName,
	Short: fmt.Sprint(chainCmdDes),
	Long:  fmt.Sprint(chainCmdDes),
	PersistentPreRun: func(cmd *cobra.Command, args []string) {
		common.InitCmd(cmd, args)  // 初始化MSP
		common.SetOrdererEnv(cmd, args)
	},
}

MSP组件是管理本地成员身份的重要安全模块，封装了根CA证书、本地签名者实体等。main()函数首先基于Viper组件获取core.yaml文件中MSP组件的配置文件路径mspMgrConfigDir（peer.mspConfigPath配置项）、MSP名称mspID（peer.localMspId配置项）与MSP组件类型mspType（peer.localMspType配置项，默认为FABRIC类型），提供给common.InitCrypto()函数作为参数进行调用，以获取BCCSP区块链加密服务组件，并用于初始化本地MSP组件

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
// 初始化MSP
func InitCmd(cmd *cobra.Command, args []string) {
    ...
    err := InitConfig(CmdRoot) // 加载core.yaml配置文件
    ...
    // 初始化本地MSP组件对象
	var mspMgrConfigDir = config.GetPath("peer.mspConfigPath")
	// 获取本地MSP名称
    var mspID = viper.GetString("peer.localMspId")
	// 获取本地MSP组件类型
    var mspType = viper.GetString("peer.localMspType")
	if mspType == "" {
        // 默认为FABRIC类型
		mspType = msp.ProviderTypeToString(msp.FABRIC)
	}
    // 获取BCCSCP组件配置信息，初始化MSP组件对象
	err = InitCrypto(mspMgrConfigDir, mspID, mspType)
	...  
}

配置文件如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
func InitCrypto(mspMgrConfigDir, localMSPID, localMSPType string) error {
	var err error
	// Check whether msp folder exists
	fi, err := os.Stat(mspMgrConfigDir)
	...
	// 设置BCCSCP密钥存储文件的绝对路径
	SetBCCSPKeystorePath()
	var bccspConfig *factory.FactoryOpts
    // 解析配置文件BCCSCP配置信息保存到变量
	err = viperutil.EnhancedExactUnmarshalKey("peer.BCCSP", &bccspConfig) 
	...
    // 初始化本地MSP组件对象
	err = mspmgmt.LoadLocalMspWithType(mspMgrConfigDir, bccspConfig, localMSPID, localMSPType)
    ...
	return nil
}

三、执行启动Peer节点命令

1
2
3
4
5
6
7
func main() {
	...
	if mainCmd.Execute() != nil {
		os.Exit(1)
	}
    ...
}

main()主函数通过Cobra组件调用主命令Execute()方法，执行peer node start命令启动Peer节点

在byfn中调用peer-base.yaml，启动peer node start

peer node start 主要流程：主要在start子命令执行server()函数。（函数实现在peer/node/start.go文件）

1、初始化服务启动的基本参数
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
func serve(args []string) error {
	// (1) 获取本地MSP组件类型，默认基于BCCSCP组件构建的FABRIC类型MSP组件
	mspType := mgmt.GetLocalMSP().GetType()
	if mspType != msp.FABRIC {
		panic("Unsupported msp type " + msp.ProviderTypeToString(mspType))
	}
	
	grpc.EnableTracing = true
	logger.Infof("Starting %s", version.GetInfo())

    // (2) 注册资源访问提供者aclProvider.设置peer以及通道的节点资源的访问权限，例如Lscc_Install不能由peer执行。具体的peer资源对应map为d.pResourcePolicyMap，通道的访问权限对应的map为cResourcePolicyMap
	aclProvider := aclmgmt.NewACLProvider(
		aclmgmt.ResourceGetter(peer.GetStableChannelConfig),
	)

    ...
	// （3）初始化本地账本管理器。详情见下：
	ledgermgmt.Initialize(
		&ledgermgmt.Initializer{
			CustomTxProcessors:            peer.ConfigTxProcessors,
			PlatformRegistry:              pr,
			DeployedChaincodeInfoProvider: deployedCCInfoProvider,
			MembershipInfoProvider:        membershipInfoProvider,
			MetricsProvider:               metricsProvider,
		},
	)

    // (4)初始化服务器基本参数
	if chaincodeDevMode {
		logger.Info("Running in chaincode development mode")
		logger.Info("Disable loading validity system chaincode")
		// 设置链码模式为"dev"
		viper.Set("chaincode.mode", chaincode.DevModeUserRunsChaincode)
	}
    // 读取配置并缓存peer节点地址与端点
	if err := peer.CacheConfiguration(); err != nil {
		return err
	}
	// 获取缓存的peer端点
	peerEndpoint, err := peer.GetPeerEndpoint()
	if err != nil {
		err = fmt.Errorf("Failed to get Peer Endpoint: %s", err)
		return err
	}
    // 获取peer节点的ip地址，为启动节点上的服务器做准备
	peerHost, _, err := net.SplitHostPort(peerEndpoint.Address)
	if err != nil {
		return fmt.Errorf("peer address is not in the format of host:port: %v", err)
	}

(1) 获取本地MSP组件类型

代码已经注释

(2) 注册资源访问策略提供者

代码已经注释

(3) 初始化本地账本管理器

peer.ConfigTxProcessors定义通道上配置交易信息处理器字典，且configtxProcessor提供GenerateSimulationResults()方法，用于生成配置交易消息对应的通道配置与资源配置信息，作为模拟执行结果保存到交易模拟器中，再生成模拟执行结果的公共数据，封装成交易对象（Transaction类型）提交给Committer记账节点进行验证

func initialize真正函数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
func initialize(initializer *Initializer) {
	logger.Info("Initializing ledger mgmt")
	lock.Lock()
	defer lock.Unlock()
	initialized = true //设置peer节点初始化标志位为true
	openedLedgers = make(map[string]ledger.PeerLedger)
    // 初始化配置交易消息处理器
	customtx.Initialize(initializer.CustomTxProcessors)
    // 初始化链码事件管理器 用于监听处理链码生命周期事件
	cceventmgmt.Initialize(&chaincodeInfoProviderImpl{
		initializer.PlatformRegistry,
		initializer.DeployedChaincodeInfoProvider,
	})
    ...
    // 创建本地peer节点账本提供者 详情见下
	provider, err := kvledger.NewProvider()
    ...
    // 初始化状态监听器
	provider.Initialize(&ledger.Initializer{
        // 初始化Peer节点账本提供者的状态监听器
		StateListeners:                finalStateListeners,
		DeployedChaincodeInfoProvider: initializer.DeployedChaincodeInfoProvider,
		MembershipInfoProvider:        initializer.MembershipInfoProvider,
		MetricsProvider:               initializer.MetricsProvider,
	})
	ledgerProvider = provider
	logger.Info("ledger mgmt initialized")
}

创建本地peer账本提供者：kvledger.NewProvider()

1、账本ID数据库（idStore类型）：提供存储账本ID（即链ID）与创世区块键值对的LevelDB数据库；

2、账本数据存储对象提供者（ledgerstorage.Provider类型）：创建账本数据存储对象，负责管理区块数据文件、隐私数据库、区块索引数据库等；

3、历史数据库提供者（HistoryDBProvider类型）：创建历史数据库，存储每个状态数据的历史信息；

4、状态数据库提供者（CommonStorageDBProvider类型）：创建状态数据库（LevelDB或CouchDB类型），存储世界状态（world state），包括有效交易的公有数据与隐私数据

(4) 初始化服务器基本参数

代码已注释

2、创建gRPC服务器

​ peer节点所有的服务器：

(1) 创建gRPC服务器

1
2
3
4
5
6
7
8
9
10
11
12
13
14
func server() {
	...
    // 获取peer节点的grpc服务器监听地址
	listenAddr := viper.GetString("peer.listenAddress")
	serverConfig, err := peer.GetServerConfig() // 构造grpc服务器的安全配置项
    // 构造gRPC服务器的安全配置项serverConfig。该对象封装了TLS认证所需要的服务器认证证书与密钥、客户端的根CA证书列表、服务器端的根CA证书列表、服务器心跳消息keepalive选项
    ...
    // 创建grpc服务器(7051)
	peerServer, err := peer.NewPeerServer(listenAddr, serverConfig)
	if err != nil {
		logger.Fatalf("Failed to create peer server (%s)", err)
	}
	...
}

(2) 创建DeliverEnvents事件服务器

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
func server() {
	...
    // 若启用TLS安全认证，则配置服务端的根CA证书与客户端证书
	if serverConfig.SecOpts.UseTLS {
		logger.Info("Starting peer with TLS enabled")
		// set up credential support
		cs := comm.GetCredentialSupport()
        // 设置服务器CA证书
		cs.ServerRootCAs = serverConfig.SecOpts.ServerRootCAs
		// 获取gRPC客户端证书用于TLS连接认证
		clientCert, err := peer.GetClientCertificate()
		if err != nil {
			logger.Fatalf("Failed to set TLS client certificate (%s)", err)
		}
		comm.GetCredentialSupport().SetClientCertificate(clientCert)
	}

	mutualTLS := serverConfig.SecOpts.UseTLS && serverConfig.SecOpts.RequireClientCert
	policyCheckerProvider := func(resourceName string) deliver.PolicyCheckerFunc {
		return func(env *cb.Envelope, channelID string) error {
			return aclProvider.CheckACL(resourceName, channelID, env)
		}
	}

	abServer := peer.NewDeliverEventsServer(mutualTLS, policyCheckerProvider, &peer.DeliverChainManager{}, metricsProvider)
	pb.RegisterDeliverServer(peerServer.Server(), abServer)
    ...
}

(3) 创建ChaincodeSupport链码支持服务器

Peer节点上的全局链码支持服务实例或链码支持服务器

1
2
3
4
5
func server() {
	...
	chaincodeSupport, ccp, sccp, packageProvider := startChaincodeServer(peerHost, aclProvider, pr, opsSystem)
	...
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
// startChaincodeServer will finish chaincode related initialization, including:
// 1) setup local chaincode install path
// 2) create chaincode specific tls CA
// 3) start the chaincode specific gRPC listening service
func startChaincodeServer(
	peerHost string,
	aclProvider aclmgmt.ACLProvider,
	pr *platforms.Registry,
	ops *operations.System,
) (*chaincode.ChaincodeSupport, ccprovider.ChaincodeProvider, *scc.Provider, *persistence.PackageProvider) {
	// Setup chaincode path
	chaincodeInstallPath := ccprovider.GetChaincodeInstallPathFromViper()
	ccprovider.SetChaincodesPath(chaincodeInstallPath)

	ccPackageParser := &persistence.ChaincodePackageParser{}
	ccStore := &persistence.Store{
		Path:       chaincodeInstallPath,
		ReadWriter: &persistence.FilesystemIO{},
	}

	packageProvider := &persistence.PackageProvider{
		LegacyPP: &ccprovider.CCInfoFSImpl{},
		Store:    ccStore,
	}

	lifecycleSCC := &lifecycle.SCC{
		Protobuf: &lifecycle.ProtobufImpl{},
		Functions: &lifecycle.Lifecycle{
			PackageParser:  ccPackageParser,
			ChaincodeStore: ccStore,
		},
	}

	// Create a self-signed CA for chaincode service
	ca, err := tlsgen.NewCA()
	if err != nil {
		logger.Panic("Failed creating authentication layer:", err)
	}
	ccSrv, ccEndpoint, err := createChaincodeServer(ca, peerHost)
	if err != nil {
		logger.Panicf("Failed to create chaincode server: %s", err)
	}
	chaincodeSupport, ccp, sccp := registerChaincodeSupport(
		ccSrv,
		ccEndpoint,
		ca,
		packageProvider,
		aclProvider,
		pr,
		lifecycleSCC,
		ops,
	)
	go ccSrv.Start() // 启动服务
	return chaincodeSupport, ccp, sccp, packageProvider
}

在peer注册所以系统链码

(4) 创建Admin管理服务器与Endorser背书服务器

Admin管理服务器提供节点启动、节点状态查询等服务。Endorser背书服务器提供对交易提案的模拟执行结果执行签名背书的服务

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
func server() {
	...
	startAdminServer(listenAddr, peerServer.Server(), metricsProvider)
	// 定义Gossip协议分发隐私数据函数
	privDataDist := func(channel string, txID string, privateData *transientstore.TxPvtReadWriteSetWithConfigInfo, blkHt uint64) error {
		return service.GetGossipService().DistributePrivateData(channel, txID, privateData, blkHt)
	}
	...
    // 读core.yaml的peer.handlers
    ...
    // 创建背书服务器
	serverEndorser := endorser.NewEndorserServer(privDataDist, endorserSupport, pr)
    // 将所有的消息过滤器构成过滤器链，返回第一个过滤器，serverEndorser是在链尾
    auth := authHandler.ChainFilters(serverEndorser, authFilters...)
	...
}

(5) 创建Gossip消息服务器

Peer节点的Gossip消息服务器是基于Gossip消息协议分发数据与同步状态的，负责将区块数据与隐私数据发送到组织内的其他Peer节点。同时，Gossip消息服务器提供了节点管理机制、反熵算法等，支持同步更新节点信息与缺失的数据信息（区块数据与隐私数据）

1
2
3
4
5
6
7
8
9
10
11
12
13
func server() {
	...
	policyMgr := peer.NewChannelPolicyManagerGetter()

	// Initialize gossip component
	err = initGossipService(policyMgr, peerServer, serializedIdentity, peerEndpoint.Address)
	if err != nil {
		return err
	}
	// 在退出时延迟调用该函数以停止Gossip消息服务器
	defer service.GetGossipService().Stop()
	...
}
3、部署系统链码与初始化现存通道的链结构

(1) 部署系统链码initSysCCs()函数

1
2
3
4
5
6
func server() {
	// 部署系统链码（CSCC\LSCC\QSCC\VSCC\ESCC）
	sccp.DeploySysCCs("", ccp)
	logger.Infof("Deployed system chaincodes")
	...
}

部署系统链码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
func deploySysCC(chainID string, ccprov ccprovider.ChaincodeProvider, syscc SelfDescribingSysCC) error {
    // 检查链码标志位是否开启，以及是否在白名单中
	if !syscc.Enabled() || !isWhitelisted(syscc) {
		...
	}

	txid := util.GenerateUUID()

	// Note, this structure is barely initialized,
	// we omit the history query executor, the proposal
	// and the signed proposal
	txParams := &ccprovider.TransactionParams{
		TxID:      txid,
		ChannelID: chainID,
	}

	if chainID != "" {
		lgr := peer.GetLedger(chainID) // 获取指定账本对象
		...
		txsim, err := lgr.NewTxSimulator(txid)
		if err != nil {
			return err
		}

		txParams.TXSimulator = txsim
		defer txsim.Done() // 释放交易模拟器占用的资源
	}

	chaincodeID := &pb.ChaincodeID{Path: syscc.Path(), Name: syscc.Name()}
	spec := &pb.ChaincodeSpec{Type: pb.ChaincodeSpec_Type(pb.ChaincodeSpec_Type_value["GOLANG"]), ChaincodeId: chaincodeID, Input: &pb.ChaincodeInput{Args: syscc.InitArgs()}}

	chaincodeDeploymentSpec := &pb.ChaincodeDeploymentSpec{ExecEnv: pb.ChaincodeDeploymentSpec_SYSTEM, ChaincodeSpec: spec}

	// XXX This is an ugly hack, version should be tied to the chaincode instance, not he peer binary
	version := util.GetSysCCVersion()

	cccid := &ccprovider.CCContext{
		Name:    chaincodeDeploymentSpec.ChaincodeSpec.ChaincodeId.Name,
		Version: version,
	}
	// 部署系统链码
	resp, _, err := ccprov.ExecuteLegacyInit(txParams, cccid, chaincodeDeploymentSpec)
	if err == nil && resp.Status != shim.OK {
		err = errors.New(resp.Message)
	}

	sysccLogger.Infof("system chaincode %s/%s(%s) deployed", syscc.Name(), chainID, syscc.Path())

	return err
}

(2) 初始化现存通道上的链结构Initialize()函数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
func server() {
	...
	// this brings up all the channels
	peer.Initialize(func(cid string) {
		logger.Debugf("Deploying system CC, for channel <%s>", cid)
		sccp.DeploySysCCs(cid, ccp)
		sub, err := lifecycle.NewChannelSubscription(cid, cc.QueryCreatorFunc(func() (cc.Query, error) {
			return peer.GetLedger(cid).NewQueryExecutor()
		}))
		if err != nil {
			logger.Panicf("Failed subscribing to chaincode lifecycle updates")
		}
		cceventmgmt.GetMgr().Register(cid, sub)
	}, ccp, sccp, txvalidator.MapBasedPluginMapper(validationPluginsByName),
		pr, deployedCCInfoProvider, membershipInfoProvider, metricsProvider)
		...
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
func Initialize(init func(string), ccp ccprovider.ChaincodeProvider, sccp sysccprovider.SystemChaincodeProvider,
	pm txvalidator.PluginMapper, pr *platforms.Registry, deployedCCInfoProvider ledger.DeployedChaincodeInfoProvider,
	membershipProvider ledger.MembershipInfoProvider, metricsProvider metrics.Provider) {
	nWorkers := viper.GetInt("peer.validatorPoolSize")
	if nWorkers <= 0 {
		nWorkers = runtime.NumCPU()
	}
	// 获取交易验证线程数量
	validationWorkersSemaphore = semaphore.NewWeighted(int64(nWorkers))

	pluginMapper = pm
	chainInitializer = init

	var cb *common.Block
	var ledger ledger.PeerLedger
	// 初始化账本服务器
	ledgermgmt.Initialize(&ledgermgmt.Initializer{
		CustomTxProcessors:            ConfigTxProcessors,
		PlatformRegistry:              pr,
		DeployedChaincodeInfoProvider: deployedCCInfoProvider,
		MembershipInfoProvider:        membershipProvider,
		MetricsProvider:               metricsProvider,
	})
	// 获取当前账本管理器下的账本ID列表
	ledgerIds, err := ledgermgmt.GetLedgerIDs()
	if err != nil {
		panic(fmt.Errorf("Error in initializing ledgermgmt: %s", err))
	}
	for _, cid := range ledgerIds {
	    // 遍历当前账本ID列表
		peerLogger.Infof("Loading chain %s", cid)
		// 创建本地PEER节点账本
		if ledger, err = ledgermgmt.OpenLedger(cid); err != nil {
			...
			continue
		}
        // 从账本获取配置块
		if cb, err = getCurrConfigBlockFromLedger(ledger); err != nil {
			...
			continue
		}
		// Create a chain if we get a valid ledger with config block
		if err = createChain(cid, ledger, cb, ccp, sccp, pm); err != nil {			...
			continue
		}
		// 用自定义函数初始化通道链结构，如部署系统链码
		InitChain(cid)
	}
}
4、启动gRPC服务器与profile服务器

此时再执行4个goroutine，监听信号程序、grpc服务器、profile服务器等

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
func server() {
	...
	if viper.GetBool("peer.discovery.enabled") {
		registerDiscoveryService(peerServer, policyMgr, lifecycle)
	}

	networkID := viper.GetString("peer.networkId")
	// 获取profile监听地址
	profileEnabled := viper.GetBool("peer.profile.enabled")
	profileListenAddress := viper.GetString("peer.profile.listenAddress")

	// Start the grpc server. Done in a goroutine so we can deploy the
	// genesis block if needed.
	serve := make(chan error)

	go func() {
		var grpcErr error
        // 启动grpc服务器
		if grpcErr = peerServer.Start(); grpcErr != nil {
			grpcErr = fmt.Errorf("grpc server exited with error: %s", grpcErr)
		} else {
			logger.Info("peer server exited")
		}
		serve <- grpcErr
	}()

	// Start profiling http endpoint if enabled
	if profileEnabled {
		go func() {
			logger.Infof("Starting profiling server with listenAddress = %s", profileListenAddress)
			if profileErr := http.ListenAndServe(profileListenAddress, nil); profileErr != nil {
				logger.Errorf("Error starting profiler: %s", profileErr)
			}
		}()
	}
	...
}
赏

感谢您的认可

支付宝

扫一扫，分享到微信

微信分享二维码

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true